Commit 3924f173af51c50ac18be2166fe115555241778e | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2025-02-01 08:07:14+00:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2025-02-01 15:48:45+00:00
log	3924f173af51c50ac18be2166fe115555241778e
tree	ee3fa65cc85dd6022af6533068dc3fb4f46461ab
parent	c225b780e3944014300555c3b45eaccd7bc7c8ae

compiler: do not propagate result type to `try` operand

This commit effectively reverts 9e683f0, and hence un-accepts #19777.
While nice in theory, this proposal turned out to have a few problems.

Firstly, supplying a result type implicitly coerces the operand to this
type -- that's the main point of result types! But for `try`, this is
actually a bad idea; we want a redundant `try` to be a compile error,
not to silently coerce the non-error value to an error union. In
practice, this didn't always happen, because the implementation was
buggy anyway; but when it did, it was really quite silly. For instance,
`try try ... try .{ ... }` was an accepted expression, with the inner
initializer being initially coerced to `E!E!...E!T`.

Secondly, the result type inference here didn't play nicely with
`return`. If you write `return try`, the operand would actually receive
a result type of `E!E!T`, since the `return` gave a result type of `E!T`
and the `try` wrapped it in *another* error union. More generally, the
problem here is that `try` doesn't know when it should or shouldn't
nest error unions. This occasionally broke code which looked like it
should work.

So, this commit prevents `try` from propagating result types through to
its operand. A key motivation for the original proposal here was decl
literals; so, as a special case, `try .foo(...)` is still an allowed
syntax form, caught by AstGen and specially lowered. This does open the
doors to allowing other special cases for decl literals in future, such
as `.foo(...) catch ...`, but those proposals are for another time.

Resolves: #21991
Resolves: #22633

6 files changed, 105 insertions(+), 72 deletions(-)

lib
- std
  - zig
    AstGen.zig
    Zir.zig
src
- Sema.zig
- print_zir.zig
test
- behavior
  - try.zig
- cases
  - compile_errors
    redundant_try.zig

lib/std/zig/AstGen.zig+32-19

 @@ -851,7 +851,7 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE
         .async_call_comma,
         => {
             var buf: [1]Ast.Node.Index = undefined;
-            return callExpr(gz, scope, ri, node, tree.fullCall(&buf, node).?);
+            return callExpr(gz, scope, ri, .none, node, tree.fullCall(&buf, node).?);
         },
         .unreachable_literal => {
 @@ -3009,8 +3009,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
             .validate_ptr_array_init,
             .validate_ref_ty,
             .validate_const,
-            .try_operand_ty,
-            .try_ref_operand_ty,
             => break :b true,
             .@"defer" => unreachable,
 @@ -6158,20 +6156,24 @@ fn tryExpr(
     const try_lc: LineColumn = .{ astgen.source_line - parent_gz.decl_line, astgen.source_column };
     const operand_rl: ResultInfo.Loc, const block_tag: Zir.Inst.Tag = switch (ri.rl) {
-        .ref => .{ .ref, .try_ptr },
+        .ref, .ref_coerced_ty => .{ .ref, .try_ptr },
-        .ref_coerced_ty => |payload_ptr_ty| .{
+        else => .{ .none, .@"try" },
-            .{ .ref_coerced_ty = try parent_gz.addUnNode(.try_ref_operand_ty, payload_ptr_ty, node) },
-            .try_ptr,
-        },
-        else => if (try ri.rl.resultType(parent_gz, node)) |payload_ty| .{
-            // `coerced_ty` is OK due to the `rvalue` call below
-            .{ .coerced_ty = try parent_gz.addUnNode(.try_operand_ty, payload_ty, node) },
-            .@"try",
-        } else .{ .none, .@"try" },
     };
     const operand_ri: ResultInfo = .{ .rl = operand_rl, .ctx = .error_handling_expr };
-    // This could be a pointer or value depending on the `ri` parameter.
+    const operand = operand: {
-    const operand = try reachableExpr(parent_gz, scope, operand_ri, operand_node, node);
+        // As a special case, we need to detect this form:
+        // `try .foo(...)`
+        // This is a decl literal form, even though we don't propagate a result type through `try`.
+        var buf: [1]Ast.Node.Index = undefined;
+        if (astgen.tree.fullCall(&buf, operand_node)) |full_call| {
+            const res_ty: Zir.Inst.Ref = try ri.rl.resultType(parent_gz, operand_node) orelse .none;
+            break :operand try callExpr(parent_gz, scope, operand_ri, res_ty, operand_node, full_call);
+        }
+        // This could be a pointer or value depending on the `ri` parameter.
+        break :operand try reachableExpr(parent_gz, scope, operand_ri, operand_node, node);
+    };
     const try_inst = try parent_gz.makeBlockInst(block_tag, node);
     try parent_gz.instructions.append(astgen.gpa, try_inst);
 @@ -10236,12 +10238,15 @@ fn callExpr(
     gz: *GenZir,
     scope: *Scope,
     ri: ResultInfo,
+    /// If this is not `.none` and this call is a decl literal form (`.foo(...)`), then this
+    /// type is used as the decl literal result type instead of the result type from `ri.rl`.
+    override_decl_literal_type: Zir.Inst.Ref,
     node: Ast.Node.Index,
     call: Ast.full.Call,
 ) InnerError!Zir.Inst.Ref {
     const astgen = gz.astgen;
-    const callee = try calleeExpr(gz, scope, ri.rl, call.ast.fn_expr);
+    const callee = try calleeExpr(gz, scope, ri.rl, override_decl_literal_type, call.ast.fn_expr);
     const modifier: std.builtin.CallModifier = blk: {
         if (call.async_token != null) {
             break :blk .async_kw;
 @@ -10367,6 +10372,9 @@ fn calleeExpr(
     gz: *GenZir,
     scope: *Scope,
     call_rl: ResultInfo.Loc,
+    /// If this is not `.none` and this call is a decl literal form (`.foo(...)`), then this
+    /// type is used as the decl literal result type instead of the result type from `call_rl`.
+    override_decl_literal_type: Zir.Inst.Ref,
     node: Ast.Node.Index,
 ) InnerError!Callee {
     const astgen = gz.astgen;
 @@ -10393,7 +10401,14 @@ fn calleeExpr(
                 .field_name_start = str_index,
             } };
         },
-        .enum_literal => if (try call_rl.resultType(gz, node)) |res_ty| {
+        .enum_literal => {
+            const res_ty = res_ty: {
+                if (override_decl_literal_type != .none) break :res_ty override_decl_literal_type;
+                break :res_ty try call_rl.resultType(gz, node) orelse {
+                    // No result type; lower to a literal call of an enum literal.
+                    return .{ .direct = try expr(gz, scope, .{ .rl = .none }, node) };
+                };
+            };
             // Decl literal call syntax, e.g.
             // `const foo: T = .init();`
             // Look up `init` in `T`, but don't try and coerce it.
 @@ -10403,8 +10418,6 @@ fn calleeExpr(
                 .field_name_start = str_index,
             });
             return .{ .direct = callee };
-        } else {
-            return .{ .direct = try expr(gz, scope, .{ .rl = .none }, node) };
         },
         else => return .{ .direct = try expr(gz, scope, .{ .rl = .none }, node) },
     }

lib/std/zig/Zir.zig-16

 @@ -721,14 +721,6 @@ pub const Inst = struct {
         /// Result is always void.
         /// Uses the `un_node` union field. Node is the initializer. Operand is the initializer value.
         validate_const,
-        /// Given a type `T`, construct the type `E!T`, where `E` is this function's error set, to be used
-        /// as the result type of a `try` operand. Generic poison is propagated.
-        /// Uses the `un_node` union field. Node is the `try` expression. Operand is the type `T`.
-        try_operand_ty,
-        /// Given a type `*T`, construct the type `*E!T`, where `E` is this function's error set, to be used
-        /// as the result type of a `try` operand whose address is taken with `&`. Generic poison is propagated.
-        /// Uses the `un_node` union field. Node is the `try` expression. Operand is the type `*T`.
-        try_ref_operand_ty,
         // The following tags all relate to struct initialization expressions.
 @@ -1304,8 +1296,6 @@ pub const Inst = struct {
                 .array_init_elem_ptr,
                 .validate_ref_ty,
                 .validate_const,
-                .try_operand_ty,
-                .try_ref_operand_ty,
                 .restore_err_ret_index_unconditional,
                 .restore_err_ret_index_fn_entry,
                 => false,
 @@ -1365,8 +1355,6 @@ pub const Inst = struct {
                 .validate_ptr_array_init,
                 .validate_ref_ty,
                 .validate_const,
-                .try_operand_ty,
-                .try_ref_operand_ty,
                 => true,
                 .param,
 @@ -1749,8 +1737,6 @@ pub const Inst = struct {
                 .coerce_ptr_elem_ty = .pl_node,
                 .validate_ref_ty = .un_tok,
                 .validate_const = .un_node,
-                .try_operand_ty = .un_node,
-                .try_ref_operand_ty = .un_node,
                 .int_from_ptr = .un_node,
                 .compile_error = .un_node,
 @@ -4196,8 +4182,6 @@ fn findTrackableInner(
         .coerce_ptr_elem_ty,
         .validate_ref_ty,
         .validate_const,
-        .try_operand_ty,
-        .try_ref_operand_ty,
         .struct_init_empty,
         .struct_init_empty_result,
         .struct_init_empty_ref_result,

src/Sema.zig-16

...	@@ -1257,8 +1257,6 @@ fn analyzeBodyInner(	...	@@ -1257,8 +1257,6 @@ fn analyzeBodyInner(
1257	.validate_array_init_ref_ty => try sema.zirValidateArrayInitRefTy(block, inst),	1257	.validate_array_init_ref_ty => try sema.zirValidateArrayInitRefTy(block, inst),
1258	.opt_eu_base_ptr_init => try sema.zirOptEuBasePtrInit(block, inst),	1258	.opt_eu_base_ptr_init => try sema.zirOptEuBasePtrInit(block, inst),
1259	.coerce_ptr_elem_ty => try sema.zirCoercePtrElemTy(block, inst),	1259	.coerce_ptr_elem_ty => try sema.zirCoercePtrElemTy(block, inst),
1260	.try_operand_ty => try sema.zirTryOperandTy(block, inst, false),
1261	.try_ref_operand_ty => try sema.zirTryOperandTy(block, inst, true),
1262		1260
1263	.clz => try sema.zirBitCount(block, inst, .clz, Value.clz),	1261	.clz => try sema.zirBitCount(block, inst, .clz, Value.clz),
1264	.ctz => try sema.zirBitCount(block, inst, .ctz, Value.ctz),	1262	.ctz => try sema.zirBitCount(block, inst, .ctz, Value.ctz),
...	@@ -2085,20 +2083,6 @@ fn genericPoisonReason(sema: Sema, block: Block, ref: Zir.Inst.Ref) GenericPoi	...	@@ -2085,20 +2083,6 @@ fn genericPoisonReason(sema: Sema, block: Block, ref: Zir.Inst.Ref) GenericPoi
2085	const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;	2083	const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
2086	cur = un_node.operand;	2084	cur = un_node.operand;
2087	},	2085	},
2088	.try_operand_ty => {
2089	// Either the input type was itself poison, or it was a slice, which we cannot translate
2090	// to an overall result type.
2091	const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
2092	const operand_ref = try sema.resolveInst(un_node.operand);
2093	if (operand_ref == .generic_poison_type) {
2094	// The input was poison -- keep looking.
2095	cur = un_node.operand;
2096	continue;
2097	}
2098	// We got a poison because the result type was a slice. This is a tricky case -- let's just
2099	// not bother explaining it to the user for now...
2100	return .unknown;
2101	},
2102	.struct_init_field_type => {	2086	.struct_init_field_type => {
2103	const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	2087	const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
2104	const extra = sema.code.extraData(Zir.Inst.FieldType, pl_node.payload_index).data;	2088	const extra = sema.code.extraData(Zir.Inst.FieldType, pl_node.payload_index).data;

src/print_zir.zig-2

...	@@ -278,8 +278,6 @@ const Writer = struct {	...	@@ -278,8 +278,6 @@ const Writer = struct {
278	.opt_eu_base_ptr_init,	278	.opt_eu_base_ptr_init,
279	.restore_err_ret_index_unconditional,	279	.restore_err_ret_index_unconditional,
280	.restore_err_ret_index_fn_entry,	280	.restore_err_ret_index_fn_entry,
281	.try_operand_ty,
282	.try_ref_operand_ty,
283	=> try self.writeUnNode(stream, inst),	281	=> try self.writeUnNode(stream, inst),
284		282
285	.ref,	283	.ref,

test/behavior/try.zig+21-19

 @@ -68,25 +68,6 @@ test "`try`ing an if/else expression" {
     try std.testing.expectError(error.Test, S.getError2());
 }
-test "try forwards result location" {
-    if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    const S = struct {
-        fn foo(err: bool) error{Foo}!u32 {
-            const result: error{ Foo, Bar }!u32 = if (err) error.Foo else 123;
-            const res_int: u32 = try @errorCast(result);
-            return res_int;
-        }
-    };
-    try expect((S.foo(false) catch return error.TestUnexpectedResult) == 123);
-    try std.testing.expectError(error.Foo, S.foo(true));
-}
 test "'return try' of empty error set in function returning non-error" {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 @@ -123,3 +104,24 @@ test "'return try' of empty error set in function returning non-error" {
     try S.doTheTest();
     try comptime S.doTheTest();
 }
+test "'return try' through conditional" {
+    const S = struct {
+        fn get(t: bool) !u32 {
+            return try if (t) inner() else error.TestFailed;
+        }
+        fn inner() !u16 {
+            return 123;
+        }
+    };
+    {
+        const result = try S.get(true);
+        try expect(result == 123);
+    }
+    {
+        const result = try comptime S.get(true);
+        comptime std.debug.assert(result == 123);
+    }
+}

test/cases/compile_errors/redundant_try.zig created+52

...	@@ -0,0 +1,52 @@
1	const S = struct { x: u32 = 0 };
2	const T = struct { []const u8 };
3
4	fn test0() !void {
5	const x: u8 = try 1;
6	_ = x;
7	}
8
9	fn test1() !void {
10	const x: S = try .{};
11	_ = x;
12	}
13
14	fn test2() !void {
15	const x: S = try .{ .x = 123 };
16	_ = x;
17	}
18
19	fn test3() !void {
20	const x: S = try try .{ .x = 123 };
21	_ = x;
22	}
23
24	fn test4() !void {
25	const x: T = try .{"hello"};
26	_ = x;
27	}
28
29	fn test5() !void {
30	const x: error{Foo}!u32 = 123;
31	_ = try try x;
32	}
33
34	comptime {
35	_ = &test0;
36	_ = &test1;
37	_ = &test2;
38	_ = &test3;
39	_ = &test4;
40	_ = &test5;
41	}
42
43	// error
44	//
45	// :5:23: error: expected error union type, found 'comptime_int'
46	// :10:23: error: expected error union type, found '@TypeOf(.{})'
47	// :15:23: error: expected error union type, found 'tmp.test2__struct_493'
48	// :15:23: note: struct declared here
49	// :20:27: error: expected error union type, found 'tmp.test3__struct_495'
50	// :20:27: note: struct declared here
51	// :25:23: error: expected error union type, found 'struct { comptime *const [5:0]u8 = "hello" }'
52	// :31:13: error: expected error union type, found 'u32'