Commit b7452fe35f514d4c04aae4582bc8071bc9e70f1b | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-01-20 20:37:44-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-01-31 21:09:22-07:00
log	b7452fe35f514d4c04aae4582bc8071bc9e70f1b
tree	b125fa735b9d2f9ea3791687f8ef22d75aca590a
parent	fdc875ed0080cd2542a854a8cd6c627b25e9b7a4

stage2: rework astgen result locations

Motivating test case:

```zig
export fn _start() noreturn {
    var x: u64 = 1;
    var y: u32 = 2;
    var thing: u32 = 1;
    const result = if (thing == 1) x else y;
    exit();
}
```

The main idea here is for astgen to output ideal ZIR depending on
whether or not the sub-expressions of a block consume the result
location. Here, neither `x` nor `y` consume the result location of the
conditional expression block, and so the ZIR should communicate the
result of the condbr using break instructions, not with the result
location pointer.

With this commit, this is accomplished:

```
  %22 = alloc_inferred()
  %23 = block({
    %24 = const(TypedValue{ .ty = type, .val = bool})
    %25 = deref(%18)
    %26 = const(TypedValue{ .ty = comptime_int, .val = 1})
    %27 = cmp_eq(%25, %26)
    %28 = as(%24, %27)
    %29 = condbr(%28, {
      %30 = deref(%4)
      < there is no longer a store instruction here >
      %31 = break("label_23", %30)
    }, {
      %32 = deref(%11)
      < there is no longer a store instruction here >
      %33 = break("label_23", %32)
    })
  })
  %34 = store_to_inferred_ptr(%22, %23) <-- the store is only here
  %35 = resolve_inferred_alloc(%22)
```

However if the result location gets consumed, the break instructions
change to break_void, and the result value is communicated only by the
stores, not by the break instructions.

Implementation:

 * The GenZIR scope that conditional branches uses now has an optional
   result location pointer field and a count of how many times the
   result location ended up being an rvalue (not consumed).
 * When rvalue() is called on a result location for a block, it
   increments this counter. After generating the branches of a block,
   astgen for the conditional branch checks this count and if it is 2
   then the store_to_block_ptr instructions are elided and it calls
   rvalue() using the block result (which will account for peer type
   resolution on the break operands).

astgen has many functions disabled until they can be reworked with these
new semantics. That will be done before merging the branch.

There are some new rules for astgen to follow regarding result locations
and what you are allowed/required to do depending on which one is passed
to expr(). See the updated doc comments of ResultLoc for details.

I also changed naming conventions of stuff in this commit, sorry about
that.

6 files changed, 649 insertions(+), 529 deletions(-)

src/Module.zig+8-1

 @@ -697,6 +697,13 @@ pub const Scope = struct {
         continue_block: ?*zir.Inst.Block = null,
         /// only valid if label != null or (continue_block and break_block) != null
         break_result_loc: astgen.ResultLoc = undefined,
+        /// When a block has a pointer result location, here it is.
+        rl_ptr: ?*zir.Inst = null,
+        /// Keeps track of how many branches of a block did not actually
+        /// consume the result location. astgen uses this to figure out
+        /// whether to rely on break instructions or writing to the result
+        /// pointer for the result instruction.
+        rvalue_rl_count: usize = 0,
         pub const Label = struct {
             token: ast.TokenIndex,
 @@ -1171,7 +1178,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                     !gen_scope.instructions.items[gen_scope.instructions.items.len - 1].tag.isNoReturn())
                 {
                     const src = tree.token_locs[body_block.rbrace].start;
-                    _ = try astgen.addZIRNoOp(self, &gen_scope.base, src, .returnvoid);
+                    _ = try astgen.addZIRNoOp(self, &gen_scope.base, src, .return_void);
                 }
                 if (std.builtin.mode == .Debug and self.comp.verbose_ir) {

src/astgen.zig+259-143

...	@@ -14,25 +14,30 @@ const InnerError = Module.InnerError;	...	@@ -14,25 +14,30 @@ const InnerError = Module.InnerError;
14		14
15	pub const ResultLoc = union(enum) {	15	pub const ResultLoc = union(enum) {
16	/// The expression is the right-hand side of assignment to `_`. Only the side-effects of the	16	/// The expression is the right-hand side of assignment to `_`. Only the side-effects of the
17	/// expression should be generated.	17	/// expression should be generated. The result instruction from the expression must
		18	/// be ignored.
18	discard,	19	discard,
19	/// The expression has an inferred type, and it will be evaluated as an rvalue.	20	/// The expression has an inferred type, and it will be evaluated as an rvalue.
20	none,	21	none,
21	/// The expression must generate a pointer rather than a value. For example, the left hand side	22	/// The expression must generate a pointer rather than a value. For example, the left hand side
22	/// of an assignment uses this kind of result location.	23	/// of an assignment uses this kind of result location.
23	ref,	24	ref,
24	/// The expression will be type coerced into this type, but it will be evaluated as an rvalue.	25	/// The expression will be coerced into this type, but it will be evaluated as an rvalue.
25	ty: *zir.Inst,	26	ty: *zir.Inst,
26	/// The expression must store its result into this typed pointer.	27	/// The expression must store its result into this typed pointer. The result instruction
		28	/// from the expression must be ignored.
27	ptr: *zir.Inst,	29	ptr: *zir.Inst,
28	/// The expression must store its result into this allocation, which has an inferred type.	30	/// The expression must store its result into this allocation, which has an inferred type.
		31	/// The result instruction from the expression must be ignored.
29	inferred_ptr: *zir.Inst.Tag.alloc_inferred.Type(),	32	inferred_ptr: *zir.Inst.Tag.alloc_inferred.Type(),
30	/// The expression must store its result into this pointer, which is a typed pointer that	33	/// The expression must store its result into this pointer, which is a typed pointer that
31	/// has been bitcasted to whatever the expression's type is.	34	/// has been bitcasted to whatever the expression's type is.
		35	/// The result instruction from the expression must be ignored.
32	bitcasted_ptr: *zir.Inst.UnOp,	36	bitcasted_ptr: *zir.Inst.UnOp,
33	/// There is a pointer for the expression to store its result into, however, its type	37	/// There is a pointer for the expression to store its result into, however, its type
34	/// is inferred based on peer type resolution for a `zir.Inst.Block`.	38	/// is inferred based on peer type resolution for a `zir.Inst.Block`.
35	block_ptr: *zir.Inst.Block,	39	/// The result instruction from the expression must be ignored.
		40	block_ptr: *Module.Scope.GenZIR,
36	};	41	};
37		42
38	pub fn typeExpr(mod: Module, scope: Scope, type_node: ast.Node) InnerError!zir.Inst {	43	pub fn typeExpr(mod: Module, scope: Scope, type_node: ast.Node) InnerError!zir.Inst {
...	@@ -179,6 +184,9 @@ fn lvalExpr(mod: Module, scope: Scope, node: ast.Node) InnerError!zir.Inst {	...	@@ -179,6 +184,9 @@ fn lvalExpr(mod: Module, scope: Scope, node: ast.Node) InnerError!zir.Inst {
179	}	184	}
180		185
181	/// Turn Zig AST into untyped ZIR istructions.	186	/// Turn Zig AST into untyped ZIR istructions.
		187	/// When `rl` is discard, ptr, inferred_ptr, bitcasted_ptr, or inferred_ptr, the
		188	/// result instruction can be used to inspect whether it is isNoReturn() but that is it,
		189	/// it must otherwise not be used.
182	pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: ast.Node) InnerError!zir.Inst {	190	pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: ast.Node) InnerError!zir.Inst {
183	switch (node.tag) {	191	switch (node.tag) {
184	.Root => unreachable, // Top-level declaration.	192	.Root => unreachable, // Top-level declaration.
...	@@ -197,20 +205,20 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr	...	@@ -197,20 +205,20 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr
197	.FieldInitializer => unreachable, // Handled explicitly.	205	.FieldInitializer => unreachable, // Handled explicitly.
198	.ContainerField => unreachable, // Handled explicitly.	206	.ContainerField => unreachable, // Handled explicitly.
199		207
200	.Assign => return rlWrapVoid(mod, scope, rl, node, try assign(mod, scope, node.castTag(.Assign).?)),	208	.Assign => return rvalueVoid(mod, scope, rl, node, try assign(mod, scope, node.castTag(.Assign).?)),
201	.AssignBitAnd => return rlWrapVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignBitAnd).?, .bitand)),	209	.AssignBitAnd => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignBitAnd).?, .bit_and)),
202	.AssignBitOr => return rlWrapVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignBitOr).?, .bitor)),	210	.AssignBitOr => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignBitOr).?, .bit_or)),
203	.AssignBitShiftLeft => return rlWrapVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignBitShiftLeft).?, .shl)),	211	.AssignBitShiftLeft => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignBitShiftLeft).?, .shl)),
204	.AssignBitShiftRight => return rlWrapVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignBitShiftRight).?, .shr)),	212	.AssignBitShiftRight => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignBitShiftRight).?, .shr)),
205	.AssignBitXor => return rlWrapVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignBitXor).?, .xor)),	213	.AssignBitXor => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignBitXor).?, .xor)),
206	.AssignDiv => return rlWrapVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignDiv).?, .div)),	214	.AssignDiv => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignDiv).?, .div)),
207	.AssignSub => return rlWrapVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignSub).?, .sub)),	215	.AssignSub => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignSub).?, .sub)),
208	.AssignSubWrap => return rlWrapVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignSubWrap).?, .subwrap)),	216	.AssignSubWrap => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignSubWrap).?, .subwrap)),
209	.AssignMod => return rlWrapVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignMod).?, .mod_rem)),	217	.AssignMod => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignMod).?, .mod_rem)),
210	.AssignAdd => return rlWrapVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignAdd).?, .add)),	218	.AssignAdd => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignAdd).?, .add)),
211	.AssignAddWrap => return rlWrapVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignAddWrap).?, .addwrap)),	219	.AssignAddWrap => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignAddWrap).?, .addwrap)),
212	.AssignMul => return rlWrapVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignMul).?, .mul)),	220	.AssignMul => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignMul).?, .mul)),
213	.AssignMulWrap => return rlWrapVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignMulWrap).?, .mulwrap)),	221	.AssignMulWrap => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignMulWrap).?, .mulwrap)),
214		222
215	.Add => return simpleBinOp(mod, scope, rl, node.castTag(.Add).?, .add),	223	.Add => return simpleBinOp(mod, scope, rl, node.castTag(.Add).?, .add),
216	.AddWrap => return simpleBinOp(mod, scope, rl, node.castTag(.AddWrap).?, .addwrap),	224	.AddWrap => return simpleBinOp(mod, scope, rl, node.castTag(.AddWrap).?, .addwrap),
...	@@ -220,8 +228,8 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr	...	@@ -220,8 +228,8 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr
220	.MulWrap => return simpleBinOp(mod, scope, rl, node.castTag(.MulWrap).?, .mulwrap),	228	.MulWrap => return simpleBinOp(mod, scope, rl, node.castTag(.MulWrap).?, .mulwrap),
221	.Div => return simpleBinOp(mod, scope, rl, node.castTag(.Div).?, .div),	229	.Div => return simpleBinOp(mod, scope, rl, node.castTag(.Div).?, .div),
222	.Mod => return simpleBinOp(mod, scope, rl, node.castTag(.Mod).?, .mod_rem),	230	.Mod => return simpleBinOp(mod, scope, rl, node.castTag(.Mod).?, .mod_rem),
223	.BitAnd => return simpleBinOp(mod, scope, rl, node.castTag(.BitAnd).?, .bitand),	231	.BitAnd => return simpleBinOp(mod, scope, rl, node.castTag(.BitAnd).?, .bit_and),
224	.BitOr => return simpleBinOp(mod, scope, rl, node.castTag(.BitOr).?, .bitor),	232	.BitOr => return simpleBinOp(mod, scope, rl, node.castTag(.BitOr).?, .bit_or),
225	.BitShiftLeft => return simpleBinOp(mod, scope, rl, node.castTag(.BitShiftLeft).?, .shl),	233	.BitShiftLeft => return simpleBinOp(mod, scope, rl, node.castTag(.BitShiftLeft).?, .shl),
226	.BitShiftRight => return simpleBinOp(mod, scope, rl, node.castTag(.BitShiftRight).?, .shr),	234	.BitShiftRight => return simpleBinOp(mod, scope, rl, node.castTag(.BitShiftRight).?, .shr),
227	.BitXor => return simpleBinOp(mod, scope, rl, node.castTag(.BitXor).?, .xor),	235	.BitXor => return simpleBinOp(mod, scope, rl, node.castTag(.BitXor).?, .xor),
...	@@ -239,15 +247,15 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr	...	@@ -239,15 +247,15 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr
239	.BoolAnd => return boolBinOp(mod, scope, rl, node.castTag(.BoolAnd).?),	247	.BoolAnd => return boolBinOp(mod, scope, rl, node.castTag(.BoolAnd).?),
240	.BoolOr => return boolBinOp(mod, scope, rl, node.castTag(.BoolOr).?),	248	.BoolOr => return boolBinOp(mod, scope, rl, node.castTag(.BoolOr).?),
241		249
242	.BoolNot => return rlWrap(mod, scope, rl, try boolNot(mod, scope, node.castTag(.BoolNot).?)),	250	.BoolNot => return rvalue(mod, scope, rl, try boolNot(mod, scope, node.castTag(.BoolNot).?)),
243	.BitNot => return rlWrap(mod, scope, rl, try bitNot(mod, scope, node.castTag(.BitNot).?)),	251	.BitNot => return rvalue(mod, scope, rl, try bitNot(mod, scope, node.castTag(.BitNot).?)),
244	.Negation => return rlWrap(mod, scope, rl, try negation(mod, scope, node.castTag(.Negation).?, .sub)),	252	.Negation => return rvalue(mod, scope, rl, try negation(mod, scope, node.castTag(.Negation).?, .sub)),
245	.NegationWrap => return rlWrap(mod, scope, rl, try negation(mod, scope, node.castTag(.NegationWrap).?, .subwrap)),	253	.NegationWrap => return rvalue(mod, scope, rl, try negation(mod, scope, node.castTag(.NegationWrap).?, .subwrap)),
246		254
247	.Identifier => return try identifier(mod, scope, rl, node.castTag(.Identifier).?),	255	.Identifier => return try identifier(mod, scope, rl, node.castTag(.Identifier).?),
248	.Asm => return rlWrap(mod, scope, rl, try assembly(mod, scope, node.castTag(.Asm).?)),	256	.Asm => return rvalue(mod, scope, rl, try assembly(mod, scope, node.castTag(.Asm).?)),
249	.StringLiteral => return rlWrap(mod, scope, rl, try stringLiteral(mod, scope, node.castTag(.StringLiteral).?)),	257	.StringLiteral => return rvalue(mod, scope, rl, try stringLiteral(mod, scope, node.castTag(.StringLiteral).?)),
250	.IntegerLiteral => return rlWrap(mod, scope, rl, try integerLiteral(mod, scope, node.castTag(.IntegerLiteral).?)),	258	.IntegerLiteral => return rvalue(mod, scope, rl, try integerLiteral(mod, scope, node.castTag(.IntegerLiteral).?)),
251	.BuiltinCall => return builtinCall(mod, scope, rl, node.castTag(.BuiltinCall).?),	259	.BuiltinCall => return builtinCall(mod, scope, rl, node.castTag(.BuiltinCall).?),
252	.Call => return callExpr(mod, scope, rl, node.castTag(.Call).?),	260	.Call => return callExpr(mod, scope, rl, node.castTag(.Call).?),
253	.Unreachable => return unreach(mod, scope, node.castTag(.Unreachable).?),	261	.Unreachable => return unreach(mod, scope, node.castTag(.Unreachable).?),
...	@@ -255,34 +263,34 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr	...	@@ -255,34 +263,34 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr
255	.If => return ifExpr(mod, scope, rl, node.castTag(.If).?),	263	.If => return ifExpr(mod, scope, rl, node.castTag(.If).?),
256	.While => return whileExpr(mod, scope, rl, node.castTag(.While).?),	264	.While => return whileExpr(mod, scope, rl, node.castTag(.While).?),
257	.Period => return field(mod, scope, rl, node.castTag(.Period).?),	265	.Period => return field(mod, scope, rl, node.castTag(.Period).?),
258	.Deref => return rlWrap(mod, scope, rl, try deref(mod, scope, node.castTag(.Deref).?)),	266	.Deref => return rvalue(mod, scope, rl, try deref(mod, scope, node.castTag(.Deref).?)),
259	.AddressOf => return rlWrap(mod, scope, rl, try addressOf(mod, scope, node.castTag(.AddressOf).?)),	267	.AddressOf => return rvalue(mod, scope, rl, try addressOf(mod, scope, node.castTag(.AddressOf).?)),
260	.FloatLiteral => return rlWrap(mod, scope, rl, try floatLiteral(mod, scope, node.castTag(.FloatLiteral).?)),	268	.FloatLiteral => return rvalue(mod, scope, rl, try floatLiteral(mod, scope, node.castTag(.FloatLiteral).?)),
261	.UndefinedLiteral => return rlWrap(mod, scope, rl, try undefLiteral(mod, scope, node.castTag(.UndefinedLiteral).?)),	269	.UndefinedLiteral => return rvalue(mod, scope, rl, try undefLiteral(mod, scope, node.castTag(.UndefinedLiteral).?)),
262	.BoolLiteral => return rlWrap(mod, scope, rl, try boolLiteral(mod, scope, node.castTag(.BoolLiteral).?)),	270	.BoolLiteral => return rvalue(mod, scope, rl, try boolLiteral(mod, scope, node.castTag(.BoolLiteral).?)),
263	.NullLiteral => return rlWrap(mod, scope, rl, try nullLiteral(mod, scope, node.castTag(.NullLiteral).?)),	271	.NullLiteral => return rvalue(mod, scope, rl, try nullLiteral(mod, scope, node.castTag(.NullLiteral).?)),
264	.OptionalType => return rlWrap(mod, scope, rl, try optionalType(mod, scope, node.castTag(.OptionalType).?)),	272	.OptionalType => return rvalue(mod, scope, rl, try optionalType(mod, scope, node.castTag(.OptionalType).?)),
265	.UnwrapOptional => return unwrapOptional(mod, scope, rl, node.castTag(.UnwrapOptional).?),	273	.UnwrapOptional => return unwrapOptional(mod, scope, rl, node.castTag(.UnwrapOptional).?),
266	.Block => return rlWrapVoid(mod, scope, rl, node, try blockExpr(mod, scope, node.castTag(.Block).?)),	274	.Block => return rvalueVoid(mod, scope, rl, node, try blockExpr(mod, scope, node.castTag(.Block).?)),
267	.LabeledBlock => return labeledBlockExpr(mod, scope, rl, node.castTag(.LabeledBlock).?, .block),	275	.LabeledBlock => return labeledBlockExpr(mod, scope, rl, node.castTag(.LabeledBlock).?, .block),
268	.Break => return rlWrap(mod, scope, rl, try breakExpr(mod, scope, node.castTag(.Break).?)),	276	.Break => return rvalue(mod, scope, rl, try breakExpr(mod, scope, node.castTag(.Break).?)),
269	.Continue => return rlWrap(mod, scope, rl, try continueExpr(mod, scope, node.castTag(.Continue).?)),	277	.Continue => return rvalue(mod, scope, rl, try continueExpr(mod, scope, node.castTag(.Continue).?)),
270	.PtrType => return rlWrap(mod, scope, rl, try ptrType(mod, scope, node.castTag(.PtrType).?)),	278	.PtrType => return rvalue(mod, scope, rl, try ptrType(mod, scope, node.castTag(.PtrType).?)),
271	.GroupedExpression => return expr(mod, scope, rl, node.castTag(.GroupedExpression).?.expr),	279	.GroupedExpression => return expr(mod, scope, rl, node.castTag(.GroupedExpression).?.expr),
272	.ArrayType => return rlWrap(mod, scope, rl, try arrayType(mod, scope, node.castTag(.ArrayType).?)),	280	.ArrayType => return rvalue(mod, scope, rl, try arrayType(mod, scope, node.castTag(.ArrayType).?)),
273	.ArrayTypeSentinel => return rlWrap(mod, scope, rl, try arrayTypeSentinel(mod, scope, node.castTag(.ArrayTypeSentinel).?)),	281	.ArrayTypeSentinel => return rvalue(mod, scope, rl, try arrayTypeSentinel(mod, scope, node.castTag(.ArrayTypeSentinel).?)),
274	.EnumLiteral => return rlWrap(mod, scope, rl, try enumLiteral(mod, scope, node.castTag(.EnumLiteral).?)),	282	.EnumLiteral => return rvalue(mod, scope, rl, try enumLiteral(mod, scope, node.castTag(.EnumLiteral).?)),
275	.MultilineStringLiteral => return rlWrap(mod, scope, rl, try multilineStrLiteral(mod, scope, node.castTag(.MultilineStringLiteral).?)),	283	.MultilineStringLiteral => return rvalue(mod, scope, rl, try multilineStrLiteral(mod, scope, node.castTag(.MultilineStringLiteral).?)),
276	.CharLiteral => return rlWrap(mod, scope, rl, try charLiteral(mod, scope, node.castTag(.CharLiteral).?)),	284	.CharLiteral => return rvalue(mod, scope, rl, try charLiteral(mod, scope, node.castTag(.CharLiteral).?)),
277	.SliceType => return rlWrap(mod, scope, rl, try sliceType(mod, scope, node.castTag(.SliceType).?)),	285	.SliceType => return rvalue(mod, scope, rl, try sliceType(mod, scope, node.castTag(.SliceType).?)),
278	.ErrorUnion => return rlWrap(mod, scope, rl, try typeInixOp(mod, scope, node.castTag(.ErrorUnion).?, .error_union_type)),	286	.ErrorUnion => return rvalue(mod, scope, rl, try typeInixOp(mod, scope, node.castTag(.ErrorUnion).?, .error_union_type)),
279	.MergeErrorSets => return rlWrap(mod, scope, rl, try typeInixOp(mod, scope, node.castTag(.MergeErrorSets).?, .merge_error_sets)),	287	.MergeErrorSets => return rvalue(mod, scope, rl, try typeInixOp(mod, scope, node.castTag(.MergeErrorSets).?, .merge_error_sets)),
280	.AnyFrameType => return rlWrap(mod, scope, rl, try anyFrameType(mod, scope, node.castTag(.AnyFrameType).?)),	288	.AnyFrameType => return rvalue(mod, scope, rl, try anyFrameType(mod, scope, node.castTag(.AnyFrameType).?)),
281	.ErrorSetDecl => return rlWrap(mod, scope, rl, try errorSetDecl(mod, scope, node.castTag(.ErrorSetDecl).?)),	289	.ErrorSetDecl => return rvalue(mod, scope, rl, try errorSetDecl(mod, scope, node.castTag(.ErrorSetDecl).?)),
282	.ErrorType => return rlWrap(mod, scope, rl, try errorType(mod, scope, node.castTag(.ErrorType).?)),	290	.ErrorType => return rvalue(mod, scope, rl, try errorType(mod, scope, node.castTag(.ErrorType).?)),
283	.For => return forExpr(mod, scope, rl, node.castTag(.For).?),	291	.For => return forExpr(mod, scope, rl, node.castTag(.For).?),
284	.ArrayAccess => return arrayAccess(mod, scope, rl, node.castTag(.ArrayAccess).?),	292	.ArrayAccess => return arrayAccess(mod, scope, rl, node.castTag(.ArrayAccess).?),
285	.Slice => return rlWrap(mod, scope, rl, try sliceExpr(mod, scope, node.castTag(.Slice).?)),	293	.Slice => return rvalue(mod, scope, rl, try sliceExpr(mod, scope, node.castTag(.Slice).?)),
286	.Catch => return catchExpr(mod, scope, rl, node.castTag(.Catch).?),	294	.Catch => return catchExpr(mod, scope, rl, node.castTag(.Catch).?),
287	.Comptime => return comptimeKeyword(mod, scope, rl, node.castTag(.Comptime).?),	295	.Comptime => return comptimeKeyword(mod, scope, rl, node.castTag(.Comptime).?),
288	.OrElse => return orelseExpr(mod, scope, rl, node.castTag(.OrElse).?),	296	.OrElse => return orelseExpr(mod, scope, rl, node.castTag(.OrElse).?),
...	@@ -341,6 +349,9 @@ pub fn comptimeExpr(mod: Module, parent_scope: Scope, rl: ResultLoc, node: *as	...	@@ -341,6 +349,9 @@ pub fn comptimeExpr(mod: Module, parent_scope: Scope, rl: ResultLoc, node: *as
341	}	349	}
342		350
343	fn breakExpr(mod: Module, parent_scope: Scope, node: ast.Node.ControlFlowExpression) InnerError!zir.Inst {	351	fn breakExpr(mod: Module, parent_scope: Scope, node: ast.Node.ControlFlowExpression) InnerError!zir.Inst {
		352	if (true) {
		353	@panic("TODO reimplement this");
		354	}
344	const tree = parent_scope.tree();	355	const tree = parent_scope.tree();
345	const src = tree.token_locs[node.ltoken].start;	356	const src = tree.token_locs[node.ltoken].start;
346		357
...	@@ -563,8 +574,8 @@ fn blockExprStmts(mod: Module, parent_scope: Scope, node: *ast.Node, statement	...	@@ -563,8 +574,8 @@ fn blockExprStmts(mod: Module, parent_scope: Scope, node: *ast.Node, statement
563	scope = try varDecl(mod, scope, var_decl_node, &block_arena.allocator);	574	scope = try varDecl(mod, scope, var_decl_node, &block_arena.allocator);
564	},	575	},
565	.Assign => try assign(mod, scope, statement.castTag(.Assign).?),	576	.Assign => try assign(mod, scope, statement.castTag(.Assign).?),
566	.AssignBitAnd => try assignOp(mod, scope, statement.castTag(.AssignBitAnd).?, .bitand),	577	.AssignBitAnd => try assignOp(mod, scope, statement.castTag(.AssignBitAnd).?, .bit_and),
567	.AssignBitOr => try assignOp(mod, scope, statement.castTag(.AssignBitOr).?, .bitor),	578	.AssignBitOr => try assignOp(mod, scope, statement.castTag(.AssignBitOr).?, .bit_or),
568	.AssignBitShiftLeft => try assignOp(mod, scope, statement.castTag(.AssignBitShiftLeft).?, .shl),	579	.AssignBitShiftLeft => try assignOp(mod, scope, statement.castTag(.AssignBitShiftLeft).?, .shl),
569	.AssignBitShiftRight => try assignOp(mod, scope, statement.castTag(.AssignBitShiftRight).?, .shr),	580	.AssignBitShiftRight => try assignOp(mod, scope, statement.castTag(.AssignBitShiftRight).?, .shr),
570	.AssignBitXor => try assignOp(mod, scope, statement.castTag(.AssignBitXor).?, .xor),	581	.AssignBitXor => try assignOp(mod, scope, statement.castTag(.AssignBitXor).?, .xor),
...	@@ -644,6 +655,7 @@ fn varDecl(	...	@@ -644,6 +655,7 @@ fn varDecl(
644		655
645	// Namespace vars shadowing detection	656	// Namespace vars shadowing detection
646	if (mod.lookupDeclName(scope, ident_name)) \|_\| {	657	if (mod.lookupDeclName(scope, ident_name)) \|_\| {
		658	// TODO add note for other definition
647	return mod.fail(scope, name_src, "redefinition of '{s}'", .{ident_name});	659	return mod.fail(scope, name_src, "redefinition of '{s}'", .{ident_name});
648	}	660	}
649	const init_node = node.getInitNode() orelse	661	const init_node = node.getInitNode() orelse
...	@@ -751,14 +763,14 @@ fn boolNot(mod: Module, scope: Scope, node: *ast.Node.SimplePrefixOp) InnerErr	...	@@ -751,14 +763,14 @@ fn boolNot(mod: Module, scope: Scope, node: *ast.Node.SimplePrefixOp) InnerErr
751	.val = Value.initTag(.bool_type),	763	.val = Value.initTag(.bool_type),
752	});	764	});
753	const operand = try expr(mod, scope, .{ .ty = bool_type }, node.rhs);	765	const operand = try expr(mod, scope, .{ .ty = bool_type }, node.rhs);
754	return addZIRUnOp(mod, scope, src, .boolnot, operand);	766	return addZIRUnOp(mod, scope, src, .bool_not, operand);
755	}	767	}
756		768
757	fn bitNot(mod: Module, scope: Scope, node: ast.Node.SimplePrefixOp) InnerError!zir.Inst {	769	fn bitNot(mod: Module, scope: Scope, node: ast.Node.SimplePrefixOp) InnerError!zir.Inst {
758	const tree = scope.tree();	770	const tree = scope.tree();
759	const src = tree.token_locs[node.op_token].start;	771	const src = tree.token_locs[node.op_token].start;
760	const operand = try expr(mod, scope, .none, node.rhs);	772	const operand = try expr(mod, scope, .none, node.rhs);
761	return addZIRUnOp(mod, scope, src, .bitnot, operand);	773	return addZIRUnOp(mod, scope, src, .bit_not, operand);
762	}	774	}
763		775
764	fn negation(mod: Module, scope: Scope, node: ast.Node.SimplePrefixOp, op_inst_tag: zir.Inst.Tag) InnerError!zir.Inst {	776	fn negation(mod: Module, scope: Scope, node: ast.Node.SimplePrefixOp, op_inst_tag: zir.Inst.Tag) InnerError!zir.Inst {
...	@@ -1101,7 +1113,7 @@ fn containerDecl(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Con	...	@@ -1101,7 +1113,7 @@ fn containerDecl(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Con
1101	if (rl == .ref) {	1113	if (rl == .ref) {
1102	return addZIRInst(mod, scope, src, zir.Inst.DeclRef, .{ .decl = decl }, .{});	1114	return addZIRInst(mod, scope, src, zir.Inst.DeclRef, .{ .decl = decl }, .{});
1103	} else {	1115	} else {
1104	return rlWrap(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.DeclVal, .{	1116	return rvalue(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.DeclVal, .{
1105	.decl = decl,	1117	.decl = decl,
1106	}, .{}));	1118	}, .{}));
1107	}	1119	}
...	@@ -1200,6 +1212,9 @@ fn orelseCatchExpr(	...	@@ -1200,6 +1212,9 @@ fn orelseCatchExpr(
1200	rhs: *ast.Node,	1212	rhs: *ast.Node,
1201	payload_node: ?*ast.Node,	1213	payload_node: ?*ast.Node,
1202	) InnerError!*zir.Inst {	1214	) InnerError!*zir.Inst {
		1215	if (true) {
		1216	@panic("TODO reimplement this");
		1217	}
1203	const tree = scope.tree();	1218	const tree = scope.tree();
1204	const src = tree.token_locs[op_token].start;	1219	const src = tree.token_locs[op_token].start;
1205		1220
...	@@ -1308,7 +1323,7 @@ pub fn field(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.SimpleI	...	@@ -1308,7 +1323,7 @@ pub fn field(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.SimpleI
1308	.field_name = field_name,	1323	.field_name = field_name,
1309	});	1324	});
1310	}	1325	}
1311	return rlWrap(mod, scope, rl, try addZirInstTag(mod, scope, src, .field_val, .{	1326	return rvalue(mod, scope, rl, try addZirInstTag(mod, scope, src, .field_val, .{
1312	.object = try expr(mod, scope, .none, node.lhs),	1327	.object = try expr(mod, scope, .none, node.lhs),
1313	.field_name = field_name,	1328	.field_name = field_name,
1314	}));	1329	}));
...	@@ -1338,7 +1353,7 @@ fn namedField(	...	@@ -1338,7 +1353,7 @@ fn namedField(
1338	.field_name = try comptimeExpr(mod, scope, string_rl, params[1]),	1353	.field_name = try comptimeExpr(mod, scope, string_rl, params[1]),
1339	});	1354	});
1340	}	1355	}
1341	return rlWrap(mod, scope, rl, try addZirInstTag(mod, scope, src, .field_val_named, .{	1356	return rvalue(mod, scope, rl, try addZirInstTag(mod, scope, src, .field_val_named, .{
1342	.object = try expr(mod, scope, .none, params[0]),	1357	.object = try expr(mod, scope, .none, params[0]),
1343	.field_name = try comptimeExpr(mod, scope, string_rl, params[1]),	1358	.field_name = try comptimeExpr(mod, scope, string_rl, params[1]),
1344	}));	1359	}));
...	@@ -1359,7 +1374,7 @@ fn arrayAccess(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Array	...	@@ -1359,7 +1374,7 @@ fn arrayAccess(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Array
1359	.index = try expr(mod, scope, index_rl, node.index_expr),	1374	.index = try expr(mod, scope, index_rl, node.index_expr),
1360	});	1375	});
1361	}	1376	}
1362	return rlWrap(mod, scope, rl, try addZirInstTag(mod, scope, src, .elem_val, .{	1377	return rvalue(mod, scope, rl, try addZirInstTag(mod, scope, src, .elem_val, .{
1363	.array = try expr(mod, scope, .none, node.lhs),	1378	.array = try expr(mod, scope, .none, node.lhs),
1364	.index = try expr(mod, scope, index_rl, node.index_expr),	1379	.index = try expr(mod, scope, index_rl, node.index_expr),
1365	}));	1380	}));
...	@@ -1416,7 +1431,7 @@ fn simpleBinOp(	...	@@ -1416,7 +1431,7 @@ fn simpleBinOp(
1416	const rhs = try expr(mod, scope, .none, infix_node.rhs);	1431	const rhs = try expr(mod, scope, .none, infix_node.rhs);
1417		1432
1418	const result = try addZIRBinOp(mod, scope, src, op_inst_tag, lhs, rhs);	1433	const result = try addZIRBinOp(mod, scope, src, op_inst_tag, lhs, rhs);
1419	return rlWrap(mod, scope, rl, result);	1434	return rvalue(mod, scope, rl, result);
1420	}	1435	}
1421		1436
1422	fn boolBinOp(	1437	fn boolBinOp(
...	@@ -1498,7 +1513,7 @@ fn boolBinOp(	...	@@ -1498,7 +1513,7 @@ fn boolBinOp(
1498	condbr.positionals.else_body = .{ .instructions = try rhs_scope.arena.dupe(*zir.Inst, rhs_scope.instructions.items) };	1513	condbr.positionals.else_body = .{ .instructions = try rhs_scope.arena.dupe(*zir.Inst, rhs_scope.instructions.items) };
1499	}	1514	}
1500		1515
1501	return rlWrap(mod, scope, rl, &block.base);	1516	return rvalue(mod, scope, rl, &block.base);
1502	}	1517	}
1503		1518
1504	const CondKind = union(enum) {	1519	const CondKind = union(enum) {
...	@@ -1578,6 +1593,7 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn	...	@@ -1578,6 +1593,7 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
1578	cond_kind = .{ .err_union = null };	1593	cond_kind = .{ .err_union = null };
1579	}	1594	}
1580	}	1595	}
		1596	const block_branch_count = 2; // then and else
1581	var block_scope: Scope.GenZIR = .{	1597	var block_scope: Scope.GenZIR = .{
1582	.parent = scope,	1598	.parent = scope,
1583	.decl = scope.ownerDecl().?,	1599	.decl = scope.ownerDecl().?,
...	@@ -1600,6 +1616,33 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn	...	@@ -1600,6 +1616,33 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
1600	.instructions = try block_scope.arena.dupe(*zir.Inst, block_scope.instructions.items),	1616	.instructions = try block_scope.arena.dupe(*zir.Inst, block_scope.instructions.items),
1601	});	1617	});
1602		1618
		1619	// Depending on whether the result location is a pointer or value, different
		1620	// ZIR needs to be generated. In the former case we rely on storing to the
		1621	// pointer to communicate the result, and use breakvoid; in the latter case
		1622	// the block break instructions will have the result values.
		1623	// One more complication: when the result location is a pointer, we detect
		1624	// the scenario where the result location is not consumed. In this case
		1625	// we emit ZIR for the block break instructions to have the result values,
		1626	// and then rvalue() on that to pass the value to the result location.
		1627	const branch_rl: ResultLoc = switch (rl) {
		1628	.discard, .none, .ty, .ptr, .ref => rl,
		1629
		1630	.inferred_ptr => \|ptr\| blk: {
		1631	block_scope.rl_ptr = &ptr.base;
		1632	break :blk .{ .block_ptr = &block_scope };
		1633	},
		1634
		1635	.bitcasted_ptr => \|ptr\| blk: {
		1636	block_scope.rl_ptr = &ptr.base;
		1637	break :blk .{ .block_ptr = &block_scope };
		1638	},
		1639
		1640	.block_ptr => \|parent_block_scope\| blk: {
		1641	block_scope.rl_ptr = parent_block_scope.rl_ptr.?;
		1642	break :blk .{ .block_ptr = &block_scope };
		1643	},
		1644	};
		1645
1603	const then_src = tree.token_locs[if_node.body.lastToken()].start;	1646	const then_src = tree.token_locs[if_node.body.lastToken()].start;
1604	var then_scope: Scope.GenZIR = .{	1647	var then_scope: Scope.GenZIR = .{
1605	.parent = scope,	1648	.parent = scope,
...	@@ -1612,25 +1655,10 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn	...	@@ -1612,25 +1655,10 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
1612	// declare payload to the then_scope	1655	// declare payload to the then_scope
1613	const then_sub_scope = try cond_kind.thenSubScope(mod, &then_scope, then_src, if_node.payload);	1656	const then_sub_scope = try cond_kind.thenSubScope(mod, &then_scope, then_src, if_node.payload);
1614		1657
1615	// Most result location types can be forwarded directly; however
1616	// if we need to write to a pointer which has an inferred type,
1617	// proper type inference requires peer type resolution on the if's
1618	// branches.
1619	const branch_rl: ResultLoc = switch (rl) {
1620	.discard, .none, .ty, .ptr, .ref => rl,
1621	.inferred_ptr, .bitcasted_ptr, .block_ptr => .{ .block_ptr = block },
1622	};
1623
1624	const then_result = try expr(mod, then_sub_scope, branch_rl, if_node.body);	1658	const then_result = try expr(mod, then_sub_scope, branch_rl, if_node.body);
1625	if (!then_result.tag.isNoReturn()) {	1659	// We hold off on the break instructions as well as copying the then/else
1626	_ = try addZIRInst(mod, then_sub_scope, then_src, zir.Inst.Break, .{	1660	// instructions into place until we know whether to keep store_to_block_ptr
1627	.block = block,	1661	// instructions or not.
1628	.operand = then_result,
1629	}, .{});
1630	}
1631	condbr.positionals.then_body = .{
1632	.instructions = try then_scope.arena.dupe(*zir.Inst, then_scope.instructions.items),
1633	};
1634		1662
1635	var else_scope: Scope.GenZIR = .{	1663	var else_scope: Scope.GenZIR = .{
1636	.parent = scope,	1664	.parent = scope,
...	@@ -1640,34 +1668,127 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn	...	@@ -1640,34 +1668,127 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
1640	};	1668	};
1641	defer else_scope.instructions.deinit(mod.gpa);	1669	defer else_scope.instructions.deinit(mod.gpa);
1642		1670
1643	if (if_node.@"else") \|else_node\| {	1671	var else_src: usize = undefined;
1644	const else_src = tree.token_locs[else_node.body.lastToken()].start;	1672	var else_sub_scope: *Module.Scope = undefined;
		1673	const else_result: ?*zir.Inst = if (if_node.@"else") \|else_node\| blk: {
		1674	else_src = tree.token_locs[else_node.body.lastToken()].start;
1645	// declare payload to the then_scope	1675	// declare payload to the then_scope
1646	const else_sub_scope = try cond_kind.elseSubScope(mod, &else_scope, else_src, else_node.payload);	1676	else_sub_scope = try cond_kind.elseSubScope(mod, &else_scope, else_src, else_node.payload);
		1677
		1678	break :blk try expr(mod, else_sub_scope, branch_rl, else_node.body);
		1679	} else blk: {
		1680	else_src = tree.token_locs[if_node.lastToken()].start;
		1681	else_sub_scope = &else_scope.base;
		1682	block_scope.rvalue_rl_count += 1;
		1683	break :blk null;
		1684	};
1647		1685
1648	const else_result = try expr(mod, else_sub_scope, branch_rl, else_node.body);	1686	// We now have enough information to decide whether the result instruction should
1649	if (!else_result.tag.isNoReturn()) {	1687	// be communicated via result location pointer or break instructions.
1650	_ = try addZIRInst(mod, else_sub_scope, else_src, zir.Inst.Break, .{	1688	const Strategy = enum {
1651	.block = block,	1689	/// Both branches will use break_void; result location is used to communicate the
1652	.operand = else_result,	1690	/// result instruction.
1653	}, .{});	1691	break_void,
1654	}	1692	/// Use break statements to pass the block result value, and call rvalue() at
1655	} else {	1693	/// the end depending on rl. Also elide the store_to_block_ptr instructions
1656	// TODO Optimization opportunity: we can avoid an allocation and a memcpy here	1694	/// depending on rl.
1657	// by directly allocating the body for this one instruction.	1695	break_operand,
1658	const else_src = tree.token_locs[if_node.lastToken()].start;	1696	};
1659	_ = try addZIRInst(mod, &else_scope.base, else_src, zir.Inst.BreakVoid, .{	1697	var elide_store_to_block_ptr_instructions = false;
1660	.block = block,	1698	const strategy: Strategy = switch (rl) {
1661	}, .{});	1699	// In this branch there will not be any store_to_block_ptr instructions.
		1700	.discard, .none, .ty, .ref => .break_operand,
		1701	// The pointer got passed through to the sub-expressions, so we will use
		1702	// break_void here.
		1703	// In this branch there will not be any store_to_block_ptr instructions.
		1704	.ptr => .break_void,
		1705	.inferred_ptr, .bitcasted_ptr, .block_ptr => blk: {
		1706	if (block_scope.rvalue_rl_count == 2) {
		1707	// Neither prong of the if consumed the result location, so we can
		1708	// use break instructions to create an rvalue.
		1709	elide_store_to_block_ptr_instructions = true;
		1710	break :blk Strategy.break_operand;
		1711	} else {
		1712	// Allow the store_to_block_ptr instructions to remain so that
		1713	// semantic analysis can turn them into bitcasts.
		1714	break :blk Strategy.break_void;
		1715	}
		1716	},
		1717	};
		1718	switch (strategy) {
		1719	.break_void => {
		1720	if (!then_result.tag.isNoReturn()) {
		1721	_ = try addZIRNoOp(mod, then_sub_scope, then_src, .break_void);
		1722	}
		1723	if (else_result) \|inst\| {
		1724	if (!inst.tag.isNoReturn()) {
		1725	_ = try addZIRNoOp(mod, else_sub_scope, else_src, .break_void);
		1726	}
		1727	} else {
		1728	_ = try addZIRNoOp(mod, else_sub_scope, else_src, .break_void);
		1729	}
		1730	assert(!elide_store_to_block_ptr_instructions);
		1731	try copyBodyNoEliding(&condbr.positionals.then_body, then_scope);
		1732	try copyBodyNoEliding(&condbr.positionals.else_body, else_scope);
		1733	return &block.base;
		1734	},
		1735	.break_operand => {
		1736	if (!then_result.tag.isNoReturn()) {
		1737	_ = try addZirInstTag(mod, then_sub_scope, then_src, .@"break", .{
		1738	.block = block,
		1739	.operand = then_result,
		1740	});
		1741	}
		1742	if (else_result) \|inst\| {
		1743	if (!inst.tag.isNoReturn()) {
		1744	_ = try addZirInstTag(mod, else_sub_scope, else_src, .@"break", .{
		1745	.block = block,
		1746	.operand = inst,
		1747	});
		1748	}
		1749	} else {
		1750	_ = try addZIRNoOp(mod, else_sub_scope, else_src, .break_void);
		1751	}
		1752	if (elide_store_to_block_ptr_instructions) {
		1753	try copyBodyWithElidedStoreBlockPtr(&condbr.positionals.then_body, then_scope);
		1754	try copyBodyWithElidedStoreBlockPtr(&condbr.positionals.else_body, else_scope);
		1755	} else {
		1756	try copyBodyNoEliding(&condbr.positionals.then_body, then_scope);
		1757	try copyBodyNoEliding(&condbr.positionals.else_body, else_scope);
		1758	}
		1759	switch (rl) {
		1760	.ref => return &block.base,
		1761	else => return rvalue(mod, scope, rl, &block.base),
		1762	}
		1763	},
1662	}	1764	}
1663	condbr.positionals.else_body = .{	1765	}
1664	.instructions = try else_scope.arena.dupe(*zir.Inst, else_scope.instructions.items),	1766
		1767	/// Expects to find exactly 1 .store_to_block_ptr instruction.
		1768	fn copyBodyWithElidedStoreBlockPtr(body: *zir.Body, scope: Module.Scope.GenZIR) !void {
		1769	body.* = .{
		1770	.instructions = try scope.arena.alloc(*zir.Inst, scope.instructions.items.len - 1),
1665	};	1771	};
		1772	var dst_index: usize = 0;
		1773	for (scope.instructions.items) \|src_inst\| {
		1774	if (src_inst.tag != .store_to_block_ptr) {
		1775	body.instructions[dst_index] = src_inst;
		1776	dst_index += 1;
		1777	}
		1778	}
		1779	assert(dst_index == body.instructions.len);
		1780	}
1666		1781
1667	return &block.base;	1782	fn copyBodyNoEliding(body: *zir.Body, scope: Module.Scope.GenZIR) !void {
		1783	body.* = .{
		1784	.instructions = try scope.arena.dupe(*zir.Inst, scope.instructions.items),
		1785	};
1668	}	1786	}
1669		1787
1670	fn whileExpr(mod: Module, scope: Scope, rl: ResultLoc, while_node: ast.Node.While) InnerError!zir.Inst {	1788	fn whileExpr(mod: Module, scope: Scope, rl: ResultLoc, while_node: ast.Node.While) InnerError!zir.Inst {
		1789	if (true) {
		1790	@panic("TODO reimplement this");
		1791	}
1671	var cond_kind: CondKind = .bool;	1792	var cond_kind: CondKind = .bool;
1672	if (while_node.payload) \|_\| cond_kind = .{ .optional = null };	1793	if (while_node.payload) \|_\| cond_kind = .{ .optional = null };
1673	if (while_node.@"else") \|else_node\| {	1794	if (while_node.@"else") \|else_node\| {
...	@@ -1821,6 +1942,9 @@ fn forExpr(	...	@@ -1821,6 +1942,9 @@ fn forExpr(
1821	rl: ResultLoc,	1942	rl: ResultLoc,
1822	for_node: *ast.Node.For,	1943	for_node: *ast.Node.For,
1823	) InnerError!*zir.Inst {	1944	) InnerError!*zir.Inst {
		1945	if (true) {
		1946	@panic("TODO reimplement this");
		1947	}
1824	if (for_node.label) \|label\| {	1948	if (for_node.label) \|label\| {
1825	try checkLabelRedefinition(mod, scope, label);	1949	try checkLabelRedefinition(mod, scope, label);
1826	}	1950	}
...	@@ -2017,6 +2141,9 @@ fn getRangeNode(node: ast.Node) ?ast.Node.SimpleInfixOp {	...	@@ -2017,6 +2141,9 @@ fn getRangeNode(node: ast.Node) ?ast.Node.SimpleInfixOp {
2017	}	2141	}
2018		2142
2019	fn switchExpr(mod: Module, scope: Scope, rl: ResultLoc, switch_node: ast.Node.Switch) InnerError!zir.Inst {	2143	fn switchExpr(mod: Module, scope: Scope, rl: ResultLoc, switch_node: ast.Node.Switch) InnerError!zir.Inst {
		2144	if (true) {
		2145	@panic("TODO reimplement this");
		2146	}
2020	var block_scope: Scope.GenZIR = .{	2147	var block_scope: Scope.GenZIR = .{
2021	.parent = scope,	2148	.parent = scope,
2022	.decl = scope.ownerDecl().?,	2149	.decl = scope.ownerDecl().?,
...	@@ -2186,10 +2313,10 @@ fn switchExpr(mod: Module, scope: Scope, rl: ResultLoc, switch_node: *ast.Node	...	@@ -2186,10 +2313,10 @@ fn switchExpr(mod: Module, scope: Scope, rl: ResultLoc, switch_node: *ast.Node
2186	// target >= start and target <= end	2313	// target >= start and target <= end
2187	const range_start_ok = try addZIRBinOp(mod, &else_scope.base, range_src, .cmp_gte, target, start);	2314	const range_start_ok = try addZIRBinOp(mod, &else_scope.base, range_src, .cmp_gte, target, start);
2188	const range_end_ok = try addZIRBinOp(mod, &else_scope.base, range_src, .cmp_lte, target, end);	2315	const range_end_ok = try addZIRBinOp(mod, &else_scope.base, range_src, .cmp_lte, target, end);
2189	const range_ok = try addZIRBinOp(mod, &else_scope.base, range_src, .booland, range_start_ok, range_end_ok);	2316	const range_ok = try addZIRBinOp(mod, &else_scope.base, range_src, .bool_and, range_start_ok, range_end_ok);
2190		2317
2191	if (any_ok) \|some\| {	2318	if (any_ok) \|some\| {
2192	any_ok = try addZIRBinOp(mod, &else_scope.base, range_src, .boolor, some, range_ok);	2319	any_ok = try addZIRBinOp(mod, &else_scope.base, range_src, .bool_or, some, range_ok);
2193	} else {	2320	} else {
2194	any_ok = range_ok;	2321	any_ok = range_ok;
2195	}	2322	}
...	@@ -2201,7 +2328,7 @@ fn switchExpr(mod: Module, scope: Scope, rl: ResultLoc, switch_node: *ast.Node	...	@@ -2201,7 +2328,7 @@ fn switchExpr(mod: Module, scope: Scope, rl: ResultLoc, switch_node: *ast.Node
2201	const cpm_ok = try addZIRBinOp(mod, &else_scope.base, item_inst.src, .cmp_eq, target, item_inst);	2328	const cpm_ok = try addZIRBinOp(mod, &else_scope.base, item_inst.src, .cmp_eq, target, item_inst);
2202		2329
2203	if (any_ok) \|some\| {	2330	if (any_ok) \|some\| {
2204	any_ok = try addZIRBinOp(mod, &else_scope.base, item_inst.src, .boolor, some, cpm_ok);	2331	any_ok = try addZIRBinOp(mod, &else_scope.base, item_inst.src, .bool_or, some, cpm_ok);
2205	} else {	2332	} else {
2206	any_ok = cpm_ok;	2333	any_ok = cpm_ok;
2207	}	2334	}
...	@@ -2238,7 +2365,7 @@ fn switchExpr(mod: Module, scope: Scope, rl: ResultLoc, switch_node: *ast.Node	...	@@ -2238,7 +2365,7 @@ fn switchExpr(mod: Module, scope: Scope, rl: ResultLoc, switch_node: *ast.Node
2238	try switchCaseExpr(mod, &else_scope.base, case_rl, block, case);	2365	try switchCaseExpr(mod, &else_scope.base, case_rl, block, case);
2239	} else {	2366	} else {
2240	// Not handling all possible cases is a compile error.	2367	// Not handling all possible cases is a compile error.
2241	_ = try addZIRNoOp(mod, &else_scope.base, switch_src, .unreach_nocheck);	2368	_ = try addZIRNoOp(mod, &else_scope.base, switch_src, .unreachable_unsafe);
2242	}	2369	}
2243		2370
2244	// All items have been generated, add the instructions to the comptime block.	2371	// All items have been generated, add the instructions to the comptime block.
...	@@ -2288,7 +2415,7 @@ fn ret(mod: Module, scope: Scope, cfe: *ast.Node.ControlFlowExpression) InnerE	...	@@ -2288,7 +2415,7 @@ fn ret(mod: Module, scope: Scope, cfe: *ast.Node.ControlFlowExpression) InnerE
2288	return addZIRUnOp(mod, scope, src, .@"return", operand);	2415	return addZIRUnOp(mod, scope, src, .@"return", operand);
2289	}	2416	}
2290	} else {	2417	} else {
2291	return addZIRNoOp(mod, scope, src, .returnvoid);	2418	return addZIRNoOp(mod, scope, src, .return_void);
2292	}	2419	}
2293	}	2420	}
2294		2421
...	@@ -2305,7 +2432,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo	...	@@ -2305,7 +2432,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo
2305		2432
2306	if (getSimplePrimitiveValue(ident_name)) \|typed_value\| {	2433	if (getSimplePrimitiveValue(ident_name)) \|typed_value\| {
2307	const result = try addZIRInstConst(mod, scope, src, typed_value);	2434	const result = try addZIRInstConst(mod, scope, src, typed_value);
2308	return rlWrap(mod, scope, rl, result);	2435	return rvalue(mod, scope, rl, result);
2309	}	2436	}
2310		2437
2311	if (ident_name.len >= 2) integer: {	2438	if (ident_name.len >= 2) integer: {
...	@@ -2327,7 +2454,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo	...	@@ -2327,7 +2454,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo
2327	32 => if (is_signed) Value.initTag(.i32_type) else Value.initTag(.u32_type),	2454	32 => if (is_signed) Value.initTag(.i32_type) else Value.initTag(.u32_type),
2328	64 => if (is_signed) Value.initTag(.i64_type) else Value.initTag(.u64_type),	2455	64 => if (is_signed) Value.initTag(.i64_type) else Value.initTag(.u64_type),
2329	else => {	2456	else => {
2330	return rlWrap(mod, scope, rl, try addZIRInstConst(mod, scope, src, .{	2457	return rvalue(mod, scope, rl, try addZIRInstConst(mod, scope, src, .{
2331	.ty = Type.initTag(.type),	2458	.ty = Type.initTag(.type),
2332	.val = try Value.Tag.int_type.create(scope.arena(), .{	2459	.val = try Value.Tag.int_type.create(scope.arena(), .{
2333	.signed = is_signed,	2460	.signed = is_signed,
...	@@ -2340,7 +2467,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo	...	@@ -2340,7 +2467,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo
2340	.ty = Type.initTag(.type),	2467	.ty = Type.initTag(.type),
2341	.val = val,	2468	.val = val,
2342	});	2469	});
2343	return rlWrap(mod, scope, rl, result);	2470	return rvalue(mod, scope, rl, result);
2344	}	2471	}
2345	}	2472	}
2346		2473
...	@@ -2351,7 +2478,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo	...	@@ -2351,7 +2478,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo
2351	.local_val => {	2478	.local_val => {
2352	const local_val = s.cast(Scope.LocalVal).?;	2479	const local_val = s.cast(Scope.LocalVal).?;
2353	if (mem.eql(u8, local_val.name, ident_name)) {	2480	if (mem.eql(u8, local_val.name, ident_name)) {
2354	return rlWrap(mod, scope, rl, local_val.inst);	2481	return rvalue(mod, scope, rl, local_val.inst);
2355	}	2482	}
2356	s = local_val.parent;	2483	s = local_val.parent;
2357	},	2484	},
...	@@ -2360,7 +2487,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo	...	@@ -2360,7 +2487,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo
2360	if (mem.eql(u8, local_ptr.name, ident_name)) {	2487	if (mem.eql(u8, local_ptr.name, ident_name)) {
2361	if (rl == .ref) return local_ptr.ptr;	2488	if (rl == .ref) return local_ptr.ptr;
2362	const loaded = try addZIRUnOp(mod, scope, src, .deref, local_ptr.ptr);	2489	const loaded = try addZIRUnOp(mod, scope, src, .deref, local_ptr.ptr);
2363	return rlWrap(mod, scope, rl, loaded);	2490	return rvalue(mod, scope, rl, loaded);
2364	}	2491	}
2365	s = local_ptr.parent;	2492	s = local_ptr.parent;
2366	},	2493	},
...	@@ -2373,7 +2500,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo	...	@@ -2373,7 +2500,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo
2373	if (rl == .ref) {	2500	if (rl == .ref) {
2374	return addZIRInst(mod, scope, src, zir.Inst.DeclRef, .{ .decl = decl }, .{});	2501	return addZIRInst(mod, scope, src, zir.Inst.DeclRef, .{ .decl = decl }, .{});
2375	} else {	2502	} else {
2376	return rlWrap(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.DeclVal, .{	2503	return rvalue(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.DeclVal, .{
2377	.decl = decl,	2504	.decl = decl,
2378	}, .{}));	2505	}, .{}));
2379	}	2506	}
...	@@ -2590,7 +2717,7 @@ fn simpleCast(	...	@@ -2590,7 +2717,7 @@ fn simpleCast(
2590	const dest_type = try typeExpr(mod, scope, params[0]);	2717	const dest_type = try typeExpr(mod, scope, params[0]);
2591	const rhs = try expr(mod, scope, .none, params[1]);	2718	const rhs = try expr(mod, scope, .none, params[1]);
2592	const result = try addZIRBinOp(mod, scope, src, inst_tag, dest_type, rhs);	2719	const result = try addZIRBinOp(mod, scope, src, inst_tag, dest_type, rhs);
2593	return rlWrap(mod, scope, rl, result);	2720	return rvalue(mod, scope, rl, result);
2594	}	2721	}
2595		2722
2596	fn ptrToInt(mod: Module, scope: Scope, call: ast.Node.BuiltinCall) InnerError!zir.Inst {	2723	fn ptrToInt(mod: Module, scope: Scope, call: ast.Node.BuiltinCall) InnerError!zir.Inst {
...	@@ -2634,11 +2761,11 @@ fn as(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.BuiltinCall) I	...	@@ -2634,11 +2761,11 @@ fn as(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.BuiltinCall) I
2634	// TODO here we should be able to resolve the inference; we now have a type for the result.	2761	// TODO here we should be able to resolve the inference; we now have a type for the result.
2635	return mod.failTok(scope, call.builtin_token, "TODO implement @as with inferred-type result location pointer", .{});	2762	return mod.failTok(scope, call.builtin_token, "TODO implement @as with inferred-type result location pointer", .{});
2636	},	2763	},
2637	.block_ptr => \|block_ptr\| {	2764	.block_ptr => \|block_scope\| {
2638	const casted_block_ptr = try addZIRInst(mod, scope, src, zir.Inst.CoerceResultBlockPtr, .{	2765	const casted_block_ptr = try addZirInstTag(mod, scope, src, .coerce_result_block_ptr, .{
2639	.dest_type = dest_type,	2766	.dest_type = dest_type,
2640	.block = block_ptr,	2767	.block_ptr = block_scope.rl_ptr.?,
2641	}, .{});	2768	});
2642	return expr(mod, scope, .{ .ptr = casted_block_ptr }, params[1]);	2769	return expr(mod, scope, .{ .ptr = casted_block_ptr }, params[1]);
2643	},	2770	},
2644	}	2771	}
...	@@ -2703,7 +2830,7 @@ fn compileError(mod: Module, scope: Scope, call: *ast.Node.BuiltinCall) InnerE	...	@@ -2703,7 +2830,7 @@ fn compileError(mod: Module, scope: Scope, call: *ast.Node.BuiltinCall) InnerE
2703	const src = tree.token_locs[call.builtin_token].start;	2830	const src = tree.token_locs[call.builtin_token].start;
2704	const params = call.params();	2831	const params = call.params();
2705	const target = try expr(mod, scope, .none, params[0]);	2832	const target = try expr(mod, scope, .none, params[0]);
2706	return addZIRUnOp(mod, scope, src, .compileerror, target);	2833	return addZIRUnOp(mod, scope, src, .compile_error, target);
2707	}	2834	}
2708		2835
2709	fn setEvalBranchQuota(mod: Module, scope: Scope, call: ast.Node.BuiltinCall) InnerError!zir.Inst {	2836	fn setEvalBranchQuota(mod: Module, scope: Scope, call: ast.Node.BuiltinCall) InnerError!zir.Inst {
...	@@ -2728,12 +2855,12 @@ fn typeOf(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.BuiltinCal	...	@@ -2728,12 +2855,12 @@ fn typeOf(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.BuiltinCal
2728	return mod.failTok(scope, call.builtin_token, "expected at least 1 argument, found 0", .{});	2855	return mod.failTok(scope, call.builtin_token, "expected at least 1 argument, found 0", .{});
2729	}	2856	}
2730	if (params.len == 1) {	2857	if (params.len == 1) {
2731	return rlWrap(mod, scope, rl, try addZIRUnOp(mod, scope, src, .typeof, try expr(mod, scope, .none, params[0])));	2858	return rvalue(mod, scope, rl, try addZIRUnOp(mod, scope, src, .typeof, try expr(mod, scope, .none, params[0])));
2732	}	2859	}
2733	var items = try arena.alloc(*zir.Inst, params.len);	2860	var items = try arena.alloc(*zir.Inst, params.len);
2734	for (params) \|param, param_i\|	2861	for (params) \|param, param_i\|
2735	items[param_i] = try expr(mod, scope, .none, param);	2862	items[param_i] = try expr(mod, scope, .none, param);
2736	return rlWrap(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.TypeOfPeer, .{ .items = items }, .{}));	2863	return rvalue(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.TypeOfPeer, .{ .items = items }, .{}));
2737	}	2864	}
2738	fn compileLog(mod: Module, scope: Scope, call: ast.Node.BuiltinCall) InnerError!zir.Inst {	2865	fn compileLog(mod: Module, scope: Scope, call: ast.Node.BuiltinCall) InnerError!zir.Inst {
2739	const tree = scope.tree();	2866	const tree = scope.tree();
...	@@ -2756,7 +2883,7 @@ fn builtinCall(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.Built	...	@@ -2756,7 +2883,7 @@ fn builtinCall(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.Built
2756	// Also, some builtins have a variable number of parameters.	2883	// Also, some builtins have a variable number of parameters.
2757		2884
2758	if (mem.eql(u8, builtin_name, "@ptrToInt")) {	2885	if (mem.eql(u8, builtin_name, "@ptrToInt")) {
2759	return rlWrap(mod, scope, rl, try ptrToInt(mod, scope, call));	2886	return rvalue(mod, scope, rl, try ptrToInt(mod, scope, call));
2760	} else if (mem.eql(u8, builtin_name, "@as")) {	2887	} else if (mem.eql(u8, builtin_name, "@as")) {
2761	return as(mod, scope, rl, call);	2888	return as(mod, scope, rl, call);
2762	} else if (mem.eql(u8, builtin_name, "@floatCast")) {	2889	} else if (mem.eql(u8, builtin_name, "@floatCast")) {
...	@@ -2769,9 +2896,9 @@ fn builtinCall(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.Built	...	@@ -2769,9 +2896,9 @@ fn builtinCall(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.Built
2769	return typeOf(mod, scope, rl, call);	2896	return typeOf(mod, scope, rl, call);
2770	} else if (mem.eql(u8, builtin_name, "@breakpoint")) {	2897	} else if (mem.eql(u8, builtin_name, "@breakpoint")) {
2771	const src = tree.token_locs[call.builtin_token].start;	2898	const src = tree.token_locs[call.builtin_token].start;
2772	return rlWrap(mod, scope, rl, try addZIRNoOp(mod, scope, src, .breakpoint));	2899	return rvalue(mod, scope, rl, try addZIRNoOp(mod, scope, src, .breakpoint));
2773	} else if (mem.eql(u8, builtin_name, "@import")) {	2900	} else if (mem.eql(u8, builtin_name, "@import")) {
2774	return rlWrap(mod, scope, rl, try import(mod, scope, call));	2901	return rvalue(mod, scope, rl, try import(mod, scope, call));
2775	} else if (mem.eql(u8, builtin_name, "@compileError")) {	2902	} else if (mem.eql(u8, builtin_name, "@compileError")) {
2776	return compileError(mod, scope, call);	2903	return compileError(mod, scope, call);
2777	} else if (mem.eql(u8, builtin_name, "@setEvalBranchQuota")) {	2904	} else if (mem.eql(u8, builtin_name, "@setEvalBranchQuota")) {
...	@@ -2806,13 +2933,13 @@ fn callExpr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Call) In	...	@@ -2806,13 +2933,13 @@ fn callExpr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Call) In
2806	.args = args,	2933	.args = args,
2807	}, .{});	2934	}, .{});
2808	// TODO function call with result location	2935	// TODO function call with result location
2809	return rlWrap(mod, scope, rl, result);	2936	return rvalue(mod, scope, rl, result);
2810	}	2937	}
2811		2938
2812	fn unreach(mod: Module, scope: Scope, unreach_node: ast.Node.OneToken) InnerError!zir.Inst {	2939	fn unreach(mod: Module, scope: Scope, unreach_node: ast.Node.OneToken) InnerError!zir.Inst {
2813	const tree = scope.tree();	2940	const tree = scope.tree();
2814	const src = tree.token_locs[unreach_node.token].start;	2941	const src = tree.token_locs[unreach_node.token].start;
2815	return addZIRNoOp(mod, scope, src, .@"unreachable");	2942	return addZIRNoOp(mod, scope, src, .unreachable_safe);
2816	}	2943	}
2817		2944
2818	fn getSimplePrimitiveValue(name: []const u8) ?TypedValue {	2945	fn getSimplePrimitiveValue(name: []const u8) ?TypedValue {
...	@@ -3099,7 +3226,7 @@ fn nodeMayNeedMemoryLocation(start_node: ast.Node, scope: Scope) bool {	...	@@ -3099,7 +3226,7 @@ fn nodeMayNeedMemoryLocation(start_node: ast.Node, scope: Scope) bool {
3099	/// result locations must call this function on their result.	3226	/// result locations must call this function on their result.
3100	/// As an example, if the `ResultLoc` is `ptr`, it will write the result to the pointer.	3227	/// As an example, if the `ResultLoc` is `ptr`, it will write the result to the pointer.
3101	/// If the `ResultLoc` is `ty`, it will coerce the result to the type.	3228	/// If the `ResultLoc` is `ty`, it will coerce the result to the type.
3102	fn rlWrap(mod: Module, scope: Scope, rl: ResultLoc, result: zir.Inst) InnerError!zir.Inst {	3229	fn rvalue(mod: Module, scope: Scope, rl: ResultLoc, result: zir.Inst) InnerError!zir.Inst {
3103	switch (rl) {	3230	switch (rl) {
3104	.none => return result,	3231	.none => return result,
3105	.discard => {	3232	.discard => {
...	@@ -3113,42 +3240,31 @@ fn rlWrap(mod: Module, scope: Scope, rl: ResultLoc, result: *zir.Inst) InnerEr	...	@@ -3113,42 +3240,31 @@ fn rlWrap(mod: Module, scope: Scope, rl: ResultLoc, result: *zir.Inst) InnerEr
3113	},	3240	},
3114	.ty => \|ty_inst\| return addZIRBinOp(mod, scope, result.src, .as, ty_inst, result),	3241	.ty => \|ty_inst\| return addZIRBinOp(mod, scope, result.src, .as, ty_inst, result),
3115	.ptr => \|ptr_inst\| {	3242	.ptr => \|ptr_inst\| {
3116	const casted_result = try addZIRInst(mod, scope, result.src, zir.Inst.CoerceToPtrElem, .{	3243	_ = try addZIRBinOp(mod, scope, result.src, .store, ptr_inst, result);
3117	.ptr = ptr_inst,	3244	return result;
3118	.value = result,
3119	}, .{});
3120	_ = try addZIRBinOp(mod, scope, result.src, .store, ptr_inst, casted_result);
3121	return casted_result;
3122	},	3245	},
3123	.bitcasted_ptr => \|bitcasted_ptr\| {	3246	.bitcasted_ptr => \|bitcasted_ptr\| {
3124	return mod.fail(scope, result.src, "TODO implement rlWrap .bitcasted_ptr", .{});	3247	return mod.fail(scope, result.src, "TODO implement rvalue .bitcasted_ptr", .{});
3125	},	3248	},
3126	.inferred_ptr => \|alloc\| {	3249	.inferred_ptr => \|alloc\| {
3127	_ = try addZIRBinOp(mod, scope, result.src, .store_to_inferred_ptr, &alloc.base, result);	3250	_ = try addZIRBinOp(mod, scope, result.src, .store_to_inferred_ptr, &alloc.base, result);
3128	return result;	3251	return result;
3129	},	3252	},
3130	.block_ptr => \|block_ptr\| {	3253	.block_ptr => \|block_scope\| {
3131	return mod.fail(scope, result.src, "TODO implement rlWrap .block_ptr", .{});	3254	block_scope.rvalue_rl_count += 1;
		3255	_ = try addZIRBinOp(mod, scope, result.src, .store_to_block_ptr, block_scope.rl_ptr.?, result);
		3256	return result;
3132	},	3257	},
3133	}	3258	}
3134	}	3259	}
3135		3260
3136	fn rlWrapVoid(mod: Module, scope: Scope, rl: ResultLoc, node: ast.Node, result: void) InnerError!zir.Inst {	3261	fn rvalueVoid(mod: Module, scope: Scope, rl: ResultLoc, node: ast.Node, result: void) InnerError!zir.Inst {
3137	const src = scope.tree().token_locs[node.firstToken()].start;	3262	const src = scope.tree().token_locs[node.firstToken()].start;
3138	const void_inst = try addZIRInstConst(mod, scope, src, .{	3263	const void_inst = try addZIRInstConst(mod, scope, src, .{
3139	.ty = Type.initTag(.void),	3264	.ty = Type.initTag(.void),
3140	.val = Value.initTag(.void_value),	3265	.val = Value.initTag(.void_value),
3141	});	3266	});
3142	return rlWrap(mod, scope, rl, void_inst);	3267	return rvalue(mod, scope, rl, void_inst);
3143	}
3144
3145	/// TODO go over all the callsites and see where we can introduce "by-value" ZIR instructions
3146	/// to save ZIR memory. For example, see DeclVal vs DeclRef.
3147	/// Do not add additional callsites to this function.
3148	fn rlWrapPtr(mod: Module, scope: Scope, rl: ResultLoc, ptr: zir.Inst) InnerError!zir.Inst {
3149	if (rl == .ref) return ptr;
3150
3151	return rlWrap(mod, scope, rl, try addZIRUnOp(mod, scope, ptr.src, .deref, ptr));
3152	}	3268	}
3153		3269
3154	pub fn addZirInstTag(	3270	pub fn addZirInstTag(

src/codegen.zig+12-12

src/ir.zig+8-8

...	@@ -56,9 +56,9 @@ pub const Inst = struct {	...	@@ -56,9 +56,9 @@ pub const Inst = struct {
56	alloc,	56	alloc,
57	arg,	57	arg,
58	assembly,	58	assembly,
59	bitand,	59	bit_and,
60	bitcast,	60	bitcast,
61	bitor,	61	bit_or,
62	block,	62	block,
63	br,	63	br,
64	breakpoint,	64	breakpoint,
...	@@ -85,8 +85,8 @@ pub const Inst = struct {	...	@@ -85,8 +85,8 @@ pub const Inst = struct {
85	is_err,	85	is_err,
86	// *E!T => bool	86	// *E!T => bool
87	is_err_ptr,	87	is_err_ptr,
88	booland,	88	bool_and,
89	boolor,	89	bool_or,
90	/// Read a value from a pointer.	90	/// Read a value from a pointer.
91	load,	91	load,
92	loop,	92	loop,
...	@@ -147,10 +147,10 @@ pub const Inst = struct {	...	@@ -147,10 +147,10 @@ pub const Inst = struct {
147	.cmp_gt,	147	.cmp_gt,
148	.cmp_neq,	148	.cmp_neq,
149	.store,	149	.store,
150	.booland,	150	.bool_and,
151	.boolor,	151	.bool_or,
152	.bitand,	152	.bit_and,
153	.bitor,	153	.bit_or,
154	.xor,	154	.xor,
155	=> BinOp,	155	=> BinOp,
156		156

src/zir.zig+73-82

 @@ -59,7 +59,7 @@ pub const Inst = struct {
         /// Inline assembly.
         @"asm",
         /// Bitwise AND. `&`
-        bitand,
+        bit_and,
         /// TODO delete this instruction, it has no purpose.
         bitcast,
         /// An arbitrary typed pointer is pointer-casted to a new Pointer.
 @@ -71,9 +71,9 @@ pub const Inst = struct {
         /// The new result location pointer has an inferred type.
         bitcast_result_ptr,
         /// Bitwise NOT. `~`
-        bitnot,
+        bit_not,
         /// Bitwise OR. `|`
-        bitor,
+        bit_or,
         /// A labeled block of code, which can return a value.
         block,
         /// A block of code, which can return a value. There are no instructions that break out of
 @@ -83,17 +83,17 @@ pub const Inst = struct {
         block_comptime,
         /// Same as `block_flat` but additionally makes the inner instructions execute at comptime.
         block_comptime_flat,
-        /// Boolean AND. See also `bitand`.
+        /// Boolean AND. See also `bit_and`.
-        booland,
+        bool_and,
-        /// Boolean NOT. See also `bitnot`.
+        /// Boolean NOT. See also `bit_not`.
-        boolnot,
+        bool_not,
-        /// Boolean OR. See also `bitor`.
+        /// Boolean OR. See also `bit_or`.
-        boolor,
+        bool_or,
         /// Return a value from a `Block`.
         @"break",
         breakpoint,
         /// Same as `break` but without an operand; the operand is assumed to be the void value.
-        breakvoid,
+        break_void,
         /// Function call.
         call,
         /// `<`
 @@ -116,12 +116,10 @@ pub const Inst = struct {
         /// result location pointer, whose type is inferred by peer type resolution on the
         /// `Block`'s corresponding `break` instructions.
         coerce_result_block_ptr,
-        /// Equivalent to `as(ptr_child_type(typeof(ptr)), value)`.
-        coerce_to_ptr_elem,
         /// Emit an error message and fail compilation.
-        compileerror,
+        compile_error,
         /// Log compile time variables and emit an error message.
-        compilelog,
+        compile_log,
         /// Conditional branch. Splits control flow based on a boolean condition value.
         condbr,
         /// Special case, has no textual representation.
 @@ -135,11 +133,11 @@ pub const Inst = struct {
         /// Declares the beginning of a statement. Used for debug info.
         dbg_stmt,
         /// Represents a pointer to a global decl.
-        declref,
+        decl_ref,
         /// Represents a pointer to a global decl by string name.
-        declref_str,
+        decl_ref_str,
-        /// Equivalent to a declref followed by deref.
+        /// Equivalent to a decl_ref followed by deref.
-        declval,
+        decl_val,
         /// Load the value from a pointer.
         deref,
         /// Arithmetic division. Asserts no integer overflow.
 @@ -185,7 +183,7 @@ pub const Inst = struct {
         /// can hold the same mathematical value.
         intcast,
         /// Make an integer type out of signedness and bit count.
-        inttype,
+        int_type,
         /// Return a boolean false if an optional is null. `x != null`
         is_non_null,
         /// Return a boolean true if an optional is null. `x == null`
 @@ -232,7 +230,7 @@ pub const Inst = struct {
         /// Sends control flow back to the function's callee. Takes an operand as the return value.
         @"return",
         /// Same as `return` but there is no operand; the operand is implicitly the void value.
-        returnvoid,
+        return_void,
         /// Changes the maximum number of backwards branches that compile-time
         /// code execution can use before giving up and making a compile error.
         set_eval_branch_quota,
 @@ -270,6 +268,10 @@ pub const Inst = struct {
         /// Write a value to a pointer. For loading, see `deref`.
         store,
         /// Same as `store` but the type of the value being stored will be used to infer
+        /// the block type. The LHS is a block instruction, whose result location is
+        /// being stored to.
+        store_to_block_ptr,
+        /// Same as `store` but the type of the value being stored will be used to infer
         /// the pointer type.
         store_to_inferred_ptr,
         /// String Literal. Makes an anonymous Decl and then takes a pointer to it.
 @@ -286,11 +288,11 @@ pub const Inst = struct {
         typeof_peer,
         /// Asserts control-flow will not reach this instruction. Not safety checked - the compiler
         /// will assume the correctness of this instruction.
-        unreach_nocheck,
+        unreachable_unsafe,
         /// Asserts control-flow will not reach this instruction. In safety-checked modes,
         /// this will generate a call to the panic function unless it can be proven unreachable
         /// by the compiler.
-        @"unreachable",
+        unreachable_safe,
         /// Bitwise XOR. `^`
         xor,
         /// Create an optional type '?T'
 @@ -352,17 +354,17 @@ pub const Inst = struct {
                 .alloc_inferred_mut,
                 .breakpoint,
                 .dbg_stmt,
-                .returnvoid,
+                .return_void,
                 .ret_ptr,
                 .ret_type,
-                .unreach_nocheck,
+                .unreachable_unsafe,
-                .@"unreachable",
+                .unreachable_safe,
                 => NoOp,
                 .alloc,
                 .alloc_mut,
-                .boolnot,
+                .bool_not,
-                .compileerror,
+                .compile_error,
                 .deref,
                 .@"return",
                 .is_null,
 @@ -400,7 +402,7 @@ pub const Inst = struct {
                 .err_union_code_ptr,
                 .ensure_err_payload_void,
                 .anyframe_type,
-                .bitnot,
+                .bit_not,
                 .import,
                 .set_eval_branch_quota,
                 .indexable_ptr_len,
 @@ -411,10 +413,10 @@ pub const Inst = struct {
                 .array_cat,
                 .array_mul,
                 .array_type,
-                .bitand,
+                .bit_and,
-                .bitor,
+                .bit_or,
-                .booland,
+                .bool_and,
-                .boolor,
+                .bool_or,
                 .div,
                 .mod_rem,
                 .mul,
 @@ -422,6 +424,7 @@ pub const Inst = struct {
                 .shl,
                 .shr,
                 .store,
+                .store_to_block_ptr,
                 .store_to_inferred_ptr,
                 .sub,
                 .subwrap,
 @@ -452,19 +455,18 @@ pub const Inst = struct {
                 .arg => Arg,
                 .array_type_sentinel => ArrayTypeSentinel,
                 .@"break" => Break,
-                .breakvoid => BreakVoid,
+                .break_void => BreakVoid,
                 .call => Call,
-                .coerce_to_ptr_elem => CoerceToPtrElem,
+                .decl_ref => DeclRef,
-                .declref => DeclRef,
+                .decl_ref_str => DeclRefStr,
-                .declref_str => DeclRefStr,
+                .decl_val => DeclVal,
-                .declval => DeclVal,
                 .coerce_result_block_ptr => CoerceResultBlockPtr,
-                .compilelog => CompileLog,
+                .compile_log => CompileLog,
                 .loop => Loop,
                 .@"const" => Const,
                 .str => Str,
                 .int => Int,
-                .inttype => IntType,
+                .int_type => IntType,
                 .field_ptr, .field_val => Field,
                 .field_ptr_named, .field_val_named => FieldNamed,
                 .@"asm" => Asm,
 @@ -508,18 +510,18 @@ pub const Inst = struct {
                 .arg,
                 .as,
                 .@"asm",
-                .bitand,
+                .bit_and,
                 .bitcast,
                 .bitcast_ref,
                 .bitcast_result_ptr,
-                .bitor,
+                .bit_or,
                 .block,
                 .block_flat,
                 .block_comptime,
                 .block_comptime_flat,
-                .boolnot,
+                .bool_not,
-                .booland,
+                .bool_and,
-                .boolor,
+                .bool_or,
                 .breakpoint,
                 .call,
                 .cmp_lt,
 @@ -530,12 +532,11 @@ pub const Inst = struct {
                 .cmp_neq,
                 .coerce_result_ptr,
                 .coerce_result_block_ptr,
-                .coerce_to_ptr_elem,
                 .@"const",
                 .dbg_stmt,
-                .declref,
+                .decl_ref,
-                .declref_str,
+                .decl_ref_str,
-                .declval,
+                .decl_val,
                 .deref,
                 .div,
                 .elem_ptr,
 @@ -552,7 +553,7 @@ pub const Inst = struct {
                 .fntype,
                 .int,
                 .intcast,
-                .inttype,
+                .int_type,
                 .is_non_null,
                 .is_null,
                 .is_non_null_ptr,
 @@ -579,6 +580,7 @@ pub const Inst = struct {
                 .mut_slice_type,
                 .const_slice_type,
                 .store,
+                .store_to_block_ptr,
                 .store_to_inferred_ptr,
                 .str,
                 .sub,
 @@ -602,7 +604,7 @@ pub const Inst = struct {
                 .merge_error_sets,
                 .anyframe_type,
                 .error_union_type,
-                .bitnot,
+                .bit_not,
                 .error_set,
                 .slice,
                 .slice_start,
 @@ -611,20 +613,20 @@ pub const Inst = struct {
                 .typeof_peer,
                 .resolve_inferred_alloc,
                 .set_eval_branch_quota,
-                .compilelog,
+                .compile_log,
                 .enum_type,
                 .union_type,
                 .struct_type,
                 => false,
                 .@"break",
-                .breakvoid,
+                .break_void,
                 .condbr,
-                .compileerror,
+                .compile_error,
                 .@"return",
-                .returnvoid,
+                .return_void,
-                .unreach_nocheck,
+                .unreachable_unsafe,
-                .@"unreachable",
+                .unreachable_safe,
                 .loop,
                 .switchbr,
                 .container_field_named,
 @@ -717,7 +719,7 @@ pub const Inst = struct {
     };
     pub const BreakVoid = struct {
-        pub const base_tag = Tag.breakvoid;
+        pub const base_tag = Tag.break_void;
         base: Inst,
         positionals: struct {
 @@ -739,19 +741,8 @@ pub const Inst = struct {
         },
     };
-    pub const CoerceToPtrElem = struct {
-        pub const base_tag = Tag.coerce_to_ptr_elem;
-        base: Inst,
-        positionals: struct {
-            ptr: *Inst,
-            value: *Inst,
-        },
-        kw_args: struct {},
-    };
     pub const DeclRef = struct {
-        pub const base_tag = Tag.declref;
+        pub const base_tag = Tag.decl_ref;
         base: Inst,
         positionals: struct {
 @@ -761,7 +752,7 @@ pub const Inst = struct {
     };
     pub const DeclRefStr = struct {
-        pub const base_tag = Tag.declref_str;
+        pub const base_tag = Tag.decl_ref_str;
         base: Inst,
         positionals: struct {
 @@ -771,7 +762,7 @@ pub const Inst = struct {
     };
     pub const DeclVal = struct {
-        pub const base_tag = Tag.declval;
+        pub const base_tag = Tag.decl_val;
         base: Inst,
         positionals: struct {
 @@ -786,13 +777,13 @@ pub const Inst = struct {
         positionals: struct {
             dest_type: *Inst,
-            block: *Block,
+            block_ptr: *Inst,
         },
         kw_args: struct {},
     };
     pub const CompileLog = struct {
-        pub const base_tag = Tag.compilelog;
+        pub const base_tag = Tag.compile_log;
         base: Inst,
         positionals: struct {
 @@ -905,7 +896,7 @@ pub const Inst = struct {
     };
     pub const IntType = struct {
-        pub const base_tag = Tag.inttype;
+        pub const base_tag = Tag.int_type;
         base: Inst,
         positionals: struct {
 @@ -1641,10 +1632,10 @@ const DumpTzir = struct {
                 .cmp_gt,
                 .cmp_neq,
                 .store,
-                .booland,
+                .bool_and,
-                .boolor,
+                .bool_or,
-                .bitand,
+                .bit_and,
-                .bitor,
+                .bit_or,
                 .xor,
                 => {
                     const bin_op = inst.cast(ir.Inst.BinOp).?;
 @@ -1753,10 +1744,10 @@ const DumpTzir = struct {
                 .cmp_gt,
                 .cmp_neq,
                 .store,
-                .booland,
+                .bool_and,
-                .boolor,
+                .bool_or,
-                .bitand,
+                .bit_and,
-                .bitor,
+                .bit_or,
                 .xor,
                 => {
                     const bin_op = inst.cast(ir.Inst.BinOp).?;

src/zir_sema.zig+289-283

 @@ -28,144 +28,134 @@ const Decl = Module.Decl;
 pub fn analyzeInst(mod: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!*Inst {
     switch (old_inst.tag) {
-        .alloc => return analyzeInstAlloc(mod, scope, old_inst.castTag(.alloc).?),
+        .alloc => return zirAlloc(mod, scope, old_inst.castTag(.alloc).?),
-        .alloc_mut => return analyzeInstAllocMut(mod, scope, old_inst.castTag(.alloc_mut).?),
+        .alloc_mut => return zirAllocMut(mod, scope, old_inst.castTag(.alloc_mut).?),
-        .alloc_inferred => return analyzeInstAllocInferred(
+        .alloc_inferred => return zirAllocInferred(mod, scope, old_inst.castTag(.alloc_inferred).?, .inferred_alloc_const),
-            mod,
+        .alloc_inferred_mut => return zirAllocInferred(mod, scope, old_inst.castTag(.alloc_inferred_mut).?, .inferred_alloc_mut),
-            scope,
+        .arg => return zirArg(mod, scope, old_inst.castTag(.arg).?),
-            old_inst.castTag(.alloc_inferred).?,
+        .bitcast_ref => return zirBitcastRef(mod, scope, old_inst.castTag(.bitcast_ref).?),
-            .inferred_alloc_const,
+        .bitcast_result_ptr => return zirBitcastResultPtr(mod, scope, old_inst.castTag(.bitcast_result_ptr).?),
-        ),
+        .block => return zirBlock(mod, scope, old_inst.castTag(.block).?, false),
-        .alloc_inferred_mut => return analyzeInstAllocInferred(
+        .block_comptime => return zirBlock(mod, scope, old_inst.castTag(.block_comptime).?, true),
-            mod,
+        .block_flat => return zirBlockFlat(mod, scope, old_inst.castTag(.block_flat).?, false),
-            scope,
+        .block_comptime_flat => return zirBlockFlat(mod, scope, old_inst.castTag(.block_comptime_flat).?, true),
-            old_inst.castTag(.alloc_inferred_mut).?,
+        .@"break" => return zirBreak(mod, scope, old_inst.castTag(.@"break").?),
-            .inferred_alloc_mut,
+        .breakpoint => return zirBreakpoint(mod, scope, old_inst.castTag(.breakpoint).?),
-        ),
+        .break_void => return zirBreakVoid(mod, scope, old_inst.castTag(.break_void).?),
-        .arg => return analyzeInstArg(mod, scope, old_inst.castTag(.arg).?),
+        .call => return zirCall(mod, scope, old_inst.castTag(.call).?),
-        .bitcast_ref => return bitCastRef(mod, scope, old_inst.castTag(.bitcast_ref).?),
+        .coerce_result_block_ptr => return zirCoerceResultBlockPtr(mod, scope, old_inst.castTag(.coerce_result_block_ptr).?),
-        .bitcast_result_ptr => return bitCastResultPtr(mod, scope, old_inst.castTag(.bitcast_result_ptr).?),
+        .coerce_result_ptr => return zirCoerceResultPtr(mod, scope, old_inst.castTag(.coerce_result_ptr).?),
-        .block => return analyzeInstBlock(mod, scope, old_inst.castTag(.block).?, false),
+        .compile_error => return zirCompileError(mod, scope, old_inst.castTag(.compile_error).?),
-        .block_comptime => return analyzeInstBlock(mod, scope, old_inst.castTag(.block_comptime).?, true),
+        .compile_log => return zirCompileLog(mod, scope, old_inst.castTag(.compile_log).?),
-        .block_flat => return analyzeInstBlockFlat(mod, scope, old_inst.castTag(.block_flat).?, false),
+        .@"const" => return zirConst(mod, scope, old_inst.castTag(.@"const").?),
-        .block_comptime_flat => return analyzeInstBlockFlat(mod, scope, old_inst.castTag(.block_comptime_flat).?, true),
+        .dbg_stmt => return zirDbgStmt(mod, scope, old_inst.castTag(.dbg_stmt).?),
-        .@"break" => return analyzeInstBreak(mod, scope, old_inst.castTag(.@"break").?),
+        .decl_ref => return zirDeclRef(mod, scope, old_inst.castTag(.decl_ref).?),
-        .breakpoint => return analyzeInstBreakpoint(mod, scope, old_inst.castTag(.breakpoint).?),
+        .decl_ref_str => return zirDeclRefStr(mod, scope, old_inst.castTag(.decl_ref_str).?),
-        .breakvoid => return analyzeInstBreakVoid(mod, scope, old_inst.castTag(.breakvoid).?),
+        .decl_val => return zirDeclVal(mod, scope, old_inst.castTag(.decl_val).?),
-        .call => return call(mod, scope, old_inst.castTag(.call).?),
+        .ensure_result_used => return zirEnsureResultUsed(mod, scope, old_inst.castTag(.ensure_result_used).?),
-        .coerce_result_block_ptr => return analyzeInstCoerceResultBlockPtr(mod, scope, old_inst.castTag(.coerce_result_block_ptr).?),
+        .ensure_result_non_error => return zirEnsureResultNonError(mod, scope, old_inst.castTag(.ensure_result_non_error).?),
-        .coerce_result_ptr => return analyzeInstCoerceResultPtr(mod, scope, old_inst.castTag(.coerce_result_ptr).?),
+        .indexable_ptr_len => return zirIndexablePtrLen(mod, scope, old_inst.castTag(.indexable_ptr_len).?),
-        .coerce_to_ptr_elem => return analyzeInstCoerceToPtrElem(mod, scope, old_inst.castTag(.coerce_to_ptr_elem).?),
+        .ref => return zirRef(mod, scope, old_inst.castTag(.ref).?),
-        .compileerror => return analyzeInstCompileError(mod, scope, old_inst.castTag(.compileerror).?),
+        .resolve_inferred_alloc => return zirResolveInferredAlloc(mod, scope, old_inst.castTag(.resolve_inferred_alloc).?),
-        .compilelog => return analyzeInstCompileLog(mod, scope, old_inst.castTag(.compilelog).?),
+        .ret_ptr => return zirRetPtr(mod, scope, old_inst.castTag(.ret_ptr).?),
-        .@"const" => return analyzeInstConst(mod, scope, old_inst.castTag(.@"const").?),
+        .ret_type => return zirRetType(mod, scope, old_inst.castTag(.ret_type).?),
-        .dbg_stmt => return analyzeInstDbgStmt(mod, scope, old_inst.castTag(.dbg_stmt).?),
+        .store_to_block_ptr => return zirStoreToBlockPtr(mod, scope, old_inst.castTag(.store_to_block_ptr).?),
-        .declref => return declRef(mod, scope, old_inst.castTag(.declref).?),
+        .store_to_inferred_ptr => return zirStoreToInferredPtr(mod, scope, old_inst.castTag(.store_to_inferred_ptr).?),
-        .declref_str => return analyzeInstDeclRefStr(mod, scope, old_inst.castTag(.declref_str).?),
+        .single_const_ptr_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.single_const_ptr_type).?, false, .One),
-        .declval => return declVal(mod, scope, old_inst.castTag(.declval).?),
+        .single_mut_ptr_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.single_mut_ptr_type).?, true, .One),
-        .ensure_result_used => return analyzeInstEnsureResultUsed(mod, scope, old_inst.castTag(.ensure_result_used).?),
+        .many_const_ptr_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.many_const_ptr_type).?, false, .Many),
-        .ensure_result_non_error => return analyzeInstEnsureResultNonError(mod, scope, old_inst.castTag(.ensure_result_non_error).?),
+        .many_mut_ptr_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.many_mut_ptr_type).?, true, .Many),
-        .indexable_ptr_len => return indexablePtrLen(mod, scope, old_inst.castTag(.indexable_ptr_len).?),
+        .c_const_ptr_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.c_const_ptr_type).?, false, .C),
-        .ref => return ref(mod, scope, old_inst.castTag(.ref).?),
+        .c_mut_ptr_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.c_mut_ptr_type).?, true, .C),
-        .resolve_inferred_alloc => return analyzeInstResolveInferredAlloc(mod, scope, old_inst.castTag(.resolve_inferred_alloc).?),
+        .const_slice_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.const_slice_type).?, false, .Slice),
-        .ret_ptr => return analyzeInstRetPtr(mod, scope, old_inst.castTag(.ret_ptr).?),
+        .mut_slice_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.mut_slice_type).?, true, .Slice),
-        .ret_type => return analyzeInstRetType(mod, scope, old_inst.castTag(.ret_type).?),
+        .ptr_type => return zirPtrType(mod, scope, old_inst.castTag(.ptr_type).?),
-        .store_to_inferred_ptr => return analyzeInstStoreToInferredPtr(mod, scope, old_inst.castTag(.store_to_inferred_ptr).?),
+        .store => return zirStore(mod, scope, old_inst.castTag(.store).?),
-        .single_const_ptr_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.single_const_ptr_type).?, false, .One),
+        .set_eval_branch_quota => return zirSetEvalBranchQuota(mod, scope, old_inst.castTag(.set_eval_branch_quota).?),
-        .single_mut_ptr_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.single_mut_ptr_type).?, true, .One),
+        .str => return zirStr(mod, scope, old_inst.castTag(.str).?),
-        .many_const_ptr_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.many_const_ptr_type).?, false, .Many),
+        .int => return zirInt(mod, scope, old_inst.castTag(.int).?),
-        .many_mut_ptr_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.many_mut_ptr_type).?, true, .Many),
+        .int_type => return zirIntType(mod, scope, old_inst.castTag(.int_type).?),
-        .c_const_ptr_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.c_const_ptr_type).?, false, .C),
+        .loop => return zirLoop(mod, scope, old_inst.castTag(.loop).?),
-        .c_mut_ptr_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.c_mut_ptr_type).?, true, .C),
+        .param_type => return zirParamType(mod, scope, old_inst.castTag(.param_type).?),
-        .const_slice_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.const_slice_type).?, false, .Slice),
+        .ptrtoint => return zirPtrtoint(mod, scope, old_inst.castTag(.ptrtoint).?),
-        .mut_slice_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.mut_slice_type).?, true, .Slice),
+        .field_ptr => return zirFieldPtr(mod, scope, old_inst.castTag(.field_ptr).?),
-        .ptr_type => return analyzeInstPtrType(mod, scope, old_inst.castTag(.ptr_type).?),
+        .field_val => return zirFieldVal(mod, scope, old_inst.castTag(.field_val).?),
-        .store => return analyzeInstStore(mod, scope, old_inst.castTag(.store).?),
+        .field_ptr_named => return zirFieldPtrNamed(mod, scope, old_inst.castTag(.field_ptr_named).?),
-        .set_eval_branch_quota => return analyzeInstSetEvalBranchQuota(mod, scope, old_inst.castTag(.set_eval_branch_quota).?),
+        .field_val_named => return zirFieldValNamed(mod, scope, old_inst.castTag(.field_val_named).?),
-        .str => return analyzeInstStr(mod, scope, old_inst.castTag(.str).?),
+        .deref => return zirDeref(mod, scope, old_inst.castTag(.deref).?),
-        .int => return analyzeInstInt(mod, scope, old_inst.castTag(.int).?),
+        .as => return zirAs(mod, scope, old_inst.castTag(.as).?),
-        .inttype => return analyzeInstIntType(mod, scope, old_inst.castTag(.inttype).?),
+        .@"asm" => return zirAsm(mod, scope, old_inst.castTag(.@"asm").?),
-        .loop => return analyzeInstLoop(mod, scope, old_inst.castTag(.loop).?),
+        .unreachable_safe => return zirUnreachable(mod, scope, old_inst.castTag(.unreachable_safe).?, true),
-        .param_type => return analyzeInstParamType(mod, scope, old_inst.castTag(.param_type).?),
+        .unreachable_unsafe => return zirUnreachable(mod, scope, old_inst.castTag(.unreachable_unsafe).?, false),
-        .ptrtoint => return analyzeInstPtrToInt(mod, scope, old_inst.castTag(.ptrtoint).?),
+        .@"return" => return zirReturn(mod, scope, old_inst.castTag(.@"return").?),
-        .field_ptr => return fieldPtr(mod, scope, old_inst.castTag(.field_ptr).?),
+        .return_void => return zirReturnVoid(mod, scope, old_inst.castTag(.return_void).?),
-        .field_val => return fieldVal(mod, scope, old_inst.castTag(.field_val).?),
+        .@"fn" => return zirFn(mod, scope, old_inst.castTag(.@"fn").?),
-        .field_ptr_named => return fieldPtrNamed(mod, scope, old_inst.castTag(.field_ptr_named).?),
+        .@"export" => return zirExport(mod, scope, old_inst.castTag(.@"export").?),
-        .field_val_named => return fieldValNamed(mod, scope, old_inst.castTag(.field_val_named).?),
+        .primitive => return zirPrimitive(mod, scope, old_inst.castTag(.primitive).?),
-        .deref => return analyzeInstDeref(mod, scope, old_inst.castTag(.deref).?),
+        .fntype => return zirFnType(mod, scope, old_inst.castTag(.fntype).?),
-        .as => return analyzeInstAs(mod, scope, old_inst.castTag(.as).?),
+        .intcast => return zirIntcast(mod, scope, old_inst.castTag(.intcast).?),
-        .@"asm" => return analyzeInstAsm(mod, scope, old_inst.castTag(.@"asm").?),
+        .bitcast => return zirBitcast(mod, scope, old_inst.castTag(.bitcast).?),
-        .@"unreachable" => return analyzeInstUnreachable(mod, scope, old_inst.castTag(.@"unreachable").?, true),
+        .floatcast => return zirFloatcast(mod, scope, old_inst.castTag(.floatcast).?),
-        .unreach_nocheck => return analyzeInstUnreachable(mod, scope, old_inst.castTag(.unreach_nocheck).?, false),
+        .elem_ptr => return zirElemPtr(mod, scope, old_inst.castTag(.elem_ptr).?),
-        .@"return" => return analyzeInstRet(mod, scope, old_inst.castTag(.@"return").?),
+        .elem_val => return zirElemVal(mod, scope, old_inst.castTag(.elem_val).?),
-        .returnvoid => return analyzeInstRetVoid(mod, scope, old_inst.castTag(.returnvoid).?),
+        .add => return zirArithmetic(mod, scope, old_inst.castTag(.add).?),
-        .@"fn" => return analyzeInstFn(mod, scope, old_inst.castTag(.@"fn").?),
+        .addwrap => return zirArithmetic(mod, scope, old_inst.castTag(.addwrap).?),
-        .@"export" => return analyzeInstExport(mod, scope, old_inst.castTag(.@"export").?),
+        .sub => return zirArithmetic(mod, scope, old_inst.castTag(.sub).?),
-        .primitive => return analyzeInstPrimitive(mod, scope, old_inst.castTag(.primitive).?),
+        .subwrap => return zirArithmetic(mod, scope, old_inst.castTag(.subwrap).?),
-        .fntype => return analyzeInstFnType(mod, scope, old_inst.castTag(.fntype).?),
+        .mul => return zirArithmetic(mod, scope, old_inst.castTag(.mul).?),
-        .intcast => return analyzeInstIntCast(mod, scope, old_inst.castTag(.intcast).?),
+        .mulwrap => return zirArithmetic(mod, scope, old_inst.castTag(.mulwrap).?),
-        .bitcast => return analyzeInstBitCast(mod, scope, old_inst.castTag(.bitcast).?),
+        .div => return zirArithmetic(mod, scope, old_inst.castTag(.div).?),
-        .floatcast => return analyzeInstFloatCast(mod, scope, old_inst.castTag(.floatcast).?),
+        .mod_rem => return zirArithmetic(mod, scope, old_inst.castTag(.mod_rem).?),
-        .elem_ptr => return elemPtr(mod, scope, old_inst.castTag(.elem_ptr).?),
+        .array_cat => return zirArrayCat(mod, scope, old_inst.castTag(.array_cat).?),
-        .elem_val => return elemVal(mod, scope, old_inst.castTag(.elem_val).?),
+        .array_mul => return zirArrayMul(mod, scope, old_inst.castTag(.array_mul).?),
-        .add => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.add).?),
+        .bit_and => return zirBitwise(mod, scope, old_inst.castTag(.bit_and).?),
-        .addwrap => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.addwrap).?),
+        .bit_not => return zirBitNot(mod, scope, old_inst.castTag(.bit_not).?),
-        .sub => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.sub).?),
+        .bit_or => return zirBitwise(mod, scope, old_inst.castTag(.bit_or).?),
-        .subwrap => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.subwrap).?),
+        .xor => return zirBitwise(mod, scope, old_inst.castTag(.xor).?),
-        .mul => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.mul).?),
+        .shl => return zirShl(mod, scope, old_inst.castTag(.shl).?),
-        .mulwrap => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.mulwrap).?),
+        .shr => return zirShr(mod, scope, old_inst.castTag(.shr).?),
-        .div => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.div).?),
+        .cmp_lt => return zirCmp(mod, scope, old_inst.castTag(.cmp_lt).?, .lt),
-        .mod_rem => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.mod_rem).?),
+        .cmp_lte => return zirCmp(mod, scope, old_inst.castTag(.cmp_lte).?, .lte),
-        .array_cat => return analyzeInstArrayCat(mod, scope, old_inst.castTag(.array_cat).?),
+        .cmp_eq => return zirCmp(mod, scope, old_inst.castTag(.cmp_eq).?, .eq),
-        .array_mul => return analyzeInstArrayMul(mod, scope, old_inst.castTag(.array_mul).?),
+        .cmp_gte => return zirCmp(mod, scope, old_inst.castTag(.cmp_gte).?, .gte),
-        .bitand => return analyzeInstBitwise(mod, scope, old_inst.castTag(.bitand).?),
+        .cmp_gt => return zirCmp(mod, scope, old_inst.castTag(.cmp_gt).?, .gt),
-        .bitnot => return analyzeInstBitNot(mod, scope, old_inst.castTag(.bitnot).?),
+        .cmp_neq => return zirCmp(mod, scope, old_inst.castTag(.cmp_neq).?, .neq),
-        .bitor => return analyzeInstBitwise(mod, scope, old_inst.castTag(.bitor).?),
+        .condbr => return zirCondbr(mod, scope, old_inst.castTag(.condbr).?),
-        .xor => return analyzeInstBitwise(mod, scope, old_inst.castTag(.xor).?),
+        .is_null => return zirIsNull(mod, scope, old_inst.castTag(.is_null).?, false),
-        .shl => return analyzeInstShl(mod, scope, old_inst.castTag(.shl).?),
+        .is_non_null => return zirIsNull(mod, scope, old_inst.castTag(.is_non_null).?, true),
-        .shr => return analyzeInstShr(mod, scope, old_inst.castTag(.shr).?),
+        .is_null_ptr => return zirIsNullPtr(mod, scope, old_inst.castTag(.is_null_ptr).?, false),
-        .cmp_lt => return analyzeInstCmp(mod, scope, old_inst.castTag(.cmp_lt).?, .lt),
+        .is_non_null_ptr => return zirIsNullPtr(mod, scope, old_inst.castTag(.is_non_null_ptr).?, true),
-        .cmp_lte => return analyzeInstCmp(mod, scope, old_inst.castTag(.cmp_lte).?, .lte),
+        .is_err => return zirIsErr(mod, scope, old_inst.castTag(.is_err).?),
-        .cmp_eq => return analyzeInstCmp(mod, scope, old_inst.castTag(.cmp_eq).?, .eq),
+        .is_err_ptr => return zirIsErrPtr(mod, scope, old_inst.castTag(.is_err_ptr).?),
-        .cmp_gte => return analyzeInstCmp(mod, scope, old_inst.castTag(.cmp_gte).?, .gte),
+        .bool_not => return zirBoolNot(mod, scope, old_inst.castTag(.bool_not).?),
-        .cmp_gt => return analyzeInstCmp(mod, scope, old_inst.castTag(.cmp_gt).?, .gt),
+        .typeof => return zirTypeof(mod, scope, old_inst.castTag(.typeof).?),
-        .cmp_neq => return analyzeInstCmp(mod, scope, old_inst.castTag(.cmp_neq).?, .neq),
+        .typeof_peer => return zirTypeofPeer(mod, scope, old_inst.castTag(.typeof_peer).?),
-        .condbr => return analyzeInstCondBr(mod, scope, old_inst.castTag(.condbr).?),
+        .optional_type => return zirOptionalType(mod, scope, old_inst.castTag(.optional_type).?),
-        .is_null => return isNull(mod, scope, old_inst.castTag(.is_null).?, false),
+        .optional_payload_safe => return zirOptionalPayload(mod, scope, old_inst.castTag(.optional_payload_safe).?, true),
-        .is_non_null => return isNull(mod, scope, old_inst.castTag(.is_non_null).?, true),
+        .optional_payload_unsafe => return zirOptionalPayload(mod, scope, old_inst.castTag(.optional_payload_unsafe).?, false),
-        .is_null_ptr => return isNullPtr(mod, scope, old_inst.castTag(.is_null_ptr).?, false),
+        .optional_payload_safe_ptr => return zirOptionalPayloadPtr(mod, scope, old_inst.castTag(.optional_payload_safe_ptr).?, true),
-        .is_non_null_ptr => return isNullPtr(mod, scope, old_inst.castTag(.is_non_null_ptr).?, true),
+        .optional_payload_unsafe_ptr => return zirOptionalPayloadPtr(mod, scope, old_inst.castTag(.optional_payload_unsafe_ptr).?, false),
-        .is_err => return isErr(mod, scope, old_inst.castTag(.is_err).?),
+        .err_union_payload_safe => return zirErrUnionPayload(mod, scope, old_inst.castTag(.err_union_payload_safe).?, true),
-        .is_err_ptr => return isErrPtr(mod, scope, old_inst.castTag(.is_err_ptr).?),
+        .err_union_payload_unsafe => return zirErrUnionPayload(mod, scope, old_inst.castTag(.err_union_payload_unsafe).?, false),
-        .boolnot => return analyzeInstBoolNot(mod, scope, old_inst.castTag(.boolnot).?),
+        .err_union_payload_safe_ptr => return zirErrUnionPayloadPtr(mod, scope, old_inst.castTag(.err_union_payload_safe_ptr).?, true),
-        .typeof => return analyzeInstTypeOf(mod, scope, old_inst.castTag(.typeof).?),
+        .err_union_payload_unsafe_ptr => return zirErrUnionPayloadPtr(mod, scope, old_inst.castTag(.err_union_payload_unsafe_ptr).?, false),
-        .typeof_peer => return analyzeInstTypeOfPeer(mod, scope, old_inst.castTag(.typeof_peer).?),
+        .err_union_code => return zirErrUnionCode(mod, scope, old_inst.castTag(.err_union_code).?),
-        .optional_type => return analyzeInstOptionalType(mod, scope, old_inst.castTag(.optional_type).?),
+        .err_union_code_ptr => return zirErrUnionCodePtr(mod, scope, old_inst.castTag(.err_union_code_ptr).?),
-        .optional_payload_safe => return optionalPayload(mod, scope, old_inst.castTag(.optional_payload_safe).?, true),
+        .ensure_err_payload_void => return zirEnsureErrPayloadVoid(mod, scope, old_inst.castTag(.ensure_err_payload_void).?),
-        .optional_payload_unsafe => return optionalPayload(mod, scope, old_inst.castTag(.optional_payload_unsafe).?, false),
+        .array_type => return zirArrayType(mod, scope, old_inst.castTag(.array_type).?),
-        .optional_payload_safe_ptr => return optionalPayloadPtr(mod, scope, old_inst.castTag(.optional_payload_safe_ptr).?, true),
+        .array_type_sentinel => return zirArrayTypeSentinel(mod, scope, old_inst.castTag(.array_type_sentinel).?),
-        .optional_payload_unsafe_ptr => return optionalPayloadPtr(mod, scope, old_inst.castTag(.optional_payload_unsafe_ptr).?, false),
+        .enum_literal => return zirEnumLiteral(mod, scope, old_inst.castTag(.enum_literal).?),
-        .err_union_payload_safe => return errorUnionPayload(mod, scope, old_inst.castTag(.err_union_payload_safe).?, true),
+        .merge_error_sets => return zirMergeErrorSets(mod, scope, old_inst.castTag(.merge_error_sets).?),
-        .err_union_payload_unsafe => return errorUnionPayload(mod, scope, old_inst.castTag(.err_union_payload_unsafe).?, false),
+        .error_union_type => return zirErrorUnionType(mod, scope, old_inst.castTag(.error_union_type).?),
-        .err_union_payload_safe_ptr => return errorUnionPayloadPtr(mod, scope, old_inst.castTag(.err_union_payload_safe_ptr).?, true),
+        .anyframe_type => return zirAnyframeType(mod, scope, old_inst.castTag(.anyframe_type).?),
-        .err_union_payload_unsafe_ptr => return errorUnionPayloadPtr(mod, scope, old_inst.castTag(.err_union_payload_unsafe_ptr).?, false),
+        .error_set => return zirErrorSet(mod, scope, old_inst.castTag(.error_set).?),
-        .err_union_code => return errorUnionCode(mod, scope, old_inst.castTag(.err_union_code).?),
+        .slice => return zirSlice(mod, scope, old_inst.castTag(.slice).?),
-        .err_union_code_ptr => return errorUnionCodePtr(mod, scope, old_inst.castTag(.err_union_code_ptr).?),
+        .slice_start => return zirSliceStart(mod, scope, old_inst.castTag(.slice_start).?),
-        .ensure_err_payload_void => return analyzeInstEnsureErrPayloadVoid(mod, scope, old_inst.castTag(.ensure_err_payload_void).?),
+        .import => return zirImport(mod, scope, old_inst.castTag(.import).?),
-        .array_type => return analyzeInstArrayType(mod, scope, old_inst.castTag(.array_type).?),
+        .switchbr => return zirSwitchbr(mod, scope, old_inst.castTag(.switchbr).?),
-        .array_type_sentinel => return analyzeInstArrayTypeSentinel(mod, scope, old_inst.castTag(.array_type_sentinel).?),
+        .switch_range => return zirSwitchRange(mod, scope, old_inst.castTag(.switch_range).?),
-        .enum_literal => return analyzeInstEnumLiteral(mod, scope, old_inst.castTag(.enum_literal).?),
+        .bool_and => return zirBoolOp(mod, scope, old_inst.castTag(.bool_and).?),
-        .merge_error_sets => return analyzeInstMergeErrorSets(mod, scope, old_inst.castTag(.merge_error_sets).?),
+        .bool_or => return zirBoolOp(mod, scope, old_inst.castTag(.bool_or).?),
-        .error_union_type => return analyzeInstErrorUnionType(mod, scope, old_inst.castTag(.error_union_type).?),
-        .anyframe_type => return analyzeInstAnyframeType(mod, scope, old_inst.castTag(.anyframe_type).?),
-        .error_set => return analyzeInstErrorSet(mod, scope, old_inst.castTag(.error_set).?),
-        .slice => return analyzeInstSlice(mod, scope, old_inst.castTag(.slice).?),
-        .slice_start => return analyzeInstSliceStart(mod, scope, old_inst.castTag(.slice_start).?),
-        .import => return analyzeInstImport(mod, scope, old_inst.castTag(.import).?),
-        .switchbr => return analyzeInstSwitchBr(mod, scope, old_inst.castTag(.switchbr).?),
-        .switch_range => return analyzeInstSwitchRange(mod, scope, old_inst.castTag(.switch_range).?),
-        .booland => return analyzeInstBoolOp(mod, scope, old_inst.castTag(.booland).?),
-        .boolor => return analyzeInstBoolOp(mod, scope, old_inst.castTag(.boolor).?),
         .container_field_named,
         .container_field_typed,
 @@ -258,7 +248,7 @@ pub fn resolveInstConst(mod: *Module, scope: *Scope, old_inst: *zir.Inst) InnerE
     };
 }
-fn analyzeInstConst(mod: *Module, scope: *Scope, const_inst: *zir.Inst.Const) InnerError!*Inst {
+fn zirConst(mod: *Module, scope: *Scope, const_inst: *zir.Inst.Const) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     // Move the TypedValue from old memory to new memory. This allows freeing the ZIR instructions
 @@ -275,44 +265,35 @@ fn analyzeConstInst(mod: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError
     };
 }
-fn analyzeInstCoerceResultBlockPtr(
+fn zirCoerceResultBlockPtr(
     mod: *Module,
     scope: *Scope,
     inst: *zir.Inst.CoerceResultBlockPtr,
 ) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, inst.base.src, "TODO implement analyzeInstCoerceResultBlockPtr", .{});
+    return mod.fail(scope, inst.base.src, "TODO implement zirCoerceResultBlockPtr", .{});
 }
-fn bitCastRef(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirBitcastRef(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, inst.base.src, "TODO implement zir_sema.bitCastRef", .{});
+    return mod.fail(scope, inst.base.src, "TODO implement zir_sema.zirBitcastRef", .{});
 }
-fn bitCastResultPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirBitcastResultPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, inst.base.src, "TODO implement zir_sema.bitCastResultPtr", .{});
+    return mod.fail(scope, inst.base.src, "TODO implement zir_sema.zirBitcastResultPtr", .{});
 }
-fn analyzeInstCoerceResultPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirCoerceResultPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, inst.base.src, "TODO implement analyzeInstCoerceResultPtr", .{});
+    return mod.fail(scope, inst.base.src, "TODO implement zirCoerceResultPtr", .{});
 }
-/// Equivalent to `as(ptr_child_type(typeof(ptr)), value)`.
+fn zirRetPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerError!*Inst {
-fn analyzeInstCoerceToPtrElem(mod: *Module, scope: *Scope, inst: *zir.Inst.CoerceToPtrElem) InnerError!*Inst {
-    const tracy = trace(@src());
-    defer tracy.end();
-    const ptr = try resolveInst(mod, scope, inst.positionals.ptr);
-    const operand = try resolveInst(mod, scope, inst.positionals.value);
-    return mod.coerce(scope, ptr.ty.elemType(), operand);
-}
-fn analyzeInstRetPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const b = try mod.requireFunctionBlock(scope, inst.base.src);
 @@ -322,7 +303,7 @@ fn analyzeInstRetPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerErr
     return mod.addNoOp(b, inst.base.src, ptr_type, .alloc);
 }
-fn ref(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirRef(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -330,7 +311,7 @@ fn ref(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     return mod.analyzeRef(scope, inst.base.src, operand);
 }
-fn analyzeInstRetType(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerError!*Inst {
+fn zirRetType(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const b = try mod.requireFunctionBlock(scope, inst.base.src);
 @@ -339,7 +320,7 @@ fn analyzeInstRetType(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerEr
     return mod.constType(scope, inst.base.src, ret_type);
 }
-fn analyzeInstEnsureResultUsed(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirEnsureResultUsed(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const operand = try resolveInst(mod, scope, inst.positionals.operand);
 @@ -349,7 +330,7 @@ fn analyzeInstEnsureResultUsed(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp
     }
 }
-fn analyzeInstEnsureResultNonError(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirEnsureResultNonError(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const operand = try resolveInst(mod, scope, inst.positionals.operand);
 @@ -359,7 +340,7 @@ fn analyzeInstEnsureResultNonError(mod: *Module, scope: *Scope, inst: *zir.Inst.
     }
 }
-fn indexablePtrLen(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirIndexablePtrLen(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -389,7 +370,7 @@ fn indexablePtrLen(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError
     return mod.analyzeDeref(scope, inst.base.src, result_ptr, result_ptr.src);
 }
-fn analyzeInstAlloc(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirAlloc(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const var_type = try resolveType(mod, scope, inst.positionals.operand);
 @@ -398,7 +379,7 @@ fn analyzeInstAlloc(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerErro
     return mod.addNoOp(b, inst.base.src, ptr_type, .alloc);
 }
-fn analyzeInstAllocMut(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirAllocMut(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const var_type = try resolveType(mod, scope, inst.positionals.operand);
 @@ -408,7 +389,7 @@ fn analyzeInstAllocMut(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerE
     return mod.addNoOp(b, inst.base.src, ptr_type, .alloc);
 }
-fn analyzeInstAllocInferred(
+fn zirAllocInferred(
     mod: *Module,
     scope: *Scope,
     inst: *zir.Inst.NoOp,
 @@ -437,7 +418,7 @@ fn analyzeInstAllocInferred(
     return result;
 }
-fn analyzeInstResolveInferredAlloc(
+fn zirResolveInferredAlloc(
     mod: *Module,
     scope: *Scope,
     inst: *zir.Inst.UnOp,
 @@ -466,28 +447,44 @@ fn analyzeInstResolveInferredAlloc(
     return mod.constVoid(scope, inst.base.src);
 }
-fn analyzeInstStoreToInferredPtr(
+fn zirStoreToBlockPtr(
+    mod: *Module,
+    scope: *Scope,
+    inst: *zir.Inst.BinOp,
+) InnerError!*Inst {
+    const tracy = trace(@src());
+    defer tracy.end();
+    const ptr = try resolveInst(mod, scope, inst.positionals.lhs);
+    const value = try resolveInst(mod, scope, inst.positionals.rhs);
+    const ptr_ty = try mod.simplePtrType(scope, inst.base.src, value.ty, true, .One);
+    const b = try mod.requireRuntimeBlock(scope, inst.base.src);
+    const bitcasted_ptr = try mod.addUnOp(b, inst.base.src, ptr_ty, .bitcast, ptr);
+    return mod.storePtr(scope, inst.base.src, bitcasted_ptr, value);
+}
+fn zirStoreToInferredPtr(
     mod: *Module,
     scope: *Scope,
     inst: *zir.Inst.BinOp,
 ) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const ptr = try resolveInst(mod, scope, inst.positionals.lhs);
     const value = try resolveInst(mod, scope, inst.positionals.rhs);
     const inferred_alloc = ptr.castTag(.constant).?.val.castTag(.inferred_alloc).?;
     // Add the stored instruction to the set we will use to resolve peer types
     // for the inferred allocation.
     try inferred_alloc.data.stored_inst_list.append(scope.arena(), value);
-    // Create a new alloc with exactly the type the pointer wants.
+    // Create a runtime bitcast instruction with exactly the type the pointer wants.
-    // Later it gets cleaned up by aliasing the alloc we are supposed to be storing to.
     const ptr_ty = try mod.simplePtrType(scope, inst.base.src, value.ty, true, .One);
     const b = try mod.requireRuntimeBlock(scope, inst.base.src);
     const bitcasted_ptr = try mod.addUnOp(b, inst.base.src, ptr_ty, .bitcast, ptr);
     return mod.storePtr(scope, inst.base.src, bitcasted_ptr, value);
 }
-fn analyzeInstSetEvalBranchQuota(
+fn zirSetEvalBranchQuota(
     mod: *Module,
     scope: *Scope,
     inst: *zir.Inst.UnOp,
 @@ -499,15 +496,16 @@ fn analyzeInstSetEvalBranchQuota(
     return mod.constVoid(scope, inst.base.src);
 }
-fn analyzeInstStore(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirStore(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const ptr = try resolveInst(mod, scope, inst.positionals.lhs);
     const value = try resolveInst(mod, scope, inst.positionals.rhs);
     return mod.storePtr(scope, inst.base.src, ptr, value);
 }
-fn analyzeInstParamType(mod: *Module, scope: *Scope, inst: *zir.Inst.ParamType) InnerError!*Inst {
+fn zirParamType(mod: *Module, scope: *Scope, inst: *zir.Inst.ParamType) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const fn_inst = try resolveInst(mod, scope, inst.positionals.func);
 @@ -516,7 +514,7 @@ fn analyzeInstParamType(mod: *Module, scope: *Scope, inst: *zir.Inst.ParamType)
     const fn_ty: Type = switch (fn_inst.ty.zigTypeTag()) {
         .Fn => fn_inst.ty,
         .BoundFn => {
-            return mod.fail(scope, fn_inst.src, "TODO implement analyzeInstParamType for method call syntax", .{});
+            return mod.fail(scope, fn_inst.src, "TODO implement zirParamType for method call syntax", .{});
         },
         else => {
             return mod.fail(scope, fn_inst.src, "expected function, found '{}'", .{fn_inst.ty});
 @@ -538,7 +536,7 @@ fn analyzeInstParamType(mod: *Module, scope: *Scope, inst: *zir.Inst.ParamType)
     return mod.constType(scope, inst.base.src, param_type);
 }
-fn analyzeInstStr(mod: *Module, scope: *Scope, str_inst: *zir.Inst.Str) InnerError!*Inst {
+fn zirStr(mod: *Module, scope: *Scope, str_inst: *zir.Inst.Str) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     // The bytes references memory inside the ZIR module, which can get deallocated
 @@ -557,14 +555,14 @@ fn analyzeInstStr(mod: *Module, scope: *Scope, str_inst: *zir.Inst.Str) InnerErr
     return mod.analyzeDeclRef(scope, str_inst.base.src, new_decl);
 }
-fn analyzeInstInt(mod: *Module, scope: *Scope, inst: *zir.Inst.Int) InnerError!*Inst {
+fn zirInt(mod: *Module, scope: *Scope, inst: *zir.Inst.Int) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     return mod.constIntBig(scope, inst.base.src, Type.initTag(.comptime_int), inst.positionals.int);
 }
-fn analyzeInstExport(mod: *Module, scope: *Scope, export_inst: *zir.Inst.Export) InnerError!*Inst {
+fn zirExport(mod: *Module, scope: *Scope, export_inst: *zir.Inst.Export) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const symbol_name = try resolveConstString(mod, scope, export_inst.positionals.symbol_name);
 @@ -574,14 +572,14 @@ fn analyzeInstExport(mod: *Module, scope: *Scope, export_inst: *zir.Inst.Export)
     return mod.constVoid(scope, export_inst.base.src);
 }
-fn analyzeInstCompileError(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirCompileError(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const msg = try resolveConstString(mod, scope, inst.positionals.operand);
     return mod.fail(scope, inst.base.src, "{s}", .{msg});
 }
-fn analyzeInstCompileLog(mod: *Module, scope: *Scope, inst: *zir.Inst.CompileLog) InnerError!*Inst {
+fn zirCompileLog(mod: *Module, scope: *Scope, inst: *zir.Inst.CompileLog) InnerError!*Inst {
     var managed = mod.compile_log_text.toManaged(mod.gpa);
     defer mod.compile_log_text = managed.moveToUnmanaged();
     const writer = managed.writer();
 @@ -608,7 +606,7 @@ fn analyzeInstCompileLog(mod: *Module, scope: *Scope, inst: *zir.Inst.CompileLog
     return mod.constVoid(scope, inst.base.src);
 }
-fn analyzeInstArg(mod: *Module, scope: *Scope, inst: *zir.Inst.Arg) InnerError!*Inst {
+fn zirArg(mod: *Module, scope: *Scope, inst: *zir.Inst.Arg) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const b = try mod.requireFunctionBlock(scope, inst.base.src);
 @@ -631,7 +629,7 @@ fn analyzeInstArg(mod: *Module, scope: *Scope, inst: *zir.Inst.Arg) InnerError!*
     return mod.addArg(b, inst.base.src, param_type, name);
 }
-fn analyzeInstLoop(mod: *Module, scope: *Scope, inst: *zir.Inst.Loop) InnerError!*Inst {
+fn zirLoop(mod: *Module, scope: *Scope, inst: *zir.Inst.Loop) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const parent_block = scope.cast(Scope.Block).?;
 @@ -672,7 +670,7 @@ fn analyzeInstLoop(mod: *Module, scope: *Scope, inst: *zir.Inst.Loop) InnerError
     return &loop_inst.base;
 }
-fn analyzeInstBlockFlat(mod: *Module, scope: *Scope, inst: *zir.Inst.Block, is_comptime: bool) InnerError!*Inst {
+fn zirBlockFlat(mod: *Module, scope: *Scope, inst: *zir.Inst.Block, is_comptime: bool) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const parent_block = scope.cast(Scope.Block).?;
 @@ -704,9 +702,15 @@ fn analyzeInstBlockFlat(mod: *Module, scope: *Scope, inst: *zir.Inst.Block, is_c
     return resolveInst(mod, scope, last_zir_inst);
 }
-fn analyzeInstBlock(mod: *Module, scope: *Scope, inst: *zir.Inst.Block, is_comptime: bool) InnerError!*Inst {
+fn zirBlock(
+    mod: *Module,
+    scope: *Scope,
+    inst: *zir.Inst.Block,
+    is_comptime: bool,
+) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const parent_block = scope.cast(Scope.Block).?;
     // Reserve space for a Block instruction so that generated Break instructions can
 @@ -798,30 +802,52 @@ fn analyzeBlockBody(
     return &merges.block_inst.base;
 }
-fn analyzeInstBreakpoint(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerError!*Inst {
+fn zirBreakpoint(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const b = try mod.requireRuntimeBlock(scope, inst.base.src);
     return mod.addNoOp(b, inst.base.src, Type.initTag(.void), .breakpoint);
 }
-fn analyzeInstBreak(mod: *Module, scope: *Scope, inst: *zir.Inst.Break) InnerError!*Inst {
+fn zirBreak(mod: *Module, scope: *Scope, inst: *zir.Inst.Break) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const operand = try resolveInst(mod, scope, inst.positionals.operand);
     const block = inst.positionals.block;
     return analyzeBreak(mod, scope, inst.base.src, block, operand);
 }
-fn analyzeInstBreakVoid(mod: *Module, scope: *Scope, inst: *zir.Inst.BreakVoid) InnerError!*Inst {
+fn zirBreakVoid(mod: *Module, scope: *Scope, inst: *zir.Inst.BreakVoid) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const block = inst.positionals.block;
     const void_inst = try mod.constVoid(scope, inst.base.src);
     return analyzeBreak(mod, scope, inst.base.src, block, void_inst);
 }
-fn analyzeInstDbgStmt(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerError!*Inst {
+fn analyzeBreak(
+    mod: *Module,
+    scope: *Scope,
+    src: usize,
+    zir_block: *zir.Inst.Block,
+    operand: *Inst,
+) InnerError!*Inst {
+    var opt_block = scope.cast(Scope.Block);
+    while (opt_block) |block| {
+        if (block.label) |*label| {
+            if (label.zir_block == zir_block) {
+                try label.merges.results.append(mod.gpa, operand);
+                const b = try mod.requireFunctionBlock(scope, src);
+                return mod.addBr(b, src, label.merges.block_inst, operand);
+            }
+        }
+        opt_block = block.parent;
+    } else unreachable;
+}
+fn zirDbgStmt(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     if (scope.cast(Scope.Block)) |b| {
 @@ -832,26 +858,26 @@ fn analyzeInstDbgStmt(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerEr
     return mod.constVoid(scope, inst.base.src);
 }
-fn analyzeInstDeclRefStr(mod: *Module, scope: *Scope, inst: *zir.Inst.DeclRefStr) InnerError!*Inst {
+fn zirDeclRefStr(mod: *Module, scope: *Scope, inst: *zir.Inst.DeclRefStr) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const decl_name = try resolveConstString(mod, scope, inst.positionals.name);
     return mod.analyzeDeclRefByName(scope, inst.base.src, decl_name);
 }
-fn declRef(mod: *Module, scope: *Scope, inst: *zir.Inst.DeclRef) InnerError!*Inst {
+fn zirDeclRef(mod: *Module, scope: *Scope, inst: *zir.Inst.DeclRef) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     return mod.analyzeDeclRef(scope, inst.base.src, inst.positionals.decl);
 }
-fn declVal(mod: *Module, scope: *Scope, inst: *zir.Inst.DeclVal) InnerError!*Inst {
+fn zirDeclVal(mod: *Module, scope: *Scope, inst: *zir.Inst.DeclVal) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     return mod.analyzeDeclVal(scope, inst.base.src, inst.positionals.decl);
 }
-fn call(mod: *Module, scope: *Scope, inst: *zir.Inst.Call) InnerError!*Inst {
+fn zirCall(mod: *Module, scope: *Scope, inst: *zir.Inst.Call) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1002,7 +1028,7 @@ fn call(mod: *Module, scope: *Scope, inst: *zir.Inst.Call) InnerError!*Inst {
     return mod.addCall(b, inst.base.src, ret_type, func, casted_args);
 }
-fn analyzeInstFn(mod: *Module, scope: *Scope, fn_inst: *zir.Inst.Fn) InnerError!*Inst {
+fn zirFn(mod: *Module, scope: *Scope, fn_inst: *zir.Inst.Fn) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const fn_type = try resolveType(mod, scope, fn_inst.positionals.fn_type);
 @@ -1019,13 +1045,13 @@ fn analyzeInstFn(mod: *Module, scope: *Scope, fn_inst: *zir.Inst.Fn) InnerError!
     });
 }
-fn analyzeInstIntType(mod: *Module, scope: *Scope, inttype: *zir.Inst.IntType) InnerError!*Inst {
+fn zirIntType(mod: *Module, scope: *Scope, inttype: *zir.Inst.IntType) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     return mod.fail(scope, inttype.base.src, "TODO implement inttype", .{});
 }
-fn analyzeInstOptionalType(mod: *Module, scope: *Scope, optional: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirOptionalType(mod: *Module, scope: *Scope, optional: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const child_type = try resolveType(mod, scope, optional.positionals.operand);
 @@ -1033,7 +1059,7 @@ fn analyzeInstOptionalType(mod: *Module, scope: *Scope, optional: *zir.Inst.UnOp
     return mod.constType(scope, optional.base.src, try mod.optionalType(scope, child_type));
 }
-fn analyzeInstArrayType(mod: *Module, scope: *Scope, array: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirArrayType(mod: *Module, scope: *Scope, array: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     // TODO these should be lazily evaluated
 @@ -1043,7 +1069,7 @@ fn analyzeInstArrayType(mod: *Module, scope: *Scope, array: *zir.Inst.BinOp) Inn
     return mod.constType(scope, array.base.src, try mod.arrayType(scope, len.val.toUnsignedInt(), null, elem_type));
 }
-fn analyzeInstArrayTypeSentinel(mod: *Module, scope: *Scope, array: *zir.Inst.ArrayTypeSentinel) InnerError!*Inst {
+fn zirArrayTypeSentinel(mod: *Module, scope: *Scope, array: *zir.Inst.ArrayTypeSentinel) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     // TODO these should be lazily evaluated
 @@ -1054,7 +1080,7 @@ fn analyzeInstArrayTypeSentinel(mod: *Module, scope: *Scope, array: *zir.Inst.Ar
     return mod.constType(scope, array.base.src, try mod.arrayType(scope, len.val.toUnsignedInt(), sentinel.val, elem_type));
 }
-fn analyzeInstErrorUnionType(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirErrorUnionType(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const error_union = try resolveType(mod, scope, inst.positionals.lhs);
 @@ -1067,7 +1093,7 @@ fn analyzeInstErrorUnionType(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp)
     return mod.constType(scope, inst.base.src, try mod.errorUnionType(scope, error_union, payload));
 }
-fn analyzeInstAnyframeType(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirAnyframeType(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const return_type = try resolveType(mod, scope, inst.positionals.operand);
 @@ -1075,7 +1101,7 @@ fn analyzeInstAnyframeType(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) In
     return mod.constType(scope, inst.base.src, try mod.anyframeType(scope, return_type));
 }
-fn analyzeInstErrorSet(mod: *Module, scope: *Scope, inst: *zir.Inst.ErrorSet) InnerError!*Inst {
+fn zirErrorSet(mod: *Module, scope: *Scope, inst: *zir.Inst.ErrorSet) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     // The declarations arena will store the hashmap.
 @@ -1107,13 +1133,13 @@ fn analyzeInstErrorSet(mod: *Module, scope: *Scope, inst: *zir.Inst.ErrorSet) In
     return mod.analyzeDeclVal(scope, inst.base.src, new_decl);
 }
-fn analyzeInstMergeErrorSets(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirMergeErrorSets(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     return mod.fail(scope, inst.base.src, "TODO implement merge_error_sets", .{});
 }
-fn analyzeInstEnumLiteral(mod: *Module, scope: *Scope, inst: *zir.Inst.EnumLiteral) InnerError!*Inst {
+fn zirEnumLiteral(mod: *Module, scope: *Scope, inst: *zir.Inst.EnumLiteral) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const duped_name = try scope.arena().dupe(u8, inst.positionals.name);
 @@ -1124,7 +1150,7 @@ fn analyzeInstEnumLiteral(mod: *Module, scope: *Scope, inst: *zir.Inst.EnumLiter
 }
 /// Pointer in, pointer out.
-fn optionalPayloadPtr(
+fn zirOptionalPayloadPtr(
     mod: *Module,
     scope: *Scope,
     unwrap: *zir.Inst.UnOp,
 @@ -1165,7 +1191,7 @@ fn optionalPayloadPtr(
 }
 /// Value in, value out.
-fn optionalPayload(
+fn zirOptionalPayload(
     mod: *Module,
     scope: *Scope,
     unwrap: *zir.Inst.UnOp,
 @@ -1201,40 +1227,40 @@ fn optionalPayload(
 }
 /// Value in, value out
-fn errorUnionPayload(mod: *Module, scope: *Scope, unwrap: *zir.Inst.UnOp, safety_check: bool) InnerError!*Inst {
+fn zirErrUnionPayload(mod: *Module, scope: *Scope, unwrap: *zir.Inst.UnOp, safety_check: bool) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, unwrap.base.src, "TODO implement zir_sema.errorUnionPayload", .{});
+    return mod.fail(scope, unwrap.base.src, "TODO implement zir_sema.zirErrUnionPayload", .{});
 }
 /// Pointer in, pointer out
-fn errorUnionPayloadPtr(mod: *Module, scope: *Scope, unwrap: *zir.Inst.UnOp, safety_check: bool) InnerError!*Inst {
+fn zirErrUnionPayloadPtr(mod: *Module, scope: *Scope, unwrap: *zir.Inst.UnOp, safety_check: bool) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, unwrap.base.src, "TODO implement zir_sema.errorUnionPayloadPtr", .{});
+    return mod.fail(scope, unwrap.base.src, "TODO implement zir_sema.zirErrUnionPayloadPtr", .{});
 }
 /// Value in, value out
-fn errorUnionCode(mod: *Module, scope: *Scope, unwrap: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirErrUnionCode(mod: *Module, scope: *Scope, unwrap: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, unwrap.base.src, "TODO implement zir_sema.errorUnionCode", .{});
+    return mod.fail(scope, unwrap.base.src, "TODO implement zir_sema.zirErrUnionCode", .{});
 }
 /// Pointer in, value out
-fn errorUnionCodePtr(mod: *Module, scope: *Scope, unwrap: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirErrUnionCodePtr(mod: *Module, scope: *Scope, unwrap: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, unwrap.base.src, "TODO implement zir_sema.errorUnionCodePtr", .{});
+    return mod.fail(scope, unwrap.base.src, "TODO implement zir_sema.zirErrUnionCodePtr", .{});
 }
-fn analyzeInstEnsureErrPayloadVoid(mod: *Module, scope: *Scope, unwrap: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirEnsureErrPayloadVoid(mod: *Module, scope: *Scope, unwrap: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, unwrap.base.src, "TODO implement analyzeInstEnsureErrPayloadVoid", .{});
+    return mod.fail(scope, unwrap.base.src, "TODO implement zirEnsureErrPayloadVoid", .{});
 }
-fn analyzeInstFnType(mod: *Module, scope: *Scope, fntype: *zir.Inst.FnType) InnerError!*Inst {
+fn zirFnType(mod: *Module, scope: *Scope, fntype: *zir.Inst.FnType) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const return_type = try resolveType(mod, scope, fntype.positionals.return_type);
 @@ -1277,13 +1303,13 @@ fn analyzeInstFnType(mod: *Module, scope: *Scope, fntype: *zir.Inst.FnType) Inne
     return mod.constType(scope, fntype.base.src, fn_ty);
 }
-fn analyzeInstPrimitive(mod: *Module, scope: *Scope, primitive: *zir.Inst.Primitive) InnerError!*Inst {
+fn zirPrimitive(mod: *Module, scope: *Scope, primitive: *zir.Inst.Primitive) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     return mod.constInst(scope, primitive.base.src, primitive.positionals.tag.toTypedValue());
 }
-fn analyzeInstAs(mod: *Module, scope: *Scope, as: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirAs(mod: *Module, scope: *Scope, as: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const dest_type = try resolveType(mod, scope, as.positionals.lhs);
 @@ -1291,7 +1317,7 @@ fn analyzeInstAs(mod: *Module, scope: *Scope, as: *zir.Inst.BinOp) InnerError!*I
     return mod.coerce(scope, dest_type, new_inst);
 }
-fn analyzeInstPtrToInt(mod: *Module, scope: *Scope, ptrtoint: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirPtrtoint(mod: *Module, scope: *Scope, ptrtoint: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const ptr = try resolveInst(mod, scope, ptrtoint.positionals.operand);
 @@ -1304,7 +1330,7 @@ fn analyzeInstPtrToInt(mod: *Module, scope: *Scope, ptrtoint: *zir.Inst.UnOp) In
     return mod.addUnOp(b, ptrtoint.base.src, ty, .ptrtoint, ptr);
 }
-fn fieldVal(mod: *Module, scope: *Scope, inst: *zir.Inst.Field) InnerError!*Inst {
+fn zirFieldVal(mod: *Module, scope: *Scope, inst: *zir.Inst.Field) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1315,7 +1341,7 @@ fn fieldVal(mod: *Module, scope: *Scope, inst: *zir.Inst.Field) InnerError!*Inst
     return mod.analyzeDeref(scope, inst.base.src, result_ptr, result_ptr.src);
 }
-fn fieldPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.Field) InnerError!*Inst {
+fn zirFieldPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.Field) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1324,7 +1350,7 @@ fn fieldPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.Field) InnerError!*Inst
     return mod.namedFieldPtr(scope, inst.base.src, object_ptr, field_name, inst.base.src);
 }
-fn fieldValNamed(mod: *Module, scope: *Scope, inst: *zir.Inst.FieldNamed) InnerError!*Inst {
+fn zirFieldValNamed(mod: *Module, scope: *Scope, inst: *zir.Inst.FieldNamed) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1336,7 +1362,7 @@ fn fieldValNamed(mod: *Module, scope: *Scope, inst: *zir.Inst.FieldNamed) InnerE
     return mod.analyzeDeref(scope, inst.base.src, result_ptr, result_ptr.src);
 }
-fn fieldPtrNamed(mod: *Module, scope: *Scope, inst: *zir.Inst.FieldNamed) InnerError!*Inst {
+fn zirFieldPtrNamed(mod: *Module, scope: *Scope, inst: *zir.Inst.FieldNamed) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1346,7 +1372,7 @@ fn fieldPtrNamed(mod: *Module, scope: *Scope, inst: *zir.Inst.FieldNamed) InnerE
     return mod.namedFieldPtr(scope, inst.base.src, object_ptr, field_name, fsrc);
 }
-fn analyzeInstIntCast(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirIntcast(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const dest_type = try resolveType(mod, scope, inst.positionals.lhs);
 @@ -1384,7 +1410,7 @@ fn analyzeInstIntCast(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerE
     return mod.fail(scope, inst.base.src, "TODO implement analyze widen or shorten int", .{});
 }
-fn analyzeInstBitCast(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirBitcast(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const dest_type = try resolveType(mod, scope, inst.positionals.lhs);
 @@ -1392,7 +1418,7 @@ fn analyzeInstBitCast(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerE
     return mod.bitcast(scope, dest_type, operand);
 }
-fn analyzeInstFloatCast(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirFloatcast(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const dest_type = try resolveType(mod, scope, inst.positionals.lhs);
 @@ -1430,7 +1456,7 @@ fn analyzeInstFloatCast(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) Inne
     return mod.fail(scope, inst.base.src, "TODO implement analyze widen or shorten float", .{});
 }
-fn elemVal(mod: *Module, scope: *Scope, inst: *zir.Inst.Elem) InnerError!*Inst {
+fn zirElemVal(mod: *Module, scope: *Scope, inst: *zir.Inst.Elem) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1441,7 +1467,7 @@ fn elemVal(mod: *Module, scope: *Scope, inst: *zir.Inst.Elem) InnerError!*Inst {
     return mod.analyzeDeref(scope, inst.base.src, result_ptr, result_ptr.src);
 }
-fn elemPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.Elem) InnerError!*Inst {
+fn zirElemPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.Elem) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1450,7 +1476,7 @@ fn elemPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.Elem) InnerError!*Inst {
     return mod.elemPtr(scope, inst.base.src, array_ptr, elem_index);
 }
-fn analyzeInstSlice(mod: *Module, scope: *Scope, inst: *zir.Inst.Slice) InnerError!*Inst {
+fn zirSlice(mod: *Module, scope: *Scope, inst: *zir.Inst.Slice) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const array_ptr = try resolveInst(mod, scope, inst.positionals.array_ptr);
 @@ -1461,7 +1487,7 @@ fn analyzeInstSlice(mod: *Module, scope: *Scope, inst: *zir.Inst.Slice) InnerErr
     return mod.analyzeSlice(scope, inst.base.src, array_ptr, start, end, sentinel);
 }
-fn analyzeInstSliceStart(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirSliceStart(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const array_ptr = try resolveInst(mod, scope, inst.positionals.lhs);
 @@ -1470,7 +1496,7 @@ fn analyzeInstSliceStart(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) Inn
     return mod.analyzeSlice(scope, inst.base.src, array_ptr, start, null, null);
 }
-fn analyzeInstSwitchRange(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirSwitchRange(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const start = try resolveInst(mod, scope, inst.positionals.lhs);
 @@ -1494,7 +1520,7 @@ fn analyzeInstSwitchRange(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) In
     return mod.constVoid(scope, inst.base.src);
 }
-fn analyzeInstSwitchBr(mod: *Module, scope: *Scope, inst: *zir.Inst.SwitchBr) InnerError!*Inst {
+fn zirSwitchbr(mod: *Module, scope: *Scope, inst: *zir.Inst.SwitchBr) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const target_ptr = try resolveInst(mod, scope, inst.positionals.target_ptr);
 @@ -1698,7 +1724,7 @@ fn validateSwitch(mod: *Module, scope: *Scope, target: *Inst, inst: *zir.Inst.Sw
     }
 }
-fn analyzeInstImport(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirImport(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const operand = try resolveConstString(mod, scope, inst.positionals.operand);
 @@ -1718,19 +1744,19 @@ fn analyzeInstImport(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerErr
     return mod.constType(scope, inst.base.src, file_scope.root_container.ty);
 }
-fn analyzeInstShl(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirShl(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, inst.base.src, "TODO implement analyzeInstShl", .{});
+    return mod.fail(scope, inst.base.src, "TODO implement zirShl", .{});
 }
-fn analyzeInstShr(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirShr(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, inst.base.src, "TODO implement analyzeInstShr", .{});
+    return mod.fail(scope, inst.base.src, "TODO implement zirShr", .{});
 }
-fn analyzeInstBitwise(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirBitwise(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1784,8 +1810,8 @@ fn analyzeInstBitwise(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerE
     const b = try mod.requireRuntimeBlock(scope, inst.base.src);
     const ir_tag = switch (inst.base.tag) {
-        .bitand => Inst.Tag.bitand,
+        .bit_and => Inst.Tag.bit_and,
-        .bitor => Inst.Tag.bitor,
+        .bit_or => Inst.Tag.bit_or,
         .xor => Inst.Tag.xor,
         else => unreachable,
     };
 @@ -1793,25 +1819,25 @@ fn analyzeInstBitwise(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerE
     return mod.addBinOp(b, inst.base.src, scalar_type, ir_tag, casted_lhs, casted_rhs);
 }
-fn analyzeInstBitNot(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirBitNot(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, inst.base.src, "TODO implement analyzeInstBitNot", .{});
+    return mod.fail(scope, inst.base.src, "TODO implement zirBitNot", .{});
 }
-fn analyzeInstArrayCat(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirArrayCat(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, inst.base.src, "TODO implement analyzeInstArrayCat", .{});
+    return mod.fail(scope, inst.base.src, "TODO implement zirArrayCat", .{});
 }
-fn analyzeInstArrayMul(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirArrayMul(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
-    return mod.fail(scope, inst.base.src, "TODO implement analyzeInstArrayMul", .{});
+    return mod.fail(scope, inst.base.src, "TODO implement zirArrayMul", .{});
 }
-fn analyzeInstArithmetic(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirArithmetic(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1912,14 +1938,14 @@ fn analyzeInstComptimeOp(mod: *Module, scope: *Scope, res_type: Type, inst: *zir
     });
 }
-fn analyzeInstDeref(mod: *Module, scope: *Scope, deref: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirDeref(mod: *Module, scope: *Scope, deref: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const ptr = try resolveInst(mod, scope, deref.positionals.operand);
     return mod.analyzeDeref(scope, deref.base.src, ptr, deref.positionals.operand.src);
 }
-fn analyzeInstAsm(mod: *Module, scope: *Scope, assembly: *zir.Inst.Asm) InnerError!*Inst {
+fn zirAsm(mod: *Module, scope: *Scope, assembly: *zir.Inst.Asm) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const return_type = try resolveType(mod, scope, assembly.positionals.return_type);
 @@ -1960,7 +1986,7 @@ fn analyzeInstAsm(mod: *Module, scope: *Scope, assembly: *zir.Inst.Asm) InnerErr
     return &inst.base;
 }
-fn analyzeInstCmp(
+fn zirCmp(
     mod: *Module,
     scope: *Scope,
     inst: *zir.Inst.BinOp,
 @@ -2018,14 +2044,14 @@ fn analyzeInstCmp(
     return mod.fail(scope, inst.base.src, "TODO implement more cmp analysis", .{});
 }
-fn analyzeInstTypeOf(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirTypeof(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const operand = try resolveInst(mod, scope, inst.positionals.operand);
     return mod.constType(scope, inst.base.src, operand.ty);
 }
-fn analyzeInstTypeOfPeer(mod: *Module, scope: *Scope, inst: *zir.Inst.TypeOfPeer) InnerError!*Inst {
+fn zirTypeofPeer(mod: *Module, scope: *Scope, inst: *zir.Inst.TypeOfPeer) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     var insts_to_res = try mod.gpa.alloc(*ir.Inst, inst.positionals.items.len);
 @@ -2037,7 +2063,7 @@ fn analyzeInstTypeOfPeer(mod: *Module, scope: *Scope, inst: *zir.Inst.TypeOfPeer
     return mod.constType(scope, inst.base.src, pt_res);
 }
-fn analyzeInstBoolNot(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirBoolNot(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const uncasted_operand = try resolveInst(mod, scope, inst.positionals.operand);
 @@ -2050,7 +2076,7 @@ fn analyzeInstBoolNot(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerEr
     return mod.addUnOp(b, inst.base.src, bool_type, .not, operand);
 }
-fn analyzeInstBoolOp(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
+fn zirBoolOp(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const bool_type = Type.initTag(.bool);
 @@ -2059,7 +2085,7 @@ fn analyzeInstBoolOp(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerEr
     const uncasted_rhs = try resolveInst(mod, scope, inst.positionals.rhs);
     const rhs = try mod.coerce(scope, bool_type, uncasted_rhs);
-    const is_bool_or = inst.base.tag == .boolor;
+    const is_bool_or = inst.base.tag == .bool_or;
     if (lhs.value()) |lhs_val| {
         if (rhs.value()) |rhs_val| {
 @@ -2071,17 +2097,17 @@ fn analyzeInstBoolOp(mod: *Module, scope: *Scope, inst: *zir.Inst.BinOp) InnerEr
         }
     }
     const b = try mod.requireRuntimeBlock(scope, inst.base.src);
-    return mod.addBinOp(b, inst.base.src, bool_type, if (is_bool_or) .boolor else .booland, lhs, rhs);
+    return mod.addBinOp(b, inst.base.src, bool_type, if (is_bool_or) .bool_or else .bool_and, lhs, rhs);
 }
-fn isNull(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp, invert_logic: bool) InnerError!*Inst {
+fn zirIsNull(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp, invert_logic: bool) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const operand = try resolveInst(mod, scope, inst.positionals.operand);
     return mod.analyzeIsNull(scope, inst.base.src, operand, invert_logic);
 }
-fn isNullPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp, invert_logic: bool) InnerError!*Inst {
+fn zirIsNullPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp, invert_logic: bool) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const ptr = try resolveInst(mod, scope, inst.positionals.operand);
 @@ -2089,14 +2115,14 @@ fn isNullPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp, invert_logic: bo
     return mod.analyzeIsNull(scope, inst.base.src, loaded, invert_logic);
 }
-fn isErr(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirIsErr(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const operand = try resolveInst(mod, scope, inst.positionals.operand);
     return mod.analyzeIsErr(scope, inst.base.src, operand);
 }
-fn isErrPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirIsErrPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const ptr = try resolveInst(mod, scope, inst.positionals.operand);
 @@ -2104,7 +2130,7 @@ fn isErrPtr(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst
     return mod.analyzeIsErr(scope, inst.base.src, loaded);
 }
-fn analyzeInstCondBr(mod: *Module, scope: *Scope, inst: *zir.Inst.CondBr) InnerError!*Inst {
+fn zirCondbr(mod: *Module, scope: *Scope, inst: *zir.Inst.CondBr) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const uncasted_cond = try resolveInst(mod, scope, inst.positionals.condition);
 @@ -2153,7 +2179,7 @@ fn analyzeInstCondBr(mod: *Module, scope: *Scope, inst: *zir.Inst.CondBr) InnerE
     return mod.addCondBr(parent_block, inst.base.src, cond, then_body, else_body);
 }
-fn analyzeInstUnreachable(
+fn zirUnreachable(
     mod: *Module,
     scope: *Scope,
     unreach: *zir.Inst.NoOp,
 @@ -2170,7 +2196,7 @@ fn analyzeInstUnreachable(
     }
 }
-fn analyzeInstRet(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
+fn zirReturn(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const operand = try resolveInst(mod, scope, inst.positionals.operand);
 @@ -2185,7 +2211,7 @@ fn analyzeInstRet(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!
     return mod.addUnOp(b, inst.base.src, Type.initTag(.noreturn), .ret, operand);
 }
-fn analyzeInstRetVoid(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerError!*Inst {
+fn zirReturnVoid(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const b = try mod.requireFunctionBlock(scope, inst.base.src);
 @@ -2216,27 +2242,7 @@ fn floatOpAllowed(tag: zir.Inst.Tag) bool {
     };
 }
-fn analyzeBreak(
+fn zirSimplePtrType(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp, mutable: bool, size: std.builtin.TypeInfo.Pointer.Size) InnerError!*Inst {
-    mod: *Module,
-    scope: *Scope,
-    src: usize,
-    zir_block: *zir.Inst.Block,
-    operand: *Inst,
-) InnerError!*Inst {
-    var opt_block = scope.cast(Scope.Block);
-    while (opt_block) |block| {
-        if (block.label) |*label| {
-            if (label.zir_block == zir_block) {
-                try label.merges.results.append(mod.gpa, operand);
-                const b = try mod.requireFunctionBlock(scope, src);
-                return mod.addBr(b, src, label.merges.block_inst, operand);
-            }
-        }
-        opt_block = block.parent;
-    } else unreachable;
-}
-fn analyzeInstSimplePtrType(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp, mutable: bool, size: std.builtin.TypeInfo.Pointer.Size) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     const elem_type = try resolveType(mod, scope, inst.positionals.operand);
 @@ -2244,7 +2250,7 @@ fn analyzeInstSimplePtrType(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp, m
     return mod.constType(scope, inst.base.src, ty);
 }
-fn analyzeInstPtrType(mod: *Module, scope: *Scope, inst: *zir.Inst.PtrType) InnerError!*Inst {
+fn zirPtrType(mod: *Module, scope: *Scope, inst: *zir.Inst.PtrType) InnerError!*Inst {
     const tracy = trace(@src());
     defer tracy.end();
     // TODO lazy values

...	@@ -840,14 +840,14 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {	...	@@ -840,14 +840,14 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
840	.arg => return self.genArg(inst.castTag(.arg).?),	840	.arg => return self.genArg(inst.castTag(.arg).?),
841	.assembly => return self.genAsm(inst.castTag(.assembly).?),	841	.assembly => return self.genAsm(inst.castTag(.assembly).?),
842	.bitcast => return self.genBitCast(inst.castTag(.bitcast).?),	842	.bitcast => return self.genBitCast(inst.castTag(.bitcast).?),
843	.bitand => return self.genBitAnd(inst.castTag(.bitand).?),	843	.bit_and => return self.genBitAnd(inst.castTag(.bit_and).?),
844	.bitor => return self.genBitOr(inst.castTag(.bitor).?),	844	.bit_or => return self.genBitOr(inst.castTag(.bit_or).?),
845	.block => return self.genBlock(inst.castTag(.block).?),	845	.block => return self.genBlock(inst.castTag(.block).?),
846	.br => return self.genBr(inst.castTag(.br).?),	846	.br => return self.genBr(inst.castTag(.br).?),
847	.breakpoint => return self.genBreakpoint(inst.src),	847	.breakpoint => return self.genBreakpoint(inst.src),
848	.brvoid => return self.genBrVoid(inst.castTag(.brvoid).?),	848	.brvoid => return self.genBrVoid(inst.castTag(.brvoid).?),
849	.booland => return self.genBoolOp(inst.castTag(.booland).?),	849	.bool_and => return self.genBoolOp(inst.castTag(.bool_and).?),
850	.boolor => return self.genBoolOp(inst.castTag(.boolor).?),	850	.bool_or => return self.genBoolOp(inst.castTag(.bool_or).?),
851	.call => return self.genCall(inst.castTag(.call).?),	851	.call => return self.genCall(inst.castTag(.call).?),
852	.cmp_lt => return self.genCmp(inst.castTag(.cmp_lt).?, .lt),	852	.cmp_lt => return self.genCmp(inst.castTag(.cmp_lt).?, .lt),
853	.cmp_lte => return self.genCmp(inst.castTag(.cmp_lte).?, .lte),	853	.cmp_lte => return self.genCmp(inst.castTag(.cmp_lte).?, .lte),
...	@@ -1097,7 +1097,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {	...	@@ -1097,7 +1097,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
1097	if (inst.base.isUnused())	1097	if (inst.base.isUnused())
1098	return MCValue.dead;	1098	return MCValue.dead;
1099	switch (arch) {	1099	switch (arch) {
1100	.arm, .armeb => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .bitand),	1100	.arm, .armeb => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .bit_and),
1101	else => return self.fail(inst.base.src, "TODO implement bitwise and for {}", .{self.target.cpu.arch}),	1101	else => return self.fail(inst.base.src, "TODO implement bitwise and for {}", .{self.target.cpu.arch}),
1102	}	1102	}
1103	}	1103	}
...	@@ -1107,7 +1107,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {	...	@@ -1107,7 +1107,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
1107	if (inst.base.isUnused())	1107	if (inst.base.isUnused())
1108	return MCValue.dead;	1108	return MCValue.dead;
1109	switch (arch) {	1109	switch (arch) {
1110	.arm, .armeb => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .bitor),	1110	.arm, .armeb => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .bit_or),
1111	else => return self.fail(inst.base.src, "TODO implement bitwise or for {}", .{self.target.cpu.arch}),	1111	else => return self.fail(inst.base.src, "TODO implement bitwise or for {}", .{self.target.cpu.arch}),
1112	}	1112	}
1113	}	1113	}
...	@@ -1371,10 +1371,10 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {	...	@@ -1371,10 +1371,10 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
1371	writeInt(u32, try self.code.addManyAsArray(4), Instruction.rsb(.al, dst_reg, dst_reg, operand).toU32());	1371	writeInt(u32, try self.code.addManyAsArray(4), Instruction.rsb(.al, dst_reg, dst_reg, operand).toU32());
1372	}	1372	}
1373	},	1373	},
1374	.booland, .bitand => {	1374	.bool_and, .bit_and => {
1375	writeInt(u32, try self.code.addManyAsArray(4), Instruction.@"and"(.al, dst_reg, dst_reg, operand).toU32());	1375	writeInt(u32, try self.code.addManyAsArray(4), Instruction.@"and"(.al, dst_reg, dst_reg, operand).toU32());
1376	},	1376	},
1377	.boolor, .bitor => {	1377	.bool_or, .bit_or => {
1378	writeInt(u32, try self.code.addManyAsArray(4), Instruction.orr(.al, dst_reg, dst_reg, operand).toU32());	1378	writeInt(u32, try self.code.addManyAsArray(4), Instruction.orr(.al, dst_reg, dst_reg, operand).toU32());
1379	},	1379	},
1380	.not, .xor => {	1380	.not, .xor => {
...	@@ -2464,14 +2464,14 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {	...	@@ -2464,14 +2464,14 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
2464	switch (arch) {	2464	switch (arch) {
2465	.x86_64 => switch (inst.base.tag) {	2465	.x86_64 => switch (inst.base.tag) {
2466	// lhs AND rhs	2466	// lhs AND rhs
2467	.booland => return try self.genX8664BinMath(&inst.base, inst.lhs, inst.rhs, 4, 0x20),	2467	.bool_and => return try self.genX8664BinMath(&inst.base, inst.lhs, inst.rhs, 4, 0x20),
2468	// lhs OR rhs	2468	// lhs OR rhs
2469	.boolor => return try self.genX8664BinMath(&inst.base, inst.lhs, inst.rhs, 1, 0x08),	2469	.bool_or => return try self.genX8664BinMath(&inst.base, inst.lhs, inst.rhs, 1, 0x08),
2470	else => unreachable, // Not a boolean operation	2470	else => unreachable, // Not a boolean operation
2471	},	2471	},
2472	.arm, .armeb => switch (inst.base.tag) {	2472	.arm, .armeb => switch (inst.base.tag) {
2473	.booland => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .booland),	2473	.bool_and => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .bool_and),
2474	.boolor => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .boolor),	2474	.bool_or => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .bool_or),
2475	else => unreachable, // Not a boolean operation	2475	else => unreachable, // Not a boolean operation
2476	},	2476	},
2477	else => return self.fail(inst.base.src, "TODO implement boolean operations for {}", .{self.target.cpu.arch}),	2477	else => return self.fail(inst.base.src, "TODO implement boolean operations for {}", .{self.target.cpu.arch}),