Commit 7ef1eb1c27754cb0349fdc10db1f02ff2dddd99b | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-08-17 14:25:18-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-08-17 18:16:03-07:00
log	7ef1eb1c27754cb0349fdc10db1f02ff2dddd99b
tree	6a76839d8be347648741e17f50d6c70d8313adc3
parent	8c1329b222ab620d7388d766e9e558baa502ce93

InternPool: safer enum API

The key changes in this commit are:

```diff
-        names: []const NullTerminatedString,
+        names: NullTerminatedString.Slice,
-        values: []const Index,
+        values: Index.Slice,
```

Which eliminates the slices from `InternPool.Key.EnumType` and replaces
them with structs that contain `start` and `len` indexes. This makes the
lifetime of `EnumType` change from expiring with updates to InternPool,
to expiring when the InternPool is garbage-collected, which is currently
never.

This is gearing up for a larger change I started working on locally
which moves union types into InternPool.

As a bonus, I fixed some unnecessary instances of `@as`.

8 files changed, 176 insertions(+), 142 deletions(-)

src
- InternPool.zig
- Module.zig
- Sema.zig
- TypedValue.zig
- codegen
  - llvm.zig
- link
  - Dwarf.zig
- type.zig
- value.zig

src/InternPool.zig+137-110

 @@ -105,7 +105,7 @@ pub const OptionalMapIndex = enum(u32) {
     pub fn unwrap(oi: OptionalMapIndex) ?MapIndex {
         if (oi == .none) return null;
-        return @as(MapIndex, @enumFromInt(@intFromEnum(oi)));
+        return @enumFromInt(@intFromEnum(oi));
     }
 };
 @@ -114,7 +114,7 @@ pub const MapIndex = enum(u32) {
     _,
     pub fn toOptional(i: MapIndex) OptionalMapIndex {
-        return @as(OptionalMapIndex, @enumFromInt(@intFromEnum(i)));
+        return @enumFromInt(@intFromEnum(i));
     }
 };
 @@ -218,7 +218,7 @@ pub const OptionalNullTerminatedString = enum(u32) {
     pub fn unwrap(oi: OptionalNullTerminatedString) ?NullTerminatedString {
         if (oi == .none) return null;
-        return @as(NullTerminatedString, @enumFromInt(@intFromEnum(oi)));
+        return @enumFromInt(@intFromEnum(oi));
     }
 };
 @@ -415,11 +415,11 @@ pub const Key = union(enum) {
         /// explicitly provided tag type or auto-numbered.
         tag_ty: Index,
         /// Set of field names in declaration order.
-        names: []const NullTerminatedString,
+        names: NullTerminatedString.Slice,
         /// Maps integer tag value to field index.
         /// Entries are in declaration order, same as `fields`.
         /// If this is empty, it means the enum tags are auto-numbered.
-        values: []const Index,
+        values: Index.Slice,
         tag_mode: TagMode,
         /// This is ignored by `get` but will always be provided by `indexToKey`.
         names_map: OptionalMapIndex = .none,
 @@ -441,9 +441,9 @@ pub const Key = union(enum) {
         /// Look up field index based on field name.
         pub fn nameIndex(self: EnumType, ip: *const InternPool, name: NullTerminatedString) ?u32 {
             const map = &ip.maps.items[@intFromEnum(self.names_map.unwrap().?)];
-            const adapter: NullTerminatedString.Adapter = .{ .strings = self.names };
+            const adapter: NullTerminatedString.Adapter = .{ .strings = self.names.get(ip) };
             const field_index = map.getIndexAdapted(name, adapter) orelse return null;
-            return @as(u32, @intCast(field_index));
+            return @intCast(field_index);
         }
         /// Look up field index based on tag value.
 @@ -461,9 +461,9 @@ pub const Key = union(enum) {
             };
             if (self.values_map.unwrap()) |values_map| {
                 const map = &ip.maps.items[@intFromEnum(values_map)];
-                const adapter: Index.Adapter = .{ .indexes = self.values };
+                const adapter: Index.Adapter = .{ .indexes = self.values.get(ip) };
                 const field_index = map.getIndexAdapted(int_tag_val, adapter) orelse return null;
-                return @as(u32, @intCast(field_index));
+                return @intCast(field_index);
             }
             // Auto-numbered enum. Convert `int_tag_val` to field index.
             const field_index = switch (ip.indexToKey(int_tag_val).int.storage) {
 @@ -497,8 +497,8 @@ pub const Key = union(enum) {
                 .namespace = self.namespace,
                 .tag_ty = self.tag_ty,
                 .tag_mode = self.tag_mode,
-                .names = &.{},
+                .names = .{ .start = 0, .len = 0 },
-                .values = &.{},
+                .values = .{ .start = 0, .len = 0 },
             };
         }
 @@ -2570,7 +2570,7 @@ pub const Alignment = enum(u6) {
     pub fn fromByteUnits(n: u64) Alignment {
         if (n == 0) return .none;
         assert(std.math.isPowerOfTwo(n));
-        return @as(Alignment, @enumFromInt(@ctz(n)));
+        return @enumFromInt(@ctz(n));
     }
     pub fn fromNonzeroByteUnits(n: u64) Alignment {
 @@ -2647,11 +2647,11 @@ pub const PackedU64 = packed struct(u64) {
     b: u32,
     pub fn get(x: PackedU64) u64 {
-        return @as(u64, @bitCast(x));
+        return @bitCast(x);
     }
     pub fn init(x: u64) PackedU64 {
-        return @as(PackedU64, @bitCast(x));
+        return @bitCast(x);
     }
 };
 @@ -2714,7 +2714,7 @@ pub const Float64 = struct {
     pub fn get(self: Float64) f64 {
         const int_bits = @as(u64, self.piece0) | (@as(u64, self.piece1) << 32);
-        return @as(f64, @bitCast(int_bits));
+        return @bitCast(int_bits);
     }
     fn pack(val: f64) Float64 {
 @@ -2736,7 +2736,7 @@ pub const Float80 = struct {
         const int_bits = @as(u80, self.piece0) |
             (@as(u80, self.piece1) << 32) |
             (@as(u80, self.piece2) << 64);
-        return @as(f80, @bitCast(int_bits));
+        return @bitCast(int_bits);
     }
     fn pack(val: f80) Float80 {
 @@ -2761,7 +2761,7 @@ pub const Float128 = struct {
             (@as(u128, self.piece1) << 32) |
             (@as(u128, self.piece2) << 64) |
             (@as(u128, self.piece3) << 96);
-        return @as(f128, @bitCast(int_bits));
+        return @bitCast(int_bits);
     }
     fn pack(val: f128) Float128 {
 @@ -2968,16 +2968,18 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         .type_enum_auto => {
             const enum_auto = ip.extraDataTrail(EnumAuto, data);
-            const names = @as(
-                []const NullTerminatedString,
-                @ptrCast(ip.extra.items[enum_auto.end..][0..enum_auto.data.fields_len]),
-            );
             return .{ .enum_type = .{
                 .decl = enum_auto.data.decl,
                 .namespace = enum_auto.data.namespace,
                 .tag_ty = enum_auto.data.int_tag_type,
-                .names = names,
+                .names = .{
-                .values = &.{},
+                    .start = @intCast(enum_auto.end),
+                    .len = enum_auto.data.fields_len,
+                },
+                .values = .{
+                    .start = 0,
+                    .len = 0,
+                },
                 .tag_mode = .auto,
                 .names_map = enum_auto.data.names_map.toOptional(),
                 .values_map = .none,
 @@ -3443,21 +3445,19 @@ fn extraFuncCoerced(ip: *const InternPool, extra_index: u32) Key.Func {
 fn indexToKeyEnum(ip: *const InternPool, data: u32, tag_mode: Key.EnumType.TagMode) Key {
     const enum_explicit = ip.extraDataTrail(EnumExplicit, data);
-    const names = @as(
+    const fields_len = enum_explicit.data.fields_len;
-        []const NullTerminatedString,
-        @ptrCast(ip.extra.items[enum_explicit.end..][0..enum_explicit.data.fields_len]),
-    );
-    const values = if (enum_explicit.data.values_map != .none) @as(
-        []const Index,
-        @ptrCast(ip.extra.items[enum_explicit.end + names.len ..][0..enum_explicit.data.fields_len]),
-    ) else &[0]Index{};
     return .{ .enum_type = .{
         .decl = enum_explicit.data.decl,
         .namespace = enum_explicit.data.namespace,
         .tag_ty = enum_explicit.data.int_tag_type,
-        .names = names,
+        .names = .{
-        .values = values,
+            .start = @intCast(enum_explicit.end),
+            .len = fields_len,
+        },
+        .values = .{
+            .start = @intCast(enum_explicit.end + fields_len),
+            .len = if (enum_explicit.data.values_map != .none) fields_len else 0,
+        },
         .tag_mode = tag_mode,
         .names_map = enum_explicit.data.names_map.toOptional(),
         .values_map = enum_explicit.data.values_map,
 @@ -3506,7 +3506,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     .tag = .type_slice,
                     .data = @intFromEnum(ptr_type_index),
                 });
-                return @as(Index, @enumFromInt(ip.items.len - 1));
+                return @enumFromInt(ip.items.len - 1);
             }
             var ptr_type_adjusted = ptr_type;
 @@ -3530,7 +3530,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                             .child = array_type.child,
                         }),
                     });
-                    return @as(Index, @enumFromInt(ip.items.len - 1));
+                    return @enumFromInt(ip.items.len - 1);
                 }
             }
 @@ -3643,7 +3643,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
             assert(anon_struct_type.types.len == anon_struct_type.values.len);
             for (anon_struct_type.types) |elem| assert(elem != .none);
-            const fields_len = @as(u32, @intCast(anon_struct_type.types.len));
+            const fields_len: u32 = @intCast(anon_struct_type.types.len);
             if (anon_struct_type.names.len == 0) {
                 try ip.extra.ensureUnusedCapacity(
                     gpa,
 @@ -3655,9 +3655,9 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                         .fields_len = fields_len,
                     }),
                 });
-                ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(anon_struct_type.types)));
+                ip.extra.appendSliceAssumeCapacity(@ptrCast(anon_struct_type.types));
-                ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(anon_struct_type.values)));
+                ip.extra.appendSliceAssumeCapacity(@ptrCast(anon_struct_type.values));
-                return @as(Index, @enumFromInt(ip.items.len - 1));
+                return @enumFromInt(ip.items.len - 1);
             }
             assert(anon_struct_type.names.len == anon_struct_type.types.len);
 @@ -3672,10 +3672,10 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     .fields_len = fields_len,
                 }),
             });
-            ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(anon_struct_type.types)));
+            ip.extra.appendSliceAssumeCapacity(@ptrCast(anon_struct_type.types));
-            ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(anon_struct_type.values)));
+            ip.extra.appendSliceAssumeCapacity(@ptrCast(anon_struct_type.values));
-            ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(anon_struct_type.names)));
+            ip.extra.appendSliceAssumeCapacity(@ptrCast(anon_struct_type.names));
-            return @as(Index, @enumFromInt(ip.items.len - 1));
+            return @enumFromInt(ip.items.len - 1);
         },
         .union_type => |union_type| {
 @@ -3696,38 +3696,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
             });
         },
-        .enum_type => |enum_type| {
+        .enum_type => unreachable, // use getEnum() or getIncompleteEnum() instead
-            assert(enum_type.tag_ty == .noreturn_type or ip.isIntegerType(enum_type.tag_ty));
-            for (enum_type.values) |value| assert(ip.typeOf(value) == enum_type.tag_ty);
-            assert(enum_type.names_map == .none);
-            assert(enum_type.values_map == .none);
-            switch (enum_type.tag_mode) {
-                .auto => {
-                    const names_map = try ip.addMap(gpa);
-                    try addStringsToMap(ip, gpa, names_map, enum_type.names);
-                    const fields_len = @as(u32, @intCast(enum_type.names.len));
-                    try ip.extra.ensureUnusedCapacity(gpa, @typeInfo(EnumAuto).Struct.fields.len +
-                        fields_len);
-                    ip.items.appendAssumeCapacity(.{
-                        .tag = .type_enum_auto,
-                        .data = ip.addExtraAssumeCapacity(EnumAuto{
-                            .decl = enum_type.decl,
-                            .namespace = enum_type.namespace,
-                            .int_tag_type = enum_type.tag_ty,
-                            .names_map = names_map,
-                            .fields_len = fields_len,
-                        }),
-                    });
-                    ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(enum_type.names)));
-                    return @as(Index, @enumFromInt(ip.items.len - 1));
-                },
-                .explicit => return finishGetEnum(ip, gpa, enum_type, .type_enum_explicit),
-                .nonexhaustive => return finishGetEnum(ip, gpa, enum_type, .type_enum_nonexhaustive),
-            }
-        },
         .func_type => unreachable, // use getFuncType() instead
         .extern_func => unreachable, // use getExternFunc() instead
         .func => unreachable, // use getFuncInstance() or getFuncDecl() instead
 @@ -3915,7 +3884,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                             .lazy_ty = lazy_ty,
                         }),
                     });
-                    return @as(Index, @enumFromInt(ip.items.len - 1));
+                    return @enumFromInt(ip.items.len - 1);
                 },
             }
             switch (int.ty) {
 @@ -4056,7 +4025,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                                 .value = casted,
                             }),
                         });
-                        return @as(Index, @enumFromInt(ip.items.len - 1));
+                        return @enumFromInt(ip.items.len - 1);
                     } else |_| {}
                     const tag: Tag = if (big_int.positive) .int_positive else .int_negative;
 @@ -4071,7 +4040,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                                 .value = casted,
                             }),
                         });
-                        return @as(Index, @enumFromInt(ip.items.len - 1));
+                        return @enumFromInt(ip.items.len - 1);
                     }
                     var buf: [2]Limb = undefined;
 @@ -4234,7 +4203,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     .tag = .only_possible_value,
                     .data = @intFromEnum(aggregate.ty),
                 });
-                return @as(Index, @enumFromInt(ip.items.len - 1));
+                return @enumFromInt(ip.items.len - 1);
             }
             switch (ty_key) {
 @@ -4262,7 +4231,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                         .tag = .only_possible_value,
                         .data = @intFromEnum(aggregate.ty),
                     });
-                    return @as(Index, @enumFromInt(ip.items.len - 1));
+                    return @enumFromInt(ip.items.len - 1);
                 },
                 else => {},
             }
 @@ -4301,7 +4270,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                         .elem_val = elem,
                     }),
                 });
-                return @as(Index, @enumFromInt(ip.items.len - 1));
+                return @enumFromInt(ip.items.len - 1);
             }
             if (child == .u8_type) bytes: {
 @@ -4345,7 +4314,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                         .bytes = string,
                     }),
                 });
-                return @as(Index, @enumFromInt(ip.items.len - 1));
+                return @enumFromInt(ip.items.len - 1);
             }
             try ip.extra.ensureUnusedCapacity(
 @@ -4358,7 +4327,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     .ty = aggregate.ty,
                 }),
             });
-            ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(aggregate.storage.elems)));
+            ip.extra.appendSliceAssumeCapacity(@ptrCast(aggregate.storage.elems));
             if (sentinel != .none) ip.extra.appendAssumeCapacity(@intFromEnum(sentinel));
         },
 @@ -4384,7 +4353,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                     .result = memoized_call.result,
                 }),
             });
-            ip.extra.appendSliceAssumeCapacity(@as([]const u32, @ptrCast(memoized_call.arg_values)));
+            ip.extra.appendSliceAssumeCapacity(@ptrCast(memoized_call.arg_values));
         },
     }
     return @enumFromInt(ip.items.len - 1);
 @@ -5017,7 +4986,7 @@ pub const IncompleteEnumType = struct {
             .strings = @as([]const NullTerminatedString, @ptrCast(strings)),
         };
         const gop = try map.getOrPutAdapted(gpa, name, adapter);
-        if (gop.found_existing) return @as(u32, @intCast(gop.index));
+        if (gop.found_existing) return @intCast(gop.index);
         ip.extra.items[self.names_start + field_index] = @intFromEnum(name);
         return null;
     }
 @@ -5038,7 +5007,7 @@ pub const IncompleteEnumType = struct {
             .indexes = @as([]const Index, @ptrCast(indexes)),
         };
         const gop = try map.getOrPutAdapted(gpa, value, adapter);
-        if (gop.found_existing) return @as(u32, @intCast(gop.index));
+        if (gop.found_existing) return @intCast(gop.index);
         ip.extra.items[self.values_start + field_index] = @intFromEnum(value);
         return null;
     }
 @@ -5158,36 +5127,94 @@ fn getIncompleteEnumExplicit(
     };
 }
+pub const GetEnumInit = struct {
+    decl: Module.Decl.Index,
+    namespace: Module.Namespace.OptionalIndex,
+    tag_ty: Index,
+    names: []const NullTerminatedString,
+    values: []const Index,
+    tag_mode: Key.EnumType.TagMode,
+};
+pub fn getEnum(ip: *InternPool, gpa: Allocator, ini: GetEnumInit) Allocator.Error!Index {
+    const adapter: KeyAdapter = .{ .intern_pool = ip };
+    const gop = try ip.map.getOrPutAdapted(gpa, Key{
+        .enum_type = .{
+            // Only the decl is used for hashing and equality.
+            .decl = ini.decl,
+            .namespace = undefined,
+            .tag_ty = undefined,
+            .names = undefined,
+            .values = undefined,
+            .tag_mode = undefined,
+            .names_map = undefined,
+            .values_map = undefined,
+        },
+    }, adapter);
+    if (gop.found_existing) return @enumFromInt(gop.index);
+    errdefer _ = ip.map.pop();
+    try ip.items.ensureUnusedCapacity(gpa, 1);
+    assert(ini.tag_ty == .noreturn_type or ip.isIntegerType(ini.tag_ty));
+    for (ini.values) |value| assert(ip.typeOf(value) == ini.tag_ty);
+    switch (ini.tag_mode) {
+        .auto => {
+            const names_map = try ip.addMap(gpa);
+            try addStringsToMap(ip, gpa, names_map, ini.names);
+            const fields_len: u32 = @intCast(ini.names.len);
+            try ip.extra.ensureUnusedCapacity(gpa, @typeInfo(EnumAuto).Struct.fields.len +
+                fields_len);
+            ip.items.appendAssumeCapacity(.{
+                .tag = .type_enum_auto,
+                .data = ip.addExtraAssumeCapacity(EnumAuto{
+                    .decl = ini.decl,
+                    .namespace = ini.namespace,
+                    .int_tag_type = ini.tag_ty,
+                    .names_map = names_map,
+                    .fields_len = fields_len,
+                }),
+            });
+            ip.extra.appendSliceAssumeCapacity(@ptrCast(ini.names));
+            return @enumFromInt(ip.items.len - 1);
+        },
+        .explicit => return finishGetEnum(ip, gpa, ini, .type_enum_explicit),
+        .nonexhaustive => return finishGetEnum(ip, gpa, ini, .type_enum_nonexhaustive),
+    }
+}
 pub fn finishGetEnum(
     ip: *InternPool,
     gpa: Allocator,
-    enum_type: Key.EnumType,
+    ini: GetEnumInit,
     tag: Tag,
 ) Allocator.Error!Index {
     const names_map = try ip.addMap(gpa);
-    try addStringsToMap(ip, gpa, names_map, enum_type.names);
+    try addStringsToMap(ip, gpa, names_map, ini.names);
-    const values_map: OptionalMapIndex = if (enum_type.values.len == 0) .none else m: {
+    const values_map: OptionalMapIndex = if (ini.values.len == 0) .none else m: {
         const values_map = try ip.addMap(gpa);
-        try addIndexesToMap(ip, gpa, values_map, enum_type.values);
+        try addIndexesToMap(ip, gpa, values_map, ini.values);
         break :m values_map.toOptional();
     };
-    const fields_len = @as(u32, @intCast(enum_type.names.len));
+    const fields_len: u32 = @intCast(ini.names.len);
     try ip.extra.ensureUnusedCapacity(gpa, @typeInfo(EnumExplicit).Struct.fields.len +
         fields_len);
     ip.items.appendAssumeCapacity(.{
         .tag = tag,
         .data = ip.addExtraAssumeCapacity(EnumExplicit{
-            .decl = enum_type.decl,
+            .decl = ini.decl,
-            .namespace = enum_type.namespace,
+            .namespace = ini.namespace,
-            .int_tag_type = enum_type.tag_ty,
+            .int_tag_type = ini.tag_ty,
             .fields_len = fields_len,
             .names_map = names_map,
             .values_map = values_map,
         }),
     });
-    ip.extra.appendSliceAssumeCapacity(@ptrCast(enum_type.names));
+    ip.extra.appendSliceAssumeCapacity(@ptrCast(ini.names));
-    ip.extra.appendSliceAssumeCapacity(@ptrCast(enum_type.values));
+    ip.extra.appendSliceAssumeCapacity(@ptrCast(ini.values));
     return @enumFromInt(ip.items.len - 1);
 }
 @@ -5486,7 +5513,7 @@ pub fn slicePtrType(ip: *const InternPool, i: Index) Index {
     }
     const item = ip.items.get(@intFromEnum(i));
     switch (item.tag) {
-        .type_slice => return @as(Index, @enumFromInt(item.data)),
+        .type_slice => return @enumFromInt(item.data),
         else => unreachable, // not a slice type
     }
 }
 @@ -5618,7 +5645,7 @@ pub fn getCoerced(ip: *InternPool, gpa: Allocator, val: Index, new_ty: Index) Al
                 return ip.get(gpa, .{ .enum_tag = .{
                     .ty = new_ty,
                     .int = if (enum_type.values.len != 0)
-                        enum_type.values[index]
+                        enum_type.values.get(ip)[index]
                     else
                         try ip.get(gpa, .{ .int = .{
                             .ty = enum_type.tag_ty,
 @@ -6362,7 +6389,7 @@ pub fn createStruct(
     }
     const ptr = try ip.allocated_structs.addOne(gpa);
     ptr.* = initialization;
-    return @as(Module.Struct.Index, @enumFromInt(ip.allocated_structs.len - 1));
+    return @enumFromInt(ip.allocated_structs.len - 1);
 }
 pub fn destroyStruct(ip: *InternPool, gpa: Allocator, index: Module.Struct.Index) void {
 @@ -6384,7 +6411,7 @@ pub fn createUnion(
     }
     const ptr = try ip.allocated_unions.addOne(gpa);
     ptr.* = initialization;
-    return @as(Module.Union.Index, @enumFromInt(ip.allocated_unions.len - 1));
+    return @enumFromInt(ip.allocated_unions.len - 1);
 }
 pub fn destroyUnion(ip: *InternPool, gpa: Allocator, index: Module.Union.Index) void {
 @@ -6406,7 +6433,7 @@ pub fn createDecl(
     }
     const ptr = try ip.allocated_decls.addOne(gpa);
     ptr.* = initialization;
-    return @as(Module.Decl.Index, @enumFromInt(ip.allocated_decls.len - 1));
+    return @enumFromInt(ip.allocated_decls.len - 1);
 }
 pub fn destroyDecl(ip: *InternPool, gpa: Allocator, index: Module.Decl.Index) void {
 @@ -6428,7 +6455,7 @@ pub fn createNamespace(
     }
     const ptr = try ip.allocated_namespaces.addOne(gpa);
     ptr.* = initialization;
-    return @as(Module.Namespace.Index, @enumFromInt(ip.allocated_namespaces.len - 1));
+    return @enumFromInt(ip.allocated_namespaces.len - 1);
 }
 pub fn destroyNamespace(ip: *InternPool, gpa: Allocator, index: Module.Namespace.Index) void {
 @@ -6495,11 +6522,11 @@ pub fn getOrPutTrailingString(
     });
     if (gop.found_existing) {
         string_bytes.shrinkRetainingCapacity(str_index);
-        return @as(NullTerminatedString, @enumFromInt(gop.key_ptr.*));
+        return @enumFromInt(gop.key_ptr.*);
     } else {
         gop.key_ptr.* = str_index;
         string_bytes.appendAssumeCapacity(0);
-        return @as(NullTerminatedString, @enumFromInt(str_index));
+        return @enumFromInt(str_index);
     }
 }
 @@ -6725,7 +6752,7 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
 /// Assumes that the enum's field indexes equal its value tags.
 pub fn toEnum(ip: *const InternPool, comptime E: type, i: Index) E {
     const int = ip.indexToKey(i).enum_tag.int;
-    return @as(E, @enumFromInt(ip.indexToKey(int).int.storage.u64));
+    return @enumFromInt(ip.indexToKey(int).int.storage.u64);
 }
 pub fn aggregateTypeLen(ip: *const InternPool, ty: Index) u64 {
 @@ -6758,9 +6785,9 @@ pub fn funcTypeReturnType(ip: *const InternPool, ty: Index) Index {
         else => unreachable,
     };
     assert(child_item.tag == .type_function);
-    return @as(Index, @enumFromInt(ip.extra.items[
+    return @enumFromInt(ip.extra.items[
         child_item.data + std.meta.fieldIndex(Tag.TypeFunction, "return_type").?
-    ]));
+    ]);
 }
 pub fn isNoReturn(ip: *const InternPool, ty: Index) bool {
 @@ -6791,9 +6818,9 @@ pub fn getBackingDecl(ip: *const InternPool, val: Index) Module.Decl.OptionalInd
         switch (ip.items.items(.tag)[base]) {
             inline .ptr_decl,
             .ptr_mut_decl,
-            => |tag| return @as(Module.Decl.OptionalIndex, @enumFromInt(ip.extra.items[
+            => |tag| return @enumFromInt(ip.extra.items[
                 ip.items.items(.data)[base] + std.meta.fieldIndex(tag.Payload(), "decl").?
-            ])),
+            ]),
             inline .ptr_eu_payload,
             .ptr_opt_payload,
             .ptr_elem,

src/Module.zig+1-1

...	@@ -6655,7 +6655,7 @@ pub fn enumValueFieldIndex(mod: *Module, ty: Type, field_index: u32) Allocator.E	...	@@ -6655,7 +6655,7 @@ pub fn enumValueFieldIndex(mod: *Module, ty: Type, field_index: u32) Allocator.E
6655		6655
6656	return (try ip.get(gpa, .{ .enum_tag = .{	6656	return (try ip.get(gpa, .{ .enum_tag = .{
6657	.ty = ty.toIntern(),	6657	.ty = ty.toIntern(),
6658	.int = enum_type.values[field_index],	6658	.int = enum_type.values.get(ip)[field_index],
6659	} })).toValue();	6659	} })).toValue();
6660	}	6660	}
6661		6661

src/Sema.zig+17-14

...	@@ -17170,14 +17170,14 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -17170,14 +17170,14 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
17170	for (enum_field_vals, 0..) \|*field_val, i\| {	17170	for (enum_field_vals, 0..) \|*field_val, i\| {
17171	const enum_type = ip.indexToKey(ty.toIntern()).enum_type;	17171	const enum_type = ip.indexToKey(ty.toIntern()).enum_type;
17172	const value_val = if (enum_type.values.len > 0)	17172	const value_val = if (enum_type.values.len > 0)
17173	try mod.intern_pool.getCoerced(gpa, enum_type.values[i], .comptime_int_type)	17173	try mod.intern_pool.getCoerced(gpa, enum_type.values.get(ip)[i], .comptime_int_type)
17174	else	17174	else
17175	try mod.intern(.{ .int = .{	17175	try mod.intern(.{ .int = .{
17176	.ty = .comptime_int_type,	17176	.ty = .comptime_int_type,
17177	.storage = .{ .u64 = @as(u64, @intCast(i)) },	17177	.storage = .{ .u64 = @as(u64, @intCast(i)) },
17178	} });	17178	} });
17179	// TODO: write something like getCoercedInts to avoid needing to dupe	17179	// TODO: write something like getCoercedInts to avoid needing to dupe
17180	const name = try sema.arena.dupe(u8, ip.stringToSlice(enum_type.names[i]));	17180	const name = try sema.arena.dupe(u8, ip.stringToSlice(enum_type.names.get(ip)[i]));
17181	const name_val = v: {	17181	const name_val = v: {
17182	var anon_decl = try block.startAnonDecl();	17182	var anon_decl = try block.startAnonDecl();
17183	defer anon_decl.deinit();	17183	defer anon_decl.deinit();
...	@@ -20601,7 +20601,7 @@ fn zirReify(	...	@@ -20601,7 +20601,7 @@ fn zirReify(
20601	errdefer msg.destroy(gpa);	20601	errdefer msg.destroy(gpa);
20602		20602
20603	const enum_ty = union_obj.tag_ty;	20603	const enum_ty = union_obj.tag_ty;
20604	for (tag_info.names, 0..) \|field_name, field_index\| {	20604	for (tag_info.names.get(ip), 0..) \|field_name, field_index\| {
20605	if (explicit_tags_seen[field_index]) continue;	20605	if (explicit_tags_seen[field_index]) continue;
20606	try sema.addFieldErrNote(enum_ty, field_index, msg, "field '{}' missing, declared here", .{	20606	try sema.addFieldErrNote(enum_ty, field_index, msg, "field '{}' missing, declared here", .{
20607	field_name.fmt(ip),	20607	field_name.fmt(ip),
...	@@ -35420,7 +35420,7 @@ fn semaUnionFields(mod: Module, union_obj: Module.Union) CompileError!void {	...	@@ -35420,7 +35420,7 @@ fn semaUnionFields(mod: Module, union_obj: Module.Union) CompileError!void {
35420	errdefer msg.destroy(sema.gpa);	35420	errdefer msg.destroy(sema.gpa);
35421		35421
35422	const enum_ty = union_obj.tag_ty;	35422	const enum_ty = union_obj.tag_ty;
35423	for (tag_info.names, 0..) \|field_name, field_index\| {	35423	for (tag_info.names.get(ip), 0..) \|field_name, field_index\| {
35424	if (explicit_tags_seen[field_index]) continue;	35424	if (explicit_tags_seen[field_index]) continue;
35425	try sema.addFieldErrNote(enum_ty, field_index, msg, "field '{}' missing, declared here", .{	35425	try sema.addFieldErrNote(enum_ty, field_index, msg, "field '{}' missing, declared here", .{
35426	field_name.fmt(ip),	35426	field_name.fmt(ip),
...	@@ -35452,12 +35452,13 @@ fn generateUnionTagTypeNumbered(	...	@@ -35452,12 +35452,13 @@ fn generateUnionTagTypeNumbered(
35452	) !Type {	35452	) !Type {
35453	const mod = sema.mod;	35453	const mod = sema.mod;
35454	const gpa = sema.gpa;	35454	const gpa = sema.gpa;
		35455	const ip = &mod.intern_pool;
35455		35456
35456	const src_decl = mod.declPtr(block.src_decl);	35457	const src_decl = mod.declPtr(block.src_decl);
35457	const new_decl_index = try mod.allocateNewDecl(block.namespace, src_decl.src_node, block.wip_capture_scope);	35458	const new_decl_index = try mod.allocateNewDecl(block.namespace, src_decl.src_node, block.wip_capture_scope);
35458	errdefer mod.destroyDecl(new_decl_index);	35459	errdefer mod.destroyDecl(new_decl_index);
35459	const fqn = try union_obj.getFullyQualifiedName(mod);	35460	const fqn = try union_obj.getFullyQualifiedName(mod);
35460	const name = try mod.intern_pool.getOrPutStringFmt(gpa, "@typeInfo({}).Union.tag_type.?", .{fqn.fmt(&mod.intern_pool)});	35461	const name = try ip.getOrPutStringFmt(gpa, "@typeInfo({}).Union.tag_type.?", .{fqn.fmt(ip)});
35461	try mod.initNewAnonDecl(new_decl_index, src_decl.src_line, .{	35462	try mod.initNewAnonDecl(new_decl_index, src_decl.src_line, .{
35462	.ty = Type.noreturn,	35463	.ty = Type.noreturn,
35463	.val = Value.@"unreachable",	35464	.val = Value.@"unreachable",
...	@@ -35469,17 +35470,17 @@ fn generateUnionTagTypeNumbered(	...	@@ -35469,17 +35470,17 @@ fn generateUnionTagTypeNumbered(
35469	new_decl.owns_tv = true;	35470	new_decl.owns_tv = true;
35470	new_decl.name_fully_qualified = true;	35471	new_decl.name_fully_qualified = true;
35471		35472
35472	const enum_ty = try mod.intern(.{ .enum_type = .{	35473	const enum_ty = try ip.getEnum(gpa, .{
35473	.decl = new_decl_index,	35474	.decl = new_decl_index,
35474	.namespace = .none,	35475	.namespace = .none,
35475	.tag_ty = if (enum_field_vals.len == 0)	35476	.tag_ty = if (enum_field_vals.len == 0)
35476	(try mod.intType(.unsigned, 0)).toIntern()	35477	(try mod.intType(.unsigned, 0)).toIntern()
35477	else	35478	else
35478	mod.intern_pool.typeOf(enum_field_vals[0]),	35479	ip.typeOf(enum_field_vals[0]),
35479	.names = enum_field_names,	35480	.names = enum_field_names,
35480	.values = enum_field_vals,	35481	.values = enum_field_vals,
35481	.tag_mode = .explicit,	35482	.tag_mode = .explicit,
35482	} });	35483	});
35483		35484
35484	new_decl.ty = Type.type;	35485	new_decl.ty = Type.type;
35485	new_decl.val = enum_ty.toValue();	35486	new_decl.val = enum_ty.toValue();
...	@@ -35495,6 +35496,7 @@ fn generateUnionTagTypeSimple(	...	@@ -35495,6 +35496,7 @@ fn generateUnionTagTypeSimple(
35495	maybe_union_obj: ?*Module.Union,	35496	maybe_union_obj: ?*Module.Union,
35496	) !Type {	35497	) !Type {
35497	const mod = sema.mod;	35498	const mod = sema.mod;
		35499	const ip = &mod.intern_pool;
35498	const gpa = sema.gpa;	35500	const gpa = sema.gpa;
35499		35501
35500	const new_decl_index = new_decl_index: {	35502	const new_decl_index = new_decl_index: {
...	@@ -35508,7 +35510,7 @@ fn generateUnionTagTypeSimple(	...	@@ -35508,7 +35510,7 @@ fn generateUnionTagTypeSimple(
35508	const new_decl_index = try mod.allocateNewDecl(block.namespace, src_decl.src_node, block.wip_capture_scope);	35510	const new_decl_index = try mod.allocateNewDecl(block.namespace, src_decl.src_node, block.wip_capture_scope);
35509	errdefer mod.destroyDecl(new_decl_index);	35511	errdefer mod.destroyDecl(new_decl_index);
35510	const fqn = try union_obj.getFullyQualifiedName(mod);	35512	const fqn = try union_obj.getFullyQualifiedName(mod);
35511	const name = try mod.intern_pool.getOrPutStringFmt(gpa, "@typeInfo({}).Union.tag_type.?", .{fqn.fmt(&mod.intern_pool)});	35513	const name = try ip.getOrPutStringFmt(gpa, "@typeInfo({}).Union.tag_type.?", .{fqn.fmt(ip)});
35512	try mod.initNewAnonDecl(new_decl_index, src_decl.src_line, .{	35514	try mod.initNewAnonDecl(new_decl_index, src_decl.src_line, .{
35513	.ty = Type.noreturn,	35515	.ty = Type.noreturn,
35514	.val = Value.@"unreachable",	35516	.val = Value.@"unreachable",
...	@@ -35518,7 +35520,7 @@ fn generateUnionTagTypeSimple(	...	@@ -35518,7 +35520,7 @@ fn generateUnionTagTypeSimple(
35518	};	35520	};
35519	errdefer mod.abortAnonDecl(new_decl_index);	35521	errdefer mod.abortAnonDecl(new_decl_index);
35520		35522
35521	const enum_ty = try mod.intern(.{ .enum_type = .{	35523	const enum_ty = try ip.getEnum(gpa, .{
35522	.decl = new_decl_index,	35524	.decl = new_decl_index,
35523	.namespace = .none,	35525	.namespace = .none,
35524	.tag_ty = if (enum_field_names.len == 0)	35526	.tag_ty = if (enum_field_names.len == 0)
...	@@ -35528,7 +35530,7 @@ fn generateUnionTagTypeSimple(	...	@@ -35528,7 +35530,7 @@ fn generateUnionTagTypeSimple(
35528	.names = enum_field_names,	35530	.names = enum_field_names,
35529	.values = &.{},	35531	.values = &.{},
35530	.tag_mode = .auto,	35532	.tag_mode = .auto,
35531	} });	35533	});
35532		35534
35533	const new_decl = mod.declPtr(new_decl_index);	35535	const new_decl = mod.declPtr(new_decl_index);
35534	new_decl.owns_tv = true;	35536	new_decl.owns_tv = true;
...	@@ -35625,6 +35627,7 @@ fn getBuiltinType(sema: *Sema, name: []const u8) CompileError!Type {	...	@@ -35625,6 +35627,7 @@ fn getBuiltinType(sema: *Sema, name: []const u8) CompileError!Type {
35625	/// TODO assert the return value matches `ty.onePossibleValue`	35627	/// TODO assert the return value matches `ty.onePossibleValue`
35626	pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {	35628	pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
35627	const mod = sema.mod;	35629	const mod = sema.mod;
		35630	const ip = &mod.intern_pool;
35628	return switch (ty.toIntern()) {	35631	return switch (ty.toIntern()) {
35629	.u0_type,	35632	.u0_type,
35630	.i0_type,	35633	.i0_type,
...	@@ -35718,7 +35721,7 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {	...	@@ -35718,7 +35721,7 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
35718	.none,	35721	.none,
35719	=> unreachable,	35722	=> unreachable,
35720		35723
35721	_ => switch (mod.intern_pool.items.items(.tag)[@intFromEnum(ty.toIntern())]) {	35724	_ => switch (ip.items.items(.tag)[@intFromEnum(ty.toIntern())]) {
35722	.type_int_signed, // i0 handled above	35725	.type_int_signed, // i0 handled above
35723	.type_int_unsigned, // u0 handled above	35726	.type_int_unsigned, // u0 handled above
35724	.type_pointer,	35727	.type_pointer,
...	@@ -35801,7 +35804,7 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {	...	@@ -35801,7 +35804,7 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
35801	.type_union_tagged,	35804	.type_union_tagged,
35802	.type_union_untagged,	35805	.type_union_untagged,
35803	.type_union_safety,	35806	.type_union_safety,
35804	=> switch (mod.intern_pool.indexToKey(ty.toIntern())) {	35807	=> switch (ip.indexToKey(ty.toIntern())) {
35805	inline .array_type, .vector_type => \|seq_type, seq_tag\| {	35808	inline .array_type, .vector_type => \|seq_type, seq_tag\| {
35806	const has_sentinel = seq_tag == .array_type and seq_type.sentinel != .none;	35809	const has_sentinel = seq_tag == .array_type and seq_type.sentinel != .none;
35807	if (seq_type.len + @intFromBool(has_sentinel) == 0) return (try mod.intern(.{ .aggregate = .{	35810	if (seq_type.len + @intFromBool(has_sentinel) == 0) return (try mod.intern(.{ .aggregate = .{
...	@@ -35930,7 +35933,7 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {	...	@@ -35930,7 +35933,7 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
35930	.storage = .{ .u64 = 0 },	35933	.storage = .{ .u64 = 0 },
35931	} })	35934	} })
35932	else	35935	else
35933	enum_type.values[0]).toValue(), ty),	35936	enum_type.values.get(ip)[0]).toValue(), ty),
35934	else => return null,	35937	else => return null,
35935	}	35938	}
35936	},	35939	},

src/TypedValue.zig+1-1

...	@@ -238,7 +238,7 @@ pub fn print(	...	@@ -238,7 +238,7 @@ pub fn print(
238	}	238	}
239	const enum_type = ip.indexToKey(ty.toIntern()).enum_type;	239	const enum_type = ip.indexToKey(ty.toIntern()).enum_type;
240	if (enum_type.tagValueIndex(ip, val.toIntern())) \|tag_index\| {	240	if (enum_type.tagValueIndex(ip, val.toIntern())) \|tag_index\| {
241	try writer.print(".{i}", .{enum_type.names[tag_index].fmt(ip)});	241	try writer.print(".{i}", .{enum_type.names.get(ip)[tag_index].fmt(ip)});
242	return;	242	return;
243	}	243	}
244	try writer.writeAll("@enumFromInt(");	244	try writer.writeAll("@enumFromInt(");

src/codegen/llvm.zig+7-6

src/link/Dwarf.zig+5-4

src/type.zig+7-5

...	@@ -2434,11 +2434,11 @@ pub const Type = struct {	...	@@ -2434,11 +2434,11 @@ pub const Type = struct {
2434	/// resolves field types rather than asserting they are already resolved.	2434	/// resolves field types rather than asserting they are already resolved.
2435	pub fn onePossibleValue(starting_type: Type, mod: *Module) !?Value {	2435	pub fn onePossibleValue(starting_type: Type, mod: *Module) !?Value {
2436	var ty = starting_type;	2436	var ty = starting_type;
2437		2437	const ip = &mod.intern_pool;
2438	while (true) switch (ty.toIntern()) {	2438	while (true) switch (ty.toIntern()) {
2439	.empty_struct_type => return Value.empty_struct,	2439	.empty_struct_type => return Value.empty_struct,
2440		2440
2441	else => switch (mod.intern_pool.indexToKey(ty.toIntern())) {	2441	else => switch (ip.indexToKey(ty.toIntern())) {
2442	.int_type => \|int_type\| {	2442	.int_type => \|int_type\| {
2443	if (int_type.bits == 0) {	2443	if (int_type.bits == 0) {
2444	return try mod.intValue(ty, 0);	2444	return try mod.intValue(ty, 0);
...	@@ -2619,7 +2619,7 @@ pub const Type = struct {	...	@@ -2619,7 +2619,7 @@ pub const Type = struct {
2619	} });	2619	} });
2620	return only.toValue();	2620	return only.toValue();
2621	} else {	2621	} else {
2622	return enum_type.values[0].toValue();	2622	return enum_type.values.get(ip)[0].toValue();
2623	}	2623	}
2624	},	2624	},
2625	else => return null,	2625	else => return null,
...	@@ -2967,7 +2967,8 @@ pub const Type = struct {	...	@@ -2967,7 +2967,8 @@ pub const Type = struct {
2967	}	2967	}
2968		2968
2969	pub fn enumFields(ty: Type, mod: *Module) []const InternPool.NullTerminatedString {	2969	pub fn enumFields(ty: Type, mod: *Module) []const InternPool.NullTerminatedString {
2970	return mod.intern_pool.indexToKey(ty.toIntern()).enum_type.names;	2970	const ip = &mod.intern_pool;
		2971	return ip.indexToKey(ty.toIntern()).enum_type.names.get(ip);
2971	}	2972	}
2972		2973
2973	pub fn enumFieldCount(ty: Type, mod: *Module) usize {	2974	pub fn enumFieldCount(ty: Type, mod: *Module) usize {
...	@@ -2975,7 +2976,8 @@ pub const Type = struct {	...	@@ -2975,7 +2976,8 @@ pub const Type = struct {
2975	}	2976	}
2976		2977
2977	pub fn enumFieldName(ty: Type, field_index: usize, mod: *Module) InternPool.NullTerminatedString {	2978	pub fn enumFieldName(ty: Type, field_index: usize, mod: *Module) InternPool.NullTerminatedString {
2978	return mod.intern_pool.indexToKey(ty.toIntern()).enum_type.names[field_index];	2979	const ip = &mod.intern_pool;
		2980	return ip.indexToKey(ty.toIntern()).enum_type.names.get(ip)[field_index];
2979	}	2981	}
2980		2982
2981	pub fn enumFieldIndex(ty: Type, field_name: InternPool.NullTerminatedString, mod: *Module) ?u32 {	2983	pub fn enumFieldIndex(ty: Type, field_name: InternPool.NullTerminatedString, mod: *Module) ?u32 {

src/value.zig+1-1

...	@@ -426,7 +426,7 @@ pub const Value = struct {	...	@@ -426,7 +426,7 @@ pub const Value = struct {
426	// Assume it is already an integer and return it directly.	426	// Assume it is already an integer and return it directly.
427	.simple_type, .int_type => val,	427	.simple_type, .int_type => val,
428	.enum_type => \|enum_type\| if (enum_type.values.len != 0)	428	.enum_type => \|enum_type\| if (enum_type.values.len != 0)
429	enum_type.values[field_index].toValue()	429	enum_type.values.get(ip)[field_index].toValue()
430	else // Field index and integer values are the same.	430	else // Field index and integer values are the same.
431	mod.intValue(enum_type.tag_ty.toType(), field_index),	431	mod.intValue(enum_type.tag_ty.toType(), field_index),
432	else => unreachable,	432	else => unreachable,

...	@@ -1909,12 +1909,12 @@ pub const Object = struct {	...	@@ -1909,12 +1909,12 @@ pub const Object = struct {
1909	const int_info = ty.intInfo(mod);	1909	const int_info = ty.intInfo(mod);
1910	assert(int_info.bits != 0);	1910	assert(int_info.bits != 0);
1911		1911
1912	for (enum_type.names, 0..) \|field_name_ip, i\| {	1912	for (enum_type.names.get(ip), 0..) \|field_name_ip, i\| {
1913	const field_name_z = ip.stringToSlice(field_name_ip);	1913	const field_name_z = ip.stringToSlice(field_name_ip);
1914		1914
1915	var bigint_space: Value.BigIntSpace = undefined;	1915	var bigint_space: Value.BigIntSpace = undefined;
1916	const bigint = if (enum_type.values.len != 0)	1916	const bigint = if (enum_type.values.len != 0)
1917	enum_type.values[i].toValue().toBigInt(&bigint_space, mod)	1917	enum_type.values.get(ip)[i].toValue().toBigInt(&bigint_space, mod)
1918	else	1918	else
1919	std.math.big.int.Mutable.init(&bigint_space.limbs, i).toConst();	1919	std.math.big.int.Mutable.init(&bigint_space.limbs, i).toConst();
1920		1920
...	@@ -9206,7 +9206,8 @@ pub const FuncGen = struct {	...	@@ -9206,7 +9206,8 @@ pub const FuncGen = struct {
9206	fn getEnumTagNameFunction(self: *FuncGen, enum_ty: Type) !Builder.Function.Index {	9206	fn getEnumTagNameFunction(self: *FuncGen, enum_ty: Type) !Builder.Function.Index {
9207	const o = self.dg.object;	9207	const o = self.dg.object;
9208	const mod = o.module;	9208	const mod = o.module;
9209	const enum_type = mod.intern_pool.indexToKey(enum_ty.toIntern()).enum_type;	9209	const ip = &mod.intern_pool;
		9210	const enum_type = ip.indexToKey(enum_ty.toIntern()).enum_type;
9210		9211
9211	// TODO: detect when the type changes and re-emit this function.	9212	// TODO: detect when the type changes and re-emit this function.
9212	const gop = try o.decl_map.getOrPut(o.gpa, enum_type.decl);	9213	const gop = try o.decl_map.getOrPut(o.gpa, enum_type.decl);
...	@@ -9218,7 +9219,7 @@ pub const FuncGen = struct {	...	@@ -9218,7 +9219,7 @@ pub const FuncGen = struct {
9218	const fqn = try mod.declPtr(enum_type.decl).getFullyQualifiedName(mod);	9219	const fqn = try mod.declPtr(enum_type.decl).getFullyQualifiedName(mod);
9219	const function_index = try o.builder.addFunction(	9220	const function_index = try o.builder.addFunction(
9220	try o.builder.fnType(ret_ty, &.{try o.lowerType(enum_type.tag_ty.toType())}, .normal),	9221	try o.builder.fnType(ret_ty, &.{try o.lowerType(enum_type.tag_ty.toType())}, .normal),
9221	try o.builder.fmt("__zig_tag_name_{}", .{fqn.fmt(&mod.intern_pool)}),	9222	try o.builder.fmt("__zig_tag_name_{}", .{fqn.fmt(ip)}),
9222	toLlvmAddressSpace(.generic, mod.getTarget()),	9223	toLlvmAddressSpace(.generic, mod.getTarget()),
9223	);	9224	);
9224		9225
...	@@ -9241,8 +9242,8 @@ pub const FuncGen = struct {	...	@@ -9241,8 +9242,8 @@ pub const FuncGen = struct {
9241	try wip.@"switch"(tag_int_value, bad_value_block, @intCast(enum_type.names.len));	9242	try wip.@"switch"(tag_int_value, bad_value_block, @intCast(enum_type.names.len));
9242	defer wip_switch.finish(&wip);	9243	defer wip_switch.finish(&wip);
9243		9244
9244	for (enum_type.names, 0..) \|name, field_index\| {	9245	for (enum_type.names.get(ip), 0..) \|name, field_index\| {
9245	const name_string = try o.builder.string(mod.intern_pool.stringToSlice(name));	9246	const name_string = try o.builder.string(ip.stringToSlice(name));
9246	const name_init = try o.builder.stringNullConst(name_string);	9247	const name_init = try o.builder.stringNullConst(name_string);
9247	const name_variable_index =	9248	const name_variable_index =
9248	try o.builder.addVariable(.empty, name_init.typeOf(&o.builder), .default);	9249	try o.builder.addVariable(.empty, name_init.typeOf(&o.builder), .default);

...	@@ -388,9 +388,10 @@ pub const DeclState = struct {	...	@@ -388,9 +388,10 @@ pub const DeclState = struct {
388	try ty.print(dbg_info_buffer.writer(), mod);	388	try ty.print(dbg_info_buffer.writer(), mod);
389	try dbg_info_buffer.append(0);	389	try dbg_info_buffer.append(0);
390		390
391	const enum_type = mod.intern_pool.indexToKey(ty.ip_index).enum_type;	391	const ip = &mod.intern_pool;
392	for (enum_type.names, 0..) \|field_name_index, field_i\| {	392	const enum_type = ip.indexToKey(ty.ip_index).enum_type;
393	const field_name = mod.intern_pool.stringToSlice(field_name_index);	393	for (enum_type.names.get(ip), 0..) \|field_name_index, field_i\| {
		394	const field_name = ip.stringToSlice(field_name_index);
394	// DW.AT.enumerator	395	// DW.AT.enumerator
395	try dbg_info_buffer.ensureUnusedCapacity(field_name.len + 2 + @sizeOf(u64));	396	try dbg_info_buffer.ensureUnusedCapacity(field_name.len + 2 + @sizeOf(u64));
396	dbg_info_buffer.appendAssumeCapacity(@intFromEnum(AbbrevKind.enum_variant));	397	dbg_info_buffer.appendAssumeCapacity(@intFromEnum(AbbrevKind.enum_variant));
...	@@ -400,7 +401,7 @@ pub const DeclState = struct {	...	@@ -400,7 +401,7 @@ pub const DeclState = struct {
400	// DW.AT.const_value, DW.FORM.data8	401	// DW.AT.const_value, DW.FORM.data8
401	const value: u64 = value: {	402	const value: u64 = value: {
402	if (enum_type.values.len == 0) break :value field_i; // auto-numbered	403	if (enum_type.values.len == 0) break :value field_i; // auto-numbered
403	const value = enum_type.values[field_i];	404	const value = enum_type.values.get(ip)[field_i];
404	// TODO do not assume a 64bit enum value - could be bigger.	405	// TODO do not assume a 64bit enum value - could be bigger.
405	// See https://github.com/ziglang/zig/issues/645	406	// See https://github.com/ziglang/zig/issues/645
406	const field_int_val = try value.toValue().intFromEnum(ty, mod);	407	const field_int_val = try value.toValue().intFromEnum(ty, mod);