Commit 3ba099bfba9d3c38fe188010aa82fc589b1cabf6 | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-05-10 17:21:22-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-06-10 20:42:30-07:00
log	3ba099bfba9d3c38fe188010aa82fc589b1cabf6
tree	ef96b24aa9e6417e4cfa8c421c0a77ef9b75e22c
parent	8297f28546b44afe49bec074733f05e03a3c0e62

stage2: move union types and values to InternPool

18 files changed, 688 insertions(+), 546 deletions(-)

src
- InternPool.zig
- Module.zig
- Sema.zig
- TypedValue.zig
- arch
  - aarch64
    abi.zig
  - arm
    abi.zig
  - wasm
    CodeGen.zig
    abi.zig
  - x86_64
    CodeGen.zig
    abi.zig
- codegen.zig
- codegen
- link
  - Dwarf.zig
- type.zig
- value.zig

src/InternPool.zig+148-25

 @@ -21,6 +21,13 @@ allocated_structs: std.SegmentedList(Module.Struct, 0) = .{},
 /// When a Struct object is freed from `allocated_structs`, it is pushed into this stack.
 structs_free_list: std.ArrayListUnmanaged(Module.Struct.Index) = .{},
+/// Union objects are stored in this data structure because:
+/// * They contain pointers such as the field maps.
+/// * They need to be mutated after creation.
+allocated_unions: std.SegmentedList(Module.Union, 0) = .{},
+/// When a Union object is freed from `allocated_unions`, it is pushed into this stack.
+unions_free_list: std.ArrayListUnmanaged(Module.Union.Index) = .{},
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
 @@ -59,10 +66,7 @@ pub const Key = union(enum) {
     /// If `empty_struct_type` is handled separately, then this value may be
     /// safely assumed to never be `none`.
     struct_type: StructType,
-    union_type: struct {
+    union_type: UnionType,
-        fields_len: u32,
-        // TODO move Module.Union data to InternPool
-    },
     opaque_type: OpaqueType,
     simple_value: SimpleValue,
 @@ -87,6 +91,8 @@ pub const Key = union(enum) {
     /// In the case of sentinel-terminated arrays, the sentinel value *is* stored,
     /// so the slice length will be one more than the type's array length.
     aggregate: Aggregate,
+    /// An instance of a union.
+    un: Union,
     pub const IntType = std.builtin.Type.Int;
 @@ -145,13 +151,27 @@ pub const Key = union(enum) {
     ///   - index == .none
     /// * A struct which has fields as well as a namepace.
     pub const StructType = struct {
-        /// This will be `none` only in the case of `@TypeOf(.{})`
-        /// (`Index.empty_struct_type`).
-        namespace: Module.Namespace.OptionalIndex,
         /// The `none` tag is used to represent two cases:
         /// * `@TypeOf(.{})`, in which case `namespace` will also be `none`.
         /// * A struct with no fields, in which case `namespace` will be populated.
         index: Module.Struct.OptionalIndex,
+        /// This will be `none` only in the case of `@TypeOf(.{})`
+        /// (`Index.empty_struct_type`).
+        namespace: Module.Namespace.OptionalIndex,
+    };
+    pub const UnionType = struct {
+        index: Module.Union.Index,
+        runtime_tag: RuntimeTag,
+        pub const RuntimeTag = enum { none, safety, tagged };
+        pub fn hasTag(self: UnionType) bool {
+            return switch (self.runtime_tag) {
+                .none => false,
+                .tagged, .safety => true,
+            };
+        }
     };
     pub const Int = struct {
 @@ -198,6 +218,15 @@ pub const Key = union(enum) {
         val: Index,
     };
+    pub const Union = struct {
+        /// This is the union type; not the field type.
+        ty: Index,
+        /// Indicates the active field.
+        tag: Index,
+        /// The value of the active field.
+        val: Index,
+    };
     pub const Aggregate = struct {
         ty: Index,
         fields: []const Index,
 @@ -229,12 +258,10 @@ pub const Key = union(enum) {
             .extern_func,
             .opt,
             .struct_type,
+            .union_type,
+            .un,
             => |info| std.hash.autoHash(hasher, info),
-            .union_type => |union_type| {
-                _ = union_type;
-                @panic("TODO");
-            },
             .opaque_type => |opaque_type| std.hash.autoHash(hasher, opaque_type.decl),
             .int => |int| {
 @@ -320,6 +347,14 @@ pub const Key = union(enum) {
                 const b_info = b.struct_type;
                 return std.meta.eql(a_info, b_info);
             },
+            .union_type => |a_info| {
+                const b_info = b.union_type;
+                return std.meta.eql(a_info, b_info);
+            },
+            .un => |a_info| {
+                const b_info = b.un;
+                return std.meta.eql(a_info, b_info);
+            },
             .ptr => |a_info| {
                 const b_info = b.ptr;
 @@ -371,14 +406,6 @@ pub const Key = union(enum) {
                 @panic("TODO");
             },
-            .union_type => |a_info| {
-                const b_info = b.union_type;
-                _ = a_info;
-                _ = b_info;
-                @panic("TODO");
-            },
             .opaque_type => |a_info| {
                 const b_info = b.opaque_type;
                 return a_info.decl == b_info.decl;
 @@ -411,6 +438,7 @@ pub const Key = union(enum) {
             .extern_func,
             .enum_tag,
             .aggregate,
+            .un,
             => |x| return x.ty,
             .simple_value => |s| switch (s) {
 @@ -838,6 +866,15 @@ pub const Tag = enum(u8) {
     /// Module.Struct object allocated for it.
     /// data is Module.Namespace.Index.
     type_struct_ns,
+    /// A tagged union type.
+    /// `data` is `Module.Union.Index`.
+    type_union_tagged,
+    /// An untagged union type. It also has no safety tag.
+    /// `data` is `Module.Union.Index`.
+    type_union_untagged,
+    /// An untagged union type which has a safety tag.
+    /// `data` is `Module.Union.Index`.
+    type_union_safety,
     /// A value that can be represented with only an enum tag.
     /// data is SimpleValue enum value.
 @@ -908,6 +945,8 @@ pub const Tag = enum(u8) {
     /// * A struct which has 0 fields.
     /// data is Index of the type, which is known to be zero bits at runtime.
     only_possible_value,
+    /// data is extra index to Key.Union.
+    union_value,
 };
 /// Having `SimpleType` and `SimpleValue` in separate enums makes it easier to
 @@ -1141,6 +1180,9 @@ pub fn deinit(ip: *InternPool, gpa: Allocator) void {
     ip.structs_free_list.deinit(gpa);
     ip.allocated_structs.deinit(gpa);
+    ip.unions_free_list.deinit(gpa);
+    ip.allocated_unions.deinit(gpa);
     ip.* = undefined;
 }
 @@ -1233,6 +1275,19 @@ pub fn indexToKey(ip: InternPool, index: Index) Key {
             .namespace = @intToEnum(Module.Namespace.Index, data).toOptional(),
         } },
+        .type_union_untagged => .{ .union_type = .{
+            .index = @intToEnum(Module.Union.Index, data),
+            .runtime_tag = .none,
+        } },
+        .type_union_tagged => .{ .union_type = .{
+            .index = @intToEnum(Module.Union.Index, data),
+            .runtime_tag = .tagged,
+        } },
+        .type_union_safety => .{ .union_type = .{
+            .index = @intToEnum(Module.Union.Index, data),
+            .runtime_tag = .safety,
+        } },
         .opt_null => .{ .opt = .{
             .ty = @intToEnum(Index, data),
             .val = .none,
 @@ -1303,6 +1358,7 @@ pub fn indexToKey(ip: InternPool, index: Index) Key {
                 else => unreachable,
             };
         },
+        .union_value => .{ .un = ip.extraData(Key.Union, data) },
     };
 }
 @@ -1350,7 +1406,6 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                 return @intToEnum(Index, ip.items.len - 1);
             }
-            // TODO introduce more pointer encodings
             ip.items.appendAssumeCapacity(.{
                 .tag = .type_pointer,
                 .data = try ip.addExtra(gpa, Pointer{
 @@ -1450,8 +1505,14 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
         },
         .union_type => |union_type| {
-            _ = union_type;
+            ip.items.appendAssumeCapacity(.{
-            @panic("TODO");
+                .tag = switch (union_type.runtime_tag) {
+                    .none => .type_union_untagged,
+                    .safety => .type_union_safety,
+                    .tagged => .type_union_tagged,
+                },
+                .data = @enumToInt(union_type.index),
+            });
         },
         .opaque_type => |opaque_type| {
 @@ -1642,6 +1703,16 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
             }
             @panic("TODO");
         },
+        .un => |un| {
+            assert(un.ty != .none);
+            assert(un.tag != .none);
+            assert(un.val != .none);
+            ip.items.appendAssumeCapacity(.{
+                .tag = .union_value,
+                .data = try ip.addExtra(gpa, un),
+            });
+        },
     }
     return @intToEnum(Index, ip.items.len - 1);
 }
 @@ -1923,6 +1994,17 @@ pub fn indexToStruct(ip: *InternPool, val: Index) Module.Struct.OptionalIndex {
     return @intToEnum(Module.Struct.Index, datas[@enumToInt(val)]).toOptional();
 }
+pub fn indexToUnion(ip: *InternPool, val: Index) Module.Union.OptionalIndex {
+    const tags = ip.items.items(.tag);
+    if (val == .none) return .none;
+    switch (tags[@enumToInt(val)]) {
+        .type_union_tagged, .type_union_untagged, .type_union_safety => {},
+        else => return .none,
+    }
+    const datas = ip.items.items(.data);
+    return @intToEnum(Module.Union.Index, datas[@enumToInt(val)]).toOptional();
+}
 pub fn isOptionalType(ip: InternPool, ty: Index) bool {
     const tags = ip.items.items(.tag);
     if (ty == .none) return false;
 @@ -1937,15 +2019,22 @@ fn dumpFallible(ip: InternPool, arena: Allocator) anyerror!void {
     const items_size = (1 + 4) * ip.items.len;
     const extra_size = 4 * ip.extra.items.len;
     const limbs_size = 8 * ip.limbs.items.len;
+    const structs_size = ip.allocated_structs.len *
+        (@sizeOf(Module.Struct) + @sizeOf(Module.Namespace) + @sizeOf(Module.Decl));
+    const unions_size = ip.allocated_unions.len *
+        (@sizeOf(Module.Union) + @sizeOf(Module.Namespace) + @sizeOf(Module.Decl));
     // TODO: map overhead size is not taken into account
-    const total_size = @sizeOf(InternPool) + items_size + extra_size + limbs_size;
+    const total_size = @sizeOf(InternPool) + items_size + extra_size + limbs_size +
+        structs_size + unions_size;
     std.debug.print(
         \\InternPool size: {d} bytes
         \\  {d} items: {d} bytes
         \\  {d} extra: {d} bytes
         \\  {d} limbs: {d} bytes
+        \\  {d} structs: {d} bytes
+        \\  {d} unions: {d} bytes
         \\
     , .{
         total_size,
 @@ -1955,6 +2044,10 @@ fn dumpFallible(ip: InternPool, arena: Allocator) anyerror!void {
         extra_size,
         ip.limbs.items.len,
         limbs_size,
+        ip.allocated_structs.len,
+        structs_size,
+        ip.allocated_unions.len,
+        unions_size,
     });
     const tags = ip.items.items(.tag);
 @@ -1980,8 +2073,14 @@ fn dumpFallible(ip: InternPool, arena: Allocator) anyerror!void {
             .type_error_union => @sizeOf(ErrorUnion),
             .type_enum_simple => @sizeOf(EnumSimple),
             .type_opaque => @sizeOf(Key.OpaqueType),
-            .type_struct => 0,
+            .type_struct => @sizeOf(Module.Struct) + @sizeOf(Module.Namespace) + @sizeOf(Module.Decl),
-            .type_struct_ns => 0,
+            .type_struct_ns => @sizeOf(Module.Namespace),
+            .type_union_tagged,
+            .type_union_untagged,
+            .type_union_safety,
+            => @sizeOf(Module.Union) + @sizeOf(Module.Namespace) + @sizeOf(Module.Decl),
             .simple_type => 0,
             .simple_value => 0,
             .ptr_int => @sizeOf(PtrInt),
 @@ -2010,6 +2109,7 @@ fn dumpFallible(ip: InternPool, arena: Allocator) anyerror!void {
             .extern_func => @panic("TODO"),
             .func => @panic("TODO"),
             .only_possible_value => 0,
+            .union_value => @sizeOf(Key.Union),
         });
     }
     const SortContext = struct {
 @@ -2041,6 +2141,10 @@ pub fn structPtrUnwrapConst(ip: InternPool, index: Module.Struct.OptionalIndex)
     return structPtrConst(ip, index.unwrap() orelse return null);
 }
+pub fn unionPtr(ip: *InternPool, index: Module.Union.Index) *Module.Union {
+    return ip.allocated_unions.at(@enumToInt(index));
+}
 pub fn createStruct(
     ip: *InternPool,
     gpa: Allocator,
 @@ -2059,3 +2163,22 @@ pub fn destroyStruct(ip: *InternPool, gpa: Allocator, index: Module.Struct.Index
         // allocation failures here, instead leaking the Struct until garbage collection.
     };
 }
+pub fn createUnion(
+    ip: *InternPool,
+    gpa: Allocator,
+    initialization: Module.Union,
+) Allocator.Error!Module.Union.Index {
+    if (ip.unions_free_list.popOrNull()) |index| return index;
+    const ptr = try ip.allocated_unions.addOne(gpa);
+    ptr.* = initialization;
+    return @intToEnum(Module.Union.Index, ip.allocated_unions.len - 1);
+}
+pub fn destroyUnion(ip: *InternPool, gpa: Allocator, index: Module.Union.Index) void {
+    ip.unionPtr(index).* = undefined;
+    ip.unions_free_list.append(gpa, index) catch {
+        // In order to keep `destroyUnion` a non-fallible function, we ignore memory
+        // allocation failures here, instead leaking the Union until garbage collection.
+    };
+}

src/Module.zig+57-20

 @@ -851,11 +851,10 @@ pub const Decl = struct {
     /// If the Decl has a value and it is a union, return it,
     /// otherwise null.
-    pub fn getUnion(decl: *Decl) ?*Union {
+    pub fn getUnion(decl: *Decl, mod: *Module) ?*Union {
         if (!decl.owns_tv) return null;
         const ty = (decl.val.castTag(.ty) orelse return null).data;
-        const union_obj = (ty.cast(Type.Payload.Union) orelse return null).data;
+        return mod.typeToUnion(ty);
-        return union_obj;
     }
     /// If the Decl has a value and it is a function, return it,
 @@ -896,10 +895,6 @@ pub const Decl = struct {
                         const enum_obj = ty.cast(Type.Payload.EnumFull).?.data;
                         return enum_obj.namespace.toOptional();
                     },
-                    .@"union", .union_safety_tagged, .union_tagged => {
-                        const union_obj = ty.cast(Type.Payload.Union).?.data;
-                        return union_obj.namespace.toOptional();
-                    },
                     else => return .none,
                 }
 @@ -907,6 +902,10 @@ pub const Decl = struct {
             else => return switch (mod.intern_pool.indexToKey(decl.val.ip_index)) {
                 .opaque_type => |opaque_type| opaque_type.namespace.toOptional(),
                 .struct_type => |struct_type| struct_type.namespace,
+                .union_type => |union_type| {
+                    const union_obj = mod.unionPtr(union_type.index);
+                    return union_obj.namespace.toOptional();
+                },
                 else => .none,
             },
         }
 @@ -1373,6 +1372,28 @@ pub const Union = struct {
     requires_comptime: PropertyBoolean = .unknown,
     assumed_runtime_bits: bool = false,
+    pub const Index = enum(u32) {
+        _,
+        pub fn toOptional(i: Index) OptionalIndex {
+            return @intToEnum(OptionalIndex, @enumToInt(i));
+        }
+    };
+    pub const OptionalIndex = enum(u32) {
+        none = std.math.maxInt(u32),
+        _,
+        pub fn init(oi: ?Index) OptionalIndex {
+            return @intToEnum(OptionalIndex, @enumToInt(oi orelse return .none));
+        }
+        pub fn unwrap(oi: OptionalIndex) ?Index {
+            if (oi == .none) return null;
+            return @intToEnum(Index, @enumToInt(oi));
+        }
+    };
     pub const Field = struct {
         /// undefined until `status` is `have_field_types` or `have_layout`.
         ty: Type,
 @@ -3639,6 +3660,10 @@ pub fn namespacePtr(mod: *Module, index: Namespace.Index) *Namespace {
     return mod.allocated_namespaces.at(@enumToInt(index));
 }
+pub fn unionPtr(mod: *Module, index: Union.Index) *Union {
+    return mod.intern_pool.unionPtr(index);
+}
 pub fn structPtr(mod: *Module, index: Struct.Index) *Struct {
     return mod.intern_pool.structPtr(index);
 }
 @@ -4112,7 +4137,7 @@ fn updateZirRefs(mod: *Module, file: *File, old_zir: Zir) !void {
             };
         }
-        if (decl.getUnion()) |union_obj| {
+        if (decl.getUnion(mod)) |union_obj| {
             union_obj.zir_index = inst_map.get(union_obj.zir_index) orelse {
                 try file.deleted_decls.append(gpa, decl_index);
                 continue;
 @@ -5988,20 +6013,10 @@ fn markOutdatedDecl(mod: *Module, decl_index: Decl.Index) !void {
     decl.analysis = .outdated;
 }
-pub const CreateNamespaceOptions = struct {
+pub fn createNamespace(mod: *Module, initialization: Namespace) !Namespace.Index {
-    parent: Namespace.OptionalIndex,
-    file_scope: *File,
-    ty: Type,
-};
-pub fn createNamespace(mod: *Module, options: CreateNamespaceOptions) !Namespace.Index {
     if (mod.namespaces_free_list.popOrNull()) |index| return index;
     const ptr = try mod.allocated_namespaces.addOne(mod.gpa);
-    ptr.* = .{
+    ptr.* = initialization;
-        .parent = options.parent,
-        .file_scope = options.file_scope,
-        .ty = options.ty,
-    };
     return @intToEnum(Namespace.Index, mod.allocated_namespaces.len - 1);
 }
 @@ -6021,6 +6036,14 @@ pub fn destroyStruct(mod: *Module, index: Struct.Index) void {
     return mod.intern_pool.destroyStruct(mod.gpa, index);
 }
+pub fn createUnion(mod: *Module, initialization: Union) Allocator.Error!Union.Index {
+    return mod.intern_pool.createUnion(mod.gpa, initialization);
+}
+pub fn destroyUnion(mod: *Module, index: Union.Index) void {
+    return mod.intern_pool.destroyUnion(mod.gpa, index);
+}
 pub fn allocateNewDecl(
     mod: *Module,
     namespace: Namespace.Index,
 @@ -7068,6 +7091,15 @@ pub fn intValue_i64(mod: *Module, ty: Type, x: i64) Allocator.Error!Value {
     return i.toValue();
 }
+pub fn unionValue(mod: *Module, union_ty: Type, tag: Value, val: Value) Allocator.Error!Value {
+    const i = try intern(mod, .{ .un = .{
+        .ty = union_ty.ip_index,
+        .tag = tag.ip_index,
+        .val = val.ip_index,
+    } });
+    return i.toValue();
+}
 pub fn smallestUnsignedInt(mod: *Module, max: u64) Allocator.Error!Type {
     return intType(mod, .unsigned, Type.smallestUnsignedBits(max));
 }
 @@ -7276,3 +7308,8 @@ pub fn typeToStruct(mod: *Module, ty: Type) ?*Struct {
     const struct_index = mod.intern_pool.indexToStruct(ty.ip_index).unwrap() orelse return null;
     return mod.structPtr(struct_index);
 }
+pub fn typeToUnion(mod: *Module, ty: Type) ?*Union {
+    const union_index = mod.intern_pool.indexToUnion(ty.ip_index).unwrap() orelse return null;
+    return mod.unionPtr(union_index);
+}

src/Sema.zig+203-178

...	@@ -3123,6 +3123,8 @@ fn zirUnionDecl(	...	@@ -3123,6 +3123,8 @@ fn zirUnionDecl(
3123	const tracy = trace(@src());	3123	const tracy = trace(@src());
3124	defer tracy.end();	3124	defer tracy.end();
3125		3125
		3126	const mod = sema.mod;
		3127	const gpa = sema.gpa;
3126	const small = @bitCast(Zir.Inst.UnionDecl.Small, extended.small);	3128	const small = @bitCast(Zir.Inst.UnionDecl.Small, extended.small);
3127	var extra_index: usize = extended.operand;	3129	var extra_index: usize = extended.operand;
3128		3130
...	@@ -3142,49 +3144,57 @@ fn zirUnionDecl(	...	@@ -3142,49 +3144,57 @@ fn zirUnionDecl(
3142	break :blk decls_len;	3144	break :blk decls_len;
3143	} else 0;	3145	} else 0;
3144		3146
3145	var new_decl_arena = std.heap.ArenaAllocator.init(sema.gpa);	3147	var new_decl_arena = std.heap.ArenaAllocator.init(gpa);
3146	errdefer new_decl_arena.deinit();	3148	errdefer new_decl_arena.deinit();
3147	const new_decl_arena_allocator = new_decl_arena.allocator();
3148		3149
3149	const union_obj = try new_decl_arena_allocator.create(Module.Union);	3150	// Because these three things each reference each other, `undefined`
3150	const type_tag = if (small.has_tag_type or small.auto_enum_tag)	3151	// placeholders are used before being set after the union type gains an
3151	Type.Tag.union_tagged	3152	// InternPool index.
3152	else if (small.layout != .Auto)	3153
3153	Type.Tag.@"union"
3154	else switch (block.sema.mod.optimizeMode()) {
3155	.Debug, .ReleaseSafe => Type.Tag.union_safety_tagged,
3156	.ReleaseFast, .ReleaseSmall => Type.Tag.@"union",
3157	};
3158	const union_payload = try new_decl_arena_allocator.create(Type.Payload.Union);
3159	union_payload.* = .{
3160	.base = .{ .tag = type_tag },
3161	.data = union_obj,
3162	};
3163	const union_ty = Type.initPayload(&union_payload.base);
3164	const union_val = try Value.Tag.ty.create(new_decl_arena_allocator, union_ty);
3165	const mod = sema.mod;
3166	const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{	3154	const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{
3167	.ty = Type.type,	3155	.ty = Type.type,
3168	.val = union_val,	3156	.val = undefined,
3169	}, small.name_strategy, "union", inst);	3157	}, small.name_strategy, "union", inst);
3170	const new_decl = mod.declPtr(new_decl_index);	3158	const new_decl = mod.declPtr(new_decl_index);
3171	new_decl.owns_tv = true;	3159	new_decl.owns_tv = true;
3172	errdefer mod.abortAnonDecl(new_decl_index);	3160	errdefer mod.abortAnonDecl(new_decl_index);
3173	union_obj.* = .{	3161
		3162	const new_namespace_index = try mod.createNamespace(.{
		3163	.parent = block.namespace.toOptional(),
		3164	.ty = undefined,
		3165	.file_scope = block.getFileScope(mod),
		3166	});
		3167	const new_namespace = mod.namespacePtr(new_namespace_index);
		3168	errdefer mod.destroyNamespace(new_namespace_index);
		3169
		3170	const union_index = try mod.createUnion(.{
3174	.owner_decl = new_decl_index,	3171	.owner_decl = new_decl_index,
3175	.tag_ty = Type.null,	3172	.tag_ty = Type.null,
3176	.fields = .{},	3173	.fields = .{},
3177	.zir_index = inst,	3174	.zir_index = inst,
3178	.layout = small.layout,	3175	.layout = small.layout,
3179	.status = .none,	3176	.status = .none,
3180	.namespace = try mod.createNamespace(.{	3177	.namespace = new_namespace_index,
3181	.parent = block.namespace.toOptional(),	3178	});
3182	.ty = union_ty,	3179	errdefer mod.destroyUnion(union_index);
3183	.file_scope = block.getFileScope(mod),	3180
3184	}),	3181	const union_ty = try mod.intern_pool.get(gpa, .{ .union_type = .{
3185	};	3182	.index = union_index,
		3183	.runtime_tag = if (small.has_tag_type or small.auto_enum_tag)
		3184	.tagged
		3185	else if (small.layout != .Auto)
		3186	.none
		3187	else switch (block.sema.mod.optimizeMode()) {
		3188	.Debug, .ReleaseSafe => .safety,
		3189	.ReleaseFast, .ReleaseSmall => .none,
		3190	},
		3191	} });
		3192	errdefer mod.intern_pool.remove(union_ty);
		3193
		3194	new_decl.val = union_ty.toValue();
		3195	new_namespace.ty = union_ty.toType();
3186		3196
3187	_ = try mod.scanNamespace(union_obj.namespace, extra_index, decls_len, new_decl);	3197	_ = try mod.scanNamespace(new_namespace_index, extra_index, decls_len, new_decl);
3188		3198
3189	try new_decl.finalizeNewArena(&new_decl_arena);	3199	try new_decl.finalizeNewArena(&new_decl_arena);
3190	return sema.analyzeDeclVal(block, src, new_decl_index);	3200	return sema.analyzeDeclVal(block, src, new_decl_index);
...	@@ -4246,6 +4256,8 @@ fn validateUnionInit(	...	@@ -4246,6 +4256,8 @@ fn validateUnionInit(
4246	instrs: []const Zir.Inst.Index,	4256	instrs: []const Zir.Inst.Index,
4247	union_ptr: Air.Inst.Ref,	4257	union_ptr: Air.Inst.Ref,
4248	) CompileError!void {	4258	) CompileError!void {
		4259	const mod = sema.mod;
		4260
4249	if (instrs.len != 1) {	4261	if (instrs.len != 1) {
4250	const msg = msg: {	4262	const msg = msg: {
4251	const msg = try sema.errMsg(	4263	const msg = try sema.errMsg(
...	@@ -4343,7 +4355,7 @@ fn validateUnionInit(	...	@@ -4343,7 +4355,7 @@ fn validateUnionInit(
4343	break;	4355	break;
4344	}	4356	}
4345		4357
4346	const tag_ty = union_ty.unionTagTypeHypothetical();	4358	const tag_ty = union_ty.unionTagTypeHypothetical(mod);
4347	const enum_field_index = @intCast(u32, tag_ty.enumFieldIndex(field_name).?);	4359	const enum_field_index = @intCast(u32, tag_ty.enumFieldIndex(field_name).?);
4348	const tag_val = try Value.Tag.enum_field_index.create(sema.arena, enum_field_index);	4360	const tag_val = try Value.Tag.enum_field_index.create(sema.arena, enum_field_index);
4349		4361
...	@@ -8273,7 +8285,7 @@ fn zirEnumToInt(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!A	...	@@ -8273,7 +8285,7 @@ fn zirEnumToInt(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!A
8273	.Enum => operand,	8285	.Enum => operand,
8274	.Union => blk: {	8286	.Union => blk: {
8275	const union_ty = try sema.resolveTypeFields(operand_ty);	8287	const union_ty = try sema.resolveTypeFields(operand_ty);
8276	const tag_ty = union_ty.unionTagType() orelse {	8288	const tag_ty = union_ty.unionTagType(mod) orelse {
8277	return sema.fail(	8289	return sema.fail(
8278	block,	8290	block,
8279	operand_src,	8291	operand_src,
...	@@ -10158,7 +10170,7 @@ fn zirSwitchCapture(	...	@@ -10158,7 +10170,7 @@ fn zirSwitchCapture(
10158	const item_val = sema.resolveConstValue(block, .unneeded, block.inline_case_capture, undefined) catch unreachable;	10170	const item_val = sema.resolveConstValue(block, .unneeded, block.inline_case_capture, undefined) catch unreachable;
10159	if (operand_ty.zigTypeTag(mod) == .Union) {	10171	if (operand_ty.zigTypeTag(mod) == .Union) {
10160	const field_index = @intCast(u32, operand_ty.unionTagFieldIndex(item_val, sema.mod).?);	10172	const field_index = @intCast(u32, operand_ty.unionTagFieldIndex(item_val, sema.mod).?);
10161	const union_obj = operand_ty.cast(Type.Payload.Union).?.data;	10173	const union_obj = mod.typeToUnion(operand_ty).?;
10162	const field_ty = union_obj.fields.values()[field_index].ty;	10174	const field_ty = union_obj.fields.values()[field_index].ty;
10163	if (try sema.resolveDefinedValue(block, sema.src, operand_ptr)) \|union_val\| {	10175	if (try sema.resolveDefinedValue(block, sema.src, operand_ptr)) \|union_val\| {
10164	if (is_ref) {	10176	if (is_ref) {
...	@@ -10229,7 +10241,7 @@ fn zirSwitchCapture(	...	@@ -10229,7 +10241,7 @@ fn zirSwitchCapture(
10229		10241
10230	switch (operand_ty.zigTypeTag(mod)) {	10242	switch (operand_ty.zigTypeTag(mod)) {
10231	.Union => {	10243	.Union => {
10232	const union_obj = operand_ty.cast(Type.Payload.Union).?.data;	10244	const union_obj = mod.typeToUnion(operand_ty).?;
10233	const first_item = try sema.resolveInst(items[0]);	10245	const first_item = try sema.resolveInst(items[0]);
10234	// Previous switch validation ensured this will succeed	10246	// Previous switch validation ensured this will succeed
10235	const first_item_val = sema.resolveConstValue(block, .unneeded, first_item, "") catch unreachable;	10247	const first_item_val = sema.resolveConstValue(block, .unneeded, first_item, "") catch unreachable;
...	@@ -10403,7 +10415,7 @@ fn zirSwitchCond(	...	@@ -10403,7 +10415,7 @@ fn zirSwitchCond(
10403		10415
10404	.Union => {	10416	.Union => {
10405	const union_ty = try sema.resolveTypeFields(operand_ty);	10417	const union_ty = try sema.resolveTypeFields(operand_ty);
10406	const enum_ty = union_ty.unionTagType() orelse {	10418	const enum_ty = union_ty.unionTagType(mod) orelse {
10407	const msg = msg: {	10419	const msg = msg: {
10408	const msg = try sema.errMsg(block, src, "switch on union with no attached enum", .{});	10420	const msg = try sema.errMsg(block, src, "switch on union with no attached enum", .{});
10409	errdefer msg.destroy(sema.gpa);	10421	errdefer msg.destroy(sema.gpa);
...	@@ -11627,7 +11639,7 @@ fn zirSwitchBlock(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError	...	@@ -11627,7 +11639,7 @@ fn zirSwitchBlock(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError
11627	const analyze_body = if (union_originally and !special.is_inline)	11639	const analyze_body = if (union_originally and !special.is_inline)
11628	for (seen_enum_fields, 0..) \|seen_field, index\| {	11640	for (seen_enum_fields, 0..) \|seen_field, index\| {
11629	if (seen_field != null) continue;	11641	if (seen_field != null) continue;
11630	const union_obj = maybe_union_ty.cast(Type.Payload.Union).?.data;	11642	const union_obj = mod.typeToUnion(maybe_union_ty).?;
11631	const field_ty = union_obj.fields.values()[index].ty;	11643	const field_ty = union_obj.fields.values()[index].ty;
11632	if (field_ty.zigTypeTag(mod) != .NoReturn) break true;	11644	if (field_ty.zigTypeTag(mod) != .NoReturn) break true;
11633	} else false	11645	} else false
...	@@ -12068,7 +12080,7 @@ fn zirHasField(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -12068,7 +12080,7 @@ fn zirHasField(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
12068	}	12080	}
12069	break :hf switch (ty.zigTypeTag(mod)) {	12081	break :hf switch (ty.zigTypeTag(mod)) {
12070	.Struct => ty.structFields(mod).contains(field_name),	12082	.Struct => ty.structFields(mod).contains(field_name),
12071	.Union => ty.unionFields().contains(field_name),	12083	.Union => ty.unionFields(mod).contains(field_name),
12072	.Enum => ty.enumFields().contains(field_name),	12084	.Enum => ty.enumFields().contains(field_name),
12073	.Array => mem.eql(u8, field_name, "len"),	12085	.Array => mem.eql(u8, field_name, "len"),
12074	else => return sema.fail(block, ty_src, "type '{}' does not support '@hasField'", .{	12086	else => return sema.fail(block, ty_src, "type '{}' does not support '@hasField'", .{
...	@@ -15415,7 +15427,7 @@ fn analyzeCmpUnionTag(	...	@@ -15415,7 +15427,7 @@ fn analyzeCmpUnionTag(
15415	) CompileError!Air.Inst.Ref {	15427	) CompileError!Air.Inst.Ref {
15416	const mod = sema.mod;	15428	const mod = sema.mod;
15417	const union_ty = try sema.resolveTypeFields(sema.typeOf(un));	15429	const union_ty = try sema.resolveTypeFields(sema.typeOf(un));
15418	const union_tag_ty = union_ty.unionTagType() orelse {	15430	const union_tag_ty = union_ty.unionTagType(mod) orelse {
15419	const msg = msg: {	15431	const msg = msg: {
15420	const msg = try sema.errMsg(block, un_src, "comparison of union and enum literal is only valid for tagged union types", .{});	15432	const msg = try sema.errMsg(block, un_src, "comparison of union and enum literal is only valid for tagged union types", .{});
15421	errdefer msg.destroy(sema.gpa);	15433	errdefer msg.destroy(sema.gpa);
...	@@ -16403,7 +16415,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -16403,7 +16415,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16403	try sema.resolveTypeLayout(ty); // Getting alignment requires type layout	16415	try sema.resolveTypeLayout(ty); // Getting alignment requires type layout
16404	const layout = union_ty.containerLayout(mod);	16416	const layout = union_ty.containerLayout(mod);
16405		16417
16406	const union_fields = union_ty.unionFields();	16418	const union_fields = union_ty.unionFields(mod);
16407	const union_field_vals = try fields_anon_decl.arena().alloc(Value, union_fields.count());	16419	const union_field_vals = try fields_anon_decl.arena().alloc(Value, union_fields.count());
16408		16420
16409	for (union_field_vals, 0..) \|*field_val, i\| {	16421	for (union_field_vals, 0..) \|*field_val, i\| {
...	@@ -16458,7 +16470,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -16458,7 +16470,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16458		16470
16459	const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, union_ty.getNamespace(mod));	16471	const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, union_ty.getNamespace(mod));
16460		16472
16461	const enum_tag_ty_val = if (union_ty.unionTagType()) \|tag_ty\| v: {	16473	const enum_tag_ty_val = if (union_ty.unionTagType(mod)) \|tag_ty\| v: {
16462	const ty_val = try Value.Tag.ty.create(sema.arena, tag_ty);	16474	const ty_val = try Value.Tag.ty.create(sema.arena, tag_ty);
16463	break :v try Value.Tag.opt_payload.create(sema.arena, ty_val);	16475	break :v try Value.Tag.opt_payload.create(sema.arena, ty_val);
16464	} else Value.null;	16476	} else Value.null;
...	@@ -17877,12 +17889,13 @@ fn unionInit(	...	@@ -17877,12 +17889,13 @@ fn unionInit(
17877	field_name: []const u8,	17889	field_name: []const u8,
17878	field_src: LazySrcLoc,	17890	field_src: LazySrcLoc,
17879	) CompileError!Air.Inst.Ref {	17891	) CompileError!Air.Inst.Ref {
		17892	const mod = sema.mod;
17880	const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_src);	17893	const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_src);
17881	const field = union_ty.unionFields().values()[field_index];	17894	const field = union_ty.unionFields(mod).values()[field_index];
17882	const init = try sema.coerce(block, field.ty, uncasted_init, init_src);	17895	const init = try sema.coerce(block, field.ty, uncasted_init, init_src);
17883		17896
17884	if (try sema.resolveMaybeUndefVal(init)) \|init_val\| {	17897	if (try sema.resolveMaybeUndefVal(init)) \|init_val\| {
17885	const tag_ty = union_ty.unionTagTypeHypothetical();	17898	const tag_ty = union_ty.unionTagTypeHypothetical(mod);
17886	const enum_field_index = @intCast(u32, tag_ty.enumFieldIndex(field_name).?);	17899	const enum_field_index = @intCast(u32, tag_ty.enumFieldIndex(field_name).?);
17887	const tag_val = try Value.Tag.enum_field_index.create(sema.arena, enum_field_index);	17900	const tag_val = try Value.Tag.enum_field_index.create(sema.arena, enum_field_index);
17888	return sema.addConstant(union_ty, try Value.Tag.@"union".create(sema.arena, .{	17901	return sema.addConstant(union_ty, try Value.Tag.@"union".create(sema.arena, .{
...	@@ -17983,7 +17996,7 @@ fn zirStructInit(	...	@@ -17983,7 +17996,7 @@ fn zirStructInit(
17983	const field_type_extra = sema.code.extraData(Zir.Inst.FieldType, field_type_data.payload_index).data;	17996	const field_type_extra = sema.code.extraData(Zir.Inst.FieldType, field_type_data.payload_index).data;
17984	const field_name = sema.code.nullTerminatedString(field_type_extra.name_start);	17997	const field_name = sema.code.nullTerminatedString(field_type_extra.name_start);
17985	const field_index = try sema.unionFieldIndex(block, resolved_ty, field_name, field_src);	17998	const field_index = try sema.unionFieldIndex(block, resolved_ty, field_name, field_src);
17986	const tag_ty = resolved_ty.unionTagTypeHypothetical();	17999	const tag_ty = resolved_ty.unionTagTypeHypothetical(mod);
17987	const enum_field_index = @intCast(u32, tag_ty.enumFieldIndex(field_name).?);	18000	const enum_field_index = @intCast(u32, tag_ty.enumFieldIndex(field_name).?);
17988	const tag_val = try Value.Tag.enum_field_index.create(sema.arena, enum_field_index);	18001	const tag_val = try Value.Tag.enum_field_index.create(sema.arena, enum_field_index);
17989		18002
...	@@ -18006,7 +18019,7 @@ fn zirStructInit(	...	@@ -18006,7 +18019,7 @@ fn zirStructInit(
18006	const alloc = try block.addTy(.alloc, alloc_ty);	18019	const alloc = try block.addTy(.alloc, alloc_ty);
18007	const field_ptr = try sema.unionFieldPtr(block, field_src, alloc, field_name, field_src, resolved_ty, true);	18020	const field_ptr = try sema.unionFieldPtr(block, field_src, alloc, field_name, field_src, resolved_ty, true);
18008	try sema.storePtr(block, src, field_ptr, init_inst);	18021	try sema.storePtr(block, src, field_ptr, init_inst);
18009	const new_tag = try sema.addConstant(resolved_ty.unionTagTypeHypothetical(), tag_val);	18022	const new_tag = try sema.addConstant(resolved_ty.unionTagTypeHypothetical(mod), tag_val);
18010	_ = try block.addBinOp(.set_union_tag, alloc, new_tag);	18023	_ = try block.addBinOp(.set_union_tag, alloc, new_tag);
18011	return sema.makePtrConst(block, alloc);	18024	return sema.makePtrConst(block, alloc);
18012	}	18025	}
...	@@ -18544,7 +18557,7 @@ fn fieldType(	...	@@ -18544,7 +18557,7 @@ fn fieldType(
18544	return sema.addType(field.ty);	18557	return sema.addType(field.ty);
18545	},	18558	},
18546	.Union => {	18559	.Union => {
18547	const union_obj = cur_ty.cast(Type.Payload.Union).?.data;	18560	const union_obj = mod.typeToUnion(cur_ty).?;
18548	const field = union_obj.fields.get(field_name) orelse	18561	const field = union_obj.fields.get(field_name) orelse
18549	return sema.failWithBadUnionFieldAccess(block, union_obj, field_src, field_name);	18562	return sema.failWithBadUnionFieldAccess(block, union_obj, field_src, field_name);
18550	return sema.addType(field.ty);	18563	return sema.addType(field.ty);
...	@@ -18726,7 +18739,7 @@ fn zirTagName(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air	...	@@ -18726,7 +18739,7 @@ fn zirTagName(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air
18726	return sema.addStrLit(block, bytes);	18739	return sema.addStrLit(block, bytes);
18727	},	18740	},
18728	.Enum => operand_ty,	18741	.Enum => operand_ty,
18729	.Union => operand_ty.unionTagType() orelse {	18742	.Union => operand_ty.unionTagType(mod) orelse {
18730	const msg = msg: {	18743	const msg = msg: {
18731	const msg = try sema.errMsg(block, src, "union '{}' is untagged", .{	18744	const msg = try sema.errMsg(block, src, "union '{}' is untagged", .{
18732	operand_ty.fmt(sema.mod),	18745	operand_ty.fmt(sema.mod),
...	@@ -19245,42 +19258,53 @@ fn zirReify(	...	@@ -19245,42 +19258,53 @@ fn zirReify(
19245	errdefer new_decl_arena.deinit();	19258	errdefer new_decl_arena.deinit();
19246	const new_decl_arena_allocator = new_decl_arena.allocator();	19259	const new_decl_arena_allocator = new_decl_arena.allocator();
19247		19260
19248	const union_obj = try new_decl_arena_allocator.create(Module.Union);	19261	// Because these three things each reference each other, `undefined`
19249	const type_tag = if (!tag_type_val.isNull(mod))	19262	// placeholders are used before being set after the union type gains an
19250	Type.Tag.union_tagged	19263	// InternPool index.
19251	else if (layout != .Auto)	19264
19252	Type.Tag.@"union"
19253	else switch (mod.optimizeMode()) {
19254	.Debug, .ReleaseSafe => Type.Tag.union_safety_tagged,
19255	.ReleaseFast, .ReleaseSmall => Type.Tag.@"union",
19256	};
19257	const union_payload = try new_decl_arena_allocator.create(Type.Payload.Union);
19258	union_payload.* = .{
19259	.base = .{ .tag = type_tag },
19260	.data = union_obj,
19261	};
19262	const union_ty = Type.initPayload(&union_payload.base);
19263	const new_union_val = try Value.Tag.ty.create(new_decl_arena_allocator, union_ty);
19264	const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{	19265	const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{
19265	.ty = Type.type,	19266	.ty = Type.type,
19266	.val = new_union_val,	19267	.val = undefined,
19267	}, name_strategy, "union", inst);	19268	}, name_strategy, "union", inst);
19268	const new_decl = mod.declPtr(new_decl_index);	19269	const new_decl = mod.declPtr(new_decl_index);
19269	new_decl.owns_tv = true;	19270	new_decl.owns_tv = true;
19270	errdefer mod.abortAnonDecl(new_decl_index);	19271	errdefer mod.abortAnonDecl(new_decl_index);
19271	union_obj.* = .{	19272
		19273	const new_namespace_index = try mod.createNamespace(.{
		19274	.parent = block.namespace.toOptional(),
		19275	.ty = undefined,
		19276	.file_scope = block.getFileScope(mod),
		19277	});
		19278	const new_namespace = mod.namespacePtr(new_namespace_index);
		19279	errdefer mod.destroyNamespace(new_namespace_index);
		19280
		19281	const union_index = try mod.createUnion(.{
19272	.owner_decl = new_decl_index,	19282	.owner_decl = new_decl_index,
19273	.tag_ty = Type.null,	19283	.tag_ty = Type.null,
19274	.fields = .{},	19284	.fields = .{},
19275	.zir_index = inst,	19285	.zir_index = inst,
19276	.layout = layout,	19286	.layout = layout,
19277	.status = .have_field_types,	19287	.status = .have_field_types,
19278	.namespace = try mod.createNamespace(.{	19288	.namespace = new_namespace_index,
19279	.parent = block.namespace.toOptional(),	19289	});
19280	.ty = union_ty,	19290	const union_obj = mod.unionPtr(union_index);
19281	.file_scope = block.getFileScope(mod),	19291	errdefer mod.destroyUnion(union_index);
19282	}),	19292
19283	};	19293	const union_ty = try mod.intern_pool.get(gpa, .{ .union_type = .{
		19294	.index = union_index,
		19295	.runtime_tag = if (!tag_type_val.isNull(mod))
		19296	.tagged
		19297	else if (layout != .Auto)
		19298	.none
		19299	else switch (mod.optimizeMode()) {
		19300	.Debug, .ReleaseSafe => .safety,
		19301	.ReleaseFast, .ReleaseSmall => .none,
		19302	},
		19303	} });
		19304	errdefer mod.intern_pool.remove(union_ty);
		19305
		19306	new_decl.val = union_ty.toValue();
		19307	new_namespace.ty = union_ty.toType();
19284		19308
19285	// Tag type	19309	// Tag type
19286	var tag_ty_field_names: ?Module.EnumFull.NameMap = null;	19310	var tag_ty_field_names: ?Module.EnumFull.NameMap = null;
...	@@ -21981,8 +22005,8 @@ fn zirFieldParentPtr(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileEr	...	@@ -21981,8 +22005,8 @@ fn zirFieldParentPtr(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileEr
21981	ptr_ty_data.@"align" = blk: {	22005	ptr_ty_data.@"align" = blk: {
21982	if (mod.typeToStruct(parent_ty)) \|struct_obj\| {	22006	if (mod.typeToStruct(parent_ty)) \|struct_obj\| {
21983	break :blk struct_obj.fields.values()[field_index].abi_align;	22007	break :blk struct_obj.fields.values()[field_index].abi_align;
21984	} else if (parent_ty.cast(Type.Payload.Union)) \|union_obj\| {	22008	} else if (mod.typeToUnion(parent_ty)) \|union_obj\| {
21985	break :blk union_obj.data.fields.values()[field_index].abi_align;	22009	break :blk union_obj.fields.values()[field_index].abi_align;
21986	} else {	22010	} else {
21987	break :blk 0;	22011	break :blk 0;
21988	}	22012	}
...	@@ -23443,8 +23467,7 @@ fn explainWhyTypeIsComptimeInner(	...	@@ -23443,8 +23467,7 @@ fn explainWhyTypeIsComptimeInner(
23443	.Union => {	23467	.Union => {
23444	if ((try type_set.getOrPutContext(sema.gpa, ty, .{ .mod = mod })).found_existing) return;	23468	if ((try type_set.getOrPutContext(sema.gpa, ty, .{ .mod = mod })).found_existing) return;
23445		23469
23446	if (ty.cast(Type.Payload.Union)) \|payload\| {	23470	if (mod.typeToUnion(ty)) \|union_obj\| {
23447	const union_obj = payload.data;
23448	for (union_obj.fields.values(), 0..) \|field, i\| {	23471	for (union_obj.fields.values(), 0..) \|field, i\| {
23449	const field_src_loc = union_obj.fieldSrcLoc(sema.mod, .{	23472	const field_src_loc = union_obj.fieldSrcLoc(sema.mod, .{
23450	.index = i,	23473	.index = i,
...	@@ -24144,7 +24167,7 @@ fn fieldVal(	...	@@ -24144,7 +24167,7 @@ fn fieldVal(
24144	}	24167	}
24145	}	24168	}
24146	const union_ty = try sema.resolveTypeFields(child_type);	24169	const union_ty = try sema.resolveTypeFields(child_type);
24147	if (union_ty.unionTagType()) \|enum_ty\| {	24170	if (union_ty.unionTagType(mod)) \|enum_ty\| {
24148	if (enum_ty.enumFieldIndex(field_name)) \|field_index_usize\| {	24171	if (enum_ty.enumFieldIndex(field_name)) \|field_index_usize\| {
24149	const field_index = @intCast(u32, field_index_usize);	24172	const field_index = @intCast(u32, field_index_usize);
24150	return sema.addConstant(	24173	return sema.addConstant(
...	@@ -24358,7 +24381,7 @@ fn fieldPtr(	...	@@ -24358,7 +24381,7 @@ fn fieldPtr(
24358	}	24381	}
24359	}	24382	}
24360	const union_ty = try sema.resolveTypeFields(child_type);	24383	const union_ty = try sema.resolveTypeFields(child_type);
24361	if (union_ty.unionTagType()) \|enum_ty\| {	24384	if (union_ty.unionTagType(mod)) \|enum_ty\| {
24362	if (enum_ty.enumFieldIndex(field_name)) \|field_index\| {	24385	if (enum_ty.enumFieldIndex(field_name)) \|field_index\| {
24363	const field_index_u32 = @intCast(u32, field_index);	24386	const field_index_u32 = @intCast(u32, field_index);
24364	var anon_decl = try block.startAnonDecl();	24387	var anon_decl = try block.startAnonDecl();
...	@@ -24489,7 +24512,7 @@ fn fieldCallBind(	...	@@ -24489,7 +24512,7 @@ fn fieldCallBind(
24489	},	24512	},
24490	.Union => {	24513	.Union => {
24491	const union_ty = try sema.resolveTypeFields(concrete_ty);	24514	const union_ty = try sema.resolveTypeFields(concrete_ty);
24492	const fields = union_ty.unionFields();	24515	const fields = union_ty.unionFields(mod);
24493	const field_index_usize = fields.getIndex(field_name) orelse break :find_field;	24516	const field_index_usize = fields.getIndex(field_name) orelse break :find_field;
24494	const field_index = @intCast(u32, field_index_usize);	24517	const field_index = @intCast(u32, field_index_usize);
24495	const field = fields.values()[field_index];	24518	const field = fields.values()[field_index];
...	@@ -24964,7 +24987,7 @@ fn unionFieldPtr(	...	@@ -24964,7 +24987,7 @@ fn unionFieldPtr(
24964		24987
24965	const union_ptr_ty = sema.typeOf(union_ptr);	24988	const union_ptr_ty = sema.typeOf(union_ptr);
24966	const union_ty = try sema.resolveTypeFields(unresolved_union_ty);	24989	const union_ty = try sema.resolveTypeFields(unresolved_union_ty);
24967	const union_obj = union_ty.cast(Type.Payload.Union).?.data;	24990	const union_obj = mod.typeToUnion(union_ty).?;
24968	const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_name_src);	24991	const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_name_src);
24969	const field = union_obj.fields.values()[field_index];	24992	const field = union_obj.fields.values()[field_index];
24970	const ptr_field_ty = try Type.ptr(arena, mod, .{	24993	const ptr_field_ty = try Type.ptr(arena, mod, .{
...	@@ -25028,7 +25051,7 @@ fn unionFieldPtr(	...	@@ -25028,7 +25051,7 @@ fn unionFieldPtr(
25028		25051
25029	try sema.requireRuntimeBlock(block, src, null);	25052	try sema.requireRuntimeBlock(block, src, null);
25030	if (!initializing and union_obj.layout == .Auto and block.wantSafety() and	25053	if (!initializing and union_obj.layout == .Auto and block.wantSafety() and
25031	union_ty.unionTagTypeSafety() != null and union_obj.fields.count() > 1)	25054	union_ty.unionTagTypeSafety(mod) != null and union_obj.fields.count() > 1)
25032	{	25055	{
25033	const wanted_tag_val = try Value.Tag.enum_field_index.create(sema.arena, enum_field_index);	25056	const wanted_tag_val = try Value.Tag.enum_field_index.create(sema.arena, enum_field_index);
25034	const wanted_tag = try sema.addConstant(union_obj.tag_ty, wanted_tag_val);	25057	const wanted_tag = try sema.addConstant(union_obj.tag_ty, wanted_tag_val);
...	@@ -25057,7 +25080,7 @@ fn unionFieldVal(	...	@@ -25057,7 +25080,7 @@ fn unionFieldVal(
25057	assert(unresolved_union_ty.zigTypeTag(mod) == .Union);	25080	assert(unresolved_union_ty.zigTypeTag(mod) == .Union);
25058		25081
25059	const union_ty = try sema.resolveTypeFields(unresolved_union_ty);	25082	const union_ty = try sema.resolveTypeFields(unresolved_union_ty);
25060	const union_obj = union_ty.cast(Type.Payload.Union).?.data;	25083	const union_obj = mod.typeToUnion(union_ty).?;
25061	const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_name_src);	25084	const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_name_src);
25062	const field = union_obj.fields.values()[field_index];	25085	const field = union_obj.fields.values()[field_index];
25063	const enum_field_index = @intCast(u32, union_obj.tag_ty.enumFieldIndex(field_name).?);	25086	const enum_field_index = @intCast(u32, union_obj.tag_ty.enumFieldIndex(field_name).?);
...	@@ -25103,7 +25126,7 @@ fn unionFieldVal(	...	@@ -25103,7 +25126,7 @@ fn unionFieldVal(
25103		25126
25104	try sema.requireRuntimeBlock(block, src, null);	25127	try sema.requireRuntimeBlock(block, src, null);
25105	if (union_obj.layout == .Auto and block.wantSafety() and	25128	if (union_obj.layout == .Auto and block.wantSafety() and
25106	union_ty.unionTagTypeSafety() != null and union_obj.fields.count() > 1)	25129	union_ty.unionTagTypeSafety(mod) != null and union_obj.fields.count() > 1)
25107	{	25130	{
25108	const wanted_tag_val = try Value.Tag.enum_field_index.create(sema.arena, enum_field_index);	25131	const wanted_tag_val = try Value.Tag.enum_field_index.create(sema.arena, enum_field_index);
25109	const wanted_tag = try sema.addConstant(union_obj.tag_ty, wanted_tag_val);	25132	const wanted_tag = try sema.addConstant(union_obj.tag_ty, wanted_tag_val);
...	@@ -26189,7 +26212,7 @@ fn coerceExtra(	...	@@ -26189,7 +26212,7 @@ fn coerceExtra(
26189	},	26212	},
26190	.Union => blk: {	26213	.Union => blk: {
26191	// union to its own tag type	26214	// union to its own tag type
26192	const union_tag_ty = inst_ty.unionTagType() orelse break :blk;	26215	const union_tag_ty = inst_ty.unionTagType(mod) orelse break :blk;
26193	if (union_tag_ty.eql(dest_ty, sema.mod)) {	26216	if (union_tag_ty.eql(dest_ty, sema.mod)) {
26194	return sema.unionToTag(block, dest_ty, inst, inst_src);	26217	return sema.unionToTag(block, dest_ty, inst, inst_src);
26195	}	26218	}
...	@@ -28622,7 +28645,7 @@ fn coerceEnumToUnion(	...	@@ -28622,7 +28645,7 @@ fn coerceEnumToUnion(
28622	const mod = sema.mod;	28645	const mod = sema.mod;
28623	const inst_ty = sema.typeOf(inst);	28646	const inst_ty = sema.typeOf(inst);
28624		28647
28625	const tag_ty = union_ty.unionTagType() orelse {	28648	const tag_ty = union_ty.unionTagType(mod) orelse {
28626	const msg = msg: {	28649	const msg = msg: {
28627	const msg = try sema.errMsg(block, inst_src, "expected type '{}', found '{}'", .{	28650	const msg = try sema.errMsg(block, inst_src, "expected type '{}', found '{}'", .{
28628	union_ty.fmt(sema.mod), inst_ty.fmt(sema.mod),	28651	union_ty.fmt(sema.mod), inst_ty.fmt(sema.mod),
...	@@ -28649,7 +28672,7 @@ fn coerceEnumToUnion(	...	@@ -28649,7 +28672,7 @@ fn coerceEnumToUnion(
28649	return sema.failWithOwnedErrorMsg(msg);	28672	return sema.failWithOwnedErrorMsg(msg);
28650	};	28673	};
28651		28674
28652	const union_obj = union_ty.cast(Type.Payload.Union).?.data;	28675	const union_obj = mod.typeToUnion(union_ty).?;
28653	const field = union_obj.fields.values()[field_index];	28676	const field = union_obj.fields.values()[field_index];
28654	const field_ty = try sema.resolveTypeFields(field.ty);	28677	const field_ty = try sema.resolveTypeFields(field.ty);
28655	if (field_ty.zigTypeTag(mod) == .NoReturn) {	28678	if (field_ty.zigTypeTag(mod) == .NoReturn) {
...	@@ -28679,10 +28702,7 @@ fn coerceEnumToUnion(	...	@@ -28679,10 +28702,7 @@ fn coerceEnumToUnion(
28679	return sema.failWithOwnedErrorMsg(msg);	28702	return sema.failWithOwnedErrorMsg(msg);
28680	};	28703	};
28681		28704
28682	return sema.addConstant(union_ty, try Value.Tag.@"union".create(sema.arena, .{	28705	return sema.addConstant(union_ty, try mod.unionValue(union_ty, val, opv));
28683	.tag = val,
28684	.val = opv,
28685	}));
28686	}	28706	}
28687		28707
28688	try sema.requireRuntimeBlock(block, inst_src, null);	28708	try sema.requireRuntimeBlock(block, inst_src, null);
...	@@ -28699,7 +28719,7 @@ fn coerceEnumToUnion(	...	@@ -28699,7 +28719,7 @@ fn coerceEnumToUnion(
28699	return sema.failWithOwnedErrorMsg(msg);	28719	return sema.failWithOwnedErrorMsg(msg);
28700	}	28720	}
28701		28721
28702	const union_obj = union_ty.cast(Type.Payload.Union).?.data;	28722	const union_obj = mod.typeToUnion(union_ty).?;
28703	{	28723	{
28704	var msg: ?*Module.ErrorMsg = null;	28724	var msg: ?*Module.ErrorMsg = null;
28705	errdefer if (msg) \|some\| some.destroy(sema.gpa);	28725	errdefer if (msg) \|some\| some.destroy(sema.gpa);
...	@@ -29350,10 +29370,13 @@ fn analyzeRef(	...	@@ -29350,10 +29370,13 @@ fn analyzeRef(
29350	const operand_ty = sema.typeOf(operand);	29370	const operand_ty = sema.typeOf(operand);
29351		29371
29352	if (try sema.resolveMaybeUndefVal(operand)) \|val\| {	29372	if (try sema.resolveMaybeUndefVal(operand)) \|val\| {
29353	switch (val.tag()) {	29373	switch (val.ip_index) {
29354	.extern_fn, .function => {	29374	.none => switch (val.tag()) {
29355	const decl_index = val.pointerDecl().?;	29375	.extern_fn, .function => {
29356	return sema.analyzeDeclRef(decl_index);	29376	const decl_index = val.pointerDecl().?;
		29377	return sema.analyzeDeclRef(decl_index);
		29378	},
		29379	else => {},
29357	},	29380	},
29358	else => {},	29381	else => {},
29359	}	29382	}
...	@@ -31523,8 +31546,9 @@ fn checkMemOperand(sema: Sema, block: Block, src: LazySrcLoc, ty: Type) !void	...	@@ -31523,8 +31546,9 @@ fn checkMemOperand(sema: Sema, block: Block, src: LazySrcLoc, ty: Type) !void
31523	}	31546	}
31524		31547
31525	fn resolveUnionLayout(sema: *Sema, ty: Type) CompileError!void {	31548	fn resolveUnionLayout(sema: *Sema, ty: Type) CompileError!void {
		31549	const mod = sema.mod;
31526	const resolved_ty = try sema.resolveTypeFields(ty);	31550	const resolved_ty = try sema.resolveTypeFields(ty);
31527	const union_obj = resolved_ty.cast(Type.Payload.Union).?.data;	31551	const union_obj = mod.typeToUnion(resolved_ty).?;
31528	switch (union_obj.status) {	31552	switch (union_obj.status) {
31529	.none, .have_field_types => {},	31553	.none, .have_field_types => {},
31530	.field_types_wip, .layout_wip => {	31554	.field_types_wip, .layout_wip => {
...	@@ -31617,27 +31641,6 @@ pub fn resolveTypeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {	...	@@ -31617,27 +31641,6 @@ pub fn resolveTypeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {
31617	return false;	31641	return false;
31618	},	31642	},
31619		31643
31620	.@"union", .union_safety_tagged, .union_tagged => {
31621	const union_obj = ty.cast(Type.Payload.Union).?.data;
31622	switch (union_obj.requires_comptime) {
31623	.no, .wip => return false,
31624	.yes => return true,
31625	.unknown => {
31626	var requires_comptime = false;
31627	union_obj.requires_comptime = .wip;
31628	for (union_obj.fields.values()) \|field\| {
31629	if (try sema.resolveTypeRequiresComptime(field.ty)) requires_comptime = true;
31630	}
31631	if (requires_comptime) {
31632	union_obj.requires_comptime = .yes;
31633	} else {
31634	union_obj.requires_comptime = .no;
31635	}
31636	return requires_comptime;
31637	},
31638	}
31639	},
31640
31641	.error_union => return sema.resolveTypeRequiresComptime(ty.errorUnionPayload()),	31644	.error_union => return sema.resolveTypeRequiresComptime(ty.errorUnionPayload()),
31642	.anyframe_T => {	31645	.anyframe_T => {
31643	const child_ty = ty.castTag(.anyframe_T).?.data;	31646	const child_ty = ty.castTag(.anyframe_T).?.data;
...	@@ -31734,10 +31737,31 @@ pub fn resolveTypeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {	...	@@ -31734,10 +31737,31 @@ pub fn resolveTypeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {
31734	}	31737	}
31735	},	31738	},
31736		31739
31737	.union_type => @panic("TODO"),	31740	.union_type => \|union_type\| {
		31741	const union_obj = mod.unionPtr(union_type.index);
		31742	switch (union_obj.requires_comptime) {
		31743	.no, .wip => return false,
		31744	.yes => return true,
		31745	.unknown => {
		31746	var requires_comptime = false;
		31747	union_obj.requires_comptime = .wip;
		31748	for (union_obj.fields.values()) \|field\| {
		31749	if (try sema.resolveTypeRequiresComptime(field.ty)) requires_comptime = true;
		31750	}
		31751	if (requires_comptime) {
		31752	union_obj.requires_comptime = .yes;
		31753	} else {
		31754	union_obj.requires_comptime = .no;
		31755	}
		31756	return requires_comptime;
		31757	},
		31758	}
		31759	},
		31760
31738	.opaque_type => false,	31761	.opaque_type => false,
31739		31762
31740	// values, not types	31763	// values, not types
		31764	.un => unreachable,
31741	.simple_value => unreachable,	31765	.simple_value => unreachable,
31742	.extern_func => unreachable,	31766	.extern_func => unreachable,
31743	.int => unreachable,	31767	.int => unreachable,
...	@@ -31829,8 +31853,9 @@ fn resolveStructFully(sema: *Sema, ty: Type) CompileError!void {	...	@@ -31829,8 +31853,9 @@ fn resolveStructFully(sema: *Sema, ty: Type) CompileError!void {
31829	fn resolveUnionFully(sema: *Sema, ty: Type) CompileError!void {	31853	fn resolveUnionFully(sema: *Sema, ty: Type) CompileError!void {
31830	try sema.resolveUnionLayout(ty);	31854	try sema.resolveUnionLayout(ty);
31831		31855
		31856	const mod = sema.mod;
31832	const resolved_ty = try sema.resolveTypeFields(ty);	31857	const resolved_ty = try sema.resolveTypeFields(ty);
31833	const union_obj = resolved_ty.cast(Type.Payload.Union).?.data;	31858	const union_obj = mod.typeToUnion(resolved_ty).?;
31834	switch (union_obj.status) {	31859	switch (union_obj.status) {
31835	.none, .have_field_types, .field_types_wip, .layout_wip, .have_layout => {},	31860	.none, .have_field_types, .field_types_wip, .layout_wip, .have_layout => {},
31836	.fully_resolved_wip, .fully_resolved => return,	31861	.fully_resolved_wip, .fully_resolved => return,
...	@@ -31858,15 +31883,8 @@ pub fn resolveTypeFields(sema: *Sema, ty: Type) CompileError!Type {	...	@@ -31858,15 +31883,8 @@ pub fn resolveTypeFields(sema: *Sema, ty: Type) CompileError!Type {
31858	const mod = sema.mod;	31883	const mod = sema.mod;
31859		31884
31860	switch (ty.ip_index) {	31885	switch (ty.ip_index) {
31861	.none => switch (ty.tag()) {	31886	// TODO: After the InternPool transition is complete, change this to `unreachable`.
31862	.@"union", .union_safety_tagged, .union_tagged => {	31887	.none => return ty,
31863	const union_obj = ty.cast(Type.Payload.Union).?.data;
31864	try sema.resolveTypeFieldsUnion(ty, union_obj);
31865	return ty;
31866	},
31867
31868	else => return ty,
31869	},
31870		31888
31871	.u1_type,	31889	.u1_type,
31872	.u8_type,	31890	.u8_type,
...	@@ -31957,7 +31975,12 @@ pub fn resolveTypeFields(sema: *Sema, ty: Type) CompileError!Type {	...	@@ -31957,7 +31975,12 @@ pub fn resolveTypeFields(sema: *Sema, ty: Type) CompileError!Type {
31957	try sema.resolveTypeFieldsStruct(ty, struct_obj);	31975	try sema.resolveTypeFieldsStruct(ty, struct_obj);
31958	return ty;	31976	return ty;
31959	},	31977	},
31960	.union_type => @panic("TODO"),	31978	.union_type => \|union_type\| {
		31979	const union_obj = mod.unionPtr(union_type.index);
		31980	try sema.resolveTypeFieldsUnion(ty, union_obj);
		31981	return ty;
		31982	},
		31983
31961	else => return ty,	31984	else => return ty,
31962	},	31985	},
31963	}	31986	}
...	@@ -33123,32 +33146,6 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {	...	@@ -33123,32 +33146,6 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
33123	return null;	33146	return null;
33124	}	33147	}
33125	},	33148	},
33126	.@"union", .union_safety_tagged, .union_tagged => {
33127	const resolved_ty = try sema.resolveTypeFields(ty);
33128	const union_obj = resolved_ty.cast(Type.Payload.Union).?.data;
33129	const tag_val = (try sema.typeHasOnePossibleValue(union_obj.tag_ty)) orelse
33130	return null;
33131	const fields = union_obj.fields.values();
33132	if (fields.len == 0) return Value.@"unreachable";
33133	const only_field = fields[0];
33134	if (only_field.ty.eql(resolved_ty, sema.mod)) {
33135	const msg = try Module.ErrorMsg.create(
33136	sema.gpa,
33137	union_obj.srcLoc(sema.mod),
33138	"union '{}' depends on itself",
33139	.{ty.fmt(sema.mod)},
33140	);
33141	try sema.addFieldErrNote(resolved_ty, 0, msg, "while checking this field", .{});
33142	return sema.failWithOwnedErrorMsg(msg);
33143	}
33144	const val_val = (try sema.typeHasOnePossibleValue(only_field.ty)) orelse
33145	return null;
33146	// TODO make this not allocate.
33147	return try Value.Tag.@"union".create(sema.arena, .{
33148	.tag = tag_val,
33149	.val = val_val,
33150	});
33151	},
33152		33149
33153	.array => {	33150	.array => {
33154	if (ty.arrayLen(mod) == 0)	33151	if (ty.arrayLen(mod) == 0)
...	@@ -33268,10 +33265,37 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {	...	@@ -33268,10 +33265,37 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
33268	return empty.toValue();	33265	return empty.toValue();
33269	},	33266	},
33270		33267
33271	.union_type => @panic("TODO"),	33268	.union_type => \|union_type\| {
		33269	const resolved_ty = try sema.resolveTypeFields(ty);
		33270	const union_obj = mod.unionPtr(union_type.index);
		33271	const tag_val = (try sema.typeHasOnePossibleValue(union_obj.tag_ty)) orelse
		33272	return null;
		33273	const fields = union_obj.fields.values();
		33274	if (fields.len == 0) return Value.@"unreachable";
		33275	const only_field = fields[0];
		33276	if (only_field.ty.eql(resolved_ty, sema.mod)) {
		33277	const msg = try Module.ErrorMsg.create(
		33278	sema.gpa,
		33279	union_obj.srcLoc(sema.mod),
		33280	"union '{}' depends on itself",
		33281	.{ty.fmt(sema.mod)},
		33282	);
		33283	try sema.addFieldErrNote(resolved_ty, 0, msg, "while checking this field", .{});
		33284	return sema.failWithOwnedErrorMsg(msg);
		33285	}
		33286	const val_val = (try sema.typeHasOnePossibleValue(only_field.ty)) orelse
		33287	return null;
		33288	const only = try mod.intern(.{ .un = .{
		33289	.ty = resolved_ty.ip_index,
		33290	.tag = tag_val.ip_index,
		33291	.val = val_val.ip_index,
		33292	} });
		33293	return only.toValue();
		33294	},
33272	.opaque_type => null,	33295	.opaque_type => null,
33273		33296
33274	// values, not types	33297	// values, not types
		33298	.un => unreachable,
33275	.simple_value => unreachable,	33299	.simple_value => unreachable,
33276	.extern_func => unreachable,	33300	.extern_func => unreachable,
33277	.int => unreachable,	33301	.int => unreachable,
...	@@ -33710,30 +33734,6 @@ pub fn typeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {	...	@@ -33710,30 +33734,6 @@ pub fn typeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {
33710	return false;	33734	return false;
33711	},	33735	},
33712		33736
33713	.@"union", .union_safety_tagged, .union_tagged => {
33714	const union_obj = ty.cast(Type.Payload.Union).?.data;
33715	switch (union_obj.requires_comptime) {
33716	.no, .wip => return false,
33717	.yes => return true,
33718	.unknown => {
33719	if (union_obj.status == .field_types_wip)
33720	return false;
33721
33722	try sema.resolveTypeFieldsUnion(ty, union_obj);
33723
33724	union_obj.requires_comptime = .wip;
33725	for (union_obj.fields.values()) \|field\| {
33726	if (try sema.typeRequiresComptime(field.ty)) {
33727	union_obj.requires_comptime = .yes;
33728	return true;
33729	}
33730	}
33731	union_obj.requires_comptime = .no;
33732	return false;
33733	},
33734	}
33735	},
33736
33737	.error_union => return sema.typeRequiresComptime(ty.errorUnionPayload()),	33737	.error_union => return sema.typeRequiresComptime(ty.errorUnionPayload()),
33738	.anyframe_T => {	33738	.anyframe_T => {
33739	const child_ty = ty.castTag(.anyframe_T).?.data;	33739	const child_ty = ty.castTag(.anyframe_T).?.data;
...	@@ -33837,10 +33837,34 @@ pub fn typeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {	...	@@ -33837,10 +33837,34 @@ pub fn typeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {
33837	}	33837	}
33838	},	33838	},
33839		33839
33840	.union_type => @panic("TODO"),	33840	.union_type => \|union_type\| {
		33841	const union_obj = mod.unionPtr(union_type.index);
		33842	switch (union_obj.requires_comptime) {
		33843	.no, .wip => return false,
		33844	.yes => return true,
		33845	.unknown => {
		33846	if (union_obj.status == .field_types_wip)
		33847	return false;
		33848
		33849	try sema.resolveTypeFieldsUnion(ty, union_obj);
		33850
		33851	union_obj.requires_comptime = .wip;
		33852	for (union_obj.fields.values()) \|field\| {
		33853	if (try sema.typeRequiresComptime(field.ty)) {
		33854	union_obj.requires_comptime = .yes;
		33855	return true;
		33856	}
		33857	}
		33858	union_obj.requires_comptime = .no;
		33859	return false;
		33860	},
		33861	}
		33862	},
		33863
33841	.opaque_type => false,	33864	.opaque_type => false,
33842		33865
33843	// values, not types	33866	// values, not types
		33867	.un => unreachable,
33844	.simple_value => unreachable,	33868	.simple_value => unreachable,
33845	.extern_func => unreachable,	33869	.extern_func => unreachable,
33846	.int => unreachable,	33870	.int => unreachable,
...	@@ -33905,8 +33929,9 @@ fn unionFieldIndex(	...	@@ -33905,8 +33929,9 @@ fn unionFieldIndex(
33905	field_name: []const u8,	33929	field_name: []const u8,
33906	field_src: LazySrcLoc,	33930	field_src: LazySrcLoc,
33907	) !u32 {	33931	) !u32 {
		33932	const mod = sema.mod;
33908	const union_ty = try sema.resolveTypeFields(unresolved_union_ty);	33933	const union_ty = try sema.resolveTypeFields(unresolved_union_ty);
33909	const union_obj = union_ty.cast(Type.Payload.Union).?.data;	33934	const union_obj = mod.typeToUnion(union_ty).?;
33910	const field_index_usize = union_obj.fields.getIndex(field_name) orelse	33935	const field_index_usize = union_obj.fields.getIndex(field_name) orelse
33911	return sema.failWithBadUnionFieldAccess(block, union_obj, field_src, field_name);	33936	return sema.failWithBadUnionFieldAccess(block, union_obj, field_src, field_name);
33912	return @intCast(u32, field_index_usize);	33937	return @intCast(u32, field_index_usize);

src/TypedValue.zig+2-2

...	@@ -91,7 +91,7 @@ pub fn print(	...	@@ -91,7 +91,7 @@ pub fn print(
91	try writer.writeAll(".{ ");	91	try writer.writeAll(".{ ");
92		92
93	try print(.{	93	try print(.{
94	.ty = ty.cast(Type.Payload.Union).?.data.tag_ty,	94	.ty = mod.unionPtr(mod.intern_pool.indexToKey(ty.ip_index).union_type.index).tag_ty,
95	.val = union_val.tag,	95	.val = union_val.tag,
96	}, writer, level - 1, mod);	96	}, writer, level - 1, mod);
97	try writer.writeAll(" = ");	97	try writer.writeAll(" = ");
...	@@ -185,7 +185,7 @@ pub fn print(	...	@@ -185,7 +185,7 @@ pub fn print(
185	},	185	},
186	}	186	}
187	} else if (field_ptr.container_ty.zigTypeTag(mod) == .Union) {	187	} else if (field_ptr.container_ty.zigTypeTag(mod) == .Union) {
188	const field_name = field_ptr.container_ty.unionFields().keys()[field_ptr.field_index];	188	const field_name = field_ptr.container_ty.unionFields(mod).keys()[field_ptr.field_index];
189	return writer.print(".{s}", .{field_name});	189	return writer.print(".{s}", .{field_name});
190	} else if (field_ptr.container_ty.isSlice(mod)) {	190	} else if (field_ptr.container_ty.isSlice(mod)) {
191	switch (field_ptr.field_index) {	191	switch (field_ptr.field_index) {

src/arch/aarch64/abi.zig+2-2

...	@@ -79,7 +79,7 @@ fn countFloats(ty: Type, mod: Module, maybe_float_bits: ?u16) u8 {	...	@@ -79,7 +79,7 @@ fn countFloats(ty: Type, mod: Module, maybe_float_bits: ?u16) u8 {
79	const invalid = std.math.maxInt(u8);	79	const invalid = std.math.maxInt(u8);
80	switch (ty.zigTypeTag(mod)) {	80	switch (ty.zigTypeTag(mod)) {
81	.Union => {	81	.Union => {
82	const fields = ty.unionFields();	82	const fields = ty.unionFields(mod);
83	var max_count: u8 = 0;	83	var max_count: u8 = 0;
84	for (fields.values()) \|field\| {	84	for (fields.values()) \|field\| {
85	const field_count = countFloats(field.ty, mod, maybe_float_bits);	85	const field_count = countFloats(field.ty, mod, maybe_float_bits);
...	@@ -118,7 +118,7 @@ fn countFloats(ty: Type, mod: Module, maybe_float_bits: ?u16) u8 {	...	@@ -118,7 +118,7 @@ fn countFloats(ty: Type, mod: Module, maybe_float_bits: ?u16) u8 {
118	pub fn getFloatArrayType(ty: Type, mod: *Module) ?Type {	118	pub fn getFloatArrayType(ty: Type, mod: *Module) ?Type {
119	switch (ty.zigTypeTag(mod)) {	119	switch (ty.zigTypeTag(mod)) {
120	.Union => {	120	.Union => {
121	const fields = ty.unionFields();	121	const fields = ty.unionFields(mod);
122	for (fields.values()) \|field\| {	122	for (fields.values()) \|field\| {
123	if (getFloatArrayType(field.ty, mod)) \|some\| return some;	123	if (getFloatArrayType(field.ty, mod)) \|some\| return some;
124	}	124	}

src/arch/arm/abi.zig+2-2

...	@@ -62,7 +62,7 @@ pub fn classifyType(ty: Type, mod: *Module, ctx: Context) Class {	...	@@ -62,7 +62,7 @@ pub fn classifyType(ty: Type, mod: *Module, ctx: Context) Class {
62	const float_count = countFloats(ty, mod, &maybe_float_bits);	62	const float_count = countFloats(ty, mod, &maybe_float_bits);
63	if (float_count <= byval_float_count) return .byval;	63	if (float_count <= byval_float_count) return .byval;
64		64
65	for (ty.unionFields().values()) \|field\| {	65	for (ty.unionFields(mod).values()) \|field\| {
66	if (field.ty.bitSize(mod) > 32 or field.normalAlignment(mod) > 32) {	66	if (field.ty.bitSize(mod) > 32 or field.normalAlignment(mod) > 32) {
67	return Class.arrSize(bit_size, 64);	67	return Class.arrSize(bit_size, 64);
68	}	68	}
...	@@ -121,7 +121,7 @@ fn countFloats(ty: Type, mod: Module, maybe_float_bits: ?u16) u32 {	...	@@ -121,7 +121,7 @@ fn countFloats(ty: Type, mod: Module, maybe_float_bits: ?u16) u32 {
121	const invalid = std.math.maxInt(u32);	121	const invalid = std.math.maxInt(u32);
122	switch (ty.zigTypeTag(mod)) {	122	switch (ty.zigTypeTag(mod)) {
123	.Union => {	123	.Union => {
124	const fields = ty.unionFields();	124	const fields = ty.unionFields(mod);
125	var max_count: u32 = 0;	125	var max_count: u32 = 0;
126	for (fields.values()) \|field\| {	126	for (fields.values()) \|field\| {
127	const field_count = countFloats(field.ty, mod, maybe_float_bits);	127	const field_count = countFloats(field.ty, mod, maybe_float_bits);

src/arch/wasm/CodeGen.zig+5-5

src/arch/wasm/abi.zig+5-5

...	@@ -70,8 +70,8 @@ pub fn classifyType(ty: Type, mod: *Module) [2]Class {	...	@@ -70,8 +70,8 @@ pub fn classifyType(ty: Type, mod: *Module) [2]Class {
70	}	70	}
71	const layout = ty.unionGetLayout(mod);	71	const layout = ty.unionGetLayout(mod);
72	std.debug.assert(layout.tag_size == 0);	72	std.debug.assert(layout.tag_size == 0);
73	if (ty.unionFields().count() > 1) return memory;	73	if (ty.unionFields(mod).count() > 1) return memory;
74	return classifyType(ty.unionFields().values()[0].ty, mod);	74	return classifyType(ty.unionFields(mod).values()[0].ty, mod);
75	},	75	},
76	.ErrorUnion,	76	.ErrorUnion,
77	.Frame,	77	.Frame,
...	@@ -111,11 +111,11 @@ pub fn scalarType(ty: Type, mod: *Module) Type {	...	@@ -111,11 +111,11 @@ pub fn scalarType(ty: Type, mod: *Module) Type {
111	if (ty.containerLayout(mod) != .Packed) {	111	if (ty.containerLayout(mod) != .Packed) {
112	const layout = ty.unionGetLayout(mod);	112	const layout = ty.unionGetLayout(mod);
113	if (layout.payload_size == 0 and layout.tag_size != 0) {	113	if (layout.payload_size == 0 and layout.tag_size != 0) {
114	return scalarType(ty.unionTagTypeSafety().?, mod);	114	return scalarType(ty.unionTagTypeSafety(mod).?, mod);
115	}	115	}
116	std.debug.assert(ty.unionFields().count() == 1);	116	std.debug.assert(ty.unionFields(mod).count() == 1);
117	}	117	}
118	return scalarType(ty.unionFields().values()[0].ty, mod);	118	return scalarType(ty.unionFields(mod).values()[0].ty, mod);
119	},	119	},
120	else => return ty,	120	else => return ty,
121	}	121	}

src/arch/x86_64/CodeGen.zig+2-2

...	@@ -11410,9 +11410,9 @@ fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -11410,9 +11410,9 @@ fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
11410		11410
11411	const dst_mcv = try self.allocRegOrMem(inst, false);	11411	const dst_mcv = try self.allocRegOrMem(inst, false);
11412		11412
11413	const union_obj = union_ty.cast(Type.Payload.Union).?.data;	11413	const union_obj = mod.typeToUnion(union_ty).?;
11414	const field_name = union_obj.fields.keys()[extra.field_index];	11414	const field_name = union_obj.fields.keys()[extra.field_index];
11415	const tag_ty = union_ty.unionTagTypeSafety().?;	11415	const tag_ty = union_obj.tag_ty;
11416	const field_index = @intCast(u32, tag_ty.enumFieldIndex(field_name).?);	11416	const field_index = @intCast(u32, tag_ty.enumFieldIndex(field_name).?);
11417	var tag_pl = Value.Payload.U32{ .base = .{ .tag = .enum_field_index }, .data = field_index };	11417	var tag_pl = Value.Payload.U32{ .base = .{ .tag = .enum_field_index }, .data = field_index };
11418	const tag_val = Value.initPayload(&tag_pl.base);	11418	const tag_val = Value.initPayload(&tag_pl.base);

src/arch/x86_64/abi.zig+1-1

...	@@ -338,7 +338,7 @@ pub fn classifySystemV(ty: Type, mod: *Module, ctx: Context) [8]Class {	...	@@ -338,7 +338,7 @@ pub fn classifySystemV(ty: Type, mod: *Module, ctx: Context) [8]Class {
338	if (ty_size > 64)	338	if (ty_size > 64)
339	return memory_class;	339	return memory_class;
340		340
341	const fields = ty.unionFields();	341	const fields = ty.unionFields(mod);
342	for (fields.values()) \|field\| {	342	for (fields.values()) \|field\| {
343	if (field.abi_align != 0) {	343	if (field.abi_align != 0) {
344	if (field.abi_align < field.ty.abiAlignment(mod)) {	344	if (field.abi_align < field.ty.abiAlignment(mod)) {

src/codegen.zig+3-3

src/codegen/c.zig+49-45

 @@ -853,7 +853,7 @@ pub const DeclGen = struct {
                     }
                     try writer.writeByte('{');
-                    if (ty.unionTagTypeSafety()) |tag_ty| {
+                    if (ty.unionTagTypeSafety(mod)) |tag_ty| {
                         const layout = ty.unionGetLayout(mod);
                         if (layout.tag_size != 0) {
                             try writer.writeAll(" .tag = ");
 @@ -863,12 +863,12 @@ pub const DeclGen = struct {
                         if (layout.tag_size != 0) try writer.writeByte(',');
                         try writer.writeAll(" .payload = {");
                     }
-                    for (ty.unionFields().values()) |field| {
+                    for (ty.unionFields(mod).values()) |field| {
                         if (!field.ty.hasRuntimeBits(mod)) continue;
                         try dg.renderValue(writer, field.ty, val, initializer_type);
                         break;
                     }
-                    if (ty.unionTagTypeSafety()) |_| try writer.writeByte('}');
+                    if (ty.unionTagTypeSafety(mod)) |_| try writer.writeByte('}');
                     return writer.writeByte('}');
                 },
                 .ErrorUnion => {
 @@ -1451,8 +1451,8 @@ pub const DeclGen = struct {
                 }
                 const field_i = ty.unionTagFieldIndex(union_obj.tag, mod).?;
-                const field_ty = ty.unionFields().values()[field_i].ty;
+                const field_ty = ty.unionFields(mod).values()[field_i].ty;
-                const field_name = ty.unionFields().keys()[field_i];
+                const field_name = ty.unionFields(mod).keys()[field_i];
                 if (ty.containerLayout(mod) == .Packed) {
                     if (field_ty.hasRuntimeBits(mod)) {
                         if (field_ty.isPtrAtRuntime(mod)) {
 @@ -1472,7 +1472,7 @@ pub const DeclGen = struct {
                 }
                 try writer.writeByte('{');
-                if (ty.unionTagTypeSafety()) |tag_ty| {
+                if (ty.unionTagTypeSafety(mod)) |tag_ty| {
                     const layout = ty.unionGetLayout(mod);
                     if (layout.tag_size != 0) {
                         try writer.writeAll(" .tag = ");
 @@ -1486,12 +1486,12 @@ pub const DeclGen = struct {
                     try writer.print(" .{ } = ", .{fmtIdent(field_name)});
                     try dg.renderValue(writer, field_ty, union_obj.val, initializer_type);
                     try writer.writeByte(' ');
-                } else for (ty.unionFields().values()) |field| {
+                } else for (ty.unionFields(mod).values()) |field| {
                     if (!field.ty.hasRuntimeBits(mod)) continue;
                     try dg.renderValue(writer, field.ty, Value.undef, initializer_type);
                     break;
                 }
-                if (ty.unionTagTypeSafety()) |_| try writer.writeByte('}');
+                if (ty.unionTagTypeSafety(mod)) |_| try writer.writeByte('}');
                 try writer.writeByte('}');
             },
 @@ -5238,13 +5238,13 @@ fn fieldLocation(
             .Auto, .Extern => {
                 const field_ty = container_ty.structFieldType(field_index, mod);
                 if (!field_ty.hasRuntimeBitsIgnoreComptime(mod))
-                    return if (container_ty.unionTagTypeSafety() != null and
+                    return if (container_ty.unionTagTypeSafety(mod) != null and
                         !container_ty.unionHasAllZeroBitFieldTypes(mod))
                         .{ .field = .{ .identifier = "payload" } }
                     else
                         .begin;
-                const field_name = container_ty.unionFields().keys()[field_index];
+                const field_name = container_ty.unionFields(mod).keys()[field_index];
-                return .{ .field = if (container_ty.unionTagTypeSafety()) |_|
+                return .{ .field = if (container_ty.unionTagTypeSafety(mod)) |_|
                     .{ .payload_identifier = field_name }
                 else
                     .{ .identifier = field_name } };
 @@ -5424,37 +5424,6 @@ fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
             else
                 .{ .identifier = struct_ty.structFieldName(extra.field_index, mod) },
-            .@"union", .union_safety_tagged, .union_tagged => if (struct_ty.containerLayout(mod) == .Packed) {
-                const operand_lval = if (struct_byval == .constant) blk: {
-                    const operand_local = try f.allocLocal(inst, struct_ty);
-                    try f.writeCValue(writer, operand_local, .Other);
-                    try writer.writeAll(" = ");
-                    try f.writeCValue(writer, struct_byval, .Initializer);
-                    try writer.writeAll(";\n");
-                    break :blk operand_local;
-                } else struct_byval;
-                const local = try f.allocLocal(inst, inst_ty);
-                try writer.writeAll("memcpy(&");
-                try f.writeCValue(writer, local, .Other);
-                try writer.writeAll(", &");
-                try f.writeCValue(writer, operand_lval, .Other);
-                try writer.writeAll(", sizeof(");
-                try f.renderType(writer, inst_ty);
-                try writer.writeAll("));\n");
-                if (struct_byval == .constant) {
-                    try freeLocal(f, inst, operand_lval.new_local, 0);
-                }
-                return local;
-            } else field_name: {
-                const name = struct_ty.unionFields().keys()[extra.field_index];
-                break :field_name if (struct_ty.unionTagTypeSafety()) |_|
-                    .{ .payload_identifier = name }
-                else
-                    .{ .identifier = name };
-            },
             else => unreachable,
         },
         else => switch (mod.intern_pool.indexToKey(struct_ty.ip_index)) {
 @@ -5520,6 +5489,41 @@ fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
                     return local;
                 },
             },
+            .union_type => |union_type| field_name: {
+                const union_obj = mod.unionPtr(union_type.index);
+                if (union_obj.layout == .Packed) {
+                    const operand_lval = if (struct_byval == .constant) blk: {
+                        const operand_local = try f.allocLocal(inst, struct_ty);
+                        try f.writeCValue(writer, operand_local, .Other);
+                        try writer.writeAll(" = ");
+                        try f.writeCValue(writer, struct_byval, .Initializer);
+                        try writer.writeAll(";\n");
+                        break :blk operand_local;
+                    } else struct_byval;
+                    const local = try f.allocLocal(inst, inst_ty);
+                    try writer.writeAll("memcpy(&");
+                    try f.writeCValue(writer, local, .Other);
+                    try writer.writeAll(", &");
+                    try f.writeCValue(writer, operand_lval, .Other);
+                    try writer.writeAll(", sizeof(");
+                    try f.renderType(writer, inst_ty);
+                    try writer.writeAll("));\n");
+                    if (struct_byval == .constant) {
+                        try freeLocal(f, inst, operand_lval.new_local, 0);
+                    }
+                    return local;
+                } else {
+                    const name = union_obj.fields.keys()[extra.field_index];
+                    break :field_name if (union_type.hasTag()) .{
+                        .payload_identifier = name,
+                    } else .{
+                        .identifier = name,
+                    };
+                }
+            },
             else => unreachable,
         },
     };
 @@ -6461,7 +6465,7 @@ fn airSetUnionTag(f: *Function, inst: Air.Inst.Index) !CValue {
     const union_ty = f.typeOf(bin_op.lhs).childType(mod);
     const layout = union_ty.unionGetLayout(mod);
     if (layout.tag_size == 0) return .none;
-    const tag_ty = union_ty.unionTagTypeSafety().?;
+    const tag_ty = union_ty.unionTagTypeSafety(mod).?;
     const writer = f.object.writer();
     const a = try Assignment.start(f, writer, tag_ty);
 @@ -6907,7 +6911,7 @@ fn airUnionInit(f: *Function, inst: Air.Inst.Index) !CValue {
     const extra = f.air.extraData(Air.UnionInit, ty_pl.payload).data;
     const union_ty = f.typeOfIndex(inst);
-    const union_obj = union_ty.cast(Type.Payload.Union).?.data;
+    const union_obj = mod.typeToUnion(union_ty).?;
     const field_name = union_obj.fields.keys()[extra.field_index];
     const payload_ty = f.typeOf(extra.init);
     const payload = try f.resolveInst(extra.init);
 @@ -6923,7 +6927,7 @@ fn airUnionInit(f: *Function, inst: Air.Inst.Index) !CValue {
         return local;
     }
-    const field: CValue = if (union_ty.unionTagTypeSafety()) |tag_ty| field: {
+    const field: CValue = if (union_ty.unionTagTypeSafety(mod)) |tag_ty| field: {
         const layout = union_ty.unionGetLayout(mod);
         if (layout.tag_size != 0) {
             const field_index = tag_ty.enumFieldIndex(field_name).?;

src/codegen/c/type.zig+13-13

...	@@ -303,7 +303,7 @@ pub const CType = extern union {	...	@@ -303,7 +303,7 @@ pub const CType = extern union {
303	);	303	);
304	}	304	}
305	pub fn unionPayloadAlign(union_ty: Type, mod: *Module) AlignAs {	305	pub fn unionPayloadAlign(union_ty: Type, mod: *Module) AlignAs {
306	const union_obj = union_ty.cast(Type.Payload.Union).?.data;	306	const union_obj = mod.typeToUnion(union_ty).?;
307	const union_payload_align = union_obj.abiAlignment(mod, false);	307	const union_payload_align = union_obj.abiAlignment(mod, false);
308	return init(union_payload_align, union_payload_align);	308	return init(union_payload_align, union_payload_align);
309	}	309	}
...	@@ -1498,7 +1498,7 @@ pub const CType = extern union {	...	@@ -1498,7 +1498,7 @@ pub const CType = extern union {
1498	if (lookup.isMutable()) {	1498	if (lookup.isMutable()) {
1499	for (0..switch (zig_ty_tag) {	1499	for (0..switch (zig_ty_tag) {
1500	.Struct => ty.structFieldCount(mod),	1500	.Struct => ty.structFieldCount(mod),
1501	.Union => ty.unionFields().count(),	1501	.Union => ty.unionFields(mod).count(),
1502	else => unreachable,	1502	else => unreachable,
1503	}) \|field_i\| {	1503	}) \|field_i\| {
1504	const field_ty = ty.structFieldType(field_i, mod);	1504	const field_ty = ty.structFieldType(field_i, mod);
...	@@ -1531,7 +1531,7 @@ pub const CType = extern union {	...	@@ -1531,7 +1531,7 @@ pub const CType = extern union {
1531	.payload => unreachable,	1531	.payload => unreachable,
1532	});	1532	});
1533	} else {	1533	} else {
1534	const tag_ty = ty.unionTagTypeSafety();	1534	const tag_ty = ty.unionTagTypeSafety(mod);
1535	const is_tagged_union_wrapper = kind != .payload and tag_ty != null;	1535	const is_tagged_union_wrapper = kind != .payload and tag_ty != null;
1536	const is_struct = zig_ty_tag == .Struct or is_tagged_union_wrapper;	1536	const is_struct = zig_ty_tag == .Struct or is_tagged_union_wrapper;
1537	switch (kind) {	1537	switch (kind) {
...	@@ -1580,7 +1580,7 @@ pub const CType = extern union {	...	@@ -1580,7 +1580,7 @@ pub const CType = extern union {
1580	var is_packed = false;	1580	var is_packed = false;
1581	for (0..switch (zig_ty_tag) {	1581	for (0..switch (zig_ty_tag) {
1582	.Struct => ty.structFieldCount(mod),	1582	.Struct => ty.structFieldCount(mod),
1583	.Union => ty.unionFields().count(),	1583	.Union => ty.unionFields(mod).count(),
1584	else => unreachable,	1584	else => unreachable,
1585	}) \|field_i\| {	1585	}) \|field_i\| {
1586	const field_ty = ty.structFieldType(field_i, mod);	1586	const field_ty = ty.structFieldType(field_i, mod);
...	@@ -1930,7 +1930,7 @@ pub const CType = extern union {	...	@@ -1930,7 +1930,7 @@ pub const CType = extern union {
1930	const zig_ty_tag = ty.zigTypeTag(mod);	1930	const zig_ty_tag = ty.zigTypeTag(mod);
1931	const fields_len = switch (zig_ty_tag) {	1931	const fields_len = switch (zig_ty_tag) {
1932	.Struct => ty.structFieldCount(mod),	1932	.Struct => ty.structFieldCount(mod),
1933	.Union => ty.unionFields().count(),	1933	.Union => ty.unionFields(mod).count(),
1934	else => unreachable,	1934	else => unreachable,
1935	};	1935	};
1936		1936
...	@@ -1956,7 +1956,7 @@ pub const CType = extern union {	...	@@ -1956,7 +1956,7 @@ pub const CType = extern union {
1956	else	1956	else
1957	arena.dupeZ(u8, switch (zig_ty_tag) {	1957	arena.dupeZ(u8, switch (zig_ty_tag) {
1958	.Struct => ty.structFieldName(field_i, mod),	1958	.Struct => ty.structFieldName(field_i, mod),
1959	.Union => ty.unionFields().keys()[field_i],	1959	.Union => ty.unionFields(mod).keys()[field_i],
1960	else => unreachable,	1960	else => unreachable,
1961	}),	1961	}),
1962	.type = store.set.typeToIndex(field_ty, mod, switch (kind) {	1962	.type = store.set.typeToIndex(field_ty, mod, switch (kind) {
...	@@ -1986,7 +1986,7 @@ pub const CType = extern union {	...	@@ -1986,7 +1986,7 @@ pub const CType = extern union {
1986	unnamed_pl.* = .{ .base = .{ .tag = t }, .data = .{	1986	unnamed_pl.* = .{ .base = .{ .tag = t }, .data = .{
1987	.fields = fields_pl,	1987	.fields = fields_pl,
1988	.owner_decl = ty.getOwnerDecl(mod),	1988	.owner_decl = ty.getOwnerDecl(mod),
1989	.id = if (ty.unionTagTypeSafety()) \|_\| 0 else unreachable,	1989	.id = if (ty.unionTagTypeSafety(mod)) \|_\| 0 else unreachable,
1990	} };	1990	} };
1991	return initPayload(unnamed_pl);	1991	return initPayload(unnamed_pl);
1992	},	1992	},
...	@@ -2085,7 +2085,7 @@ pub const CType = extern union {	...	@@ -2085,7 +2085,7 @@ pub const CType = extern union {
2085	var c_field_i: usize = 0;	2085	var c_field_i: usize = 0;
2086	for (0..switch (zig_ty_tag) {	2086	for (0..switch (zig_ty_tag) {
2087	.Struct => ty.structFieldCount(mod),	2087	.Struct => ty.structFieldCount(mod),
2088	.Union => ty.unionFields().count(),	2088	.Union => ty.unionFields(mod).count(),
2089	else => unreachable,	2089	else => unreachable,
2090	}) \|field_i\| {	2090	}) \|field_i\| {
2091	const field_ty = ty.structFieldType(field_i, mod);	2091	const field_ty = ty.structFieldType(field_i, mod);
...	@@ -2106,7 +2106,7 @@ pub const CType = extern union {	...	@@ -2106,7 +2106,7 @@ pub const CType = extern union {
2106	std.fmt.bufPrint(&name_buf, "f{}", .{field_i}) catch unreachable	2106	std.fmt.bufPrint(&name_buf, "f{}", .{field_i}) catch unreachable
2107	else switch (zig_ty_tag) {	2107	else switch (zig_ty_tag) {
2108	.Struct => ty.structFieldName(field_i, mod),	2108	.Struct => ty.structFieldName(field_i, mod),
2109	.Union => ty.unionFields().keys()[field_i],	2109	.Union => ty.unionFields(mod).keys()[field_i],
2110	else => unreachable,	2110	else => unreachable,
2111	},	2111	},
2112	mem.span(c_field.name),	2112	mem.span(c_field.name),
...	@@ -2122,7 +2122,7 @@ pub const CType = extern union {	...	@@ -2122,7 +2122,7 @@ pub const CType = extern union {
2122	.packed_unnamed_union,	2122	.packed_unnamed_union,
2123	=> switch (self.kind) {	2123	=> switch (self.kind) {
2124	.forward, .forward_parameter, .complete, .parameter, .global => unreachable,	2124	.forward, .forward_parameter, .complete, .parameter, .global => unreachable,
2125	.payload => if (ty.unionTagTypeSafety()) \|_\| {	2125	.payload => if (ty.unionTagTypeSafety(mod)) \|_\| {
2126	const data = cty.cast(Payload.Unnamed).?.data;	2126	const data = cty.cast(Payload.Unnamed).?.data;
2127	return ty.getOwnerDecl(mod) == data.owner_decl and data.id == 0;	2127	return ty.getOwnerDecl(mod) == data.owner_decl and data.id == 0;
2128	} else unreachable,	2128	} else unreachable,
...	@@ -2211,7 +2211,7 @@ pub const CType = extern union {	...	@@ -2211,7 +2211,7 @@ pub const CType = extern union {
2211	const zig_ty_tag = ty.zigTypeTag(mod);	2211	const zig_ty_tag = ty.zigTypeTag(mod);
2212	for (0..switch (ty.zigTypeTag(mod)) {	2212	for (0..switch (ty.zigTypeTag(mod)) {
2213	.Struct => ty.structFieldCount(mod),	2213	.Struct => ty.structFieldCount(mod),
2214	.Union => ty.unionFields().count(),	2214	.Union => ty.unionFields(mod).count(),
2215	else => unreachable,	2215	else => unreachable,
2216	}) \|field_i\| {	2216	}) \|field_i\| {
2217	const field_ty = ty.structFieldType(field_i, mod);	2217	const field_ty = ty.structFieldType(field_i, mod);
...	@@ -2228,7 +2228,7 @@ pub const CType = extern union {	...	@@ -2228,7 +2228,7 @@ pub const CType = extern union {
2228	std.fmt.bufPrint(&name_buf, "f{}", .{field_i}) catch unreachable	2228	std.fmt.bufPrint(&name_buf, "f{}", .{field_i}) catch unreachable
2229	else switch (zig_ty_tag) {	2229	else switch (zig_ty_tag) {
2230	.Struct => ty.structFieldName(field_i, mod),	2230	.Struct => ty.structFieldName(field_i, mod),
2231	.Union => ty.unionFields().keys()[field_i],	2231	.Union => ty.unionFields(mod).keys()[field_i],
2232	else => unreachable,	2232	else => unreachable,
2233	});	2233	});
2234	autoHash(hasher, AlignAs.fieldAlign(ty, field_i, mod).@"align");	2234	autoHash(hasher, AlignAs.fieldAlign(ty, field_i, mod).@"align");
...	@@ -2241,7 +2241,7 @@ pub const CType = extern union {	...	@@ -2241,7 +2241,7 @@ pub const CType = extern union {
2241	.packed_unnamed_union,	2241	.packed_unnamed_union,
2242	=> switch (self.kind) {	2242	=> switch (self.kind) {
2243	.forward, .forward_parameter, .complete, .parameter, .global => unreachable,	2243	.forward, .forward_parameter, .complete, .parameter, .global => unreachable,
2244	.payload => if (ty.unionTagTypeSafety()) \|_\| {	2244	.payload => if (ty.unionTagTypeSafety(mod)) \|_\| {
2245	autoHash(hasher, ty.getOwnerDecl(mod));	2245	autoHash(hasher, ty.getOwnerDecl(mod));
2246	autoHash(hasher, @as(u32, 0));	2246	autoHash(hasher, @as(u32, 0));
2247	} else unreachable,	2247	} else unreachable,

src/codegen/llvm.zig+7-7

src/codegen/spirv.zig+5-5

src/link/Dwarf.zig+2-2

...	@@ -432,7 +432,7 @@ pub const DeclState = struct {	...	@@ -432,7 +432,7 @@ pub const DeclState = struct {
432	},	432	},
433	.Union => {	433	.Union => {
434	const layout = ty.unionGetLayout(mod);	434	const layout = ty.unionGetLayout(mod);
435	const union_obj = ty.cast(Type.Payload.Union).?.data;	435	const union_obj = mod.typeToUnion(ty).?;
436	const payload_offset = if (layout.tag_align >= layout.payload_align) layout.tag_size else 0;	436	const payload_offset = if (layout.tag_align >= layout.payload_align) layout.tag_size else 0;
437	const tag_offset = if (layout.tag_align >= layout.payload_align) 0 else layout.payload_size;	437	const tag_offset = if (layout.tag_align >= layout.payload_align) 0 else layout.payload_size;
438	const is_tagged = layout.tag_size > 0;	438	const is_tagged = layout.tag_size > 0;
...	@@ -476,7 +476,7 @@ pub const DeclState = struct {	...	@@ -476,7 +476,7 @@ pub const DeclState = struct {
476	try dbg_info_buffer.writer().print("{s}\x00", .{union_name});	476	try dbg_info_buffer.writer().print("{s}\x00", .{union_name});
477	}	477	}
478		478
479	const fields = ty.unionFields();	479	const fields = ty.unionFields(mod);
480	for (fields.keys()) \|field_name\| {	480	for (fields.keys()) \|field_name\| {
481	const field = fields.get(field_name).?;	481	const field = fields.get(field_name).?;
482	if (!field.ty.hasRuntimeBits(mod)) continue;	482	if (!field.ty.hasRuntimeBits(mod)) continue;

src/type.zig+176-223

 @@ -68,11 +68,6 @@ pub const Type = struct {
                 .enum_simple,
                 .enum_numbered,
                 => return .Enum,
-                .@"union",
-                .union_safety_tagged,
-                .union_tagged,
-                => return .Union,
             },
             else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
                 .int_type => return .Int,
 @@ -140,6 +135,7 @@ pub const Type = struct {
                 },
                 // values, not types
+                .un => unreachable,
                 .extern_func => unreachable,
                 .int => unreachable,
                 .ptr => unreachable,
 @@ -585,12 +581,6 @@ pub const Type = struct {
                 const b_enum_obj = (b.cast(Payload.EnumNumbered) orelse return false).data;
                 return a_enum_obj == b_enum_obj;
             },
-            .@"union", .union_safety_tagged, .union_tagged => {
-                const a_union_obj = a.cast(Payload.Union).?.data;
-                const b_union_obj = (b.cast(Payload.Union) orelse return false).data;
-                return a_union_obj == b_union_obj;
-            },
         }
     }
 @@ -752,12 +742,6 @@ pub const Type = struct {
                 std.hash.autoHash(hasher, std.builtin.TypeId.Enum);
                 std.hash.autoHash(hasher, enum_obj);
             },
-            .@"union", .union_safety_tagged, .union_tagged => {
-                const union_obj: *const Module.Union = ty.cast(Payload.Union).?.data;
-                std.hash.autoHash(hasher, std.builtin.TypeId.Union);
-                std.hash.autoHash(hasher, union_obj);
-            },
         }
     }
 @@ -935,7 +919,6 @@ pub const Type = struct {
             .error_set => return self.copyPayloadShallow(allocator, Payload.ErrorSet),
             .error_set_inferred => return self.copyPayloadShallow(allocator, Payload.ErrorSetInferred),
             .error_set_single => return self.copyPayloadShallow(allocator, Payload.Name),
-            .@"union", .union_safety_tagged, .union_tagged => return self.copyPayloadShallow(allocator, Payload.Union),
             .enum_simple => return self.copyPayloadShallow(allocator, Payload.EnumSimple),
             .enum_numbered => return self.copyPayloadShallow(allocator, Payload.EnumNumbered),
             .enum_full, .enum_nonexhaustive => return self.copyPayloadShallow(allocator, Payload.EnumFull),
 @@ -1011,12 +994,6 @@ pub const Type = struct {
         while (true) {
             const t = ty.tag();
             switch (t) {
-                .@"union", .union_safety_tagged, .union_tagged => {
-                    const union_obj = ty.cast(Payload.Union).?.data;
-                    return writer.print("({s} decl={d})", .{
-                        @tagName(t), union_obj.owner_decl,
-                    });
-                },
                 .enum_full, .enum_nonexhaustive => {
                     const enum_full = ty.cast(Payload.EnumFull).?.data;
                     return writer.print("({s} decl={d})", .{
 @@ -1221,11 +1198,6 @@ pub const Type = struct {
                 .inferred_alloc_const => unreachable,
                 .inferred_alloc_mut => unreachable,
-                .@"union", .union_safety_tagged, .union_tagged => {
-                    const union_obj = ty.cast(Payload.Union).?.data;
-                    const decl = mod.declPtr(union_obj.owner_decl);
-                    try decl.renderFullyQualifiedName(mod, writer);
-                },
                 .enum_full, .enum_nonexhaustive => {
                     const enum_full = ty.cast(Payload.EnumFull).?.data;
                     const decl = mod.declPtr(enum_full.owner_decl);
 @@ -1518,13 +1490,18 @@ pub const Type = struct {
                     }
                 },
-                .union_type => @panic("TODO"),
+                .union_type => |union_type| {
+                    const union_obj = mod.unionPtr(union_type.index);
+                    const decl = mod.declPtr(union_obj.owner_decl);
+                    try decl.renderFullyQualifiedName(mod, writer);
+                },
                 .opaque_type => |opaque_type| {
                     const decl = mod.declPtr(opaque_type.decl);
                     try decl.renderFullyQualifiedName(mod, writer);
                 },
                 // values, not types
+                .un => unreachable,
                 .simple_value => unreachable,
                 .extern_func => unreachable,
                 .int => unreachable,
 @@ -1627,45 +1604,6 @@ pub const Type = struct {
                     return int_tag_ty.hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat);
                 },
-                .@"union" => {
-                    const union_obj = ty.castTag(.@"union").?.data;
-                    if (union_obj.status == .field_types_wip) {
-                        // In this case, we guess that hasRuntimeBits() for this type is true,
-                        // and then later if our guess was incorrect, we emit a compile error.
-                        union_obj.assumed_runtime_bits = true;
-                        return true;
-                    }
-                    switch (strat) {
-                        .sema => |sema| _ = try sema.resolveTypeFields(ty),
-                        .eager => assert(union_obj.haveFieldTypes()),
-                        .lazy => if (!union_obj.haveFieldTypes()) return error.NeedLazy,
-                    }
-                    for (union_obj.fields.values()) |value| {
-                        if (try value.ty.hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat))
-                            return true;
-                    } else {
-                        return false;
-                    }
-                },
-                .union_safety_tagged, .union_tagged => {
-                    const union_obj = ty.cast(Payload.Union).?.data;
-                    if (try union_obj.tag_ty.hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat)) {
-                        return true;
-                    }
-                    switch (strat) {
-                        .sema => |sema| _ = try sema.resolveTypeFields(ty),
-                        .eager => assert(union_obj.haveFieldTypes()),
-                        .lazy => if (!union_obj.haveFieldTypes()) return error.NeedLazy,
-                    }
-                    for (union_obj.fields.values()) |value| {
-                        if (try value.ty.hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat))
-                            return true;
-                    } else {
-                        return false;
-                    }
-                },
                 .array => return ty.arrayLen(mod) != 0 and
                     try ty.childType(mod).hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat),
                 .array_sentinel => return ty.childType(mod).hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat),
 @@ -1795,10 +1733,40 @@ pub const Type = struct {
                     }
                 },
-                .union_type => @panic("TODO"),
+                .union_type => |union_type| {
+                    const union_obj = mod.unionPtr(union_type.index);
+                    switch (union_type.runtime_tag) {
+                        .none => {
+                            if (union_obj.status == .field_types_wip) {
+                                // In this case, we guess that hasRuntimeBits() for this type is true,
+                                // and then later if our guess was incorrect, we emit a compile error.
+                                union_obj.assumed_runtime_bits = true;
+                                return true;
+                            }
+                        },
+                        .safety, .tagged => {
+                            if (try union_obj.tag_ty.hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat)) {
+                                return true;
+                            }
+                        },
+                    }
+                    switch (strat) {
+                        .sema => |sema| _ = try sema.resolveTypeFields(ty),
+                        .eager => assert(union_obj.haveFieldTypes()),
+                        .lazy => if (!union_obj.haveFieldTypes()) return error.NeedLazy,
+                    }
+                    for (union_obj.fields.values()) |value| {
+                        if (try value.ty.hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat))
+                            return true;
+                    } else {
+                        return false;
+                    }
+                },
                 .opaque_type => true,
                 // values, not types
+                .un => unreachable,
                 .simple_value => unreachable,
                 .extern_func => unreachable,
                 .int => unreachable,
 @@ -1847,8 +1815,6 @@ pub const Type = struct {
                 => ty.childType(mod).hasWellDefinedLayout(mod),
                 .optional => ty.isPtrLikeOptional(mod),
-                .@"union", .union_safety_tagged => ty.cast(Payload.Union).?.data.layout != .Auto,
-                .union_tagged => false,
             },
             else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
                 .int_type => true,
 @@ -1912,10 +1878,14 @@ pub const Type = struct {
                     };
                     return struct_obj.layout != .Auto;
                 },
-                .union_type => @panic("TODO"),
+                .union_type => |union_type| switch (union_type.runtime_tag) {
+                    .none, .safety => mod.unionPtr(union_type.index).layout != .Auto,
+                    .tagged => false,
+                },
                 .opaque_type => false,
                 // values, not types
+                .un => unreachable,
                 .simple_value => unreachable,
                 .extern_func => unreachable,
                 .int => unreachable,
 @@ -2146,14 +2116,6 @@ pub const Type = struct {
                     const int_tag_ty = try ty.intTagType(mod);
                     return AbiAlignmentAdvanced{ .scalar = int_tag_ty.abiAlignment(mod) };
                 },
-                .@"union" => {
-                    const union_obj = ty.castTag(.@"union").?.data;
-                    return abiAlignmentAdvancedUnion(ty, mod, strat, union_obj, false);
-                },
-                .union_safety_tagged, .union_tagged => {
-                    const union_obj = ty.cast(Payload.Union).?.data;
-                    return abiAlignmentAdvancedUnion(ty, mod, strat, union_obj, true);
-                },
                 .inferred_alloc_const,
                 .inferred_alloc_mut,
 @@ -2312,10 +2274,14 @@ pub const Type = struct {
                     }
                     return AbiAlignmentAdvanced{ .scalar = big_align };
                 },
-                .union_type => @panic("TODO"),
+                .union_type => |union_type| {
+                    const union_obj = mod.unionPtr(union_type.index);
+                    return abiAlignmentAdvancedUnion(ty, mod, strat, union_obj, union_type.hasTag());
+                },
                 .opaque_type => return AbiAlignmentAdvanced{ .scalar = 1 },
                 // values, not types
+                .un => unreachable,
                 .simple_value => unreachable,
                 .extern_func => unreachable,
                 .int => unreachable,
 @@ -2508,14 +2474,6 @@ pub const Type = struct {
                     const int_tag_ty = try ty.intTagType(mod);
                     return AbiSizeAdvanced{ .scalar = int_tag_ty.abiSize(mod) };
                 },
-                .@"union" => {
-                    const union_obj = ty.castTag(.@"union").?.data;
-                    return abiSizeAdvancedUnion(ty, mod, strat, union_obj, false);
-                },
-                .union_safety_tagged, .union_tagged => {
-                    const union_obj = ty.cast(Payload.Union).?.data;
-                    return abiSizeAdvancedUnion(ty, mod, strat, union_obj, true);
-                },
                 .array => {
                     const payload = ty.castTag(.array).?.data;
 @@ -2737,10 +2695,14 @@ pub const Type = struct {
                         return AbiSizeAdvanced{ .scalar = ty.structFieldOffset(field_count, mod) };
                     },
                 },
-                .union_type => @panic("TODO"),
+                .union_type => |union_type| {
+                    const union_obj = mod.unionPtr(union_type.index);
+                    return abiSizeAdvancedUnion(ty, mod, strat, union_obj, union_type.hasTag());
+                },
                 .opaque_type => unreachable, // no size available
                 // values, not types
+                .un => unreachable,
                 .simple_value => unreachable,
                 .extern_func => unreachable,
                 .int => unreachable,
 @@ -2860,21 +2822,6 @@ pub const Type = struct {
                     return try bitSizeAdvanced(int_tag_ty, mod, opt_sema);
                 },
-                .@"union", .union_safety_tagged, .union_tagged => {
-                    if (opt_sema) |sema| _ = try sema.resolveTypeFields(ty);
-                    if (ty.containerLayout(mod) != .Packed) {
-                        return (try ty.abiSizeAdvanced(mod, strat)).scalar * 8;
-                    }
-                    const union_obj = ty.cast(Payload.Union).?.data;
-                    assert(union_obj.haveFieldTypes());
-                    var size: u64 = 0;
-                    for (union_obj.fields.values()) |field| {
-                        size = @max(size, try bitSizeAdvanced(field.ty, mod, opt_sema));
-                    }
-                    return size;
-                },
                 .array => {
                     const payload = ty.castTag(.array).?.data;
                     const elem_size = std.math.max(payload.elem_type.abiAlignment(mod), payload.elem_type.abiSize(mod));
 @@ -2996,10 +2943,24 @@ pub const Type = struct {
                     return try struct_obj.backing_int_ty.bitSizeAdvanced(mod, opt_sema);
                 },
-                .union_type => @panic("TODO"),
+                .union_type => |union_type| {
+                    if (opt_sema) |sema| _ = try sema.resolveTypeFields(ty);
+                    if (ty.containerLayout(mod) != .Packed) {
+                        return (try ty.abiSizeAdvanced(mod, strat)).scalar * 8;
+                    }
+                    const union_obj = mod.unionPtr(union_type.index);
+                    assert(union_obj.haveFieldTypes());
+                    var size: u64 = 0;
+                    for (union_obj.fields.values()) |field| {
+                        size = @max(size, try bitSizeAdvanced(field.ty, mod, opt_sema));
+                    }
+                    return size;
+                },
                 .opaque_type => unreachable,
                 // values, not types
+                .un => unreachable,
                 .simple_value => unreachable,
                 .extern_func => unreachable,
                 .int => unreachable,
 @@ -3022,8 +2983,8 @@ pub const Type = struct {
                 return true;
             },
             .Union => {
-                if (ty.cast(Payload.Union)) |union_ty| {
+                if (mod.typeToUnion(ty)) |union_obj| {
-                    return union_ty.data.haveLayout();
+                    return union_obj.haveLayout();
                 }
                 return true;
             },
 @@ -3413,76 +3374,71 @@ pub const Type = struct {
     /// Returns the tag type of a union, if the type is a union and it has a tag type.
     /// Otherwise, returns `null`.
-    pub fn unionTagType(ty: Type) ?Type {
+    pub fn unionTagType(ty: Type, mod: *Module) ?Type {
-        return switch (ty.tag()) {
+        return switch (mod.intern_pool.indexToKey(ty.ip_index)) {
-            .union_tagged => {
+            .union_type => |union_type| switch (union_type.runtime_tag) {
-                const union_obj = ty.castTag(.union_tagged).?.data;
+                .tagged => {
-                assert(union_obj.haveFieldTypes());
+                    const union_obj = mod.unionPtr(union_type.index);
-                return union_obj.tag_ty;
+                    assert(union_obj.haveFieldTypes());
+                    return union_obj.tag_ty;
+                },
+                else => null,
             },
             else => null,
         };
     }
     /// Same as `unionTagType` but includes safety tag.
     /// Codegen should use this version.
-    pub fn unionTagTypeSafety(ty: Type) ?Type {
+    pub fn unionTagTypeSafety(ty: Type, mod: *Module) ?Type {
-        return switch (ty.tag()) {
+        return switch (mod.intern_pool.indexToKey(ty.ip_index)) {
-            .union_safety_tagged, .union_tagged => {
+            .union_type => |union_type| {
-                const union_obj = ty.cast(Payload.Union).?.data;
+                if (!union_type.hasTag()) return null;
+                const union_obj = mod.unionPtr(union_type.index);
                 assert(union_obj.haveFieldTypes());
                 return union_obj.tag_ty;
             },
             else => null,
         };
     }
     /// Asserts the type is a union; returns the tag type, even if the tag will
     /// not be stored at runtime.
-    pub fn unionTagTypeHypothetical(ty: Type) Type {
+    pub fn unionTagTypeHypothetical(ty: Type, mod: *Module) Type {
-        const union_obj = ty.cast(Payload.Union).?.data;
+        const union_obj = mod.typeToUnion(ty).?;
         assert(union_obj.haveFieldTypes());
         return union_obj.tag_ty;
     }
-    pub fn unionFields(ty: Type) Module.Union.Fields {
+    pub fn unionFields(ty: Type, mod: *Module) Module.Union.Fields {
-        const union_obj = ty.cast(Payload.Union).?.data;
+        const union_obj = mod.typeToUnion(ty).?;
         assert(union_obj.haveFieldTypes());
         return union_obj.fields;
     }
     pub fn unionFieldType(ty: Type, enum_tag: Value, mod: *Module) Type {
-        const union_obj = ty.cast(Payload.Union).?.data;
+        const union_obj = mod.typeToUnion(ty).?;
         const index = ty.unionTagFieldIndex(enum_tag, mod).?;
         assert(union_obj.haveFieldTypes());
         return union_obj.fields.values()[index].ty;
     }
     pub fn unionTagFieldIndex(ty: Type, enum_tag: Value, mod: *Module) ?usize {
-        const union_obj = ty.cast(Payload.Union).?.data;
+        const union_obj = mod.typeToUnion(ty).?;
         const index = union_obj.tag_ty.enumTagFieldIndex(enum_tag, mod) orelse return null;
         const name = union_obj.tag_ty.enumFieldName(index);
         return union_obj.fields.getIndex(name);
     }
     pub fn unionHasAllZeroBitFieldTypes(ty: Type, mod: *Module) bool {
-        return ty.cast(Payload.Union).?.data.hasAllZeroBitFieldTypes(mod);
+        const union_obj = mod.typeToUnion(ty).?;
+        return union_obj.hasAllZeroBitFieldTypes(mod);
     }
     pub fn unionGetLayout(ty: Type, mod: *Module) Module.Union.Layout {
-        switch (ty.tag()) {
+        const union_type = mod.intern_pool.indexToKey(ty.ip_index).union_type;
-            .@"union" => {
+        const union_obj = mod.unionPtr(union_type.index);
-                const union_obj = ty.castTag(.@"union").?.data;
+        return union_obj.getLayout(mod, union_type.hasTag());
-                return union_obj.getLayout(mod, false);
-            },
-            .union_safety_tagged, .union_tagged => {
-                const union_obj = ty.cast(Payload.Union).?.data;
-                return union_obj.getLayout(mod, true);
-            },
-            else => unreachable,
-        }
     }
     pub fn containerLayout(ty: Type, mod: *Module) std.builtin.Type.ContainerLayout {
 @@ -3490,9 +3446,6 @@ pub const Type = struct {
             .empty_struct_type => .Auto,
             .none => switch (ty.tag()) {
                 .tuple, .anon_struct => .Auto,
-                .@"union" => ty.castTag(.@"union").?.data.layout,
-                .union_safety_tagged => ty.castTag(.union_safety_tagged).?.data.layout,
-                .union_tagged => ty.castTag(.union_tagged).?.data.layout,
                 else => unreachable,
             },
             else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
 @@ -3500,6 +3453,10 @@ pub const Type = struct {
                     const struct_obj = mod.structPtrUnwrap(struct_type.index) orelse return .Auto;
                     return struct_obj.layout;
                 },
+                .union_type => |union_type| {
+                    const union_obj = mod.unionPtr(union_type.index);
+                    return union_obj.layout;
+                },
                 else => unreachable,
             },
         };
 @@ -3777,6 +3734,7 @@ pub const Type = struct {
                 .opaque_type => unreachable,
                 // values, not types
+                .un => unreachable,
                 .simple_value => unreachable,
                 .extern_func => unreachable,
                 .int => unreachable,
 @@ -4038,16 +3996,6 @@ pub const Type = struct {
                         return null;
                     }
                 },
-                .@"union", .union_safety_tagged, .union_tagged => {
-                    const union_obj = ty.cast(Payload.Union).?.data;
-                    const tag_val = (try union_obj.tag_ty.onePossibleValue(mod)) orelse return null;
-                    if (union_obj.fields.count() == 0) return Value.@"unreachable";
-                    const only_field = union_obj.fields.values()[0];
-                    const val_val = (try only_field.ty.onePossibleValue(mod)) orelse return null;
-                    _ = tag_val;
-                    _ = val_val;
-                    return Value.empty_struct;
-                },
                 .array => {
                     if (ty.arrayLen(mod) == 0)
 @@ -4153,10 +4101,23 @@ pub const Type = struct {
                     return empty.toValue();
                 },
-                .union_type => @panic("TODO"),
+                .union_type => |union_type| {
+                    const union_obj = mod.unionPtr(union_type.index);
+                    const tag_val = (try union_obj.tag_ty.onePossibleValue(mod)) orelse return null;
+                    if (union_obj.fields.count() == 0) return Value.@"unreachable";
+                    const only_field = union_obj.fields.values()[0];
+                    const val_val = (try only_field.ty.onePossibleValue(mod)) orelse return null;
+                    const only = try mod.intern(.{ .un = .{
+                        .ty = ty.ip_index,
+                        .tag = tag_val.ip_index,
+                        .val = val_val.ip_index,
+                    } });
+                    return only.toValue();
+                },
                 .opaque_type => return null,
                 // values, not types
+                .un => unreachable,
                 .simple_value => unreachable,
                 .extern_func => unreachable,
                 .int => unreachable,
 @@ -4216,20 +4177,6 @@ pub const Type = struct {
                     return false;
                 },
-                .@"union", .union_safety_tagged, .union_tagged => {
-                    const union_obj = ty.cast(Type.Payload.Union).?.data;
-                    switch (union_obj.requires_comptime) {
-                        .wip, .unknown => {
-                            // Return false to avoid incorrect dependency loops.
-                            // This will be handled correctly once merged with
-                            // `Sema.typeRequiresComptime`.
-                            return false;
-                        },
-                        .no => return false,
-                        .yes => return true,
-                    }
-                },
                 .error_union => return ty.errorUnionPayload().comptimeOnly(mod),
                 .anyframe_T => {
                     const child_ty = ty.castTag(.anyframe_T).?.data;
 @@ -4321,10 +4268,24 @@ pub const Type = struct {
                     }
                 },
-                .union_type => @panic("TODO"),
+                .union_type => |union_type| {
+                    const union_obj = mod.unionPtr(union_type.index);
+                    switch (union_obj.requires_comptime) {
+                        .wip, .unknown => {
+                            // Return false to avoid incorrect dependency loops.
+                            // This will be handled correctly once merged with
+                            // `Sema.typeRequiresComptime`.
+                            return false;
+                        },
+                        .no => return false,
+                        .yes => return true,
+                    }
+                },
                 .opaque_type => false,
                 // values, not types
+                .un => unreachable,
                 .simple_value => unreachable,
                 .extern_func => unreachable,
                 .int => unreachable,
 @@ -4378,15 +4339,13 @@ pub const Type = struct {
             .none => switch (ty.tag()) {
                 .enum_full => ty.castTag(.enum_full).?.data.namespace.toOptional(),
                 .enum_nonexhaustive => ty.castTag(.enum_nonexhaustive).?.data.namespace.toOptional(),
-                .@"union" => ty.castTag(.@"union").?.data.namespace.toOptional(),
-                .union_safety_tagged => ty.castTag(.union_safety_tagged).?.data.namespace.toOptional(),
-                .union_tagged => ty.castTag(.union_tagged).?.data.namespace.toOptional(),
                 else => .none,
             },
             else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
                 .opaque_type => |opaque_type| opaque_type.namespace.toOptional(),
                 .struct_type => |struct_type| struct_type.namespace,
+                .union_type => |union_type| mod.unionPtr(union_type.index).namespace.toOptional(),
                 else => .none,
             },
         };
 @@ -4474,20 +4433,23 @@ pub const Type = struct {
     /// Asserts the type is an enum or a union.
     pub fn intTagType(ty: Type, mod: *Module) !Type {
-        switch (ty.tag()) {
+        return switch (ty.ip_index) {
-            .enum_full, .enum_nonexhaustive => return ty.cast(Payload.EnumFull).?.data.tag_ty,
+            .none => switch (ty.tag()) {
-            .enum_numbered => return ty.castTag(.enum_numbered).?.data.tag_ty,
+                .enum_full, .enum_nonexhaustive => ty.cast(Payload.EnumFull).?.data.tag_ty,
-            .enum_simple => {
+                .enum_numbered => ty.castTag(.enum_numbered).?.data.tag_ty,
-                const enum_simple = ty.castTag(.enum_simple).?.data;
+                .enum_simple => {
-                const field_count = enum_simple.fields.count();
+                    const enum_simple = ty.castTag(.enum_simple).?.data;
-                const bits: u16 = if (field_count == 0) 0 else std.math.log2_int_ceil(usize, field_count);
+                    const field_count = enum_simple.fields.count();
-                return mod.intType(.unsigned, bits);
+                    const bits: u16 = if (field_count == 0) 0 else std.math.log2_int_ceil(usize, field_count);
+                    return mod.intType(.unsigned, bits);
+                },
+                else => unreachable,
             },
-            .union_tagged => {
+            else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
-                return ty.castTag(.union_tagged).?.data.tag_ty.intTagType(mod);
+                .union_type => |union_type| mod.unionPtr(union_type.index).tag_ty.intTagType(mod),
+                else => unreachable,
             },
-            else => unreachable,
+        };
-        }
     }
     pub fn isNonexhaustiveEnum(ty: Type) bool {
 @@ -4663,10 +4625,6 @@ pub const Type = struct {
     pub fn structFieldType(ty: Type, index: usize, mod: *Module) Type {
         return switch (ty.ip_index) {
             .none => switch (ty.tag()) {
-                .@"union", .union_safety_tagged, .union_tagged => {
-                    const union_obj = ty.cast(Payload.Union).?.data;
-                    return union_obj.fields.values()[index].ty;
-                },
                 .tuple => return ty.castTag(.tuple).?.data.types[index],
                 .anon_struct => return ty.castTag(.anon_struct).?.data.types[index],
                 else => unreachable,
 @@ -4676,6 +4634,10 @@ pub const Type = struct {
                     const struct_obj = mod.structPtrUnwrap(struct_type.index).?;
                     return struct_obj.fields.values()[index].ty;
                 },
+                .union_type => |union_type| {
+                    const union_obj = mod.unionPtr(union_type.index);
+                    return union_obj.fields.values()[index].ty;
+                },
                 else => unreachable,
             },
         };
 @@ -4684,10 +4646,6 @@ pub const Type = struct {
     pub fn structFieldAlign(ty: Type, index: usize, mod: *Module) u32 {
         switch (ty.ip_index) {
             .none => switch (ty.tag()) {
-                .@"union", .union_safety_tagged, .union_tagged => {
-                    const union_obj = ty.cast(Payload.Union).?.data;
-                    return union_obj.fields.values()[index].normalAlignment(mod);
-                },
                 .tuple => return ty.castTag(.tuple).?.data.types[index].abiAlignment(mod),
                 .anon_struct => return ty.castTag(.anon_struct).?.data.types[index].abiAlignment(mod),
                 else => unreachable,
 @@ -4698,6 +4656,10 @@ pub const Type = struct {
                     assert(struct_obj.layout != .Packed);
                     return struct_obj.fields.values()[index].alignment(mod, struct_obj.layout);
                 },
+                .union_type => |union_type| {
+                    const union_obj = mod.unionPtr(union_type.index);
+                    return union_obj.fields.values()[index].normalAlignment(mod);
+                },
                 else => unreachable,
             },
         }
 @@ -4889,18 +4851,6 @@ pub const Type = struct {
                     return offset;
                 },
-                .@"union" => return 0,
-                .union_safety_tagged, .union_tagged => {
-                    const union_obj = ty.cast(Payload.Union).?.data;
-                    const layout = union_obj.getLayout(mod, true);
-                    if (layout.tag_align >= layout.payload_align) {
-                        // {Tag, Payload}
-                        return std.mem.alignForwardGeneric(u64, layout.tag_size, layout.payload_align);
-                    } else {
-                        // {Payload, Tag}
-                        return 0;
-                    }
-                },
                 else => unreachable,
             },
             else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
 @@ -4917,6 +4867,20 @@ pub const Type = struct {
                     return std.mem.alignForwardGeneric(u64, it.offset, @max(it.big_align, 1));
                 },
+                .union_type => |union_type| {
+                    if (!union_type.hasTag())
+                        return 0;
+                    const union_obj = mod.unionPtr(union_type.index);
+                    const layout = union_obj.getLayout(mod, true);
+                    if (layout.tag_align >= layout.payload_align) {
+                        // {Tag, Payload}
+                        return std.mem.alignForwardGeneric(u64, layout.tag_size, layout.payload_align);
+                    } else {
+                        // {Payload, Tag}
+                        return 0;
+                    }
+                },
                 else => unreachable,
             },
         }
 @@ -4946,10 +4910,6 @@ pub const Type = struct {
                     const error_set = ty.castTag(.error_set).?.data;
                     return error_set.srcLoc(mod);
                 },
-                .@"union", .union_safety_tagged, .union_tagged => {
-                    const union_obj = ty.cast(Payload.Union).?.data;
-                    return union_obj.srcLoc(mod);
-                },
                 else => return null,
             },
 @@ -4958,7 +4918,10 @@ pub const Type = struct {
                     const struct_obj = mod.structPtrUnwrap(struct_type.index).?;
                     return struct_obj.srcLoc(mod);
                 },
-                .union_type => @panic("TODO"),
+                .union_type => |union_type| {
+                    const union_obj = mod.unionPtr(union_type.index);
+                    return union_obj.srcLoc(mod);
+                },
                 .opaque_type => |opaque_type| mod.opaqueSrcLoc(opaque_type),
                 else => null,
             },
 @@ -4985,10 +4948,6 @@ pub const Type = struct {
                     const error_set = ty.castTag(.error_set).?.data;
                     return error_set.owner_decl;
                 },
-                .@"union", .union_safety_tagged, .union_tagged => {
-                    const union_obj = ty.cast(Payload.Union).?.data;
-                    return union_obj.owner_decl;
-                },
                 else => return null,
             },
 @@ -4997,7 +4956,10 @@ pub const Type = struct {
                     const struct_obj = mod.structPtrUnwrap(struct_type.index) orelse return null;
                     return struct_obj.owner_decl;
                 },
-                .union_type => @panic("TODO"),
+                .union_type => |union_type| {
+                    const union_obj = mod.unionPtr(union_type.index);
+                    return union_obj.owner_decl;
+                },
                 .opaque_type => |opaque_type| opaque_type.decl,
                 else => null,
             },
 @@ -5039,9 +5001,6 @@ pub const Type = struct {
         /// The type is the inferred error set of a specific function.
         error_set_inferred,
         error_set_merged,
-        @"union",
-        union_safety_tagged,
-        union_tagged,
         enum_simple,
         enum_numbered,
         enum_full,
 @@ -5070,7 +5029,6 @@ pub const Type = struct {
                 .function => Payload.Function,
                 .error_union => Payload.ErrorUnion,
                 .error_set_single => Payload.Name,
-                .@"union", .union_safety_tagged, .union_tagged => Payload.Union,
                 .enum_full, .enum_nonexhaustive => Payload.EnumFull,
                 .enum_simple => Payload.EnumSimple,
                 .enum_numbered => Payload.EnumNumbered,
 @@ -5373,11 +5331,6 @@ pub const Type = struct {
             };
         };
-        pub const Union = struct {
-            base: Payload,
-            data: *Module.Union,
-        };
         pub const EnumFull = struct {
             base: Payload,
             data: *Module.EnumFull,

src/value.zig+6-6

...	@@ -1739,8 +1739,8 @@ fn isByRef(ty: Type, mod: *Module) bool {	...	@@ -1739,8 +1739,8 @@ fn isByRef(ty: Type, mod: *Module) bool {
1739	.Frame,	1739	.Frame,
1740	=> return ty.hasRuntimeBitsIgnoreComptime(mod),	1740	=> return ty.hasRuntimeBitsIgnoreComptime(mod),
1741	.Union => {	1741	.Union => {
1742	if (ty.castTag(.@"union")) \|union_ty\| {	1742	if (mod.typeToUnion(ty)) \|union_obj\| {
1743	if (union_ty.data.layout == .Packed) {	1743	if (union_obj.layout == .Packed) {
1744	return ty.abiSize(mod) > 8;	1744	return ty.abiSize(mod) > 8;
1745	}	1745	}
1746	}	1746	}
...	@@ -3175,7 +3175,7 @@ fn lowerConstant(func: *CodeGen, arg_val: Value, ty: Type) InnerError!WValue {	...	@@ -3175,7 +3175,7 @@ fn lowerConstant(func: *CodeGen, arg_val: Value, ty: Type) InnerError!WValue {
3175	},	3175	},
3176	.Union => {	3176	.Union => {
3177	// in this case we have a packed union which will not be passed by reference.	3177	// in this case we have a packed union which will not be passed by reference.
3178	const union_ty = ty.cast(Type.Payload.Union).?.data;	3178	const union_ty = mod.typeToUnion(ty).?;
3179	const union_obj = val.castTag(.@"union").?.data;	3179	const union_obj = val.castTag(.@"union").?.data;
3180	const field_index = ty.unionTagFieldIndex(union_obj.tag, func.bin_file.base.options.module.?).?;	3180	const field_index = ty.unionTagFieldIndex(union_obj.tag, func.bin_file.base.options.module.?).?;
3181	const field_ty = union_ty.fields.values()[field_index].ty;	3181	const field_ty = union_ty.fields.values()[field_index].ty;
...	@@ -5086,12 +5086,12 @@ fn airUnionInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -5086,12 +5086,12 @@ fn airUnionInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
5086	const result = result: {	5086	const result = result: {
5087	const union_ty = func.typeOfIndex(inst);	5087	const union_ty = func.typeOfIndex(inst);
5088	const layout = union_ty.unionGetLayout(mod);	5088	const layout = union_ty.unionGetLayout(mod);
5089	const union_obj = union_ty.cast(Type.Payload.Union).?.data;	5089	const union_obj = mod.typeToUnion(union_ty).?;
5090	const field = union_obj.fields.values()[extra.field_index];	5090	const field = union_obj.fields.values()[extra.field_index];
5091	const field_name = union_obj.fields.keys()[extra.field_index];	5091	const field_name = union_obj.fields.keys()[extra.field_index];
5092		5092
5093	const tag_int = blk: {	5093	const tag_int = blk: {
5094	const tag_ty = union_ty.unionTagTypeHypothetical();	5094	const tag_ty = union_ty.unionTagTypeHypothetical(mod);
5095	const enum_field_index = tag_ty.enumFieldIndex(field_name).?;	5095	const enum_field_index = tag_ty.enumFieldIndex(field_name).?;
5096	var tag_val_payload: Value.Payload.U32 = .{	5096	var tag_val_payload: Value.Payload.U32 = .{
5097	.base = .{ .tag = .enum_field_index },	5097	.base = .{ .tag = .enum_field_index },

...	@@ -568,7 +568,7 @@ pub fn generateSymbol(	...	@@ -568,7 +568,7 @@ pub fn generateSymbol(
568		568
569	if (layout.payload_size == 0) {	569	if (layout.payload_size == 0) {
570	return generateSymbol(bin_file, src_loc, .{	570	return generateSymbol(bin_file, src_loc, .{
571	.ty = typed_value.ty.unionTagType().?,	571	.ty = typed_value.ty.unionTagType(mod).?,
572	.val = union_obj.tag,	572	.val = union_obj.tag,
573	}, code, debug_output, reloc_info);	573	}, code, debug_output, reloc_info);
574	}	574	}
...	@@ -576,7 +576,7 @@ pub fn generateSymbol(	...	@@ -576,7 +576,7 @@ pub fn generateSymbol(
576	// Check if we should store the tag first.	576	// Check if we should store the tag first.
577	if (layout.tag_align >= layout.payload_align) {	577	if (layout.tag_align >= layout.payload_align) {
578	switch (try generateSymbol(bin_file, src_loc, .{	578	switch (try generateSymbol(bin_file, src_loc, .{
579	.ty = typed_value.ty.unionTagType().?,	579	.ty = typed_value.ty.unionTagType(mod).?,
580	.val = union_obj.tag,	580	.val = union_obj.tag,
581	}, code, debug_output, reloc_info)) {	581	}, code, debug_output, reloc_info)) {
582	.ok => {},	582	.ok => {},
...	@@ -584,7 +584,7 @@ pub fn generateSymbol(	...	@@ -584,7 +584,7 @@ pub fn generateSymbol(
584	}	584	}
585	}	585	}
586		586
587	const union_ty = typed_value.ty.cast(Type.Payload.Union).?.data;	587	const union_ty = mod.typeToUnion(typed_value.ty).?;
588	const field_index = typed_value.ty.unionTagFieldIndex(union_obj.tag, mod).?;	588	const field_index = typed_value.ty.unionTagFieldIndex(union_obj.tag, mod).?;
589	assert(union_ty.haveFieldTypes());	589	assert(union_ty.haveFieldTypes());
590	const field_ty = union_ty.fields.values()[field_index].ty;	590	const field_ty = union_ty.fields.values()[field_index].ty;

...	@@ -2178,7 +2178,7 @@ pub const Object = struct {	...	@@ -2178,7 +2178,7 @@ pub const Object = struct {
2178	break :blk fwd_decl;	2178	break :blk fwd_decl;
2179	};	2179	};
2180		2180
2181	const union_obj = ty.cast(Type.Payload.Union).?.data;	2181	const union_obj = mod.typeToUnion(ty).?;
2182	if (!union_obj.haveFieldTypes() or !ty.hasRuntimeBitsIgnoreComptime(mod)) {	2182	if (!union_obj.haveFieldTypes() or !ty.hasRuntimeBitsIgnoreComptime(mod)) {
2183	const union_di_ty = try o.makeEmptyNamespaceDIType(owner_decl_index);	2183	const union_di_ty = try o.makeEmptyNamespaceDIType(owner_decl_index);
2184	dib.replaceTemporary(fwd_decl, union_di_ty);	2184	dib.replaceTemporary(fwd_decl, union_di_ty);
...	@@ -3063,7 +3063,7 @@ pub const DeclGen = struct {	...	@@ -3063,7 +3063,7 @@ pub const DeclGen = struct {
3063	gop.key_ptr.* = try t.copy(dg.object.type_map_arena.allocator());	3063	gop.key_ptr.* = try t.copy(dg.object.type_map_arena.allocator());
3064		3064
3065	const layout = t.unionGetLayout(mod);	3065	const layout = t.unionGetLayout(mod);
3066	const union_obj = t.cast(Type.Payload.Union).?.data;	3066	const union_obj = mod.typeToUnion(t).?;
3067		3067
3068	if (union_obj.layout == .Packed) {	3068	if (union_obj.layout == .Packed) {
3069	const bitsize = @intCast(c_uint, t.bitSize(mod));	3069	const bitsize = @intCast(c_uint, t.bitSize(mod));
...	@@ -3797,11 +3797,11 @@ pub const DeclGen = struct {	...	@@ -3797,11 +3797,11 @@ pub const DeclGen = struct {
3797		3797
3798	if (layout.payload_size == 0) {	3798	if (layout.payload_size == 0) {
3799	return lowerValue(dg, .{	3799	return lowerValue(dg, .{
3800	.ty = tv.ty.unionTagTypeSafety().?,	3800	.ty = tv.ty.unionTagTypeSafety(mod).?,
3801	.val = tag_and_val.tag,	3801	.val = tag_and_val.tag,
3802	});	3802	});
3803	}	3803	}
3804	const union_obj = tv.ty.cast(Type.Payload.Union).?.data;	3804	const union_obj = mod.typeToUnion(tv.ty).?;
3805	const field_index = tv.ty.unionTagFieldIndex(tag_and_val.tag, dg.module).?;	3805	const field_index = tv.ty.unionTagFieldIndex(tag_and_val.tag, dg.module).?;
3806	assert(union_obj.haveFieldTypes());	3806	assert(union_obj.haveFieldTypes());
3807		3807
...	@@ -3851,7 +3851,7 @@ pub const DeclGen = struct {	...	@@ -3851,7 +3851,7 @@ pub const DeclGen = struct {
3851	}	3851	}
3852	}	3852	}
3853	const llvm_tag_value = try lowerValue(dg, .{	3853	const llvm_tag_value = try lowerValue(dg, .{
3854	.ty = tv.ty.unionTagTypeSafety().?,	3854	.ty = tv.ty.unionTagTypeSafety(mod).?,
3855	.val = tag_and_val.tag,	3855	.val = tag_and_val.tag,
3856	});	3856	});
3857	var fields: [3]*llvm.Value = undefined;	3857	var fields: [3]*llvm.Value = undefined;
...	@@ -9410,7 +9410,7 @@ pub const FuncGen = struct {	...	@@ -9410,7 +9410,7 @@ pub const FuncGen = struct {
9410	const union_ty = self.typeOfIndex(inst);	9410	const union_ty = self.typeOfIndex(inst);
9411	const union_llvm_ty = try self.dg.lowerType(union_ty);	9411	const union_llvm_ty = try self.dg.lowerType(union_ty);
9412	const layout = union_ty.unionGetLayout(mod);	9412	const layout = union_ty.unionGetLayout(mod);
9413	const union_obj = union_ty.cast(Type.Payload.Union).?.data;	9413	const union_obj = mod.typeToUnion(union_ty).?;
9414		9414
9415	if (union_obj.layout == .Packed) {	9415	if (union_obj.layout == .Packed) {
9416	const big_bits = union_ty.bitSize(mod);	9416	const big_bits = union_ty.bitSize(mod);
...	@@ -9427,7 +9427,7 @@ pub const FuncGen = struct {	...	@@ -9427,7 +9427,7 @@ pub const FuncGen = struct {
9427	}	9427	}
9428		9428
9429	const tag_int = blk: {	9429	const tag_int = blk: {
9430	const tag_ty = union_ty.unionTagTypeHypothetical();	9430	const tag_ty = union_ty.unionTagTypeHypothetical(mod);
9431	const union_field_name = union_obj.fields.keys()[extra.field_index];	9431	const union_field_name = union_obj.fields.keys()[extra.field_index];
9432	const enum_field_index = tag_ty.enumFieldIndex(union_field_name).?;	9432	const enum_field_index = tag_ty.enumFieldIndex(union_field_name).?;
9433	var tag_val_payload: Value.Payload.U32 = .{	9433	var tag_val_payload: Value.Payload.U32 = .{

...	@@ -755,10 +755,10 @@ pub const DeclGen = struct {	...	@@ -755,10 +755,10 @@ pub const DeclGen = struct {
755	const layout = ty.unionGetLayout(mod);	755	const layout = ty.unionGetLayout(mod);
756		756
757	if (layout.payload_size == 0) {	757	if (layout.payload_size == 0) {
758	return try self.lower(ty.unionTagTypeSafety().?, tag_and_val.tag);	758	return try self.lower(ty.unionTagTypeSafety(mod).?, tag_and_val.tag);
759	}	759	}
760		760
761	const union_ty = ty.cast(Type.Payload.Union).?.data;	761	const union_ty = mod.typeToUnion(ty).?;
762	if (union_ty.layout == .Packed) {	762	if (union_ty.layout == .Packed) {
763	return dg.todo("packed union constants", .{});	763	return dg.todo("packed union constants", .{});
764	}	764	}
...	@@ -770,7 +770,7 @@ pub const DeclGen = struct {	...	@@ -770,7 +770,7 @@ pub const DeclGen = struct {
770	const tag_first = layout.tag_align >= layout.payload_align;	770	const tag_first = layout.tag_align >= layout.payload_align;
771		771
772	if (has_tag and tag_first) {	772	if (has_tag and tag_first) {
773	try self.lower(ty.unionTagTypeSafety().?, tag_and_val.tag);	773	try self.lower(ty.unionTagTypeSafety(mod).?, tag_and_val.tag);
774	}	774	}
775		775
776	const active_field_size = if (active_field_ty.hasRuntimeBitsIgnoreComptime(mod)) blk: {	776	const active_field_size = if (active_field_ty.hasRuntimeBitsIgnoreComptime(mod)) blk: {
...	@@ -782,7 +782,7 @@ pub const DeclGen = struct {	...	@@ -782,7 +782,7 @@ pub const DeclGen = struct {
782	try self.addUndef(payload_padding_len);	782	try self.addUndef(payload_padding_len);
783		783
784	if (has_tag and !tag_first) {	784	if (has_tag and !tag_first) {
785	try self.lower(ty.unionTagTypeSafety().?, tag_and_val.tag);	785	try self.lower(ty.unionTagTypeSafety(mod).?, tag_and_val.tag);
786	}	786	}
787		787
788	try self.addUndef(layout.padding);	788	try self.addUndef(layout.padding);
...	@@ -1121,7 +1121,7 @@ pub const DeclGen = struct {	...	@@ -1121,7 +1121,7 @@ pub const DeclGen = struct {
1121	fn resolveUnionType(self: *DeclGen, ty: Type, maybe_active_field: ?usize) !CacheRef {	1121	fn resolveUnionType(self: *DeclGen, ty: Type, maybe_active_field: ?usize) !CacheRef {
1122	const mod = self.module;	1122	const mod = self.module;
1123	const layout = ty.unionGetLayout(mod);	1123	const layout = ty.unionGetLayout(mod);
1124	const union_ty = ty.cast(Type.Payload.Union).?.data;	1124	const union_ty = mod.typeToUnion(ty).?;
1125		1125
1126	if (union_ty.layout == .Packed) {	1126	if (union_ty.layout == .Packed) {
1127	return self.todo("packed union types", .{});	1127	return self.todo("packed union types", .{});

...	@@ -715,7 +715,7 @@ pub const Value = struct {	...	@@ -715,7 +715,7 @@ pub const Value = struct {
715	}	715	}
716		716
717	pub fn tagName(val: Value, ty: Type, mod: *Module) []const u8 {	717	pub fn tagName(val: Value, ty: Type, mod: *Module) []const u8 {
718	if (ty.zigTypeTag(mod) == .Union) return val.unionTag().tagName(ty.unionTagTypeHypothetical(), mod);	718	if (ty.zigTypeTag(mod) == .Union) return val.unionTag().tagName(ty.unionTagTypeHypothetical(mod), mod);
719		719
720	const field_index = switch (val.tag()) {	720	const field_index = switch (val.tag()) {
721	.enum_field_index => val.castTag(.enum_field_index).?.data,	721	.enum_field_index => val.castTag(.enum_field_index).?.data,
...	@@ -1138,7 +1138,7 @@ pub const Value = struct {	...	@@ -1138,7 +1138,7 @@ pub const Value = struct {
1138	.Extern => unreachable, // Handled in non-packed writeToMemory	1138	.Extern => unreachable, // Handled in non-packed writeToMemory
1139	.Packed => {	1139	.Packed => {
1140	const field_index = ty.unionTagFieldIndex(val.unionTag(), mod);	1140	const field_index = ty.unionTagFieldIndex(val.unionTag(), mod);
1141	const field_type = ty.unionFields().values()[field_index.?].ty;	1141	const field_type = ty.unionFields(mod).values()[field_index.?].ty;
1142	const field_val = try val.fieldValue(field_type, mod, field_index.?);	1142	const field_val = try val.fieldValue(field_type, mod, field_index.?);
1143		1143
1144	return field_val.writeToPackedMemory(field_type, mod, buffer, bit_offset);	1144	return field_val.writeToPackedMemory(field_type, mod, buffer, bit_offset);
...	@@ -2021,7 +2021,7 @@ pub const Value = struct {	...	@@ -2021,7 +2021,7 @@ pub const Value = struct {
2021	const b_union = b.castTag(.@"union").?.data;	2021	const b_union = b.castTag(.@"union").?.data;
2022	switch (ty.containerLayout(mod)) {	2022	switch (ty.containerLayout(mod)) {
2023	.Packed, .Extern => {	2023	.Packed, .Extern => {
2024	const tag_ty = ty.unionTagTypeHypothetical();	2024	const tag_ty = ty.unionTagTypeHypothetical(mod);
2025	if (!(try eqlAdvanced(a_union.tag, tag_ty, b_union.tag, tag_ty, mod, opt_sema))) {	2025	if (!(try eqlAdvanced(a_union.tag, tag_ty, b_union.tag, tag_ty, mod, opt_sema))) {
2026	// In this case, we must disregard mismatching tags and compare	2026	// In this case, we must disregard mismatching tags and compare
2027	// based on the in-memory bytes of the payloads.	2027	// based on the in-memory bytes of the payloads.
...	@@ -2029,7 +2029,7 @@ pub const Value = struct {	...	@@ -2029,7 +2029,7 @@ pub const Value = struct {
2029	}	2029	}
2030	},	2030	},
2031	.Auto => {	2031	.Auto => {
2032	const tag_ty = ty.unionTagTypeHypothetical();	2032	const tag_ty = ty.unionTagTypeHypothetical(mod);
2033	if (!(try eqlAdvanced(a_union.tag, tag_ty, b_union.tag, tag_ty, mod, opt_sema))) {	2033	if (!(try eqlAdvanced(a_union.tag, tag_ty, b_union.tag, tag_ty, mod, opt_sema))) {
2034	return false;	2034	return false;
2035	}	2035	}
...	@@ -2118,7 +2118,7 @@ pub const Value = struct {	...	@@ -2118,7 +2118,7 @@ pub const Value = struct {
2118	return false;	2118	return false;
2119	}	2119	}
2120	const field_name = tuple.names[0];	2120	const field_name = tuple.names[0];
2121	const union_obj = ty.cast(Type.Payload.Union).?.data;	2121	const union_obj = mod.typeToUnion(ty).?;
2122	const field_index = union_obj.fields.getIndex(field_name) orelse return false;	2122	const field_index = union_obj.fields.getIndex(field_name) orelse return false;
2123	const tag_and_val = b.castTag(.@"union").?.data;	2123	const tag_and_val = b.castTag(.@"union").?.data;
2124	var field_tag_buf: Value.Payload.U32 = .{	2124	var field_tag_buf: Value.Payload.U32 = .{
...	@@ -2297,7 +2297,7 @@ pub const Value = struct {	...	@@ -2297,7 +2297,7 @@ pub const Value = struct {
2297	},	2297	},
2298	.Union => {	2298	.Union => {
2299	const union_obj = val.cast(Payload.Union).?.data;	2299	const union_obj = val.cast(Payload.Union).?.data;
2300	if (ty.unionTagType()) \|tag_ty\| {	2300	if (ty.unionTagType(mod)) \|tag_ty\| {
2301	union_obj.tag.hash(tag_ty, hasher, mod);	2301	union_obj.tag.hash(tag_ty, hasher, mod);
2302	}	2302	}
2303	const active_field_ty = ty.unionFieldType(union_obj.tag, mod);	2303	const active_field_ty = ty.unionFieldType(union_obj.tag, mod);