Commit 0c601965ab6600fdaf5be3c017176a6871413026 | zig

author	Isaac Freund <mail@isaacfreund.com> 2021-03-24 01:17:38+01:00
committer	Isaac Freund <mail@isaacfreund.com> 2021-03-24 19:11:44+01:00
log	0c601965ab6600fdaf5be3c017176a6871413026
tree	12c797047baf1bbc87a89c4b513bc2227b9f177f
parent	a1afe693951f6d2ad06961c06b3a2cc14ad6efd9
signature	Commit is signed but in an unrecognized format.

stage2: make zir.Inst.Ref a non-exhaustive enum

This provides us greatly increased type safety and prevents the common
mistake of using a zir.Inst.Ref where a zir.Inst.Index was expected or
vice-versa. It also increases the ergonomics of using the typed values
which can be directly referenced with a Ref over the previous zir.Const
approach.

The main pain point is casting between a []Ref and []u32, which could be
alleviated in the future with a new std.mem function.

5 files changed, 548 insertions(+), 529 deletions(-)

lib
- std
  - enums.zig
src

lib/std/enums.zig+48-41

 @@ -32,7 +32,7 @@ pub fn EnumFieldStruct(comptime E: type, comptime Data: type, comptime field_def
         .fields = fields,
         .decls = &[_]std.builtin.TypeInfo.Declaration{},
         .is_tuple = false,
-    }});
+    } });
 }
 /// Looks up the supplied fields in the given enum type.
 @@ -70,7 +70,7 @@ pub fn values(comptime E: type) []const E {
 test "std.enum.values" {
     const E = extern enum { a, b, c, d = 0 };
-    testing.expectEqualSlices(E, &.{.a, .b, .c, .d}, values(E));
+    testing.expectEqualSlices(E, &.{ .a, .b, .c, .d }, values(E));
 }
 /// Returns the set of all unique named values in the given enum, in
 @@ -82,10 +82,10 @@ pub fn uniqueValues(comptime E: type) []const E {
 test "std.enum.uniqueValues" {
     const E = extern enum { a, b, c, d = 0, e, f = 3 };
-    testing.expectEqualSlices(E, &.{.a, .b, .c, .f}, uniqueValues(E));
+    testing.expectEqualSlices(E, &.{ .a, .b, .c, .f }, uniqueValues(E));
     const F = enum { a, b, c };
-    testing.expectEqualSlices(F, &.{.a, .b, .c}, uniqueValues(F));
+    testing.expectEqualSlices(F, &.{ .a, .b, .c }, uniqueValues(F));
 }
 /// Returns the set of all unique field values in the given enum, in
 @@ -102,8 +102,7 @@ pub fn uniqueFields(comptime E: type) []const EnumField {
         }
         var unique_fields: []const EnumField = &[_]EnumField{};
-    outer:
+        outer: for (raw_fields) |candidate| {
-        for (raw_fields) |candidate| {
             for (unique_fields) |u| {
                 if (u.value == candidate.value)
                     continue :outer;
 @@ -116,28 +115,25 @@ pub fn uniqueFields(comptime E: type) []const EnumField {
 }
 /// Determines the length of a direct-mapped enum array, indexed by
-/// @intCast(usize, @enumToInt(enum_value)).  The enum must be exhaustive.
+/// @intCast(usize, @enumToInt(enum_value)).
+/// If the enum is non-exhaustive, the resulting length will only be enough
+/// to hold all explicit fields.
 /// If the enum contains any fields with values that cannot be represented
 /// by usize, a compile error is issued.  The max_unused_slots parameter limits
 /// the total number of items which have no matching enum key (holes in the enum
 /// numbering).  So for example, if an enum has values 1, 2, 5, and 6, max_unused_slots
 /// must be at least 3, to allow unused slots 0, 3, and 4.
 fn directEnumArrayLen(comptime E: type, comptime max_unused_slots: comptime_int) comptime_int {
-    const info = @typeInfo(E).Enum;
-    if (!info.is_exhaustive) {
-        @compileError("Cannot create direct array of non-exhaustive enum "++@typeName(E));
-    }
     var max_value: comptime_int = -1;
     const max_usize: comptime_int = ~@as(usize, 0);
     const fields = uniqueFields(E);
     for (fields) |f| {
         if (f.value < 0) {
-            @compileError("Cannot create a direct enum array for "++@typeName(E)++", field ."++f.name++" has a negative value.");
+            @compileError("Cannot create a direct enum array for " ++ @typeName(E) ++ ", field ." ++ f.name ++ " has a negative value.");
         }
         if (f.value > max_value) {
             if (f.value > max_usize) {
-                @compileError("Cannot create a direct enum array for "++@typeName(E)++", field ."++f.name++" is larger than the max value of usize.");
+                @compileError("Cannot create a direct enum array for " ++ @typeName(E) ++ ", field ." ++ f.name ++ " is larger than the max value of usize.");
             }
             max_value = f.value;
         }
 @@ -147,14 +143,16 @@ fn directEnumArrayLen(comptime E: type, comptime max_unused_slots: comptime_int)
     if (unused_slots > max_unused_slots) {
         const unused_str = std.fmt.comptimePrint("{d}", .{unused_slots});
         const allowed_str = std.fmt.comptimePrint("{d}", .{max_unused_slots});
-        @compileError("Cannot create a direct enum array for "++@typeName(E)++". It would have "++unused_str++" unused slots, but only "++allowed_str++" are allowed.");
+        @compileError("Cannot create a direct enum array for " ++ @typeName(E) ++ ". It would have " ++ unused_str ++ " unused slots, but only " ++ allowed_str ++ " are allowed.");
     }
     return max_value + 1;
 }
 /// Initializes an array of Data which can be indexed by
-/// @intCast(usize, @enumToInt(enum_value)).  The enum must be exhaustive.
+/// @intCast(usize, @enumToInt(enum_value)).
+/// If the enum is non-exhaustive, the resulting array will only be large enough
+/// to hold all explicit fields.
 /// If the enum contains any fields with values that cannot be represented
 /// by usize, a compile error is issued.  The max_unused_slots parameter limits
 /// the total number of items which have no matching enum key (holes in the enum
 @@ -243,9 +241,9 @@ pub fn nameCast(comptime E: type, comptime value: anytype) E {
             if (@hasField(E, n)) {
                 return @field(E, n);
             }
-            @compileError("Enum "++@typeName(E)++" has no field named "++n);
+            @compileError("Enum " ++ @typeName(E) ++ " has no field named " ++ n);
         }
-        @compileError("Cannot cast from "++@typeName(@TypeOf(value))++" to "++@typeName(E));
+        @compileError("Cannot cast from " ++ @typeName(@TypeOf(value)) ++ " to " ++ @typeName(E));
     }
 }
 @@ -256,7 +254,7 @@ test "std.enums.nameCast" {
     testing.expectEqual(A.a, nameCast(A, A.a));
     testing.expectEqual(A.a, nameCast(A, B.a));
     testing.expectEqual(A.a, nameCast(A, "a"));
-    testing.expectEqual(A.a, nameCast(A, @as(*const[1]u8, "a")));
+    testing.expectEqual(A.a, nameCast(A, @as(*const [1]u8, "a")));
     testing.expectEqual(A.a, nameCast(A, @as([:0]const u8, "a")));
     testing.expectEqual(A.a, nameCast(A, @as([]const u8, "a")));
 @@ -398,12 +396,12 @@ pub fn EnumArray(comptime E: type, comptime V: type) type {
 pub fn NoExtension(comptime Self: type) type {
     return NoExt;
 }
-const NoExt = struct{};
+const NoExt = struct {};
 /// A set type with an Indexer mapping from keys to indices.
 /// Presence or absence is stored as a dense bitfield.  This
 /// type does no allocation and can be copied by value.
-pub fn IndexedSet(comptime I: type, comptime Ext: fn(type)type) type {
+pub fn IndexedSet(comptime I: type, comptime Ext: fn (type) type) type {
     comptime ensureIndexer(I);
     return struct {
         const Self = @This();
 @@ -422,7 +420,7 @@ pub fn IndexedSet(comptime I: type, comptime Ext: fn(type)type) type {
         bits: BitSet = BitSet.initEmpty(),
         /// Returns a set containing all possible keys.
         pub fn initFull() Self {
             return .{ .bits = BitSet.initFull() };
         }
 @@ -492,7 +490,8 @@ pub fn IndexedSet(comptime I: type, comptime Ext: fn(type)type) type {
             pub fn next(self: *Iterator) ?Key {
                 return if (self.inner.next()) |index|
                     Indexer.keyForIndex(index)
-                else null;
+                else
+                    null;
             }
         };
     };
 @@ -501,7 +500,7 @@ pub fn IndexedSet(comptime I: type, comptime Ext: fn(type)type) type {
 /// A map from keys to values, using an index lookup.  Uses a
 /// bitfield to track presence and a dense array of values.
 /// This type does no allocation and can be copied by value.
-pub fn IndexedMap(comptime I: type, comptime V: type, comptime Ext: fn(type)type) type {
+pub fn IndexedMap(comptime I: type, comptime V: type, comptime Ext: fn (type) type) type {
     comptime ensureIndexer(I);
     return struct {
         const Self = @This();
 @@ -652,7 +651,8 @@ pub fn IndexedMap(comptime I: type, comptime V: type, comptime Ext: fn(type)type
                         .key = Indexer.keyForIndex(index),
                         .value = &self.values[index],
                     }
-                else null;
+                else
+                    null;
             }
         };
     };
 @@ -660,7 +660,7 @@ pub fn IndexedMap(comptime I: type, comptime V: type, comptime Ext: fn(type)type
 /// A dense array of values, using an indexed lookup.
 /// This type does no allocation and can be copied by value.
-pub fn IndexedArray(comptime I: type, comptime V: type, comptime Ext: fn(type)type) type {
+pub fn IndexedArray(comptime I: type, comptime V: type, comptime Ext: fn (type) type) type {
     comptime ensureIndexer(I);
     return struct {
         const Self = @This();
 @@ -769,9 +769,9 @@ pub fn ensureIndexer(comptime T: type) void {
         if (!@hasDecl(T, "count")) @compileError("Indexer must have decl count: usize.");
         if (@TypeOf(T.count) != usize) @compileError("Indexer.count must be a usize.");
         if (!@hasDecl(T, "indexOf")) @compileError("Indexer.indexOf must be a fn(Key)usize.");
-        if (@TypeOf(T.indexOf) != fn(T.Key)usize) @compileError("Indexer must have decl indexOf: fn(Key)usize.");
+        if (@TypeOf(T.indexOf) != fn (T.Key) usize) @compileError("Indexer must have decl indexOf: fn(Key)usize.");
         if (!@hasDecl(T, "keyForIndex")) @compileError("Indexer must have decl keyForIndex: fn(usize)Key.");
-        if (@TypeOf(T.keyForIndex) != fn(usize)T.Key) @compileError("Indexer.keyForIndex must be a fn(usize)Key.");
+        if (@TypeOf(T.keyForIndex) != fn (usize) T.Key) @compileError("Indexer.keyForIndex must be a fn(usize)Key.");
     }
 }
 @@ -802,14 +802,18 @@ pub fn EnumIndexer(comptime E: type) type {
         return struct {
             pub const Key = E;
             pub const count: usize = 0;
-            pub fn indexOf(e: E) usize { unreachable; }
+            pub fn indexOf(e: E) usize {
-            pub fn keyForIndex(i: usize) E { unreachable; }
+                unreachable;
+            }
+            pub fn keyForIndex(i: usize) E {
+                unreachable;
+            }
         };
     }
     std.sort.sort(EnumField, &fields, {}, ascByValue);
     const min = fields[0].value;
-    const max = fields[fields.len-1].value;
+    const max = fields[fields.len - 1].value;
-    if (max - min == fields.len-1) {
+    if (max - min == fields.len - 1) {
         return struct {
             pub const Key = E;
             pub const count = fields.len;
 @@ -844,7 +848,7 @@ pub fn EnumIndexer(comptime E: type) type {
 }
 test "std.enums.EnumIndexer dense zeroed" {
-    const E = enum{ b = 1, a = 0, c = 2 };
+    const E = enum { b = 1, a = 0, c = 2 };
     const Indexer = EnumIndexer(E);
     ensureIndexer(Indexer);
     testing.expectEqual(E, Indexer.Key);
 @@ -908,7 +912,7 @@ test "std.enums.EnumIndexer sparse" {
 }
 test "std.enums.EnumIndexer repeats" {
-    const E = extern enum{ a = -2, c = 6, b = 4, b2 = 4 };
+    const E = extern enum { a = -2, c = 6, b = 4, b2 = 4 };
     const Indexer = EnumIndexer(E);
     ensureIndexer(Indexer);
     testing.expectEqual(E, Indexer.Key);
 @@ -957,7 +961,8 @@ test "std.enums.EnumSet" {
     }
     var mut = Set.init(.{
-        .a=true, .c=true,
+        .a = true,
+        .c = true,
     });
     testing.expectEqual(@as(usize, 2), mut.count());
     testing.expectEqual(true, mut.contains(.a));
 @@ -986,7 +991,7 @@ test "std.enums.EnumSet" {
         testing.expectEqual(@as(?E, null), it.next());
     }
-    mut.toggleSet(Set.init(.{ .a=true, .b=true }));
+    mut.toggleSet(Set.init(.{ .a = true, .b = true }));
     testing.expectEqual(@as(usize, 2), mut.count());
     testing.expectEqual(true, mut.contains(.a));
     testing.expectEqual(false, mut.contains(.b));
 @@ -994,7 +999,7 @@ test "std.enums.EnumSet" {
     testing.expectEqual(true, mut.contains(.d));
     testing.expectEqual(true, mut.contains(.e)); // aliases a
-    mut.setUnion(Set.init(.{ .a=true, .b=true }));
+    mut.setUnion(Set.init(.{ .a = true, .b = true }));
     testing.expectEqual(@as(usize, 3), mut.count());
     testing.expectEqual(true, mut.contains(.a));
     testing.expectEqual(true, mut.contains(.b));
 @@ -1009,7 +1014,7 @@ test "std.enums.EnumSet" {
     testing.expectEqual(false, mut.contains(.c));
     testing.expectEqual(true, mut.contains(.d));
-    mut.setIntersection(Set.init(.{ .a=true, .b=true }));
+    mut.setIntersection(Set.init(.{ .a = true, .b = true }));
     testing.expectEqual(@as(usize, 1), mut.count());
     testing.expectEqual(true, mut.contains(.a));
     testing.expectEqual(false, mut.contains(.b));
 @@ -1072,7 +1077,7 @@ test "std.enums.EnumArray sized" {
     const undef = Array.initUndefined();
     var inst = Array.initFill(5);
     const inst2 = Array.init(.{ .a = 1, .b = 2, .c = 3, .d = 4 });
-    const inst3 = Array.initDefault(6, .{.b = 4, .c = 2});
+    const inst3 = Array.initDefault(6, .{ .b = 4, .c = 2 });
     testing.expectEqual(@as(usize, 5), inst.get(.a));
     testing.expectEqual(@as(usize, 5), inst.get(.b));
 @@ -1272,10 +1277,12 @@ test "std.enums.EnumMap sized" {
     var iter = a.iterator();
     const Entry = Map.Entry;
     testing.expectEqual(@as(?Entry, Entry{
-        .key = .b, .value = &a.values[1],
+        .key = .b,
+        .value = &a.values[1],
     }), iter.next());
     testing.expectEqual(@as(?Entry, Entry{
-        .key = .d, .value = &a.values[3],
+        .key = .d,
+        .value = &a.values[3],
     }), iter.next());
     testing.expectEqual(@as(?Entry, null), iter.next());
 }

src/Module.zig+50-48

...	@@ -914,16 +914,16 @@ pub const Scope = struct {	...	@@ -914,16 +914,16 @@ pub const Scope = struct {
914	parent: *Scope,	914	parent: *Scope,
915	/// All `GenZir` scopes for the same ZIR share this.	915	/// All `GenZir` scopes for the same ZIR share this.
916	zir_code: *WipZirCode,	916	zir_code: *WipZirCode,
917	/// Keeps track of the list of instructions in this scope only. References	917	/// Keeps track of the list of instructions in this scope only. Indexes
918	/// to instructions in `zir_code`.	918	/// to instructions in `zir_code`.
919	instructions: std.ArrayListUnmanaged(zir.Inst.Ref) = .{},	919	instructions: std.ArrayListUnmanaged(zir.Inst.Index) = .{},
920	label: ?Label = null,	920	label: ?Label = null,
921	break_block: zir.Inst.Index = 0,	921	break_block: zir.Inst.Index = 0,
922	continue_block: zir.Inst.Index = 0,	922	continue_block: zir.Inst.Index = 0,
923	/// Only valid when setBlockResultLoc is called.	923	/// Only valid when setBlockResultLoc is called.
924	break_result_loc: astgen.ResultLoc = undefined,	924	break_result_loc: astgen.ResultLoc = undefined,
925	/// When a block has a pointer result location, here it is.	925	/// When a block has a pointer result location, here it is.
926	rl_ptr: zir.Inst.Ref = 0,	926	rl_ptr: zir.Inst.Ref = .none,
927	/// Keeps track of how many branches of a block did not actually	927	/// Keeps track of how many branches of a block did not actually
928	/// consume the result location. astgen uses this to figure out	928	/// consume the result location. astgen uses this to figure out
929	/// whether to rely on break instructions or writing to the result	929	/// whether to rely on break instructions or writing to the result
...	@@ -1001,8 +1001,8 @@ pub const Scope = struct {	...	@@ -1001,8 +1001,8 @@ pub const Scope = struct {
1001	ret_ty: zir.Inst.Ref,	1001	ret_ty: zir.Inst.Ref,
1002	cc: zir.Inst.Ref,	1002	cc: zir.Inst.Ref,
1003	}) !zir.Inst.Ref {	1003	}) !zir.Inst.Ref {
1004	assert(args.ret_ty != 0);	1004	assert(args.ret_ty != .none);
1005	assert(args.cc != 0);	1005	assert(args.cc != .none);
1006	const gpa = gz.zir_code.gpa;	1006	const gpa = gz.zir_code.gpa;
1007	try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);	1007	try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);
1008	try gz.zir_code.instructions.ensureCapacity(gpa, gz.zir_code.instructions.len + 1);	1008	try gz.zir_code.instructions.ensureCapacity(gpa, gz.zir_code.instructions.len + 1);
...	@@ -1013,7 +1013,7 @@ pub const Scope = struct {	...	@@ -1013,7 +1013,7 @@ pub const Scope = struct {
1013	.cc = args.cc,	1013	.cc = args.cc,
1014	.param_types_len = @intCast(u32, args.param_types.len),	1014	.param_types_len = @intCast(u32, args.param_types.len),
1015	});	1015	});
1016	gz.zir_code.extra.appendSliceAssumeCapacity(args.param_types);	1016	gz.zir_code.extra.appendSliceAssumeCapacity(mem.bytesAsSlice(u32, mem.sliceAsBytes(args.param_types)));
1017		1017
1018	const new_index = @intCast(zir.Inst.Index, gz.zir_code.instructions.len);	1018	const new_index = @intCast(zir.Inst.Index, gz.zir_code.instructions.len);
1019	gz.zir_code.instructions.appendAssumeCapacity(.{	1019	gz.zir_code.instructions.appendAssumeCapacity(.{
...	@@ -1024,7 +1024,7 @@ pub const Scope = struct {	...	@@ -1024,7 +1024,7 @@ pub const Scope = struct {
1024	} },	1024	} },
1025	});	1025	});
1026	gz.instructions.appendAssumeCapacity(new_index);	1026	gz.instructions.appendAssumeCapacity(new_index);
1027	return new_index + gz.zir_code.ref_start_index;	1027	return zir.Inst.Ref.fromIndex(new_index, gz.zir_code.param_count);
1028	}	1028	}
1029		1029
1030	pub fn addFnType(	1030	pub fn addFnType(
...	@@ -1033,7 +1033,7 @@ pub const Scope = struct {	...	@@ -1033,7 +1033,7 @@ pub const Scope = struct {
1033	ret_ty: zir.Inst.Ref,	1033	ret_ty: zir.Inst.Ref,
1034	param_types: []const zir.Inst.Ref,	1034	param_types: []const zir.Inst.Ref,
1035	) !zir.Inst.Ref {	1035	) !zir.Inst.Ref {
1036	assert(ret_ty != 0);	1036	assert(ret_ty != .none);
1037	const gpa = gz.zir_code.gpa;	1037	const gpa = gz.zir_code.gpa;
1038	try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);	1038	try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);
1039	try gz.zir_code.instructions.ensureCapacity(gpa, gz.zir_code.instructions.len + 1);	1039	try gz.zir_code.instructions.ensureCapacity(gpa, gz.zir_code.instructions.len + 1);
...	@@ -1043,7 +1043,7 @@ pub const Scope = struct {	...	@@ -1043,7 +1043,7 @@ pub const Scope = struct {
1043	const payload_index = gz.zir_code.addExtraAssumeCapacity(zir.Inst.FnType{	1043	const payload_index = gz.zir_code.addExtraAssumeCapacity(zir.Inst.FnType{
1044	.param_types_len = @intCast(u32, param_types.len),	1044	.param_types_len = @intCast(u32, param_types.len),
1045	});	1045	});
1046	gz.zir_code.extra.appendSliceAssumeCapacity(param_types);	1046	gz.zir_code.extra.appendSliceAssumeCapacity(mem.bytesAsSlice(u32, mem.sliceAsBytes(param_types)));
1047		1047
1048	const new_index = @intCast(zir.Inst.Index, gz.zir_code.instructions.len);	1048	const new_index = @intCast(zir.Inst.Index, gz.zir_code.instructions.len);
1049	gz.zir_code.instructions.appendAssumeCapacity(.{	1049	gz.zir_code.instructions.appendAssumeCapacity(.{
...	@@ -1054,7 +1054,7 @@ pub const Scope = struct {	...	@@ -1054,7 +1054,7 @@ pub const Scope = struct {
1054	} },	1054	} },
1055	});	1055	});
1056	gz.instructions.appendAssumeCapacity(new_index);	1056	gz.instructions.appendAssumeCapacity(new_index);
1057	return new_index + gz.zir_code.ref_start_index;	1057	return zir.Inst.Ref.fromIndex(new_index, gz.zir_code.param_count);
1058	}	1058	}
1059		1059
1060	pub fn addCall(	1060	pub fn addCall(
...	@@ -1065,7 +1065,7 @@ pub const Scope = struct {	...	@@ -1065,7 +1065,7 @@ pub const Scope = struct {
1065	/// Absolute node index. This function does the conversion to offset from Decl.	1065	/// Absolute node index. This function does the conversion to offset from Decl.
1066	src_node: ast.Node.Index,	1066	src_node: ast.Node.Index,
1067	) !zir.Inst.Ref {	1067	) !zir.Inst.Ref {
1068	assert(callee != 0);	1068	assert(callee != .none);
1069	assert(src_node != 0);	1069	assert(src_node != 0);
1070	const gpa = gz.zir_code.gpa;	1070	const gpa = gz.zir_code.gpa;
1071	try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);	1071	try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);
...	@@ -1077,7 +1077,7 @@ pub const Scope = struct {	...	@@ -1077,7 +1077,7 @@ pub const Scope = struct {
1077	.callee = callee,	1077	.callee = callee,
1078	.args_len = @intCast(u32, args.len),	1078	.args_len = @intCast(u32, args.len),
1079	});	1079	});
1080	gz.zir_code.extra.appendSliceAssumeCapacity(args);	1080	gz.zir_code.extra.appendSliceAssumeCapacity(mem.bytesAsSlice(u32, mem.sliceAsBytes(args)));
1081		1081
1082	const new_index = @intCast(zir.Inst.Index, gz.zir_code.instructions.len);	1082	const new_index = @intCast(zir.Inst.Index, gz.zir_code.instructions.len);
1083	gz.zir_code.instructions.appendAssumeCapacity(.{	1083	gz.zir_code.instructions.appendAssumeCapacity(.{
...	@@ -1088,7 +1088,7 @@ pub const Scope = struct {	...	@@ -1088,7 +1088,7 @@ pub const Scope = struct {
1088	} },	1088	} },
1089	});	1089	});
1090	gz.instructions.appendAssumeCapacity(new_index);	1090	gz.instructions.appendAssumeCapacity(new_index);
1091	return new_index + gz.zir_code.ref_start_index;	1091	return zir.Inst.Ref.fromIndex(new_index, gz.zir_code.param_count);
1092	}	1092	}
1093		1093
1094	/// Note that this returns a `zir.Inst.Index` not a ref.	1094	/// Note that this returns a `zir.Inst.Index` not a ref.
...	@@ -1098,7 +1098,7 @@ pub const Scope = struct {	...	@@ -1098,7 +1098,7 @@ pub const Scope = struct {
1098	tag: zir.Inst.Tag,	1098	tag: zir.Inst.Tag,
1099	lhs: zir.Inst.Ref,	1099	lhs: zir.Inst.Ref,
1100	) !zir.Inst.Index {	1100	) !zir.Inst.Index {
1101	assert(lhs != 0);	1101	assert(lhs != .none);
1102	const gpa = gz.zir_code.gpa;	1102	const gpa = gz.zir_code.gpa;
1103	try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);	1103	try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);
1104	try gz.zir_code.instructions.ensureCapacity(gpa, gz.zir_code.instructions.len + 1);	1104	try gz.zir_code.instructions.ensureCapacity(gpa, gz.zir_code.instructions.len + 1);
...	@@ -1129,7 +1129,7 @@ pub const Scope = struct {	...	@@ -1129,7 +1129,7 @@ pub const Scope = struct {
1129	/// Absolute node index. This function does the conversion to offset from Decl.	1129	/// Absolute node index. This function does the conversion to offset from Decl.
1130	src_node: ast.Node.Index,	1130	src_node: ast.Node.Index,
1131	) !zir.Inst.Ref {	1131	) !zir.Inst.Ref {
1132	assert(operand != 0);	1132	assert(operand != .none);
1133	return gz.add(.{	1133	return gz.add(.{
1134	.tag = tag,	1134	.tag = tag,
1135	.data = .{ .un_node = .{	1135	.data = .{ .un_node = .{
...	@@ -1160,7 +1160,7 @@ pub const Scope = struct {	...	@@ -1160,7 +1160,7 @@ pub const Scope = struct {
1160	} },	1160	} },
1161	});	1161	});
1162	gz.instructions.appendAssumeCapacity(new_index);	1162	gz.instructions.appendAssumeCapacity(new_index);
1163	return new_index + gz.zir_code.ref_start_index;	1163	return zir.Inst.Ref.fromIndex(new_index, gz.zir_code.param_count);
1164	}	1164	}
1165		1165
1166	pub fn addArrayTypeSentinel(	1166	pub fn addArrayTypeSentinel(
...	@@ -1186,7 +1186,7 @@ pub const Scope = struct {	...	@@ -1186,7 +1186,7 @@ pub const Scope = struct {
1186	} },	1186	} },
1187	});	1187	});
1188	gz.instructions.appendAssumeCapacity(new_index);	1188	gz.instructions.appendAssumeCapacity(new_index);
1189	return new_index + gz.zir_code.ref_start_index;	1189	return zir.Inst.Ref.fromIndex(new_index, gz.zir_code.param_count);
1190	}	1190	}
1191		1191
1192	pub fn addUnTok(	1192	pub fn addUnTok(
...	@@ -1196,7 +1196,7 @@ pub const Scope = struct {	...	@@ -1196,7 +1196,7 @@ pub const Scope = struct {
1196	/// Absolute token index. This function does the conversion to Decl offset.	1196	/// Absolute token index. This function does the conversion to Decl offset.
1197	abs_tok_index: ast.TokenIndex,	1197	abs_tok_index: ast.TokenIndex,
1198	) !zir.Inst.Ref {	1198	) !zir.Inst.Ref {
1199	assert(operand != 0);	1199	assert(operand != .none);
1200	return gz.add(.{	1200	return gz.add(.{
1201	.tag = tag,	1201	.tag = tag,
1202	.data = .{ .un_tok = .{	1202	.data = .{ .un_tok = .{
...	@@ -1228,8 +1228,8 @@ pub const Scope = struct {	...	@@ -1228,8 +1228,8 @@ pub const Scope = struct {
1228	lhs: zir.Inst.Ref,	1228	lhs: zir.Inst.Ref,
1229	rhs: zir.Inst.Ref,	1229	rhs: zir.Inst.Ref,
1230	) !zir.Inst.Ref {	1230	) !zir.Inst.Ref {
1231	assert(lhs != 0);	1231	assert(lhs != .none);
1232	assert(rhs != 0);	1232	assert(rhs != .none);
1233	return gz.add(.{	1233	return gz.add(.{
1234	.tag = tag,	1234	.tag = tag,
1235	.data = .{ .bin = .{	1235	.data = .{ .bin = .{
...	@@ -1317,7 +1317,7 @@ pub const Scope = struct {	...	@@ -1317,7 +1317,7 @@ pub const Scope = struct {
1317	const new_index = @intCast(zir.Inst.Index, gz.zir_code.instructions.len);	1317	const new_index = @intCast(zir.Inst.Index, gz.zir_code.instructions.len);
1318	gz.zir_code.instructions.appendAssumeCapacity(inst);	1318	gz.zir_code.instructions.appendAssumeCapacity(inst);
1319	gz.instructions.appendAssumeCapacity(new_index);	1319	gz.instructions.appendAssumeCapacity(new_index);
1320	return gz.zir_code.ref_start_index + new_index;	1320	return zir.Inst.Ref.fromIndex(new_index, gz.zir_code.param_count);
1321	}	1321	}
1322	};	1322	};
1323		1323
...	@@ -1331,7 +1331,7 @@ pub const Scope = struct {	...	@@ -1331,7 +1331,7 @@ pub const Scope = struct {
1331	parent: *Scope,	1331	parent: *Scope,
1332	gen_zir: *GenZir,	1332	gen_zir: *GenZir,
1333	name: []const u8,	1333	name: []const u8,
1334	inst: zir.Inst.Index,	1334	inst: zir.Inst.Ref,
1335	/// Source location of the corresponding variable declaration.	1335	/// Source location of the corresponding variable declaration.
1336	src: LazySrcLoc,	1336	src: LazySrcLoc,
1337	};	1337	};
...	@@ -1346,7 +1346,7 @@ pub const Scope = struct {	...	@@ -1346,7 +1346,7 @@ pub const Scope = struct {
1346	parent: *Scope,	1346	parent: *Scope,
1347	gen_zir: *GenZir,	1347	gen_zir: *GenZir,
1348	name: []const u8,	1348	name: []const u8,
1349	ptr: zir.Inst.Index,	1349	ptr: zir.Inst.Ref,
1350	/// Source location of the corresponding variable declaration.	1350	/// Source location of the corresponding variable declaration.
1351	src: LazySrcLoc,	1351	src: LazySrcLoc,
1352	};	1352	};
...	@@ -1366,9 +1366,9 @@ pub const WipZirCode = struct {	...	@@ -1366,9 +1366,9 @@ pub const WipZirCode = struct {
1366	instructions: std.MultiArrayList(zir.Inst) = .{},	1366	instructions: std.MultiArrayList(zir.Inst) = .{},
1367	string_bytes: std.ArrayListUnmanaged(u8) = .{},	1367	string_bytes: std.ArrayListUnmanaged(u8) = .{},
1368	extra: std.ArrayListUnmanaged(u32) = .{},	1368	extra: std.ArrayListUnmanaged(u32) = .{},
1369	/// The end of special indexes. `zir.Inst.Ref` subtracts against this number to convert	1369	/// We need to keep track of this count in order to convert between
1370	/// to `zir.Inst.Index`. The default here is correct if there are 0 parameters.	1370	/// `zir.Inst.Ref` and `zir.Inst.Index` types.
1371	ref_start_index: u32 = zir.const_inst_list.len,	1371	param_count: u32 = 0,
1372	decl: *Decl,	1372	decl: *Decl,
1373	gpa: *Allocator,	1373	gpa: *Allocator,
1374	arena: *Allocator,	1374	arena: *Allocator,
...	@@ -1383,15 +1383,18 @@ pub const WipZirCode = struct {	...	@@ -1383,15 +1383,18 @@ pub const WipZirCode = struct {
1383	const fields = std.meta.fields(@TypeOf(extra));	1383	const fields = std.meta.fields(@TypeOf(extra));
1384	const result = @intCast(u32, wzc.extra.items.len);	1384	const result = @intCast(u32, wzc.extra.items.len);
1385	inline for (fields) \|field\| {	1385	inline for (fields) \|field\| {
1386	comptime assert(field.field_type == u32);	1386	wzc.extra.appendAssumeCapacity(switch (field.field_type) {
1387	wzc.extra.appendAssumeCapacity(@field(extra, field.name));	1387	u32 => @field(extra, field.name),
		1388	zir.Inst.Ref => @enumToInt(@field(extra, field.name)),
		1389	else => unreachable,
		1390	});
1388	}	1391	}
1389	return result;	1392	return result;
1390	}	1393	}
1391		1394
1392	pub fn refIsNoReturn(wzc: WipZirCode, zir_inst_ref: zir.Inst.Ref) bool {	1395	pub fn refIsNoReturn(wzc: WipZirCode, zir_inst_ref: zir.Inst.Ref) bool {
1393	if (zir_inst_ref >= wzc.ref_start_index) {	1396	if (zir_inst_ref == .unreachable_value) return true;
1394	const zir_inst = zir_inst_ref - wzc.ref_start_index;	1397	if (zir_inst_ref.toIndex(wzc.param_count)) \|zir_inst\| {
1395	return wzc.instructions.items(.tag)[zir_inst].isNoReturn();	1398	return wzc.instructions.items(.tag)[zir_inst].isNoReturn();
1396	}	1399	}
1397	return false;	1400	return false;
...	@@ -2072,7 +2075,7 @@ fn astgenAndSemaFn(	...	@@ -2072,7 +2075,7 @@ fn astgenAndSemaFn(
2072	// The AST params array does not contain anytype and ... parameters.	2075	// The AST params array does not contain anytype and ... parameters.
2073	// We must iterate to count how many param types to allocate.	2076	// We must iterate to count how many param types to allocate.
2074	const param_count = blk: {	2077	const param_count = blk: {
2075	var count: usize = 0;	2078	var count: u32 = 0;
2076	var it = fn_proto.iterate(tree);	2079	var it = fn_proto.iterate(tree);
2077	while (it.next()) \|param\| {	2080	while (it.next()) \|param\| {
2078	if (param.anytype_ellipsis3) \|some\| if (token_tags[some] == .ellipsis3) break;	2081	if (param.anytype_ellipsis3) \|some\| if (token_tags[some] == .ellipsis3) break;
...	@@ -2081,7 +2084,6 @@ fn astgenAndSemaFn(	...	@@ -2081,7 +2084,6 @@ fn astgenAndSemaFn(
2081	break :blk count;	2084	break :blk count;
2082	};	2085	};
2083	const param_types = try fn_type_scope_arena.allocator.alloc(zir.Inst.Ref, param_count);	2086	const param_types = try fn_type_scope_arena.allocator.alloc(zir.Inst.Ref, param_count);
2084	const type_type_rl: astgen.ResultLoc = .{ .ty = @enumToInt(zir.Const.type_type) };
2085		2087
2086	var is_var_args = false;	2088	var is_var_args = false;
2087	{	2089	{
...	@@ -2106,7 +2108,7 @@ fn astgenAndSemaFn(	...	@@ -2106,7 +2108,7 @@ fn astgenAndSemaFn(
2106	const param_type_node = param.type_expr;	2108	const param_type_node = param.type_expr;
2107	assert(param_type_node != 0);	2109	assert(param_type_node != 0);
2108	param_types[param_type_i] =	2110	param_types[param_type_i] =
2109	try astgen.expr(mod, &fn_type_scope.base, type_type_rl, param_type_node);	2111	try astgen.expr(mod, &fn_type_scope.base, .{ .ty = .type_type }, param_type_node);
2110	}	2112	}
2111	assert(param_type_i == param_count);	2113	assert(param_type_i == param_count);
2112	}	2114	}
...	@@ -2178,7 +2180,7 @@ fn astgenAndSemaFn(	...	@@ -2178,7 +2180,7 @@ fn astgenAndSemaFn(
2178	const return_type_inst = try astgen.expr(	2180	const return_type_inst = try astgen.expr(
2179	mod,	2181	mod,
2180	&fn_type_scope.base,	2182	&fn_type_scope.base,
2181	type_type_rl,	2183	.{ .ty = .type_type },
2182	fn_proto.ast.return_type,	2184	fn_proto.ast.return_type,
2183	);	2185	);
2184		2186
...	@@ -2187,19 +2189,22 @@ fn astgenAndSemaFn(	...	@@ -2187,19 +2189,22 @@ fn astgenAndSemaFn(
2187	else	2189	else
2188	false;	2190	false;
2189		2191
2190	const cc: zir.Inst.Index = if (fn_proto.ast.callconv_expr != 0)	2192	const cc: zir.Inst.Ref = if (fn_proto.ast.callconv_expr != 0)
2191	// TODO instead of enum literal type, this needs to be the	2193	// TODO instead of enum literal type, this needs to be the
2192	// std.builtin.CallingConvention enum. We need to implement importing other files	2194	// std.builtin.CallingConvention enum. We need to implement importing other files
2193	// and enums in order to fix this.	2195	// and enums in order to fix this.
2194	try astgen.comptimeExpr(mod, &fn_type_scope.base, .{	2196	try astgen.comptimeExpr(
2195	.ty = @enumToInt(zir.Const.enum_literal_type),	2197	mod,
2196	}, fn_proto.ast.callconv_expr)	2198	&fn_type_scope.base,
		2199	.{ .ty = .enum_literal_type },
		2200	fn_proto.ast.callconv_expr,
		2201	)
2197	else if (is_extern) // note: https://github.com/ziglang/zig/issues/5269	2202	else if (is_extern) // note: https://github.com/ziglang/zig/issues/5269
2198	try fn_type_scope.addSmallStr(.enum_literal_small, "C")	2203	try fn_type_scope.addSmallStr(.enum_literal_small, "C")
2199	else	2204	else
2200	0;	2205	.none;
2201		2206
2202	const fn_type_inst: zir.Inst.Ref = if (cc != 0) fn_type: {	2207	const fn_type_inst: zir.Inst.Ref = if (cc != .none) fn_type: {
2203	const tag: zir.Inst.Tag = if (is_var_args) .fn_type_cc_var_args else .fn_type_cc;	2208	const tag: zir.Inst.Tag = if (is_var_args) .fn_type_cc_var_args else .fn_type_cc;
2204	break :fn_type try fn_type_scope.addFnTypeCc(tag, .{	2209	break :fn_type try fn_type_scope.addFnTypeCc(tag, .{
2205	.ret_ty = return_type_inst,	2210	.ret_ty = return_type_inst,
...	@@ -2292,7 +2297,7 @@ fn astgenAndSemaFn(	...	@@ -2292,7 +2297,7 @@ fn astgenAndSemaFn(
2292	.decl = decl,	2297	.decl = decl,
2293	.arena = &decl_arena.allocator,	2298	.arena = &decl_arena.allocator,
2294	.gpa = mod.gpa,	2299	.gpa = mod.gpa,
2295	.ref_start_index = @intCast(u32, zir.const_inst_list.len + param_count),	2300	.param_count = param_count,
2296	};	2301	};
2297	defer wip_zir_code.deinit();	2302	defer wip_zir_code.deinit();
2298		2303
...	@@ -2309,7 +2314,7 @@ fn astgenAndSemaFn(	...	@@ -2309,7 +2314,7 @@ fn astgenAndSemaFn(
2309	try wip_zir_code.extra.ensureCapacity(mod.gpa, param_count);	2314	try wip_zir_code.extra.ensureCapacity(mod.gpa, param_count);
2310		2315
2311	var params_scope = &gen_scope.base;	2316	var params_scope = &gen_scope.base;
2312	var i: usize = 0;	2317	var i: u32 = 0;
2313	var it = fn_proto.iterate(tree);	2318	var it = fn_proto.iterate(tree);
2314	while (it.next()) \|param\| : (i += 1) {	2319	while (it.next()) \|param\| : (i += 1) {
2315	const name_token = param.name_token.?;	2320	const name_token = param.name_token.?;
...	@@ -2320,7 +2325,7 @@ fn astgenAndSemaFn(	...	@@ -2320,7 +2325,7 @@ fn astgenAndSemaFn(
2320	.gen_zir = &gen_scope,	2325	.gen_zir = &gen_scope,
2321	.name = param_name,	2326	.name = param_name,
2322	// Implicit const list first, then implicit arg list.	2327	// Implicit const list first, then implicit arg list.
2323	.inst = @intCast(u32, zir.const_inst_list.len + i),	2328	.inst = zir.Inst.Ref.fromParam(i),
2324	.src = decl.tokSrcLoc(name_token),	2329	.src = decl.tokSrcLoc(name_token),
2325	};	2330	};
2326	params_scope = &sub_scope.base;	2331	params_scope = &sub_scope.base;
...	@@ -2344,8 +2349,7 @@ fn astgenAndSemaFn(	...	@@ -2344,8 +2349,7 @@ fn astgenAndSemaFn(
2344	// astgen uses result location semantics to coerce return operands.	2349	// astgen uses result location semantics to coerce return operands.
2345	// Since we are adding the return instruction here, we must handle the coercion.	2350	// Since we are adding the return instruction here, we must handle the coercion.
2346	// We do this by using the `ret_coerce` instruction.	2351	// We do this by using the `ret_coerce` instruction.
2347	const void_inst: zir.Inst.Ref = @enumToInt(zir.Const.void_value);	2352	_ = try gen_scope.addUnTok(.ret_coerce, .void_value, tree.lastToken(body_node));
2348	_ = try gen_scope.addUnTok(.ret_coerce, void_inst, tree.lastToken(body_node));
2349	}	2353	}
2350		2354
2351	const code = try gen_scope.finish();	2355	const code = try gen_scope.finish();
...	@@ -2514,9 +2518,7 @@ fn astgenAndSemaVarDecl(	...	@@ -2514,9 +2518,7 @@ fn astgenAndSemaVarDecl(
2514	defer gen_scope.instructions.deinit(mod.gpa);	2518	defer gen_scope.instructions.deinit(mod.gpa);
2515		2519
2516	const init_result_loc: astgen.ResultLoc = if (var_decl.ast.type_node != 0) .{	2520	const init_result_loc: astgen.ResultLoc = if (var_decl.ast.type_node != 0) .{
2517	.ty = try astgen.expr(mod, &gen_scope.base, .{	2521	.ty = try astgen.expr(mod, &gen_scope.base, .{ .ty = .type_type }, var_decl.ast.type_node),
2518	.ty = @enumToInt(zir.Const.type_type),
2519	}, var_decl.ast.type_node),
2520	} else .none;	2522	} else .none;
2521		2523
2522	const init_inst = try astgen.comptimeExpr(	2524	const init_inst = try astgen.comptimeExpr(

src/Sema.zig+32-34

...	@@ -78,7 +78,7 @@ pub fn rootAsType(sema: Sema, root_block: Scope.Block) !Type {	...	@@ -78,7 +78,7 @@ pub fn rootAsType(sema: Sema, root_block: Scope.Block) !Type {
78	/// return type of `analyzeBody` so that we can tail call them.	78	/// return type of `analyzeBody` so that we can tail call them.
79	/// Only appropriate to return when the instruction is known to be NoReturn	79	/// Only appropriate to return when the instruction is known to be NoReturn
80	/// solely based on the ZIR tag.	80	/// solely based on the ZIR tag.
81	const always_noreturn: InnerError!zir.Inst.Ref = @as(zir.Inst.Index, 0);	81	const always_noreturn: InnerError!zir.Inst.Ref = .none;
82		82
83	/// This function is the main loop of `Sema` and it can be used in two different ways:	83	/// This function is the main loop of `Sema` and it can be used in two different ways:
84	/// * The traditional way where there are N breaks out of the block and peer type	84	/// * The traditional way where there are N breaks out of the block and peer type
...	@@ -88,7 +88,7 @@ const always_noreturn: InnerError!zir.Inst.Ref = @as(zir.Inst.Index, 0);	...	@@ -88,7 +88,7 @@ const always_noreturn: InnerError!zir.Inst.Ref = @as(zir.Inst.Index, 0);
88	/// * The "flat" way. There is only 1 break out of the block, and it is with a `break_flat`	88	/// * The "flat" way. There is only 1 break out of the block, and it is with a `break_flat`
89	/// instruction. In this case, the `zir.Inst.Index` part of the return value will be	89	/// instruction. In this case, the `zir.Inst.Index` part of the return value will be
90	/// the block result value. No block scope needs to be created for this strategy.	90	/// the block result value. No block scope needs to be created for this strategy.
91	pub fn analyzeBody(sema: Sema, block: Scope.Block, body: []const zir.Inst.Index) !zir.Inst.Index {	91	pub fn analyzeBody(sema: Sema, block: Scope.Block, body: []const zir.Inst.Index) !zir.Inst.Ref {
92	// No tracy calls here, to avoid interfering with the tail call mechanism.	92	// No tracy calls here, to avoid interfering with the tail call mechanism.
93		93
94	const map = block.sema.inst_map;	94	const map = block.sema.inst_map;
...	@@ -300,28 +300,18 @@ pub fn analyzeBody(sema: Sema, block: Scope.Block, body: []const zir.Inst.Inde	...	@@ -300,28 +300,18 @@ pub fn analyzeBody(sema: Sema, block: Scope.Block, body: []const zir.Inst.Inde
300	}	300	}
301		301
302	/// TODO when we rework TZIR memory layout, this function will no longer have a possible error.	302	/// TODO when we rework TZIR memory layout, this function will no longer have a possible error.
		303	/// Until then we allocate memory for a new, mutable `ir.Inst` to match what TZIR expects.
303	pub fn resolveInst(sema: Sema, zir_ref: zir.Inst.Ref) error{OutOfMemory}!ir.Inst {	304	pub fn resolveInst(sema: Sema, zir_ref: zir.Inst.Ref) error{OutOfMemory}!ir.Inst {
304	var i: usize = zir_ref;	305	if (zir_ref.toTypedValue()) \|typed_value\| {
305		306	return sema.mod.constInst(sema.arena, .unneeded, typed_value);
306	// First section of indexes correspond to a set number of constant values.
307	if (i < zir.const_inst_list.len) {
308	// TODO when we rework TZIR memory layout, this function can be as simple as:
309	// if (zir_ref < zir.const_inst_list.len + sema.param_count)
310	// return zir_ref;
311	// Until then we allocate memory for a new, mutable `ir.Inst` to match what
312	// TZIR expects.
313	return sema.mod.constInst(sema.arena, .unneeded, zir.const_inst_list[i]);
314	}	307	}
315	i -= zir.const_inst_list.len;
316		308
317	// Next section of indexes correspond to function parameters, if any.	309	const param_count = @intCast(u32, sema.param_inst_list.len);
318	if (i < sema.param_inst_list.len) {	310	if (zir_ref.toParam(param_count)) \|param\| {
319	return sema.param_inst_list[i];	311	return sema.param_inst_list[param];
320	}	312	}
321	i -= sema.param_inst_list.len;
322		313
323	// Finally, the last section of indexes refers to the map of ZIR=>TZIR.	314	return sema.inst_map[zir_ref.toIndex(param_count).?];
324	return sema.inst_map[i];
325	}	315	}
326		316
327	fn resolveConstString(	317	fn resolveConstString(
...	@@ -745,7 +735,7 @@ fn zirInt(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerError!*In	...	@@ -745,7 +735,7 @@ fn zirInt(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerError!*In
745	return sema.mod.constIntUnsigned(sema.arena, .unneeded, Type.initTag(.comptime_int), int);	735	return sema.mod.constIntUnsigned(sema.arena, .unneeded, Type.initTag(.comptime_int), int);
746	}	736	}
747		737
748	fn zirCompileError(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerError!zir.Inst.Index {	738	fn zirCompileError(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerError!zir.Inst.Ref {
749	const tracy = trace(@src());	739	const tracy = trace(@src());
750	defer tracy.end();	740	defer tracy.end();
751		741
...	@@ -763,7 +753,10 @@ fn zirCompileLog(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerEr	...	@@ -763,7 +753,10 @@ fn zirCompileLog(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerEr
763		753
764	const inst_data = sema.code.instructions.items(.data)[inst].pl_node;	754	const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
765	const extra = sema.code.extraData(zir.Inst.MultiOp, inst_data.payload_index);	755	const extra = sema.code.extraData(zir.Inst.MultiOp, inst_data.payload_index);
766	for (sema.code.extra[extra.end..][0..extra.data.operands_len]) \|arg_ref, i\| {	756	const raw_args = sema.code.extra[extra.end..][0..extra.data.operands_len];
		757	const args = mem.bytesAsSlice(zir.Inst.Ref, mem.sliceAsBytes(raw_args));
		758
		759	for (args) \|arg_ref, i\| {
767	if (i != 0) try writer.print(", ", .{});	760	if (i != 0) try writer.print(", ", .{});
768		761
769	const arg = try sema.resolveInst(arg_ref);	762	const arg = try sema.resolveInst(arg_ref);
...	@@ -998,7 +991,7 @@ fn zirBreakpoint(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerEr	...	@@ -998,7 +991,7 @@ fn zirBreakpoint(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerEr
998	_ = try block.addNoOp(src, Type.initTag(.void), .breakpoint);	991	_ = try block.addNoOp(src, Type.initTag(.void), .breakpoint);
999	}	992	}
1000		993
1001	fn zirBreak(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerError!zir.Inst.Index {	994	fn zirBreak(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerError!zir.Inst.Ref {
1002	const tracy = trace(@src());	995	const tracy = trace(@src());
1003	defer tracy.end();	996	defer tracy.end();
1004		997
...	@@ -1007,7 +1000,7 @@ fn zirBreak(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerError!z	...	@@ -1007,7 +1000,7 @@ fn zirBreak(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerError!z
1007	return sema.analyzeBreak(block, sema.src, inst_data.block_inst, operand);	1000	return sema.analyzeBreak(block, sema.src, inst_data.block_inst, operand);
1008	}	1001	}
1009		1002
1010	fn zirBreakVoidNode(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerError!zir.Inst.Index {	1003	fn zirBreakVoidNode(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerError!zir.Inst.Ref {
1011	const tracy = trace(@src());	1004	const tracy = trace(@src());
1012	defer tracy.end();	1005	defer tracy.end();
1013		1006
...	@@ -1112,7 +1105,8 @@ fn zirCall(	...	@@ -1112,7 +1105,8 @@ fn zirCall(
1112	const func_src: LazySrcLoc = .{ .node_offset_call_func = inst_data.src_node };	1105	const func_src: LazySrcLoc = .{ .node_offset_call_func = inst_data.src_node };
1113	const call_src = inst_data.src();	1106	const call_src = inst_data.src();
1114	const extra = sema.code.extraData(zir.Inst.Call, inst_data.payload_index);	1107	const extra = sema.code.extraData(zir.Inst.Call, inst_data.payload_index);
1115	const args = sema.code.extra[extra.end..][0..extra.data.args_len];	1108	const raw_args = sema.code.extra[extra.end..][0..extra.data.args_len];
		1109	const args = mem.bytesAsSlice(zir.Inst.Ref, mem.sliceAsBytes(raw_args));
1116		1110
1117	return sema.analyzeCall(block, extra.data.callee, func_src, call_src, modifier, ensure_result_used, args);	1111	return sema.analyzeCall(block, extra.data.callee, func_src, call_src, modifier, ensure_result_used, args);
1118	}	1112	}
...	@@ -1739,7 +1733,8 @@ fn zirFnType(sema: Sema, block: Scope.Block, inst: zir.Inst.Index, var_args: b	...	@@ -1739,7 +1733,8 @@ fn zirFnType(sema: Sema, block: Scope.Block, inst: zir.Inst.Index, var_args: b
1739		1733
1740	const inst_data = sema.code.instructions.items(.data)[inst].fn_type;	1734	const inst_data = sema.code.instructions.items(.data)[inst].fn_type;
1741	const extra = sema.code.extraData(zir.Inst.FnType, inst_data.payload_index);	1735	const extra = sema.code.extraData(zir.Inst.FnType, inst_data.payload_index);
1742	const param_types = sema.code.extra[extra.end..][0..extra.data.param_types_len];	1736	const raw_param_types = sema.code.extra[extra.end..][0..extra.data.param_types_len];
		1737	const param_types = mem.bytesAsSlice(zir.Inst.Ref, mem.sliceAsBytes(raw_param_types));
1743		1738
1744	return sema.fnTypeCommon(	1739	return sema.fnTypeCommon(
1745	block,	1740	block,
...	@@ -1757,7 +1752,8 @@ fn zirFnTypeCc(sema: Sema, block: Scope.Block, inst: zir.Inst.Index, var_args:	...	@@ -1757,7 +1752,8 @@ fn zirFnTypeCc(sema: Sema, block: Scope.Block, inst: zir.Inst.Index, var_args:
1757		1752
1758	const inst_data = sema.code.instructions.items(.data)[inst].fn_type;	1753	const inst_data = sema.code.instructions.items(.data)[inst].fn_type;
1759	const extra = sema.code.extraData(zir.Inst.FnTypeCc, inst_data.payload_index);	1754	const extra = sema.code.extraData(zir.Inst.FnTypeCc, inst_data.payload_index);
1760	const param_types = sema.code.extra[extra.end..][0..extra.data.param_types_len];	1755	const raw_param_types = sema.code.extra[extra.end..][0..extra.data.param_types_len];
		1756	const param_types = mem.bytesAsSlice(zir.Inst.Ref, mem.sliceAsBytes(raw_param_types));
1761		1757
1762	const cc_tv = try sema.resolveInstConst(block, .todo, extra.data.cc);	1758	const cc_tv = try sema.resolveInstConst(block, .todo, extra.data.cc);
1763	// TODO once we're capable of importing and analyzing decls from	1759	// TODO once we're capable of importing and analyzing decls from
...	@@ -2487,7 +2483,7 @@ fn zirNegate(	...	@@ -2487,7 +2483,7 @@ fn zirNegate(
2487	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };	2483	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
2488	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };	2484	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
2489	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };	2485	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
2490	const lhs = try sema.resolveInst(@enumToInt(zir.Const.zero));	2486	const lhs = try sema.resolveInst(.zero);
2491	const rhs = try sema.resolveInst(inst_data.operand);	2487	const rhs = try sema.resolveInst(inst_data.operand);
2492		2488
2493	return sema.analyzeArithmetic(block, tag_override, lhs, rhs, src, lhs_src, rhs_src);	2489	return sema.analyzeArithmetic(block, tag_override, lhs, rhs, src, lhs_src, rhs_src);
...	@@ -2641,7 +2637,7 @@ fn zirAsm(	...	@@ -2641,7 +2637,7 @@ fn zirAsm(
2641		2637
2642	var extra_i = extra.end;	2638	var extra_i = extra.end;
2643	const Output = struct { name: []const u8, inst: *Inst };	2639	const Output = struct { name: []const u8, inst: *Inst };
2644	const output: ?Output = if (extra.data.output != 0) blk: {	2640	const output: ?Output = if (extra.data.output != .none) blk: {
2645	const name = sema.code.nullTerminatedString(sema.code.extra[extra_i]);	2641	const name = sema.code.nullTerminatedString(sema.code.extra[extra_i]);
2646	extra_i += 1;	2642	extra_i += 1;
2647	break :blk Output{	2643	break :blk Output{
...	@@ -2655,7 +2651,7 @@ fn zirAsm(	...	@@ -2655,7 +2651,7 @@ fn zirAsm(
2655	const clobbers = try sema.arena.alloc([]const u8, extra.data.clobbers_len);	2651	const clobbers = try sema.arena.alloc([]const u8, extra.data.clobbers_len);
2656		2652
2657	for (args) \|*arg\| {	2653	for (args) \|*arg\| {
2658	arg.* = try sema.resolveInst(sema.code.extra[extra_i]);	2654	arg.* = try sema.resolveInst(@intToEnum(zir.Inst.Ref, sema.code.extra[extra_i]));
2659	extra_i += 1;	2655	extra_i += 1;
2660	}	2656	}
2661	for (inputs) \|*name\| {	2657	for (inputs) \|*name\| {
...	@@ -2772,11 +2768,13 @@ fn zirTypeofPeer(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerEr	...	@@ -2772,11 +2768,13 @@ fn zirTypeofPeer(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerEr
2772	const inst_data = sema.code.instructions.items(.data)[inst].pl_node;	2768	const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
2773	const src = inst_data.src();	2769	const src = inst_data.src();
2774	const extra = sema.code.extraData(zir.Inst.MultiOp, inst_data.payload_index);	2770	const extra = sema.code.extraData(zir.Inst.MultiOp, inst_data.payload_index);
		2771	const raw_args = sema.code.extra[extra.end..][0..extra.data.operands_len];
		2772	const args = mem.bytesAsSlice(zir.Inst.Ref, mem.sliceAsBytes(raw_args));
2775		2773
2776	const inst_list = try sema.gpa.alloc(*ir.Inst, extra.data.operands_len);	2774	const inst_list = try sema.gpa.alloc(*ir.Inst, extra.data.operands_len);
2777	defer sema.gpa.free(inst_list);	2775	defer sema.gpa.free(inst_list);
2778		2776
2779	for (sema.code.extra[extra.end..][0..extra.data.operands_len]) \|arg_ref, i\| {	2777	for (args) \|arg_ref, i\| {
2780	inst_list[i] = try sema.resolveInst(arg_ref);	2778	inst_list[i] = try sema.resolveInst(arg_ref);
2781	}	2779	}
2782		2780
...	@@ -3115,25 +3113,25 @@ fn zirPtrType(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerError	...	@@ -3115,25 +3113,25 @@ fn zirPtrType(sema: Sema, block: Scope.Block, inst: zir.Inst.Index) InnerError
3115	var extra_i = extra.end;	3113	var extra_i = extra.end;
3116		3114
3117	const sentinel = if (inst_data.flags.has_sentinel) blk: {	3115	const sentinel = if (inst_data.flags.has_sentinel) blk: {
3118	const ref = sema.code.extra[extra_i];	3116	const ref = @intToEnum(zir.Inst.Ref, sema.code.extra[extra_i]);
3119	extra_i += 1;	3117	extra_i += 1;
3120	break :blk (try sema.resolveInstConst(block, .unneeded, ref)).val;	3118	break :blk (try sema.resolveInstConst(block, .unneeded, ref)).val;
3121	} else null;	3119	} else null;
3122		3120
3123	const abi_align = if (inst_data.flags.has_align) blk: {	3121	const abi_align = if (inst_data.flags.has_align) blk: {
3124	const ref = sema.code.extra[extra_i];	3122	const ref = @intToEnum(zir.Inst.Ref, sema.code.extra[extra_i]);
3125	extra_i += 1;	3123	extra_i += 1;
3126	break :blk try sema.resolveAlreadyCoercedInt(block, .unneeded, ref, u32);	3124	break :blk try sema.resolveAlreadyCoercedInt(block, .unneeded, ref, u32);
3127	} else 0;	3125	} else 0;
3128		3126
3129	const bit_start = if (inst_data.flags.has_bit_range) blk: {	3127	const bit_start = if (inst_data.flags.has_bit_range) blk: {
3130	const ref = sema.code.extra[extra_i];	3128	const ref = @intToEnum(zir.Inst.Ref, sema.code.extra[extra_i]);
3131	extra_i += 1;	3129	extra_i += 1;
3132	break :blk try sema.resolveAlreadyCoercedInt(block, .unneeded, ref, u16);	3130	break :blk try sema.resolveAlreadyCoercedInt(block, .unneeded, ref, u16);
3133	} else 0;	3131	} else 0;
3134		3132
3135	const bit_end = if (inst_data.flags.has_bit_range) blk: {	3133	const bit_end = if (inst_data.flags.has_bit_range) blk: {
3136	const ref = sema.code.extra[extra_i];	3134	const ref = @intToEnum(zir.Inst.Ref, sema.code.extra[extra_i]);
3137	extra_i += 1;	3135	extra_i += 1;
3138	break :blk try sema.resolveAlreadyCoercedInt(block, .unneeded, ref, u16);	3136	break :blk try sema.resolveAlreadyCoercedInt(block, .unneeded, ref, u16);
3139	} else 0;	3137	} else 0;

src/astgen.zig+85-106

 @@ -58,11 +58,8 @@ pub const ResultLoc = union(enum) {
     };
 };
-const void_inst: zir.Inst.Ref = @enumToInt(zir.Const.void_value);
 pub fn typeExpr(mod: *Module, scope: *Scope, type_node: ast.Node.Index) InnerError!zir.Inst.Ref {
-    const type_rl: ResultLoc = .{ .ty = @enumToInt(zir.Const.type_type) };
+    return expr(mod, scope, .{ .ty = .type_type }, type_node);
-    return expr(mod, scope, type_rl, type_node);
 }
 fn lvalExpr(mod: *Module, scope: *Scope, node: ast.Node.Index) InnerError!zir.Inst.Ref {
 @@ -291,59 +288,59 @@ pub fn expr(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) In
         .assign => {
             try assign(mod, scope, node);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .assign_bit_and => {
             try assignOp(mod, scope, node, .bit_and);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .assign_bit_or => {
             try assignOp(mod, scope, node, .bit_or);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .assign_bit_shift_left => {
             try assignOp(mod, scope, node, .shl);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .assign_bit_shift_right => {
             try assignOp(mod, scope, node, .shr);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .assign_bit_xor => {
             try assignOp(mod, scope, node, .xor);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .assign_div => {
             try assignOp(mod, scope, node, .div);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .assign_sub => {
             try assignOp(mod, scope, node, .sub);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .assign_sub_wrap => {
             try assignOp(mod, scope, node, .subwrap);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .assign_mod => {
             try assignOp(mod, scope, node, .mod_rem);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .assign_add => {
             try assignOp(mod, scope, node, .add);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .assign_add_wrap => {
             try assignOp(mod, scope, node, .addwrap);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .assign_mul => {
             try assignOp(mod, scope, node, .mul);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .assign_mul_wrap => {
             try assignOp(mod, scope, node, .mulwrap);
-            return rvalue(mod, scope, rl, void_inst, node);
+            return rvalue(mod, scope, rl, .void_value, node);
         },
         .add => return simpleBinOp(mod, scope, rl, node, .add),
 @@ -450,22 +447,10 @@ pub fn expr(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) In
             const result = try expr(mod, scope, .ref, node_datas[node].lhs);
             return rvalue(mod, scope, rl, result, node);
         },
-        .undefined_literal => {
+        .undefined_literal => return rvalue(mod, scope, rl, .undef, node),
-            const result = @enumToInt(zir.Const.undef);
+        .true_literal => return rvalue(mod, scope, rl, .bool_true, node),
-            return rvalue(mod, scope, rl, result, node);
+        .false_literal => return rvalue(mod, scope, rl, .bool_false, node),
-        },
+        .null_literal => return rvalue(mod, scope, rl, .null_value, node),
-        .true_literal => {
-            const result = @enumToInt(zir.Const.bool_true);
-            return rvalue(mod, scope, rl, result, node);
-        },
-        .false_literal => {
-            const result = @enumToInt(zir.Const.bool_false);
-            return rvalue(mod, scope, rl, result, node);
-        },
-        .null_literal => {
-            const result = @enumToInt(zir.Const.null_value);
-            return rvalue(mod, scope, rl, result, node);
-        },
         .optional_type => {
             const operand = try typeExpr(mod, scope, node_datas[node].lhs);
             const result = try gz.addUnNode(.optional_type, operand, node);
 @@ -830,7 +815,7 @@ pub fn blockExpr(
     }
     try blockExprStmts(mod, scope, block_node, statements);
-    return rvalue(mod, scope, rl, void_inst, block_node);
+    return rvalue(mod, scope, rl, .void_value, block_node);
 }
 fn checkLabelRedefinition(mod: *Module, parent_scope: *Scope, label: ast.TokenIndex) !void {
 @@ -935,13 +920,13 @@ fn labeledBlockExpr(
             // The code took advantage of the result location as a pointer.
             // Turn the break instruction operands into void.
             for (block_scope.labeled_breaks.items) |br| {
-                zir_datas[br].@"break".operand = @enumToInt(zir.Const.void_value);
+                zir_datas[br].@"break".operand = .void_value;
             }
             // TODO technically not needed since we changed the tag to break_void but
             // would be better still to elide the ones that are in this list.
             try block_scope.setBlockBody(block_inst);
-            return gz.zir_code.ref_start_index + block_inst;
+            return zir.Inst.Ref.fromIndex(block_inst, gz.zir_code.param_count);
         },
         .break_operand => {
             // All break operands are values that did not use the result location pointer.
 @@ -954,7 +939,7 @@ fn labeledBlockExpr(
                 // would be better still to elide the ones that are in this list.
             }
             try block_scope.setBlockBody(block_inst);
-            const block_ref = gz.zir_code.ref_start_index + block_inst;
+            const block_ref = zir.Inst.Ref.fromIndex(block_inst, gz.zir_code.param_count);
             switch (rl) {
                 .ref => return block_ref,
                 else => return rvalue(mod, parent_scope, rl, block_ref, block_node),
 @@ -1006,8 +991,7 @@ fn blockExprStmts(
                 // We need to emit an error if the result is not `noreturn` or `void`, but
                 // we want to avoid adding the ZIR instruction if possible for performance.
                 const maybe_unused_result = try expr(mod, scope, .none, statement);
-                const elide_check = if (maybe_unused_result >= gz.zir_code.ref_start_index) b: {
+                const elide_check = if (maybe_unused_result.toIndex(gz.zir_code.param_count)) |inst| b: {
-                    const inst = maybe_unused_result - gz.zir_code.ref_start_index;
                     // Note that this array becomes invalid after appending more items to it
                     // in the above while loop.
                     const zir_tags = gz.zir_code.instructions.items(.tag);
 @@ -1167,10 +1151,10 @@ fn blockExprStmts(
                         => break :b true,
                     }
                 } else switch (maybe_unused_result) {
-                    @enumToInt(zir.Const.unused) => unreachable,
+                    .none => unreachable,
-                    @enumToInt(zir.Const.void_value),
+                    .void_value,
-                    @enumToInt(zir.Const.unreachable_value),
+                    .unreachable_value,
                     => true,
                     else => false,
 @@ -1283,8 +1267,8 @@ fn varDecl(
             };
             defer init_scope.instructions.deinit(mod.gpa);
-            var resolve_inferred_alloc: zir.Inst.Ref = 0;
+            var resolve_inferred_alloc: zir.Inst.Ref = .none;
-            var opt_type_inst: zir.Inst.Ref = 0;
+            var opt_type_inst: zir.Inst.Ref = .none;
             if (var_decl.ast.type_node != 0) {
                 const type_inst = try typeExpr(mod, &init_scope.base, var_decl.ast.type_node);
                 opt_type_inst = type_inst;
 @@ -1308,14 +1292,14 @@ fn varDecl(
                 const expected_len = parent_zir.items.len + init_scope.instructions.items.len - 2;
                 try parent_zir.ensureCapacity(mod.gpa, expected_len);
                 for (init_scope.instructions.items) |src_inst| {
-                    if (wzc.ref_start_index + src_inst == init_scope.rl_ptr) continue;
+                    if (zir.Inst.Ref.fromIndex(src_inst, wzc.param_count) == init_scope.rl_ptr) continue;
                     if (zir_tags[src_inst] == .store_to_block_ptr) {
                         if (zir_datas[src_inst].bin.lhs == init_scope.rl_ptr) continue;
                     }
                     parent_zir.appendAssumeCapacity(src_inst);
                 }
                 assert(parent_zir.items.len == expected_len);
-                const casted_init = if (opt_type_inst != 0)
+                const casted_init = if (opt_type_inst != .none)
                     try gz.addPlNode(.as_node, var_decl.ast.type_node, zir.Inst.As{
                         .dest_type = opt_type_inst,
                         .operand = init_inst,
 @@ -1348,7 +1332,7 @@ fn varDecl(
                 parent_zir.appendAssumeCapacity(src_inst);
             }
             assert(parent_zir.items.len == expected_len);
-            if (resolve_inferred_alloc != 0) {
+            if (resolve_inferred_alloc != .none) {
                 _ = try gz.addUnNode(.resolve_inferred_alloc, resolve_inferred_alloc, node);
             }
             const sub_scope = try block_arena.create(Scope.LocalPtr);
 @@ -1362,7 +1346,7 @@ fn varDecl(
             return &sub_scope.base;
         },
         .keyword_var => {
-            var resolve_inferred_alloc: zir.Inst.Ref = 0;
+            var resolve_inferred_alloc: zir.Inst.Ref = .none;
             const var_data: struct {
                 result_loc: ResultLoc,
                 alloc: zir.Inst.Ref,
 @@ -1377,7 +1361,7 @@ fn varDecl(
                 break :a .{ .alloc = alloc, .result_loc = .{ .inferred_ptr = alloc } };
             };
             const init_inst = try expr(mod, scope, var_data.result_loc, var_decl.ast.init_node);
-            if (resolve_inferred_alloc != 0) {
+            if (resolve_inferred_alloc != .none) {
                 _ = try gz.addUnNode(.resolve_inferred_alloc, resolve_inferred_alloc, node);
             }
             const sub_scope = try block_arena.create(Scope.LocalPtr);
 @@ -1440,7 +1424,7 @@ fn boolNot(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) Inn
     const tree = scope.tree();
     const node_datas = tree.nodes.items(.data);
-    const operand = try expr(mod, scope, .{ .ty = @enumToInt(zir.Const.bool_type) }, node_datas[node].lhs);
+    const operand = try expr(mod, scope, .{ .ty = .bool_type }, node_datas[node].lhs);
     const gz = scope.getGenZir();
     const result = try gz.addUnNode(.bool_not, operand, node);
     return rvalue(mod, scope, rl, result, node);
 @@ -1501,10 +1485,10 @@ fn ptrType(
         return rvalue(mod, scope, rl, result, node);
     }
-    var sentinel_ref: zir.Inst.Ref = 0;
+    var sentinel_ref: zir.Inst.Ref = .none;
-    var align_ref: zir.Inst.Ref = 0;
+    var align_ref: zir.Inst.Ref = .none;
-    var bit_start_ref: zir.Inst.Ref = 0;
+    var bit_start_ref: zir.Inst.Ref = .none;
-    var bit_end_ref: zir.Inst.Ref = 0;
+    var bit_end_ref: zir.Inst.Ref = .none;
     var trailing_count: u32 = 0;
     if (ptr_info.ast.sentinel != 0) {
 @@ -1529,24 +1513,28 @@ fn ptrType(
         @typeInfo(zir.Inst.PtrType).Struct.fields.len + trailing_count);
     const payload_index = gz.zir_code.addExtraAssumeCapacity(zir.Inst.PtrType{ .elem_type = elem_type });
-    if (sentinel_ref != 0) gz.zir_code.extra.appendAssumeCapacity(sentinel_ref);
+    if (sentinel_ref != .none) {
-    if (align_ref != 0) gz.zir_code.extra.appendAssumeCapacity(align_ref);
+        gz.zir_code.extra.appendAssumeCapacity(@enumToInt(sentinel_ref));
-    if (bit_start_ref != 0) {
+    }
-        gz.zir_code.extra.appendAssumeCapacity(bit_start_ref);
+    if (align_ref != .none) {
-        gz.zir_code.extra.appendAssumeCapacity(bit_end_ref);
+        gz.zir_code.extra.appendAssumeCapacity(@enumToInt(align_ref));
+    }
+    if (bit_start_ref != .none) {
+        gz.zir_code.extra.appendAssumeCapacity(@enumToInt(bit_start_ref));
+        gz.zir_code.extra.appendAssumeCapacity(@enumToInt(bit_end_ref));
     }
     const new_index = @intCast(zir.Inst.Index, gz.zir_code.instructions.len);
-    const result = new_index + gz.zir_code.ref_start_index;
+    const result = zir.Inst.Ref.fromIndex(new_index, gz.zir_code.param_count);
     gz.zir_code.instructions.appendAssumeCapacity(.{ .tag = .ptr_type, .data = .{
         .ptr_type = .{
             .flags = .{
                 .is_allowzero = ptr_info.allowzero_token != null,
                 .is_mutable = ptr_info.const_token == null,
                 .is_volatile = ptr_info.volatile_token != null,
-                .has_sentinel = sentinel_ref != 0,
+                .has_sentinel = sentinel_ref != .none,
-                .has_align = align_ref != 0,
+                .has_align = align_ref != .none,
-                .has_bit_range = bit_start_ref != 0,
+                .has_bit_range = bit_start_ref != .none,
             },
             .size = ptr_info.size,
             .payload_index = payload_index,
 @@ -1561,10 +1549,9 @@ fn arrayType(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.Index) !
     const tree = scope.tree();
     const node_datas = tree.nodes.items(.data);
     const gz = scope.getGenZir();
-    const usize_type = @enumToInt(zir.Const.usize_type);
     // TODO check for [_]T
-    const len = try expr(mod, scope, .{ .ty = usize_type }, node_datas[node].lhs);
+    const len = try expr(mod, scope, .{ .ty = .usize_type }, node_datas[node].lhs);
     const elem_type = try typeExpr(mod, scope, node_datas[node].rhs);
     const result = try gz.addBin(.array_type, len, elem_type);
 @@ -1576,10 +1563,9 @@ fn arrayTypeSentinel(mod: *Module, scope: *Scope, rl: ResultLoc, node: ast.Node.
     const node_datas = tree.nodes.items(.data);
     const extra = tree.extraData(node_datas[node].rhs, ast.Node.ArrayTypeSentinel);
     const gz = scope.getGenZir();
-    const usize_type = @enumToInt(zir.Const.usize_type);
     // TODO check for [_]T
-    const len = try expr(mod, scope, .{ .ty = usize_type }, node_datas[node].lhs);
+    const len = try expr(mod, scope, .{ .ty = .usize_type }, node_datas[node].lhs);
     const elem_type = try typeExpr(mod, scope, extra.elem_type);
     const sentinel = try expr(mod, scope, .{ .ty = elem_type }, extra.sentinel);
 @@ -1784,7 +1770,7 @@ fn finishThenElseBlock(
                     } },
                 });
             }
-            const elide_else = if (else_result != 0) wzc.refIsNoReturn(else_result) else false;
+            const elide_else = if (else_result != .none) wzc.refIsNoReturn(else_result) else false;
             if (!elide_else) {
                 _ = try else_scope.add(.{
                     .tag = .break_void_node,
 @@ -1796,7 +1782,7 @@ fn finishThenElseBlock(
             }
             assert(!strat.elide_store_to_block_ptr_instructions);
             try setCondBrPayload(condbr, cond, then_scope, else_scope);
-            return wzc.ref_start_index + main_block;
+            return zir.Inst.Ref.fromIndex(main_block, wzc.param_count);
         },
         .break_operand => {
             if (!wzc.refIsNoReturn(then_result)) {
 @@ -1808,7 +1794,7 @@ fn finishThenElseBlock(
                     } },
                 });
             }
-            if (else_result != 0) {
+            if (else_result != .none) {
                 if (!wzc.refIsNoReturn(else_result)) {
                     _ = try else_scope.add(.{
                         .tag = .@"break",
 @@ -1832,7 +1818,7 @@ fn finishThenElseBlock(
             } else {
                 try setCondBrPayload(condbr, cond, then_scope, else_scope);
             }
-            const block_ref = wzc.ref_start_index + main_block;
+            const block_ref = zir.Inst.Ref.fromIndex(main_block, wzc.param_count);
             switch (rl) {
                 .ref => return block_ref,
                 else => return rvalue(mod, parent_scope, rl, block_ref, node),
 @@ -1981,9 +1967,8 @@ fn boolBinOp(
 ) InnerError!zir.Inst.Ref {
     const gz = scope.getGenZir();
     const node_datas = gz.tree().nodes.items(.data);
-    const bool_type = @enumToInt(zir.Const.bool_type);
-    const lhs = try expr(mod, scope, .{ .ty = bool_type }, node_datas[node].lhs);
+    const lhs = try expr(mod, scope, .{ .ty = .bool_type }, node_datas[node].lhs);
     const bool_br = try gz.addBoolBr(zir_tag, lhs);
     var rhs_scope: Scope.GenZir = .{
 @@ -1992,11 +1977,11 @@ fn boolBinOp(
         .force_comptime = gz.force_comptime,
     };
     defer rhs_scope.instructions.deinit(mod.gpa);
-    const rhs = try expr(mod, &rhs_scope.base, .{ .ty = bool_type }, node_datas[node].rhs);
+    const rhs = try expr(mod, &rhs_scope.base, .{ .ty = .bool_type }, node_datas[node].rhs);
     _ = try rhs_scope.addUnNode(.break_flat, rhs, node);
     try rhs_scope.setBoolBrBody(bool_br);
-    const block_ref = gz.zir_code.ref_start_index + bool_br;
+    const block_ref = zir.Inst.Ref.fromIndex(bool_br, gz.zir_code.param_count);
     return rvalue(mod, scope, rl, block_ref, node);
 }
 @@ -2024,8 +2009,7 @@ fn ifExpr(
         } else if (if_full.payload_token) |payload_token| {
             return mod.failTok(scope, payload_token, "TODO implement if optional", .{});
         } else {
-            const bool_rl: ResultLoc = .{ .ty = @enumToInt(zir.Const.bool_type) };
+            break :c try expr(mod, &block_scope.base, .{ .ty = .bool_type }, if_full.ast.cond_expr);
-            break :c try expr(mod, &block_scope.base, bool_rl, if_full.ast.cond_expr);
         }
     };
 @@ -2073,7 +2057,7 @@ fn ifExpr(
         };
     } else .{
         .src = if_full.ast.then_expr,
-        .result = 0,
+        .result = .none,
     };
     return finishThenElseBlock(
 @@ -2185,7 +2169,7 @@ fn whileExpr(
         } else if (while_full.payload_token) |payload_token| {
             return mod.failTok(scope, payload_token, "TODO implement while optional", .{});
         } else {
-            const bool_type_rl: ResultLoc = .{ .ty = @enumToInt(zir.Const.bool_type) };
+            const bool_type_rl: ResultLoc = .{ .ty = .bool_type };
             break :c try expr(mod, &continue_scope.base, bool_type_rl, while_full.ast.cond_expr);
         }
     };
 @@ -2200,8 +2184,7 @@ fn whileExpr(
     // and there are no `continue` statements.
     // The "repeat" at the end of a loop body is implied.
     if (while_full.ast.cont_expr != 0) {
-        const void_type_rl: ResultLoc = .{ .ty = @enumToInt(zir.Const.void_type) };
+        _ = try expr(mod, &loop_scope.base, .{ .ty = .void_type }, while_full.ast.cont_expr);
-        _ = try expr(mod, &loop_scope.base, void_type_rl, while_full.ast.cont_expr);
     }
     const is_inline = while_full.inline_token != null;
     const repeat_tag: zir.Inst.Tag = if (is_inline) .repeat_inline else .repeat;
 @@ -2251,7 +2234,7 @@ fn whileExpr(
         };
     } else .{
         .src = while_full.ast.then_expr,
-        .result = 0,
+        .result = .none,
     };
     if (loop_scope.label) |some| {
 @@ -2838,7 +2821,7 @@ fn ret(mod: *Module, scope: *Scope, node: ast.Node.Index) InnerError!zir.Inst.Re
             .ty = try gz.addNode(.ret_type, node),
         };
         break :operand try expr(mod, scope, rl, operand_node);
-    } else void_inst;
+    } else .void_value;
     return gz.addUnNode(.ret_node, operand, node);
 }
 @@ -2862,8 +2845,8 @@ fn identifier(
         return mod.failNode(scope, ident, "TODO implement '_' identifier", .{});
     }
-    if (simple_types.get(ident_name)) |zir_const_tag| {
+    if (simple_types.get(ident_name)) |zir_const_ref| {
-        return rvalue(mod, scope, rl, @enumToInt(zir_const_tag), ident);
+        return rvalue(mod, scope, rl, zir_const_ref, ident);
     }
     if (ident_name.len >= 2) integer: {
 @@ -3028,9 +3011,9 @@ fn integerLiteral(
     const prefixed_bytes = tree.tokenSlice(int_token);
     const gz = scope.getGenZir();
     if (std.fmt.parseInt(u64, prefixed_bytes, 0)) |small_int| {
-        const result: zir.Inst.Index = switch (small_int) {
+        const result: zir.Inst.Ref = switch (small_int) {
-            0 => @enumToInt(zir.Const.zero),
+            0 => .zero,
-            1 => @enumToInt(zir.Const.one),
+            1 => .one,
             else => try gz.addInt(small_int),
         };
         return rvalue(mod, scope, rl, result, node);
 @@ -3078,14 +3061,11 @@ fn asmExpr(
     const node_datas = tree.nodes.items(.data);
     const gz = scope.getGenZir();
-    const str_type = @enumToInt(zir.Const.const_slice_u8_type);
+    const asm_source = try expr(mod, scope, .{ .ty = .const_slice_u8_type }, full.ast.template);
-    const str_type_rl: ResultLoc = .{ .ty = str_type };
-    const asm_source = try expr(mod, scope, str_type_rl, full.ast.template);
     if (full.outputs.len != 0) {
         return mod.failTok(scope, full.ast.asm_token, "TODO implement asm with an output", .{});
     }
-    const return_type = @enumToInt(zir.Const.void_type);
     const constraints = try arena.alloc(u32, full.inputs.len);
     const args = try arena.alloc(zir.Inst.Ref, full.inputs.len);
 @@ -3098,22 +3078,21 @@ fn asmExpr(
         try mod.parseStrLit(scope, constraint_token, string_bytes, token_bytes, 0);
         try string_bytes.append(mod.gpa, 0);
-        const usize_rl: ResultLoc = .{ .ty = @enumToInt(zir.Const.usize_type) };
+        args[i] = try expr(mod, scope, .{ .ty = .usize_type }, node_datas[input].lhs);
-        args[i] = try expr(mod, scope, usize_rl, node_datas[input].lhs);
     }
     const tag: zir.Inst.Tag = if (full.volatile_token != null) .asm_volatile else .@"asm";
     const result = try gz.addPlNode(tag, node, zir.Inst.Asm{
         .asm_source = asm_source,
-        .return_type = return_type,
+        .return_type = .void_type,
-        .output = 0,
+        .output = .none,
         .args_len = @intCast(u32, full.inputs.len),
         .clobbers_len = 0, // TODO implement asm clobbers
     });
     try gz.zir_code.extra.ensureCapacity(mod.gpa, gz.zir_code.extra.items.len +
         args.len + constraints.len);
-    gz.zir_code.extra.appendSliceAssumeCapacity(args);
+    gz.zir_code.extra.appendSliceAssumeCapacity(mem.bytesAsSlice(u32, mem.sliceAsBytes(args)));
     gz.zir_code.extra.appendSliceAssumeCapacity(constraints);
     return rvalue(mod, scope, rl, result, node);
 @@ -3185,7 +3164,7 @@ fn asRlPtr(
         const expected_len = parent_zir.items.len + as_scope.instructions.items.len - 2;
         try parent_zir.ensureCapacity(mod.gpa, expected_len);
         for (as_scope.instructions.items) |src_inst| {
-            if (wzc.ref_start_index + src_inst == as_scope.rl_ptr) continue;
+            if (zir.Inst.Ref.fromIndex(src_inst, wzc.param_count) == as_scope.rl_ptr) continue;
             if (zir_tags[src_inst] == .store_to_block_ptr) {
                 if (zir_datas[src_inst].bin.lhs == as_scope.rl_ptr) continue;
             }
 @@ -3272,11 +3251,12 @@ fn typeOf(
     }
     const arena = scope.arena();
     var items = try arena.alloc(zir.Inst.Ref, params.len);
-    for (params) |param, param_i|
+    for (params) |param, param_i| {
         items[param_i] = try expr(mod, scope, .none, param);
+    }
     const result = try gz.addPlNode(.typeof_peer, node, zir.Inst.MultiOp{ .operands_len = @intCast(u32, params.len) });
-    try gz.zir_code.extra.appendSlice(gz.zir_code.gpa, items);
+    try gz.zir_code.extra.appendSlice(gz.zir_code.gpa, mem.bytesAsSlice(u32, mem.sliceAsBytes(items)));
     return rvalue(mod, scope, rl, result, node);
 }
 @@ -3351,8 +3331,7 @@ fn builtinCall(
             return rvalue(mod, scope, rl, result, node);
         },
         .set_eval_branch_quota => {
-            const u32_rl: ResultLoc = .{ .ty = @enumToInt(zir.Const.u32_type) };
+            const quota = try expr(mod, scope, .{ .ty = .u32_type }, params[0]);
-            const quota = try expr(mod, scope, u32_rl, params[0]);
             const result = try gz.addUnNode(.set_eval_branch_quota, quota, node);
             return rvalue(mod, scope, rl, result, node);
         },
 @@ -3498,7 +3477,7 @@ fn callExpr(
     }
     const lhs = try expr(mod, scope, .none, call.ast.fn_expr);
-    const args = try mod.gpa.alloc(zir.Inst.Index, call.ast.params.len);
+    const args = try mod.gpa.alloc(zir.Inst.Ref, call.ast.params.len);
     defer mod.gpa.free(args);
     const gz = scope.getGenZir();
 @@ -3517,7 +3496,7 @@ fn callExpr(
         true => .async_kw,
         false => .auto,
     };
-    const result: zir.Inst.Index = res: {
+    const result: zir.Inst.Ref = res: {
         const tag: zir.Inst.Tag = switch (modifier) {
             .auto => switch (args.len == 0) {
                 true => break :res try gz.addUnNode(.call_none, lhs, node),
 @@ -3536,7 +3515,7 @@ fn callExpr(
     return rvalue(mod, scope, rl, result, node); // TODO function call with result location
 }
-pub const simple_types = std.ComptimeStringMap(zir.Const, .{
+pub const simple_types = std.ComptimeStringMap(zir.Inst.Ref, .{
     .{ "u8", .u8_type },
     .{ "i8", .i8_type },
     .{ "u16", .u16_type },

src/zir.zig+333-300

 @@ -48,8 +48,11 @@ pub const Code = struct {
         var i: usize = index;
         var result: T = undefined;
         inline for (fields) |field| {
-            comptime assert(field.field_type == u32);
+            @field(result, field.name) = switch (field.field_type) {
-            @field(result, field.name) = code.extra[i];
+                u32 => code.extra[i],
+                Inst.Ref => @intToEnum(Inst.Ref, code.extra[i]),
+                else => unreachable,
+            };
             i += 1;
         }
         return .{
 @@ -105,284 +108,6 @@ pub const Code = struct {
     }
 };
-/// These correspond to the first N tags of Value.
-/// A ZIR instruction refers to another one by index. However the first N indexes
-/// correspond to this enum, and the next M indexes correspond to the parameters
-/// of the current function. After that, they refer to other instructions in the
-/// instructions array for the function.
-/// When adding to this, consider adding a corresponding entry o `simple_types`
-/// in astgen.
-pub const Const = enum {
-    /// The 0 value is reserved so that ZIR instruction indexes can use it to
-    /// mean "null".
-    unused,
-    u8_type,
-    i8_type,
-    u16_type,
-    i16_type,
-    u32_type,
-    i32_type,
-    u64_type,
-    i64_type,
-    u128_type,
-    i128_type,
-    usize_type,
-    isize_type,
-    c_short_type,
-    c_ushort_type,
-    c_int_type,
-    c_uint_type,
-    c_long_type,
-    c_ulong_type,
-    c_longlong_type,
-    c_ulonglong_type,
-    c_longdouble_type,
-    f16_type,
-    f32_type,
-    f64_type,
-    f128_type,
-    c_void_type,
-    bool_type,
-    void_type,
-    type_type,
-    anyerror_type,
-    comptime_int_type,
-    comptime_float_type,
-    noreturn_type,
-    null_type,
-    undefined_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,
-    enum_literal_type,
-    /// `undefined` (untyped)
-    undef,
-    /// `0` (comptime_int)
-    zero,
-    /// `1` (comptime_int)
-    one,
-    /// `{}`
-    void_value,
-    /// `unreachable` (noreturn type)
-    unreachable_value,
-    /// `null` (untyped)
-    null_value,
-    /// `true`
-    bool_true,
-    /// `false`
-    bool_false,
-};
-pub const const_inst_list = std.enums.directEnumArray(Const, TypedValue, 0, .{
-    .unused = undefined,
-    .u8_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.u8_type),
-    },
-    .i8_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.i8_type),
-    },
-    .u16_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.u16_type),
-    },
-    .i16_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.i16_type),
-    },
-    .u32_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.u32_type),
-    },
-    .i32_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.i32_type),
-    },
-    .u64_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.u64_type),
-    },
-    .i64_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.i64_type),
-    },
-    .u128_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.u128_type),
-    },
-    .i128_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.i128_type),
-    },
-    .usize_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.usize_type),
-    },
-    .isize_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.isize_type),
-    },
-    .c_short_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.c_short_type),
-    },
-    .c_ushort_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.c_ushort_type),
-    },
-    .c_int_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.c_int_type),
-    },
-    .c_uint_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.c_uint_type),
-    },
-    .c_long_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.c_long_type),
-    },
-    .c_ulong_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.c_ulong_type),
-    },
-    .c_longlong_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.c_longlong_type),
-    },
-    .c_ulonglong_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.c_ulonglong_type),
-    },
-    .c_longdouble_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.c_longdouble_type),
-    },
-    .f16_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.f16_type),
-    },
-    .f32_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.f32_type),
-    },
-    .f64_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.f64_type),
-    },
-    .f128_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.f128_type),
-    },
-    .c_void_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.c_void_type),
-    },
-    .bool_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.bool_type),
-    },
-    .void_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.void_type),
-    },
-    .type_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.type_type),
-    },
-    .anyerror_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.anyerror_type),
-    },
-    .comptime_int_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.comptime_int_type),
-    },
-    .comptime_float_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.comptime_float_type),
-    },
-    .noreturn_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.noreturn_type),
-    },
-    .null_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.null_type),
-    },
-    .undefined_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.undefined_type),
-    },
-    .fn_noreturn_no_args_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.fn_noreturn_no_args_type),
-    },
-    .fn_void_no_args_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.fn_void_no_args_type),
-    },
-    .fn_naked_noreturn_no_args_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.fn_naked_noreturn_no_args_type),
-    },
-    .fn_ccc_void_no_args_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.fn_ccc_void_no_args_type),
-    },
-    .single_const_pointer_to_comptime_int_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.single_const_pointer_to_comptime_int_type),
-    },
-    .const_slice_u8_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.const_slice_u8_type),
-    },
-    .enum_literal_type = .{
-        .ty = Type.initTag(.type),
-        .val = Value.initTag(.enum_literal_type),
-    },
-    .undef = .{
-        .ty = Type.initTag(.@"undefined"),
-        .val = Value.initTag(.undef),
-    },
-    .zero = .{
-        .ty = Type.initTag(.comptime_int),
-        .val = Value.initTag(.zero),
-    },
-    .one = .{
-        .ty = Type.initTag(.comptime_int),
-        .val = Value.initTag(.one),
-    },
-    .void_value = .{
-        .ty = Type.initTag(.void),
-        .val = Value.initTag(.void_value),
-    },
-    .unreachable_value = .{
-        .ty = Type.initTag(.noreturn),
-        .val = Value.initTag(.unreachable_value),
-    },
-    .null_value = .{
-        .ty = Type.initTag(.@"null"),
-        .val = Value.initTag(.null_value),
-    },
-    .bool_true = .{
-        .ty = Type.initTag(.bool),
-        .val = Value.initTag(.bool_true),
-    },
-    .bool_false = .{
-        .ty = Type.initTag(.bool),
-        .val = Value.initTag(.bool_false),
-    },
-});
 /// These are untyped instructions generated from an Abstract Syntax Tree.
 /// The data here is immutable because it is possible to have multiple
 /// analyses on the same ZIR happening at the same time.
 @@ -1032,14 +757,319 @@ pub const Inst = struct {
     /// The position of a ZIR instruction within the `Code` instructions array.
     pub const Index = u32;
-    /// A reference to another ZIR instruction. If this value is below a certain
+    /// A reference to a TypedValue, parameter of the current function,
-    /// threshold, it implicitly refers to a constant-known value from the `Const` enum.
+    /// or ZIR instruction.
-    /// Below a second threshold, it implicitly refers to a parameter of the current
+    ///
-    /// function.
+    /// If the Ref has a tag in this enum, it refers to a TypedValue which may be
-    /// Finally, after subtracting that offset, it refers to another instruction in
+    /// retrieved with Ref.toTypedValue().
-    /// the instruction array.
+    ///
-    /// This logic is implemented in `Sema.resolveRef`.
+    /// If the value of a Ref does not have a tag, it referes to either a parameter
-    pub const Ref = u32;
+    /// of the current function or a ZIR instruction.
+    ///
+    /// The first values after the the last tag refer to parameters which may be
+    /// derived by subtracting typed_value_count.
+    ///
+    /// All further values refer to ZIR instructions which may be derived by
+    /// subtracting typed_value_count and the number of parameters.
+    ///
+    /// When adding a tag to this enum, consider adding a corresponding entry to
+    /// `simple_types` in astgen.
+    ///
+    /// This is packed so that it is safe to cast between `[]u32` and `[]Ref`.
+    pub const Ref = packed enum(u32) {
+        /// This Ref does not correspond to any ZIR instruction or constant
+        /// value and may instead be used as a sentinel to indicate null.
+        none,
+        u8_type,
+        i8_type,
+        u16_type,
+        i16_type,
+        u32_type,
+        i32_type,
+        u64_type,
+        i64_type,
+        usize_type,
+        isize_type,
+        c_short_type,
+        c_ushort_type,
+        c_int_type,
+        c_uint_type,
+        c_long_type,
+        c_ulong_type,
+        c_longlong_type,
+        c_ulonglong_type,
+        c_longdouble_type,
+        f16_type,
+        f32_type,
+        f64_type,
+        f128_type,
+        c_void_type,
+        bool_type,
+        void_type,
+        type_type,
+        anyerror_type,
+        comptime_int_type,
+        comptime_float_type,
+        noreturn_type,
+        null_type,
+        undefined_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,
+        enum_literal_type,
+        /// `undefined` (untyped)
+        undef,
+        /// `0` (comptime_int)
+        zero,
+        /// `1` (comptime_int)
+        one,
+        /// `{}`
+        void_value,
+        /// `unreachable` (noreturn type)
+        unreachable_value,
+        /// `null` (untyped)
+        null_value,
+        /// `true`
+        bool_true,
+        /// `false`
+        bool_false,
+        _,
+        pub const typed_value_count = @as(u32, typed_value_map.len);
+        const typed_value_map = std.enums.directEnumArray(Ref, TypedValue, 0, .{
+            .none = undefined,
+            .u8_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.u8_type),
+            },
+            .i8_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.i8_type),
+            },
+            .u16_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.u16_type),
+            },
+            .i16_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.i16_type),
+            },
+            .u32_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.u32_type),
+            },
+            .i32_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.i32_type),
+            },
+            .u64_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.u64_type),
+            },
+            .i64_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.i64_type),
+            },
+            .usize_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.usize_type),
+            },
+            .isize_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.isize_type),
+            },
+            .c_short_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.c_short_type),
+            },
+            .c_ushort_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.c_ushort_type),
+            },
+            .c_int_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.c_int_type),
+            },
+            .c_uint_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.c_uint_type),
+            },
+            .c_long_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.c_long_type),
+            },
+            .c_ulong_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.c_ulong_type),
+            },
+            .c_longlong_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.c_longlong_type),
+            },
+            .c_ulonglong_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.c_ulonglong_type),
+            },
+            .c_longdouble_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.c_longdouble_type),
+            },
+            .f16_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.f16_type),
+            },
+            .f32_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.f32_type),
+            },
+            .f64_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.f64_type),
+            },
+            .f128_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.f128_type),
+            },
+            .c_void_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.c_void_type),
+            },
+            .bool_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.bool_type),
+            },
+            .void_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.void_type),
+            },
+            .type_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.type_type),
+            },
+            .anyerror_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.anyerror_type),
+            },
+            .comptime_int_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.comptime_int_type),
+            },
+            .comptime_float_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.comptime_float_type),
+            },
+            .noreturn_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.noreturn_type),
+            },
+            .null_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.null_type),
+            },
+            .undefined_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.undefined_type),
+            },
+            .fn_noreturn_no_args_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.fn_noreturn_no_args_type),
+            },
+            .fn_void_no_args_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.fn_void_no_args_type),
+            },
+            .fn_naked_noreturn_no_args_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.fn_naked_noreturn_no_args_type),
+            },
+            .fn_ccc_void_no_args_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.fn_ccc_void_no_args_type),
+            },
+            .single_const_pointer_to_comptime_int_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.single_const_pointer_to_comptime_int_type),
+            },
+            .const_slice_u8_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.const_slice_u8_type),
+            },
+            .enum_literal_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.enum_literal_type),
+            },
+            .undef = .{
+                .ty = Type.initTag(.@"undefined"),
+                .val = Value.initTag(.undef),
+            },
+            .zero = .{
+                .ty = Type.initTag(.comptime_int),
+                .val = Value.initTag(.zero),
+            },
+            .one = .{
+                .ty = Type.initTag(.comptime_int),
+                .val = Value.initTag(.one),
+            },
+            .void_value = .{
+                .ty = Type.initTag(.void),
+                .val = Value.initTag(.void_value),
+            },
+            .unreachable_value = .{
+                .ty = Type.initTag(.noreturn),
+                .val = Value.initTag(.unreachable_value),
+            },
+            .null_value = .{
+                .ty = Type.initTag(.@"null"),
+                .val = Value.initTag(.null_value),
+            },
+            .bool_true = .{
+                .ty = Type.initTag(.bool),
+                .val = Value.initTag(.bool_true),
+            },
+            .bool_false = .{
+                .ty = Type.initTag(.bool),
+                .val = Value.initTag(.bool_false),
+            },
+        });
+        pub fn fromParam(param: u32) Ref {
+            return @intToEnum(Ref, typed_value_count + param);
+        }
+        pub fn fromIndex(index: Index, param_count: u32) Ref {
+            return @intToEnum(Ref, typed_value_count + param_count + index);
+        }
+        pub fn toTypedValue(ref: Ref) ?TypedValue {
+            assert(ref != .none);
+            if (@enumToInt(ref) >= typed_value_count) return null;
+            return typed_value_map[@enumToInt(ref)];
+        }
+        pub fn toParam(ref: Ref, param_count: u32) ?u32 {
+            assert(ref != .none);
+            if (@enumToInt(ref) < typed_value_count or
+                @enumToInt(ref) >= typed_value_count + param_count)
+            {
+                return null;
+            }
+            return @enumToInt(ref) - typed_value_count;
+        }
+        pub fn toIndex(ref: Ref, param_count: u32) ?Index {
+            assert(ref != .none);
+            if (@enumToInt(ref) < typed_value_count + param_count) return null;
+            return @enumToInt(ref) - typed_value_count - param_count;
+        }
+    };
     /// All instructions have an 8-byte payload, which is contained within
     /// this union. `Tag` determines which union field is active, as well as
 @@ -1642,7 +1672,9 @@ const Writer = struct {
     fn writePlNodeCall(self: *Writer, stream: anytype, inst: Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[inst].pl_node;
         const extra = self.code.extraData(Inst.Call, inst_data.payload_index);
-        const args = self.code.extra[extra.end..][0..extra.data.args_len];
+        const raw_args = self.code.extra[extra.end..][0..extra.data.args_len];
+        const args = mem.bytesAsSlice(Inst.Ref, mem.sliceAsBytes(raw_args));
         try self.writeInstRef(stream, extra.data.callee);
         try stream.writeAll(", [");
         for (args) |arg, i| {
 @@ -1735,9 +1767,9 @@ const Writer = struct {
     ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
         const inst_data = self.code.instructions.items(.data)[inst].fn_type;
         const extra = self.code.extraData(Inst.FnType, inst_data.payload_index);
-        const param_types = self.code.extra[extra.end..][0..extra.data.param_types_len];
+        const raw_param_types = self.code.extra[extra.end..][0..extra.data.param_types_len];
-        const cc: Inst.Ref = 0;
+        const param_types = mem.bytesAsSlice(Inst.Ref, mem.sliceAsBytes(raw_param_types));
-        return self.writeFnTypeCommon(stream, param_types, inst_data.return_type, var_args, cc);
+        return self.writeFnTypeCommon(stream, param_types, inst_data.return_type, var_args, .none);
     }
     fn writeBoolBr(self: *Writer, stream: anytype, inst: Inst.Index) !void {
 @@ -1761,7 +1793,8 @@ const Writer = struct {
     ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
         const inst_data = self.code.instructions.items(.data)[inst].fn_type;
         const extra = self.code.extraData(Inst.FnTypeCc, inst_data.payload_index);
-        const param_types = self.code.extra[extra.end..][0..extra.data.param_types_len];
+        const raw_param_types = self.code.extra[extra.end..][0..extra.data.param_types_len];
+        const param_types = mem.bytesAsSlice(Inst.Ref, mem.sliceAsBytes(raw_param_types));
         const cc = extra.data.cc;
         return self.writeFnTypeCommon(stream, param_types, inst_data.return_type, var_args, cc);
     }
 @@ -1828,13 +1861,13 @@ const Writer = struct {
         try stream.print("\"{}\")", .{std.zig.fmtEscapes(str)});
     }
-    fn writeInstRef(self: *Writer, stream: anytype, inst: Inst.Ref) !void {
+    fn writeInstRef(self: *Writer, stream: anytype, ref: Inst.Ref) !void {
-        var i: usize = inst;
+        var i: usize = @enumToInt(ref);
-        if (i < const_inst_list.len) {
+        if (i < Inst.Ref.typed_value_count) {
-            return stream.print("@{d}", .{i});
+            return stream.print("@{}", .{ref});
         }
-        i -= const_inst_list.len;
+        i -= Inst.Ref.typed_value_count;
         if (i < self.param_count) {
             return stream.print("${d}", .{i});
 @@ -1852,9 +1885,9 @@ const Writer = struct {
         self: *Writer,
         stream: anytype,
         prefix: []const u8,
-        inst: Inst.Index,
+        inst: Inst.Ref,
     ) !void {
-        if (inst == 0) return;
+        if (inst == .none) return;
         try stream.writeAll(prefix);
         try self.writeInstRef(stream, inst);
     }