mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-01-10 01:15:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
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.
This commit is contained in:
Andrew Kelley 2023-05-18 16:24:07 -07:00
parent 3d64ed0353
commit ad391ad399
2 changed files with 23 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/Sema.zig
View File

@ -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;

42
test/behavior/error.zig
View File

@ -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));
}