zig

commit ad391ad399b26cf6a781e01c6daecf48bb764478 (tree)
parent 3d64ed0353ba7ec1ca46f4779fe5d32af8d17358
Author: Andrew Kelley <andrew@ziglang.org>
Date:   Thu, 18 May 2023 16:24:07 -0700

Revert "Sema: handle recursive inferred errors better in analyzeIsNonErrComptimeOnly"

This reverts commit 5aa9628de3c6637f45b9d8cf8cbd19c422a74f6f.

This is a breaking language change and I do not agree with it. Please go
through the proposal process on this one.

Diffstat:
M
src/Sema.zig
 | 
11
+++++++----
M
test/behavior/error.zig
 | 
42
++++++++++++++++--------------------------

2 files changed, 23 insertions(+), 30 deletions(-)
diff --git a/src/Sema.zig b/src/Sema.zig
@@ -29198,6 +29198,8 @@ fn analyzeIsNonErrComptimeOnly(
             if (ies.errors.count() != 0) break :blk;
             if (maybe_operand_val == null) {
                 // Try to avoid resolving inferred error set if possible.
+                if (ies.errors.count() != 0) break :blk;
+                if (ies.is_anyerror) break :blk;
                 for (ies.inferred_error_sets.keys()) |other_ies| {
                     if (ies == other_ies) continue;
                     try sema.resolveInferredErrorSet(block, src, other_ies);
@@ -29209,10 +29211,11 @@ fn analyzeIsNonErrComptimeOnly(
 
                     if (other_ies.errors.count() != 0) break :blk;
                 }
-                if (!ies.is_resolved and ies.func.state == .in_progress) {
-                    // Calling resolveInferredErrorSet would immediately fail
-                    // so we'll have to rely on runtime checks.
-                    return Air.Inst.Ref.none;
+                if (ies.func == sema.owner_func) {
+                    // We're checking the inferred errorset of the current function and none of
+                    // its child inferred error sets contained any errors meaning that any value
+                    // so far with this type can't contain errors either.
+                    return Air.Inst.Ref.bool_true;
                 }
                 try sema.resolveInferredErrorSet(block, src, ies);
                 if (ies.is_anyerror) break :blk;
diff --git a/test/behavior/error.zig b/test/behavior/error.zig
@@ -705,6 +705,22 @@ test "error union payload is properly aligned" {
     if (blk.a != 1) unreachable;
 }
 
+test "ret_ptr doesn't cause own inferred error set to be resolved" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+
+    const S = struct {
+        fn foo() !void {}
+
+        fn doTheTest() !void {
+            errdefer @compileError("bad");
+
+            return try @This().foo();
+        }
+    };
+    try S.doTheTest();
+}
+
 test "simple else prong allowed even when all errors handled" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -912,29 +928,3 @@ test "optional error set return type" {
     try expect(null == S.foo(true));
     try expect(E.A == S.foo(false).?);
 }
-
-test "try used in recursive function with inferred error set" {
-    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; // TODO
-
-    const Value = union(enum) {
-        values: []const @This(),
-        b,
-
-        fn x(value: @This()) !void {
-            switch (value.values[0]) {
-                .values => return try x(value.values[0]),
-                .b => return error.a,
-            }
-        }
-    };
-    const a = Value{
-        .values = &[1]Value{
-            .{
-                .values = &[1]Value{.{ .b = {} }},
-            },
-        },
-    };
-    try expectError(error.a, Value.x(a));
-}