Commit 7999374b21795a7b8fac7af0b2e326d39bd1e839 | zig

author	Andrew Kelley <andrew@ziglang.org> 2025-06-29 16:39:26-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-06-29 17:20:23-07:00
log	7999374b21795a7b8fac7af0b2e326d39bd1e839
tree	14a3344acff87876a43897211912115f592b771d
parent	e8377659560497beb36ec1f981b024f74292c1b9

Sema: correct OPV for optional empty error set

prevents crashes in backends; improves codegen; provides more
comptime-ness.

3 files changed, 52 insertions(+), 5 deletions(-)

src
- Sema.zig
test
- cases
  - compile_errors
    optional_empty_error_set.zig
  - safety
    optional_empty_error_set.zig

src/Sema.zig+17-5

 @@ -9065,10 +9065,14 @@ fn zirOptionalPayload(
     };
     if (try sema.resolveDefinedValue(block, src, operand)) |val| {
-        return if (val.optionalValue(zcu)) |payload|
+        if (val.optionalValue(zcu)) |payload| return Air.internedToRef(payload.toIntern());
-            Air.internedToRef(payload.toIntern())
+        if (block.isComptime()) return sema.fail(block, src, "unable to unwrap null", .{});
-        else
+        if (safety_check and block.wantSafety()) {
-            sema.fail(block, src, "unable to unwrap null", .{});
+            try sema.safetyPanic(block, src, .unwrap_null);
+        } else {
+            _ = try block.addNoOp(.unreach);
+        }
+        return .unreachable_value;
     }
     try sema.requireRuntimeBlock(block, src, null);
 @@ -36443,7 +36447,6 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
             .type_int_unsigned, // u0 handled above
             .type_pointer,
             .type_slice,
-            .type_optional, // ?noreturn handled above
             .type_anyframe,
             .type_error_union,
             .type_anyerror_union,
 @@ -36655,6 +36658,15 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
                 else => unreachable,
             },
+            .type_optional => {
+                const payload_ip = ip.indexToKey(ty.toIntern()).opt_type;
+                // Although ?noreturn is handled above, the element type
+                // can be effectively noreturn for example via an empty
+                // enum or error set.
+                if (ip.isNoReturn(payload_ip)) return try pt.nullValue(ty);
+                return null;
+            },
         },
     };
 }

test/cases/compile_errors/optional_empty_error_set.zig created+13

...	@@ -0,0 +1,13 @@
1	export fn example() void {
2	comptime foo() catch \|err\| switch (err) {};
3	}
4	var x: ?error{} = null;
5	fn foo() !void {
6	return x.?;
7	}
8	// error
9	// backend=stage2
10	// target=native
11	//
12	// :6:13: error: unable to unwrap null
13	// :2:17: note: called at comptime here

test/cases/safety/optional_empty_error_set.zig created+22

...	@@ -0,0 +1,22 @@
1	const std = @import("std");
2
3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, ra: ?usize) noreturn {
4	_ = stack_trace;
5	_ = ra;
6	if (std.mem.eql(u8, message, "attempt to use null value")) {
7	std.process.exit(0);
8	}
9	std.process.exit(1);
10	}
11
12	pub fn main() !void {
13	foo() catch \|err\| switch (err) {};
14	return error.TestFailed;
15	}
16	var x: ?error{} = null;
17	fn foo() !void {
18	return x.?;
19	}
20	// run
21	// backend=stage2,llvm
22	// target=native