}
                    fir.getter?.let { getter ->
                        methods.singleOrNull { it.returnType != PsiTypes.voidType() }?.let {
                            bindings.put(METHOD_FOR_FIR_FUNCTION, getter, Method(it.name, getAsmMethodSignatureWithCorrection(it)))
                        }
                    }

}

func (t *ArrayType) Size() int64 {
	if t.Count == -1 {
		return 0
	}
	return t.Count * t.Type.Size()
}

// A VoidType represents the C void type.
type VoidType struct {
	CommonType
}

func (t *VoidType) String() string { return "void" }

// A PtrType represents a pointer type.
type PtrType struct {
	CommonType
	Type Type
}

        return typeMetaData;
    }

    private void extractElementTypeName(Type elementType, TypeMetaData typeMetaData) {
        elementType.ifVoidType(voidType -> typeMetaData.setName("void"));
        elementType.ifPrimitiveType(primitiveType -> typeMetaData.setName(primitiveType.asString()));
        elementType.ifWildcardType(wildcardType -> {

		if t.Size != c.ptrSize && t.Size != -1 {
			fatalf("%s: unexpected: %d-byte pointer type - %s", lineno(pos), t.Size, dtype)
		}
		t.Size = c.ptrSize
		t.Align = c.ptrSize

		if _, ok := base(dt.Type).(*dwarf.VoidType); ok {
			t.Go = c.goVoidPtr
			t.C.Set("void*")
			dq := dt.Type
			for {
				if d, ok := dq.(*dwarf.QualType); ok {
					t.C.Set(d.Qual + " " + t.C.String())
					dq = d.Type
				} else {

		{"(*UnsupportedType).Common", Method, 13},
		{"(*UnsupportedType).Size", Method, 13},
		{"(*UnsupportedType).String", Method, 13},
		{"(*VoidType).Common", Method, 0},
		{"(*VoidType).Size", Method, 0},
		{"(*VoidType).String", Method, 0},
		{"(Attr).GoString", Method, 0},
		{"(Attr).String", Method, 0},
		{"(Class).GoString", Method, 5},
		{"(Class).String", Method, 5},

    private static final String STATE_SET_METHOD_DESCRIPTOR = Type.getMethodDescriptor(Type.VOID_TYPE, STRING_TYPE, OBJECT_TYPE);
    private static final String STATE_GET_METHOD_DESCRIPTOR = Type.getMethodDescriptor(OBJECT_TYPE, STRING_TYPE);
    private static final String STATE_APPLY_METHOD_DESCRIPTOR = Type.getMethodDescriptor(Type.VOID_TYPE, STRING_TYPE, CLOSURE_TYPE);

            return Type.SHORT_TYPE;
        }
        if (kind == TypeKind.VOID) {
            return Type.VOID_TYPE;
        }
        throw unsupportedType(t);
    }

    @Override
    public Type visitNoType(NoType t, Void unused) {
        return Type.VOID_TYPE;
    }

    @Override
    public Type visitNull(NullType t, Void unused) {
        throw unsupportedType(t);
    }

        /**
         * Whenever the closure's delegate is set, we want to make sure that the call interception hooks are added to the new delegate's metaclass.
         */
        SET_DELEGATE("setDelegate", getMethodDescriptor(Type.VOID_TYPE, getType(Object.class)), true, (classData, mv) -> {
            @NonNullApi
            class MethodVisitorScopeImpl extends MethodVisitorScope {
                public MethodVisitorScopeImpl(MethodVisitor methodVisitor) {

        private static final String RETURN_VOID_FROM_OBJECT = getMethodDescriptor(Type.VOID_TYPE, OBJECT_TYPE);
        private static final String RETURN_VOID_FROM_OBJECT_CLASS_DYNAMIC_OBJECT_SERVICE_LOOKUP = getMethodDescriptor(Type.VOID_TYPE, OBJECT_TYPE, CLASS_TYPE, DYNAMIC_OBJECT_TYPE, SERVICE_LOOKUP_TYPE);

            for (int i = 0; i < paramTypes.length; i++) {
                paramTypes[i] = Type.getType(constructor.getParameterTypes()[i]);
            }
            String methodDescriptor = Type.getMethodDescriptor(Type.VOID_TYPE, paramTypes);
            MethodVisitor constructorVisitor = visitor.visitMethod(Opcodes.ACC_PUBLIC, CONSTRUCTOR_NAME, methodDescriptor, CONCRETE_SIGNATURE, NO_EXCEPTIONS);
            constructorVisitor.visitCode();