Resolve bound type parameters in generic union declarations

Author: FnControlOption

src/analysis.zig

@@ -834,7 +834,8 @@ pub fn resolveFieldAccess(analyser: *Analyser, lhs: Type, field_name: []const u8
 pub fn resolveFieldAccessBinding(analyser: *Analyser, lhs_binding: Binding, field_name: []const u8) !?Binding {
     const lhs = lhs_binding.type;
 
-    if (try analyser.resolveUnionFieldBinding(lhs, field_name)) |b| return b;
+    if (try analyser.resolveUnionTagAccess(lhs, field_name)) |t|
+        return .{ .type = t, .is_const = true };
 
     // If we are accessing a pointer type, remove one pointerness level :)
     const left_type = (try analyser.resolveDerefType(lhs)) orelse lhs;
@@ -995,7 +996,7 @@ pub fn resolveUnwrapErrorUnionType(analyser: *Analyser, ty: Type, side: ErrorUni
     };
 }
 
-fn resolveUnionFieldBinding(analyser: *Analyser, ty: Type, symbol: []const u8) error{OutOfMemory}!?Binding {
+fn resolveUnionTagAccess(analyser: *Analyser, ty: Type, symbol: []const u8) error{OutOfMemory}!?Type {
     if (!ty.is_type_val)
         return null;
 
@@ -1020,24 +1021,14 @@ fn resolveUnionFieldBinding(analyser: *Analyser, ty: Type, symbol: []const u8) e
         return null;
 
     if (child.decl != .ast_node or !child.handle.tree.nodeTag(child.decl.ast_node).isContainerField())
-        return .{
-            .type = try child.resolveType(analyser) orelse return null,
-            .is_const = child.isConst(),
-        };
+        return null;
 
-    if (container_decl.ast.enum_token != null) {
-        return .{
-            .type = .{ .data = .{ .union_tag = try analyser.allocType(ty) }, .is_type_val = false },
-            .is_const = true,
-        };
-    }
+    if (container_decl.ast.enum_token != null)
+        return .{ .data = .{ .union_tag = try analyser.allocType(ty) }, .is_type_val = false };
 
     if (container_decl.ast.arg.unwrap()) |arg| {
         const tag_type = (try analyser.resolveTypeOfNode(.of(arg, handle))) orelse return null;
-        return .{
-            .type = tag_type.instanceTypeVal(analyser) orelse return null,
-            .is_const = true,
-        };
+        return tag_type.instanceTypeVal(analyser) orelse return null;
     }
 
     return null;
@@ -3773,7 +3764,7 @@ pub const Type = struct {
                 }
                 try writer.print("!{}", .{info.payload.fmtTypeVal(analyser, ctx.options)});
             },
-            .union_tag => |t| try writer.print("@typeInfo({}).Union.tag_type.?", .{t.fmtTypeVal(analyser, ctx.options)}),
+            .union_tag => |t| try writer.print("@typeInfo({}).@\"union\".tag_type.?", .{t.fmtTypeVal(analyser, ctx.options)}),
             .container => |info| {
                 const scope_handle = info.scope_handle;
                 const handle = scope_handle.handle;

tests/analysis/generics.zig

@@ -107,3 +107,79 @@ const option_default: Option(u8) = .default;
 // TODO this should be `fn () Option(u8)`
 const option_init: Option(u8) = .init();
 //                              ^^^^^ (fn () Option(T))()
+
+fn GenericUnion(T: type) type {
+    return union {
+        field: T,
+        const decl: T = undefined;
+    };
+}
+
+const generic_union_decl = GenericUnion(u8).decl;
+//    ^^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_union: GenericUnion(u8) = .{ .field = 1 };
+//    ^^^^^^^^^^^^^ (GenericUnion(u8))()
+
+const generic_union_field = generic_union.field;
+//    ^^^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_union_tag = GenericUnion(u8).field;
+//    ^^^^^^^^^^^^^^^^^ (unknown)()
+
+fn GenericTaggedUnion(T: type) type {
+    return union(enum) {
+        field: T,
+        const decl: T = undefined;
+    };
+}
+
+const generic_tagged_union_decl = GenericTaggedUnion(u8).decl;
+//    ^^^^^^^^^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_tagged_union: GenericTaggedUnion(u8) = .{ .field = 1 };
+//    ^^^^^^^^^^^^^^^^^^^^ (GenericTaggedUnion(u8))()
+
+const generic_tagged_union_field = generic_tagged_union.field;
+//    ^^^^^^^^^^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_tagged_union_tag = GenericTaggedUnion(u8).field;
+//    ^^^^^^^^^^^^^^^^^^^^^^^^ (@typeInfo(GenericTaggedUnion(u8)).@"union".tag_type.?)()
+
+fn GenericEnum(T: type) type {
+    return enum {
+        field,
+        const decl: T = undefined;
+    };
+}
+
+const generic_enum_decl = GenericEnum(u8).decl;
+//    ^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_enum: GenericEnum(u8) = .field;
+//    ^^^^^^^^^^^^ (GenericEnum(u8))()
+
+const generic_enum_field = generic_enum.field;
+//    ^^^^^^^^^^^^^^^^^^ (unknown)()
+
+const generic_enum_tag = GenericEnum(u8).field;
+//    ^^^^^^^^^^^^^^^^ (GenericEnum(u8))()
+
+fn GenericStruct(T: type) type {
+    return struct {
+        field: T,
+        const decl: T = undefined;
+    };
+}
+
+const generic_struct_decl = GenericStruct(u8).decl;
+//    ^^^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_struct: GenericStruct(u8) = .{ .field = 1 };
+//    ^^^^^^^^^^^^^^ (GenericStruct(u8))()
+
+const generic_struct_field = generic_struct.field;
+//    ^^^^^^^^^^^^^^^^^^^^ (u8)()
+
+const generic_struct_tag = GenericStruct(u8).field;
+//    ^^^^^^^^^^^^^^^^^^ (unknown)()