syntax: allow function types as struct member type

type Foo struct {
    fn void (void* arg, i32 a) callback;
}

Author: bvdberg

analyser/conversion_checker.c2

@@ -497,7 +497,7 @@ fn bool Checker.checkFunc2Builtin(Checker* c, const Type* lcanon, const Type* rc
         // only allow Callback types or weak-functions
         FunctionType* ft = (FunctionType*)rcanon;
         FunctionDecl* fd = ft.getDecl();
-        if (fd.isType() || fd.hasAttrWeak()) return true; // Variable with Function type (eg callback)
+        if (fd.canBeNil()) return true; // Variable with Function type (eg callback)
 
         // TODO not always comparision (bool b = test1);
         c.diags.error(c.loc, "comparison of function '%s' will always be true", fd.asDecl().getFullName());

analyser/module_analyser_struct.c2

@@ -57,6 +57,14 @@ fn void Analyser.analyseStructMembers(Analyser* ma, StructTypeDecl* d) {
             member.setCheckInProgress();
             ma.analyseStructMember(vd);
 
+#if 0
+            // TODO decide whether to allow this
+            QualType qt = member.getType();
+            if (is_packed && qt.isPointerOrFunction()) {
+                ma.error(member.getLoc(), "pointer types are not allowed in packed structs");
+            }
+#endif
+
             Expr* bitfield = vd.getBitfield();
             if (bitfield) {
                 // canonical must be builtin type/enum

analyser/module_analyser_type.c2

@@ -96,6 +96,18 @@ fn void Analyser.analyseEnumType(Analyser* ma, EnumTypeDecl* d) {
     }
 }
 
+fn QualType Analyser.analyseStructMemberTypeRef(Analyser* ma, TypeRef* ref) {
+    const Ref* member = ref.getStructMemberType();
+    // Member.decl is uninitialized!? (member is ok)
+    assert(member.decl);
+    assert(member.decl.isFunction());
+
+    FunctionDecl* fd = (FunctionDecl*)member.decl;
+    ma.analyseFunction(fd);
+    if (ma.has_error) return QualType_Invalid;
+    return member.decl.getType();
+}
+
 fn QualType Analyser.analyseUserTypeRef(Analyser* ma, TypeRef* ref) {
     assert(ma.mod);
     const Ref* user = ref.getUser();
@@ -166,14 +178,22 @@ fn QualType Analyser.analyseUserTypeRef(Analyser* ma, TypeRef* ref) {
 
 fn QualType Analyser.analyseTypeRef(Analyser* ma, TypeRef* ref) {
     QualType base;
-    if (ref.isUser()) {
-        base = ma.analyseUserTypeRef(ref);
-        if (base.isInvalid()) return base;
-        if (!base.hasCanonicalType()) return QualType_Invalid;
-    } else {
+    switch (ref.getKind()) {
+    case Builtin:
         BuiltinKind kind = ref.getBuiltinKind();
         base = ma.builder.actOnBuiltinType(kind);
         assert(base.isValid());
+        break;
+    case User:
+        base = ma.analyseUserTypeRef(ref);
+        if (base.isInvalid()) return base;
+        if (!base.hasCanonicalType()) return QualType_Invalid;
+        break;
+    case StructMemberType:
+        base = ma.analyseStructMemberTypeRef(ref);
+        if (base.isInvalid()) return base;
+        if (!base.hasCanonicalType()) return QualType_Invalid;
+        break;
     }
 
     if (ref.isConst()) base.setConst();

ast/function_decl.c2

@@ -43,6 +43,7 @@ type FunctionDeclBits struct {
     u32 has_return : 1;     // if it returns something, set during analysis
     u32 is_template : 1;
     u32 is_type : 1;     // part of FunctionTypeDecl
+    u32 is_member_type : 1;    // if function is defined in struct as member type
     u32 has_body : 1;    // if function is defined in C2
 }
 
@@ -125,16 +126,16 @@ public fn FunctionDecl* FunctionDecl.create(ast_context.Context* c,
 }
 
 public fn FunctionDecl* FunctionDecl.createTemplate(ast_context.Context* c,
-                                                      u32 name,
-                                                      SrcLoc loc,
-                                                      bool is_public,
-                                                      u32 ast_idx,
-                                                      const TypeRefHolder* rtype,
-                                                      u32 template_name,
-                                                      SrcLoc template_loc,
-                                                      VarDecl** params,
-                                                      u32 num_params,
-                                                      bool is_variadic)
+                                                    u32 name,
+                                                    SrcLoc loc,
+                                                    bool is_public,
+                                                    u32 ast_idx,
+                                                    const TypeRefHolder* rtype,
+                                                    u32 template_name,
+                                                    SrcLoc template_loc,
+                                                    VarDecl** params,
+                                                    u32 num_params,
+                                                    bool is_variadic)
 {
     u32 size = sizeof(FunctionDecl) + num_params * sizeof(VarDecl*) + rtype.getExtraSize();
     FunctionDecl* d = c.alloc(size);
@@ -238,6 +239,11 @@ public fn bool FunctionDecl.isInline(const FunctionDecl* d) {
     return true;
 }
 
+public fn bool FunctionDecl.canBeNil(const FunctionDecl* d) {
+    // Variable with Function type (eg callback)
+    return d.isType() || d.isMemberType() || d.hasAttrWeak();
+}
+
 public fn bool FunctionDecl.isType(const FunctionDecl* d) {
     return d.base.functionDeclBits.is_type;
 }
@@ -426,6 +432,14 @@ public fn const char* FunctionDecl.getDiagKind(const FunctionDecl* d) {
     return "";
 }
 
+public fn void FunctionDecl.setMemberType(FunctionDecl* d) {
+    d.base.functionDeclBits.is_member_type = 1;
+}
+
+public fn bool FunctionDecl.isMemberType(const FunctionDecl* d) {
+    return d.base.functionDeclBits.is_member_type;
+}
+
 fn void FunctionDecl.print(const FunctionDecl* d, string_buffer.Buf* out, u32 indent) {
     bool valid_type = d.base.qt.isValid();
     d.base.printKind(out, indent, valid_type);
@@ -441,6 +455,7 @@ fn void FunctionDecl.print(const FunctionDecl* d, string_buffer.Buf* out, u32 in
     out.add(callKind_names[d.getCallKind()]);
     d.base.printAttrs(out);
     if (d.base.functionDeclBits.is_type) out.add(" Type");
+    if (d.base.functionDeclBits.is_member_type) out.add(" MemberType");
     out.color(col_Expr); // purple
     if (d.hasAttrUnusedParams()) out.add(" unused-params");
     if (d.hasAttrNoReturn()) out.add(" noreturn");

ast/qualtype.c2

@@ -243,6 +243,11 @@ public fn bool QualType.isPointer(const QualType* qt) {
     return qt.getTypeOrNil().isPointerType();
 }
 
+public fn bool QualType.isPointerOrFunction(const QualType* qt) @(unused) {
+    const Type* t = qt.getTypeOrNil();
+    return t.isPointerType() || t.isFunctionType();
+}
+
 // NOTE: does not check if kind is ok
 public fn QualType QualType.getPointerBaseType(const QualType* qt) {
     const PointerType* pt = qt.getPointerType();