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).
44 lines
1.4 KiB
Plaintext
44 lines
1.4 KiB
Plaintext
// Value-carrying failable functions (`-> 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 success value must be intact.
|
|
// Regression (issue 0190): `lowerValueBody` used to `coerceToType`+`ret` the
|
|
// bare success value to the full failable tuple, leaving the error-tag slot
|
|
// uninitialized → phantom catch on success (and dropped value for string /
|
|
// multi-value returns).
|
|
#import "modules/std.sx";
|
|
|
|
E :: error { Bad }
|
|
|
|
// Single-value trailing-expression success.
|
|
val :: () -> i64 !E { 99 }
|
|
|
|
// String trailing-expression success.
|
|
sval :: () -> string !E { "hi" }
|
|
|
|
// Multi-value (tuple) trailing-expression success.
|
|
mval :: () -> Tuple(i64, i64) !E { .(1, 2) }
|
|
|
|
// A real error still propagates through the value-failable channel.
|
|
fval :: (n: i64) -> i64 !E {
|
|
if n < 0 { raise error.Bad; }
|
|
n + 1
|
|
}
|
|
|
|
main :: () -> i32 {
|
|
x := val() catch (e) { print("PHANTOM val\n"); return 1; };
|
|
print("x={}\n", x);
|
|
|
|
s := sval() catch (e) { print("PHANTOM sval\n"); return 1; };
|
|
print("s={}\n", s);
|
|
|
|
t := mval() catch (e) { print("PHANTOM mval\n"); return 1; };
|
|
print("t=({},{})\n", t.0, t.1);
|
|
|
|
ok := fval(10) catch (e) { print("PHANTOM fval-ok\n"); return 1; };
|
|
print("ok={}\n", ok);
|
|
|
|
fval(-1) catch (e) { print("real error caught\n"); return 0; };
|
|
print("UNEXPECTED no error\n");
|
|
return 1;
|
|
}
|