diff --git a/current/CHECKPOINT-FIBERS.md b/current/CHECKPOINT-FIBERS.md index 1a4e434c..85c40002 100644 --- a/current/CHECKPOINT-FIBERS.md +++ b/current/CHECKPOINT-FIBERS.md @@ -59,13 +59,21 @@ body); closed + locked. The review's `.naked`-lambda CRITICAL was a false positi (unparseable — `isLambda` breaks on the `abi` keyword). ## Current state -**B1.2 is BLOCKED on two newly-filed compiler bugs (issues 0150 + 0151). Master is GREEN -(726/0); all B1.2 working changes were REVERTED so the installed `zig-out/bin/sx` is clean.** -See the "B1.2 attempt (BLOCKED)" subsection below + "Known issues" for the full story. The -B1.2 *design* is validated end-to-end (the `Io` protocol on `Context`, the blocking -`CBlockingIo` default, and `context.io.now_ms()` all WORK — verified live); only the two -generic/void compiler gaps stop the `async`/`await`/`timeout` ergonomic layer. WIP saved at -`.sx-tmp/b12-wip/` (io.sx + the compiler+lib diff + the 1805 example) for a fast resume. +**B1.2 is UNBLOCKED.** Master GREEN (726/0), installed `sx` clean. The earlier "blockers" +were NOT real: issue **0151 was INVALID** (its repro used the non-idiomatic `($A)->$R` +bare-fn-ptr form) — **removed**. The correct `async` idiom **works today with no compiler +change** (verified live): `spawn :: (worker: Closure(..$args) -> $R, ..$args) -> Wrap($R)` +with a **lambda worker** + the `w : Wrap($R) = ---; w.v = worker(..args);` build form — +mirrors the canonical `examples/0543-packs-canonical-map.sx`. Ran `42 42` for homogeneous + +heterogeneous args. Caveats (work within them, not "bugs"): lambda params must be annotated +(`(a: i64, b: i64) -> i64 => …`); a bare *named* fn passed as the worker is non-idiomatic — +use a lambda; build the result struct with `= ---` + field-assign, not a struct-literal in +`return`. Issue **0150** (`void` struct field → SIGTRAP exit 133) is a **real** bug but only +reached via `Future(void)` (void-returning worker / `timeout`) — **DEFERRED**: B1.2 supports +non-void workers; revisit `Future(void)` in B1.4 (or fix 0150 standalone). The B1.2 *design* +(Io protocol on Context, blocking `CBlockingIo`, `context.io.now_ms()`) was validated live; +WIP at `.sx-tmp/b12-wip/` has the working Io/Context/materializer parts — reuse those, rewrite +the async layer to the pack-lambda idiom above. ### B1.2 attempt (BLOCKED — design proven, two compiler bugs filed) What was built + verified WORKING (then reverted to keep master green): @@ -132,27 +140,29 @@ fibers/Io/scheduler code yet. Grounded floor facts: boundary; a sharper sx diagnostic for it is a candidate polish, not a blocker. ## Next step -**B1.2 is BLOCKED — resume only AFTER issues 0150 + 0151 are fixed.** Then re-land B1.2 from -the saved WIP (`.sx-tmp/b12-wip/`): the `Io` protocol + `Context.io` + both materializers + -the push-inherit fix + the `!`-impl-warning fix all WORK as-is; restore `timeout -> -Future(void)` (needs 0150) and `async`/`await` (needs 0151), add `examples/1805-concurrency- -io-blocking-async.sx` (lock→green) + `1806-concurrency-io-cancel.sx` (cancel→`await` raises -`.canceled`). Regen `.ir` snapshots ONLY after green (`-Dupdate-goldens`) — adding `Io` to the -prelude shifts many `.ir` type tables; confirm the diff is ONLY layout/numbering + the new -vtable, NO error text. The `Context` layout decision is settled: `{ allocator; data; io; }` -(allocator index 0 fixed by `call.zig:1229`, `io` last). +**B1.2 — resume now (UNBLOCKED, no compiler fix needed).** Re-land from the saved WIP +(`.sx-tmp/b12-wip/`): keep the verified-working parts — the `Io` protocol on `Context`, both +`__sx_default_context` materializers (protocol.zig + comptime_vm.zig), the push-inherit-omitted +fix (stmt.zig `lowerPush` — omitted `push Context.{...}` fields inherit the ambient ctx; the +correct fix, NOT per-site `io = context.io` edits across the 17 sites), and the +`!`-impl-warning fix. **Rewrite the async/await layer to the CORRECT idiom** (verified live): -**API CORRECTION (user, 2026-06-20):** `async`'s args are a **variadic heterogeneous -comptime pack** `..$args: []Type` ([specs.md:1383](../specs.md#L1383)), NOT a single `$A`. -Shape: `async(io, worker, ..args)` forwards a per-position-typed pack to `worker` (so -`context.io.async(fn, a, b, c)` works at any arity). The WIP's single-`arg: $A` form is -superseded — re-land async with the pack. This is ORTHOGONAL to issue 0151 (which is about -the *return* type-var `$R` not binding in the body — needed regardless of arg shape); also -verify packs-in-fn-pointer-param-signatures work when re-landing (surface a new issue if not). + async :: (io: Io, worker: Closure(..$args) -> $R, ..$args) -> Future($R) { + f : Future($R) = ---; // `= ---` + field-assign, NOT a struct-literal return + f.value = worker(..args); // blocking impl: run to completion + f.state = .ready; + return f; + } -NOTE for the resume: do NOT add `io = context.io` to the 17 partial `push Context.{...}` sites -— the push-inherit-omitted fix (in the WIP diff) makes omitted fields inherit from the ambient -context, which is the correct fix and was verified to compile. Use that, not per-site edits. +Worker is a **lambda** with **annotated params** (`(a: i64, b: i64) -> i64 => …`); name it +`async` (NOT `run` — `run` collides with `process.run` re-exported by std.sx and is silently +shadowed). `Future($R)` is a parameterized `struct($T)` (so the bare-`-> $R`-return inference +gap is auto-avoided). **Avoid `Future(void)`** (issue 0150 SIGTRAP) — B1.2 supports non-void +workers; `timeout`/`Future(void)` defer to B1.4. Add `examples/1805-concurrency-io-blocking- +async.sx` (lock→green) + `1806-concurrency-io-cancel.sx`. Regen `.ir` ONLY after green +(`-Dupdate-goldens`) — adding `Io` to the prelude shifts many `.ir` type tables; confirm the +diff is ONLY layout/numbering + the new vtable, NO error text. `Context` layout settled: +`{ allocator; data; io; }` (allocator index 0 fixed by `call.zig:1229`, `io` last). ## Known issues / capability gaps - **🔴 B1.2 BLOCKERS (both filed, both standalone-reproducible, both independent of the Io diff --git a/current/PLAN-FIBERS.md b/current/PLAN-FIBERS.md index 99321712..fee3a5a0 100644 --- a/current/PLAN-FIBERS.md +++ b/current/PLAN-FIBERS.md @@ -1,12 +1,17 @@ # PLAN-FIBERS — Stream B1 (fibers + Io + M:1 scheduler) -> **STATUS: 🚧 in progress.** B1.0 (`abi(.naked)` codegen) ✅ + B1.1 (per-fiber `context` -> root — zero compiler change, library convention) ✅ complete. **B1.2** (`Io` interface + -> `context.io` + `Future` + `cancel()`) is **🔴 BLOCKED on compiler issues 0150 (`void` -> struct field SIGTRAP) + 0151 (type-var from a fn-ptr-return not bound in body)** — the Io -> design is proven (the protocol-on-`Context` + blocking default + `context.io.now_ms()` work -> live), but `Future(void)`/`timeout` and the `async`/`await` generics hit those two bugs. -> Resume B1.2 after both land (WIP saved at `.sx-tmp/b12-wip/`); see `CHECKPOINT-FIBERS.md`. +> **STATUS: 🚧 in progress.** B1.0 (`abi(.naked)`) ✅ + B1.1 (per-fiber `context`) ✅. **B1.2** +> (`Io` interface) is **UNBLOCKED** — the earlier "blockers" were artifacts of non-idiomatic +> syntax + a worker's dirty binary. Issue **0151 was INVALID** (the `($A)->$R` bare-fn-ptr +> form is not idiomatic sx) and is **removed**. The correct `async` idiom **works today, no +> compiler change**: `async :: (io, worker: Closure(..$args) -> $R, ..$args) -> Future($R)` +> with a **lambda worker** + the `result : Future($R) = ---; result.v = worker(..args);` build +> form (mirrors the canonical `examples/0543-packs-canonical-map.sx`). Caveats: lambda params +> must be annotated; passing a bare *named* fn as the worker is non-idiomatic (use a lambda). +> Issue **0150** (`void` struct field SIGTRAP, exit 133) is a **real** bug but only hit by +> `Future(void)`/`timeout` — **deferred** (avoid void Futures in B1.2; revisit in B1.4). Resume +> B1.2 with the corrected idiom (the WIP at `.sx-tmp/b12-wip/` has the Io-protocol/Context/ +> materializer parts that WORK; rewrite the async layer to the pack-lambda form above). Carved from [PLAN-POST-METATYPE.md](PLAN-POST-METATYPE.md) Stream B (§B1) + the design-of-record [../design/execution-evolution-roadmap.md](../design/execution-evolution-roadmap.md) diff --git a/issues/0151-typevar-from-fnptr-return-not-bound-in-body.md b/issues/0151-typevar-from-fnptr-return-not-bound-in-body.md deleted file mode 100644 index d74438fa..00000000 --- a/issues/0151-typevar-from-fnptr-return-not-bound-in-body.md +++ /dev/null @@ -1,98 +0,0 @@ -# 0151 — a type-var inferred from a fn-pointer parameter's RETURN type is not bound in the function body - -## Status -OPEN — blocks Stream B1 (fibers) B1.2's `async(io, worker: ($A) -> $R, arg: $A)` -free-fn (it needs `Future(R)` in its body). Independent of the fibers work -(reproduces with a tiny `Wrap($R)` standalone). - -## Symptom -A generic free function whose type-var `$R` is introduced **inside a -fn-pointer parameter's return type** (`worker: ($A) -> $R`) infers `$R` fine for -the call's type-checking, but `R` is **not in scope as a usable type name in the -function body**. Referencing `Wrap(R)` (or any `R`) in the body errors: - -``` -error: unknown type 'R' - --> repro.sx:4:14 - | - 4 | w : Wrap(R) = .{ v = worker(arg) }; -``` - -By contrast a type-var introduced **directly** by a parameter (`arg: $A`) IS -usable in the body (`Wrap(A)` works — see the second repro). So the gap is -specific to type-vars that appear only nested in a fn-pointer (or closure) -parameter's signature. - -Observed: `error: unknown type 'R'` for the body reference. -Expected: `R` binds to the worker's return type (here `i64`), so `Wrap(R)` -resolves to `Wrap(i64)`, exactly as `$A` → `A` does. - -## Reproduction (fails) -```sx -#import "modules/std.sx"; - -Wrap :: struct($T: Type) { v: T; } - -runit :: (worker: ($A) -> $R, arg: $A) -> Wrap($R) { - w : Wrap(R) = .{ v = worker(arg) }; // error: unknown type 'R' - return w; -} - -dbl :: (n: i64) -> i64 { return n * 2; } - -main :: () -> i32 { - r := runit(dbl, 21); - print("{}\n", r.v); // want: 42 - return 0; -} -``` - -## Reproduction (works — shows the contrast) -```sx -#import "modules/std.sx"; -Wrap :: struct($T: Type) { v: T; } -runit :: (arg: $A) -> Wrap($A) { - w : Wrap(A) = .{ v = arg }; // OK — `A` (direct param type-var) binds - return w; -} -main :: () -> i32 { r := runit(21); print("{}\n", r.v); return 0; } // prints 21 -``` - -## Suspected area -Generic monomorphization / type-binding collection (the pass that walks a generic -function's parameter signatures to discover `$X` type-vars and record the -caller-inferred binding for use in the body). It descends into direct param types -(`arg: $A` → binds `A`) but does NOT descend into a fn-pointer / closure -parameter's nested signature (`($A) -> $R`) to also bind `$R` from the matched -argument function's return type (and likewise `$A` from its params, if only named -there). Look for where `$`-type-params are gathered from `fd.params` and the -per-instance `type_bindings` map is seeded — likely in `src/ir/generic.zig` -and/or the call-site argument→param type-var unifier in `src/ir/lower/call.zig`. -The unifier already infers `$R` well enough to type-check the call (the error is -only in the BODY), so the binding exists at the call site but isn't propagated -into the monomorphized body's `type_bindings`. - -## Investigation prompt (paste into a fresh session) -> A type-var that appears only inside a fn-pointer parameter's signature -> (`worker: ($A) -> $R`) is inferred at the call site (the call type-checks) but -> is NOT available as a type name in the generic function's BODY — `Wrap(R)` in -> the body errors `unknown type 'R'`, while a direct `arg: $A` makes `A` usable. -> Repro: `issues/0151-...` (the failing + the working contrast are both inline in -> the `.md`; the `.sx` is the failing one). Fix the generic type-binding pass so -> that when a generic fn is monomorphized, type-vars discovered inside a -> fn-pointer/closure parameter's nested signature (its params AND its return -> type) are added to the instance's `type_bindings` from the matched argument -> function's concrete signature — mirroring how direct param type-vars are bound. -> Suspected sites: `src/ir/generic.zig` (binding collection from `fd.params`) + -> the call-site unifier in `src/ir/lower/call.zig` (it already infers `$R` for -> overload/type-check, so reuse that result to seed the body bindings). Verify: -> the failing repro prints `42`; then move it to `examples/` as a regression test. - -## Why this matters for B1 (fibers) -`async(io, worker: ($A) -> $R, arg: $A) -> Future($R)` is the central B1.2 -ergonomic free-fn; its body builds `Future(R)`. Without this fix `async` can't be -written in its spec-faithful form. Routing around it (an explicit `$R: Type` -param the caller must pass) would change the surface and HIDE the gap — not done. -The rest of the B1.2 Io surface (the `Io` protocol on `Context`, the blocking -`CBlockingIo` default, `context.io.now_ms()`) works; only the `async`/`await` -generics are blocked by this. Saved WIP: `.sx-tmp/b12-wip/`.