Commit bf76501b5d46277d3706a1f0b92ba52f2a47d894 | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-01-31 20:15:08-08:00
committer	GitHub <noreply@github.com> 2021-01-31 20:15:08-08:00
log	bf76501b5d46277d3706a1f0b92ba52f2a47d894
tree	7a40c904b9246092009c02f5b09a2a8732b69175
parent	fdc875ed0080cd2542a854a8cd6c627b25e9b7a4
parent	0f5eda973e0c17b3f792cdb06674bf8d2863c8fb
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #7847 from ziglang/astgen-rl-rework

stage2: rework astgen result locations

7 files changed, 1280 insertions(+), 1398 deletions(-)

src
test
- stage2
  - test.zig

src/Module.zig+62-11

 @@ -375,6 +375,10 @@ pub const Scope = struct {
         }
     }
+    pub fn isComptime(self: *Scope) bool {
+        return self.getGenZIR().force_comptime;
+    }
     pub fn ownerDecl(self: *Scope) ?*Decl {
         return switch (self.tag) {
             .block => self.cast(Block).?.owner_decl,
 @@ -671,14 +675,36 @@ pub const Scope = struct {
         };
         pub const Merges = struct {
-            results: ArrayListUnmanaged(*Inst),
             block_inst: *Inst.Block,
+            /// Separate array list from break_inst_list so that it can be passed directly
+            /// to resolvePeerTypes.
+            results: ArrayListUnmanaged(*Inst),
+            /// Keeps track of the break instructions so that the operand can be replaced
+            /// if we need to add type coercion at the end of block analysis.
+            /// Same indexes, capacity, length as `results`.
+            br_list: ArrayListUnmanaged(*Inst.Br),
         };
         /// For debugging purposes.
         pub fn dump(self: *Block, mod: Module) void {
             zir.dumpBlock(mod, self);
         }
+        pub fn makeSubBlock(parent: *Block) Block {
+            return .{
+                .parent = parent,
+                .inst_table = parent.inst_table,
+                .func = parent.func,
+                .owner_decl = parent.owner_decl,
+                .src_decl = parent.src_decl,
+                .instructions = .{},
+                .arena = parent.arena,
+                .label = null,
+                .inlining = parent.inlining,
+                .is_comptime = parent.is_comptime,
+                .branch_quota = parent.branch_quota,
+            };
+        }
     };
     /// This is a temporary structure, references to it are valid only
 @@ -690,13 +716,32 @@ pub const Scope = struct {
         parent: *Scope,
         decl: *Decl,
         arena: *Allocator,
+        force_comptime: bool,
         /// The first N instructions in a function body ZIR are arg instructions.
         instructions: std.ArrayListUnmanaged(*zir.Inst) = .{},
         label: ?Label = null,
         break_block: ?*zir.Inst.Block = null,
         continue_block: ?*zir.Inst.Block = null,
-        /// only valid if label != null or (continue_block and break_block) != null
+        /// Only valid when setBlockResultLoc is called.
         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,
+        /// Keeps track of how many break instructions there are. When astgen is finished
+        /// with a block, it can check this against rvalue_rl_count to find out whether
+        /// the break instructions should be downgraded to break_void.
+        break_count: usize = 0,
+        /// Tracks `break :foo bar` instructions so they can possibly be elided later if
+        /// the labeled block ends up not needing a result location pointer.
+        labeled_breaks: std.ArrayListUnmanaged(*zir.Inst.Break) = .{},
+        /// Tracks `store_to_block_ptr` instructions that correspond to break instructions
+        /// so they can possibly be elided later if the labeled block ends up not needing
+        /// a result location pointer.
+        labeled_store_to_block_ptr_list: std.ArrayListUnmanaged(*zir.Inst.BinOp) = .{},
         pub const Label = struct {
             token: ast.TokenIndex,
 @@ -968,6 +1013,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                 .decl = decl,
                 .arena = &fn_type_scope_arena.allocator,
                 .parent = &decl.container.base,
+                .force_comptime = true,
             };
             defer fn_type_scope.instructions.deinit(self.gpa);
 @@ -1131,6 +1177,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                     .decl = decl,
                     .arena = &decl_arena.allocator,
                     .parent = &decl.container.base,
+                    .force_comptime = false,
                 };
                 defer gen_scope.instructions.deinit(self.gpa);
 @@ -1171,7 +1218,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) {
 @@ -1329,6 +1376,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                     .decl = decl,
                     .arena = &gen_scope_arena.allocator,
                     .parent = &decl.container.base,
+                    .force_comptime = false,
                 };
                 defer gen_scope.instructions.deinit(self.gpa);
 @@ -1388,6 +1436,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
                     .decl = decl,
                     .arena = &type_scope_arena.allocator,
                     .parent = &decl.container.base,
+                    .force_comptime = true,
                 };
                 defer type_scope.instructions.deinit(self.gpa);
 @@ -1457,13 +1506,15 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
             decl.analysis = .in_progress;
-            // A comptime decl does not store any value so we can just deinit this arena after analysis is done.
+            // A comptime decl does not store any value so we can just deinit
+            // this arena after analysis is done.
             var analysis_arena = std.heap.ArenaAllocator.init(self.gpa);
             defer analysis_arena.deinit();
             var gen_scope: Scope.GenZIR = .{
                 .decl = decl,
                 .arena = &analysis_arena.allocator,
                 .parent = &decl.container.base,
+                .force_comptime = true,
             };
             defer gen_scope.instructions.deinit(self.gpa);
 @@ -2100,7 +2151,7 @@ pub fn addBr(
     src: usize,
     target_block: *Inst.Block,
     operand: *Inst,
-) !*Inst {
+) !*Inst.Br {
     const inst = try scope_block.arena.create(Inst.Br);
     inst.* = .{
         .base = .{
 @@ -2112,7 +2163,7 @@ pub fn addBr(
         .block = target_block,
     };
     try scope_block.instructions.append(self.gpa, &inst.base);
-    return &inst.base;
+    return inst;
 }
 pub fn addCondBr(
 @@ -3466,18 +3517,18 @@ pub fn addSafetyCheck(mod: *Module, parent_block: *Scope.Block, ok: *Inst, panic
     };
     const ok_body: ir.Body = .{
-        .instructions = try parent_block.arena.alloc(*Inst, 1), // Only need space for the brvoid.
+        .instructions = try parent_block.arena.alloc(*Inst, 1), // Only need space for the br_void.
     };
-    const brvoid = try parent_block.arena.create(Inst.BrVoid);
+    const br_void = try parent_block.arena.create(Inst.BrVoid);
-    brvoid.* = .{
+    br_void.* = .{
         .base = .{
-            .tag = .brvoid,
+            .tag = .br_void,
             .ty = Type.initTag(.noreturn),
             .src = ok.src,
         },
         .block = block_inst,
     };
-    ok_body.instructions[0] = &brvoid.base;
+    ok_body.instructions[0] = &br_void.base;
     var fail_block: Scope.Block = .{
         .parent = parent_block,

src/astgen.zig+674-611

...	@@ -14,25 +14,45 @@ const InnerError = Module.InnerError;	...	@@ -14,25 +14,45 @@ 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,
		41
		42	pub const Strategy = struct {
		43	elide_store_to_block_ptr_instructions: bool,
		44	tag: Tag,
		45
		46	pub const Tag = enum {
		47	/// Both branches will use break_void; result location is used to communicate the
		48	/// result instruction.
		49	break_void,
		50	/// Use break statements to pass the block result value, and call rvalue() at
		51	/// the end depending on rl. Also elide the store_to_block_ptr instructions
		52	/// depending on rl.
		53	break_operand,
		54	};
		55	};
36	};	56	};
37		57
38	pub fn typeExpr(mod: Module, scope: Scope, type_node: ast.Node) InnerError!zir.Inst {	58	pub fn typeExpr(mod: Module, scope: Scope, type_node: ast.Node) InnerError!zir.Inst {
...	@@ -179,6 +199,9 @@ fn lvalExpr(mod: Module, scope: Scope, node: ast.Node) InnerError!zir.Inst {	...	@@ -179,6 +199,9 @@ fn lvalExpr(mod: Module, scope: Scope, node: ast.Node) InnerError!zir.Inst {
179	}	199	}
180		200
181	/// Turn Zig AST into untyped ZIR istructions.	201	/// Turn Zig AST into untyped ZIR istructions.
		202	/// When `rl` is discard, ptr, inferred_ptr, bitcasted_ptr, or inferred_ptr, the
		203	/// result instruction can be used to inspect whether it is isNoReturn() but that is it,
		204	/// it must otherwise not be used.
182	pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: ast.Node) InnerError!zir.Inst {	205	pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: ast.Node) InnerError!zir.Inst {
183	switch (node.tag) {	206	switch (node.tag) {
184	.Root => unreachable, // Top-level declaration.	207	.Root => unreachable, // Top-level declaration.
...	@@ -197,20 +220,20 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr	...	@@ -197,20 +220,20 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr
197	.FieldInitializer => unreachable, // Handled explicitly.	220	.FieldInitializer => unreachable, // Handled explicitly.
198	.ContainerField => unreachable, // Handled explicitly.	221	.ContainerField => unreachable, // Handled explicitly.
199		222
200	.Assign => return rlWrapVoid(mod, scope, rl, node, try assign(mod, scope, node.castTag(.Assign).?)),	223	.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)),	224	.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)),	225	.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)),	226	.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)),	227	.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)),	228	.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)),	229	.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)),	230	.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)),	231	.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)),	232	.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)),	233	.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)),	234	.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)),	235	.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)),	236	.AssignMulWrap => return rvalueVoid(mod, scope, rl, node, try assignOp(mod, scope, node.castTag(.AssignMulWrap).?, .mulwrap)),
214		237
215	.Add => return simpleBinOp(mod, scope, rl, node.castTag(.Add).?, .add),	238	.Add => return simpleBinOp(mod, scope, rl, node.castTag(.Add).?, .add),
216	.AddWrap => return simpleBinOp(mod, scope, rl, node.castTag(.AddWrap).?, .addwrap),	239	.AddWrap => return simpleBinOp(mod, scope, rl, node.castTag(.AddWrap).?, .addwrap),
...	@@ -220,8 +243,8 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr	...	@@ -220,8 +243,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),	243	.MulWrap => return simpleBinOp(mod, scope, rl, node.castTag(.MulWrap).?, .mulwrap),
221	.Div => return simpleBinOp(mod, scope, rl, node.castTag(.Div).?, .div),	244	.Div => return simpleBinOp(mod, scope, rl, node.castTag(.Div).?, .div),
222	.Mod => return simpleBinOp(mod, scope, rl, node.castTag(.Mod).?, .mod_rem),	245	.Mod => return simpleBinOp(mod, scope, rl, node.castTag(.Mod).?, .mod_rem),
223	.BitAnd => return simpleBinOp(mod, scope, rl, node.castTag(.BitAnd).?, .bitand),	246	.BitAnd => return simpleBinOp(mod, scope, rl, node.castTag(.BitAnd).?, .bit_and),
224	.BitOr => return simpleBinOp(mod, scope, rl, node.castTag(.BitOr).?, .bitor),	247	.BitOr => return simpleBinOp(mod, scope, rl, node.castTag(.BitOr).?, .bit_or),
225	.BitShiftLeft => return simpleBinOp(mod, scope, rl, node.castTag(.BitShiftLeft).?, .shl),	248	.BitShiftLeft => return simpleBinOp(mod, scope, rl, node.castTag(.BitShiftLeft).?, .shl),
226	.BitShiftRight => return simpleBinOp(mod, scope, rl, node.castTag(.BitShiftRight).?, .shr),	249	.BitShiftRight => return simpleBinOp(mod, scope, rl, node.castTag(.BitShiftRight).?, .shr),
227	.BitXor => return simpleBinOp(mod, scope, rl, node.castTag(.BitXor).?, .xor),	250	.BitXor => return simpleBinOp(mod, scope, rl, node.castTag(.BitXor).?, .xor),
...	@@ -239,15 +262,15 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr	...	@@ -239,15 +262,15 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr
239	.BoolAnd => return boolBinOp(mod, scope, rl, node.castTag(.BoolAnd).?),	262	.BoolAnd => return boolBinOp(mod, scope, rl, node.castTag(.BoolAnd).?),
240	.BoolOr => return boolBinOp(mod, scope, rl, node.castTag(.BoolOr).?),	263	.BoolOr => return boolBinOp(mod, scope, rl, node.castTag(.BoolOr).?),
241		264
242	.BoolNot => return rlWrap(mod, scope, rl, try boolNot(mod, scope, node.castTag(.BoolNot).?)),	265	.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).?)),	266	.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)),	267	.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)),	268	.NegationWrap => return rvalue(mod, scope, rl, try negation(mod, scope, node.castTag(.NegationWrap).?, .subwrap)),
246		269
247	.Identifier => return try identifier(mod, scope, rl, node.castTag(.Identifier).?),	270	.Identifier => return try identifier(mod, scope, rl, node.castTag(.Identifier).?),
248	.Asm => return rlWrap(mod, scope, rl, try assembly(mod, scope, node.castTag(.Asm).?)),	271	.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).?)),	272	.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).?)),	273	.IntegerLiteral => return rvalue(mod, scope, rl, try integerLiteral(mod, scope, node.castTag(.IntegerLiteral).?)),
251	.BuiltinCall => return builtinCall(mod, scope, rl, node.castTag(.BuiltinCall).?),	274	.BuiltinCall => return builtinCall(mod, scope, rl, node.castTag(.BuiltinCall).?),
252	.Call => return callExpr(mod, scope, rl, node.castTag(.Call).?),	275	.Call => return callExpr(mod, scope, rl, node.castTag(.Call).?),
253	.Unreachable => return unreach(mod, scope, node.castTag(.Unreachable).?),	276	.Unreachable => return unreach(mod, scope, node.castTag(.Unreachable).?),
...	@@ -255,38 +278,38 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr	...	@@ -255,38 +278,38 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr
255	.If => return ifExpr(mod, scope, rl, node.castTag(.If).?),	278	.If => return ifExpr(mod, scope, rl, node.castTag(.If).?),
256	.While => return whileExpr(mod, scope, rl, node.castTag(.While).?),	279	.While => return whileExpr(mod, scope, rl, node.castTag(.While).?),
257	.Period => return field(mod, scope, rl, node.castTag(.Period).?),	280	.Period => return field(mod, scope, rl, node.castTag(.Period).?),
258	.Deref => return rlWrap(mod, scope, rl, try deref(mod, scope, node.castTag(.Deref).?)),	281	.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).?)),	282	.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).?)),	283	.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).?)),	284	.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).?)),	285	.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).?)),	286	.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).?)),	287	.OptionalType => return rvalue(mod, scope, rl, try optionalType(mod, scope, node.castTag(.OptionalType).?)),
265	.UnwrapOptional => return unwrapOptional(mod, scope, rl, node.castTag(.UnwrapOptional).?),	288	.UnwrapOptional => return unwrapOptional(mod, scope, rl, node.castTag(.UnwrapOptional).?),
266	.Block => return rlWrapVoid(mod, scope, rl, node, try blockExpr(mod, scope, node.castTag(.Block).?)),	289	.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),	290	.LabeledBlock => return labeledBlockExpr(mod, scope, rl, node.castTag(.LabeledBlock).?, .block),
268	.Break => return rlWrap(mod, scope, rl, try breakExpr(mod, scope, node.castTag(.Break).?)),	291	.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).?)),	292	.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).?)),	293	.PtrType => return rvalue(mod, scope, rl, try ptrType(mod, scope, node.castTag(.PtrType).?)),
271	.GroupedExpression => return expr(mod, scope, rl, node.castTag(.GroupedExpression).?.expr),	294	.GroupedExpression => return expr(mod, scope, rl, node.castTag(.GroupedExpression).?.expr),
272	.ArrayType => return rlWrap(mod, scope, rl, try arrayType(mod, scope, node.castTag(.ArrayType).?)),	295	.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).?)),	296	.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).?)),	297	.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).?)),	298	.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).?)),	299	.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).?)),	300	.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)),	301	.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)),	302	.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).?)),	303	.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).?)),	304	.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).?)),	305	.ErrorType => return rvalue(mod, scope, rl, try errorType(mod, scope, node.castTag(.ErrorType).?)),
283	.For => return forExpr(mod, scope, rl, node.castTag(.For).?),	306	.For => return forExpr(mod, scope, rl, node.castTag(.For).?),
284	.ArrayAccess => return arrayAccess(mod, scope, rl, node.castTag(.ArrayAccess).?),	307	.ArrayAccess => return arrayAccess(mod, scope, rl, node.castTag(.ArrayAccess).?),
285	.Slice => return rlWrap(mod, scope, rl, try sliceExpr(mod, scope, node.castTag(.Slice).?)),	308	.Slice => return rvalue(mod, scope, rl, try sliceExpr(mod, scope, node.castTag(.Slice).?)),
286	.Catch => return catchExpr(mod, scope, rl, node.castTag(.Catch).?),	309	.Catch => return catchExpr(mod, scope, rl, node.castTag(.Catch).?),
287	.Comptime => return comptimeKeyword(mod, scope, rl, node.castTag(.Comptime).?),	310	.Comptime => return comptimeKeyword(mod, scope, rl, node.castTag(.Comptime).?),
288	.OrElse => return orelseExpr(mod, scope, rl, node.castTag(.OrElse).?),	311	.OrElse => return orelseExpr(mod, scope, rl, node.castTag(.OrElse).?),
289	.Switch => return switchExpr(mod, scope, rl, node.castTag(.Switch).?),	312	.Switch => return mod.failNode(scope, node, "TODO implement astgen.expr for .Switch", .{}),
290	.ContainerDecl => return containerDecl(mod, scope, rl, node.castTag(.ContainerDecl).?),	313	.ContainerDecl => return containerDecl(mod, scope, rl, node.castTag(.ContainerDecl).?),
291		314
292	.Defer => return mod.failNode(scope, node, "TODO implement astgen.expr for .Defer", .{}),	315	.Defer => return mod.failNode(scope, node, "TODO implement astgen.expr for .Defer", .{}),
...	@@ -311,11 +334,19 @@ fn comptimeKeyword(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.C	...	@@ -311,11 +334,19 @@ fn comptimeKeyword(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.C
311	return comptimeExpr(mod, scope, rl, node.expr);	334	return comptimeExpr(mod, scope, rl, node.expr);
312	}	335	}
313		336
314	pub fn comptimeExpr(mod: Module, parent_scope: Scope, rl: ResultLoc, node: ast.Node) InnerError!zir.Inst {	337	pub fn comptimeExpr(
315	const tree = parent_scope.tree();	338	mod: *Module,
316	const src = tree.token_locs[node.firstToken()].start;	339	parent_scope: *Scope,
		340	rl: ResultLoc,
		341	node: *ast.Node,
		342	) InnerError!*zir.Inst {
		343	// If we are already in a comptime scope, no need to make another one.
		344	if (parent_scope.isComptime()) {
		345	return expr(mod, parent_scope, rl, node);
		346	}
317		347
318	// Optimization for labeled blocks: don't need to have 2 layers of blocks, we can reuse the existing one.	348	// Optimization for labeled blocks: don't need to have 2 layers of blocks,
		349	// we can reuse the existing one.
319	if (node.castTag(.LabeledBlock)) \|block_node\| {	350	if (node.castTag(.LabeledBlock)) \|block_node\| {
320	return labeledBlockExpr(mod, parent_scope, rl, block_node, .block_comptime);	351	return labeledBlockExpr(mod, parent_scope, rl, block_node, .block_comptime);
321	}	352	}
...	@@ -325,6 +356,7 @@ pub fn comptimeExpr(mod: Module, parent_scope: Scope, rl: ResultLoc, node: *as	...	@@ -325,6 +356,7 @@ pub fn comptimeExpr(mod: Module, parent_scope: Scope, rl: ResultLoc, node: *as
325	.parent = parent_scope,	356	.parent = parent_scope,
326	.decl = parent_scope.ownerDecl().?,	357	.decl = parent_scope.ownerDecl().?,
327	.arena = parent_scope.arena(),	358	.arena = parent_scope.arena(),
		359	.force_comptime = true,
328	.instructions = .{},	360	.instructions = .{},
329	};	361	};
330	defer block_scope.instructions.deinit(mod.gpa);	362	defer block_scope.instructions.deinit(mod.gpa);
...	@@ -333,6 +365,9 @@ pub fn comptimeExpr(mod: Module, parent_scope: Scope, rl: ResultLoc, node: *as	...	@@ -333,6 +365,9 @@ pub fn comptimeExpr(mod: Module, parent_scope: Scope, rl: ResultLoc, node: *as
333	// instruction is the block's result value.	365	// instruction is the block's result value.
334	_ = try expr(mod, &block_scope.base, rl, node);	366	_ = try expr(mod, &block_scope.base, rl, node);
335		367
		368	const tree = parent_scope.tree();
		369	const src = tree.token_locs[node.firstToken()].start;
		370
336	const block = try addZIRInstBlock(mod, parent_scope, src, .block_comptime_flat, .{	371	const block = try addZIRInstBlock(mod, parent_scope, src, .block_comptime_flat, .{
337	.instructions = try block_scope.arena.dupe(*zir.Inst, block_scope.instructions.items),	372	.instructions = try block_scope.arena.dupe(*zir.Inst, block_scope.instructions.items),
338	});	373	});
...	@@ -340,7 +375,11 @@ pub fn comptimeExpr(mod: Module, parent_scope: Scope, rl: ResultLoc, node: *as	...	@@ -340,7 +375,11 @@ pub fn comptimeExpr(mod: Module, parent_scope: Scope, rl: ResultLoc, node: *as
340	return &block.base;	375	return &block.base;
341	}	376	}
342		377
343	fn breakExpr(mod: Module, parent_scope: Scope, node: ast.Node.ControlFlowExpression) InnerError!zir.Inst {	378	fn breakExpr(
		379	mod: *Module,
		380	parent_scope: *Scope,
		381	node: *ast.Node.ControlFlowExpression,
		382	) InnerError!*zir.Inst {
344	const tree = parent_scope.tree();	383	const tree = parent_scope.tree();
345	const src = tree.token_locs[node.ltoken].start;	384	const src = tree.token_locs[node.ltoken].start;
346		385
...	@@ -366,25 +405,31 @@ fn breakExpr(mod: Module, parent_scope: Scope, node: *ast.Node.ControlFlowExpr	...	@@ -366,25 +405,31 @@ fn breakExpr(mod: Module, parent_scope: Scope, node: *ast.Node.ControlFlowExpr
366	continue;	405	continue;
367	};	406	};
368		407
369	if (node.getRHS()) \|rhs\| {	408	const rhs = node.getRHS() orelse {
370	// Most result location types can be forwarded directly; however	409	return addZirInstTag(mod, parent_scope, src, .break_void, .{
371	// if we need to write to a pointer which has an inferred type,
372	// proper type inference requires peer type resolution on the block's
373	// break operand expressions.
374	const branch_rl: ResultLoc = switch (gen_zir.break_result_loc) {
375	.discard, .none, .ty, .ptr, .ref => gen_zir.break_result_loc,
376	.inferred_ptr, .bitcasted_ptr, .block_ptr => .{ .block_ptr = block_inst },
377	};
378	const operand = try expr(mod, parent_scope, branch_rl, rhs);
379	return try addZIRInst(mod, parent_scope, src, zir.Inst.Break, .{
380	.block = block_inst,	410	.block = block_inst,
381	.operand = operand,	411	});
382	}, .{});	412	};
383	} else {	413	gen_zir.break_count += 1;
384	return try addZIRInst(mod, parent_scope, src, zir.Inst.BreakVoid, .{	414	const prev_rvalue_rl_count = gen_zir.rvalue_rl_count;
385	.block = block_inst,	415	const operand = try expr(mod, parent_scope, gen_zir.break_result_loc, rhs);
386	}, .{});	416	const have_store_to_block = gen_zir.rvalue_rl_count != prev_rvalue_rl_count;
		417	const br = try addZirInstTag(mod, parent_scope, src, .@"break", .{
		418	.block = block_inst,
		419	.operand = operand,
		420	});
		421	if (gen_zir.break_result_loc == .block_ptr) {
		422	try gen_zir.labeled_breaks.append(mod.gpa, br.castTag(.@"break").?);
		423
		424	if (have_store_to_block) {
		425	const inst_list = parent_scope.getGenZIR().instructions.items;
		426	const last_inst = inst_list[inst_list.len - 2];
		427	const store_inst = last_inst.castTag(.store_to_block_ptr).?;
		428	assert(store_inst.positionals.lhs == gen_zir.rl_ptr.?);
		429	try gen_zir.labeled_store_to_block_ptr_list.append(mod.gpa, store_inst);
		430	}
387	}	431	}
		432	return br;
388	},	433	},
389	.local_val => scope = scope.cast(Scope.LocalVal).?.parent,	434	.local_val => scope = scope.cast(Scope.LocalVal).?.parent,
390	.local_ptr => scope = scope.cast(Scope.LocalPtr).?.parent,	435	.local_ptr => scope = scope.cast(Scope.LocalPtr).?.parent,
...	@@ -424,9 +469,9 @@ fn continueExpr(mod: Module, parent_scope: Scope, node: *ast.Node.ControlFlowE	...	@@ -424,9 +469,9 @@ fn continueExpr(mod: Module, parent_scope: Scope, node: *ast.Node.ControlFlowE
424	continue;	469	continue;
425	}	470	}
426		471
427	return addZIRInst(mod, parent_scope, src, zir.Inst.BreakVoid, .{	472	return addZirInstTag(mod, parent_scope, src, .break_void, .{
428	.block = continue_block,	473	.block = continue_block,
429	}, .{});	474	});
430	},	475	},
431	.local_val => scope = scope.cast(Scope.LocalVal).?.parent,	476	.local_val => scope = scope.cast(Scope.LocalVal).?.parent,
432	.local_ptr => scope = scope.cast(Scope.LocalPtr).?.parent,	477	.local_ptr => scope = scope.cast(Scope.LocalPtr).?.parent,
...	@@ -526,28 +571,65 @@ fn labeledBlockExpr(	...	@@ -526,28 +571,65 @@ fn labeledBlockExpr(
526	.parent = parent_scope,	571	.parent = parent_scope,
527	.decl = parent_scope.ownerDecl().?,	572	.decl = parent_scope.ownerDecl().?,
528	.arena = gen_zir.arena,	573	.arena = gen_zir.arena,
		574	.force_comptime = parent_scope.isComptime(),
529	.instructions = .{},	575	.instructions = .{},
530	.break_result_loc = rl,
531	// TODO @as here is working around a stage1 miscompilation bug :(	576	// TODO @as here is working around a stage1 miscompilation bug :(
532	.label = @as(?Scope.GenZIR.Label, Scope.GenZIR.Label{	577	.label = @as(?Scope.GenZIR.Label, Scope.GenZIR.Label{
533	.token = block_node.label,	578	.token = block_node.label,
534	.block_inst = block_inst,	579	.block_inst = block_inst,
535	}),	580	}),
536	};	581	};
		582	setBlockResultLoc(&block_scope, rl);
537	defer block_scope.instructions.deinit(mod.gpa);	583	defer block_scope.instructions.deinit(mod.gpa);
		584	defer block_scope.labeled_breaks.deinit(mod.gpa);
		585	defer block_scope.labeled_store_to_block_ptr_list.deinit(mod.gpa);
538		586
539	try blockExprStmts(mod, &block_scope.base, &block_node.base, block_node.statements());	587	try blockExprStmts(mod, &block_scope.base, &block_node.base, block_node.statements());
		588
540	if (!block_scope.label.?.used) {	589	if (!block_scope.label.?.used) {
541	return mod.fail(parent_scope, tree.token_locs[block_node.label].start, "unused block label", .{});	590	return mod.fail(parent_scope, tree.token_locs[block_node.label].start, "unused block label", .{});
542	}	591	}
543		592
544	block_inst.positionals.body.instructions = try block_scope.arena.dupe(*zir.Inst, block_scope.instructions.items);
545	try gen_zir.instructions.append(mod.gpa, &block_inst.base);	593	try gen_zir.instructions.append(mod.gpa, &block_inst.base);
546		594
547	return &block_inst.base;	595	const strat = rlStrategy(rl, &block_scope);
		596	switch (strat.tag) {
		597	.break_void => {
		598	// The code took advantage of the result location as a pointer.
		599	// Turn the break instructions into break_void instructions.
		600	for (block_scope.labeled_breaks.items) \|br\| {
		601	br.base.tag = .break_void;
		602	}
		603	// TODO technically not needed since we changed the tag to break_void but
		604	// would be better still to elide the ones that are in this list.
		605	try copyBodyNoEliding(&block_inst.positionals.body, block_scope);
		606
		607	return &block_inst.base;
		608	},
		609	.break_operand => {
		610	// All break operands are values that did not use the result location pointer.
		611	if (strat.elide_store_to_block_ptr_instructions) {
		612	for (block_scope.labeled_store_to_block_ptr_list.items) \|inst\| {
		613	inst.base.tag = .void_value;
		614	}
		615	// TODO technically not needed since we changed the tag to void_value but
		616	// would be better still to elide the ones that are in this list.
		617	}
		618	try copyBodyNoEliding(&block_inst.positionals.body, block_scope);
		619	switch (rl) {
		620	.ref => return &block_inst.base,
		621	else => return rvalue(mod, parent_scope, rl, &block_inst.base),
		622	}
		623	},
		624	}
548	}	625	}
549		626
550	fn blockExprStmts(mod: Module, parent_scope: Scope, node: ast.Node, statements: []ast.Node) !void {	627	fn blockExprStmts(
		628	mod: *Module,
		629	parent_scope: *Scope,
		630	node: *ast.Node,
		631	statements: []*ast.Node,
		632	) !void {
551	const tree = parent_scope.tree();	633	const tree = parent_scope.tree();
552		634
553	var block_arena = std.heap.ArenaAllocator.init(mod.gpa);	635	var block_arena = std.heap.ArenaAllocator.init(mod.gpa);
...	@@ -563,8 +645,8 @@ fn blockExprStmts(mod: Module, parent_scope: Scope, node: *ast.Node, statement	...	@@ -563,8 +645,8 @@ fn blockExprStmts(mod: Module, parent_scope: Scope, node: *ast.Node, statement
563	scope = try varDecl(mod, scope, var_decl_node, &block_arena.allocator);	645	scope = try varDecl(mod, scope, var_decl_node, &block_arena.allocator);
564	},	646	},
565	.Assign => try assign(mod, scope, statement.castTag(.Assign).?),	647	.Assign => try assign(mod, scope, statement.castTag(.Assign).?),
566	.AssignBitAnd => try assignOp(mod, scope, statement.castTag(.AssignBitAnd).?, .bitand),	648	.AssignBitAnd => try assignOp(mod, scope, statement.castTag(.AssignBitAnd).?, .bit_and),
567	.AssignBitOr => try assignOp(mod, scope, statement.castTag(.AssignBitOr).?, .bitor),	649	.AssignBitOr => try assignOp(mod, scope, statement.castTag(.AssignBitOr).?, .bit_or),
568	.AssignBitShiftLeft => try assignOp(mod, scope, statement.castTag(.AssignBitShiftLeft).?, .shl),	650	.AssignBitShiftLeft => try assignOp(mod, scope, statement.castTag(.AssignBitShiftLeft).?, .shl),
569	.AssignBitShiftRight => try assignOp(mod, scope, statement.castTag(.AssignBitShiftRight).?, .shr),	651	.AssignBitShiftRight => try assignOp(mod, scope, statement.castTag(.AssignBitShiftRight).?, .shr),
570	.AssignBitXor => try assignOp(mod, scope, statement.castTag(.AssignBitXor).?, .xor),	652	.AssignBitXor => try assignOp(mod, scope, statement.castTag(.AssignBitXor).?, .xor),
...	@@ -644,6 +726,7 @@ fn varDecl(	...	@@ -644,6 +726,7 @@ fn varDecl(
644		726
645	// Namespace vars shadowing detection	727	// Namespace vars shadowing detection
646	if (mod.lookupDeclName(scope, ident_name)) \|_\| {	728	if (mod.lookupDeclName(scope, ident_name)) \|_\| {
		729	// TODO add note for other definition
647	return mod.fail(scope, name_src, "redefinition of '{s}'", .{ident_name});	730	return mod.fail(scope, name_src, "redefinition of '{s}'", .{ident_name});
648	}	731	}
649	const init_node = node.getInitNode() orelse	732	const init_node = node.getInitNode() orelse
...	@@ -651,36 +734,103 @@ fn varDecl(	...	@@ -651,36 +734,103 @@ fn varDecl(
651		734
652	switch (tree.token_ids[node.mut_token]) {	735	switch (tree.token_ids[node.mut_token]) {
653	.Keyword_const => {	736	.Keyword_const => {
654	var resolve_inferred_alloc: ?*zir.Inst = null;
655	// Depending on the type of AST the initialization expression is, we may need an lvalue	737	// Depending on the type of AST the initialization expression is, we may need an lvalue
656	// or an rvalue as a result location. If it is an rvalue, we can use the instruction as	738	// or an rvalue as a result location. If it is an rvalue, we can use the instruction as
657	// the variable, no memory location needed.	739	// the variable, no memory location needed.
658	const result_loc = if (nodeMayNeedMemoryLocation(init_node, scope)) r: {	740	if (!nodeMayNeedMemoryLocation(init_node, scope)) {
659	if (node.getTypeNode()) \|type_node\| {	741	const result_loc: ResultLoc = if (node.getTypeNode()) \|type_node\|
660	const type_inst = try typeExpr(mod, scope, type_node);	742	.{ .ty = try typeExpr(mod, scope, type_node) }
661	const alloc = try addZIRUnOp(mod, scope, name_src, .alloc, type_inst);
662	break :r ResultLoc{ .ptr = alloc };
663	} else {
664	const alloc = try addZIRNoOpT(mod, scope, name_src, .alloc_inferred);
665	resolve_inferred_alloc = &alloc.base;
666	break :r ResultLoc{ .inferred_ptr = alloc };
667	}
668	} else r: {
669	if (node.getTypeNode()) \|type_node\|
670	break :r ResultLoc{ .ty = try typeExpr(mod, scope, type_node) }
671	else	743	else
672	break :r .none;	744	.none;
		745	const init_inst = try expr(mod, scope, result_loc, init_node);
		746	const sub_scope = try block_arena.create(Scope.LocalVal);
		747	sub_scope.* = .{
		748	.parent = scope,
		749	.gen_zir = scope.getGenZIR(),
		750	.name = ident_name,
		751	.inst = init_inst,
		752	};
		753	return &sub_scope.base;
		754	}
		755
		756	// Detect whether the initialization expression actually uses the
		757	// result location pointer.
		758	var init_scope: Scope.GenZIR = .{
		759	.parent = scope,
		760	.decl = scope.ownerDecl().?,
		761	.arena = scope.arena(),
		762	.force_comptime = scope.isComptime(),
		763	.instructions = .{},
673	};	764	};
674	const init_inst = try expr(mod, scope, result_loc, init_node);	765	defer init_scope.instructions.deinit(mod.gpa);
		766
		767	var resolve_inferred_alloc: ?*zir.Inst = null;
		768	var opt_type_inst: ?*zir.Inst = null;
		769	if (node.getTypeNode()) \|type_node\| {
		770	const type_inst = try typeExpr(mod, &init_scope.base, type_node);
		771	opt_type_inst = type_inst;
		772	init_scope.rl_ptr = try addZIRUnOp(mod, &init_scope.base, name_src, .alloc, type_inst);
		773	} else {
		774	const alloc = try addZIRNoOpT(mod, &init_scope.base, name_src, .alloc_inferred);
		775	resolve_inferred_alloc = &alloc.base;
		776	init_scope.rl_ptr = &alloc.base;
		777	}
		778	const init_result_loc: ResultLoc = .{ .block_ptr = &init_scope };
		779	const init_inst = try expr(mod, &init_scope.base, init_result_loc, init_node);
		780	const parent_zir = &scope.getGenZIR().instructions;
		781	if (init_scope.rvalue_rl_count == 1) {
		782	// Result location pointer not used. We don't need an alloc for this
		783	// const local, and type inference becomes trivial.
		784	// Move the init_scope instructions into the parent scope, eliding
		785	// the alloc instruction and the store_to_block_ptr instruction.
		786	const expected_len = parent_zir.items.len + init_scope.instructions.items.len - 2;
		787	try parent_zir.ensureCapacity(mod.gpa, expected_len);
		788	for (init_scope.instructions.items) \|src_inst\| {
		789	if (src_inst == init_scope.rl_ptr.?) continue;
		790	if (src_inst.castTag(.store_to_block_ptr)) \|store\| {
		791	if (store.positionals.lhs == init_scope.rl_ptr.?) continue;
		792	}
		793	parent_zir.appendAssumeCapacity(src_inst);
		794	}
		795	assert(parent_zir.items.len == expected_len);
		796	const casted_init = if (opt_type_inst) \|type_inst\|
		797	try addZIRBinOp(mod, scope, type_inst.src, .as, type_inst, init_inst)
		798	else
		799	init_inst;
		800
		801	const sub_scope = try block_arena.create(Scope.LocalVal);
		802	sub_scope.* = .{
		803	.parent = scope,
		804	.gen_zir = scope.getGenZIR(),
		805	.name = ident_name,
		806	.inst = casted_init,
		807	};
		808	return &sub_scope.base;
		809	}
		810	// The initialization expression took advantage of the result location
		811	// of the const local. In this case we will create an alloc and a LocalPtr for it.
		812	// Move the init_scope instructions into the parent scope, swapping
		813	// store_to_block_ptr for store_to_inferred_ptr.
		814	const expected_len = parent_zir.items.len + init_scope.instructions.items.len;
		815	try parent_zir.ensureCapacity(mod.gpa, expected_len);
		816	for (init_scope.instructions.items) \|src_inst\| {
		817	if (src_inst.castTag(.store_to_block_ptr)) \|store\| {
		818	if (store.positionals.lhs == init_scope.rl_ptr.?) {
		819	src_inst.tag = .store_to_inferred_ptr;
		820	}
		821	}
		822	parent_zir.appendAssumeCapacity(src_inst);
		823	}
		824	assert(parent_zir.items.len == expected_len);
675	if (resolve_inferred_alloc) \|inst\| {	825	if (resolve_inferred_alloc) \|inst\| {
676	_ = try addZIRUnOp(mod, scope, name_src, .resolve_inferred_alloc, inst);	826	_ = try addZIRUnOp(mod, scope, name_src, .resolve_inferred_alloc, inst);
677	}	827	}
678	const sub_scope = try block_arena.create(Scope.LocalVal);	828	const sub_scope = try block_arena.create(Scope.LocalPtr);
679	sub_scope.* = .{	829	sub_scope.* = .{
680	.parent = scope,	830	.parent = scope,
681	.gen_zir = scope.getGenZIR(),	831	.gen_zir = scope.getGenZIR(),
682	.name = ident_name,	832	.name = ident_name,
683	.inst = init_inst,	833	.ptr = init_scope.rl_ptr.?,
684	};	834	};
685	return &sub_scope.base;	835	return &sub_scope.base;
686	},	836	},
...	@@ -751,14 +901,14 @@ fn boolNot(mod: Module, scope: Scope, node: *ast.Node.SimplePrefixOp) InnerErr	...	@@ -751,14 +901,14 @@ fn boolNot(mod: Module, scope: Scope, node: *ast.Node.SimplePrefixOp) InnerErr
751	.val = Value.initTag(.bool_type),	901	.val = Value.initTag(.bool_type),
752	});	902	});
753	const operand = try expr(mod, scope, .{ .ty = bool_type }, node.rhs);	903	const operand = try expr(mod, scope, .{ .ty = bool_type }, node.rhs);
754	return addZIRUnOp(mod, scope, src, .boolnot, operand);	904	return addZIRUnOp(mod, scope, src, .bool_not, operand);
755	}	905	}
756		906
757	fn bitNot(mod: Module, scope: Scope, node: ast.Node.SimplePrefixOp) InnerError!zir.Inst {	907	fn bitNot(mod: Module, scope: Scope, node: ast.Node.SimplePrefixOp) InnerError!zir.Inst {
758	const tree = scope.tree();	908	const tree = scope.tree();
759	const src = tree.token_locs[node.op_token].start;	909	const src = tree.token_locs[node.op_token].start;
760	const operand = try expr(mod, scope, .none, node.rhs);	910	const operand = try expr(mod, scope, .none, node.rhs);
761	return addZIRUnOp(mod, scope, src, .bitnot, operand);	911	return addZIRUnOp(mod, scope, src, .bit_not, operand);
762	}	912	}
763		913
764	fn negation(mod: Module, scope: Scope, node: ast.Node.SimplePrefixOp, op_inst_tag: zir.Inst.Tag) InnerError!zir.Inst {	914	fn negation(mod: Module, scope: Scope, node: ast.Node.SimplePrefixOp, op_inst_tag: zir.Inst.Tag) InnerError!zir.Inst {
...	@@ -971,6 +1121,7 @@ fn containerDecl(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Con	...	@@ -971,6 +1121,7 @@ fn containerDecl(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Con
971	.parent = scope,	1121	.parent = scope,
972	.decl = scope.ownerDecl().?,	1122	.decl = scope.ownerDecl().?,
973	.arena = scope.arena(),	1123	.arena = scope.arena(),
		1124	.force_comptime = scope.isComptime(),
974	.instructions = .{},	1125	.instructions = .{},
975	};	1126	};
976	defer gen_scope.instructions.deinit(mod.gpa);	1127	defer gen_scope.instructions.deinit(mod.gpa);
...	@@ -1101,7 +1252,7 @@ fn containerDecl(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Con	...	@@ -1101,7 +1252,7 @@ fn containerDecl(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Con
1101	if (rl == .ref) {	1252	if (rl == .ref) {
1102	return addZIRInst(mod, scope, src, zir.Inst.DeclRef, .{ .decl = decl }, .{});	1253	return addZIRInst(mod, scope, src, zir.Inst.DeclRef, .{ .decl = decl }, .{});
1103	} else {	1254	} else {
1104	return rlWrap(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.DeclVal, .{	1255	return rvalue(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.DeclVal, .{
1105	.decl = decl,	1256	.decl = decl,
1106	}, .{}));	1257	}, .{}));
1107	}	1258	}
...	@@ -1207,24 +1358,15 @@ fn orelseCatchExpr(	...	@@ -1207,24 +1358,15 @@ fn orelseCatchExpr(
1207	.parent = scope,	1358	.parent = scope,
1208	.decl = scope.ownerDecl().?,	1359	.decl = scope.ownerDecl().?,
1209	.arena = scope.arena(),	1360	.arena = scope.arena(),
		1361	.force_comptime = scope.isComptime(),
1210	.instructions = .{},	1362	.instructions = .{},
1211	};	1363	};
		1364	setBlockResultLoc(&block_scope, rl);
1212	defer block_scope.instructions.deinit(mod.gpa);	1365	defer block_scope.instructions.deinit(mod.gpa);
1213		1366
1214	const block = try addZIRInstBlock(mod, scope, src, .block, .{
1215	.instructions = undefined, // populated below
1216	});
1217
1218	// Most result location types can be forwarded directly; however
1219	// if we need to write to a pointer which has an inferred type,
1220	// proper type inference requires peer type resolution on the if's
1221	// branches.
1222	const branch_rl: ResultLoc = switch (rl) {
1223	.discard, .none, .ty, .ptr, .ref => rl,
1224	.inferred_ptr, .bitcasted_ptr, .block_ptr => .{ .block_ptr = block },
1225	};
1226	// This could be a pointer or value depending on the `rl` parameter.	1367	// This could be a pointer or value depending on the `rl` parameter.
1227	const operand = try expr(mod, &block_scope.base, branch_rl, lhs);	1368	block_scope.break_count += 1;
		1369	const operand = try expr(mod, &block_scope.base, block_scope.break_result_loc, lhs);
1228	const cond = try addZIRUnOp(mod, &block_scope.base, src, cond_op, operand);	1370	const cond = try addZIRUnOp(mod, &block_scope.base, src, cond_op, operand);
1229		1371
1230	const condbr = try addZIRInstSpecial(mod, &block_scope.base, src, zir.Inst.CondBr, .{	1372	const condbr = try addZIRInstSpecial(mod, &block_scope.base, src, zir.Inst.CondBr, .{
...	@@ -1233,18 +1375,22 @@ fn orelseCatchExpr(	...	@@ -1233,18 +1375,22 @@ fn orelseCatchExpr(
1233	.else_body = undefined, // populated below	1375	.else_body = undefined, // populated below
1234	}, .{});	1376	}, .{});
1235		1377
		1378	const block = try addZIRInstBlock(mod, scope, src, .block, .{
		1379	.instructions = try block_scope.arena.dupe(*zir.Inst, block_scope.instructions.items),
		1380	});
		1381
1236	var then_scope: Scope.GenZIR = .{	1382	var then_scope: Scope.GenZIR = .{
1237	.parent = &block_scope.base,	1383	.parent = &block_scope.base,
1238	.decl = block_scope.decl,	1384	.decl = block_scope.decl,
1239	.arena = block_scope.arena,	1385	.arena = block_scope.arena,
		1386	.force_comptime = block_scope.force_comptime,
1240	.instructions = .{},	1387	.instructions = .{},
1241	};	1388	};
1242	defer then_scope.instructions.deinit(mod.gpa);	1389	defer then_scope.instructions.deinit(mod.gpa);
1243		1390
1244	var err_val_scope: Scope.LocalVal = undefined;	1391	var err_val_scope: Scope.LocalVal = undefined;
1245	const then_sub_scope = blk: {	1392	const then_sub_scope = blk: {
1246	const payload = payload_node orelse	1393	const payload = payload_node orelse break :blk &then_scope.base;
1247	break :blk &then_scope.base;
1248		1394
1249	const err_name = tree.tokenSlice(payload.castTag(.Payload).?.error_symbol.firstToken());	1395	const err_name = tree.tokenSlice(payload.castTag(.Payload).?.error_symbol.firstToken());
1250	if (mem.eql(u8, err_name, "_"))	1396	if (mem.eql(u8, err_name, "_"))
...	@@ -1259,32 +1405,113 @@ fn orelseCatchExpr(	...	@@ -1259,32 +1405,113 @@ fn orelseCatchExpr(
1259	break :blk &err_val_scope.base;	1405	break :blk &err_val_scope.base;
1260	};	1406	};
1261		1407
1262	_ = try addZIRInst(mod, &then_scope.base, src, zir.Inst.Break, .{	1408	block_scope.break_count += 1;
1263	.block = block,	1409	const then_result = try expr(mod, then_sub_scope, block_scope.break_result_loc, rhs);
1264	.operand = try expr(mod, then_sub_scope, branch_rl, rhs),
1265	}, .{});
1266		1410
1267	var else_scope: Scope.GenZIR = .{	1411	var else_scope: Scope.GenZIR = .{
1268	.parent = &block_scope.base,	1412	.parent = &block_scope.base,
1269	.decl = block_scope.decl,	1413	.decl = block_scope.decl,
1270	.arena = block_scope.arena,	1414	.arena = block_scope.arena,
		1415	.force_comptime = block_scope.force_comptime,
1271	.instructions = .{},	1416	.instructions = .{},
1272	};	1417	};
1273	defer else_scope.instructions.deinit(mod.gpa);	1418	defer else_scope.instructions.deinit(mod.gpa);
1274		1419
1275	// This could be a pointer or value depending on `unwrap_op`.	1420	// This could be a pointer or value depending on `unwrap_op`.
1276	const unwrapped_payload = try addZIRUnOp(mod, &else_scope.base, src, unwrap_op, operand);	1421	const unwrapped_payload = try addZIRUnOp(mod, &else_scope.base, src, unwrap_op, operand);
1277	_ = try addZIRInst(mod, &else_scope.base, src, zir.Inst.Break, .{
1278	.block = block,
1279	.operand = unwrapped_payload,
1280	}, .{});
1281		1422
1282	// All branches have been generated, add the instructions to the block.	1423	return finishThenElseBlock(
1283	block.positionals.body.instructions = try block_scope.arena.dupe(*zir.Inst, block_scope.instructions.items);	1424	mod,
		1425	scope,
		1426	rl,
		1427	&block_scope,
		1428	&then_scope,
		1429	&else_scope,
		1430	&condbr.positionals.then_body,
		1431	&condbr.positionals.else_body,
		1432	src,
		1433	src,
		1434	then_result,
		1435	unwrapped_payload,
		1436	block,
		1437	block,
		1438	);
		1439	}
1284		1440
1285	condbr.positionals.then_body = .{ .instructions = try then_scope.arena.dupe(*zir.Inst, then_scope.instructions.items) };	1441	fn finishThenElseBlock(
1286	condbr.positionals.else_body = .{ .instructions = try else_scope.arena.dupe(*zir.Inst, else_scope.instructions.items) };	1442	mod: *Module,
1287	return &block.base;	1443	parent_scope: *Scope,
		1444	rl: ResultLoc,
		1445	block_scope: *Scope.GenZIR,
		1446	then_scope: *Scope.GenZIR,
		1447	else_scope: *Scope.GenZIR,
		1448	then_body: *zir.Body,
		1449	else_body: *zir.Body,
		1450	then_src: usize,
		1451	else_src: usize,
		1452	then_result: *zir.Inst,
		1453	else_result: ?*zir.Inst,
		1454	main_block: *zir.Inst.Block,
		1455	then_break_block: *zir.Inst.Block,
		1456	) InnerError!*zir.Inst {
		1457	// We now have enough information to decide whether the result instruction should
		1458	// be communicated via result location pointer or break instructions.
		1459	const strat = rlStrategy(rl, block_scope);
		1460	switch (strat.tag) {
		1461	.break_void => {
		1462	if (!then_result.tag.isNoReturn()) {
		1463	_ = try addZirInstTag(mod, &then_scope.base, then_src, .break_void, .{
		1464	.block = then_break_block,
		1465	});
		1466	}
		1467	if (else_result) \|inst\| {
		1468	if (!inst.tag.isNoReturn()) {
		1469	_ = try addZirInstTag(mod, &else_scope.base, else_src, .break_void, .{
		1470	.block = main_block,
		1471	});
		1472	}
		1473	} else {
		1474	_ = try addZirInstTag(mod, &else_scope.base, else_src, .break_void, .{
		1475	.block = main_block,
		1476	});
		1477	}
		1478	assert(!strat.elide_store_to_block_ptr_instructions);
		1479	try copyBodyNoEliding(then_body, then_scope.*);
		1480	try copyBodyNoEliding(else_body, else_scope.*);
		1481	return &main_block.base;
		1482	},
		1483	.break_operand => {
		1484	if (!then_result.tag.isNoReturn()) {
		1485	_ = try addZirInstTag(mod, &then_scope.base, then_src, .@"break", .{
		1486	.block = then_break_block,
		1487	.operand = then_result,
		1488	});
		1489	}
		1490	if (else_result) \|inst\| {
		1491	if (!inst.tag.isNoReturn()) {
		1492	_ = try addZirInstTag(mod, &else_scope.base, else_src, .@"break", .{
		1493	.block = main_block,
		1494	.operand = inst,
		1495	});
		1496	}
		1497	} else {
		1498	_ = try addZirInstTag(mod, &else_scope.base, else_src, .break_void, .{
		1499	.block = main_block,
		1500	});
		1501	}
		1502	if (strat.elide_store_to_block_ptr_instructions) {
		1503	try copyBodyWithElidedStoreBlockPtr(then_body, then_scope.*);
		1504	try copyBodyWithElidedStoreBlockPtr(else_body, else_scope.*);
		1505	} else {
		1506	try copyBodyNoEliding(then_body, then_scope.*);
		1507	try copyBodyNoEliding(else_body, else_scope.*);
		1508	}
		1509	switch (rl) {
		1510	.ref => return &main_block.base,
		1511	else => return rvalue(mod, parent_scope, rl, &main_block.base),
		1512	}
		1513	},
		1514	}
1288	}	1515	}
1289		1516
1290	/// Return whether the identifier names of two tokens are equal. Resolves @""	1517	/// Return whether the identifier names of two tokens are equal. Resolves @""
...	@@ -1308,7 +1535,7 @@ pub fn field(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.SimpleI	...	@@ -1308,7 +1535,7 @@ pub fn field(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.SimpleI
1308	.field_name = field_name,	1535	.field_name = field_name,
1309	});	1536	});
1310	}	1537	}
1311	return rlWrap(mod, scope, rl, try addZirInstTag(mod, scope, src, .field_val, .{	1538	return rvalue(mod, scope, rl, try addZirInstTag(mod, scope, src, .field_val, .{
1312	.object = try expr(mod, scope, .none, node.lhs),	1539	.object = try expr(mod, scope, .none, node.lhs),
1313	.field_name = field_name,	1540	.field_name = field_name,
1314	}));	1541	}));
...	@@ -1338,7 +1565,7 @@ fn namedField(	...	@@ -1338,7 +1565,7 @@ fn namedField(
1338	.field_name = try comptimeExpr(mod, scope, string_rl, params[1]),	1565	.field_name = try comptimeExpr(mod, scope, string_rl, params[1]),
1339	});	1566	});
1340	}	1567	}
1341	return rlWrap(mod, scope, rl, try addZirInstTag(mod, scope, src, .field_val_named, .{	1568	return rvalue(mod, scope, rl, try addZirInstTag(mod, scope, src, .field_val_named, .{
1342	.object = try expr(mod, scope, .none, params[0]),	1569	.object = try expr(mod, scope, .none, params[0]),
1343	.field_name = try comptimeExpr(mod, scope, string_rl, params[1]),	1570	.field_name = try comptimeExpr(mod, scope, string_rl, params[1]),
1344	}));	1571	}));
...	@@ -1359,7 +1586,7 @@ fn arrayAccess(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Array	...	@@ -1359,7 +1586,7 @@ fn arrayAccess(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Array
1359	.index = try expr(mod, scope, index_rl, node.index_expr),	1586	.index = try expr(mod, scope, index_rl, node.index_expr),
1360	});	1587	});
1361	}	1588	}
1362	return rlWrap(mod, scope, rl, try addZirInstTag(mod, scope, src, .elem_val, .{	1589	return rvalue(mod, scope, rl, try addZirInstTag(mod, scope, src, .elem_val, .{
1363	.array = try expr(mod, scope, .none, node.lhs),	1590	.array = try expr(mod, scope, .none, node.lhs),
1364	.index = try expr(mod, scope, index_rl, node.index_expr),	1591	.index = try expr(mod, scope, index_rl, node.index_expr),
1365	}));	1592	}));
...	@@ -1416,7 +1643,7 @@ fn simpleBinOp(	...	@@ -1416,7 +1643,7 @@ fn simpleBinOp(
1416	const rhs = try expr(mod, scope, .none, infix_node.rhs);	1643	const rhs = try expr(mod, scope, .none, infix_node.rhs);
1417		1644
1418	const result = try addZIRBinOp(mod, scope, src, op_inst_tag, lhs, rhs);	1645	const result = try addZIRBinOp(mod, scope, src, op_inst_tag, lhs, rhs);
1419	return rlWrap(mod, scope, rl, result);	1646	return rvalue(mod, scope, rl, result);
1420	}	1647	}
1421		1648
1422	fn boolBinOp(	1649	fn boolBinOp(
...	@@ -1436,6 +1663,7 @@ fn boolBinOp(	...	@@ -1436,6 +1663,7 @@ fn boolBinOp(
1436	.parent = scope,	1663	.parent = scope,
1437	.decl = scope.ownerDecl().?,	1664	.decl = scope.ownerDecl().?,
1438	.arena = scope.arena(),	1665	.arena = scope.arena(),
		1666	.force_comptime = scope.isComptime(),
1439	.instructions = .{},	1667	.instructions = .{},
1440	};	1668	};
1441	defer block_scope.instructions.deinit(mod.gpa);	1669	defer block_scope.instructions.deinit(mod.gpa);
...	@@ -1455,6 +1683,7 @@ fn boolBinOp(	...	@@ -1455,6 +1683,7 @@ fn boolBinOp(
1455	.parent = scope,	1683	.parent = scope,
1456	.decl = block_scope.decl,	1684	.decl = block_scope.decl,
1457	.arena = block_scope.arena,	1685	.arena = block_scope.arena,
		1686	.force_comptime = block_scope.force_comptime,
1458	.instructions = .{},	1687	.instructions = .{},
1459	};	1688	};
1460	defer rhs_scope.instructions.deinit(mod.gpa);	1689	defer rhs_scope.instructions.deinit(mod.gpa);
...	@@ -1469,6 +1698,7 @@ fn boolBinOp(	...	@@ -1469,6 +1698,7 @@ fn boolBinOp(
1469	.parent = scope,	1698	.parent = scope,
1470	.decl = block_scope.decl,	1699	.decl = block_scope.decl,
1471	.arena = block_scope.arena,	1700	.arena = block_scope.arena,
		1701	.force_comptime = block_scope.force_comptime,
1472	.instructions = .{},	1702	.instructions = .{},
1473	};	1703	};
1474	defer const_scope.instructions.deinit(mod.gpa);	1704	defer const_scope.instructions.deinit(mod.gpa);
...	@@ -1498,7 +1728,7 @@ fn boolBinOp(	...	@@ -1498,7 +1728,7 @@ fn boolBinOp(
1498	condbr.positionals.else_body = .{ .instructions = try rhs_scope.arena.dupe(*zir.Inst, rhs_scope.instructions.items) };	1728	condbr.positionals.else_body = .{ .instructions = try rhs_scope.arena.dupe(*zir.Inst, rhs_scope.instructions.items) };
1499	}	1729	}
1500		1730
1501	return rlWrap(mod, scope, rl, &block.base);	1731	return rvalue(mod, scope, rl, &block.base);
1502	}	1732	}
1503		1733
1504	const CondKind = union(enum) {	1734	const CondKind = union(enum) {
...	@@ -1582,8 +1812,10 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn	...	@@ -1582,8 +1812,10 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
1582	.parent = scope,	1812	.parent = scope,
1583	.decl = scope.ownerDecl().?,	1813	.decl = scope.ownerDecl().?,
1584	.arena = scope.arena(),	1814	.arena = scope.arena(),
		1815	.force_comptime = scope.isComptime(),
1585	.instructions = .{},	1816	.instructions = .{},
1586	};	1817	};
		1818	setBlockResultLoc(&block_scope, rl);
1587	defer block_scope.instructions.deinit(mod.gpa);	1819	defer block_scope.instructions.deinit(mod.gpa);
1588		1820
1589	const tree = scope.tree();	1821	const tree = scope.tree();
...	@@ -1605,6 +1837,7 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn	...	@@ -1605,6 +1837,7 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
1605	.parent = scope,	1837	.parent = scope,
1606	.decl = block_scope.decl,	1838	.decl = block_scope.decl,
1607	.arena = block_scope.arena,	1839	.arena = block_scope.arena,
		1840	.force_comptime = block_scope.force_comptime,
1608	.instructions = .{},	1841	.instructions = .{},
1609	};	1842	};
1610	defer then_scope.instructions.deinit(mod.gpa);	1843	defer then_scope.instructions.deinit(mod.gpa);
...	@@ -1612,62 +1845,81 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn	...	@@ -1612,62 +1845,81 @@ fn ifExpr(mod: Module, scope: Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
1612	// declare payload to the then_scope	1845	// declare payload to the then_scope
1613	const then_sub_scope = try cond_kind.thenSubScope(mod, &then_scope, then_src, if_node.payload);	1846	const then_sub_scope = try cond_kind.thenSubScope(mod, &then_scope, then_src, if_node.payload);
1614		1847
1615	// Most result location types can be forwarded directly; however	1848	block_scope.break_count += 1;
1616	// if we need to write to a pointer which has an inferred type,	1849	const then_result = try expr(mod, then_sub_scope, block_scope.break_result_loc, if_node.body);
1617	// proper type inference requires peer type resolution on the if's	1850	// We hold off on the break instructions as well as copying the then/else
1618	// branches.	1851	// instructions into place until we know whether to keep store_to_block_ptr
1619	const branch_rl: ResultLoc = switch (rl) {	1852	// instructions or not.
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);
1625	if (!then_result.tag.isNoReturn()) {
1626	_ = try addZIRInst(mod, then_sub_scope, then_src, zir.Inst.Break, .{
1627	.block = block,
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		1853
1635	var else_scope: Scope.GenZIR = .{	1854	var else_scope: Scope.GenZIR = .{
1636	.parent = scope,	1855	.parent = scope,
1637	.decl = block_scope.decl,	1856	.decl = block_scope.decl,
1638	.arena = block_scope.arena,	1857	.arena = block_scope.arena,
		1858	.force_comptime = block_scope.force_comptime,
1639	.instructions = .{},	1859	.instructions = .{},
1640	};	1860	};
1641	defer else_scope.instructions.deinit(mod.gpa);	1861	defer else_scope.instructions.deinit(mod.gpa);
1642		1862
1643	if (if_node.@"else") \|else_node\| {	1863	var else_src: usize = undefined;
1644	const else_src = tree.token_locs[else_node.body.lastToken()].start;	1864	var else_sub_scope: *Module.Scope = undefined;
		1865	const else_result: ?*zir.Inst = if (if_node.@"else") \|else_node\| blk: {
		1866	else_src = tree.token_locs[else_node.body.lastToken()].start;
1645	// declare payload to the then_scope	1867	// declare payload to the then_scope
1646	const else_sub_scope = try cond_kind.elseSubScope(mod, &else_scope, else_src, else_node.payload);	1868	else_sub_scope = try cond_kind.elseSubScope(mod, &else_scope, else_src, else_node.payload);
		1869
		1870	block_scope.break_count += 1;
		1871	break :blk try expr(mod, else_sub_scope, block_scope.break_result_loc, else_node.body);
		1872	} else blk: {
		1873	else_src = tree.token_locs[if_node.lastToken()].start;
		1874	else_sub_scope = &else_scope.base;
		1875	break :blk null;
		1876	};
1647		1877
1648	const else_result = try expr(mod, else_sub_scope, branch_rl, else_node.body);	1878	return finishThenElseBlock(
1649	if (!else_result.tag.isNoReturn()) {	1879	mod,
1650	_ = try addZIRInst(mod, else_sub_scope, else_src, zir.Inst.Break, .{	1880	scope,
1651	.block = block,	1881	rl,
1652	.operand = else_result,	1882	&block_scope,
1653	}, .{});	1883	&then_scope,
		1884	&else_scope,
		1885	&condbr.positionals.then_body,
		1886	&condbr.positionals.else_body,
		1887	then_src,
		1888	else_src,
		1889	then_result,
		1890	else_result,
		1891	block,
		1892	block,
		1893	);
		1894	}
		1895
		1896	/// Expects to find exactly 1 .store_to_block_ptr instruction.
		1897	fn copyBodyWithElidedStoreBlockPtr(body: *zir.Body, scope: Module.Scope.GenZIR) !void {
		1898	body.* = .{
		1899	.instructions = try scope.arena.alloc(*zir.Inst, scope.instructions.items.len - 1),
		1900	};
		1901	var dst_index: usize = 0;
		1902	for (scope.instructions.items) \|src_inst\| {
		1903	if (src_inst.tag != .store_to_block_ptr) {
		1904	body.instructions[dst_index] = src_inst;
		1905	dst_index += 1;
1654	}	1906	}
1655	} else {
1656	// TODO Optimization opportunity: we can avoid an allocation and a memcpy here
1657	// by directly allocating the body for this one instruction.
1658	const else_src = tree.token_locs[if_node.lastToken()].start;
1659	_ = try addZIRInst(mod, &else_scope.base, else_src, zir.Inst.BreakVoid, .{
1660	.block = block,
1661	}, .{});
1662	}	1907	}
1663	condbr.positionals.else_body = .{	1908	assert(dst_index == body.instructions.len);
1664	.instructions = try else_scope.arena.dupe(*zir.Inst, else_scope.instructions.items),	1909	}
1665	};
1666		1910
1667	return &block.base;	1911	fn copyBodyNoEliding(body: *zir.Body, scope: Module.Scope.GenZIR) !void {
		1912	body.* = .{
		1913	.instructions = try scope.arena.dupe(*zir.Inst, scope.instructions.items),
		1914	};
1668	}	1915	}
1669		1916
1670	fn whileExpr(mod: Module, scope: Scope, rl: ResultLoc, while_node: ast.Node.While) InnerError!zir.Inst {	1917	fn whileExpr(
		1918	mod: *Module,
		1919	scope: *Scope,
		1920	rl: ResultLoc,
		1921	while_node: *ast.Node.While,
		1922	) InnerError!*zir.Inst {
1671	var cond_kind: CondKind = .bool;	1923	var cond_kind: CondKind = .bool;
1672	if (while_node.payload) \|_\| cond_kind = .{ .optional = null };	1924	if (while_node.payload) \|_\| cond_kind = .{ .optional = null };
1673	if (while_node.@"else") \|else_node\| {	1925	if (while_node.@"else") \|else_node\| {
...	@@ -1683,27 +1935,21 @@ fn whileExpr(mod: Module, scope: Scope, rl: ResultLoc, while_node: *ast.Node.W	...	@@ -1683,27 +1935,21 @@ fn whileExpr(mod: Module, scope: Scope, rl: ResultLoc, while_node: *ast.Node.W
1683	if (while_node.inline_token) \|tok\|	1935	if (while_node.inline_token) \|tok\|
1684	return mod.failTok(scope, tok, "TODO inline while", .{});	1936	return mod.failTok(scope, tok, "TODO inline while", .{});
1685		1937
1686	var expr_scope: Scope.GenZIR = .{	1938	var loop_scope: Scope.GenZIR = .{
1687	.parent = scope,	1939	.parent = scope,
1688	.decl = scope.ownerDecl().?,	1940	.decl = scope.ownerDecl().?,
1689	.arena = scope.arena(),	1941	.arena = scope.arena(),
		1942	.force_comptime = scope.isComptime(),
1690	.instructions = .{},	1943	.instructions = .{},
1691	};	1944	};
1692	defer expr_scope.instructions.deinit(mod.gpa);	1945	setBlockResultLoc(&loop_scope, rl);
1693
1694	var loop_scope: Scope.GenZIR = .{
1695	.parent = &expr_scope.base,
1696	.decl = expr_scope.decl,
1697	.arena = expr_scope.arena,
1698	.instructions = .{},
1699	.break_result_loc = rl,
1700	};
1701	defer loop_scope.instructions.deinit(mod.gpa);	1946	defer loop_scope.instructions.deinit(mod.gpa);
1702		1947
1703	var continue_scope: Scope.GenZIR = .{	1948	var continue_scope: Scope.GenZIR = .{
1704	.parent = &loop_scope.base,	1949	.parent = &loop_scope.base,
1705	.decl = loop_scope.decl,	1950	.decl = loop_scope.decl,
1706	.arena = loop_scope.arena,	1951	.arena = loop_scope.arena,
		1952	.force_comptime = loop_scope.force_comptime,
1707	.instructions = .{},	1953	.instructions = .{},
1708	};	1954	};
1709	defer continue_scope.instructions.deinit(mod.gpa);	1955	defer continue_scope.instructions.deinit(mod.gpa);
...	@@ -1731,11 +1977,21 @@ fn whileExpr(mod: Module, scope: Scope, rl: ResultLoc, while_node: *ast.Node.W	...	@@ -1731,11 +1977,21 @@ fn whileExpr(mod: Module, scope: Scope, rl: ResultLoc, while_node: *ast.Node.W
1731	if (while_node.continue_expr) \|cont_expr\| {	1977	if (while_node.continue_expr) \|cont_expr\| {
1732	_ = try expr(mod, &loop_scope.base, .{ .ty = void_type }, cont_expr);	1978	_ = try expr(mod, &loop_scope.base, .{ .ty = void_type }, cont_expr);
1733	}	1979	}
1734	const loop = try addZIRInstLoop(mod, &expr_scope.base, while_src, .{	1980	const loop = try scope.arena().create(zir.Inst.Loop);
1735	.instructions = try expr_scope.arena.dupe(*zir.Inst, loop_scope.instructions.items),	1981	loop.* = .{
1736	});	1982	.base = .{
		1983	.tag = .loop,
		1984	.src = while_src,
		1985	},
		1986	.positionals = .{
		1987	.body = .{
		1988	.instructions = try scope.arena().dupe(*zir.Inst, loop_scope.instructions.items),
		1989	},
		1990	},
		1991	.kw_args = .{},
		1992	};
1737	const while_block = try addZIRInstBlock(mod, scope, while_src, .block, .{	1993	const while_block = try addZIRInstBlock(mod, scope, while_src, .block, .{
1738	.instructions = try expr_scope.arena.dupe(*zir.Inst, expr_scope.instructions.items),	1994	.instructions = try scope.arena().dupe(zir.Inst, &[1]zir.Inst{&loop.base}),
1739	});	1995	});
1740	loop_scope.break_block = while_block;	1996	loop_scope.break_block = while_block;
1741	loop_scope.continue_block = cond_block;	1997	loop_scope.continue_block = cond_block;
...	@@ -1751,6 +2007,7 @@ fn whileExpr(mod: Module, scope: Scope, rl: ResultLoc, while_node: *ast.Node.W	...	@@ -1751,6 +2007,7 @@ fn whileExpr(mod: Module, scope: Scope, rl: ResultLoc, while_node: *ast.Node.W
1751	.parent = &continue_scope.base,	2007	.parent = &continue_scope.base,
1752	.decl = continue_scope.decl,	2008	.decl = continue_scope.decl,
1753	.arena = continue_scope.arena,	2009	.arena = continue_scope.arena,
		2010	.force_comptime = continue_scope.force_comptime,
1754	.instructions = .{},	2011	.instructions = .{},
1755	};	2012	};
1756	defer then_scope.instructions.deinit(mod.gpa);	2013	defer then_scope.instructions.deinit(mod.gpa);
...	@@ -1758,61 +2015,51 @@ fn whileExpr(mod: Module, scope: Scope, rl: ResultLoc, while_node: *ast.Node.W	...	@@ -1758,61 +2015,51 @@ fn whileExpr(mod: Module, scope: Scope, rl: ResultLoc, while_node: *ast.Node.W
1758	// declare payload to the then_scope	2015	// declare payload to the then_scope
1759	const then_sub_scope = try cond_kind.thenSubScope(mod, &then_scope, then_src, while_node.payload);	2016	const then_sub_scope = try cond_kind.thenSubScope(mod, &then_scope, then_src, while_node.payload);
1760		2017
1761	// Most result location types can be forwarded directly; however	2018	loop_scope.break_count += 1;
1762	// if we need to write to a pointer which has an inferred type,	2019	const then_result = try expr(mod, then_sub_scope, loop_scope.break_result_loc, while_node.body);
1763	// proper type inference requires peer type resolution on the while's
1764	// branches.
1765	const branch_rl: ResultLoc = switch (rl) {
1766	.discard, .none, .ty, .ptr, .ref => rl,
1767	.inferred_ptr, .bitcasted_ptr, .block_ptr => .{ .block_ptr = while_block },
1768	};
1769
1770	const then_result = try expr(mod, then_sub_scope, branch_rl, while_node.body);
1771	if (!then_result.tag.isNoReturn()) {
1772	_ = try addZIRInst(mod, then_sub_scope, then_src, zir.Inst.Break, .{
1773	.block = cond_block,
1774	.operand = then_result,
1775	}, .{});
1776	}
1777	condbr.positionals.then_body = .{
1778	.instructions = try then_scope.arena.dupe(*zir.Inst, then_scope.instructions.items),
1779	};
1780		2020
1781	var else_scope: Scope.GenZIR = .{	2021	var else_scope: Scope.GenZIR = .{
1782	.parent = &continue_scope.base,	2022	.parent = &continue_scope.base,
1783	.decl = continue_scope.decl,	2023	.decl = continue_scope.decl,
1784	.arena = continue_scope.arena,	2024	.arena = continue_scope.arena,
		2025	.force_comptime = continue_scope.force_comptime,
1785	.instructions = .{},	2026	.instructions = .{},
1786	};	2027	};
1787	defer else_scope.instructions.deinit(mod.gpa);	2028	defer else_scope.instructions.deinit(mod.gpa);
1788		2029
1789	if (while_node.@"else") \|else_node\| {	2030	var else_src: usize = undefined;
1790	const else_src = tree.token_locs[else_node.body.lastToken()].start;	2031	const else_result: ?*zir.Inst = if (while_node.@"else") \|else_node\| blk: {
		2032	else_src = tree.token_locs[else_node.body.lastToken()].start;
1791	// declare payload to the then_scope	2033	// declare payload to the then_scope
1792	const else_sub_scope = try cond_kind.elseSubScope(mod, &else_scope, else_src, else_node.payload);	2034	const else_sub_scope = try cond_kind.elseSubScope(mod, &else_scope, else_src, else_node.payload);
1793		2035
1794	const else_result = try expr(mod, else_sub_scope, branch_rl, else_node.body);	2036	loop_scope.break_count += 1;
1795	if (!else_result.tag.isNoReturn()) {	2037	break :blk try expr(mod, else_sub_scope, loop_scope.break_result_loc, else_node.body);
1796	_ = try addZIRInst(mod, else_sub_scope, else_src, zir.Inst.Break, .{	2038	} else blk: {
1797	.block = while_block,	2039	else_src = tree.token_locs[while_node.lastToken()].start;
1798	.operand = else_result,	2040	break :blk null;
1799	}, .{});
1800	}
1801	} else {
1802	const else_src = tree.token_locs[while_node.lastToken()].start;
1803	_ = try addZIRInst(mod, &else_scope.base, else_src, zir.Inst.BreakVoid, .{
1804	.block = while_block,
1805	}, .{});
1806	}
1807	condbr.positionals.else_body = .{
1808	.instructions = try else_scope.arena.dupe(*zir.Inst, else_scope.instructions.items),
1809	};	2041	};
1810	if (loop_scope.label) \|some\| {	2042	if (loop_scope.label) \|some\| {
1811	if (!some.used) {	2043	if (!some.used) {
1812	return mod.fail(scope, tree.token_locs[some.token].start, "unused while label", .{});	2044	return mod.fail(scope, tree.token_locs[some.token].start, "unused while label", .{});
1813	}	2045	}
1814	}	2046	}
1815	return &while_block.base;	2047	return finishThenElseBlock(
		2048	mod,
		2049	scope,
		2050	rl,
		2051	&loop_scope,
		2052	&then_scope,
		2053	&else_scope,
		2054	&condbr.positionals.then_body,
		2055	&condbr.positionals.else_body,
		2056	then_src,
		2057	else_src,
		2058	then_result,
		2059	else_result,
		2060	while_block,
		2061	cond_block,
		2062	);
1816	}	2063	}
1817		2064
1818	fn forExpr(	2065	fn forExpr(
...	@@ -1828,48 +2075,42 @@ fn forExpr(	...	@@ -1828,48 +2075,42 @@ fn forExpr(
1828	if (for_node.inline_token) \|tok\|	2075	if (for_node.inline_token) \|tok\|
1829	return mod.failTok(scope, tok, "TODO inline for", .{});	2076	return mod.failTok(scope, tok, "TODO inline for", .{});
1830		2077
1831	var for_scope: Scope.GenZIR = .{
1832	.parent = scope,
1833	.decl = scope.ownerDecl().?,
1834	.arena = scope.arena(),
1835	.instructions = .{},
1836	};
1837	defer for_scope.instructions.deinit(mod.gpa);
1838
1839	// setup variables and constants	2078	// setup variables and constants
1840	const tree = scope.tree();	2079	const tree = scope.tree();
1841	const for_src = tree.token_locs[for_node.for_token].start;	2080	const for_src = tree.token_locs[for_node.for_token].start;
1842	const index_ptr = blk: {	2081	const index_ptr = blk: {
1843	const usize_type = try addZIRInstConst(mod, &for_scope.base, for_src, .{	2082	const usize_type = try addZIRInstConst(mod, scope, for_src, .{
1844	.ty = Type.initTag(.type),	2083	.ty = Type.initTag(.type),
1845	.val = Value.initTag(.usize_type),	2084	.val = Value.initTag(.usize_type),
1846	});	2085	});
1847	const index_ptr = try addZIRUnOp(mod, &for_scope.base, for_src, .alloc, usize_type);	2086	const index_ptr = try addZIRUnOp(mod, scope, for_src, .alloc, usize_type);
1848	// initialize to zero	2087	// initialize to zero
1849	const zero = try addZIRInstConst(mod, &for_scope.base, for_src, .{	2088	const zero = try addZIRInstConst(mod, scope, for_src, .{
1850	.ty = Type.initTag(.usize),	2089	.ty = Type.initTag(.usize),
1851	.val = Value.initTag(.zero),	2090	.val = Value.initTag(.zero),
1852	});	2091	});
1853	_ = try addZIRBinOp(mod, &for_scope.base, for_src, .store, index_ptr, zero);	2092	_ = try addZIRBinOp(mod, scope, for_src, .store, index_ptr, zero);
1854	break :blk index_ptr;	2093	break :blk index_ptr;
1855	};	2094	};
1856	const array_ptr = try expr(mod, &for_scope.base, .ref, for_node.array_expr);	2095	const array_ptr = try expr(mod, scope, .ref, for_node.array_expr);
1857	const cond_src = tree.token_locs[for_node.array_expr.firstToken()].start;	2096	const cond_src = tree.token_locs[for_node.array_expr.firstToken()].start;
1858	const len = try addZIRUnOp(mod, &for_scope.base, cond_src, .indexable_ptr_len, array_ptr);	2097	const len = try addZIRUnOp(mod, scope, cond_src, .indexable_ptr_len, array_ptr);
1859		2098
1860	var loop_scope: Scope.GenZIR = .{	2099	var loop_scope: Scope.GenZIR = .{
1861	.parent = &for_scope.base,	2100	.parent = scope,
1862	.decl = for_scope.decl,	2101	.decl = scope.ownerDecl().?,
1863	.arena = for_scope.arena,	2102	.arena = scope.arena(),
		2103	.force_comptime = scope.isComptime(),
1864	.instructions = .{},	2104	.instructions = .{},
1865	.break_result_loc = rl,
1866	};	2105	};
		2106	setBlockResultLoc(&loop_scope, rl);
1867	defer loop_scope.instructions.deinit(mod.gpa);	2107	defer loop_scope.instructions.deinit(mod.gpa);
1868		2108
1869	var cond_scope: Scope.GenZIR = .{	2109	var cond_scope: Scope.GenZIR = .{
1870	.parent = &loop_scope.base,	2110	.parent = &loop_scope.base,
1871	.decl = loop_scope.decl,	2111	.decl = loop_scope.decl,
1872	.arena = loop_scope.arena,	2112	.arena = loop_scope.arena,
		2113	.force_comptime = loop_scope.force_comptime,
1873	.instructions = .{},	2114	.instructions = .{},
1874	};	2115	};
1875	defer cond_scope.instructions.deinit(mod.gpa);	2116	defer cond_scope.instructions.deinit(mod.gpa);
...	@@ -1896,12 +2137,21 @@ fn forExpr(	...	@@ -1896,12 +2137,21 @@ fn forExpr(
1896	const index_plus_one = try addZIRBinOp(mod, &loop_scope.base, for_src, .add, index_2, one);	2137	const index_plus_one = try addZIRBinOp(mod, &loop_scope.base, for_src, .add, index_2, one);
1897	_ = try addZIRBinOp(mod, &loop_scope.base, for_src, .store, index_ptr, index_plus_one);	2138	_ = try addZIRBinOp(mod, &loop_scope.base, for_src, .store, index_ptr, index_plus_one);
1898		2139
1899	// looping stuff	2140	const loop = try scope.arena().create(zir.Inst.Loop);
1900	const loop = try addZIRInstLoop(mod, &for_scope.base, for_src, .{	2141	loop.* = .{
1901	.instructions = try for_scope.arena.dupe(*zir.Inst, loop_scope.instructions.items),	2142	.base = .{
1902	});	2143	.tag = .loop,
		2144	.src = for_src,
		2145	},
		2146	.positionals = .{
		2147	.body = .{
		2148	.instructions = try scope.arena().dupe(*zir.Inst, loop_scope.instructions.items),
		2149	},
		2150	},
		2151	.kw_args = .{},
		2152	};
1903	const for_block = try addZIRInstBlock(mod, scope, for_src, .block, .{	2153	const for_block = try addZIRInstBlock(mod, scope, for_src, .block, .{
1904	.instructions = try for_scope.arena.dupe(*zir.Inst, for_scope.instructions.items),	2154	.instructions = try scope.arena().dupe(zir.Inst, &[1]zir.Inst{&loop.base}),
1905	});	2155	});
1906	loop_scope.break_block = for_block;	2156	loop_scope.break_block = for_block;
1907	loop_scope.continue_block = cond_block;	2157	loop_scope.continue_block = cond_block;
...	@@ -1918,19 +2168,11 @@ fn forExpr(	...	@@ -1918,19 +2168,11 @@ fn forExpr(
1918	.parent = &cond_scope.base,	2168	.parent = &cond_scope.base,
1919	.decl = cond_scope.decl,	2169	.decl = cond_scope.decl,
1920	.arena = cond_scope.arena,	2170	.arena = cond_scope.arena,
		2171	.force_comptime = cond_scope.force_comptime,
1921	.instructions = .{},	2172	.instructions = .{},
1922	};	2173	};
1923	defer then_scope.instructions.deinit(mod.gpa);	2174	defer then_scope.instructions.deinit(mod.gpa);
1924		2175
1925	// Most result location types can be forwarded directly; however
1926	// if we need to write to a pointer which has an inferred type,
1927	// proper type inference requires peer type resolution on the while's
1928	// branches.
1929	const branch_rl: ResultLoc = switch (rl) {
1930	.discard, .none, .ty, .ptr, .ref => rl,
1931	.inferred_ptr, .bitcasted_ptr, .block_ptr => .{ .block_ptr = for_block },
1932	};
1933
1934	var index_scope: Scope.LocalPtr = undefined;	2176	var index_scope: Scope.LocalPtr = undefined;
1935	const then_sub_scope = blk: {	2177	const then_sub_scope = blk: {
1936	const payload = for_node.payload.castTag(.PointerIndexPayload).?;	2178	const payload = for_node.payload.castTag(.PointerIndexPayload).?;
...	@@ -1959,319 +2201,49 @@ fn forExpr(	...	@@ -1959,319 +2201,49 @@ fn forExpr(
1959	break :blk &index_scope.base;	2201	break :blk &index_scope.base;
1960	};	2202	};
1961		2203
1962	const then_result = try expr(mod, then_sub_scope, branch_rl, for_node.body);	2204	loop_scope.break_count += 1;
1963	if (!then_result.tag.isNoReturn()) {	2205	const then_result = try expr(mod, then_sub_scope, loop_scope.break_result_loc, for_node.body);
1964	_ = try addZIRInst(mod, then_sub_scope, then_src, zir.Inst.Break, .{
1965	.block = cond_block,
1966	.operand = then_result,
1967	}, .{});
1968	}
1969	condbr.positionals.then_body = .{
1970	.instructions = try then_scope.arena.dupe(*zir.Inst, then_scope.instructions.items),
1971	};
1972		2206
1973	// else branch	2207	// else branch
1974	var else_scope: Scope.GenZIR = .{	2208	var else_scope: Scope.GenZIR = .{
1975	.parent = &cond_scope.base,	2209	.parent = &cond_scope.base,
1976	.decl = cond_scope.decl,	2210	.decl = cond_scope.decl,
1977	.arena = cond_scope.arena,	2211	.arena = cond_scope.arena,
		2212	.force_comptime = cond_scope.force_comptime,
1978	.instructions = .{},	2213	.instructions = .{},
1979	};	2214	};
1980	defer else_scope.instructions.deinit(mod.gpa);	2215	defer else_scope.instructions.deinit(mod.gpa);
1981		2216
1982	if (for_node.@"else") \|else_node\| {	2217	var else_src: usize = undefined;
1983	const else_src = tree.token_locs[else_node.body.lastToken()].start;	2218	const else_result: ?*zir.Inst = if (for_node.@"else") \|else_node\| blk: {
1984	const else_result = try expr(mod, &else_scope.base, branch_rl, else_node.body);	2219	else_src = tree.token_locs[else_node.body.lastToken()].start;
1985	if (!else_result.tag.isNoReturn()) {	2220	loop_scope.break_count += 1;
1986	_ = try addZIRInst(mod, &else_scope.base, else_src, zir.Inst.Break, .{	2221	break :blk try expr(mod, &else_scope.base, loop_scope.break_result_loc, else_node.body);
1987	.block = for_block,	2222	} else blk: {
1988	.operand = else_result,	2223	else_src = tree.token_locs[for_node.lastToken()].start;
1989	}, .{});	2224	break :blk null;
1990	}
1991	} else {
1992	const else_src = tree.token_locs[for_node.lastToken()].start;
1993	_ = try addZIRInst(mod, &else_scope.base, else_src, zir.Inst.BreakVoid, .{
1994	.block = for_block,
1995	}, .{});
1996	}
1997	condbr.positionals.else_body = .{
1998	.instructions = try else_scope.arena.dupe(*zir.Inst, else_scope.instructions.items),
1999	};	2225	};
2000	if (loop_scope.label) \|some\| {	2226	if (loop_scope.label) \|some\| {
2001	if (!some.used) {	2227	if (!some.used) {
2002	return mod.fail(scope, tree.token_locs[some.token].start, "unused for label", .{});	2228	return mod.fail(scope, tree.token_locs[some.token].start, "unused for label", .{});
2003	}	2229	}
2004	}	2230	}
2005	return &for_block.base;	2231	return finishThenElseBlock(
2006	}	2232	mod,
2007		2233	scope,
2008	fn getRangeNode(node: ast.Node) ?ast.Node.SimpleInfixOp {	2234	rl,
2009	var cur = node;	2235	&loop_scope,
2010	while (true) {	2236	&then_scope,
2011	switch (cur.tag) {	2237	&else_scope,
2012	.Range => return @fieldParentPtr(ast.Node.SimpleInfixOp, "base", cur),	2238	&condbr.positionals.then_body,
2013	.GroupedExpression => cur = @fieldParentPtr(ast.Node.GroupedExpression, "base", cur).expr,	2239	&condbr.positionals.else_body,
2014	else => return null,	2240	then_src,
2015	}	2241	else_src,
2016	}	2242	then_result,
2017	}	2243	else_result,
2018		2244	for_block,
2019	fn switchExpr(mod: Module, scope: Scope, rl: ResultLoc, switch_node: ast.Node.Switch) InnerError!zir.Inst {	2245	cond_block,
2020	var block_scope: Scope.GenZIR = .{	2246	);
2021	.parent = scope,
2022	.decl = scope.ownerDecl().?,
2023	.arena = scope.arena(),
2024	.instructions = .{},
2025	};
2026	defer block_scope.instructions.deinit(mod.gpa);
2027
2028	const tree = scope.tree();
2029	const switch_src = tree.token_locs[switch_node.switch_token].start;
2030	const target_ptr = try expr(mod, &block_scope.base, .ref, switch_node.expr);
2031	const target = try addZIRUnOp(mod, &block_scope.base, target_ptr.src, .deref, target_ptr);
2032	// Add the switch instruction here so that it comes before any range checks.
2033	const switch_inst = (try addZIRInst(mod, &block_scope.base, switch_src, zir.Inst.SwitchBr, .{
2034	.target_ptr = target_ptr,
2035	.cases = undefined, // populated below
2036	.items = &[_]*zir.Inst{}, // populated below
2037	.else_body = undefined, // populated below
2038	}, .{})).castTag(.switchbr).?;
2039
2040	var items = std.ArrayList(*zir.Inst).init(mod.gpa);
2041	defer items.deinit();
2042	var cases = std.ArrayList(zir.Inst.SwitchBr.Case).init(mod.gpa);
2043	defer cases.deinit();
2044
2045	// Add comptime block containing all prong items first,
2046	const item_block = try addZIRInstBlock(mod, scope, switch_src, .block_comptime_flat, .{
2047	.instructions = undefined, // populated below
2048	});
2049	// then add block containing the switch.
2050	const block = try addZIRInstBlock(mod, scope, switch_src, .block, .{
2051	.instructions = try block_scope.arena.dupe(*zir.Inst, block_scope.instructions.items),
2052	});
2053
2054	// Most result location types can be forwarded directly; however
2055	// if we need to write to a pointer which has an inferred type,
2056	// proper type inference requires peer type resolution on the switch case.
2057	const case_rl: ResultLoc = switch (rl) {
2058	.discard, .none, .ty, .ptr, .ref => rl,
2059	.inferred_ptr, .bitcasted_ptr, .block_ptr => .{ .block_ptr = block },
2060	};
2061
2062	var item_scope: Scope.GenZIR = .{
2063	.parent = scope,
2064	.decl = scope.ownerDecl().?,
2065	.arena = scope.arena(),
2066	.instructions = .{},
2067	};
2068	defer item_scope.instructions.deinit(mod.gpa);
2069
2070	var case_scope: Scope.GenZIR = .{
2071	.parent = scope,
2072	.decl = block_scope.decl,
2073	.arena = block_scope.arena,
2074	.instructions = .{},
2075	};
2076	defer case_scope.instructions.deinit(mod.gpa);
2077
2078	var else_scope: Scope.GenZIR = .{
2079	.parent = scope,
2080	.decl = block_scope.decl,
2081	.arena = block_scope.arena,
2082	.instructions = .{},
2083	};
2084	defer else_scope.instructions.deinit(mod.gpa);
2085
2086	// first we gather all the switch items and check else/'_' prongs
2087	var else_src: ?usize = null;
2088	var underscore_src: ?usize = null;
2089	var first_range: ?*zir.Inst = null;
2090	var special_case: ?*ast.Node.SwitchCase = null;
2091	for (switch_node.cases()) \|uncasted_case\| {
2092	const case = uncasted_case.castTag(.SwitchCase).?;
2093	const case_src = tree.token_locs[case.firstToken()].start;
2094	// reset without freeing to reduce allocations.
2095	case_scope.instructions.items.len = 0;
2096	assert(case.items_len != 0);
2097
2098	// Check for else/_ prong, those are handled last.
2099	if (case.items_len == 1 and case.items()[0].tag == .SwitchElse) {
2100	if (else_src) \|src\| {
2101	const msg = msg: {
2102	const msg = try mod.errMsg(
2103	scope,
2104	case_src,
2105	"multiple else prongs in switch expression",
2106	.{},
2107	);
2108	errdefer msg.destroy(mod.gpa);
2109	try mod.errNote(scope, src, msg, "previous else prong is here", .{});
2110	break :msg msg;
2111	};
2112	return mod.failWithOwnedErrorMsg(scope, msg);
2113	}
2114	else_src = case_src;
2115	special_case = case;
2116	continue;
2117	} else if (case.items_len == 1 and case.items()[0].tag == .Identifier and
2118	mem.eql(u8, tree.tokenSlice(case.items()[0].firstToken()), "_"))
2119	{
2120	if (underscore_src) \|src\| {
2121	const msg = msg: {
2122	const msg = try mod.errMsg(
2123	scope,
2124	case_src,
2125	"multiple '_' prongs in switch expression",
2126	.{},
2127	);
2128	errdefer msg.destroy(mod.gpa);
2129	try mod.errNote(scope, src, msg, "previous '_' prong is here", .{});
2130	break :msg msg;
2131	};
2132	return mod.failWithOwnedErrorMsg(scope, msg);
2133	}
2134	underscore_src = case_src;
2135	special_case = case;
2136	continue;
2137	}
2138
2139	if (else_src) \|some_else\| {
2140	if (underscore_src) \|some_underscore\| {
2141	const msg = msg: {
2142	const msg = try mod.errMsg(
2143	scope,
2144	switch_src,
2145	"else and '_' prong in switch expression",
2146	.{},
2147	);
2148	errdefer msg.destroy(mod.gpa);
2149	try mod.errNote(scope, some_else, msg, "else prong is here", .{});
2150	try mod.errNote(scope, some_underscore, msg, "'_' prong is here", .{});
2151	break :msg msg;
2152	};
2153	return mod.failWithOwnedErrorMsg(scope, msg);
2154	}
2155	}
2156
2157	// If this is a simple one item prong then it is handled by the switchbr.
2158	if (case.items_len == 1 and getRangeNode(case.items()[0]) == null) {
2159	const item = try expr(mod, &item_scope.base, .none, case.items()[0]);
2160	try items.append(item);
2161	try switchCaseExpr(mod, &case_scope.base, case_rl, block, case);
2162
2163	try cases.append(.{
2164	.item = item,
2165	.body = .{ .instructions = try scope.arena().dupe(*zir.Inst, case_scope.instructions.items) },
2166	});
2167	continue;
2168	}
2169
2170	// TODO if the case has few items and no ranges it might be better
2171	// to just handle them as switch prongs.
2172
2173	// Check if the target matches any of the items.
2174	// 1, 2, 3..6 will result in
2175	// target == 1 or target == 2 or (target >= 3 and target <= 6)
2176	var any_ok: ?*zir.Inst = null;
2177	for (case.items()) \|item\| {
2178	if (getRangeNode(item)) \|range\| {
2179	const start = try expr(mod, &item_scope.base, .none, range.lhs);
2180	const end = try expr(mod, &item_scope.base, .none, range.rhs);
2181	const range_src = tree.token_locs[range.op_token].start;
2182	const range_inst = try addZIRBinOp(mod, &item_scope.base, range_src, .switch_range, start, end);
2183	try items.append(range_inst);
2184	if (first_range == null) first_range = range_inst;
2185
2186	// target >= start and target <= end
2187	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);
2189	const range_ok = try addZIRBinOp(mod, &else_scope.base, range_src, .booland, range_start_ok, range_end_ok);
2190
2191	if (any_ok) \|some\| {
2192	any_ok = try addZIRBinOp(mod, &else_scope.base, range_src, .boolor, some, range_ok);
2193	} else {
2194	any_ok = range_ok;
2195	}
2196	continue;
2197	}
2198
2199	const item_inst = try expr(mod, &item_scope.base, .none, item);
2200	try items.append(item_inst);
2201	const cpm_ok = try addZIRBinOp(mod, &else_scope.base, item_inst.src, .cmp_eq, target, item_inst);
2202
2203	if (any_ok) \|some\| {
2204	any_ok = try addZIRBinOp(mod, &else_scope.base, item_inst.src, .boolor, some, cpm_ok);
2205	} else {
2206	any_ok = cpm_ok;
2207	}
2208	}
2209
2210	const condbr = try addZIRInstSpecial(mod, &case_scope.base, case_src, zir.Inst.CondBr, .{
2211	.condition = any_ok.?,
2212	.then_body = undefined, // populated below
2213	.else_body = undefined, // populated below
2214	}, .{});
2215	const cond_block = try addZIRInstBlock(mod, &else_scope.base, case_src, .block, .{
2216	.instructions = try scope.arena().dupe(*zir.Inst, case_scope.instructions.items),
2217	});
2218
2219	// reset cond_scope for then_body
2220	case_scope.instructions.items.len = 0;
2221	try switchCaseExpr(mod, &case_scope.base, case_rl, block, case);
2222	condbr.positionals.then_body = .{
2223	.instructions = try scope.arena().dupe(*zir.Inst, case_scope.instructions.items),
2224	};
2225
2226	// reset cond_scope for else_body
2227	case_scope.instructions.items.len = 0;
2228	_ = try addZIRInst(mod, &case_scope.base, case_src, zir.Inst.BreakVoid, .{
2229	.block = cond_block,
2230	}, .{});
2231	condbr.positionals.else_body = .{
2232	.instructions = try scope.arena().dupe(*zir.Inst, case_scope.instructions.items),
2233	};
2234	}
2235
2236	// Generate else block or a break last to finish the block.
2237	if (special_case) \|case\| {
2238	try switchCaseExpr(mod, &else_scope.base, case_rl, block, case);
2239	} else {
2240	// Not handling all possible cases is a compile error.
2241	_ = try addZIRNoOp(mod, &else_scope.base, switch_src, .unreach_nocheck);
2242	}
2243
2244	// All items have been generated, add the instructions to the comptime block.
2245	item_block.positionals.body = .{
2246	.instructions = try block_scope.arena.dupe(*zir.Inst, item_scope.instructions.items),
2247	};
2248
2249	// Actually populate switch instruction values.
2250	if (else_src != null) switch_inst.kw_args.special_prong = .@"else";
2251	if (underscore_src != null) switch_inst.kw_args.special_prong = .underscore;
2252	switch_inst.positionals.cases = try block_scope.arena.dupe(zir.Inst.SwitchBr.Case, cases.items);
2253	switch_inst.positionals.items = try block_scope.arena.dupe(*zir.Inst, items.items);
2254	switch_inst.kw_args.range = first_range;
2255	switch_inst.positionals.else_body = .{
2256	.instructions = try block_scope.arena.dupe(*zir.Inst, else_scope.instructions.items),
2257	};
2258	return &block.base;
2259	}
2260
2261	fn switchCaseExpr(mod: Module, scope: Scope, rl: ResultLoc, block: zir.Inst.Block, case: ast.Node.SwitchCase) !void {
2262	const tree = scope.tree();
2263	const case_src = tree.token_locs[case.firstToken()].start;
2264	if (case.payload != null) {
2265	return mod.fail(scope, case_src, "TODO switch case payload capture", .{});
2266	}
2267
2268	const case_body = try expr(mod, scope, rl, case.expr);
2269	if (!case_body.tag.isNoReturn()) {
2270	_ = try addZIRInst(mod, scope, case_src, zir.Inst.Break, .{
2271	.block = block,
2272	.operand = case_body,
2273	}, .{});
2274	}
2275	}	2247	}
2276		2248
2277	fn ret(mod: Module, scope: Scope, cfe: ast.Node.ControlFlowExpression) InnerError!zir.Inst {	2249	fn ret(mod: Module, scope: Scope, cfe: ast.Node.ControlFlowExpression) InnerError!zir.Inst {
...	@@ -2288,7 +2260,7 @@ fn ret(mod: Module, scope: Scope, cfe: *ast.Node.ControlFlowExpression) InnerE	...	@@ -2288,7 +2260,7 @@ fn ret(mod: Module, scope: Scope, cfe: *ast.Node.ControlFlowExpression) InnerE
2288	return addZIRUnOp(mod, scope, src, .@"return", operand);	2260	return addZIRUnOp(mod, scope, src, .@"return", operand);
2289	}	2261	}
2290	} else {	2262	} else {
2291	return addZIRNoOp(mod, scope, src, .returnvoid);	2263	return addZIRNoOp(mod, scope, src, .return_void);
2292	}	2264	}
2293	}	2265	}
2294		2266
...	@@ -2305,7 +2277,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo	...	@@ -2305,7 +2277,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo
2305		2277
2306	if (getSimplePrimitiveValue(ident_name)) \|typed_value\| {	2278	if (getSimplePrimitiveValue(ident_name)) \|typed_value\| {
2307	const result = try addZIRInstConst(mod, scope, src, typed_value);	2279	const result = try addZIRInstConst(mod, scope, src, typed_value);
2308	return rlWrap(mod, scope, rl, result);	2280	return rvalue(mod, scope, rl, result);
2309	}	2281	}
2310		2282
2311	if (ident_name.len >= 2) integer: {	2283	if (ident_name.len >= 2) integer: {
...	@@ -2327,7 +2299,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo	...	@@ -2327,7 +2299,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),	2299	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),	2300	64 => if (is_signed) Value.initTag(.i64_type) else Value.initTag(.u64_type),
2329	else => {	2301	else => {
2330	return rlWrap(mod, scope, rl, try addZIRInstConst(mod, scope, src, .{	2302	return rvalue(mod, scope, rl, try addZIRInstConst(mod, scope, src, .{
2331	.ty = Type.initTag(.type),	2303	.ty = Type.initTag(.type),
2332	.val = try Value.Tag.int_type.create(scope.arena(), .{	2304	.val = try Value.Tag.int_type.create(scope.arena(), .{
2333	.signed = is_signed,	2305	.signed = is_signed,
...	@@ -2340,7 +2312,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo	...	@@ -2340,7 +2312,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo
2340	.ty = Type.initTag(.type),	2312	.ty = Type.initTag(.type),
2341	.val = val,	2313	.val = val,
2342	});	2314	});
2343	return rlWrap(mod, scope, rl, result);	2315	return rvalue(mod, scope, rl, result);
2344	}	2316	}
2345	}	2317	}
2346		2318
...	@@ -2351,7 +2323,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo	...	@@ -2351,7 +2323,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo
2351	.local_val => {	2323	.local_val => {
2352	const local_val = s.cast(Scope.LocalVal).?;	2324	const local_val = s.cast(Scope.LocalVal).?;
2353	if (mem.eql(u8, local_val.name, ident_name)) {	2325	if (mem.eql(u8, local_val.name, ident_name)) {
2354	return rlWrap(mod, scope, rl, local_val.inst);	2326	return rvalue(mod, scope, rl, local_val.inst);
2355	}	2327	}
2356	s = local_val.parent;	2328	s = local_val.parent;
2357	},	2329	},
...	@@ -2360,7 +2332,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo	...	@@ -2360,7 +2332,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo
2360	if (mem.eql(u8, local_ptr.name, ident_name)) {	2332	if (mem.eql(u8, local_ptr.name, ident_name)) {
2361	if (rl == .ref) return local_ptr.ptr;	2333	if (rl == .ref) return local_ptr.ptr;
2362	const loaded = try addZIRUnOp(mod, scope, src, .deref, local_ptr.ptr);	2334	const loaded = try addZIRUnOp(mod, scope, src, .deref, local_ptr.ptr);
2363	return rlWrap(mod, scope, rl, loaded);	2335	return rvalue(mod, scope, rl, loaded);
2364	}	2336	}
2365	s = local_ptr.parent;	2337	s = local_ptr.parent;
2366	},	2338	},
...	@@ -2373,7 +2345,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo	...	@@ -2373,7 +2345,7 @@ fn identifier(mod: Module, scope: Scope, rl: ResultLoc, ident: *ast.Node.OneTo
2373	if (rl == .ref) {	2345	if (rl == .ref) {
2374	return addZIRInst(mod, scope, src, zir.Inst.DeclRef, .{ .decl = decl }, .{});	2346	return addZIRInst(mod, scope, src, zir.Inst.DeclRef, .{ .decl = decl }, .{});
2375	} else {	2347	} else {
2376	return rlWrap(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.DeclVal, .{	2348	return rvalue(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.DeclVal, .{
2377	.decl = decl,	2349	.decl = decl,
2378	}, .{}));	2350	}, .{}));
2379	}	2351	}
...	@@ -2590,7 +2562,7 @@ fn simpleCast(	...	@@ -2590,7 +2562,7 @@ fn simpleCast(
2590	const dest_type = try typeExpr(mod, scope, params[0]);	2562	const dest_type = try typeExpr(mod, scope, params[0]);
2591	const rhs = try expr(mod, scope, .none, params[1]);	2563	const rhs = try expr(mod, scope, .none, params[1]);
2592	const result = try addZIRBinOp(mod, scope, src, inst_tag, dest_type, rhs);	2564	const result = try addZIRBinOp(mod, scope, src, inst_tag, dest_type, rhs);
2593	return rlWrap(mod, scope, rl, result);	2565	return rvalue(mod, scope, rl, result);
2594	}	2566	}
2595		2567
2596	fn ptrToInt(mod: Module, scope: Scope, call: ast.Node.BuiltinCall) InnerError!zir.Inst {	2568	fn ptrToInt(mod: Module, scope: Scope, call: ast.Node.BuiltinCall) InnerError!zir.Inst {
...	@@ -2601,31 +2573,30 @@ fn ptrToInt(mod: Module, scope: Scope, call: *ast.Node.BuiltinCall) InnerError	...	@@ -2601,31 +2573,30 @@ fn ptrToInt(mod: Module, scope: Scope, call: *ast.Node.BuiltinCall) InnerError
2601	return addZIRUnOp(mod, scope, src, .ptrtoint, operand);	2573	return addZIRUnOp(mod, scope, src, .ptrtoint, operand);
2602	}	2574	}
2603		2575
2604	fn as(mod: Module, scope: Scope, rl: ResultLoc, call: ast.Node.BuiltinCall) InnerError!zir.Inst {	2576	fn as(
		2577	mod: *Module,
		2578	scope: *Scope,
		2579	rl: ResultLoc,
		2580	call: *ast.Node.BuiltinCall,
		2581	) InnerError!*zir.Inst {
2605	try ensureBuiltinParamCount(mod, scope, call, 2);	2582	try ensureBuiltinParamCount(mod, scope, call, 2);
2606	const tree = scope.tree();	2583	const tree = scope.tree();
2607	const src = tree.token_locs[call.builtin_token].start;	2584	const src = tree.token_locs[call.builtin_token].start;
2608	const params = call.params();	2585	const params = call.params();
2609	const dest_type = try typeExpr(mod, scope, params[0]);	2586	const dest_type = try typeExpr(mod, scope, params[0]);
2610	switch (rl) {	2587	switch (rl) {
2611	.none => return try expr(mod, scope, .{ .ty = dest_type }, params[1]),	2588	.none, .discard, .ref, .ty => {
2612	.discard => {
2613	const result = try expr(mod, scope, .{ .ty = dest_type }, params[1]);
2614	_ = try addZIRUnOp(mod, scope, result.src, .ensure_result_non_error, result);
2615	return result;
2616	},
2617	.ref => {
2618	const result = try expr(mod, scope, .{ .ty = dest_type }, params[1]);
2619	return addZIRUnOp(mod, scope, result.src, .ref, result);
2620	},
2621	.ty => \|result_ty\| {
2622	const result = try expr(mod, scope, .{ .ty = dest_type }, params[1]);	2589	const result = try expr(mod, scope, .{ .ty = dest_type }, params[1]);
2623	return addZIRBinOp(mod, scope, src, .as, result_ty, result);	2590	return rvalue(mod, scope, rl, result);
2624	},	2591	},
		2592
2625	.ptr => \|result_ptr\| {	2593	.ptr => \|result_ptr\| {
2626	const casted_result_ptr = try addZIRBinOp(mod, scope, src, .coerce_result_ptr, dest_type, result_ptr);	2594	return asRlPtr(mod, scope, rl, src, result_ptr, params[1], dest_type);
2627	return expr(mod, scope, .{ .ptr = casted_result_ptr }, params[1]);	2595	},
		2596	.block_ptr => \|block_scope\| {
		2597	return asRlPtr(mod, scope, rl, src, block_scope.rl_ptr.?, params[1], dest_type);
2628	},	2598	},
		2599
2629	.bitcasted_ptr => \|bitcasted_ptr\| {	2600	.bitcasted_ptr => \|bitcasted_ptr\| {
2630	// TODO here we should be able to resolve the inference; we now have a type for the result.	2601	// TODO here we should be able to resolve the inference; we now have a type for the result.
2631	return mod.failTok(scope, call.builtin_token, "TODO implement @as with result location @bitCast", .{});	2602	return mod.failTok(scope, call.builtin_token, "TODO implement @as with result location @bitCast", .{});
...	@@ -2634,13 +2605,50 @@ fn as(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.BuiltinCall) I	...	@@ -2634,13 +2605,50 @@ 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.	2605	// 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", .{});	2606	return mod.failTok(scope, call.builtin_token, "TODO implement @as with inferred-type result location pointer", .{});
2636	},	2607	},
2637	.block_ptr => \|block_ptr\| {	2608	}
2638	const casted_block_ptr = try addZIRInst(mod, scope, src, zir.Inst.CoerceResultBlockPtr, .{	2609	}
2639	.dest_type = dest_type,	2610
2640	.block = block_ptr,	2611	fn asRlPtr(
2641	}, .{});	2612	mod: *Module,
2642	return expr(mod, scope, .{ .ptr = casted_block_ptr }, params[1]);	2613	scope: *Scope,
2643	},	2614	rl: ResultLoc,
		2615	src: usize,
		2616	result_ptr: *zir.Inst,
		2617	operand_node: *ast.Node,
		2618	dest_type: *zir.Inst,
		2619	) InnerError!*zir.Inst {
		2620	// Detect whether this expr() call goes into rvalue() to store the result into the
		2621	// result location. If it does, elide the coerce_result_ptr instruction
		2622	// as well as the store instruction, instead passing the result as an rvalue.
		2623	var as_scope: Scope.GenZIR = .{
		2624	.parent = scope,
		2625	.decl = scope.ownerDecl().?,
		2626	.arena = scope.arena(),
		2627	.force_comptime = scope.isComptime(),
		2628	.instructions = .{},
		2629	};
		2630	defer as_scope.instructions.deinit(mod.gpa);
		2631
		2632	as_scope.rl_ptr = try addZIRBinOp(mod, &as_scope.base, src, .coerce_result_ptr, dest_type, result_ptr);
		2633	const result = try expr(mod, &as_scope.base, .{ .block_ptr = &as_scope }, operand_node);
		2634	const parent_zir = &scope.getGenZIR().instructions;
		2635	if (as_scope.rvalue_rl_count == 1) {
		2636	// Busted! This expression didn't actually need a pointer.
		2637	const expected_len = parent_zir.items.len + as_scope.instructions.items.len - 2;
		2638	try parent_zir.ensureCapacity(mod.gpa, expected_len);
		2639	for (as_scope.instructions.items) \|src_inst\| {
		2640	if (src_inst == as_scope.rl_ptr.?) continue;
		2641	if (src_inst.castTag(.store_to_block_ptr)) \|store\| {
		2642	if (store.positionals.lhs == as_scope.rl_ptr.?) continue;
		2643	}
		2644	parent_zir.appendAssumeCapacity(src_inst);
		2645	}
		2646	assert(parent_zir.items.len == expected_len);
		2647	const casted_result = try addZIRBinOp(mod, scope, dest_type.src, .as, dest_type, result);
		2648	return rvalue(mod, scope, rl, casted_result);
		2649	} else {
		2650	try parent_zir.appendSlice(mod.gpa, as_scope.instructions.items);
		2651	return result;
2644	}	2652	}
2645	}	2653	}
2646		2654
...	@@ -2703,7 +2711,7 @@ fn compileError(mod: Module, scope: Scope, call: *ast.Node.BuiltinCall) InnerE	...	@@ -2703,7 +2711,7 @@ fn compileError(mod: Module, scope: Scope, call: *ast.Node.BuiltinCall) InnerE
2703	const src = tree.token_locs[call.builtin_token].start;	2711	const src = tree.token_locs[call.builtin_token].start;
2704	const params = call.params();	2712	const params = call.params();
2705	const target = try expr(mod, scope, .none, params[0]);	2713	const target = try expr(mod, scope, .none, params[0]);
2706	return addZIRUnOp(mod, scope, src, .compileerror, target);	2714	return addZIRUnOp(mod, scope, src, .compile_error, target);
2707	}	2715	}
2708		2716
2709	fn setEvalBranchQuota(mod: Module, scope: Scope, call: ast.Node.BuiltinCall) InnerError!zir.Inst {	2717	fn setEvalBranchQuota(mod: Module, scope: Scope, call: ast.Node.BuiltinCall) InnerError!zir.Inst {
...	@@ -2728,12 +2736,12 @@ fn typeOf(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.BuiltinCal	...	@@ -2728,12 +2736,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", .{});	2736	return mod.failTok(scope, call.builtin_token, "expected at least 1 argument, found 0", .{});
2729	}	2737	}
2730	if (params.len == 1) {	2738	if (params.len == 1) {
2731	return rlWrap(mod, scope, rl, try addZIRUnOp(mod, scope, src, .typeof, try expr(mod, scope, .none, params[0])));	2739	return rvalue(mod, scope, rl, try addZIRUnOp(mod, scope, src, .typeof, try expr(mod, scope, .none, params[0])));
2732	}	2740	}
2733	var items = try arena.alloc(*zir.Inst, params.len);	2741	var items = try arena.alloc(*zir.Inst, params.len);
2734	for (params) \|param, param_i\|	2742	for (params) \|param, param_i\|
2735	items[param_i] = try expr(mod, scope, .none, param);	2743	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 }, .{}));	2744	return rvalue(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.TypeOfPeer, .{ .items = items }, .{}));
2737	}	2745	}
2738	fn compileLog(mod: Module, scope: Scope, call: ast.Node.BuiltinCall) InnerError!zir.Inst {	2746	fn compileLog(mod: Module, scope: Scope, call: ast.Node.BuiltinCall) InnerError!zir.Inst {
2739	const tree = scope.tree();	2747	const tree = scope.tree();
...	@@ -2756,7 +2764,7 @@ fn builtinCall(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.Built	...	@@ -2756,7 +2764,7 @@ fn builtinCall(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.Built
2756	// Also, some builtins have a variable number of parameters.	2764	// Also, some builtins have a variable number of parameters.
2757		2765
2758	if (mem.eql(u8, builtin_name, "@ptrToInt")) {	2766	if (mem.eql(u8, builtin_name, "@ptrToInt")) {
2759	return rlWrap(mod, scope, rl, try ptrToInt(mod, scope, call));	2767	return rvalue(mod, scope, rl, try ptrToInt(mod, scope, call));
2760	} else if (mem.eql(u8, builtin_name, "@as")) {	2768	} else if (mem.eql(u8, builtin_name, "@as")) {
2761	return as(mod, scope, rl, call);	2769	return as(mod, scope, rl, call);
2762	} else if (mem.eql(u8, builtin_name, "@floatCast")) {	2770	} else if (mem.eql(u8, builtin_name, "@floatCast")) {
...	@@ -2769,9 +2777,9 @@ fn builtinCall(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.Built	...	@@ -2769,9 +2777,9 @@ fn builtinCall(mod: Module, scope: Scope, rl: ResultLoc, call: *ast.Node.Built
2769	return typeOf(mod, scope, rl, call);	2777	return typeOf(mod, scope, rl, call);
2770	} else if (mem.eql(u8, builtin_name, "@breakpoint")) {	2778	} else if (mem.eql(u8, builtin_name, "@breakpoint")) {
2771	const src = tree.token_locs[call.builtin_token].start;	2779	const src = tree.token_locs[call.builtin_token].start;
2772	return rlWrap(mod, scope, rl, try addZIRNoOp(mod, scope, src, .breakpoint));	2780	return rvalue(mod, scope, rl, try addZIRNoOp(mod, scope, src, .breakpoint));
2773	} else if (mem.eql(u8, builtin_name, "@import")) {	2781	} else if (mem.eql(u8, builtin_name, "@import")) {
2774	return rlWrap(mod, scope, rl, try import(mod, scope, call));	2782	return rvalue(mod, scope, rl, try import(mod, scope, call));
2775	} else if (mem.eql(u8, builtin_name, "@compileError")) {	2783	} else if (mem.eql(u8, builtin_name, "@compileError")) {
2776	return compileError(mod, scope, call);	2784	return compileError(mod, scope, call);
2777	} else if (mem.eql(u8, builtin_name, "@setEvalBranchQuota")) {	2785	} else if (mem.eql(u8, builtin_name, "@setEvalBranchQuota")) {
...	@@ -2806,13 +2814,13 @@ fn callExpr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Call) In	...	@@ -2806,13 +2814,13 @@ fn callExpr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Call) In
2806	.args = args,	2814	.args = args,
2807	}, .{});	2815	}, .{});
2808	// TODO function call with result location	2816	// TODO function call with result location
2809	return rlWrap(mod, scope, rl, result);	2817	return rvalue(mod, scope, rl, result);
2810	}	2818	}
2811		2819
2812	fn unreach(mod: Module, scope: Scope, unreach_node: ast.Node.OneToken) InnerError!zir.Inst {	2820	fn unreach(mod: Module, scope: Scope, unreach_node: ast.Node.OneToken) InnerError!zir.Inst {
2813	const tree = scope.tree();	2821	const tree = scope.tree();
2814	const src = tree.token_locs[unreach_node.token].start;	2822	const src = tree.token_locs[unreach_node.token].start;
2815	return addZIRNoOp(mod, scope, src, .@"unreachable");	2823	return addZIRNoOp(mod, scope, src, .unreachable_safe);
2816	}	2824	}
2817		2825
2818	fn getSimplePrimitiveValue(name: []const u8) ?TypedValue {	2826	fn getSimplePrimitiveValue(name: []const u8) ?TypedValue {
...	@@ -3099,7 +3107,7 @@ fn nodeMayNeedMemoryLocation(start_node: ast.Node, scope: Scope) bool {	...	@@ -3099,7 +3107,7 @@ fn nodeMayNeedMemoryLocation(start_node: ast.Node, scope: Scope) bool {
3099	/// result locations must call this function on their result.	3107	/// 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.	3108	/// 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.	3109	/// 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 {	3110	fn rvalue(mod: Module, scope: Scope, rl: ResultLoc, result: zir.Inst) InnerError!zir.Inst {
3103	switch (rl) {	3111	switch (rl) {
3104	.none => return result,	3112	.none => return result,
3105	.discard => {	3113	.discard => {
...	@@ -3113,42 +3121,97 @@ fn rlWrap(mod: Module, scope: Scope, rl: ResultLoc, result: *zir.Inst) InnerEr	...	@@ -3113,42 +3121,97 @@ fn rlWrap(mod: Module, scope: Scope, rl: ResultLoc, result: *zir.Inst) InnerEr
3113	},	3121	},
3114	.ty => \|ty_inst\| return addZIRBinOp(mod, scope, result.src, .as, ty_inst, result),	3122	.ty => \|ty_inst\| return addZIRBinOp(mod, scope, result.src, .as, ty_inst, result),
3115	.ptr => \|ptr_inst\| {	3123	.ptr => \|ptr_inst\| {
3116	const casted_result = try addZIRInst(mod, scope, result.src, zir.Inst.CoerceToPtrElem, .{	3124	_ = try addZIRBinOp(mod, scope, result.src, .store, ptr_inst, result);
3117	.ptr = ptr_inst,	3125	return result;
3118	.value = result,
3119	}, .{});
3120	_ = try addZIRBinOp(mod, scope, result.src, .store, ptr_inst, casted_result);
3121	return casted_result;
3122	},	3126	},
3123	.bitcasted_ptr => \|bitcasted_ptr\| {	3127	.bitcasted_ptr => \|bitcasted_ptr\| {
3124	return mod.fail(scope, result.src, "TODO implement rlWrap .bitcasted_ptr", .{});	3128	return mod.fail(scope, result.src, "TODO implement rvalue .bitcasted_ptr", .{});
3125	},	3129	},
3126	.inferred_ptr => \|alloc\| {	3130	.inferred_ptr => \|alloc\| {
3127	_ = try addZIRBinOp(mod, scope, result.src, .store_to_inferred_ptr, &alloc.base, result);	3131	_ = try addZIRBinOp(mod, scope, result.src, .store_to_inferred_ptr, &alloc.base, result);
3128	return result;	3132	return result;
3129	},	3133	},
3130	.block_ptr => \|block_ptr\| {	3134	.block_ptr => \|block_scope\| {
3131	return mod.fail(scope, result.src, "TODO implement rlWrap .block_ptr", .{});	3135	block_scope.rvalue_rl_count += 1;
		3136	_ = try addZIRBinOp(mod, scope, result.src, .store_to_block_ptr, block_scope.rl_ptr.?, result);
		3137	return result;
3132	},	3138	},
3133	}	3139	}
3134	}	3140	}
3135		3141
3136	fn rlWrapVoid(mod: Module, scope: Scope, rl: ResultLoc, node: ast.Node, result: void) InnerError!zir.Inst {	3142	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;	3143	const src = scope.tree().token_locs[node.firstToken()].start;
3138	const void_inst = try addZIRInstConst(mod, scope, src, .{	3144	const void_inst = try addZIRInstConst(mod, scope, src, .{
3139	.ty = Type.initTag(.void),	3145	.ty = Type.initTag(.void),
3140	.val = Value.initTag(.void_value),	3146	.val = Value.initTag(.void_value),
3141	});	3147	});
3142	return rlWrap(mod, scope, rl, void_inst);	3148	return rvalue(mod, scope, rl, void_inst);
		3149	}
		3150
		3151	fn rlStrategy(rl: ResultLoc, block_scope: *Scope.GenZIR) ResultLoc.Strategy {
		3152	var elide_store_to_block_ptr_instructions = false;
		3153	switch (rl) {
		3154	// In this branch there will not be any store_to_block_ptr instructions.
		3155	.discard, .none, .ty, .ref => return .{
		3156	.tag = .break_operand,
		3157	.elide_store_to_block_ptr_instructions = false,
		3158	},
		3159	// The pointer got passed through to the sub-expressions, so we will use
		3160	// break_void here.
		3161	// In this branch there will not be any store_to_block_ptr instructions.
		3162	.ptr => return .{
		3163	.tag = .break_void,
		3164	.elide_store_to_block_ptr_instructions = false,
		3165	},
		3166	.inferred_ptr, .bitcasted_ptr, .block_ptr => {
		3167	if (block_scope.rvalue_rl_count == block_scope.break_count) {
		3168	// Neither prong of the if consumed the result location, so we can
		3169	// use break instructions to create an rvalue.
		3170	return .{
		3171	.tag = .break_operand,
		3172	.elide_store_to_block_ptr_instructions = true,
		3173	};
		3174	} else {
		3175	// Allow the store_to_block_ptr instructions to remain so that
		3176	// semantic analysis can turn them into bitcasts.
		3177	return .{
		3178	.tag = .break_void,
		3179	.elide_store_to_block_ptr_instructions = false,
		3180	};
		3181	}
		3182	},
		3183	}
3143	}	3184	}
3144		3185
3145	/// TODO go over all the callsites and see where we can introduce "by-value" ZIR instructions	3186	fn setBlockResultLoc(block_scope: *Scope.GenZIR, parent_rl: ResultLoc) void {
3146	/// to save ZIR memory. For example, see DeclVal vs DeclRef.	3187	// Depending on whether the result location is a pointer or value, different
3147	/// Do not add additional callsites to this function.	3188	// ZIR needs to be generated. In the former case we rely on storing to the
3148	fn rlWrapPtr(mod: Module, scope: Scope, rl: ResultLoc, ptr: zir.Inst) InnerError!zir.Inst {	3189	// pointer to communicate the result, and use breakvoid; in the latter case
3149	if (rl == .ref) return ptr;	3190	// the block break instructions will have the result values.
		3191	// One more complication: when the result location is a pointer, we detect
		3192	// the scenario where the result location is not consumed. In this case
		3193	// we emit ZIR for the block break instructions to have the result values,
		3194	// and then rvalue() on that to pass the value to the result location.
		3195	switch (parent_rl) {
		3196	.discard, .none, .ty, .ptr, .ref => {
		3197	block_scope.break_result_loc = parent_rl;
		3198	},
		3199
		3200	.inferred_ptr => \|ptr\| {
		3201	block_scope.rl_ptr = &ptr.base;
		3202	block_scope.break_result_loc = .{ .block_ptr = block_scope };
		3203	},
		3204
		3205	.bitcasted_ptr => \|ptr\| {
		3206	block_scope.rl_ptr = &ptr.base;
		3207	block_scope.break_result_loc = .{ .block_ptr = block_scope };
		3208	},
3150		3209
3151	return rlWrap(mod, scope, rl, try addZIRUnOp(mod, scope, ptr.src, .deref, ptr));	3210	.block_ptr => \|parent_block_scope\| {
		3211	block_scope.rl_ptr = parent_block_scope.rl_ptr.?;
		3212	block_scope.break_result_loc = .{ .block_ptr = block_scope };
		3213	},
		3214	}
3152	}	3215	}
3153		3216
3154	pub fn addZirInstTag(	3217	pub fn addZirInstTag(

src/codegen.zig+34-23

 @@ -840,14 +840,15 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                 .arg => return self.genArg(inst.castTag(.arg).?),
                 .assembly => return self.genAsm(inst.castTag(.assembly).?),
                 .bitcast => return self.genBitCast(inst.castTag(.bitcast).?),
-                .bitand => return self.genBitAnd(inst.castTag(.bitand).?),
+                .bit_and => return self.genBitAnd(inst.castTag(.bit_and).?),
-                .bitor => return self.genBitOr(inst.castTag(.bitor).?),
+                .bit_or => return self.genBitOr(inst.castTag(.bit_or).?),
                 .block => return self.genBlock(inst.castTag(.block).?),
                 .br => return self.genBr(inst.castTag(.br).?),
+                .br_block_flat => return self.genBrBlockFlat(inst.castTag(.br_block_flat).?),
                 .breakpoint => return self.genBreakpoint(inst.src),
-                .brvoid => return self.genBrVoid(inst.castTag(.brvoid).?),
+                .br_void => return self.genBrVoid(inst.castTag(.br_void).?),
-                .booland => return self.genBoolOp(inst.castTag(.booland).?),
+                .bool_and => return self.genBoolOp(inst.castTag(.bool_and).?),
-                .boolor => return self.genBoolOp(inst.castTag(.boolor).?),
+                .bool_or => return self.genBoolOp(inst.castTag(.bool_or).?),
                 .call => return self.genCall(inst.castTag(.call).?),
                 .cmp_lt => return self.genCmp(inst.castTag(.cmp_lt).?, .lt),
                 .cmp_lte => return self.genCmp(inst.castTag(.cmp_lte).?, .lte),
 @@ -1097,7 +1098,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
             if (inst.base.isUnused())
                 return MCValue.dead;
             switch (arch) {
-                .arm, .armeb => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .bitand),
+                .arm, .armeb => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .bit_and),
                 else => return self.fail(inst.base.src, "TODO implement bitwise and for {}", .{self.target.cpu.arch}),
             }
         }
 @@ -1107,7 +1108,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
             if (inst.base.isUnused())
                 return MCValue.dead;
             switch (arch) {
-                .arm, .armeb => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .bitor),
+                .arm, .armeb => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .bit_or),
                 else => return self.fail(inst.base.src, "TODO implement bitwise or for {}", .{self.target.cpu.arch}),
             }
         }
 @@ -1371,10 +1372,10 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                         writeInt(u32, try self.code.addManyAsArray(4), Instruction.rsb(.al, dst_reg, dst_reg, operand).toU32());
                     }
                 },
-                .booland, .bitand => {
+                .bool_and, .bit_and => {
                     writeInt(u32, try self.code.addManyAsArray(4), Instruction.@"and"(.al, dst_reg, dst_reg, operand).toU32());
                 },
-                .boolor, .bitor => {
+                .bool_or, .bit_or => {
                     writeInt(u32, try self.code.addManyAsArray(4), Instruction.orr(.al, dst_reg, dst_reg, operand).toU32());
                 },
                 .not, .xor => {
 @@ -2441,17 +2442,14 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
             }
         }
+        fn genBrBlockFlat(self: *Self, inst: *ir.Inst.BrBlockFlat) !MCValue {
+            try self.genBody(inst.body);
+            const last = inst.body.instructions[inst.body.instructions.len - 1];
+            return self.br(inst.base.src, inst.block, last);
+        }
         fn genBr(self: *Self, inst: *ir.Inst.Br) !MCValue {
-            if (inst.operand.ty.hasCodeGenBits()) {
+            return self.br(inst.base.src, inst.block, inst.operand);
-                const operand = try self.resolveInst(inst.operand);
-                const block_mcv = @bitCast(MCValue, inst.block.codegen.mcv);
-                if (block_mcv == .none) {
-                    inst.block.codegen.mcv = @bitCast(AnyMCValue, operand);
-                } else {
-                    try self.setRegOrMem(inst.base.src, inst.block.base.ty, block_mcv, operand);
-                }
-            }
-            return self.brVoid(inst.base.src, inst.block);
         }
         fn genBrVoid(self: *Self, inst: *ir.Inst.BrVoid) !MCValue {
 @@ -2464,20 +2462,33 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
             switch (arch) {
                 .x86_64 => switch (inst.base.tag) {
                     // lhs AND rhs
-                    .booland => return try self.genX8664BinMath(&inst.base, inst.lhs, inst.rhs, 4, 0x20),
+                    .bool_and => return try self.genX8664BinMath(&inst.base, inst.lhs, inst.rhs, 4, 0x20),
                     // lhs OR rhs
-                    .boolor => return try self.genX8664BinMath(&inst.base, inst.lhs, inst.rhs, 1, 0x08),
+                    .bool_or => return try self.genX8664BinMath(&inst.base, inst.lhs, inst.rhs, 1, 0x08),
                     else => unreachable, // Not a boolean operation
                 },
                 .arm, .armeb => switch (inst.base.tag) {
-                    .booland => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .booland),
+                    .bool_and => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .bool_and),
-                    .boolor => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .boolor),
+                    .bool_or => return try self.genArmBinOp(&inst.base, inst.lhs, inst.rhs, .bool_or),
                     else => unreachable, // Not a boolean operation
                 },
                 else => return self.fail(inst.base.src, "TODO implement boolean operations for {}", .{self.target.cpu.arch}),
             }
         }
+        fn br(self: *Self, src: usize, block: *ir.Inst.Block, operand: *ir.Inst) !MCValue {
+            if (operand.ty.hasCodeGenBits()) {
+                const operand_mcv = try self.resolveInst(operand);
+                const block_mcv = @bitCast(MCValue, block.codegen.mcv);
+                if (block_mcv == .none) {
+                    block.codegen.mcv = @bitCast(AnyMCValue, operand_mcv);
+                } else {
+                    try self.setRegOrMem(src, block.base.ty, block_mcv, operand_mcv);
+                }
+            }
+            return self.brVoid(src, block);
+        }
         fn brVoid(self: *Self, src: usize, block: *ir.Inst.Block) !MCValue {
             // Emit a jump with a relocation. It will be patched up after the block ends.
             try block.codegen.relocs.ensureCapacity(self.gpa, block.codegen.relocs.items.len + 1);

src/ir.zig+43-13

 @@ -56,13 +56,20 @@ pub const Inst = struct {
         alloc,
         arg,
         assembly,
-        bitand,
+        bit_and,
         bitcast,
-        bitor,
+        bit_or,
         block,
         br,
+        /// Same as `br` except the operand is a list of instructions to be treated as
+        /// a flat block; that is there is only 1 break instruction from the block, and
+        /// it is implied to be after the last instruction, and the last instruction is
+        /// the break operand.
+        /// This instruction exists for late-stage semantic analysis patch ups, to
+        /// replace one br operand with multiple instructions, without moving anything else around.
+        br_block_flat,
         breakpoint,
-        brvoid,
+        br_void,
         call,
         cmp_lt,
         cmp_lte,
 @@ -85,8 +92,8 @@ pub const Inst = struct {
         is_err,
         // *E!T => bool
         is_err_ptr,
-        booland,
+        bool_and,
-        boolor,
+        bool_or,
         /// Read a value from a pointer.
         load,
         loop,
 @@ -147,10 +154,10 @@ pub const Inst = struct {
                 .cmp_gt,
                 .cmp_neq,
                 .store,
-                .booland,
+                .bool_and,
-                .boolor,
+                .bool_or,
-                .bitand,
+                .bit_and,
-                .bitor,
+                .bit_or,
                 .xor,
                 => BinOp,
 @@ -158,7 +165,8 @@ pub const Inst = struct {
                 .assembly => Assembly,
                 .block => Block,
                 .br => Br,
-                .brvoid => BrVoid,
+                .br_block_flat => BrBlockFlat,
+                .br_void => BrVoid,
                 .call => Call,
                 .condbr => CondBr,
                 .constant => Constant,
 @@ -251,7 +259,8 @@ pub const Inst = struct {
     pub fn breakBlock(base: *Inst) ?*Block {
         return switch (base.tag) {
             .br => base.castTag(.br).?.block,
-            .brvoid => base.castTag(.brvoid).?.block,
+            .br_void => base.castTag(.br_void).?.block,
+            .br_block_flat => base.castTag(.br_block_flat).?.block,
             else => null,
         };
     }
 @@ -355,6 +364,27 @@ pub const Inst = struct {
         }
     };
+    pub const convertable_br_size = std.math.max(@sizeOf(BrBlockFlat), @sizeOf(Br));
+    pub const convertable_br_align = std.math.max(@alignOf(BrBlockFlat), @alignOf(Br));
+    comptime {
+        assert(@byteOffsetOf(BrBlockFlat, "base") == @byteOffsetOf(Br, "base"));
+    }
+    pub const BrBlockFlat = struct {
+        pub const base_tag = Tag.br_block_flat;
+        base: Inst,
+        block: *Block,
+        body: Body,
+        pub fn operandCount(self: *const BrBlockFlat) usize {
+            return 0;
+        }
+        pub fn getOperand(self: *const BrBlockFlat, index: usize) ?*Inst {
+            return null;
+        }
+    };
     pub const Br = struct {
         pub const base_tag = Tag.br;
 @@ -363,7 +393,7 @@ pub const Inst = struct {
         operand: *Inst,
         pub fn operandCount(self: *const Br) usize {
-            return 0;
+            return 1;
         }
         pub fn getOperand(self: *const Br, index: usize) ?*Inst {
             if (index == 0)
 @@ -373,7 +403,7 @@ pub const Inst = struct {
     };
     pub const BrVoid = struct {
-        pub const base_tag = Tag.brvoid;
+        pub const base_tag = Tag.br_void;
         base: Inst,
         block: *Block,

src/zir.zig+110-165

 @@ -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,
         /// `<`
 @@ -112,16 +112,10 @@ pub const Inst = struct {
         /// as type coercion from the new element type to the old element type.
         /// LHS is destination element type, RHS is result pointer.
         coerce_result_ptr,
-        /// This instruction does a `coerce_result_ptr` operation on a `Block`'s
-        /// 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 +129,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 +179,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 +226,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 +264,9 @@ 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 the pointer to store 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 +283,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'
 @@ -339,12 +336,8 @@ pub const Inst = struct {
         enum_literal,
         /// Create an enum type.
         enum_type,
-        /// A switch expression.
+        /// Does nothing; returns a void value.
-        switchbr,
+        void_value,
-        /// A range in a switch case, `lhs...rhs`.
-        /// Only checks that `lhs >= rhs` if they are ints, everything else is
-        /// validated by the .switch instruction.
-        switch_range,
         pub fn Type(tag: Tag) type {
             return switch (tag) {
 @@ -352,17 +345,18 @@ pub const Inst = struct {
                 .alloc_inferred_mut,
                 .breakpoint,
                 .dbg_stmt,
-                .returnvoid,
+                .return_void,
                 .ret_ptr,
                 .ret_type,
-                .unreach_nocheck,
+                .unreachable_unsafe,
-                .@"unreachable",
+                .unreachable_safe,
+                .void_value,
                 => NoOp,
                 .alloc,
                 .alloc_mut,
-                .boolnot,
+                .bool_not,
-                .compileerror,
+                .compile_error,
                 .deref,
                 .@"return",
                 .is_null,
 @@ -400,7 +394,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 +405,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 +416,7 @@ pub const Inst = struct {
                 .shl,
                 .shr,
                 .store,
+                .store_to_block_ptr,
                 .store_to_inferred_ptr,
                 .sub,
                 .subwrap,
 @@ -440,7 +435,6 @@ pub const Inst = struct {
                 .error_union_type,
                 .merge_error_sets,
                 .slice_start,
-                .switch_range,
                 => BinOp,
                 .block,
 @@ -452,19 +446,17 @@ 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,
+                .compile_log => CompileLog,
-                .coerce_result_block_ptr => CoerceResultBlockPtr,
-                .compilelog => 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,
 @@ -479,7 +471,6 @@ pub const Inst = struct {
                 .enum_literal => EnumLiteral,
                 .error_set => ErrorSet,
                 .slice => Slice,
-                .switchbr => SwitchBr,
                 .typeof_peer => TypeOfPeer,
                 .container_field_named => ContainerFieldNamed,
                 .container_field_typed => ContainerFieldTyped,
 @@ -508,18 +499,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,
 @@ -529,13 +520,11 @@ pub const Inst = struct {
                 .cmp_gt,
                 .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 +541,7 @@ pub const Inst = struct {
                 .fntype,
                 .int,
                 .intcast,
-                .inttype,
+                .int_type,
                 .is_non_null,
                 .is_null,
                 .is_non_null_ptr,
 @@ -579,6 +568,7 @@ pub const Inst = struct {
                 .mut_slice_type,
                 .const_slice_type,
                 .store,
+                .store_to_block_ptr,
                 .store_to_inferred_ptr,
                 .str,
                 .sub,
 @@ -602,31 +592,30 @@ pub const Inst = struct {
                 .merge_error_sets,
                 .anyframe_type,
                 .error_union_type,
-                .bitnot,
+                .bit_not,
                 .error_set,
                 .slice,
                 .slice_start,
                 .import,
-                .switch_range,
                 .typeof_peer,
                 .resolve_inferred_alloc,
                 .set_eval_branch_quota,
-                .compilelog,
+                .compile_log,
                 .enum_type,
                 .union_type,
                 .struct_type,
+                .void_value,
                 => 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,
                 .container_field_typed,
                 .container_field,
 @@ -717,7 +706,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 +728,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 +739,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 +749,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 {
 @@ -780,19 +758,8 @@ pub const Inst = struct {
         kw_args: struct {},
     };
-    pub const CoerceResultBlockPtr = struct {
-        pub const base_tag = Tag.coerce_result_block_ptr;
-        base: Inst,
-        positionals: struct {
-            dest_type: *Inst,
-            block: *Block,
-        },
-        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 +872,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 {
 @@ -1114,32 +1081,6 @@ pub const Inst = struct {
         },
     };
-    pub const SwitchBr = struct {
-        pub const base_tag = Tag.switchbr;
-        base: Inst,
-        positionals: struct {
-            target_ptr: *Inst,
-            /// List of all individual items and ranges
-            items: []*Inst,
-            cases: []Case,
-            else_body: Body,
-        },
-        kw_args: struct {
-            /// Pointer to first range if such exists.
-            range: ?*Inst = null,
-            special_prong: enum {
-                none,
-                @"else",
-                underscore,
-            } = .none,
-        },
-        pub const Case = struct {
-            item: *Inst,
-            body: Body,
-        };
-    };
     pub const TypeOfPeer = struct {
         pub const base_tag = .typeof_peer;
         base: Inst,
 @@ -1473,7 +1414,7 @@ const Writer = struct {
             TypedValue => return stream.print("TypedValue{{ .ty = {}, .val = {}}}", .{ param.ty, param.val }),
             *IrModule.Decl => return stream.print("Decl({s})", .{param.name}),
             *Inst.Block => {
-                const name = self.block_table.get(param).?;
+                const name = self.block_table.get(param) orelse "!BADREF!";
                 return stream.print("\"{}\"", .{std.zig.fmtEscapes(name)});
             },
             *Inst.Loop => {
 @@ -1490,26 +1431,6 @@ const Writer = struct {
                 }
                 try stream.writeByte(']');
             },
-            []Inst.SwitchBr.Case => {
-                if (param.len == 0) {
-                    return stream.writeAll("{}");
-                }
-                try stream.writeAll("{\n");
-                for (param) |*case, i| {
-                    if (i != 0) {
-                        try stream.writeAll(",\n");
-                    }
-                    try stream.writeByteNTimes(' ', self.indent);
-                    self.indent += 2;
-                    try self.writeParamToStream(stream, &case.item);
-                    try stream.writeAll(" => ");
-                    try self.writeParamToStream(stream, &case.body);
-                    self.indent -= 2;
-                }
-                try stream.writeByte('\n');
-                try stream.writeByteNTimes(' ', self.indent - 2);
-                try stream.writeByte('}');
-            },
             else => |T| @compileError("unimplemented: rendering parameter of type " ++ @typeName(T)),
         }
     }
 @@ -1641,10 +1562,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).?;
 @@ -1660,9 +1581,15 @@ const DumpTzir = struct {
                     try dtz.findConst(br.operand);
                 },
-                .brvoid => {
+                .br_block_flat => {
-                    const brvoid = inst.castTag(.brvoid).?;
+                    const br_block_flat = inst.castTag(.br_block_flat).?;
-                    try dtz.findConst(&brvoid.block.base);
+                    try dtz.findConst(&br_block_flat.block.base);
+                    try dtz.fetchInstsAndResolveConsts(br_block_flat.body);
+                },
+                .br_void => {
+                    const br_void = inst.castTag(.br_void).?;
+                    try dtz.findConst(&br_void.block.base);
                 },
                 .block => {
 @@ -1753,10 +1680,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).?;
 @@ -1805,9 +1732,27 @@ const DumpTzir = struct {
                     }
                 },
-                .brvoid => {
+                .br_block_flat => {
-                    const brvoid = inst.castTag(.brvoid).?;
+                    const br_block_flat = inst.castTag(.br_block_flat).?;
-                    const kinky = try dtz.writeInst(writer, &brvoid.block.base);
+                    const block_kinky = try dtz.writeInst(writer, &br_block_flat.block.base);
+                    if (block_kinky != null) {
+                        try writer.writeAll(", { // Instruction does not dominate all uses!\n");
+                    } else {
+                        try writer.writeAll(", {\n");
+                    }
+                    const old_indent = dtz.indent;
+                    dtz.indent += 2;
+                    try dtz.dumpBody(br_block_flat.body, writer);
+                    dtz.indent = old_indent;
+                    try writer.writeByteNTimes(' ', dtz.indent);
+                    try writer.writeAll("})\n");
+                },
+                .br_void => {
+                    const br_void = inst.castTag(.br_void).?;
+                    const kinky = try dtz.writeInst(writer, &br_void.block.base);
                     if (kinky) |_| {
                         try writer.writeAll(") // Instruction does not dominate all uses!\n");
                     } else {
 @@ -1818,7 +1763,7 @@ const DumpTzir = struct {
                 .block => {
                     const block = inst.castTag(.block).?;
-                    try writer.writeAll("\n");
+                    try writer.writeAll("{\n");
                     const old_indent = dtz.indent;
                     dtz.indent += 2;
 @@ -1826,7 +1771,7 @@ const DumpTzir = struct {
                     dtz.indent = old_indent;
                     try writer.writeByteNTimes(' ', dtz.indent);
-                    try writer.writeAll(")\n");
+                    try writer.writeAll("})\n");
                 },
                 .condbr => {
 @@ -1856,7 +1801,7 @@ const DumpTzir = struct {
                 .loop => {
                     const loop = inst.castTag(.loop).?;
-                    try writer.writeAll("\n");
+                    try writer.writeAll("{\n");
                     const old_indent = dtz.indent;
                     dtz.indent += 2;
 @@ -1864,7 +1809,7 @@ const DumpTzir = struct {
                     dtz.indent = old_indent;
                     try writer.writeByteNTimes(' ', dtz.indent);
-                    try writer.writeAll(")\n");
+                    try writer.writeAll("})\n");
                 },
                 .call => {

src/zir_sema.zig+357-538

 @@ -28,144 +28,132 @@ 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_ptr => return zirCoerceResultPtr(mod, scope, old_inst.castTag(.coerce_result_ptr).?),
-        .bitcast_result_ptr => return bitCastResultPtr(mod, scope, old_inst.castTag(.bitcast_result_ptr).?),
+        .compile_error => return zirCompileError(mod, scope, old_inst.castTag(.compile_error).?),
-        .block => return analyzeInstBlock(mod, scope, old_inst.castTag(.block).?, false),
+        .compile_log => return zirCompileLog(mod, scope, old_inst.castTag(.compile_log).?),
-        .block_comptime => return analyzeInstBlock(mod, scope, old_inst.castTag(.block_comptime).?, true),
+        .@"const" => return zirConst(mod, scope, old_inst.castTag(.@"const").?),
-        .block_flat => return analyzeInstBlockFlat(mod, scope, old_inst.castTag(.block_flat).?, false),
+        .dbg_stmt => return zirDbgStmt(mod, scope, old_inst.castTag(.dbg_stmt).?),
-        .block_comptime_flat => return analyzeInstBlockFlat(mod, scope, old_inst.castTag(.block_comptime_flat).?, true),
+        .decl_ref => return zirDeclRef(mod, scope, old_inst.castTag(.decl_ref).?),
-        .@"break" => return analyzeInstBreak(mod, scope, old_inst.castTag(.@"break").?),
+        .decl_ref_str => return zirDeclRefStr(mod, scope, old_inst.castTag(.decl_ref_str).?),
-        .breakpoint => return analyzeInstBreakpoint(mod, scope, old_inst.castTag(.breakpoint).?),
+        .decl_val => return zirDeclVal(mod, scope, old_inst.castTag(.decl_val).?),
-        .breakvoid => return analyzeInstBreakVoid(mod, scope, old_inst.castTag(.breakvoid).?),
+        .ensure_result_used => return zirEnsureResultUsed(mod, scope, old_inst.castTag(.ensure_result_used).?),
-        .call => return call(mod, scope, old_inst.castTag(.call).?),
+        .ensure_result_non_error => return zirEnsureResultNonError(mod, scope, old_inst.castTag(.ensure_result_non_error).?),
-        .coerce_result_block_ptr => return analyzeInstCoerceResultBlockPtr(mod, scope, old_inst.castTag(.coerce_result_block_ptr).?),
+        .indexable_ptr_len => return zirIndexablePtrLen(mod, scope, old_inst.castTag(.indexable_ptr_len).?),
-        .coerce_result_ptr => return analyzeInstCoerceResultPtr(mod, scope, old_inst.castTag(.coerce_result_ptr).?),
+        .ref => return zirRef(mod, scope, old_inst.castTag(.ref).?),
-        .coerce_to_ptr_elem => return analyzeInstCoerceToPtrElem(mod, scope, old_inst.castTag(.coerce_to_ptr_elem).?),
+        .resolve_inferred_alloc => return zirResolveInferredAlloc(mod, scope, old_inst.castTag(.resolve_inferred_alloc).?),
-        .compileerror => return analyzeInstCompileError(mod, scope, old_inst.castTag(.compileerror).?),
+        .ret_ptr => return zirRetPtr(mod, scope, old_inst.castTag(.ret_ptr).?),
-        .compilelog => return analyzeInstCompileLog(mod, scope, old_inst.castTag(.compilelog).?),
+        .ret_type => return zirRetType(mod, scope, old_inst.castTag(.ret_type).?),
-        .@"const" => return analyzeInstConst(mod, scope, old_inst.castTag(.@"const").?),
+        .store_to_block_ptr => return zirStoreToBlockPtr(mod, scope, old_inst.castTag(.store_to_block_ptr).?),
-        .dbg_stmt => return analyzeInstDbgStmt(mod, scope, old_inst.castTag(.dbg_stmt).?),
+        .store_to_inferred_ptr => return zirStoreToInferredPtr(mod, scope, old_inst.castTag(.store_to_inferred_ptr).?),
-        .declref => return declRef(mod, scope, old_inst.castTag(.declref).?),
+        .single_const_ptr_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.single_const_ptr_type).?, false, .One),
-        .declref_str => return analyzeInstDeclRefStr(mod, scope, old_inst.castTag(.declref_str).?),
+        .single_mut_ptr_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.single_mut_ptr_type).?, true, .One),
-        .declval => return declVal(mod, scope, old_inst.castTag(.declval).?),
+        .many_const_ptr_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.many_const_ptr_type).?, false, .Many),
-        .ensure_result_used => return analyzeInstEnsureResultUsed(mod, scope, old_inst.castTag(.ensure_result_used).?),
+        .many_mut_ptr_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.many_mut_ptr_type).?, true, .Many),
-        .ensure_result_non_error => return analyzeInstEnsureResultNonError(mod, scope, old_inst.castTag(.ensure_result_non_error).?),
+        .c_const_ptr_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.c_const_ptr_type).?, false, .C),
-        .indexable_ptr_len => return indexablePtrLen(mod, scope, old_inst.castTag(.indexable_ptr_len).?),
+        .c_mut_ptr_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.c_mut_ptr_type).?, true, .C),
-        .ref => return ref(mod, scope, old_inst.castTag(.ref).?),
+        .const_slice_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.const_slice_type).?, false, .Slice),
-        .resolve_inferred_alloc => return analyzeInstResolveInferredAlloc(mod, scope, old_inst.castTag(.resolve_inferred_alloc).?),
+        .mut_slice_type => return zirSimplePtrType(mod, scope, old_inst.castTag(.mut_slice_type).?, true, .Slice),
-        .ret_ptr => return analyzeInstRetPtr(mod, scope, old_inst.castTag(.ret_ptr).?),
+        .ptr_type => return zirPtrType(mod, scope, old_inst.castTag(.ptr_type).?),
-        .ret_type => return analyzeInstRetType(mod, scope, old_inst.castTag(.ret_type).?),
+        .store => return zirStore(mod, scope, old_inst.castTag(.store).?),
-        .store_to_inferred_ptr => return analyzeInstStoreToInferredPtr(mod, scope, old_inst.castTag(.store_to_inferred_ptr).?),
+        .set_eval_branch_quota => return zirSetEvalBranchQuota(mod, scope, old_inst.castTag(.set_eval_branch_quota).?),
-        .single_const_ptr_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.single_const_ptr_type).?, false, .One),
+        .str => return zirStr(mod, scope, old_inst.castTag(.str).?),
-        .single_mut_ptr_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.single_mut_ptr_type).?, true, .One),
+        .int => return zirInt(mod, scope, old_inst.castTag(.int).?),
-        .many_const_ptr_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.many_const_ptr_type).?, false, .Many),
+        .int_type => return zirIntType(mod, scope, old_inst.castTag(.int_type).?),
-        .many_mut_ptr_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.many_mut_ptr_type).?, true, .Many),
+        .loop => return zirLoop(mod, scope, old_inst.castTag(.loop).?),
-        .c_const_ptr_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.c_const_ptr_type).?, false, .C),
+        .param_type => return zirParamType(mod, scope, old_inst.castTag(.param_type).?),
-        .c_mut_ptr_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.c_mut_ptr_type).?, true, .C),
+        .ptrtoint => return zirPtrtoint(mod, scope, old_inst.castTag(.ptrtoint).?),
-        .const_slice_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.const_slice_type).?, false, .Slice),
+        .field_ptr => return zirFieldPtr(mod, scope, old_inst.castTag(.field_ptr).?),
-        .mut_slice_type => return analyzeInstSimplePtrType(mod, scope, old_inst.castTag(.mut_slice_type).?, true, .Slice),
+        .field_val => return zirFieldVal(mod, scope, old_inst.castTag(.field_val).?),
-        .ptr_type => return analyzeInstPtrType(mod, scope, old_inst.castTag(.ptr_type).?),
+        .field_ptr_named => return zirFieldPtrNamed(mod, scope, old_inst.castTag(.field_ptr_named).?),
-        .store => return analyzeInstStore(mod, scope, old_inst.castTag(.store).?),
+        .field_val_named => return zirFieldValNamed(mod, scope, old_inst.castTag(.field_val_named).?),
-        .set_eval_branch_quota => return analyzeInstSetEvalBranchQuota(mod, scope, old_inst.castTag(.set_eval_branch_quota).?),
+        .deref => return zirDeref(mod, scope, old_inst.castTag(.deref).?),
-        .str => return analyzeInstStr(mod, scope, old_inst.castTag(.str).?),
+        .as => return zirAs(mod, scope, old_inst.castTag(.as).?),
-        .int => return analyzeInstInt(mod, scope, old_inst.castTag(.int).?),
+        .@"asm" => return zirAsm(mod, scope, old_inst.castTag(.@"asm").?),
-        .inttype => return analyzeInstIntType(mod, scope, old_inst.castTag(.inttype).?),
+        .unreachable_safe => return zirUnreachable(mod, scope, old_inst.castTag(.unreachable_safe).?, true),
-        .loop => return analyzeInstLoop(mod, scope, old_inst.castTag(.loop).?),
+        .unreachable_unsafe => return zirUnreachable(mod, scope, old_inst.castTag(.unreachable_unsafe).?, false),
-        .param_type => return analyzeInstParamType(mod, scope, old_inst.castTag(.param_type).?),
+        .@"return" => return zirReturn(mod, scope, old_inst.castTag(.@"return").?),
-        .ptrtoint => return analyzeInstPtrToInt(mod, scope, old_inst.castTag(.ptrtoint).?),
+        .return_void => return zirReturnVoid(mod, scope, old_inst.castTag(.return_void).?),
-        .field_ptr => return fieldPtr(mod, scope, old_inst.castTag(.field_ptr).?),
+        .@"fn" => return zirFn(mod, scope, old_inst.castTag(.@"fn").?),
-        .field_val => return fieldVal(mod, scope, old_inst.castTag(.field_val).?),
+        .@"export" => return zirExport(mod, scope, old_inst.castTag(.@"export").?),
-        .field_ptr_named => return fieldPtrNamed(mod, scope, old_inst.castTag(.field_ptr_named).?),
+        .primitive => return zirPrimitive(mod, scope, old_inst.castTag(.primitive).?),
-        .field_val_named => return fieldValNamed(mod, scope, old_inst.castTag(.field_val_named).?),
+        .fntype => return zirFnType(mod, scope, old_inst.castTag(.fntype).?),
-        .deref => return analyzeInstDeref(mod, scope, old_inst.castTag(.deref).?),
+        .intcast => return zirIntcast(mod, scope, old_inst.castTag(.intcast).?),
-        .as => return analyzeInstAs(mod, scope, old_inst.castTag(.as).?),
+        .bitcast => return zirBitcast(mod, scope, old_inst.castTag(.bitcast).?),
-        .@"asm" => return analyzeInstAsm(mod, scope, old_inst.castTag(.@"asm").?),
+        .floatcast => return zirFloatcast(mod, scope, old_inst.castTag(.floatcast).?),
-        .@"unreachable" => return analyzeInstUnreachable(mod, scope, old_inst.castTag(.@"unreachable").?, true),
+        .elem_ptr => return zirElemPtr(mod, scope, old_inst.castTag(.elem_ptr).?),
-        .unreach_nocheck => return analyzeInstUnreachable(mod, scope, old_inst.castTag(.unreach_nocheck).?, false),
+        .elem_val => return zirElemVal(mod, scope, old_inst.castTag(.elem_val).?),
-        .@"return" => return analyzeInstRet(mod, scope, old_inst.castTag(.@"return").?),
+        .add => return zirArithmetic(mod, scope, old_inst.castTag(.add).?),
-        .returnvoid => return analyzeInstRetVoid(mod, scope, old_inst.castTag(.returnvoid).?),
+        .addwrap => return zirArithmetic(mod, scope, old_inst.castTag(.addwrap).?),
-        .@"fn" => return analyzeInstFn(mod, scope, old_inst.castTag(.@"fn").?),
+        .sub => return zirArithmetic(mod, scope, old_inst.castTag(.sub).?),
-        .@"export" => return analyzeInstExport(mod, scope, old_inst.castTag(.@"export").?),
+        .subwrap => return zirArithmetic(mod, scope, old_inst.castTag(.subwrap).?),
-        .primitive => return analyzeInstPrimitive(mod, scope, old_inst.castTag(.primitive).?),
+        .mul => return zirArithmetic(mod, scope, old_inst.castTag(.mul).?),
-        .fntype => return analyzeInstFnType(mod, scope, old_inst.castTag(.fntype).?),
+        .mulwrap => return zirArithmetic(mod, scope, old_inst.castTag(.mulwrap).?),
-        .intcast => return analyzeInstIntCast(mod, scope, old_inst.castTag(.intcast).?),
+        .div => return zirArithmetic(mod, scope, old_inst.castTag(.div).?),
-        .bitcast => return analyzeInstBitCast(mod, scope, old_inst.castTag(.bitcast).?),
+        .mod_rem => return zirArithmetic(mod, scope, old_inst.castTag(.mod_rem).?),
-        .floatcast => return analyzeInstFloatCast(mod, scope, old_inst.castTag(.floatcast).?),
+        .array_cat => return zirArrayCat(mod, scope, old_inst.castTag(.array_cat).?),
-        .elem_ptr => return elemPtr(mod, scope, old_inst.castTag(.elem_ptr).?),
+        .array_mul => return zirArrayMul(mod, scope, old_inst.castTag(.array_mul).?),
-        .elem_val => return elemVal(mod, scope, old_inst.castTag(.elem_val).?),
+        .bit_and => return zirBitwise(mod, scope, old_inst.castTag(.bit_and).?),
-        .add => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.add).?),
+        .bit_not => return zirBitNot(mod, scope, old_inst.castTag(.bit_not).?),
-        .addwrap => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.addwrap).?),
+        .bit_or => return zirBitwise(mod, scope, old_inst.castTag(.bit_or).?),
-        .sub => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.sub).?),
+        .xor => return zirBitwise(mod, scope, old_inst.castTag(.xor).?),
-        .subwrap => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.subwrap).?),
+        .shl => return zirShl(mod, scope, old_inst.castTag(.shl).?),
-        .mul => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.mul).?),
+        .shr => return zirShr(mod, scope, old_inst.castTag(.shr).?),
-        .mulwrap => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.mulwrap).?),
+        .cmp_lt => return zirCmp(mod, scope, old_inst.castTag(.cmp_lt).?, .lt),
-        .div => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.div).?),
+        .cmp_lte => return zirCmp(mod, scope, old_inst.castTag(.cmp_lte).?, .lte),
-        .mod_rem => return analyzeInstArithmetic(mod, scope, old_inst.castTag(.mod_rem).?),
+        .cmp_eq => return zirCmp(mod, scope, old_inst.castTag(.cmp_eq).?, .eq),
-        .array_cat => return analyzeInstArrayCat(mod, scope, old_inst.castTag(.array_cat).?),
+        .cmp_gte => return zirCmp(mod, scope, old_inst.castTag(.cmp_gte).?, .gte),
-        .array_mul => return analyzeInstArrayMul(mod, scope, old_inst.castTag(.array_mul).?),
+        .cmp_gt => return zirCmp(mod, scope, old_inst.castTag(.cmp_gt).?, .gt),
-        .bitand => return analyzeInstBitwise(mod, scope, old_inst.castTag(.bitand).?),
+        .cmp_neq => return zirCmp(mod, scope, old_inst.castTag(.cmp_neq).?, .neq),
-        .bitnot => return analyzeInstBitNot(mod, scope, old_inst.castTag(.bitnot).?),
+        .condbr => return zirCondbr(mod, scope, old_inst.castTag(.condbr).?),
-        .bitor => return analyzeInstBitwise(mod, scope, old_inst.castTag(.bitor).?),
+        .is_null => return zirIsNull(mod, scope, old_inst.castTag(.is_null).?, false),
-        .xor => return analyzeInstBitwise(mod, scope, old_inst.castTag(.xor).?),
+        .is_non_null => return zirIsNull(mod, scope, old_inst.castTag(.is_non_null).?, true),
-        .shl => return analyzeInstShl(mod, scope, old_inst.castTag(.shl).?),
+        .is_null_ptr => return zirIsNullPtr(mod, scope, old_inst.castTag(.is_null_ptr).?, false),
-        .shr => return analyzeInstShr(mod, scope, old_inst.castTag(.shr).?),
+        .is_non_null_ptr => return zirIsNullPtr(mod, scope, old_inst.castTag(.is_non_null_ptr).?, true),
-        .cmp_lt => return analyzeInstCmp(mod, scope, old_inst.castTag(.cmp_lt).?, .lt),
+        .is_err => return zirIsErr(mod, scope, old_inst.castTag(.is_err).?),
-        .cmp_lte => return analyzeInstCmp(mod, scope, old_inst.castTag(.cmp_lte).?, .lte),
+        .is_err_ptr => return zirIsErrPtr(mod, scope, old_inst.castTag(.is_err_ptr).?),
-        .cmp_eq => return analyzeInstCmp(mod, scope, old_inst.castTag(.cmp_eq).?, .eq),
+        .bool_not => return zirBoolNot(mod, scope, old_inst.castTag(.bool_not).?),
-        .cmp_gte => return analyzeInstCmp(mod, scope, old_inst.castTag(.cmp_gte).?, .gte),
+        .typeof => return zirTypeof(mod, scope, old_inst.castTag(.typeof).?),
-        .cmp_gt => return analyzeInstCmp(mod, scope, old_inst.castTag(.cmp_gt).?, .gt),
+        .typeof_peer => return zirTypeofPeer(mod, scope, old_inst.castTag(.typeof_peer).?),
-        .cmp_neq => return analyzeInstCmp(mod, scope, old_inst.castTag(.cmp_neq).?, .neq),
+        .optional_type => return zirOptionalType(mod, scope, old_inst.castTag(.optional_type).?),
-        .condbr => return analyzeInstCondBr(mod, scope, old_inst.castTag(.condbr).?),
+        .optional_payload_safe => return zirOptionalPayload(mod, scope, old_inst.castTag(.optional_payload_safe).?, true),
-        .is_null => return isNull(mod, scope, old_inst.castTag(.is_null).?, false),
+        .optional_payload_unsafe => return zirOptionalPayload(mod, scope, old_inst.castTag(.optional_payload_unsafe).?, false),
-        .is_non_null => return isNull(mod, scope, old_inst.castTag(.is_non_null).?, true),
+        .optional_payload_safe_ptr => return zirOptionalPayloadPtr(mod, scope, old_inst.castTag(.optional_payload_safe_ptr).?, true),
-        .is_null_ptr => return isNullPtr(mod, scope, old_inst.castTag(.is_null_ptr).?, false),
+        .optional_payload_unsafe_ptr => return zirOptionalPayloadPtr(mod, scope, old_inst.castTag(.optional_payload_unsafe_ptr).?, false),
-        .is_non_null_ptr => return isNullPtr(mod, scope, old_inst.castTag(.is_non_null_ptr).?, true),
+        .err_union_payload_safe => return zirErrUnionPayload(mod, scope, old_inst.castTag(.err_union_payload_safe).?, true),
-        .is_err => return isErr(mod, scope, old_inst.castTag(.is_err).?),
+        .err_union_payload_unsafe => return zirErrUnionPayload(mod, scope, old_inst.castTag(.err_union_payload_unsafe).?, false),
-        .is_err_ptr => return isErrPtr(mod, scope, old_inst.castTag(.is_err_ptr).?),
+        .err_union_payload_safe_ptr => return zirErrUnionPayloadPtr(mod, scope, old_inst.castTag(.err_union_payload_safe_ptr).?, true),
-        .boolnot => return analyzeInstBoolNot(mod, scope, old_inst.castTag(.boolnot).?),
+        .err_union_payload_unsafe_ptr => return zirErrUnionPayloadPtr(mod, scope, old_inst.castTag(.err_union_payload_unsafe_ptr).?, false),
-        .typeof => return analyzeInstTypeOf(mod, scope, old_inst.castTag(.typeof).?),
+        .err_union_code => return zirErrUnionCode(mod, scope, old_inst.castTag(.err_union_code).?),
-        .typeof_peer => return analyzeInstTypeOfPeer(mod, scope, old_inst.castTag(.typeof_peer).?),
+        .err_union_code_ptr => return zirErrUnionCodePtr(mod, scope, old_inst.castTag(.err_union_code_ptr).?),
-        .optional_type => return analyzeInstOptionalType(mod, scope, old_inst.castTag(.optional_type).?),
+        .ensure_err_payload_void => return zirEnsureErrPayloadVoid(mod, scope, old_inst.castTag(.ensure_err_payload_void).?),
-        .optional_payload_safe => return optionalPayload(mod, scope, old_inst.castTag(.optional_payload_safe).?, true),
+        .array_type => return zirArrayType(mod, scope, old_inst.castTag(.array_type).?),
-        .optional_payload_unsafe => return optionalPayload(mod, scope, old_inst.castTag(.optional_payload_unsafe).?, false),
+        .array_type_sentinel => return zirArrayTypeSentinel(mod, scope, old_inst.castTag(.array_type_sentinel).?),
-        .optional_payload_safe_ptr => return optionalPayloadPtr(mod, scope, old_inst.castTag(.optional_payload_safe_ptr).?, true),
+        .enum_literal => return zirEnumLiteral(mod, scope, old_inst.castTag(.enum_literal).?),
-        .optional_payload_unsafe_ptr => return optionalPayloadPtr(mod, scope, old_inst.castTag(.optional_payload_unsafe_ptr).?, false),
+        .merge_error_sets => return zirMergeErrorSets(mod, scope, old_inst.castTag(.merge_error_sets).?),
-        .err_union_payload_safe => return errorUnionPayload(mod, scope, old_inst.castTag(.err_union_payload_safe).?, true),
+        .error_union_type => return zirErrorUnionType(mod, scope, old_inst.castTag(.error_union_type).?),
-        .err_union_payload_unsafe => return errorUnionPayload(mod, scope, old_inst.castTag(.err_union_payload_unsafe).?, false),
+        .anyframe_type => return zirAnyframeType(mod, scope, old_inst.castTag(.anyframe_type).?),
-        .err_union_payload_safe_ptr => return errorUnionPayloadPtr(mod, scope, old_inst.castTag(.err_union_payload_safe_ptr).?, true),
+        .error_set => return zirErrorSet(mod, scope, old_inst.castTag(.error_set).?),
-        .err_union_payload_unsafe_ptr => return errorUnionPayloadPtr(mod, scope, old_inst.castTag(.err_union_payload_unsafe_ptr).?, false),
+        .slice => return zirSlice(mod, scope, old_inst.castTag(.slice).?),
-        .err_union_code => return errorUnionCode(mod, scope, old_inst.castTag(.err_union_code).?),
+        .slice_start => return zirSliceStart(mod, scope, old_inst.castTag(.slice_start).?),
-        .err_union_code_ptr => return errorUnionCodePtr(mod, scope, old_inst.castTag(.err_union_code_ptr).?),
+        .import => return zirImport(mod, scope, old_inst.castTag(.import).?),
-        .ensure_err_payload_void => return analyzeInstEnsureErrPayloadVoid(mod, scope, old_inst.castTag(.ensure_err_payload_void).?),
+        .bool_and => return zirBoolOp(mod, scope, old_inst.castTag(.bool_and).?),
-        .array_type => return analyzeInstArrayType(mod, scope, old_inst.castTag(.array_type).?),
+        .bool_or => return zirBoolOp(mod, scope, old_inst.castTag(.bool_or).?),
-        .array_type_sentinel => return analyzeInstArrayTypeSentinel(mod, scope, old_inst.castTag(.array_type_sentinel).?),
+        .void_value => return mod.constVoid(scope, old_inst.src),
-        .enum_literal => return analyzeInstEnumLiteral(mod, scope, old_inst.castTag(.enum_literal).?),
-        .merge_error_sets => return analyzeInstMergeErrorSets(mod, scope, old_inst.castTag(.merge_error_sets).?),
-        .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 +246,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 +263,25 @@ fn analyzeConstInst(mod: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError
     };
 }
-fn analyzeInstCoerceResultBlockPtr(
+fn zirBitcastRef(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
-    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", .{});
-}
-fn bitCastRef(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 +291,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 +299,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 +308,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 +318,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 +328,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 +358,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 +367,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 +377,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 +406,7 @@ fn analyzeInstAllocInferred(
     return result;
 }
-fn analyzeInstResolveInferredAlloc(
+fn zirResolveInferredAlloc(
     mod: *Module,
     scope: *Scope,
     inst: *zir.Inst.UnOp,
 @@ -466,28 +435,46 @@ 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);
+    // TODO detect when this store should be done at compile-time. For example,
+    // if expressions should force it when the condition is compile-time known.
+    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 +486,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 +504,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 +526,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 +545,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 +562,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 +596,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 +619,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,25 +660,14 @@ 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).?;
-    var child_block: Scope.Block = .{
+    var child_block = parent_block.makeSubBlock();
-        .parent = parent_block,
-        .inst_table = parent_block.inst_table,
-        .func = parent_block.func,
-        .owner_decl = parent_block.owner_decl,
-        .src_decl = parent_block.src_decl,
-        .instructions = .{},
-        .arena = parent_block.arena,
-        .label = null,
-        .inlining = parent_block.inlining,
-        .is_comptime = parent_block.is_comptime or is_comptime,
-        .branch_quota = parent_block.branch_quota,
-    };
     defer child_block.instructions.deinit(mod.gpa);
+    child_block.is_comptime = child_block.is_comptime or is_comptime;
     try analyzeBody(mod, &child_block, inst.positionals.body);
 @@ -704,9 +681,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
 @@ -735,6 +718,7 @@ fn analyzeInstBlock(mod: *Module, scope: *Scope, inst: *zir.Inst.Block, is_compt
             .zir_block = inst,
             .merges = .{
                 .results = .{},
+                .br_list = .{},
                 .block_inst = block_inst,
             },
         }),
 @@ -746,6 +730,7 @@ fn analyzeInstBlock(mod: *Module, scope: *Scope, inst: *zir.Inst.Block, is_compt
     defer child_block.instructions.deinit(mod.gpa);
     defer merges.results.deinit(mod.gpa);
+    defer merges.br_list.deinit(mod.gpa);
     try analyzeBody(mod, &child_block, inst.positionals.body);
 @@ -779,49 +764,127 @@ fn analyzeBlockBody(
         const last_inst = child_block.instructions.items[last_inst_index];
         if (last_inst.breakBlock()) |br_block| {
             if (br_block == merges.block_inst) {
-                // No need for a block instruction. We can put the new instructions directly into the parent block.
+                // No need for a block instruction. We can put the new instructions directly
-                // Here we omit the break instruction.
+                // into the parent block. Here we omit the break instruction.
                 const copied_instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items[0..last_inst_index]);
                 try parent_block.instructions.appendSlice(mod.gpa, copied_instructions);
                 return merges.results.items[0];
             }
         }
     }
-    // It should be impossible to have the number of results be > 1 in a comptime scope.
+    // It is impossible to have the number of results be > 1 in a comptime scope.
-    assert(!child_block.is_comptime); // We should have already got a compile error in the condbr condition.
+    assert(!child_block.is_comptime); // Should already got a compile error in the condbr condition.
     // Need to set the type and emit the Block instruction. This allows machine code generation
     // to emit a jump instruction to after the block when it encounters the break.
     try parent_block.instructions.append(mod.gpa, &merges.block_inst.base);
-    merges.block_inst.base.ty = try mod.resolvePeerTypes(scope, merges.results.items);
+    const resolved_ty = try mod.resolvePeerTypes(scope, merges.results.items);
-    merges.block_inst.body = .{ .instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items) };
+    merges.block_inst.base.ty = resolved_ty;
+    merges.block_inst.body = .{
+        .instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items),
+    };
+    // Now that the block has its type resolved, we need to go back into all the break
+    // instructions, and insert type coercion on the operands.
+    for (merges.br_list.items) |br| {
+        if (br.operand.ty.eql(resolved_ty)) {
+            // No type coercion needed.
+            continue;
+        }
+        var coerce_block = parent_block.makeSubBlock();
+        defer coerce_block.instructions.deinit(mod.gpa);
+        const coerced_operand = try mod.coerce(&coerce_block.base, resolved_ty, br.operand);
+        // If no instructions were produced, such as in the case of a coercion of a
+        // constant value to a new type, we can simply point the br operand to it.
+        if (coerce_block.instructions.items.len == 0) {
+            br.operand = coerced_operand;
+            continue;
+        }
+        assert(coerce_block.instructions.items[coerce_block.instructions.items.len - 1] == coerced_operand);
+        // Here we depend on the br instruction having been over-allocated (if necessary)
+        // inide analyzeBreak so that it can be converted into a br_block_flat instruction.
+        const br_src = br.base.src;
+        const br_ty = br.base.ty;
+        const br_block_flat = @ptrCast(*Inst.BrBlockFlat, br);
+        br_block_flat.* = .{
+            .base = .{
+                .src = br_src,
+                .ty = br_ty,
+                .tag = .br_block_flat,
+            },
+            .block = merges.block_inst,
+            .body = .{
+                .instructions = try parent_block.arena.dupe(*Inst, coerce_block.instructions.items),
+            },
+        };
+    }
     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) {
+                const b = try mod.requireFunctionBlock(scope, src);
+                // Here we add a br instruction, but we over-allocate a little bit
+                // (if necessary) to make it possible to convert the instruction into
+                // a br_block_flat instruction later.
+                const br = @ptrCast(*Inst.Br, try b.arena.alignedAlloc(
+                    u8,
+                    Inst.convertable_br_align,
+                    Inst.convertable_br_size,
+                ));
+                br.* = .{
+                    .base = .{
+                        .tag = .br,
+                        .ty = Type.initTag(.noreturn),
+                        .src = src,
+                    },
+                    .operand = operand,
+                    .block = label.merges.block_inst,
+                };
+                try b.instructions.append(mod.gpa, &br.base);
+                try label.merges.results.append(mod.gpa, operand);
+                try label.merges.br_list.append(mod.gpa, br);
+                return &br.base;
+            }
+        }
+        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 +895,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();
 @@ -965,6 +1028,7 @@ fn call(mod: *Module, scope: *Scope, inst: *zir.Inst.Call) InnerError!*Inst {
             .casted_args = casted_args,
             .merges = .{
                 .results = .{},
+                .br_list = .{},
                 .block_inst = block_inst,
             },
         };
 @@ -989,6 +1053,7 @@ fn call(mod: *Module, scope: *Scope, inst: *zir.Inst.Call) InnerError!*Inst {
         defer child_block.instructions.deinit(mod.gpa);
         defer merges.results.deinit(mod.gpa);
+        defer merges.br_list.deinit(mod.gpa);
         try mod.emitBackwardBranch(&child_block, inst.base.src);
 @@ -1002,7 +1067,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 +1084,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 +1098,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 +1108,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 +1119,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 +1132,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 +1140,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 +1172,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 +1189,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 +1230,7 @@ fn optionalPayloadPtr(
 }
 /// Value in, value out.
-fn optionalPayload(
+fn zirOptionalPayload(
     mod: *Module,
     scope: *Scope,
     unwrap: *zir.Inst.UnOp,
 @@ -1201,40 +1266,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 +1342,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 +1356,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 +1369,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 +1380,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 +1389,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 +1401,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 +1411,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 +1449,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 +1457,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 +1495,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 +1506,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 +1515,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 +1526,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,235 +1535,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 zirImport(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!*Inst {
-    const tracy = trace(@src());
-    defer tracy.end();
-    const start = try resolveInst(mod, scope, inst.positionals.lhs);
-    const end = try resolveInst(mod, scope, inst.positionals.rhs);
-    switch (start.ty.zigTypeTag()) {
-        .Int, .ComptimeInt => {},
-        else => return mod.constVoid(scope, inst.base.src),
-    }
-    switch (end.ty.zigTypeTag()) {
-        .Int, .ComptimeInt => {},
-        else => return mod.constVoid(scope, inst.base.src),
-    }
-    if (start.value()) |start_val| {
-        if (end.value()) |end_val| {
-            if (start_val.compare(.gte, end_val)) {
-                return mod.fail(scope, inst.base.src, "range start value must be smaller than the end value", .{});
-            }
-        }
-    }
-    return mod.constVoid(scope, inst.base.src);
-}
-fn analyzeInstSwitchBr(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);
-    const target = try mod.analyzeDeref(scope, inst.base.src, target_ptr, inst.positionals.target_ptr.src);
-    try validateSwitch(mod, scope, target, inst);
-    if (try mod.resolveDefinedValue(scope, target)) |target_val| {
-        for (inst.positionals.cases) |case| {
-            const resolved = try resolveInst(mod, scope, case.item);
-            const casted = try mod.coerce(scope, target.ty, resolved);
-            const item = try mod.resolveConstValue(scope, casted);
-            if (target_val.eql(item)) {
-                try analyzeBody(mod, scope.cast(Scope.Block).?, case.body);
-                return mod.constNoReturn(scope, inst.base.src);
-            }
-        }
-        try analyzeBody(mod, scope.cast(Scope.Block).?, inst.positionals.else_body);
-        return mod.constNoReturn(scope, inst.base.src);
-    }
-    if (inst.positionals.cases.len == 0) {
-        // no cases just analyze else_branch
-        try analyzeBody(mod, scope.cast(Scope.Block).?, inst.positionals.else_body);
-        return mod.constNoReturn(scope, inst.base.src);
-    }
-    const parent_block = try mod.requireRuntimeBlock(scope, inst.base.src);
-    const cases = try parent_block.arena.alloc(Inst.SwitchBr.Case, inst.positionals.cases.len);
-    var case_block: Scope.Block = .{
-        .parent = parent_block,
-        .inst_table = parent_block.inst_table,
-        .func = parent_block.func,
-        .owner_decl = parent_block.owner_decl,
-        .src_decl = parent_block.src_decl,
-        .instructions = .{},
-        .arena = parent_block.arena,
-        .inlining = parent_block.inlining,
-        .is_comptime = parent_block.is_comptime,
-        .branch_quota = parent_block.branch_quota,
-    };
-    defer case_block.instructions.deinit(mod.gpa);
-    for (inst.positionals.cases) |case, i| {
-        // Reset without freeing.
-        case_block.instructions.items.len = 0;
-        const resolved = try resolveInst(mod, scope, case.item);
-        const casted = try mod.coerce(scope, target.ty, resolved);
-        const item = try mod.resolveConstValue(scope, casted);
-        try analyzeBody(mod, &case_block, case.body);
-        cases[i] = .{
-            .item = item,
-            .body = .{ .instructions = try parent_block.arena.dupe(*Inst, case_block.instructions.items) },
-        };
-    }
-    case_block.instructions.items.len = 0;
-    try analyzeBody(mod, &case_block, inst.positionals.else_body);
-    const else_body: ir.Body = .{
-        .instructions = try parent_block.arena.dupe(*Inst, case_block.instructions.items),
-    };
-    return mod.addSwitchBr(parent_block, inst.base.src, target_ptr, cases, else_body);
-}
-fn validateSwitch(mod: *Module, scope: *Scope, target: *Inst, inst: *zir.Inst.SwitchBr) InnerError!void {
-    // validate usage of '_' prongs
-    if (inst.kw_args.special_prong == .underscore and target.ty.zigTypeTag() != .Enum) {
-        return mod.fail(scope, inst.base.src, "'_' prong only allowed when switching on non-exhaustive enums", .{});
-        // TODO notes "'_' prong here" inst.positionals.cases[last].src
-    }
-    // check that target type supports ranges
-    if (inst.kw_args.range) |range_inst| {
-        switch (target.ty.zigTypeTag()) {
-            .Int, .ComptimeInt => {},
-            else => {
-                return mod.fail(scope, target.src, "ranges not allowed when switching on type {}", .{target.ty});
-                // TODO notes "range used here" range_inst.src
-            },
-        }
-    }
-    // validate for duplicate items/missing else prong
-    switch (target.ty.zigTypeTag()) {
-        .Enum => return mod.fail(scope, inst.base.src, "TODO validateSwitch .Enum", .{}),
-        .ErrorSet => return mod.fail(scope, inst.base.src, "TODO validateSwitch .ErrorSet", .{}),
-        .Union => return mod.fail(scope, inst.base.src, "TODO validateSwitch .Union", .{}),
-        .Int, .ComptimeInt => {
-            var range_set = @import("RangeSet.zig").init(mod.gpa);
-            defer range_set.deinit();
-            for (inst.positionals.items) |item| {
-                const maybe_src = if (item.castTag(.switch_range)) |range| blk: {
-                    const start_resolved = try resolveInst(mod, scope, range.positionals.lhs);
-                    const start_casted = try mod.coerce(scope, target.ty, start_resolved);
-                    const end_resolved = try resolveInst(mod, scope, range.positionals.rhs);
-                    const end_casted = try mod.coerce(scope, target.ty, end_resolved);
-                    break :blk try range_set.add(
-                        try mod.resolveConstValue(scope, start_casted),
-                        try mod.resolveConstValue(scope, end_casted),
-                        item.src,
-                    );
-                } else blk: {
-                    const resolved = try resolveInst(mod, scope, item);
-                    const casted = try mod.coerce(scope, target.ty, resolved);
-                    const value = try mod.resolveConstValue(scope, casted);
-                    break :blk try range_set.add(value, value, item.src);
-                };
-                if (maybe_src) |previous_src| {
-                    return mod.fail(scope, item.src, "duplicate switch value", .{});
-                    // TODO notes "previous value is here" previous_src
-                }
-            }
-            if (target.ty.zigTypeTag() == .Int) {
-                var arena = std.heap.ArenaAllocator.init(mod.gpa);
-                defer arena.deinit();
-                const start = try target.ty.minInt(&arena, mod.getTarget());
-                const end = try target.ty.maxInt(&arena, mod.getTarget());
-                if (try range_set.spans(start, end)) {
-                    if (inst.kw_args.special_prong == .@"else") {
-                        return mod.fail(scope, inst.base.src, "unreachable else prong, all cases already handled", .{});
-                    }
-                    return;
-                }
-            }
-            if (inst.kw_args.special_prong != .@"else") {
-                return mod.fail(scope, inst.base.src, "switch must handle all possibilities", .{});
-            }
-        },
-        .Bool => {
-            var true_count: u8 = 0;
-            var false_count: u8 = 0;
-            for (inst.positionals.items) |item| {
-                const resolved = try resolveInst(mod, scope, item);
-                const casted = try mod.coerce(scope, Type.initTag(.bool), resolved);
-                if ((try mod.resolveConstValue(scope, casted)).toBool()) {
-                    true_count += 1;
-                } else {
-                    false_count += 1;
-                }
-                if (true_count + false_count > 2) {
-                    return mod.fail(scope, item.src, "duplicate switch value", .{});
-                }
-            }
-            if ((true_count + false_count < 2) and inst.kw_args.special_prong != .@"else") {
-                return mod.fail(scope, inst.base.src, "switch must handle all possibilities", .{});
-            }
-            if ((true_count + false_count == 2) and inst.kw_args.special_prong == .@"else") {
-                return mod.fail(scope, inst.base.src, "unreachable else prong, all cases already handled", .{});
-            }
-        },
-        .EnumLiteral, .Void, .Fn, .Pointer, .Type => {
-            if (inst.kw_args.special_prong != .@"else") {
-                return mod.fail(scope, inst.base.src, "else prong required when switching on type '{}'", .{target.ty});
-            }
-            var seen_values = std.HashMap(Value, usize, Value.hash, Value.eql, std.hash_map.DefaultMaxLoadPercentage).init(mod.gpa);
-            defer seen_values.deinit();
-            for (inst.positionals.items) |item| {
-                const resolved = try resolveInst(mod, scope, item);
-                const casted = try mod.coerce(scope, target.ty, resolved);
-                const val = try mod.resolveConstValue(scope, casted);
-                if (try seen_values.fetchPut(val, item.src)) |prev| {
-                    return mod.fail(scope, item.src, "duplicate switch value", .{});
-                    // TODO notes "previous value here" prev.value
-                }
-            }
-        },
-        .ErrorUnion,
-        .NoReturn,
-        .Array,
-        .Struct,
-        .Undefined,
-        .Null,
-        .Optional,
-        .BoundFn,
-        .Opaque,
-        .Vector,
-        .Frame,
-        .AnyFrame,
-        .ComptimeFloat,
-        .Float,
-        => {
-            return mod.fail(scope, target.src, "invalid switch target type '{}'", .{target.ty});
-        },
-    }
-}
-fn analyzeInstImport(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 +1555,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 +1621,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 +1630,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 +1749,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 +1797,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 +1855,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 +1874,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 +1887,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 +1896,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 +1908,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 +1926,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 +1941,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 +1990,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 +2007,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);
 @@ -2179,13 +2016,14 @@ fn analyzeInstRet(mod: *Module, scope: *Scope, inst: *zir.Inst.UnOp) InnerError!
     if (b.inlining) |inlining| {
         // We are inlining a function call; rewrite the `ret` as a `break`.
         try inlining.merges.results.append(mod.gpa, operand);
-        return mod.addBr(b, inst.base.src, inlining.merges.block_inst, operand);
+        const br = try mod.addBr(b, inst.base.src, inlining.merges.block_inst, operand);
+        return &br.base;
     }
     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);
 @@ -2193,7 +2031,8 @@ fn analyzeInstRetVoid(mod: *Module, scope: *Scope, inst: *zir.Inst.NoOp) InnerEr
         // We are inlining a function call; rewrite the `retvoid` as a `breakvoid`.
         const void_inst = try mod.constVoid(scope, inst.base.src);
         try inlining.merges.results.append(mod.gpa, void_inst);
-        return mod.addBr(b, inst.base.src, inlining.merges.block_inst, void_inst);
+        const br = try mod.addBr(b, inst.base.src, inlining.merges.block_inst, void_inst);
+        return &br.base;
     }
     if (b.func) |func| {
 @@ -2216,27 +2055,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 +2063,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

test/stage2/test.zig-37

...	@@ -962,43 +962,6 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -962,43 +962,6 @@ pub fn addCases(ctx: *TestContext) !void {
962	,	962	,
963	"hello\nhello\nhello\nhello\nhello\n",	963	"hello\nhello\nhello\nhello\nhello\n",
964	);	964	);
965
966	// comptime switch
967
968	// Basic for loop
969	case.addCompareOutput(
970	\\pub export fn _start() noreturn {
971	\\ assert(foo() == 1);
972	\\ exit();
973	\\}
974	\\
975	\\fn foo() u32 {
976	\\ const a: comptime_int = 1;
977	\\ var b: u32 = 0;
978	\\ switch (a) {
979	\\ 1 => b = 1,
980	\\ 2 => b = 2,
981	\\ else => unreachable,
982	\\ }
983	\\ return b;
984	\\}
985	\\
986	\\pub fn assert(ok: bool) void {
987	\\ if (!ok) unreachable; // assertion failure
988	\\}
989	\\
990	\\fn exit() noreturn {
991	\\ asm volatile ("syscall"
992	\\ :
993	\\ : [number] "{rax}" (231),
994	\\ [arg1] "{rdi}" (0)
995	\\ : "rcx", "r11", "memory"
996	\\ );
997	\\ unreachable;
998	\\}
999	,
1000	"",
1001	);
1002	}	965	}
1003		966
1004	{	967	{