06e2685350
A closure's underlying function carries a hidden env arg that a bare (T)->U slot
doesn't pass, so a closure flowing into a bare function-type slot dropped the
env — the first user arg landed in the env slot and the rest read garbage
(apply(closure((x)->s64 { x*2 })) returned 192 instead of 10; non-failable too).
- createClosureToBareFnAdapter: a capture-free closure into a bare (T)->U slot is
bridged by a generated adapter carrying the bare ABI (forwards a null env);
lowerLambda returns its func_ref. Rejected (no silent miscompile): a capturing
closure into a bare slot (env has nowhere to live) and a failable closure into
a non-failable slot (the ERR E5.1 FFI-boundary rule).
- Arrow-body failable closures (-> (T,!) => expr) now wrap the bare success value
into {value, 0} via lowerFailableSuccessReturn (the implicit return previously
returned a malformed tuple → caught value read as 0).
The isLambda .bang parser fix (failable closure literals parse) already landed in
485b4fa. Regressions: examples/0309-closures-literal-as-bare-fn-param (non-
failable, block + arrow, called in callee) + 1039-errors-failable-closure-literal
(failable, block + arrow, direct + Closure(...) param). Resolves issue 0060
(remaining E5.1 follow-ups noted in the .md). Suite: 328 passed.
18 lines
868 B
Plaintext
18 lines
868 B
Plaintext
// Regression (issue 0060): a closure LITERAL passed directly as a bare
|
|
// function-type argument `(T) -> U` and then called inside the callee. The
|
|
// closure's underlying function takes a hidden env arg that a bare fn-ptr slot
|
|
// doesn't pass, so the compiler bridges a capture-free closure to the bare ABI
|
|
// with a generated adapter. Both block and arrow bodies. (The working contrast
|
|
// where the param is a `Closure(...)` type is examples/0302.)
|
|
|
|
#import "modules/std.sx";
|
|
|
|
apply :: (f: (s64) -> s64) -> s64 { return f(5); }
|
|
twice :: (f: (s64) -> s64, x: s64) -> s64 { return f(f(x)); }
|
|
|
|
main :: () {
|
|
print("block={}\n", apply(closure((x: s64) -> s64 { return x * 2; }))); // 10
|
|
print("arrow={}\n", apply(closure((x: s64) -> s64 => x * 2))); // 10
|
|
print("twice={}\n", twice(closure((x: s64) -> s64 => x + 3), 1)); // ((1+3)+3) = 7
|
|
}
|