more closely match Zir.Inst.Ref to InternPool.Index

src/ComptimeInterpreter.zig

@@ -241,7 +241,7 @@ pub fn interpret(
                 else
                     (try (try interpreter.interpret(container_field.ast.value_expr, container_namespace, .{})).getValue()).val; // TODO check ty
 
-                if (init_type_value.ty != Index.type) {
+                if (init_type_value.ty != Index.type_type) {
                     try interpreter.recordError(
                         container_field.ast.type_expr,
                         "expected_type",
@@ -267,7 +267,7 @@ pub fn interpret(
             return InterpretResult{ .value = Value{
                 .interpreter = interpreter,
                 .node_idx = node_idx,
-                .ty = Index.type,
+                .ty = Index.type_type,
                 .val = struct_type,
             } };
         },
@@ -314,7 +314,7 @@ pub fn interpret(
             if (type_value == null and init_value == null) return InterpretResult{ .nothing = {} };
 
             if (type_value) |v| {
-                if (v.ty != Index.type) return InterpretResult{ .nothing = {} };
+                if (v.ty != Index.type_type) return InterpretResult{ .nothing = {} };
             }
 
             const decl = interpreter.ip.getDecl(decl_index);
@@ -383,46 +383,46 @@ pub fn interpret(
             const identifier = offsets.nodeToSlice(tree, node_idx);
 
             const simples = std.ComptimeStringMap(Index, .{
-                .{ "anyerror", Index.anyerror },
+                .{ "anyerror", Index.anyerror_type },
-                .{ "anyframe", Index.@"anyframe" },
+                .{ "anyframe", Index.anyframe_type },
-                .{ "anyopaque", Index.anyopaque },
+                .{ "anyopaque", Index.anyopaque_type },
-                .{ "bool", Index.bool },
+                .{ "bool", Index.bool_type },
-                .{ "c_int", Index.c_int },
+                .{ "c_int", Index.c_int_type },
-                .{ "c_long", Index.c_long },
+                .{ "c_long", Index.c_long_type },
-                .{ "c_longdouble", Index.c_longdouble },
+                .{ "c_longdouble", Index.c_longdouble_type },
-                .{ "c_longlong", Index.c_longlong },
+                .{ "c_longlong", Index.c_longlong_type },
-                .{ "c_short", Index.c_short },
+                .{ "c_short", Index.c_short_type },
-                .{ "c_uint", Index.c_uint },
+                .{ "c_uint", Index.c_uint_type },
-                .{ "c_ulong", Index.c_ulong },
+                .{ "c_ulong", Index.c_ulong_type },
-                .{ "c_ulonglong", Index.c_ulonglong },
+                .{ "c_ulonglong", Index.c_ulonglong_type },
-                .{ "c_ushort", Index.c_ushort },
+                .{ "c_ushort", Index.c_ushort_type },
-                .{ "comptime_float", Index.comptime_float },
+                .{ "comptime_float", Index.comptime_float_type },
-                .{ "comptime_int", Index.comptime_int },
+                .{ "comptime_int", Index.comptime_int_type },
-                .{ "f128", Index.f128 },
+                .{ "f128", Index.f128_type },
-                .{ "f16", Index.f16 },
+                .{ "f16", Index.f16_type },
-                .{ "f32", Index.f32 },
+                .{ "f32", Index.f32_type },
-                .{ "f64", Index.f64 },
+                .{ "f64", Index.f64_type },
-                .{ "f80", Index.f80 },
+                .{ "f80", Index.f80_type },
                 .{ "false", Index.bool_false },
-                .{ "isize", Index.isize },
+                .{ "isize", Index.isize_type },
-                .{ "noreturn", Index.noreturn },
+                .{ "noreturn", Index.noreturn_type },
                 .{ "null", Index.null_value },
                 .{ "true", Index.bool_true },
-                .{ "type", Index.type },
+                .{ "type", Index.type_type },
                 .{ "undefined", Index.undefined_value },
-                .{ "usize", Index.usize },
+                .{ "usize", Index.usize_type },
-                .{ "void", Index.void },
+                .{ "void", Index.void_type },
             });
 
             if (simples.get(identifier)) |index| {
                 const ty: Index = switch (index) {
                     .undefined_value => .undefined_type,
-                    .void_value => .void,
+                    .void_value => .void_type,
-                    .unreachable_value => .noreturn,
+                    .unreachable_value => .noreturn_type,
                     .null_value => .null_type,
-                    .bool_true => .bool,
+                    .bool_true => .bool_type,
-                    .bool_false => .bool,
+                    .bool_false => .bool_type,
-                    else => .type,
+                    else => .type_type,
                 };
                 return InterpretResult{ .value = Value{
                     .interpreter = interpreter,
@@ -436,7 +436,7 @@ pub fn interpret(
                 return InterpretResult{ .value = Value{
                     .interpreter = interpreter,
                     .node_idx = node_idx,
-                    .ty = Index.type,
+                    .ty = Index.type_type,
                     .val = try interpreter.ip.get(interpreter.allocator, Key{ .int_type = .{
                         .signedness = if (identifier[0] == 'u') .unsigned else .signed,
                         .bits = std.fmt.parseInt(u16, identifier[1..], 10) catch break :blk,
@@ -537,7 +537,7 @@ pub fn interpret(
                                 .value = Value{
                                     .interpreter = interpreter,
                                     .node_idx = data[node_idx].rhs,
-                                    .ty = Index.usize,
+                                    .ty = Index.usize_type,
                                     .val = .none, // TODO resolve length of Slice
                                 },
                             };
@@ -548,7 +548,7 @@ pub fn interpret(
                                 .value = Value{
                                     .interpreter = interpreter,
                                     .node_idx = data[node_idx].rhs,
-                                    .ty = Index.usize,
+                                    .ty = Index.usize_type,
                                     .val = .none, // TODO resolve length of Slice
                                 },
                             };
@@ -563,7 +563,7 @@ pub fn interpret(
                         return InterpretResult{ .value = Value{
                             .interpreter = interpreter,
                             .node_idx = data[node_idx].rhs,
-                            .ty = Index.comptime_int,
+                            .ty = Index.comptime_int_type,
                             .val = len_value,
                         } };
                     }
@@ -682,7 +682,7 @@ pub fn interpret(
                 .value = Value{
                     .interpreter = interpreter,
                     .node_idx = node_idx,
-                    .ty = Index.bool,
+                    .ty = Index.bool_type,
                     .val = if (a_value.val == b_value.val) Index.bool_true else Index.bool_false, // TODO eql function required?
                 },
             };
@@ -693,7 +693,7 @@ pub fn interpret(
 
             if (nl == .failure) return error.CriticalAstFailure;
 
-            const number_type = if (nl == .float) Index.comptime_float else Index.comptime_int;
+            const number_type = if (nl == .float) Index.comptime_float_type else Index.comptime_int_type;
 
             const value = try interpreter.ip.get(
                 interpreter.allocator,
@@ -841,7 +841,7 @@ pub fn interpret(
                     .value = Value{
                         .interpreter = interpreter,
                         .node_idx = node_idx,
-                        .ty = Index.type,
+                        .ty = Index.type_type,
                         .val = .none, // TODO
                     },
                 };
@@ -854,7 +854,7 @@ pub fn interpret(
                 return InterpretResult{ .value = Value{
                     .interpreter = interpreter,
                     .node_idx = node_idx,
-                    .ty = Index.type,
+                    .ty = Index.type_type,
                     .val = value.ty,
                 } };
             }
@@ -865,7 +865,7 @@ pub fn interpret(
                 const value = try (try interpreter.interpret(params[0], namespace, options)).getValue();
                 const field_name = try (try interpreter.interpret(params[1], namespace, options)).getValue();
 
-                if (value.ty != Index.type or value.ty == .none) return error.InvalidBuiltin;
+                if (value.ty != Index.type_type or value.ty == .none) return error.InvalidBuiltin;
                 if (interpreter.ip.indexToKey(field_name.ty) != .pointer_type) return error.InvalidBuiltin; // Check if it's a []const u8
                 if (value.val == .none) return error.InvalidBuiltin;
 
@@ -880,7 +880,7 @@ pub fn interpret(
                 return InterpretResult{ .value = Value{
                     .interpreter = interpreter,
                     .node_idx = node_idx,
-                    .ty = Index.bool,
+                    .ty = Index.bool_type,
                     .val = if (has_decl) Index.bool_true else Index.bool_false,
                 } };
             }
@@ -891,7 +891,7 @@ pub fn interpret(
                 const as_type = try (try interpreter.interpret(params[0], namespace, options)).getValue();
                 const value = try (try interpreter.interpret(params[1], namespace, options)).getValue();
 
-                if (as_type.ty != Index.type) return error.InvalidBuiltin;
+                if (as_type.ty != Index.type_type) return error.InvalidBuiltin;
 
                 return InterpretResult{
                     .value = Value{
@@ -911,10 +911,7 @@ pub fn interpret(
 
             const string_literal_type = try interpreter.ip.get(interpreter.allocator, Key{ .pointer_type = .{
                 .elem_type = try interpreter.ip.get(interpreter.allocator, Key{ .array_type = .{
-                    .child = try interpreter.ip.get(interpreter.allocator, Key{ .int_type = .{
+                    .child = Index.u8_type,
-                        .signedness = .unsigned,
-                        .bits = 8,
-                    } }),
                     .len = @intCast(u64, str.len),
                     .sentinel = try interpreter.ip.get(interpreter.allocator, Key{ .int_u64_value = 0 }),
                 } }),
@@ -990,7 +987,7 @@ pub fn interpret(
 
                 const decl_index = try interpreter.ip.createDecl(interpreter.allocator, .{
                     .name = name,
-                    .ty = Index.type,
+                    .ty = Index.type_type,
                     .val = function_type,
                     .alignment = 0, // TODO
                     .address_space = .generic, // TODO
@@ -1037,7 +1034,7 @@ pub fn interpret(
             const result = try interpreter.interpret(data[node_idx].lhs, namespace, .{});
             const value = try result.getValue();
 
-            if (value.ty != Index.bool) {
+            if (value.ty != Index.bool_type) {
                 try interpreter.recordError(
                     node_idx,
                     "invalid_deref",
@@ -1051,7 +1048,7 @@ pub fn interpret(
             return InterpretResult{ .value = .{
                 .interpreter = interpreter,
                 .node_idx = node_idx,
-                .ty = Index.bool,
+                .ty = Index.bool_type,
                 .val = if (value.val == Index.bool_false) Index.bool_true else Index.bool_false,
             } };
         },
@@ -1142,7 +1139,7 @@ pub fn call(
     while (ast.nextFnParam(&arg_it)) |param| {
         if (arg_index >= arguments.len) return error.MissingArguments;
         var tex = try (try interpreter.interpret(param.type_expr, fn_namespace, options)).getValue();
-        if (tex.ty != Index.type) {
+        if (tex.ty != Index.type_type) {
             try interpreter.recordError(
                 param.type_expr,
                 "expected_type",

src/analyser/InternPool.zig

@@ -277,10 +277,24 @@ pub const Key = union(enum) {
                 .type => .Type,
                 .anyerror => .ErrorSet,
                 .noreturn => .NoReturn,
-                .@"anyframe" => .AnyFrame,
+                .anyframe_type => .AnyFrame,
                 .null_type => .Null,
                 .undefined_type => .Undefined,
                 .enum_literal_type => .EnumLiteral,
+
+                .atomic_order => .Enum,
+                .atomic_rmw_op => .Enum,
+                .calling_convention => .Enum,
+                .address_space => .Enum,
+                .float_mode => .Enum,
+                .reduce_op => .Enum,
+                .modifier => .Enum,
+                .prefetch_options => .Struct,
+                .export_options => .Struct,
+                .extern_options => .Struct,
+                .type_info => .Union,
+
+                .generic_poison => unreachable,
             },
 
             .int_type => .Int,
@@ -293,7 +307,7 @@ pub const Key = union(enum) {
             .enum_type => .Enum,
             .function_type => .Fn,
             .union_type => .Union,
-            .tuple_type => .Struct, // TODO this correct?
+            .tuple_type => .Struct,
             .vector_type => .Vector,
             .anyframe_type => .AnyFrame,
 
@@ -447,7 +461,7 @@ pub const Key = union(enum) {
     pub fn elemType2(ty: Key) Index {
         return switch (ty) {
             .simple_type => |simple| switch (simple) {
-                .@"anyframe" => Index.void,
+                .anyframe_type => Index.void_type,
                 else => unreachable,
             },
             .pointer_type => |pointer_info| pointer_info.elem_type,
@@ -503,7 +517,7 @@ pub const Key = union(enum) {
                 .anyerror,
                 .comptime_int,
                 .comptime_float,
-                .@"anyframe",
+                .anyframe_type,
                 .enum_literal_type,
                 => Index.none,
 
@@ -511,6 +525,21 @@ pub const Key = union(enum) {
                 .noreturn => Index.unreachable_value,
                 .null_type => Index.null_value,
                 .undefined_type => Index.undefined_value,
+
+                .atomic_order,
+                .atomic_rmw_op,
+                .calling_convention,
+                .address_space,
+                .float_mode,
+                .reduce_op,
+                .modifier,
+                .prefetch_options,
+                .export_options,
+                .extern_options,
+                .type_info,
+                => Index.none,
+
+                .generic_poison => unreachable,
             },
             .int_type => |int_info| {
                 if (int_info.bits == 0) {
@@ -536,10 +565,10 @@ pub const Key = union(enum) {
                     if (ip.indexToKey(entry.value_ptr.ty).onePossibleValue(ip) != Index.none) continue;
                     return Index.none;
                 }
-                return panicOrElse("TODO return empty struct value", Index.none);
+                return Index.empty_struct;
             },
             .optional_type => |optional_info| {
-                if (optional_info.payload_type == Index.noreturn) {
+                if (optional_info.payload_type == Index.noreturn_type) {
                     return Index.null_value;
                 }
                 return Index.none;
@@ -648,12 +677,25 @@ pub const Key = union(enum) {
                 .comptime_int,
                 .comptime_float,
                 .noreturn,
-                .@"anyframe",
+                .anyframe_type,
                 => try writer.writeAll(@tagName(simple)),
 
                 .null_type => try writer.writeAll("@TypeOf(null)"),
                 .undefined_type => try writer.writeAll("@TypeOf(undefined)"),
                 .enum_literal_type => try writer.writeAll("@TypeOf(.enum_literal)"),
+
+                .atomic_order => try writer.writeAll("std.builtin.AtomicOrder"),
+                .atomic_rmw_op => try writer.writeAll("std.builtin.AtomicRmwOp"),
+                .calling_convention => try writer.writeAll("std.builtin.CallingConvention"),
+                .address_space => try writer.writeAll("std.builtin.AddressSpace"),
+                .float_mode => try writer.writeAll("std.builtin.FloatMode"),
+                .reduce_op => try writer.writeAll("std.builtin.ReduceOp"),
+                .modifier => try writer.writeAll("std.builtin.CallModifier"),
+                .prefetch_options => try writer.writeAll("std.builtin.PrefetchOptions"),
+                .export_options => try writer.writeAll("std.builtin.ExportOptions"),
+                .extern_options => try writer.writeAll("std.builtin.ExternOptions"),
+                .type_info => try writer.writeAll("std.builtin.Type"),
+                .generic_poison => unreachable,
             },
             .int_type => |int_info| switch (int_info.signedness) {
                 .signed => try writer.print("i{}", .{int_info.bits}),
@@ -821,45 +863,15 @@ pub const Key = union(enum) {
         writer: anytype,
     ) @TypeOf(writer).Error!void {
         switch (value) {
-            .simple_type => |simple| switch (simple) {
+            .simple_type => try printType(ty, ip, writer),
-                .f16,
-                .f32,
-                .f64,
-                .f80,
-                .f128,
-                .usize,
-                .isize,
-                .c_short,
-                .c_ushort,
-                .c_int,
-                .c_uint,
-                .c_long,
-                .c_ulong,
-                .c_longlong,
-                .c_ulonglong,
-                .c_longdouble,
-                .anyopaque,
-                .bool,
-                .void,
-                .type,
-                .anyerror,
-                .comptime_int,
-                .comptime_float,
-                .noreturn,
-                .@"anyframe",
-                => try writer.writeAll(@tagName(simple)),
-
-                .null_type => try writer.writeAll("@TypeOf(null)"),
-                .undefined_type => try writer.writeAll("@TypeOf(undefined)"),
-                .enum_literal_type => try writer.writeAll("@TypeOf(.enum_literal)"),
-            },
             .simple_value => |simple| switch (simple) {
-                .undefined_value => try writer.writeAll("@Type(.Undefined)"),
+                .undefined_value => try writer.writeAll("undefined"),
-                .void_value => try writer.writeAll("void"),
+                .void_value => try writer.writeAll("{}"),
                 .unreachable_value => try writer.writeAll("unreachable"),
                 .null_value => try writer.writeAll("null"),
                 .bool_true => try writer.writeAll("true"),
                 .bool_false => try writer.writeAll("false"),
+                .generic_poison => unreachable,
             },
 
             .int_type,
@@ -943,44 +955,89 @@ pub const Item = struct {
 /// the same `InternPool`.
 /// TODO split this into an Optional and non-Optional Index
 pub const Index = enum(u32) {
-    f16,
+    u1_type,
-    f32,
+    u8_type,
-    f64,
+    i8_type,
-    f80,
+    u16_type,
-    f128,
+    i16_type,
-    usize,
+    u29_type,
-    isize,
+    u32_type,
-    c_short,
+    i32_type,
-    c_ushort,
+    u64_type,
-    c_int,
+    i64_type,
-    c_uint,
+    u128_type,
-    c_long,
+    i128_type,
-    c_ulong,
+    usize_type,
-    c_longlong,
+    isize_type,
-    c_ulonglong,
+    c_short_type,
-    c_longdouble,
+    c_ushort_type,
-    anyopaque,
+    c_int_type,
-    bool,
+    c_uint_type,
-    void,
+    c_long_type,
-    type,
+    c_ulong_type,
-    anyerror,
+    c_longlong_type,
-    comptime_int,
+    c_ulonglong_type,
-    comptime_float,
+    c_longdouble_type,
-    noreturn,
+    f16_type,
-    @"anyframe",
+    f32_type,
+    f64_type,
+    f80_type,
+    f128_type,
+    anyopaque_type,
+    bool_type,
+    void_type,
+    type_type,
+    anyerror_type,
+    comptime_int_type,
+    comptime_float_type,
+    noreturn_type,
+    anyframe_type,
     null_type,
     undefined_type,
     enum_literal_type,
+    atomic_order_type,
+    atomic_rmw_op_type,
+    calling_convention_type,
+    address_space_type,
+    float_mode_type,
+    reduce_op_type,
+    modifier_type,
+    prefetch_options_type,
+    export_options_type,
+    extern_options_type,
+    type_info_type,
+    manyptr_u8_type,
+    manyptr_const_u8_type,
+    fn_noreturn_no_args_type,
+    fn_void_no_args_type,
+    fn_naked_noreturn_no_args_type,
+    fn_ccc_void_no_args_type,
+    single_const_pointer_to_comptime_int_type,
+    const_slice_u8_type,
+    anyerror_void_error_union_type,
+    generic_poison_type,
 
+    /// `undefined` (untyped)
     undefined_value,
-    void_value,
+    /// `0` (comptime_int)
-    unreachable_value,
-    null_value,
-    bool_true,
-    bool_false,
-
     zero,
+    /// `1` (comptime_int)
+    one,
+    /// `{}`
+    void_value,
+    /// `unreachable` (noreturn type)
+    unreachable_value,
+    /// `null` (untyped)
+    null_value,
+    /// `true`
+    bool_true,
+    /// `false`
+    bool_false,
+    /// `.{}` (untyped)
+    empty_struct,
+    generic_poison,
 
+    unknown = std.math.maxInt(u32) - 1,
     none = std.math.maxInt(u32),
     _,
 
@@ -1126,10 +1183,24 @@ pub const SimpleType = enum(u32) {
     comptime_int,
     comptime_float,
     noreturn,
-    @"anyframe",
+    anyframe_type,
     null_type,
     undefined_type,
     enum_literal_type,
+
+    atomic_order,
+    atomic_rmw_op,
+    calling_convention,
+    address_space,
+    float_mode,
+    reduce_op,
+    modifier,
+    prefetch_options,
+    export_options,
+    extern_options,
+    type_info,
+
+    generic_poison,
 };
 
 pub const SimpleValue = enum(u32) {
@@ -1139,6 +1210,7 @@ pub const SimpleValue = enum(u32) {
     null_value,
     bool_true,
     bool_false,
+    generic_poison,
 };
 
 comptime {
@@ -1148,51 +1220,98 @@ comptime {
 pub fn init(gpa: Allocator) Allocator.Error!InternPool {
     var ip: InternPool = .{};
 
-    const simple_count = std.meta.fields(SimpleType).len + std.meta.fields(SimpleValue).len;
+    const items = [_]struct { index: Index, key: Key }{
-    const count = simple_count + 1;
+        .{ .index = .u1_type, .key = .{ .int_type = .{ .signedness = .unsigned, .bits = 1 } } },
-    const extra_count = @sizeOf(u64);
+        .{ .index = .u8_type, .key = .{ .int_type = .{ .signedness = .unsigned, .bits = 8 } } },
+        .{ .index = .i8_type, .key = .{ .int_type = .{ .signedness = .signed, .bits = 8 } } },
+        .{ .index = .u16_type, .key = .{ .int_type = .{ .signedness = .unsigned, .bits = 16 } } },
+        .{ .index = .i16_type, .key = .{ .int_type = .{ .signedness = .signed, .bits = 16 } } },
+        .{ .index = .u29_type, .key = .{ .int_type = .{ .signedness = .unsigned, .bits = 29 } } },
+        .{ .index = .u32_type, .key = .{ .int_type = .{ .signedness = .unsigned, .bits = 32 } } },
+        .{ .index = .i32_type, .key = .{ .int_type = .{ .signedness = .signed, .bits = 32 } } },
+        .{ .index = .u64_type, .key = .{ .int_type = .{ .signedness = .unsigned, .bits = 64 } } },
+        .{ .index = .i64_type, .key = .{ .int_type = .{ .signedness = .signed, .bits = 64 } } },
+        .{ .index = .u128_type, .key = .{ .int_type = .{ .signedness = .unsigned, .bits = 128 } } },
+        .{ .index = .i128_type, .key = .{ .int_type = .{ .signedness = .signed, .bits = 128 } } },
 
-    try ip.map.ensureTotalCapacity(gpa, count);
+        .{ .index = .usize_type, .key = .{ .simple_type = .usize } },
-    try ip.items.ensureTotalCapacity(gpa, count);
+        .{ .index = .isize_type, .key = .{ .simple_type = .isize } },
+        .{ .index = .c_short_type, .key = .{ .simple_type = .c_short } },
+        .{ .index = .c_ushort_type, .key = .{ .simple_type = .c_ushort } },
+        .{ .index = .c_int_type, .key = .{ .simple_type = .c_int } },
+        .{ .index = .c_uint_type, .key = .{ .simple_type = .c_uint } },
+        .{ .index = .c_long_type, .key = .{ .simple_type = .c_long } },
+        .{ .index = .c_ulong_type, .key = .{ .simple_type = .c_ulong } },
+        .{ .index = .c_longlong_type, .key = .{ .simple_type = .c_longlong } },
+        .{ .index = .c_ulonglong_type, .key = .{ .simple_type = .c_ulonglong } },
+        .{ .index = .c_longdouble_type, .key = .{ .simple_type = .c_longdouble } },
+        .{ .index = .f16_type, .key = .{ .simple_type = .f16 } },
+        .{ .index = .f32_type, .key = .{ .simple_type = .f32 } },
+        .{ .index = .f64_type, .key = .{ .simple_type = .f64 } },
+        .{ .index = .f80_type, .key = .{ .simple_type = .f80 } },
+        .{ .index = .f128_type, .key = .{ .simple_type = .f128 } },
+        .{ .index = .anyopaque_type, .key = .{ .simple_type = .anyopaque } },
+        .{ .index = .bool_type, .key = .{ .simple_type = .bool } },
+        .{ .index = .void_type, .key = .{ .simple_type = .void } },
+        .{ .index = .type_type, .key = .{ .simple_type = .type } },
+        .{ .index = .anyerror_type, .key = .{ .simple_type = .anyerror } },
+        .{ .index = .comptime_int_type, .key = .{ .simple_type = .comptime_int } },
+        .{ .index = .comptime_float_type, .key = .{ .simple_type = .comptime_float } },
+        .{ .index = .noreturn_type, .key = .{ .simple_type = .noreturn } },
+        .{ .index = .anyframe_type, .key = .{ .simple_type = .anyframe_type } },
+        .{ .index = .null_type, .key = .{ .simple_type = .null_type } },
+        .{ .index = .undefined_type, .key = .{ .simple_type = .undefined_type } },
+        .{ .index = .enum_literal_type, .key = .{ .simple_type = .enum_literal_type } },
+
+        .{ .index = .atomic_order_type, .key = .{ .simple_type = .atomic_order } },
+        .{ .index = .atomic_rmw_op_type, .key = .{ .simple_type = .atomic_rmw_op } },
+        .{ .index = .calling_convention_type, .key = .{ .simple_type = .calling_convention } },
+        .{ .index = .address_space_type, .key = .{ .simple_type = .address_space } },
+        .{ .index = .float_mode_type, .key = .{ .simple_type = .float_mode } },
+        .{ .index = .reduce_op_type, .key = .{ .simple_type = .reduce_op } },
+        .{ .index = .modifier_type, .key = .{ .simple_type = .modifier } },
+        .{ .index = .prefetch_options_type, .key = .{ .simple_type = .prefetch_options } },
+        .{ .index = .export_options_type, .key = .{ .simple_type = .export_options } },
+        .{ .index = .extern_options_type, .key = .{ .simple_type = .extern_options } },
+        .{ .index = .type_info_type, .key = .{ .simple_type = .type_info } },
+        .{ .index = .manyptr_u8_type, .key = .{ .pointer_type = .{ .elem_type = .u8_type, .size = .Many } } },
+        .{ .index = .manyptr_const_u8_type, .key = .{ .pointer_type = .{ .elem_type = .u8_type, .size = .Many, .is_const = true } } },
+        .{ .index = .fn_noreturn_no_args_type, .key = .{ .function_type = .{ .args = &.{}, .return_type = .noreturn_type } } },
+        .{ .index = .fn_void_no_args_type, .key = .{ .function_type = .{ .args = &.{}, .return_type = .void_type } } },
+        .{ .index = .fn_naked_noreturn_no_args_type, .key = .{ .function_type = .{ .args = &.{}, .return_type = .void_type, .calling_convention = .Naked } } },
+        .{ .index = .fn_ccc_void_no_args_type, .key = .{ .function_type = .{ .args = &.{}, .return_type = .void_type, .calling_convention = .C } } },
+        .{ .index = .single_const_pointer_to_comptime_int_type, .key = .{ .pointer_type = .{ .elem_type = .comptime_int_type, .size = .One, .is_const = true } } },
+        .{ .index = .const_slice_u8_type, .key = .{ .pointer_type = .{ .elem_type = .u8_type, .size = .Slice, .is_const = true } } },
+        .{ .index = .anyerror_void_error_union_type, .key = .{ .error_union_type = .{ .error_set_type = .anyerror_type, .payload_type = .void_type } } },
+        .{ .index = .generic_poison_type, .key = .{ .simple_type = .generic_poison } },
+
+        .{ .index = .undefined_value, .key = .{ .simple_value = .undefined_value } },
+        .{ .index = .zero, .key = .{ .int_u64_value = 0 } },
+        .{ .index = .one, .key = .{ .int_u64_value = 1 } },
+        .{ .index = .void_value, .key = .{ .simple_value = .void_value } },
+        .{ .index = .unreachable_value, .key = .{ .simple_value = .unreachable_value } },
+        .{ .index = .null_value, .key = .{ .simple_value = .null_value } },
+        .{ .index = .bool_true, .key = .{ .simple_value = .bool_true } },
+        .{ .index = .bool_false, .key = .{ .simple_value = .bool_false } },
+
+        .{ .index = .empty_struct, .key = .{ .aggregate = &.{} } },
+        .{ .index = .generic_poison, .key = .{ .simple_value = .generic_poison } },
+    };
+
+    const extra_count = 4 * @sizeOf(Pointer) + @sizeOf(ErrorUnion) + 4 * @sizeOf(Function);
+
+    try ip.map.ensureTotalCapacity(gpa, items.len);
+    try ip.items.ensureTotalCapacity(gpa, items.len);
     try ip.extra.ensureTotalCapacity(gpa, extra_count);
 
-    _ = ip.get(undefined, .{ .simple_type = .f16 }) catch unreachable;
+    for (items) |item| {
-    _ = ip.get(undefined, .{ .simple_type = .f32 }) catch unreachable;
+        if (builtin.is_test or builtin.mode == .Debug) {
-    _ = ip.get(undefined, .{ .simple_type = .f64 }) catch unreachable;
+            var failing_allocator = std.testing.FailingAllocator.init(undefined, 0);
-    _ = ip.get(undefined, .{ .simple_type = .f80 }) catch unreachable;
+            std.testing.expectEqual(item.index, ip.get(failing_allocator.allocator(), item.key) catch unreachable) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .f128 }) catch unreachable;
+        } else {
-    _ = ip.get(undefined, .{ .simple_type = .usize }) catch unreachable;
+            std.debug.assert(item.index == ip.get(undefined, item.key) catch unreachable);
-    _ = ip.get(undefined, .{ .simple_type = .isize }) catch unreachable;
+        }
-    _ = ip.get(undefined, .{ .simple_type = .c_short }) catch unreachable;
+    }
-    _ = ip.get(undefined, .{ .simple_type = .c_ushort }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .c_int }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .c_uint }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .c_long }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .c_ulong }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .c_longlong }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .c_ulonglong }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .c_longdouble }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .anyopaque }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .bool }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .void }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .type }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .anyerror }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .comptime_int }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .comptime_float }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .noreturn }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .@"anyframe" }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .null_type }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .undefined_type }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_type = .enum_literal_type }) catch unreachable;
-
-    _ = ip.get(undefined, .{ .simple_value = .undefined_value }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_value = .void_value }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_value = .unreachable_value }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_value = .null_value }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_value = .bool_true }) catch unreachable;
-    _ = ip.get(undefined, .{ .simple_value = .bool_false }) catch unreachable;
-
-    _ = ip.get(undefined, .{ .int_u64_value = 0 }) catch unreachable;
 
     return ip;
 }
@@ -1222,6 +1341,8 @@ pub fn deinit(ip: *InternPool, gpa: Allocator) void {
 }
 
 pub fn indexToKey(ip: InternPool, index: Index) Key {
+    std.debug.assert(index != .none);
+    std.debug.assert(index != .unknown);
     const item = ip.items.get(@enumToInt(index));
     const data = item.data;
     return switch (item.tag) {
@@ -1554,7 +1675,7 @@ pub fn cast(ip: *InternPool, gpa: Allocator, destination_ty: Index, source_ty: I
 
 pub fn resolvePeerTypes(ip: *InternPool, gpa: Allocator, types: []const Index, target: std.Target) Allocator.Error!Index {
     switch (types.len) {
-        0 => return Index.noreturn,
+        0 => return Index.noreturn_type,
         1 => return types[0],
         else => {},
     }
@@ -2504,7 +2625,7 @@ fn coerceInMemoryAllowedFns(
         } };
     }
 
-    if (src_info.return_type != Index.noreturn) {
+    if (src_info.return_type != Index.noreturn_type) {
         const rt = try ip.coerceInMemoryAllowed(gpa, arena, dest_info.return_type, src_info.return_type, true, target);
         if (rt != .ok) {
             return InMemoryCoercionResult{ .fn_return_type = .{
@@ -2749,8 +2870,8 @@ test "simple types" {
     try testExpectFmtType(ip, undefined_type, "@TypeOf(undefined)");
     try testExpectFmtType(ip, enum_literal_type, "@TypeOf(.enum_literal)");
 
-    try testExpectFmtValue(ip, undefined_value, Index.none, "@Type(.Undefined)");
+    try testExpectFmtValue(ip, undefined_value, Index.none, "undefined");
-    try testExpectFmtValue(ip, void_value, Index.none, "void");
+    try testExpectFmtValue(ip, void_value, Index.none, "{}");
     try testExpectFmtValue(ip, unreachable_value, Index.none, "unreachable");
     try testExpectFmtValue(ip, null_value, Index.none, "null");
     try testExpectFmtValue(ip, bool_true, Index.none, "true");

src/analysis.zig

@@ -798,7 +798,7 @@ pub fn resolveTypeOfNodeInternal(store: *DocumentStore, arena: *std.heap.ArenaAl
                                 .interpreter = interpreter,
                                 .value = value,
                             } },
-                            .is_type_val = value.ty == InternPool.Index.type,
+                            .is_type_val = value.ty == InternPool.Index.type_type,
                         },
                         .handle = node_handle.handle,
                     };

tests/language_features/comptime_interpreter.zig

@@ -231,7 +231,7 @@ test "ComptimeInterpreter - call return struct" {
 
     try std.testing.expectEqual(@as(usize, 1), struct_info.fields.count());
     try std.testing.expectEqualStrings("slay", struct_info.fields.keys()[0]);
-    try std.testing.expect(struct_info.fields.values()[0].ty == Index.bool);
+    try std.testing.expect(struct_info.fields.values()[0].ty == Index.bool_type);
 }
 
 test "ComptimeInterpreter - call comptime argument" {