Commit aa2b178029fc466f847c0cb663c3b32c7809a357 | zig

author	David Rubin <david@vortan.dev> 2025-10-04 12:04:42-07:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2026-01-11 11:37:16+00:00
log	aa2b178029fc466f847c0cb663c3b32c7809a357
tree	e8f6a3b8b6b2416aef0476ce67fdceb998ad8f00
parent	c4345991340af5ff2e0155a9832f4eed9ec677fc
signature	Commit is signed but in an unrecognized format.

disallow switch case capture discards

Previously Zig allowed you to write something like,
```zig
switch (x) {
    .y => |_| {
```

This seems a bit strange because in other cases, such as when
capturing the tag in a switch case,
```zig
switch (x) {
    .y => |_, _| {
```
this produces an error.

The only usecase I can think of for the previous behaviour is
if you wanted to assert that all union payloads are able
to coerce,
```zig
const X = union(enum) { y: u8, z: f32 };

switch (x) {
    .y, .z => |_| {
```

This will compile-error with the `|_|` and pass without it.

I don't believe this usecase is strong enough to keep the current
behaviour; it was never used in the Zig codebase and I cannot
find a single usage of this behaviour in the real world, searching
through Sourcegraph.

5 files changed, 56 insertions(+), 5 deletions(-)

lib
- std
  - testing.zig
  - zig
    AstGen.zig
src
- Sema.zig
test
- behavior
  - switch_loop.zig
- cases
  - compile_errors
    switch_loop_discarded_capture.zig

lib/std/testing.zig+1-1

...	@@ -813,7 +813,7 @@ fn expectEqualDeepInner(comptime T: type, expected: T, actual: T) error{TestExpe	...	@@ -813,7 +813,7 @@ fn expectEqualDeepInner(comptime T: type, expected: T, actual: T) error{TestExpe
813	}	813	}
814	},	814	},
815		815
816	.array => \|_\| {	816	.array => {
817	if (expected.len != actual.len) {	817	if (expected.len != actual.len) {
818	print("Array len not the same, expected {d}, found {d}\n", .{ expected.len, actual.len });	818	print("Array len not the same, expected {d}, found {d}\n", .{ expected.len, actual.len });
819	return error.TestExpectedEqual;	819	return error.TestExpectedEqual;

lib/std/zig/AstGen.zig+9-3

 @@ -7882,8 +7882,10 @@ fn switchExpr(
             var payload_sub_scope: *Scope = undefined;
             if (mem.eql(u8, ident_slice, "_")) {
                 if (capture_is_ref) {
+                    // |*_, tag| is invalid, so we can fail early
                     return astgen.failTok(payload_token, "pointer modifier invalid on discard", .{});
                 }
+                capture = .none;
                 payload_sub_scope = &case_scope.base;
             } else {
                 const capture_name = try astgen.identAsString(ident);
 @@ -7903,11 +7905,15 @@ fn switchExpr(
             const tag_token = if (tree.tokenTag(ident + 1) == .comma)
                 ident + 2
-            else
+            else if (capture == .none) {
-                break :blk payload_sub_scope;
+                // discarding the capture is only valid iff the tag is captured
+                // whether the tag capture is discarded is handled below
+                return astgen.failTok(payload_token, "discard of capture; omit it instead", .{});
+            } else break :blk payload_sub_scope;
             const tag_slice = tree.tokenSlice(tag_token);
             if (mem.eql(u8, tag_slice, "_")) {
-                try astgen.appendErrorTok(tag_token, "discard of tag capture; omit it instead", .{});
+                return astgen.failTok(tag_token, "discard of tag capture; omit it instead", .{});
             } else if (case.inline_token == null) {
                 return astgen.failTok(tag_token, "tag capture on non-inline prong", .{});
             }

src/Sema.zig+3-1

 @@ -11546,7 +11546,9 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
                 });
             }
             try sema.validateRuntimeValue(block, operand_src, maybe_ptr);
-            const operand_alloc = if (extra.data.bits.any_non_inline_capture) a: {
+            const operand_alloc = if (extra.data.bits.any_non_inline_capture or
+                extra.data.bits.any_has_tag_capture)
+            a: {
                 const operand_ptr_ty = try pt.singleMutPtrType(sema.typeOf(maybe_ptr));
                 const operand_alloc = try block.addTy(.alloc, operand_ptr_ty);
                 _ = try block.addBinOp(.store, operand_alloc, maybe_ptr);

test/behavior/switch_loop.zig+27

...	@@ -270,3 +270,30 @@ test "switch loop on non-exhaustive enum" {	...	@@ -270,3 +270,30 @@ test "switch loop on non-exhaustive enum" {
270	try S.doTheTest();	270	try S.doTheTest();
271	try comptime S.doTheTest();	271	try comptime S.doTheTest();
272	}	272	}
		273
		274	test "switch loop with discarded tag capture" {
		275	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
		276	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
		277	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
		278
		279	const S = struct {
		280	const U = union(enum) {
		281	a: u32,
		282	b: u32,
		283	c: u32,
		284	};
		285
		286	fn doTheTest() void {
		287	const a: U = .{ .a = 10 };
		288	blk: switch (a) {
		289	inline .b => \|_, tag\| {
		290	_ = tag;
		291	continue :blk .{ .c = 20 };
		292	},
		293	else => {},
		294	}
		295	}
		296	};
		297	S.doTheTest();
		298	comptime S.doTheTest();
		299	}

test/cases/compile_errors/switch_loop_discarded_capture.zig created+16

...	@@ -0,0 +1,16 @@
1	export fn foo() void {
2	const S = struct {
3	fn doTheTest() void {
4	blk: switch (@as(u8, 'a')) {
5	'1' => \|_\| continue :blk '1',
6	else => {},
7	}
8	}
9	};
10	S.doTheTest();
11	comptime S.doTheTest();
12	}
13
14	// error
15	//
16	// :5:25: error: discard of capture; omit it instead