Commit 39510cc7d1f6035e16aaa4f97991abbaddef463c | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2023-05-27 07:29:55+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2023-06-13 12:55:01+01:00
log	39510cc7d1f6035e16aaa4f97991abbaddef463c
tree	b30f1bdc56f73aab84ec2996111a96a7fdb88e4e
parent	ec27524da9b4200dc9ea39285e9c4c30cad28a98
signature	Commit is signed but in an unrecognized format.

Eliminate switch_capture_tag ZIR instruction

This is a follow-up to a previous commit which eliminated switch_capture
and switch_capture_ref. All captures are now handled directly by
`switch_block`, which has also eliminated some unnecessary Block data in
Sema.

4 files changed, 194 insertions(+), 91 deletions(-)

src/AstGen.zig+47-15

...	@@ -2612,7 +2612,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As	...	@@ -2612,7 +2612,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
2612	.switch_block,	2612	.switch_block,
2613	.switch_cond,	2613	.switch_cond,
2614	.switch_cond_ref,	2614	.switch_cond_ref,
2615	.switch_capture_tag,
2616	.struct_init_empty,	2615	.struct_init_empty,
2617	.struct_init,	2616	.struct_init,
2618	.struct_init_ref,	2617	.struct_init_ref,
...	@@ -2956,7 +2955,7 @@ fn deferStmt(	...	@@ -2956,7 +2955,7 @@ fn deferStmt(
2956	try gz.astgen.instructions.append(gz.astgen.gpa, .{	2955	try gz.astgen.instructions.append(gz.astgen.gpa, .{
2957	.tag = .extended,	2956	.tag = .extended,
2958	.data = .{ .extended = .{	2957	.data = .{ .extended = .{
2959	.opcode = .errdefer_err_code,	2958	.opcode = .value_placeholder,
2960	.small = undefined,	2959	.small = undefined,
2961	.operand = undefined,	2960	.operand = undefined,
2962	} },	2961	} },
...	@@ -6711,6 +6710,7 @@ fn switchExpr(	...	@@ -6711,6 +6710,7 @@ fn switchExpr(
6711	// for the following variables, make note of the special prong AST node index,	6710	// for the following variables, make note of the special prong AST node index,
6712	// and bail out with a compile error if there are multiple special prongs present.	6711	// and bail out with a compile error if there are multiple special prongs present.
6713	var any_payload_is_ref = false;	6712	var any_payload_is_ref = false;
		6713	var any_has_tag_capture = false;
6714	var scalar_cases_len: u32 = 0;	6714	var scalar_cases_len: u32 = 0;
6715	var multi_cases_len: u32 = 0;	6715	var multi_cases_len: u32 = 0;
6716	var inline_cases_len: u32 = 0;	6716	var inline_cases_len: u32 = 0;
...	@@ -6721,8 +6721,12 @@ fn switchExpr(	...	@@ -6721,8 +6721,12 @@ fn switchExpr(
6721	for (case_nodes) \|case_node\| {	6721	for (case_nodes) \|case_node\| {
6722	const case = tree.fullSwitchCase(case_node).?;	6722	const case = tree.fullSwitchCase(case_node).?;
6723	if (case.payload_token) \|payload_token\| {	6723	if (case.payload_token) \|payload_token\| {
6724	if (token_tags[payload_token] == .asterisk) {	6724	const ident = if (token_tags[payload_token] == .asterisk) blk: {
6725	any_payload_is_ref = true;	6725	any_payload_is_ref = true;
		6726	break :blk payload_token + 1;
		6727	} else payload_token;
		6728	if (token_tags[ident + 1] == .comma) {
		6729	any_has_tag_capture = true;
6726	}	6730	}
6727	}	6731	}
6728	// Check for else/`_` prong.	6732	// Check for else/`_` prong.
...	@@ -6861,6 +6865,20 @@ fn switchExpr(	...	@@ -6861,6 +6865,20 @@ fn switchExpr(
6861	var case_scope = parent_gz.makeSubBlock(&block_scope.base);	6865	var case_scope = parent_gz.makeSubBlock(&block_scope.base);
6862	case_scope.instructions_top = GenZir.unstacked_top;	6866	case_scope.instructions_top = GenZir.unstacked_top;
6863		6867
		6868	// If any prong has an inline tag capture, allocate a shared dummy instruction for it
		6869	const tag_inst = if (any_has_tag_capture) tag_inst: {
		6870	const inst = @intCast(Zir.Inst.Index, astgen.instructions.len);
		6871	try astgen.instructions.append(astgen.gpa, .{
		6872	.tag = .extended,
		6873	.data = .{ .extended = .{
		6874	.opcode = .value_placeholder,
		6875	.small = undefined,
		6876	.operand = undefined,
		6877	} }, // TODO rename opcode
		6878	});
		6879	break :tag_inst inst;
		6880	} else undefined;
		6881
6864	// In this pass we generate all the item and prong expressions.	6882	// In this pass we generate all the item and prong expressions.
6865	var multi_case_index: u32 = 0;	6883	var multi_case_index: u32 = 0;
6866	var scalar_case_index: u32 = 0;	6884	var scalar_case_index: u32 = 0;
...	@@ -6874,7 +6892,7 @@ fn switchExpr(	...	@@ -6874,7 +6892,7 @@ fn switchExpr(
6874	var dbg_var_inst: Zir.Inst.Ref = undefined;	6892	var dbg_var_inst: Zir.Inst.Ref = undefined;
6875	var dbg_var_tag_name: ?u32 = null;	6893	var dbg_var_tag_name: ?u32 = null;
6876	var dbg_var_tag_inst: Zir.Inst.Ref = undefined;	6894	var dbg_var_tag_inst: Zir.Inst.Ref = undefined;
6877	var tag_inst: Zir.Inst.Index = 0;	6895	var has_tag_capture = false;
6878	var capture_val_scope: Scope.LocalVal = undefined;	6896	var capture_val_scope: Scope.LocalVal = undefined;
6879	var tag_scope: Scope.LocalVal = undefined;	6897	var tag_scope: Scope.LocalVal = undefined;
6880		6898
...	@@ -6925,14 +6943,9 @@ fn switchExpr(	...	@@ -6925,14 +6943,9 @@ fn switchExpr(
6925	}	6943	}
6926	const tag_name = try astgen.identAsString(tag_token);	6944	const tag_name = try astgen.identAsString(tag_token);
6927	try astgen.detectLocalShadowing(payload_sub_scope, tag_name, tag_token, tag_slice, .@"switch tag capture");	6945	try astgen.detectLocalShadowing(payload_sub_scope, tag_name, tag_token, tag_slice, .@"switch tag capture");
6928	tag_inst = @intCast(Zir.Inst.Index, astgen.instructions.len);	6946
6929	try astgen.instructions.append(gpa, .{	6947	assert(any_has_tag_capture);
6930	.tag = .switch_capture_tag,	6948	has_tag_capture = true;
6931	.data = .{ .un_tok = .{
6932	.operand = cond,
6933	.src_tok = case_scope.tokenIndexToRelative(tag_token),
6934	} },
6935	});
6936		6949
6937	tag_scope = .{	6950	tag_scope = .{
6938	.parent = payload_sub_scope,	6951	.parent = payload_sub_scope,
...	@@ -6998,7 +7011,6 @@ fn switchExpr(	...	@@ -6998,7 +7011,6 @@ fn switchExpr(
6998	case_scope.instructions_top = parent_gz.instructions.items.len;	7011	case_scope.instructions_top = parent_gz.instructions.items.len;
6999	defer case_scope.unstack();	7012	defer case_scope.unstack();
7000		7013
7001	if (tag_inst != 0) try case_scope.instructions.append(gpa, tag_inst);
7002	try case_scope.addDbgBlockBegin();	7014	try case_scope.addDbgBlockBegin();
7003	if (dbg_var_name) \|some\| {	7015	if (dbg_var_name) \|some\| {
7004	try case_scope.addDbgVar(.dbg_var_val, some, dbg_var_inst);	7016	try case_scope.addDbgVar(.dbg_var_val, some, dbg_var_inst);
...	@@ -7018,7 +7030,8 @@ fn switchExpr(	...	@@ -7018,7 +7030,8 @@ fn switchExpr(
7018	const case_slice = case_scope.instructionsSlice();	7030	const case_slice = case_scope.instructionsSlice();
7019	// Since we use the switch_block instruction itself to refer to the	7031	// Since we use the switch_block instruction itself to refer to the
7020	// capture, which will not be added to the child block, we need to	7032	// capture, which will not be added to the child block, we need to
7021	// handle ref_table manually.	7033	// handle ref_table manually, and the same for the inline tag
		7034	// capture instruction.
7022	const refs_len = refs: {	7035	const refs_len = refs: {
7023	var n: usize = 0;	7036	var n: usize = 0;
7024	var check_inst = switch_block;	7037	var check_inst = switch_block;
...	@@ -7026,18 +7039,31 @@ fn switchExpr(	...	@@ -7026,18 +7039,31 @@ fn switchExpr(
7026	n += 1;	7039	n += 1;
7027	check_inst = ref_inst;	7040	check_inst = ref_inst;
7028	}	7041	}
		7042	if (has_tag_capture) {
		7043	check_inst = tag_inst;
		7044	while (astgen.ref_table.get(check_inst)) \|ref_inst\| {
		7045	n += 1;
		7046	check_inst = ref_inst;
		7047	}
		7048	}
7029	break :refs n;	7049	break :refs n;
7030	};	7050	};
7031	const body_len = refs_len + astgen.countBodyLenAfterFixups(case_slice);	7051	const body_len = refs_len + astgen.countBodyLenAfterFixups(case_slice);
7032	try payloads.ensureUnusedCapacity(gpa, body_len);	7052	try payloads.ensureUnusedCapacity(gpa, body_len);
7033	payloads.items[body_len_index] = @bitCast(u32, Zir.Inst.SwitchBlock.ProngInfo{	7053	payloads.items[body_len_index] = @bitCast(u32, Zir.Inst.SwitchBlock.ProngInfo{
7034	.body_len = @intCast(u29, body_len),	7054	.body_len = @intCast(u28, body_len),
7035	.capture = capture,	7055	.capture = capture,
7036	.is_inline = case.inline_token != null,	7056	.is_inline = case.inline_token != null,
		7057	.has_tag_capture = has_tag_capture,
7037	});	7058	});
7038	if (astgen.ref_table.fetchRemove(switch_block)) \|kv\| {	7059	if (astgen.ref_table.fetchRemove(switch_block)) \|kv\| {
7039	appendPossiblyRefdBodyInst(astgen, payloads, kv.value);	7060	appendPossiblyRefdBodyInst(astgen, payloads, kv.value);
7040	}	7061	}
		7062	if (has_tag_capture) {
		7063	if (astgen.ref_table.fetchRemove(tag_inst)) \|kv\| {
		7064	appendPossiblyRefdBodyInst(astgen, payloads, kv.value);
		7065	}
		7066	}
7041	appendBodyWithFixupsArrayList(astgen, payloads, case_slice);	7067	appendBodyWithFixupsArrayList(astgen, payloads, case_slice);
7042	}	7068	}
7043	}	7069	}
...	@@ -7046,6 +7072,7 @@ fn switchExpr(	...	@@ -7046,6 +7072,7 @@ fn switchExpr(
7046		7072
7047	try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.SwitchBlock).Struct.fields.len +	7073	try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.SwitchBlock).Struct.fields.len +
7048	@boolToInt(multi_cases_len != 0) +	7074	@boolToInt(multi_cases_len != 0) +
		7075	@boolToInt(any_has_tag_capture) +
7049	payloads.items.len - case_table_end);	7076	payloads.items.len - case_table_end);
7050		7077
7051	const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.SwitchBlock{	7078	const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.SwitchBlock{
...	@@ -7054,6 +7081,7 @@ fn switchExpr(	...	@@ -7054,6 +7081,7 @@ fn switchExpr(
7054	.has_multi_cases = multi_cases_len != 0,	7081	.has_multi_cases = multi_cases_len != 0,
7055	.has_else = special_prong == .@"else",	7082	.has_else = special_prong == .@"else",
7056	.has_under = special_prong == .under,	7083	.has_under = special_prong == .under,
		7084	.any_has_tag_capture = any_has_tag_capture,
7057	.scalar_cases_len = @intCast(Zir.Inst.SwitchBlock.Bits.ScalarCasesLen, scalar_cases_len),	7085	.scalar_cases_len = @intCast(Zir.Inst.SwitchBlock.Bits.ScalarCasesLen, scalar_cases_len),
7058	},	7086	},
7059	});	7087	});
...	@@ -7062,6 +7090,10 @@ fn switchExpr(	...	@@ -7062,6 +7090,10 @@ fn switchExpr(
7062	astgen.extra.appendAssumeCapacity(multi_cases_len);	7090	astgen.extra.appendAssumeCapacity(multi_cases_len);
7063	}	7091	}
7064		7092
		7093	if (any_has_tag_capture) {
		7094	astgen.extra.appendAssumeCapacity(tag_inst);
		7095	}
		7096
7065	const zir_datas = astgen.instructions.items(.data);	7097	const zir_datas = astgen.instructions.items(.data);
7066	const zir_tags = astgen.instructions.items(.tag);	7098	const zir_tags = astgen.instructions.items(.tag);
7067		7099

src/Sema.zig+122-60

 @@ -277,9 +277,6 @@ pub const Block = struct {
     c_import_buf: ?*std.ArrayList(u8) = null,
-    /// Value for switch_capture in an inline case
-    inline_case_capture: Air.Inst.Ref = .none,
     const ComptimeReason = union(enum) {
         c_import: struct {
             block: *Block,
 @@ -1013,7 +1010,6 @@ fn analyzeBodyInner(
             .switch_block                 => try sema.zirSwitchBlock(block, inst),
             .switch_cond                  => try sema.zirSwitchCond(block, inst, false),
             .switch_cond_ref              => try sema.zirSwitchCond(block, inst, true),
-            .switch_capture_tag           => try sema.zirSwitchCaptureTag(block, inst),
             .type_info                    => try sema.zirTypeInfo(block, inst),
             .size_of                      => try sema.zirSizeOf(block, inst),
             .bit_size_of                  => try sema.zirBitSizeOf(block, inst),
 @@ -1217,7 +1213,7 @@ fn analyzeBodyInner(
                         i += 1;
                         continue;
                     },
-                    .errdefer_err_code => unreachable, // never appears in a body
+                    .value_placeholder => unreachable, // never appears in a body
                 };
             },
 @@ -10092,6 +10088,9 @@ const SwitchProngAnalysis = struct {
     else_error_ty: ?Type,
     /// The index of the `switch_block` instruction itself.
     switch_block_inst: Zir.Inst.Index,
+    /// The dummy index into which inline tag captures should be placed. May be
+    /// undefined if no prong has a tag capture.
+    tag_capture_inst: Zir.Inst.Index,
     /// Resolve a switch prong which is determined at comptime to have no peers.
     /// Uses `resolveBlockBody`. Sets up captures as needed.
 @@ -10106,10 +10105,23 @@ const SwitchProngAnalysis = struct {
         /// The set of all values which can reach this prong. May be undefined
         /// if the prong is special or contains ranges.
         case_vals: []const Air.Inst.Ref,
+        /// The inline capture of this prong. If this is not an inline prong,
+        /// this is `.none`.
+        inline_case_capture: Air.Inst.Ref,
+        /// Whether this prong has an inline tag capture. If `true`, then
+        /// `inline_case_capture` cannot be `.none`.
+        has_tag_capture: bool,
         merges: *Block.Merges,
     ) CompileError!Air.Inst.Ref {
         const sema = spa.sema;
         const src = sema.code.instructions.items(.data)[spa.switch_block_inst].pl_node.src();
+        if (has_tag_capture) {
+            const tag_ref = try spa.analyzeTagCapture(child_block, raw_capture_src, inline_case_capture);
+            sema.inst_map.putAssumeCapacity(spa.tag_capture_inst, tag_ref);
+        }
+        defer if (has_tag_capture) assert(sema.inst_map.remove(spa.tag_capture_inst));
         switch (capture) {
             .none => {
                 return sema.resolveBlockBody(spa.parent_block, src, child_block, prong_body, spa.switch_block_inst, merges);
 @@ -10122,6 +10134,7 @@ const SwitchProngAnalysis = struct {
                     prong_type == .special,
                     raw_capture_src,
                     case_vals,
+                    inline_case_capture,
                 );
                 if (sema.typeOf(capture_ref).isNoReturn(sema.mod)) {
 @@ -10150,8 +10163,21 @@ const SwitchProngAnalysis = struct {
         /// The set of all values which can reach this prong. May be undefined
         /// if the prong is special or contains ranges.
         case_vals: []const Air.Inst.Ref,
+        /// The inline capture of this prong. If this is not an inline prong,
+        /// this is `.none`.
+        inline_case_capture: Air.Inst.Ref,
+        /// Whether this prong has an inline tag capture. If `true`, then
+        /// `inline_case_capture` cannot be `.none`.
+        has_tag_capture: bool,
     ) CompileError!void {
         const sema = spa.sema;
+        if (has_tag_capture) {
+            const tag_ref = try spa.analyzeTagCapture(case_block, raw_capture_src, inline_case_capture);
+            sema.inst_map.putAssumeCapacity(spa.tag_capture_inst, tag_ref);
+        }
+        defer if (has_tag_capture) assert(sema.inst_map.remove(spa.tag_capture_inst));
         switch (capture) {
             .none => {
                 return sema.analyzeBodyRuntimeBreak(case_block, prong_body);
 @@ -10164,6 +10190,7 @@ const SwitchProngAnalysis = struct {
                     prong_type == .special,
                     raw_capture_src,
                     case_vals,
+                    inline_case_capture,
                 );
                 if (sema.typeOf(capture_ref).isNoReturn(sema.mod)) {
 @@ -10179,6 +10206,33 @@ const SwitchProngAnalysis = struct {
         }
     }
+    fn analyzeTagCapture(
+        spa: SwitchProngAnalysis,
+        block: *Block,
+        raw_capture_src: Module.SwitchProngSrc,
+        inline_case_capture: Air.Inst.Ref,
+    ) CompileError!Air.Inst.Ref {
+        const sema = spa.sema;
+        const mod = sema.mod;
+        const operand_ty = sema.typeOf(spa.operand);
+        if (operand_ty.zigTypeTag(mod) != .Union) {
+            const zir_datas = sema.code.instructions.items(.data);
+            const switch_node_offset = zir_datas[spa.switch_block_inst].pl_node.src_node;
+            const capture_src = raw_capture_src.resolve(mod, mod.declPtr(block.src_decl), switch_node_offset, .none);
+            const msg = msg: {
+                const msg = try sema.errMsg(block, capture_src, "cannot capture tag of non-union type '{}'", .{
+                    operand_ty.fmt(mod),
+                });
+                errdefer msg.destroy(sema.gpa);
+                try sema.addDeclaredHereNote(msg, operand_ty);
+                break :msg msg;
+            };
+            return sema.failWithOwnedErrorMsg(msg);
+        }
+        assert(inline_case_capture != .none);
+        return inline_case_capture;
+    }
     fn analyzeCapture(
         spa: SwitchProngAnalysis,
         block: *Block,
 @@ -10186,6 +10240,7 @@ const SwitchProngAnalysis = struct {
         is_special_prong: bool,
         raw_capture_src: Module.SwitchProngSrc,
         case_vals: []const Air.Inst.Ref,
+        inline_case_capture: Air.Inst.Ref,
     ) CompileError!Air.Inst.Ref {
         const sema = spa.sema;
         const mod = sema.mod;
 @@ -10197,8 +10252,8 @@ const SwitchProngAnalysis = struct {
         const operand_ptr_ty = if (capture_byref) sema.typeOf(spa.operand_ptr) else undefined;
         const operand_src: LazySrcLoc = .{ .node_offset_switch_operand = switch_node_offset };
-        if (block.inline_case_capture != .none) {
+        if (inline_case_capture != .none) {
-            const item_val = sema.resolveConstValue(block, .unneeded, block.inline_case_capture, "") catch unreachable;
+            const item_val = sema.resolveConstValue(block, .unneeded, inline_case_capture, "") catch unreachable;
             if (operand_ty.zigTypeTag(mod) == .Union) {
                 const field_index = @intCast(u32, operand_ty.unionTagFieldIndex(item_val, mod).?);
                 const union_obj = mod.typeToUnion(operand_ty).?;
 @@ -10233,7 +10288,7 @@ const SwitchProngAnalysis = struct {
             } else if (capture_byref) {
                 return sema.addConstantMaybeRef(block, operand_ty, item_val, true);
             } else {
-                return block.inline_case_capture;
+                return inline_case_capture;
             }
         }
 @@ -10356,34 +10411,6 @@ const SwitchProngAnalysis = struct {
     }
 };
-fn zirSwitchCaptureTag(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
-    const mod = sema.mod;
-    const zir_datas = sema.code.instructions.items(.data);
-    const inst_data = zir_datas[inst].un_tok;
-    const src = inst_data.src();
-    const switch_tag = sema.code.instructions.items(.tag)[Zir.refToIndex(inst_data.operand).?];
-    const is_ref = switch_tag == .switch_cond_ref;
-    const cond_data = zir_datas[Zir.refToIndex(inst_data.operand).?].un_node;
-    const operand_ptr = try sema.resolveInst(cond_data.operand);
-    const operand_ptr_ty = sema.typeOf(operand_ptr);
-    const operand_ty = if (is_ref) operand_ptr_ty.childType(mod) else operand_ptr_ty;
-    if (operand_ty.zigTypeTag(mod) != .Union) {
-        const msg = msg: {
-            const msg = try sema.errMsg(block, src, "cannot capture tag of non-union type '{}'", .{
-                operand_ty.fmt(mod),
-            });
-            errdefer msg.destroy(sema.gpa);
-            try sema.addDeclaredHereNote(msg, operand_ty);
-            break :msg msg;
-        };
-        return sema.failWithOwnedErrorMsg(msg);
-    }
-    return block.inline_case_capture;
-}
 fn zirSwitchCond(
     sema: *Sema,
     block: *Block,
 @@ -10485,6 +10512,16 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         break :blk multi_cases_len;
     } else 0;
+    const tag_capture_inst: Zir.Inst.Index = if (extra.data.bits.any_has_tag_capture) blk: {
+        const tag_capture_inst = sema.code.extra[header_extra_index];
+        header_extra_index += 1;
+        // SwitchProngAnalysis wants inst_map to have space for the tag capture.
+        // Note that the normal capture is referred to via the switch block
+        // index, which there is already necessarily space for.
+        try sema.inst_map.ensureSpaceForInstructions(gpa, &.{tag_capture_inst});
+        break :blk tag_capture_inst;
+    } else undefined;
     var case_vals = try std.ArrayListUnmanaged(Air.Inst.Ref).initCapacity(gpa, scalar_cases_len + 2 * multi_cases_len);
     defer case_vals.deinit(gpa);
 @@ -10493,11 +10530,18 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         end: usize,
         capture: Zir.Inst.SwitchBlock.ProngInfo.Capture,
         is_inline: bool,
+        has_tag_capture: bool,
     };
     const special_prong = extra.data.bits.specialProng();
     const special: Special = switch (special_prong) {
-        .none => .{ .body = &.{}, .end = header_extra_index, .capture = .none, .is_inline = false },
+        .none => .{
+            .body = &.{},
+            .end = header_extra_index,
+            .capture = .none,
+            .is_inline = false,
+            .has_tag_capture = false,
+        },
         .under, .@"else" => blk: {
             const info = @bitCast(Zir.Inst.SwitchBlock.ProngInfo, sema.code.extra[header_extra_index]);
             const extra_body_start = header_extra_index + 1;
 @@ -10506,6 +10550,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                 .end = extra_body_start + info.body_len,
                 .capture = info.capture,
                 .is_inline = info.is_inline,
+                .has_tag_capture = info.has_tag_capture,
             };
         },
     };
 @@ -11068,6 +11113,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         .operand_ptr = raw_operand.ptr,
         .else_error_ty = else_error_ty,
         .switch_block_inst = inst,
+        .tag_capture_inst = tag_capture_inst,
     };
     const block_inst = @intCast(Air.Inst.Index, sema.air_instructions.len);
 @@ -11122,7 +11168,6 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                 const item = case_vals.items[scalar_i];
                 const item_val = sema.resolveConstValue(&child_block, .unneeded, item, "") catch unreachable;
                 if (operand_val.eql(item_val, operand_ty, sema.mod)) {
-                    if (info.is_inline) child_block.inline_case_capture = operand;
                     if (err_set) try sema.maybeErrorUnwrapComptime(&child_block, body, operand);
                     return spa.resolveProngComptime(
                         &child_block,
 @@ -11131,6 +11176,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                         info.capture,
                         .{ .scalar = @intCast(u32, scalar_i) },
                         &.{item},
+                        if (info.is_inline) operand else .none,
+                        info.has_tag_capture,
                         merges,
                     );
                 }
 @@ -11155,7 +11202,6 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                     // Validation above ensured these will succeed.
                     const item_val = sema.resolveConstValue(&child_block, .unneeded, item, "") catch unreachable;
                     if (operand_val.eql(item_val, operand_ty, sema.mod)) {
-                        if (info.is_inline) child_block.inline_case_capture = operand;
                         if (err_set) try sema.maybeErrorUnwrapComptime(&child_block, body, operand);
                         return spa.resolveProngComptime(
                             &child_block,
 @@ -11164,6 +11210,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                             info.capture,
                             .{ .multi_capture = @intCast(u32, multi_i) },
                             items,
+                            if (info.is_inline) operand else .none,
+                            info.has_tag_capture,
                             merges,
                         );
                     }
 @@ -11181,7 +11229,6 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                     if ((try sema.compareAll(resolved_operand_val, .gte, first_val, operand_ty)) and
                         (try sema.compareAll(resolved_operand_val, .lte, last_val, operand_ty)))
                     {
-                        if (info.is_inline) child_block.inline_case_capture = operand;
                         if (err_set) try sema.maybeErrorUnwrapComptime(&child_block, body, operand);
                         return spa.resolveProngComptime(
                             &child_block,
 @@ -11190,6 +11237,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                             info.capture,
                             .{ .multi_capture = @intCast(u32, multi_i) },
                             undefined, // case_vals may be undefined for ranges
+                            if (info.is_inline) operand else .none,
+                            info.has_tag_capture,
                             merges,
                         );
                     }
 @@ -11199,7 +11248,6 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
             }
         }
         if (err_set) try sema.maybeErrorUnwrapComptime(&child_block, special.body, operand);
-        if (special.is_inline) child_block.inline_case_capture = operand;
         if (empty_enum) {
             return Air.Inst.Ref.void_value;
         }
 @@ -11211,6 +11259,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
             special.capture,
             .special,
             undefined, // case_vals may be undefined for special prongs
+            if (special.is_inline) operand else .none,
+            special.has_tag_capture,
             merges,
         );
     }
 @@ -11240,6 +11290,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
             special.capture,
             .special,
             undefined, // case_vals may be undefined for special prongs
+            .none,
+            false,
             merges,
         );
     }
 @@ -11278,10 +11330,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         case_block.instructions.shrinkRetainingCapacity(0);
         case_block.wip_capture_scope = wip_captures.scope;
-        case_block.inline_case_capture = .none;
         const item = case_vals.items[scalar_i];
-        if (info.is_inline) case_block.inline_case_capture = item;
         // `item` is already guaranteed to be constant known.
         const analyze_body = if (union_originally) blk: {
 @@ -11300,6 +11350,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                 info.capture,
                 .{ .scalar = @intCast(u32, scalar_i) },
                 &.{item},
+                if (info.is_inline) item else .none,
+                info.has_tag_capture,
             );
         } else {
             _ = try case_block.addNoOp(.unreach);
 @@ -11337,7 +11389,6 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         case_block.instructions.shrinkRetainingCapacity(0);
         case_block.wip_capture_scope = child_block.wip_capture_scope;
-        case_block.inline_case_capture = .none;
         // Generate all possible cases as scalar prongs.
         if (info.is_inline) {
 @@ -11367,7 +11418,6 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                     cases_len += 1;
                     const item_ref = try sema.addConstant(operand_ty, item);
-                    case_block.inline_case_capture = item_ref;
                     case_block.instructions.shrinkRetainingCapacity(0);
                     case_block.wip_capture_scope = child_block.wip_capture_scope;
 @@ -11390,12 +11440,14 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                         info.capture,
                         .{ .multi_capture = multi_i },
                         undefined, // case_vals may be undefined for ranges
+                        item_ref,
+                        info.has_tag_capture,
                     );
                     try cases_extra.ensureUnusedCapacity(gpa, 3 + case_block.instructions.items.len);
                     cases_extra.appendAssumeCapacity(1); // items_len
                     cases_extra.appendAssumeCapacity(@intCast(u32, case_block.instructions.items.len));
-                    cases_extra.appendAssumeCapacity(@enumToInt(case_block.inline_case_capture));
+                    cases_extra.appendAssumeCapacity(@enumToInt(item_ref));
                     cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
                 }
             }
 @@ -11403,8 +11455,6 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
             for (items, 0..) |item, item_i| {
                 cases_len += 1;
-                case_block.inline_case_capture = item;
                 case_block.instructions.shrinkRetainingCapacity(0);
                 case_block.wip_capture_scope = child_block.wip_capture_scope;
 @@ -11433,6 +11483,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                         info.capture,
                         .{ .multi_capture = multi_i },
                         &.{item},
+                        item,
+                        info.has_tag_capture,
                     );
                 } else {
                     _ = try case_block.addNoOp(.unreach);
 @@ -11441,7 +11493,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                 try cases_extra.ensureUnusedCapacity(gpa, 3 + case_block.instructions.items.len);
                 cases_extra.appendAssumeCapacity(1); // items_len
                 cases_extra.appendAssumeCapacity(@intCast(u32, case_block.instructions.items.len));
-                cases_extra.appendAssumeCapacity(@enumToInt(case_block.inline_case_capture));
+                cases_extra.appendAssumeCapacity(@enumToInt(item));
                 cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
             }
 @@ -11478,6 +11530,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                     info.capture,
                     .{ .multi_capture = multi_i },
                     items,
+                    .none,
+                    false,
                 );
             } else {
                 _ = try case_block.addNoOp(.unreach);
 @@ -11563,6 +11617,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                     info.capture,
                     .{ .multi_capture = multi_i },
                     items,
+                    .none,
+                    false,
                 );
             }
 @@ -11608,7 +11664,6 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                     const item_val = try mod.enumValueFieldIndex(operand_ty, @intCast(u32, i));
                     const item_ref = try sema.addConstant(operand_ty, item_val);
-                    case_block.inline_case_capture = item_ref;
                     case_block.instructions.shrinkRetainingCapacity(0);
                     case_block.wip_capture_scope = child_block.wip_capture_scope;
 @@ -11629,6 +11684,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                             special.capture,
                             .special,
                             &.{item_ref},
+                            item_ref,
+                            special.has_tag_capture,
                         );
                     } else {
                         _ = try case_block.addNoOp(.unreach);
 @@ -11637,7 +11694,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                     try cases_extra.ensureUnusedCapacity(gpa, 3 + case_block.instructions.items.len);
                     cases_extra.appendAssumeCapacity(1); // items_len
                     cases_extra.appendAssumeCapacity(@intCast(u32, case_block.instructions.items.len));
-                    cases_extra.appendAssumeCapacity(@enumToInt(case_block.inline_case_capture));
+                    cases_extra.appendAssumeCapacity(@enumToInt(item_ref));
                     cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
                 }
             },
 @@ -11657,7 +11714,6 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                         .name = error_name,
                     } });
                     const item_ref = try sema.addConstant(operand_ty, item_val.toValue());
-                    case_block.inline_case_capture = item_ref;
                     case_block.instructions.shrinkRetainingCapacity(0);
                     case_block.wip_capture_scope = child_block.wip_capture_scope;
 @@ -11672,12 +11728,14 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                         special.capture,
                         .special,
                         &.{item_ref},
+                        item_ref,
+                        special.has_tag_capture,
                     );
                     try cases_extra.ensureUnusedCapacity(gpa, 3 + case_block.instructions.items.len);
                     cases_extra.appendAssumeCapacity(1); // items_len
                     cases_extra.appendAssumeCapacity(@intCast(u32, case_block.instructions.items.len));
-                    cases_extra.appendAssumeCapacity(@enumToInt(case_block.inline_case_capture));
+                    cases_extra.appendAssumeCapacity(@enumToInt(item_ref));
                     cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
                 }
             },
 @@ -11687,7 +11745,6 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                     cases_len += 1;
                     const item_ref = try sema.addConstant(operand_ty, cur.toValue());
-                    case_block.inline_case_capture = item_ref;
                     case_block.instructions.shrinkRetainingCapacity(0);
                     case_block.wip_capture_scope = child_block.wip_capture_scope;
 @@ -11702,19 +11759,20 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                         special.capture,
                         .special,
                         &.{item_ref},
+                        item_ref,
+                        special.has_tag_capture,
                     );
                     try cases_extra.ensureUnusedCapacity(gpa, 3 + case_block.instructions.items.len);
                     cases_extra.appendAssumeCapacity(1); // items_len
                     cases_extra.appendAssumeCapacity(@intCast(u32, case_block.instructions.items.len));
-                    cases_extra.appendAssumeCapacity(@enumToInt(case_block.inline_case_capture));
+                    cases_extra.appendAssumeCapacity(@enumToInt(item_ref));
                     cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
                 }
             },
             .Bool => {
                 if (true_count == 0) {
                     cases_len += 1;
-                    case_block.inline_case_capture = Air.Inst.Ref.bool_true;
                     case_block.instructions.shrinkRetainingCapacity(0);
                     case_block.wip_capture_scope = child_block.wip_capture_scope;
 @@ -11729,17 +11787,18 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                         special.capture,
                         .special,
                         &.{Air.Inst.Ref.bool_true},
+                        Air.Inst.Ref.bool_true,
+                        special.has_tag_capture,
                     );
                     try cases_extra.ensureUnusedCapacity(gpa, 3 + case_block.instructions.items.len);
                     cases_extra.appendAssumeCapacity(1); // items_len
                     cases_extra.appendAssumeCapacity(@intCast(u32, case_block.instructions.items.len));
-                    cases_extra.appendAssumeCapacity(@enumToInt(case_block.inline_case_capture));
+                    cases_extra.appendAssumeCapacity(@enumToInt(Air.Inst.Ref.bool_true));
                     cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
                 }
                 if (false_count == 0) {
                     cases_len += 1;
-                    case_block.inline_case_capture = Air.Inst.Ref.bool_false;
                     case_block.instructions.shrinkRetainingCapacity(0);
                     case_block.wip_capture_scope = child_block.wip_capture_scope;
 @@ -11754,12 +11813,14 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                         special.capture,
                         .special,
                         &.{Air.Inst.Ref.bool_false},
+                        Air.Inst.Ref.bool_false,
+                        special.has_tag_capture,
                     );
                     try cases_extra.ensureUnusedCapacity(gpa, 3 + case_block.instructions.items.len);
                     cases_extra.appendAssumeCapacity(1); // items_len
                     cases_extra.appendAssumeCapacity(@intCast(u32, case_block.instructions.items.len));
-                    cases_extra.appendAssumeCapacity(@enumToInt(case_block.inline_case_capture));
+                    cases_extra.appendAssumeCapacity(@enumToInt(Air.Inst.Ref.bool_false));
                     cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
                 }
             },
 @@ -11773,7 +11834,6 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         case_block.instructions.shrinkRetainingCapacity(0);
         case_block.wip_capture_scope = wip_captures.scope;
-        case_block.inline_case_capture = .none;
         if (mod.backendSupportsFeature(.is_named_enum_value) and special.body.len != 0 and block.wantSafety() and
             operand_ty.zigTypeTag(mod) == .Enum and (!operand_ty.isNonexhaustiveEnum(mod) or union_originally))
 @@ -11804,6 +11864,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                 special.capture,
                 .special,
                 undefined, // case_vals may be undefined for special prongs
+                .none,
+                false,
             );
         } else {
             // We still need a terminator in this block, but we have proven

src/Zir.zig+13-14

 @@ -676,9 +676,6 @@ pub const Inst = struct {
         /// what will be switched on.
         /// Uses the `un_node` union field.
         switch_cond_ref,
-        /// Produces the capture value for an inline switch prong tag capture.
-        /// Uses the `un_tok` field.
-        switch_capture_tag,
         /// Given a
         ///   *A returns *A
         ///   *E!A returns *A
 @@ -1124,7 +1121,6 @@ pub const Inst = struct {
                 .typeof_log2_int_type,
                 .resolve_inferred_alloc,
                 .set_eval_branch_quota,
-                .switch_capture_tag,
                 .switch_block,
                 .switch_cond,
                 .switch_cond_ref,
 @@ -1414,7 +1410,6 @@ pub const Inst = struct {
                 .slice_length,
                 .import,
                 .typeof_log2_int_type,
-                .switch_capture_tag,
                 .switch_block,
                 .switch_cond,
                 .switch_cond_ref,
 @@ -1670,7 +1665,6 @@ pub const Inst = struct {
                 .switch_block = .pl_node,
                 .switch_cond = .un_node,
                 .switch_cond_ref = .un_node,
-                .switch_capture_tag = .un_tok,
                 .array_base_ptr = .un_node,
                 .field_base_ptr = .un_node,
                 .validate_array_init_ty = .pl_node,
 @@ -1996,9 +1990,10 @@ pub const Inst = struct {
         /// Implements the `@inComptime` builtin.
         /// `operand` is `src_node: i32`.
         in_comptime,
-        /// Used as a placeholder for the capture of an `errdefer`.
+        /// Used as a placeholder instruction which is just a dummy index for Sema to replace
-        /// This is replaced by Sema with the captured value.
+        /// with a specific value. For instance, this is used for the capture of an `errdefer`.
-        errdefer_err_code,
+        /// This should never appear in a body.
+        value_placeholder,
         pub const InstData = struct {
             opcode: Extended,
 @@ -2644,16 +2639,17 @@ pub const Inst = struct {
     };
     /// 0. multi_cases_len: u32 // If has_multi_cases is set.
-    /// 1. else_body { // If has_else or has_under is set.
+    /// 1. tag_capture_inst: u32 // If any_has_tag_capture is set. Index of instruction prongs use to refer to the inline tag capture.
+    /// 2. else_body { // If has_else or has_under is set.
     ///        info: ProngInfo,
     ///        body member Index for every info.body_len
     ///     }
-    /// 2. scalar_cases: { // for every scalar_cases_len
+    /// 3. scalar_cases: { // for every scalar_cases_len
     ///        item: Ref,
     ///        info: ProngInfo,
     ///        body member Index for every info.body_len
     ///     }
-    /// 3. multi_cases: { // for every multi_cases_len
+    /// 4. multi_cases: { // for every multi_cases_len
     ///        items_len: u32,
     ///        ranges_len: u32,
     ///        info: ProngInfo,
 @@ -2681,9 +2677,10 @@ pub const Inst = struct {
         /// These are stored in trailing data in `extra` for each prong.
         pub const ProngInfo = packed struct(u32) {
-            body_len: u29,
+            body_len: u28,
             capture: Capture,
             is_inline: bool,
+            has_tag_capture: bool,
             pub const Capture = enum(u2) {
                 none,
 @@ -2699,9 +2696,11 @@ pub const Inst = struct {
             has_else: bool,
             /// If true, there is an underscore prong. This is mutually exclusive with `has_else`.
             has_under: bool,
+            /// If true, at least one prong has an inline tag capture.
+            any_has_tag_capture: bool,
             scalar_cases_len: ScalarCasesLen,
-            pub const ScalarCasesLen = u29;
+            pub const ScalarCasesLen = u28;
             pub fn specialProng(bits: Bits) SpecialProng {
                 const has_else: u2 = @boolToInt(bits.has_else);

src/print_zir.zig+12-2

 @@ -235,7 +235,6 @@ const Writer = struct {
             .ref,
             .ret_implicit,
             .closure_capture,
-            .switch_capture_tag,
             => try self.writeUnTok(stream, inst),
             .bool_br_and,
 @@ -463,7 +462,7 @@ const Writer = struct {
             .breakpoint,
             .c_va_start,
             .in_comptime,
-            .errdefer_err_code,
+            .value_placeholder,
             => try self.writeExtNode(stream, extended),
             .builtin_src => {
 @@ -1897,8 +1896,19 @@ const Writer = struct {
             break :blk multi_cases_len;
         } else 0;
+        const tag_capture_inst: Zir.Inst.Index = if (extra.data.bits.any_has_tag_capture) blk: {
+            const tag_capture_inst = self.code.extra[extra_index];
+            extra_index += 1;
+            break :blk tag_capture_inst;
+        } else undefined;
         try self.writeInstRef(stream, extra.data.operand);
+        if (extra.data.bits.any_has_tag_capture) {
+            try stream.writeAll(", tag_capture=");
+            try self.writeInstIndex(stream, tag_capture_inst);
+        }
         self.indent += 2;
         else_prong: {