df1327e316
A failable function that returned by IMPLICIT success (no explicit
`return`) left its error-tag slot uninitialized, so a caller's `catch` /
`or` (or `main`) read a garbage tag and reported a phantom unhandled
error — and for value-carrying failables the success value was dropped.
The "no error" sentinel was only written on the explicit-`return;` path.
Unified all function-body-return lowering so the failable-success slot
is always written:
- void `-> !` fall-through: `ensureTerminator` (control_flow.zig) now
emits `ret constInt(0)` for a pure-failable end-of-body.
- value-failable trailing-expression success: `lowerValueBody`
(stmt.zig) routes through `lowerFailableSuccessReturn`.
- generic + pack-fn instances: `monomorphizeFunction` (generic.zig) and
`monomorphizePackFn` (pack.zig) now DELEGATE their body-return to
`lowerValueBody` instead of hand-rolling a `coerce`+`ret` that drifted
(covers generic/pack value-failables).
Also fixes the missing-value diagnostic guard added here: it now counts
`.err`-level diagnostics (new `DiagnosticList.errorCount`) rather than the
total list length, so a warning/note emitted while lowering the body
(e.g. an ObjC selector arity warning) can no longer suppress a genuine
"body produces no value" error — which previously shipped an
uninitialized return at exit 0.
Regressions: examples/errors/1061 (void fall-through), 1062 (value-failable
trailing expr), 1063 (generic value-failable trailing expr).
47 lines
1.7 KiB
Plaintext
47 lines
1.7 KiB
Plaintext
// Generic value-carrying failable functions (`($T) -> T !E`) whose body ends in
|
|
// a trailing success EXPRESSION (no explicit `return`) must set the success
|
|
// error slot to 0 — the caller's `catch` must NOT fire and the value must be
|
|
// intact across instantiations (i64 / string / struct), and `or` must yield the
|
|
// real value not the fallback.
|
|
// Regression (issue 0190): `lowerGenericInstance` hand-rolled a body-return
|
|
// (coerceToType+ret) that missed the value-failable success routing, leaving
|
|
// the error-tag slot uninitialized → phantom catch on success / value
|
|
// corruption for generic instantiations.
|
|
#import "modules/std.sx";
|
|
|
|
E :: error { Bad }
|
|
|
|
Point :: struct { x: i64; y: i64; }
|
|
|
|
// Generic trailing-expression success — instantiated at i64 / string / struct.
|
|
gen :: ($T: Type, v: T) -> T !E { v }
|
|
|
|
// Generic that RAISES — the caller's catch must still fire.
|
|
gfail :: ($T: Type, v: T, bad: bool) -> T !E {
|
|
if bad { raise error.Bad; }
|
|
v
|
|
}
|
|
|
|
main :: () -> i32 {
|
|
a := gen(i64, 42) catch (e) { print("PHANTOM i64\n"); return 1; };
|
|
print("i64: {}\n", a);
|
|
|
|
s := gen(string, "hello") catch (e) { print("PHANTOM string\n"); return 1; };
|
|
print("string: {}\n", s);
|
|
|
|
p := gen(Point, Point.{ x = 3, y = 4 }) catch (e) { print("PHANTOM struct\n"); return 1; };
|
|
print("struct: ({},{})\n", p.x, p.y);
|
|
|
|
// `or`-form on success must yield the real value, not the fallback.
|
|
o := gen(i64, 7) or 999;
|
|
print("or: {}\n", o);
|
|
|
|
// A generic that raises still propagates to the caller's catch.
|
|
gfail(i64, 0, true) catch (e) {
|
|
print("raise caught\n");
|
|
return 0;
|
|
};
|
|
print("UNEXPECTED no error\n");
|
|
return 1;
|
|
}
|