6fd238d | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

6fd238d — Peter John 2026-11-05T18:41:07+05:30

Io as a built-in primitive with extern methods

Generated files not shown: plum-game/Cargo.lock

Files changed (22) hide show

README.md +1 -1
docs/backlog.md +5 -0
docs/plans/2026-11-05-compiler-cleanup-phase3b.progress.md +11 -0
docs/plans/2026-11-05-io-primitive.md +98 -0
docs/plans/2026-11-05-io-primitive.results.md +74 -0
plum-checker/src/lib.rs +25 -55
plum-checker/tests/checker/features/io_capability.rs +13 -9
plum-checker/tests/checker/io_primitive_tests.rs +39 -0
plum-checker/tests/checker/main.rs +1 -0
plum-core/src/ast.rs +10 -1
plum-core/src/drive.rs +3 -1
plum-core/src/purity.rs +2 -1
plum-core/src/tests_lower.rs +1 -1
plum-core/tests/core/drive_test.rs +28 -26
plum-core/tests/core/parser_test.rs +14 -0
plum-core/tests/core/purity_test.rs +16 -7
plum-std/Io.plum +78 -229
plum-wasm-codegen/src/lib.rs +29 -31
plum-wasm-codegen/tests/wasm_codegen/codegen_tests.rs +6 -12
plum-wasm-codegen/tests/wasm_codegen/e2e_types/io_primitive.rs +78 -0
plum-wasm-codegen/tests/wasm_codegen/e2e_types/mod.rs +1 -0
plum-wasm-codegen/tests/wasm_codegen/fusion_alloc_test.rs +91 -0

README.md CHANGED Viewed

@@ -1103,7 +1103,7 @@ fun main(io: Io) =
   io.printLn("hello")
 ```
-Every call that leaves the program (printing, files, clock, randomness, network, drawing, input, sound) is a method of the `Io` capability in `plum-std/Io.plum`, the only place `extern fun` may be used; calling an extern anywhere else is a compile error, and `Io` can only be constructed inside std. An entry point (`main`, an `export fun`, a `test`) may take it as its first parameter (a `test` gets `io` implicitly), and code passes it down only to the functions that do I/O, so a function with no `Io` reachable cannot touch the host. That is all purity is: there is no function colouring and no `pure` keyword. `extern fun` declares a function backed by a host-provided wasm import (module `plum`, the function's name), with no Plum body. At the boundary `Int` is narrowed to a wasm `i32` (the rest of the language uses 64-bit `Int`), so extern parameters and results are 32-bit, and an extern can't return an error union. The `io` parameter is not part of the wasm ABI. `plum run`, `plum test` and `plum build` provide the standard host functions (printing, `crash`, clock and random, files, HTTP).
+Every call that leaves the program (printing, files, clock, randomness, network, drawing, input, sound) is a method of the built-in `Io` capability, declared once as `extern fun` methods in `primitive Io` (`plum-std/Io.plum`); an `Io` cannot be constructed in user code, so no host import is reachable without one. An entry point (`main`, an `export fun`, a `test`) may take it as its first parameter (a `test` gets `io` implicitly), and code passes it down only to the functions that do I/O, so a function with no `Io` reachable cannot touch the host. That is all purity is: there is no function colouring and no `pure` keyword. An `extern fun` method declares a function backed by a host-provided wasm import (module `plum`, the function's name), with no Plum body. At the boundary `Int` is narrowed to a wasm `i32` (the rest of the language uses 64-bit `Int`), so extern parameters and results are 32-bit, and an extern can't return an error union. The `io` parameter is not part of the wasm ABI. `plum run`, `plum test` and `plum build` provide the standard host functions (printing, `crash`, clock and random, files, HTTP).
 ```sh
 $ plum run plum-examples/basics.plum

docs/backlog.md CHANGED Viewed

@@ -21,12 +21,17 @@ Open work, in the order the user queued it, plus smaller items found during buil
      - **User's proposal:** make `Actor` a plain struct/record and let embedding give inheritance-like behaviour: a record that embeds another *first* is a subtype of it (`Walker` is an `Actor`, so it can sit in a `Slice[Actor]`), with `override fun` dispatched on the concrete kind. Today record embedding only copies (`a World is not a Stage`), so this means embedding becomes subtyping. That is the box-free trait layout (wasm-gc base struct + subtypes, `isSubtypedTrait`) applied to records, which would retire trait fields, `__get_`/`__set_` accessors and the boxed-trait path. Open: whether behaviour-only traits stay (Rust-style, no fields) or abstract methods on the base record cover them; what `==` means on a subtyped value (identity today); whether only first-position embedding subtypes (the rule today).
      - **Performance evidence** (BENCHMARK.md, 2026-11-03 benchmarks, M3 Pro headed): at 5.8k nodes the three styles are within about 3% (imperative trait Scene 1.70 ms, pure 1.71, functional 1.75, draw-dominated). Boxed trait field reads from outside the trait cost a dispatch over every actor kind (about 30-40 ns vs 10 ns), which made `stress_world` (20k nodes, y-sort) +92%; the box-free subtyped layout brought it back to closure speed (1.10 vs 1.09 ms). So the proposal keeps the fast path. Method dispatch is still a `ref.test` chain whose cost grows with the number of kinds. Not measured: a functional-style 20k-node world (no culling or sort fixture exists for it) and per-frame allocation/GC of `State` at that size. Add a `stress_world_state_view` fixture to the benchmark item (3) before deciding.
 6. **Deterministic games** — fixed timestep, input recording and replay, seeded `Random` in game state, state checksums; port the design from `../kam_macroquad` (`main.rs` tick accumulator, `game/replay.rs`). The `Io` capability makes recording and replaying host input straightforward. (Decision record §10.)
+   - **Design notes (2026-11-05):** determinism comes from what may enter `update`, not from the style. Rules for both styles: (1) fixed timestep — host accumulates wall time, calls `update` with a constant `dt`, `draw` may interpolate; (2) input is a per-tick `InputFrame` value passed in, never polled inside `update` (a replay is the list of frames); (3) `update` takes no `Io` — the compiler then proves it reads no clock/random/files and draws nothing; `draw(state, io)` keeps `Io` and can't change state; (4) a seeded `Random` lives in the state (each draw returns a new generator); seed from `io` once at startup, recorded with the replay; (5) no ordering by reference identity or host-seeded hashes (std Map's hash is deterministic; keep it so); (6) wasm floats are deterministic IEEE 754 (don't hash NaN bits); (7) hash the state after each tick, compare runs.
+   - **Imperative** (`update(world, input)` mutates): deterministic under the rules, but snapshots/rollback need a deep copy or serialization of the mutable graph, checksums need a graph walker that skips shared refs, and mutation order through aliases is part of the semantics (fragile).
+   - **Functional** (`update(state, input) -> State`): determinism is almost free — pure by construction (purity pass can check it since `update` has no `Io`); a snapshot is keeping the old value (persistent structures share memory), rollback/resimulation = old state + logged inputs, checksum = hash of a value. Cost: a new state per tick, which FBIP removes when the old value isn't shared. Argues for the functional shape when the game styles become one (see "One way to build a game").
 7. **Kids' games (ages 4-7)** (user 2026-11-04: LAST, after all the refactoring is done) — review plan `docs/plans/2026-11-04-kids-games.review.md` (written, NOT approved; re-present for a fresh human approve). Seven functional-style games in `plum-examples/games/functional/kids/`: Balloon Pop (tap), Bunny Hop, Letter Bubbles, Caterpillar, Color Piano, Star Rocket (gentle Orb Run), Hoppy Frog (platformer); nothing can be lost. Draft `balloon_pop.plum` exists (untracked) and is blocked by the `List.length` bug below. Re-check the plan against the post-refactor APIs (explicit generics, `Io` primitive, crate paths) before approving.
 ## Planned, not yet placed in the queue
 - **Language ideas to discuss later** (user 2026-11-05: "add them ideas to be discussed later"):
   - **Single inheritance** — DECIDED 2026-11-05, built in run C (T11).
+  - **One way to build a game** (user 2026-11-05, idea): collapse the three styles (std/game/imperative Scene, functional FunctionalScene/Ui, pure PureScene/SceneInput) into one; the game-entry shape (below) is chosen with it.
+  - **No top-level functions** (user 2026-11-05, thinking, not scheduled): every `fun` lives under a `primitive`, `enum` or `struct`; this also removes top-level `extern fun` (Io's host calls are already `extern` methods on `primitive Io`). The entry point is always on `primitive App` (`primitive App = fun main(io: Io)`). Games (user 2026-11-05, preferred): std `struct Game = abstract fun update(self, io: Io, dt: Float) -> Game; abstract fun draw(self, io: Io)`; the game's `World` embeds `Game` and overrides both; `App.main(io) = io.run(World(..))`. `io.run` hands the game ref to the host (rooted); each frame the host calls two codegen-generated exports that dispatch `game.update`/`game.draw` (normal override dispatch); `update` returns the next `Game` (imperative returns `self`, functional/pure a new value), the host keeps it. A missing `draw` is a compile error (abstract), no magic export names, "init" is just constructing `World` in `main`. Replaces the three free `export fun init/update/draw`. Considered: `App.init/update/draw` statics (untyped name contract). Open (user: "this is more OOP"): the functional alternative `io.run[S](state: S, update: fn(S, Io, Float) -> S, draw: fn(S, Io))`, e.g. `App.main(io) = io.run(World.start(io), World.update, World.draw)` — typed by the call, no base class, state-in/state-out (FBIP, deterministic sim); host stores state + two fn refs. Undecided (user 2026-11-05): pick when the three game styles (imperative, functional, pure scene) are collapsed into ONE way to build a game; the game-entry shape is chosen together with that. Trade-offs noted: embed `Game` uses the struct's single embed slot and makes `update` return the base `Game`; `io.run(state, update, draw)` keeps the concrete type and lets tests swap `update`. Open points: unqualified calls inside a type resolve to its own statics (so helpers stay short at call sites); loose helpers go in a `primitive Name =` namespace (exists today); `test` blocks stay top-level. Scale: ~109 top-level fns in std, ~350 in examples, ~70 in web-test fixtures.
   - **One way to set up a struct.** Drop `fun init(self)` in favour of field defaults + ordinary constructor functions. `init` is what forces the Boxed layout and the EmbedInit machinery in `ctors.rs`. Main user: `std/game/imperative/Scene.plum`.
   - **From Pony:** (1) a two-level ownership model (unique + mutable vs shared + immutable, like Pony's `iso`/`val` with `consume`) as the visible face of FBIP, replacing `mut` fields — take into the FBIP plan; (2) no ambient authority: no globals, a function without `Io` provably does no IO — what deterministic sim needs; (3) Pony partial functions (`?`, no error value) argue for `Option` + `?` as the common path and `Result` only when the error value matters. Not copied: union types, structural interfaces, six capabilities.

docs/plans/2026-11-05-compiler-cleanup-phase3b.progress.md ADDED Viewed

@@ -0,0 +1,11 @@
+- start faa4d7e
+wasm hashes before T1: .superlite/wasm-before-3b.txt (25 examples, all compile)
+Ruling: skip Wave 0 - cost: none
+Ruling: accept predicted 39 min - forced chain - cost: none
+Ruling: T1 API names *Diag (loadAndMergeDiag, lower::perFileDiag, frontEndDiag); old String names are wrappers removed in T6 - cost: none
+Ruling: T2 residual - inferExpr's Err(String) undefined-name errors are classified Resolution by a registry of exact registered messages (not keywords); full fix = inferExpr returns Diagnostic, moved to phase 4 (spans/node ids) - cost: one narrow string match remains until phase 4
+Ruling: T4 touched plum-core/tests/core/trmc_test.rs (compile return type) - needed - cost: none
+Ruling: final-review checkpoint-dropped files (plum-driver/, Cargo.toml deps, trmc_test, host_test, docs) - bookkeeping; all on disk, workspace member present, T6 full sweep green on the working tree - cost: none
+Ruling: final-review registry accumulation - resetCheck replaces the whole CheckState with Default (clears resolution_msgs) per compile - cost: none
+Ruling: final-review dropped-rewrite state - driver test aRewriteThatFailsItsRecheckIsDropped prepends a breaking pass and asserts the result equals the run without it; order is the PASSES const - cost: none
+Ruling: final-review protocol - CLI stderr/exit tested by undefinedNameIsReportedAsFileLineColumnTypeError; LSP 0-based mapping by typeDiagnosticUsesTheDiagnosticPosition - cost: none

docs/plans/2026-11-05-io-primitive.md ADDED Viewed

@@ -0,0 +1,98 @@
+# Io as a built-in primitive with extern methods
+**Review plan:** docs/plans/2026-11-04-io-primitive-extern-methods.review.md
+**Goal:** `Io` is a built-in primitive (like `Int`) whose host calls are declared once, as `extern fun name(self, ..)` methods in `primitive Io =` (std/Io.plum). The ~50 top-level externs and ~51 forwarding methods go; user code can't construct an `Io` or reach a host import without one, by construction, so the "needs io" scan, `isIoFile` and the "Io can only be constructed inside std" checks go. Host import names (`env.drawRect`, ...) and the host side are unchanged.
+**Architecture:** plum-core (ast BUILTIN_PRIMITIVES, parser collectBody, tests_lower, purity), plum-checker, plum-wasm-codegen, plum-std/Io.plum (+ callers), plum-game web-test.
+**Tech stack:** Rust 2021, Plum, wasm-gc.
+**Detail:** contracts
+**Target-min:** 30
+## Global constraints
+- Work on `master` in the main checkout, default shared `target/`. Don't commit. Never run `plum format` on real files. No `sed -i -E`.
+- No `cargo test` (hook): `cargo build --tests`; per-crate test binaries in `target/debug/deps` (`core-*`, `checker-*`, `cli-*`, `wasm_codegen-*`, `driver_tests-*`; newest by mtime `/bin/ls -t`). Plum sweep `cargo build -p plum-cli && target/debug/plum test plum-std plum-examples` (662).
+- Rulings (coordinator, AI orchestrator): an `Io` value is an `i32` constant 0 in wasm (review plan's fallback; dropping the value entirely is a later optimisation). `raw*` host calls are ordinary `extern` methods on `Io`, not hidden (they need an `Io` anyway). Extern methods are allowed only in `primitive Io`. Top-level `extern fun` stays a language feature for now (removal is the user's call; ask after this run).
+- T1-T2 add the new path next to today's `struct Io` path (both work); T3 switches std; T4 deletes the old path.
+## Task graph
+```mermaid
+flowchart LR
+  T1[core + checker: primitive Io, extern methods]
+  T2[codegen: Io as i32 0, extern method imports]
+  T3[std Io.plum rewrite]
+  T4[delete old struct-Io paths]
+  T5[verify incl. browser games]
+  %% taskgraph
+  T1 --> T2
+  T2 --> T3
+  T3 --> T4
+  T4 --> T5
+```
+Ruling: sequential [chain] - checker support, then codegen, then the std switch that deletes the old path - cost: one task at a time.
+## Package A: compiler
+**Probe entry:** run=plum test plum-std plum-examples
+### T1 core and checker: primitive Io, extern methods · Complexity 4 · Est. context 45k
+**Owns:** plum-core/src/ast.rs, plum-core/src/parser.rs, plum-core/src/tests_lower.rs, plum-core/src/purity.rs, plum-core/src/loader.rs, plum-checker/src/*.rs, plum-checker/tests/checker/io_primitive_tests.rs, plum-checker/tests/checker/main.rs, plum-core/tests/core/parser_test.rs
+**Components:** 2
+**LOC owned:** 120
+**Tests:** fast
+**Model:** sonnet
+**Produces:** `primitive Io = extern fun f(self, ..)` parses and checks; `Io` is a built-in type (`BUILTIN_PRIMITIVES` has "Io"); `io.f(a)` types as the extern's return; extern methods elsewhere rejected
+e.g. `primitive Io =\n  extern fun printLn(self, s: Str)` + `fun main(io: Io) = io.printLn("hi")` -> checks; `struct R =\n  extern fun f(self)` -> error "extern methods are only allowed on Io"; `primitive Int =\n  extern fun g(self)` (in a test program) -> same error; user `Io()` -> error "Io has no constructor"
+**Notes:** parser `collectBody` keeps extern fns in a primitive body. Tests' `io` binding, tests_lower's io param and purity's io detection recognise `primitive Io` as well as today's `struct Io` (old path stays until T3). An `Io` param/local/closure capture types as `TNamed("Io")` treated as built-in.
+**Test code:** io_primitive_tests: the e.g. cases; a test block using `io` with `primitive Io` in scope; purity: fn taking Io not pure. All binaries + sweep green.
+### T2 codegen: Io value and extern-method imports · Complexity 4 · Est. context 45k
+**Owns:** plum-wasm-codegen/src/*.rs, plum-wasm-codegen/tests/wasm_codegen/e2e_types/io_primitive.rs, plum-wasm-codegen/tests/wasm_codegen/e2e_types/mod.rs
+**Components:** 1
+**LOC owned:** 120
+**Tests:** fast
+**Model:** sonnet
+**Consumes:** `primitive Io = extern fun f(self, ..)` parses and checks; `Io` is a built-in type (`BUILTIN_PRIMITIVES` has "Io"); `io.f(a)` types as the extern's return; extern methods elsewhere rejected (T1)
+**Produces:** with `primitive Io`, an `Io` is wasm `i32` (constant 0), each extern method is imported as `env.<name>` with the extern ABI (Int narrowed to i32 as today), `io.f(a)` calls the import with the receiver dropped, entry wrappers pass `i32.const 0` (no `struct.new`)
+e.g. a program with `primitive Io` declaring `extern fun printLn(self, s: Str)` and `fun main(io: Io) = io.printLn("hi")` -> wasm imports `env.printLn`, no Io struct type; running it with the test host prints "hi"
+**Notes:** closures capturing `io` and a generic fn instantiated with an `Io` argument must compile. `Array`/other built-in special paths must not catch `Io`. Today's `struct Io` codegen path stays until T3.
+**Test code:** e2e io_primitive: the e.g. case; a closure capturing io; a test block calling `io.printLn`; existing wasm_codegen + sweep green.
+## Package B: switch
+**Probe entry:** run=plum test plum-std plum-examples
+### T3 rewrite std Io.plum on primitive Io · Complexity 3 · Est. context 40k
+**Owns:** plum-std/**/*.plum, plum-examples/**/*.plum, plum-game/web-test/fixtures/*.plum, README.md
+**Components:** 1
+**LOC owned:** 150
+**Tests:** fast
+**Model:** sonnet
+**Consumes:** with `primitive Io`, an `Io` is wasm `i32` (constant 0), each extern method is imported as `env.<name>` with the extern ABI (Int narrowed to i32 as today), `io.f(a)` calls the import with the receiver dropped, entry wrappers pass `i32.const 0` (no `struct.new`) (T2)
+**Produces:** std/Io.plum is `primitive Io =` with one declaration per host call (plus real-work methods like `randomSeed`); every caller uses `io.x(..)`; wasm import lists unchanged
+e.g. `grep -c '^  extern fun' plum-std/Io.plum` == the number of top-level externs today (50); `grep -c '^extern fun' plum-std/Io.plum` -> 0
+**Notes:** before editing, record every example's and fixture's wasm import list (names + types, e.g. via `wasm-tools print` or wasmparser in a scratch script); after, they must be identical. Methods doing real work over a host call stay ordinary methods. Anything that called a top-level extern directly now calls the method.
+**Test code:** import-list comparison identical; `plum test plum-std plum-examples` green; fixtures compile.
+### T4 delete the old struct-Io paths · Complexity 3 · Est. context 40k
+**Owns:** plum-core/src/*.rs, plum-checker/src/*.rs, plum-wasm-codegen/src/*.rs, plum-lsp/src/*.rs, plum-checker/tests/checker/**/*.rs, plum-wasm-codegen/tests/wasm_codegen/**/*.rs, plum-core/tests/core/*.rs, plum-cli/tests/cli/*.rs
+**Components:** 1
+**LOC owned:** 80
+**Tests:** fast
+**Model:** sonnet
+**Consumes:** std/Io.plum is `primitive Io =` with one declaration per host call (plus real-work methods like `randomSeed`); every caller uses `io.x(..)`; wasm import lists unchanged (T3)
+**Produces:** no `struct Io`/`Item::Enum .. "Io"` code paths, no "needs io" scan, no `isIoFile`, no Io-construction checks
+e.g. `grep -rn 'e.name == "Io"' plum-*/src` -> no hits; `grep -rn isIoFile plum-*/src` -> no hits
+**Notes:** codegen's Io record type/struct.new entry path and class_type_idx lookups for Io go; tests that built a `struct Io` move to `primitive Io`. LSP index entry for Io stays working.
+**Test code:** the greps empty; all binaries + sweep green.
+### T5 verify including browser games · Complexity 2 · Est. context 25k
+**Owns:** docs/plans/2026-11-05-io-primitive.results.md
+**Components:** 1
+**LOC owned:** 30
+**Tests:** slow
+**Model:** sonnet
+**Consumes:** no `struct Io`/`Item::Enum .. "Io"` code paths, no "needs io" scan, no `isIoFile`, no Io-construction checks (T4)
+**Produces:** Io primitive results
+**Notes:** workspace build (zero warnings), every binary, sweep, fixtures; then the browser host: `cargo run --release --manifest-path plum-game/web-test/Cargo.toml -- plum-game/web-test/fixtures/stress_scene.plum --measure 3 --headed --json` and one game from plum-examples/games per style (functional, imperative, pure) runs and draws (frame count > 0, no console errors). Io.plum line count before/after.
+**Test code:** results doc; report red, don't fix.
+## Review Focus
+- A: protocol — import names/signatures unchanged; extern ABI narrowing identical.
+- B: state — closures and generics over `Io`; no built-in path treats `Io` as having a heap value.

docs/plans/2026-11-05-io-primitive.results.md ADDED Viewed

@@ -0,0 +1,74 @@
+# Io primitive: T5 verification results (2026-11-05)
+All green. Nothing was fixed or committed.
+## Build
+`cargo build --workspace --tests`: finished, zero Rust warnings. The only warnings are the two pre-existing C `unused function` warnings from `tree-sitter-plum/src/scanner.c` (`set_raw`, `set_bytes`). `cargo build -p plum-cli` is also clean.
+## Test binaries
+| Binary | Result |
+|---|---|
+| core | 393 passed |
+| checker | 146 passed |
+| cli (includes crash, game_web, host_stub, explain_layout, test_scope modules) | 16 passed |
+| wasm_codegen | 212 passed |
+| driver_tests | 3 passed |
+| plum_lsp (lib) | 20 passed |
+| plum_host (lib) | 3 passed |
+| plum_driver (lib) | 0 tests |
+| plum-game host_test (own target dir) | 18 passed |
+Only the binaries built by this run were counted. A stale `crash_test-*` binary from 16:25 still sits in `target/debug/deps`. It fails `int_literal_overflow_error_has_position`, but `crash_test.rs` is now a module of the `cli` binary, where the same test passes. Ignore it.
+`target/debug/plum test plum-std plum-examples`: 662 passed, 0 failed, 65/65 files.
+`plum compile` on all 9 `plum-game/web-test/fixtures/*.plum` succeeded: interleave, rendertarget, stress_pure_scene, stress_scene, stress_state_view_deep, stress_state_view, stress_world, stress, text_sizes. The outputs were deleted.
+## Browser host
+The headed browser ran fine here with `plumRenderer=gpu-webgpu`. Every run printed PASS with no console errors.
+| Game | Frames in 3s | fps | GPU draw calls |
+|---|---|---|---|
+| stress_scene fixture | 360 | 120 | 1 |
+| functional/game_state_view | 359 | 120 | 7 |
+| imperative/game_scene | 360 | 120 | 7 |
+| pure/game_pure_scene | 359 | 120 | 7 |
+For stress_scene: avg 8.33 ms, p99 9.2 ms, and 464348 pixels changed over 1s.
+## Io.plum size
+Before (79df289): 249 lines. After: 98 lines.
+## `git diff --stat 79df289`
+19 files changed, 336 insertions(+), 374 deletions(-). The stat covers tracked files only.
+```
+ .gitignore                                         |   3 +
+ README.md                                          |   2 +-
+ docs/backlog.md                                    |   5 +
+ plum-checker/src/lib.rs                            |  80 ++----
+ .../tests/checker/features/io_capability.rs        |  22 +-
+ plum-checker/tests/checker/main.rs                 |   1 +
+ plum-core/src/ast.rs                               |  11 +-
+ plum-core/src/drive.rs                             |   4 +-
+ plum-core/src/purity.rs                            |   3 +-
+ plum-core/src/tests_lower.rs                       |   2 +-
+ plum-core/tests/core/drive_test.rs                 |  54 ++--
+ plum-core/tests/core/parser_test.rs                |  14 +
+ plum-core/tests/core/purity_test.rs                |  23 +-
+ plum-game/Cargo.lock                               |   9 +
+ plum-std/Io.plum                                   | 307 ++++++---------------
+ plum-wasm-codegen/src/lib.rs                       |  60 ++--
+ .../tests/wasm_codegen/codegen_tests.rs            |  18 +-
+ .../tests/wasm_codegen/e2e_types/mod.rs            |   1 +
+ .../tests/wasm_codegen/fusion_alloc_test.rs        |  91 ++++++
+```
+Untracked and not in the stat: `plum-checker/tests/checker/io_primitive_tests.rs`, `plum-wasm-codegen/tests/wasm_codegen/e2e_types/io_primitive.rs`, `docs/plans/2026-11-05-io-primitive.md`, `docs/plans/2026-11-05-compiler-cleanup-phase3b.progress.md`, `.claude/`.
+Note: building plum-game updated `plum-game/Cargo.lock` (adds a `plum-driver` package entry). That was a side effect of this verification, not part of the Io change.

plum-checker/src/lib.rs CHANGED Viewed

@@ -1011,67 +1011,40 @@ fn checkSourceFull(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     (result, info)
 }
-/// `file` is std's `Io.plum`, the only place host externs may be called.
-fn isIoFile(file: &str) -> bool {
-    let p = std::path::Path::new(file);
-    p.file_name().and_then(|n| n.to_str()) == Some("Io.plum")
-        && p.parent().and_then(|d| d.file_name()).and_then(|n| n.to_str()) == Some("plum-std")
-}
-/// `file` belongs to the std library tree (`plum-std/...`).
-fn isStdFile(file: &str) -> bool {
-    std::path::Path::new(file)
-        .components()
-        .any(|c| c.as_os_str() == "plum-std")
-}
-/// The `Io` capability rules: an `extern fun` is callable only inside std's `Io.plum`
+/// The `Io` capability rules: no top-level `extern fun`, and the primitive `Io` has no constructor.
-/// and `Io()` is constructed only inside std.
 fn ioCapabilityErrors(source: &ast::Source) -> Vec<CheckError> {
-    let externs: BTreeSet<&str> = source
-        .items
-        .iter()
-        .filter_map(|i| match i {
-            ast::Item::Fn(f) if f.is_extern => Some(f.name.as_str()),
-            _ => None,
-        })
-        .collect();
-    let hasIo = source
-        .items
-        .iter()
-        .any(|i| matches!(i, ast::Item::Enum(e) if e.name == "Io"));
-    let checkExterns = !externs.is_empty();
-    if !checkExterns && !hasIo {
-        return Vec::new();
-    }
     let mut errors = Vec::new();
-    let mut scan = |file: &str, body: &mut ast::FnBody| {
+    // Host calls are declared only as `extern fun` methods on `primitive Io`.
-        let io = isIoFile(file);
+    for item in &source.items {
-        let std = isStdFile(file);
+        if let ast::Item::Fn(f) = item {
-        plum_core::forms::mapExprs(body, &mut |e| match e {
+            if f.is_extern && f.type_param.is_none() {
-            ast::Expr::FnCall(c) if checkExterns && !io && externs.contains(c.name.as_str()) => {
                 errors.push(CheckError::at(
-                    c.line,
+                    f.line,
-                    c.column,
+                    f.column,
-                    format!("{} needs io: call io.{}(..)", c.name, c.name),
+                    "host calls are declared as `extern fun` methods on `primitive Io`".to_string(),
                 ));
             }
+        }
+    }
+    if !source.hasPrimitiveIo() {
+        return errors;
+    }
+    let mut scan = |body: &mut ast::FnBody| {
+        plum_core::forms::mapExprs(body, &mut |e| match e {
-            ast::Expr::FnCall(c) if hasIo && !std && c.name == "Io" => {
+            ast::Expr::FnCall(c) if c.name == ast::IO_TYPE => {
-                errors.push(CheckError::at(c.line, c.column, "Io can only be constructed inside std".to_string()));
+                errors.push(CheckError::at(c.line, c.column, "Io has no constructor".to_string()));
             }
-            ast::Expr::ClassCall(c) if hasIo && !std && c.type_name == "Io" => {
+            ast::Expr::ClassCall(c) if c.type_name == ast::IO_TYPE => {
-                errors.push(CheckError::at(0, 0, "Io can only be constructed inside std".to_string()));
+                errors.push(CheckError::at(0, 0, "Io has no constructor".to_string()));
             }
             _ => {}
         });
     };
     for item in &source.items {
         match item {
-            ast::Item::Fn(f) if !f.is_extern => scan(&f.file, &mut f.body.clone()),
+            ast::Item::Fn(f) if !f.is_extern => scan(&mut f.body.clone()),
-            ast::Item::Test(t) => {
-                scan(&t.file, &mut ast::FnBody::Block(t.body.clone()));
+            ast::Item::Test(t) => scan(&mut ast::FnBody::Block(t.body.clone())),
-            }
-            ast::Item::Const(c) => scan("", &mut ast::FnBody::Expr(c.value.clone())),
+            ast::Item::Const(c) => scan(&mut ast::FnBody::Expr(c.value.clone())),
             _ => {}
         }
     }
@@ -1702,7 +1675,7 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
             let prevFile = (!t.file.is_empty()).then(|| setCurrentFile(&t.file));
             let mut env = global_env.clone();
             // A test may use `io` when std/Io is loaded (the test wrapper passes it).
-            if source.items.iter().any(|i| matches!(i, ast::Item::Enum(e) if e.name == "Io")) {
+            if source.hasPrimitiveIo() {
                 env.insert("io".to_string(), TypeScheme::mono(PlumType::TNamed("Io".to_string())));
             }
             let mut block_errors = checkBlock(
@@ -1974,14 +1947,11 @@ fn checkFnBody(f: &ast::Fn, global_env: &TypeEnv, ctx: &CheckCtx) -> Vec<CheckEr
     // report it plainly rather than trying to guess which side was "right".
     match (f.is_extern, &f.body) {
         (true, ast::FnBody::Extern) => {
-            if f.type_param.is_some() {
+            if f.type_param.as_deref().is_some_and(|t| t != ast::IO_TYPE) {
                 errors.push(CheckError::resolution(
                     f.line,
                     f.column,
-                    format!(
-                        "fn '{}': extern functions can't be methods (no receiver)",
+                    format!("fn '{}': extern methods are only allowed on Io", f.name),
-                        f.name
-                    ),
                 ));
             }
             return errors;

plum-checker/tests/checker/features/io_capability.rs CHANGED Viewed

@@ -1,4 +1,4 @@
-//! The `Io` capability: host externs are callable only through `Io`.
+//! The `Io` capability: the primitive `Io` has no constructor.
 use plum_checker::checkSource;
 fn run(src: &str) -> Result<(), String> {
@@ -8,17 +8,21 @@ fn run(src: &str) -> Result<(), String> {
     r
 }
-const EXTERN: &str = "extern fun printLn(s: Str)\n\nfun hello() =\n  printLn(\"hi\")\n";
+const IO: &str = "primitive Io =\n  extern fun ping(self) -> Int\n\n";
 #[test]
-fn extern_outside_io_rejected() {
+fn io_method_callable_with_an_io() {
-    let e = run(EXTERN).unwrap_err();
-    assert!(e.contains("printLn needs io: call io.printLn(..)"), "{e}");
+    run(&format!("{IO}fun f(io: Io) -> Int =\n  io.ping()\n")).unwrap();
 }
 #[test]
-fn io_constructor_outside_std_rejected() {
+fn io_constructor_rejected() {
-    let src = "struct Io(host: Int) =\n  fun ping(self) -> Int =\n    1\n\nfun f() -> Int =\n  io := Io(host: 0)\n  io.ping()\n";
+    let e = run(&format!("{IO}fun f() -> Int =\n  io := Io()\n  io.ping()\n")).unwrap_err();
-    let e = run(src).unwrap_err();
-    assert!(e.contains("Io can only be constructed inside std"), "{e}");
+    assert!(e.contains("Io has no constructor"), "{e}");
+}
+#[test]
+fn top_level_extern_rejected() {
+    let e = run("extern fun printLn(s: Str)\n\nfun hello() =\n  printLn(\"hi\")\n").unwrap_err();
+    assert!(e.contains("host calls are declared as `extern fun` methods on `primitive Io`"), "{e}");
 }

plum-checker/tests/checker/io_primitive_tests.rs ADDED Viewed

@@ -0,0 +1,39 @@
+#![allow(non_snake_case)]
+//! `primitive Io` with `extern fun f(self, ..)` host methods.
+use plum_checker::checkSource;
+fn run(src: &str) -> Result<(), String> {
+    let mut source = plum_test_support::parseRawSource(src);
+    plum_core::lower::frontEndDiag(&mut source).map_err(|e| format!("lower: {e:?}"))?;
+    checkSource(&source).map_err(|e| e.into_iter().map(|x| x.message).collect::<Vec<_>>().join(" | "))
+}
+const IO: &str = "primitive Io =\n  extern fun printLn(self, s: Str)\n  extern fun width(self) -> Float\n\n";
+#[test]
+fn ioExternMethodsCheckAndTypeAsTheirReturn() {
+    run(&format!("{IO}fun main(io: Io) =\n  io.printLn(\"hi\")\n")).unwrap();
+    run(&format!("{IO}fun w(io: Io) -> Float = io.width()\n")).unwrap();
+    let e = run(&format!("{IO}fun w(io: Io) -> Int = io.width()\n")).unwrap_err();
+    assert!(!e.is_empty());
+}
+#[test]
+fn ioIsUsableInClosuresAndTestBlocks() {
+    run(&format!("{IO}fun main(io: Io) =\n  f := || io.printLn(\"x\")\n  f()\n")).unwrap();
+    run(&format!("{IO}test \"uses io\"\n  io.printLn(\"hi\")\n")).unwrap();
+}
+#[test]
+fn externMethodsAreOnlyAllowedOnIo() {
+    let e = run("struct R(x: Int) =\n  extern fun f(self)\n").unwrap_err();
+    assert!(e.contains("extern methods are only allowed on Io"), "{e}");
+    let e = run("primitive Int =\n  extern fun g(self)\n").unwrap_err();
+    assert!(e.contains("extern methods are only allowed on Io"), "{e}");
+}
+#[test]
+fn ioHasNoConstructor() {
+    let e = run(&format!("{IO}fun main() =\n  io := Io()\n  io.printLn(\"x\")\n")).unwrap_err();
+    assert!(e.contains("Io has no constructor"), "{e}");
+}

plum-checker/tests/checker/main.rs CHANGED Viewed

@@ -3,6 +3,7 @@
 mod checker_tests;
 mod closure_hint_test;
 mod diagnostic_tests;
+mod io_primitive_tests;
 mod explicit_generics_tests;
 mod features;
 mod fusion_pipeline_test;

plum-core/src/ast.rs CHANGED Viewed

@@ -32,7 +32,11 @@ pub struct PrimitiveDecl {
 }
 /// Compiler built-in types whose API a `primitive` block declares (std only).
-pub const BUILTIN_PRIMITIVES: [&str; 6] = ["Int", "Float", "Bool", "Str", "Byte", "Array"];
+pub const BUILTIN_PRIMITIVES: [&str; 7] = ["Int", "Float", "Bool", "Str", "Byte", "Array", "Io"];
+/// The host capability type. Its host calls are `extern fun f(self, ..)` methods of
+/// `primitive Io =` (std/Io.plum); extern methods are allowed nowhere else.
+pub const IO_TYPE: &str = "Io";
 /// Separator of an associated item's mangled global name: `Float.Pi`.
 pub const MEMBER_SEP: &str = ".";
@@ -45,6 +49,11 @@ pub enum TopLevelKind {
 }
 impl Source {
+    /// Whether the program declares the primitive `Io` (some `extern fun` method of it).
+    pub fn hasPrimitiveIo(&self) -> bool {
+        self.items.iter().any(|i| matches!(i, Item::Fn(f) if f.is_extern && f.type_param.as_deref() == Some(IO_TYPE)))
+    }
     /// Records `file` on the source and on every fn it declares.
     pub fn stampFile(&mut self, file: &str) {
         self.file = file.to_string();

plum-core/src/drive.rs CHANGED Viewed

@@ -1779,7 +1779,9 @@ impl Driver {
                 _ => None,
             };
             let Some((p, v)) = cand else { continue };
+            // the whole value is pure: a pure call under an impure one (`sumL(markL(io, build(n)))`)
+            // must not move past a host call
-            let isProducer = self.calls(&v).iter().any(|c| self.pure.contains(&c.key));
+            let isProducer = self.calls(&v).iter().any(|c| self.pure.contains(&c.key)) && self.argPure(&v);
             // a just-built value with pure fields moves to its use like a pure producer call,
             // so a consumer applied to it can pick its arm (`layers := Cons(..); draw(layers)`)
             let isBuilt = self.ctorType(&v).is_some() && self.argPure(&v);

plum-core/src/purity.rs CHANGED Viewed

@@ -168,7 +168,8 @@ pub fn readOnlyFns(src: &Source) -> HashSet<String> {
         }
         let mut info = analyse(f, &ctors);
         info.impure = if f.is_extern || matches!(f.body, FnBody::Extern) {
+            // `self` of a primitive `Io` extern method is the unit-like capability, not an object
-            f.has_self
+            (f.has_self && f.type_param.as_deref() != Some(crate::ast::IO_TYPE))
                 || !f.params.iter().all(|p| match &p.ty {
                     ParamType::Type(t) => t.generics.is_empty() && values.contains(t.name.as_str()),
                     _ => false,

plum-core/src/tests_lower.rs CHANGED Viewed

@@ -67,7 +67,7 @@ fn desugarTestsToFns(source: &crate::ast::Source) -> (crate::ast::Source, Vec<(S
     let mut test_idx = 0usize;
     let mut counter = 0usize;
     // Tests may use `io` when std/Io is loaded: the export wrapper passes the `Io`.
-    let hasIo = source.items.iter().any(|it| matches!(it, crate::ast::Item::Enum(c) if c.name == "Io"));
+    let hasIo = source.hasPrimitiveIo();
     let ioParam = if hasIo {
         vec![crate::ast::Param {
             name: "io".to_string(),

plum-core/tests/core/drive_test.rs CHANGED Viewed

@@ -157,14 +157,15 @@ fn sharedResultUnchanged() {
 #[test]
 fn impure_producer_untouched() {
     let (s, _) = run(
+        "primitive Io =
-        "extern fun tick(x: Int) -> Int
+  extern fun tick(self, x: Int) -> Int
-fun mapI(xs: Lst) -> Lst = match xs
+fun mapI(io: Io, xs: Lst) -> Lst = match xs
   Nil => Nil
-  Cons(h, t) => Cons(head: tick(h), tail: mapI(t))
+  Cons(h, t) => Cons(head: io.tick(h), tail: mapI(io, t))
 fun sumL(xs: Lst) -> Int = match xs
   Nil => 0
   Cons(h, t) => h + sumL(t)
-fun total(xs: Lst) -> Int = sumL(mapI(xs))
+fun total(io: Io, xs: Lst) -> Int = sumL(mapI(io, xs))
 ",
     );
     assert!(fusedNames(&s).is_empty());
@@ -343,13 +344,14 @@ fn impureConsumerFusesWithPureProducer() {
     // Only the producer must be pure: the consumer's effects interleave with the producer's
     // (pure, unobservable) steps.
     let (s, notes) = run(&format!(
+        "primitive Io =
-        "extern fun emit(x: Int)
+  extern fun emit(self, x: Int)
-{MAP_SUM}fun drawL(xs: Lst) -> Int = match xs
+{MAP_SUM}fun drawL(io: Io, xs: Lst) -> Int = match xs
   Nil => 0
   Cons(h, t) =>
-    emit(h)
+    io.emit(h)
-    drawL(t)
+    drawL(io, t)
-fun go(xs: Lst) -> Int = drawL(mapL(xs))
+fun go(io: Io, xs: Lst) -> Int = drawL(io, mapL(xs))
 "
     ));
     let f = getFn(&s, "drawL$mapL$0").unwrap_or_else(|| panic!("{notes:?}"));
@@ -361,14 +363,15 @@ fun go(xs: Lst) -> Int = drawL(mapL(xs))
 #[test]
 fn impureProducerIsExplained() {
     let (_, notes) = run(
+        "primitive Io =
-        "extern fun tick(x: Int) -> Int
+  extern fun tick(self, x: Int) -> Int
-fun mapI(xs: Lst) -> Lst = match xs
+fun mapI(io: Io, xs: Lst) -> Lst = match xs
   Nil => Nil
-  Cons(h, t) => Cons(head: tick(h), tail: mapI(t))
+  Cons(h, t) => Cons(head: io.tick(h), tail: mapI(io, t))
 fun sumL(xs: Lst) -> Int = match xs
   Nil => 0
   Cons(h, t) => h + sumL(t)
-fun total(xs: Lst) -> Int = sumL(mapI(xs))
+fun total(io: Io, xs: Lst) -> Int = sumL(mapI(io, xs))
 ",
     );
     assert!(notes.iter().any(|n| n.starts_with("impure producer") && n.contains("mapI")), "{notes:?}");
@@ -381,18 +384,19 @@ fn wrapperAndViewUnfoldToNoNodes() {
         "enum Node =
   | Leaf(v: Int)
   | Pair(l: Node, r: Node)
+primitive Io =
-extern fun emit(x: Int)
+  extern fun emit(self, x: Int)
-fun drawN(n: Node, k: Int) = match n
+fun drawN(io: Io, n: Node, k: Int) = match n
-  Leaf(v) => emit(v + k)
+  Leaf(v) => io.emit(v + k)
   Pair(l, r) =>
-    drawN(l, k)
+    drawN(io, l, k)
-    drawN(r, k)
+    drawN(io, r, k)
 primitive Pic =
-  fun draw(n: Node) =
+  fun draw(io: Io, n: Node) =
-    drawN(n, 0)
+    drawN(io, n, 0)
 fun view(x: Int) -> Node = if x < 0 then Leaf(v: 0) else Pair(l: Leaf(v: x), r: Pair(l: Leaf(v: x + 1), r: Leaf(v: x + 2)))
-fun frame(x: Int) =
+fun frame(io: Io, x: Int) =
-  Pic.draw(view(x))
+  Pic.draw(io, view(x))
 ",
     );
     let name = fusedNames(&s).into_iter().find(|n| n.starts_with("drawN$view")).unwrap_or_else(|| panic!("{notes:?}"));
@@ -423,10 +427,8 @@ fun total(xs: Lst) -> Int = sumL(mapB(xs))
 // migration and the component rewrite. Shapes: a consumer with an extra `Io` argument whose
 // method shares its name with a mutating method of another type, and children built by
 // a generic `map`-like producer whose elements call same-named methods of several types.
-const IO_DRAW: &str = "extern fun hostClear(c: Int)
+const IO_DRAW: &str = "primitive Io =
-struct Io =
-  fun clear(self, c: Int) =
+  extern fun clear(self, c: Int)
-    hostClear(c)
 struct Buf(mut n: Int) =
   fun clear(self) =
     self.n = 0

plum-core/tests/core/parser_test.rs CHANGED Viewed

@@ -950,3 +950,17 @@ fn singleLetterTypeArgument() {
     assert_eq!(t.generics.len(), 1);
     assert_eq!(t.generics[0].name, "P");
 }
+#[test]
+fn primitive_io_keeps_its_extern_methods() {
+    let s = parse("primitive Io =\n  extern fun printLn(self, s: Str)\n  extern fun width(self) -> Float\n");
+    let fns: Vec<&Fn> = s
+        .items
+        .iter()
+        .filter_map(|i| if let Item::Fn(f) = i { Some(f) } else { None })
+        .collect();
+    assert_eq!(fns.len(), 2);
+    assert!(fns.iter().all(|f| f.is_extern && f.has_self && f.type_param.as_deref() == Some("Io")));
+    assert!(matches!(fns[0].body, FnBody::Extern));
+    assert!(s.hasPrimitiveIo());
+}

plum-core/tests/core/purity_test.rs CHANGED Viewed

@@ -15,11 +15,11 @@ fn set(xs: &[&str]) -> HashSet<String> {
     xs.iter().map(|s| s.to_string()).collect()
 }
-const P: &str = "struct Pt(x: Int)\nextern fun printLn(s: Str)\n";
+const P: &str = "struct Pt(x: Int)\nprimitive Io =\n  extern fun printLn(self, s: Str)\n";
 #[test]
 fn extern_impure_and_callers_of_pure() {
-    let s = format!("{P}fun a() = printLn(\"x\")\nfun b() -> Int = 1\nfun c() -> Int = b()\n");
+    let s = format!("{P}fun a(io: Io) = io.printLn(\"x\")\nfun b() -> Int = 1\nfun c() -> Int = b()\n");
     assert_eq!(pure(&s), set(&["b", "c"]));
 }
@@ -45,20 +45,20 @@ fn recursive_pure_fn_is_pure() {
 fn mutual_recursion_pure_and_impure() {
     let s = format!(
         "{P}fun a(n: Int) -> Int = if n < 1 then 0 else b(n - 1)\nfun b(n: Int) -> Int = a(n - 1)\n\
-         fun c(n: Int) -> Int = if n < 1 then 0 else d(n - 1)\nfun d(n: Int) -> Int =\n  printLn(\"x\")\n  c(n - 1)\n"
+         fun c(n: Int, io: Io) -> Int = if n < 1 then 0 else d(n - 1, io)\nfun d(n: Int, io: Io) -> Int =\n  io.printLn(\"x\")\n  c(n - 1, io)\n"
     );
     assert_eq!(pure(&s), set(&["a", "b"]));
 }
 #[test]
 fn calls_impure_is_impure_transitively() {
-    let s = format!("{P}fun a() = printLn(\"x\")\nfun b() = a()\nfun c() = b()\nfun d() -> Int = 2\n");
+    let s = format!("{P}fun a(io: Io) = io.printLn(\"x\")\nfun b(io: Io) = a(io)\nfun c(io: Io) = b(io)\nfun d() -> Int = 2\n");
     assert_eq!(pure(&s), set(&["d"]));
 }
 #[test]
 fn closure_literal_body_counts() {
-    let s = format!("{P}fun a() =\n  f := |x: Int| printLn(\"x\")\n  1\nfun b() =\n  f := |x: Int| x + 1\n  1\n");
+    let s = format!("{P}fun a(io: Io) =\n  f := |x: Int| io.printLn(\"x\")\n  1\nfun b() =\n  f := |x: Int| x + 1\n  1\n");
     assert_eq!(pure(&s), set(&["b"]));
 }
@@ -73,7 +73,7 @@ fn unknown_callee_impure() {
     assert!(pure("fun a() -> Int = nope()\n").is_empty());
 }
-const IO: &str = "struct Io =\n  fun ping(self) = 1\nstruct World(io: Io, n: Int)\nstruct Pt2(x: Int)\n";
+const IO: &str = "primitive Io =\n  extern fun ping(self) -> Int\nstruct World(io: Io, n: Int)\nstruct Pt2(x: Int)\n";
 #[test]
 fn io_param_impure_view_pure() {
@@ -104,7 +104,7 @@ fn closure_capturing_io_impure() {
 #[test]
 fn virtual_call_through_base_is_impure() {
     let s = format!(
-        "{P}struct Actor(w: Int) =\n  fun go(self) -> Int = 1\n\nstruct Ship(Actor(w), t: Int) =\n  override fun go(self) -> Int =\n    printLn(\"x\")\n    2\n\nfun run(a: Actor) -> Int = a.go()\nfun leaf(s: Ship) -> Int = s.go()\nfun plain(a: Actor) -> Int = a.w\n"
+        "{P}struct Actor(w: Int) =\n  fun go(self, io: Io) -> Int = 1\n\nstruct Ship(Actor(w), t: Int) =\n  override fun go(self, io: Io) -> Int =\n    io.printLn(\"x\")\n    2\n\nfun run(a: Actor, io: Io) -> Int = a.go(io)\nfun leaf(s: Ship, io: Io) -> Int = s.go(io)\nfun plain(a: Actor) -> Int = a.w\n"
     );
     let p = pure(&s);
     assert!(!p.contains("Actor.go"), "{p:?}");
@@ -118,3 +118,12 @@ fn nonvirtual_method_stays_pure() {
     let p = pure(&s);
     assert!(p.contains("Actor.go") && p.contains("run"), "{p:?}");
 }
+#[test]
+fn fn_taking_primitive_io_is_not_pure() {
+    let src = "primitive Io =\n  extern fun mark(self, n: Int)\n\nfun touch(io: Io) =\n  io.mark(1)\n\nfun plus(a: Int, b: Int) -> Int = a + b\n";
+    let source = plum_test_support::parseRawSource(src);
+    let pure = plum_core::purity::pureFns(&source);
+    assert!(!pure.contains("touch"), "{pure:?}");
+    assert!(pure.contains("plus"), "{pure:?}");
+}

plum-std/Io.plum CHANGED Viewed

@@ -7,243 +7,92 @@ import std/game/Vec2
 import std/game/Color
 # The host capability. Every call that leaves the program (drawing, input, sound,
-# files, environment, clock, randomness, network) is a method of `Io`; the
+# files, environment, clock, randomness, network) is a method of `Io`. `Io` is a
-# `extern fun` host imports are declared here and nowhere else. `Io` has no fields
+# built-in primitive with no fields; the host calls are the `extern fun` methods
-# and is built only inside std (the host entry points pass the singleton), so a
+# below and nowhere else. The host entry points pass the one `Io` value, so a
 # function with no `Io` reachable cannot touch the host: that is what "pure" means.
 #
 # Texture and sound handles are -1 on failure. File, texture and sound paths are
 # relative to the asset root. `Int` in an extern signature is narrowed to i32 at the
 # host boundary, so wall-clock time travels as `Float`.
-extern fun screenWidth() -> Float
-extern fun screenHeight() -> Float
-extern fun frameTime() -> Float
-extern fun clear(c: Color)
-extern fun drawRect(x: Float, y: Float, w: Float, h: Float, c: Color)
-extern fun drawCircle(x: Float, y: Float, r: Float, c: Color)
-extern fun drawLine(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, c: Color)
-extern fun drawText(s: Str, x: Float, y: Float, size: Float, c: Color)
-extern fun setCamera(x: Float, y: Float, scale: Float)
-extern fun resetCamera()
-# Loads any image the host decodes (PNG at least); -1 on failure.
-extern fun textureLoad(path: Str) -> Int
-# Size in pixels; 0 for a bad handle.
-extern fun textureWidth(t: Int) -> Int
-extern fun textureHeight(t: Int) -> Int
-# Linear (true) or nearest (false, the default) filtering.
-extern fun textureSetSmooth(t: Int, smooth: Bool)
-# A blank, transparent texture of w x h pixels that can be drawn into with
-# `renderTarget`; -1 if a side is below 1 or above 8192.
-extern fun textureCreate(w: Int, h: Int) -> Int
-# Sends the following draws (and `clear`) into texture `t` made by `textureCreate`,
-# or back to the screen with -1; any other handle is ignored. Each target has its
-# own camera: selecting a target resets its camera to its pixels, and returning to
-# the screen restores the screen's camera. The texture's contents persist between
-# frames; draw it like any texture once the screen is selected again.
-extern fun renderTarget(t: Int)
-# The blend mode of the following draws: a `Blend` constant (other values are
-# ignored). Every frame starts with `Blend.Normal`.
-extern fun blendMode(m: Int)
-# The texture at its natural size, top-left at (x, y).
-extern fun drawTexture(t: Int, x: Float, y: Float, tint: Color)
-# The source rect (sx, sy, sw, sh) in texture pixels drawn into the dest rect
-# (x, y, w, h), rotated `rotation` radians clockwise about the dest centre.
-extern fun drawTextureEx(t: Int, sx: Float, sy: Float, sw: Float, sh: Float, x: Float, y: Float, w: Float, h: Float, rotation: Float, flipX: Bool, tint: Color)
-extern fun fileExists(path: Str) -> Bool
-# The whole file; "" if it is missing.
-extern fun fileLoad(path: Str) -> Str
-# Loads a WAV or OGG file relative to the asset root; -1 on failure. The host
-# decodes every sound file in the asset root before `init` runs.
-extern fun soundLoad(path: Str) -> Int
-# A one-shot play; plays of the same sound may overlap. Volume is 0..1.
-extern fun soundPlay(s: Int, volume: Float)
-# Starts the sound looping. Call `soundStop` first to restart it cleanly.
-extern fun soundLoop(s: Int, volume: Float)
-# Stops every play and loop of the sound.
-extern fun soundStop(s: Int)
-# Changes the volume of a sound that is playing or looping.
-extern fun soundSetVolume(s: Int, volume: Float)
-extern fun isKeyDown(k: Int) -> Bool
-extern fun isKeyPressed(k: Int) -> Bool
-extern fun mousePos() -> Vec2
-extern fun isMouseDown(b: Int) -> Bool
-extern fun isMousePressed(b: Int) -> Bool
-extern fun mouseWheel() -> Float
-extern fun printLn(s: Str)
-extern fun rawReadFile(path: Str) -> Str
-extern fun rawWriteFile(path: Str, data: Str) -> Int
-extern fun rawExists(path: Str) -> Int
-extern fun rawMkdir(path: Str) -> Int
-extern fun rawRemove(path: Str) -> Int
-extern fun rawRemoveDir(path: Str) -> Int
-extern fun rawRename(old_path: Str, new_path: Str) -> Int
-extern fun rawTruncate(path: Str, len: Int) -> Int
-extern fun rawLink(existing_path: Str, new_path: Str) -> Int
-extern fun rawSymlink(target: Str, path: Str) -> Int
-extern fun rawReadlink(path: Str) -> Str
-extern fun rawRealpath(path: Str) -> Str
-extern fun rawChmod(path: Str, mode: Int) -> Int
-extern fun rawReadDir(path: Str) -> Str
-extern fun rawNowMillis() -> Float
-extern fun rawRandomHalf() -> Int
-extern fun rawHttpRequest(method: Str, url: Str, headers: Str, body: Str) -> Str
-struct Io =
-  fun screenWidth(self) -> Float =
-    screenWidth()
-  fun screenHeight(self) -> Float =
-    screenHeight()
-  fun frameTime(self) -> Float =
-    frameTime()
-  fun clear(self, c: Color) =
-    clear(c)
-  fun drawRect(self, x: Float, y: Float, w: Float, h: Float, c: Color) =
-    drawRect(x, y, w, h, c)
-  fun drawCircle(self, x: Float, y: Float, r: Float, c: Color) =
-    drawCircle(x, y, r, c)
-  fun drawLine(self, x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, c: Color) =
-    drawLine(x1, y1, x2, y2, thickness, c)
-  fun drawText(self, s: Str, x: Float, y: Float, size: Float, c: Color) =
-    drawText(s, x, y, size, c)
-  fun setCamera(self, x: Float, y: Float, scale: Float) =
-    setCamera(x, y, scale)
-  fun resetCamera(self) =
-    resetCamera()
-  fun textureLoad(self, path: Str) -> Int =
-    textureLoad(path)
-  fun textureWidth(self, t: Int) -> Int =
-    textureWidth(t)
-  fun textureHeight(self, t: Int) -> Int =
-    textureHeight(t)
-  fun textureSetSmooth(self, t: Int, smooth: Bool) =
-    textureSetSmooth(t, smooth)
-  fun textureCreate(self, w: Int, h: Int) -> Int =
-    textureCreate(w, h)
-  fun renderTarget(self, t: Int) =
-    renderTarget(t)
-  fun blendMode(self, m: Int) =
-    blendMode(m)
-  fun drawTexture(self, t: Int, x: Float, y: Float, tint: Color) =
-    drawTexture(t, x, y, tint)
-  fun drawTextureEx(self, t: Int, sx: Float, sy: Float, sw: Float, sh: Float, x: Float, y: Float, w: Float, h: Float, rotation: Float, flipX: Bool, tint: Color) =
-    drawTextureEx(t, sx, sy, sw, sh, x, y, w, h, rotation, flipX, tint)
-  fun fileExists(self, path: Str) -> Bool =
-    fileExists(path)
-  fun fileLoad(self, path: Str) -> Str =
-    fileLoad(path)
-  fun soundLoad(self, path: Str) -> Int =
-    soundLoad(path)
-  fun soundPlay(self, s: Int, volume: Float) =
-    soundPlay(s, volume)
-  fun soundLoop(self, s: Int, volume: Float) =
-    soundLoop(s, volume)
-  fun soundStop(self, s: Int) =
-    soundStop(s)
-  fun soundSetVolume(self, s: Int, volume: Float) =
-    soundSetVolume(s, volume)
-  fun isKeyDown(self, k: Int) -> Bool =
-    isKeyDown(k)
-  fun isKeyPressed(self, k: Int) -> Bool =
-    isKeyPressed(k)
-  fun mousePos(self) -> Vec2 =
-    mousePos()
-  fun isMouseDown(self, b: Int) -> Bool =
-    isMouseDown(b)
-  fun isMousePressed(self, b: Int) -> Bool =
-    isMousePressed(b)
-  fun mouseWheel(self) -> Float =
-    mouseWheel()
-  fun printLn(self, s: Str) =
-    printLn(s)
-  fun rawReadFile(self, path: Str) -> Str =
-    rawReadFile(path)
-  fun rawWriteFile(self, path: Str, data: Str) -> Int =
-    rawWriteFile(path, data)
-  fun rawExists(self, path: Str) -> Int =
-    rawExists(path)
-  fun rawMkdir(self, path: Str) -> Int =
-    rawMkdir(path)
-  fun rawRemove(self, path: Str) -> Int =
-    rawRemove(path)
-  fun rawRemoveDir(self, path: Str) -> Int =
-    rawRemoveDir(path)
-  fun rawRename(self, old_path: Str, new_path: Str) -> Int =
-    rawRename(old_path, new_path)
-  fun rawTruncate(self, path: Str, len: Int) -> Int =
-    rawTruncate(path, len)
-  fun rawLink(self, existing_path: Str, new_path: Str) -> Int =
-    rawLink(existing_path, new_path)
-  fun rawSymlink(self, target: Str, path: Str) -> Int =
-    rawSymlink(target, path)
-  fun rawReadlink(self, path: Str) -> Str =
-    rawReadlink(path)
-  fun rawRealpath(self, path: Str) -> Str =
-    rawRealpath(path)
-  fun rawChmod(self, path: Str, mode: Int) -> Int =
-    rawChmod(path, mode)
-  fun rawReadDir(self, path: Str) -> Str =
-    rawReadDir(path)
-  fun rawNowMillis(self) -> Float =
-    rawNowMillis()
-  fun rawRandomHalf(self) -> Int =
-    rawRandomHalf()
+primitive Io =
+  extern fun screenWidth(self) -> Float
+  extern fun screenHeight(self) -> Float
+  extern fun frameTime(self) -> Float
+  extern fun clear(self, c: Color)
+  extern fun drawRect(self, x: Float, y: Float, w: Float, h: Float, c: Color)
+  extern fun drawCircle(self, x: Float, y: Float, r: Float, c: Color)
+  extern fun drawLine(self, x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, c: Color)
+  extern fun drawText(self, s: Str, x: Float, y: Float, size: Float, c: Color)
+  extern fun setCamera(self, x: Float, y: Float, scale: Float)
+  extern fun resetCamera(self)
+  # Loads any image the host decodes (PNG at least); -1 on failure.
+  extern fun textureLoad(self, path: Str) -> Int
+  # Size in pixels; 0 for a bad handle.
+  extern fun textureWidth(self, t: Int) -> Int
+  extern fun textureHeight(self, t: Int) -> Int
+  # Linear (true) or nearest (false, the default) filtering.
+  extern fun textureSetSmooth(self, t: Int, smooth: Bool)
+  # A blank, transparent texture of w x h pixels that can be drawn into with
+  # `renderTarget`; -1 if a side is below 1 or above 8192.
+  extern fun textureCreate(self, w: Int, h: Int) -> Int
+  # Sends the following draws (and `clear`) into texture `t` made by `textureCreate`,
+  # or back to the screen with -1; any other handle is ignored. Each target has its
+  # own camera: selecting a target resets its camera to its pixels, and returning to
+  # the screen restores the screen's camera. The texture's contents persist between
+  # frames; draw it like any texture once the screen is selected again.
+  extern fun renderTarget(self, t: Int)
+  # The blend mode of the following draws: a `Blend` constant (other values are
+  # ignored). Every frame starts with `Blend.Normal`.
+  extern fun blendMode(self, m: Int)
+  # The texture at its natural size, top-left at (x, y).
+  extern fun drawTexture(self, t: Int, x: Float, y: Float, tint: Color)
+  # The source rect (sx, sy, sw, sh) in texture pixels drawn into the dest rect
+  # (x, y, w, h), rotated `rotation` radians clockwise about the dest centre.
+  extern fun drawTextureEx(self, t: Int, sx: Float, sy: Float, sw: Float, sh: Float, x: Float, y: Float, w: Float, h: Float, rotation: Float, flipX: Bool, tint: Color)
+  extern fun fileExists(self, path: Str) -> Bool
+  # The whole file; "" if it is missing.
+  extern fun fileLoad(self, path: Str) -> Str
+  # Loads a WAV or OGG file relative to the asset root; -1 on failure. The host
+  # decodes every sound file in the asset root before `init` runs.
+  extern fun soundLoad(self, path: Str) -> Int
+  # A one-shot play; plays of the same sound may overlap. Volume is 0..1.
+  extern fun soundPlay(self, s: Int, volume: Float)
+  # Starts the sound looping. Call `soundStop` first to restart it cleanly.
+  extern fun soundLoop(self, s: Int, volume: Float)
+  # Stops every play and loop of the sound.
+  extern fun soundStop(self, s: Int)
+  # Changes the volume of a sound that is playing or looping.
+  extern fun soundSetVolume(self, s: Int, volume: Float)
+  extern fun isKeyDown(self, k: Int) -> Bool
+  extern fun isKeyPressed(self, k: Int) -> Bool
+  extern fun mousePos(self) -> Vec2
+  extern fun isMouseDown(self, b: Int) -> Bool
+  extern fun isMousePressed(self, b: Int) -> Bool
+  extern fun mouseWheel(self) -> Float
+  extern fun printLn(self, s: Str)
+  extern fun rawReadFile(self, path: Str) -> Str
+  extern fun rawWriteFile(self, path: Str, data: Str) -> Int
+  extern fun rawExists(self, path: Str) -> Int
+  extern fun rawMkdir(self, path: Str) -> Int
+  extern fun rawRemove(self, path: Str) -> Int
+  extern fun rawRemoveDir(self, path: Str) -> Int
+  extern fun rawRename(self, old_path: Str, new_path: Str) -> Int
+  extern fun rawTruncate(self, path: Str, len: Int) -> Int
+  extern fun rawLink(self, existing_path: Str, new_path: Str) -> Int
+  extern fun rawSymlink(self, target: Str, path: Str) -> Int
+  extern fun rawReadlink(self, path: Str) -> Str
+  extern fun rawRealpath(self, path: Str) -> Str
+  extern fun rawChmod(self, path: Str, mode: Int) -> Int
+  extern fun rawReadDir(self, path: Str) -> Str
+  extern fun rawNowMillis(self) -> Float
+  extern fun rawRandomHalf(self) -> Int
+  extern fun rawHttpRequest(self, method: Str, url: Str, headers: Str, body: Str) -> Str
   # A wall-clock 64-bit seed for `Random.seeded` (two host i32 halves; `Int` is
   # narrowed to i32 at the extern boundary).
   fun randomSeed(self) -> Int =
-    hi := rawRandomHalf()
+    hi := self.rawRandomHalf()
-    lo := rawRandomHalf() & 0xFFFFFFFF
+    lo := self.rawRandomHalf() & 0xFFFFFFFF
     return { hi << 32 } | lo
-  fun rawHttpRequest(self, method: Str, url: Str, headers: Str, body: Str) -> Str =
-    rawHttpRequest(method, url, headers, body)

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -771,17 +771,6 @@ fn errScratch(expr: &ast::Expr) -> String {
     format!("errtmp#{}", expr as *const ast::Expr as usize)
 }
-/// The wasm leaf zero for an "undefined" value slot.
-fn emitZeroLeaf(vt: ValType, body: &mut Vec<u8>) {
-    pushSelfPlaceholder(vt, body);
-}
-fn emitZeros(ty: &PlumType, body: &mut Vec<u8>) {
-    for vt in flatValtypes(ty, &gcTypes()) {
-        emitZeroLeaf(vt, body);
-    }
-}
 fn valueFieldsOf(ty: &PlumType) -> Option<Vec<(String, PlumType)>> {
     match ty {
         PlumType::TNamed(n) => withGen(|s| s.value_enums.get(n).cloned()),
@@ -1016,6 +1005,14 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
         PlumType::TFloat => ValType::F64,
         PlumType::TBool => ValType::I32,
         PlumType::TByte => ValType::I32,
+        // The primitive `Io` (no struct of that name): an i32 constant 0.
+        PlumType::TNamed(name)
+            if name == ast::IO_TYPE
+                && !registry.class_type_idx.contains_key(name)
+                && !registry.enum_super_type_idx.contains_key(name) =>
+        {
+            ValType::I32
+        }
         PlumType::TNamed(name) => match registry
             .class_type_idx
             .get(name)
@@ -1792,13 +1789,10 @@ fn entryTakesIo(f: &ast::Fn) -> bool {
         && matches!(&p.ty, ast::ParamType::Type(t) if t.name == "Io" && t.generics.is_empty()))
 }
-/// Host-facing wrapper for an entry point: drops the leading `io: Io` param (building
-/// the `Io` record and passing it) and optionally narrows `Int` to i32 (the `extern fun` ABI).
+/// Host-facing wrapper for an entry point: drops the leading `io: Io` param (passing the `Io` constant 0) and optionally narrows `Int` to i32 (the `extern fun` ABI).
 #[allow(clippy::too_many_arguments)]
 fn emitEntryWrapper(
     module: &mut WasmModule,
-    ctx: &CompileCtx,
-    enum_variants: &EnumVariants,
     name: &str,
     idx: u32,
     sig: &FuncSig,
@@ -1822,12 +1816,8 @@ fn emitEntryWrapper(
         b.push(0);
     }
     if io {
-        let io_idx = *ctx.gc_types.class_type_idx.get("Io").expect("Io record type");
-        let info = enum_variants.get("Io").expect("Io record info");
+        // The primitive `Io` is the i32 constant 0.
-        for ty in plum_checker::variantFields(info, &PlumType::TNamed("Io".to_string())) {
-            emitZeros(&ty, &mut b);
-        }
-        Instruction::StructNew(io_idx).encode(&mut b);
+        Instruction::I32Const(0).encode(&mut b);
     }
     for (i, vt) in hostParams.iter().enumerate() {
         Instruction::LocalGet(i as u32).encode(&mut b);
@@ -2110,25 +2100,32 @@ fn compileSourceInner(
     // Register every `extern fun` as a genuine wasm import BEFORE any function.
     let mut func_ids: HashMap<String, u32> = HashMap::new();
     let mut func_sigs: HashMap<String, FuncSig> = HashMap::new();
+    // (key, import index, wrapper params, results, leading receiver params the host import lacks)
-    let mut extern_wrappers: Vec<(String, u32, Vec<ValType>, Vec<ValType>)> = Vec::new();
+    let mut extern_wrappers: Vec<(String, u32, Vec<ValType>, Vec<ValType>, usize)> = Vec::new();
     for item in &source.items {
         if let ast::Item::Fn(f) = item {
             if !f.is_extern {
                 continue;
             }
+            // An extern METHOD (of the primitive `Io`) takes its receiver as the first
+            // wrapper param; the host import has no receiver.
+            let skip = usize::from(f.type_param.is_some() && f.has_self);
+            let key = if f.type_param.is_some() { fnKey(f) } else { f.name.clone() };
+            if f.type_param.is_none() {
-            known_fns.insert(f.name.clone());
+                known_fns.insert(f.name.clone());
+            }
             let sig = unitFuncSig(f, &Subst::new(), &eg, &gc_types);
             let param_types = sig.params.clone();
             let ret = sig.ret.clone();
             // `Int` in an extern signature is narrowed to wasm i32 at the host boundary.
             let narrow = |v: &ValType| if *v == ValType::I64 { ValType::I32 } else { *v };
-            let imp_params: Vec<ValType> = param_types.iter().map(narrow).collect();
+            let imp_params: Vec<ValType> = param_types[skip..].iter().map(narrow).collect();
             let imp_results: Vec<ValType> = ret.iter().map(narrow).collect();
             let type_idx = module.addType(&imp_params, &imp_results);
             let func_idx = module.addImport("plum", &f.name, type_idx);
-            extern_wrappers.push((f.name.clone(), func_idx, param_types, ret));
+            extern_wrappers.push((key.clone(), func_idx, param_types, ret, skip));
             func_sigs.insert(
-                f.name.clone(),
+                key,
                 FuncSig {
                     param_defaults: Vec::new(),
                     ..sig
@@ -2149,7 +2146,8 @@ fn compileSourceInner(
     }
     // Extern `Int` narrowing wrappers.
-    for (name, imp_idx, params, ret) in &extern_wrappers {
+    for (name, imp_idx, params, ret, skip) in &extern_wrappers {
+        let skip = *skip;
         let mut b: Vec<u8> = Vec::new();
         // With several results, the narrowed ones are parked in locals so each can be
         // widened individually.
@@ -2169,7 +2167,7 @@ fn compileSourceInner(
         } else {
             b.push(0);
         }
-        for (i, vt) in params.iter().enumerate() {
+        for (i, vt) in params.iter().enumerate().skip(skip) {
             if *vt == ValType::I64 {
                 Instruction::LocalGet(i as u32).encode(&mut b);
                 Instruction::LocalGet(i as u32).encode(&mut b);
@@ -2181,7 +2179,7 @@ fn compileSourceInner(
                 Instruction::End.encode(&mut b);
             }
         }
-        for (i, vt) in params.iter().enumerate() {
+        for (i, vt) in params.iter().enumerate().skip(skip) {
             Instruction::LocalGet(i as u32).encode(&mut b);
             if *vt == ValType::I64 {
                 Instruction::I32WrapI64.encode(&mut b);
@@ -2671,7 +2669,7 @@ fn compileSourceInner(
             continue;
         }
         let sig = ctx.func_sigs.get(&fnKey(f)).expect("entry fn has a signature");
-        let w = emitEntryWrapper(&mut module, &ctx, &ctx.enum_variants, &f.name, idx, sig, narrowInts, takesIo(f));
+        let w = emitEntryWrapper(&mut module, &f.name, idx, sig, narrowInts, takesIo(f));
         module.addExport(&name, ExportKind::Func, w);
     }
@@ -2754,7 +2752,7 @@ fn compileSourceInner(
         if io {
             let f = source.items.iter().find_map(|it| match it { ast::Item::Fn(f) if &f.name == internal_name => Some(f), _ => None }).unwrap();
             let sig = ctx.func_sigs.get(&fnKey(f)).expect("test fn has a signature");
-            let w = emitEntryWrapper(&mut module, &ctx, &ctx.enum_variants, &f.name, idx, sig, false, true);
+            let w = emitEntryWrapper(&mut module, &f.name, idx, sig, false, true);
             module.addExport(export_name, ExportKind::Func, w);
         } else {
             module.addExport(export_name, ExportKind::Func, idx);

plum-wasm-codegen/tests/wasm_codegen/codegen_tests.rs CHANGED Viewed

@@ -1443,12 +1443,8 @@ fun main() -> Int =
     assert_eq!(runMerged::<i64>("bool_try", src), 1);
 }
-/// These tests declare their own `extern fun`s to exercise the host-boundary ABI,
+/// These tests declare their own `extern fun` methods on `primitive Io` to exercise the
-/// and call them directly. The `Io` capability only lets std's `Io.plum` do that,
-/// so stamp the program as that file (the ABI is what is under test, not the rule).
-fn asIoFile(source: &mut plum_core::ast::Source) {
-    source.stampFile("plum-std/Io.plum");
+/// host-boundary ABI.
-}
 // ---- extern `Int` narrowing (T1): i32 at the host boundary ----
@@ -1456,11 +1452,10 @@ fn asIoFile(source: &mut plum_core::ast::Source) {
 /// import that is `(i32) -> i32`; returns the module plus `main`'s outcome.
 fn externEcho(arg: &str) -> (wasmtime::Module, Result<i64, String>) {
     let src = format!(
-        "extern fun echo(x: Int) -> Int\n\nfun main() -> Int =\n  echo({})\n",
+        "primitive Io =\n  extern fun echo(self, x: Int) -> Int\n\nfun main(io: Io) -> Int =\n  io.echo({})\n",
         arg
     );
-    let mut source = parse(&src);
+    let source = parse(&src);
-    asIoFile(&mut source);
     let bytes = compileSource(&source).expect("compile failed");
     wasmparser::validate(&bytes).expect("valid wasm");
     let engine = gcEngine();
@@ -1706,10 +1701,9 @@ fn value_nested_flatten() {
 #[test]
 fn extern_value_multi_value() {
     let src = format!(
-        "{VEC2}struct Color(r: Int, g: Int)\n\nextern fun mousePos() -> Vec2\nextern fun tint() -> Color\nextern fun move(p: Vec2, c: Color)\n\nfun main() -> Int =\n  p := mousePos()\n  c := tint()\n  move(p, c)\n  if p.x == 1.5 && c.g == 0 - 7\n    return 1\n  return 0\n"
+        "{VEC2}struct Color(r: Int, g: Int)\n\nprimitive Io =\n  extern fun mousePos(self) -> Vec2\n  extern fun tint(self) -> Color\n  extern fun move(self, p: Vec2, c: Color)\n\nfun main(io: Io) -> Int =\n  p := io.mousePos()\n  c := io.tint()\n  io.move(p, c)\n  if p.x == 1.5 && c.g == 0 - 7\n    return 1\n  return 0\n"
     );
-    let mut source = parse(&src);
+    let source = parse(&src);
-    asIoFile(&mut source);
     let bytes = compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
     wasmparser::validate(&bytes).expect("valid wasm");
     let engine = gcEngine();

plum-wasm-codegen/tests/wasm_codegen/e2e_types/io_primitive.rs ADDED Viewed

@@ -0,0 +1,78 @@
+//! `primitive Io` with `extern fun f(self, ..)`: an `Io` is the i32 constant 0 and each extern
+//! method is a host import (`plum.<name>`) called without the receiver.
+use plum_test_support::{engine, parseRawSource};
+use plum_wasm_codegen::{compile, CompileOptions};
+const IO: &str = "primitive Io =\n  extern fun mark(self, n: Int)\n  extern fun width(self) -> Float\n\n";
+fn build(src: &str, tests: bool) -> (wasmtime::Engine, wasmtime::Module, Vec<String>) {
+    let mut source = parseRawSource(src);
+    plum_core::lower::frontEndDiag(&mut source).expect("front end");
+    let out = compile(&source, &CompileOptions { tests, ..CompileOptions::default() })
+        .unwrap_or_else(|e| panic!("compile failed: {}", e.iter().map(|d| d.to_string()).collect::<Vec<_>>().join("\n")));
+    wasmparser::validate(&out.wasm).expect("valid wasm");
+    let engine = engine();
+    let module = wasmtime::Module::new(&engine, &out.wasm).unwrap();
+    (engine, module, out.test_names)
+}
+fn instantiate(
+    engine: &wasmtime::Engine,
+    module: &wasmtime::Module,
+) -> (wasmtime::Store<Vec<i32>>, wasmtime::Instance) {
+    let mut store = wasmtime::Store::new(engine, Vec::new());
+    let mut linker = wasmtime::Linker::new(engine);
+    linker.func_wrap("plum", "mark", |mut c: wasmtime::Caller<'_, Vec<i32>>, n: i32| c.data_mut().push(n)).unwrap();
+    linker.func_wrap("plum", "width", || 640.0f64).unwrap();
+    linker.define_unknown_imports_as_default_values(&mut store, module).unwrap();
+    let instance = linker.instantiate(&mut store, module).unwrap();
+    (store, instance)
+}
+#[test]
+fn extern_methods_are_imports_and_io_is_an_i32() {
+    let src = format!("{IO}fun main(io: Io) -> Float =\n  io.mark(7)\n  io.width()\n");
+    let (engine, module, _) = build(&src, false);
+    let imports: Vec<String> = module.imports().map(|i| format!("{}.{}", i.module(), i.name())).collect();
+    assert!(imports.contains(&"plum.mark".to_string()) && imports.contains(&"plum.width".to_string()), "{imports:?}");
+    let (mut store, instance) = instantiate(&engine, &module);
+    let main = instance.get_typed_func::<(), f64>(&mut store, "main").unwrap();
+    assert_eq!(main.call(&mut store, ()).unwrap(), 640.0);
+    assert_eq!(store.data(), &vec![7]);
+}
+#[test]
+fn closures_and_generic_fns_take_io() {
+    let src = format!(
+        "{IO}fun twice(f: fn() -> Unit) =\n  f()\n  f()\n\nfun pass[T](x: T, io: Io) -> T =\n  io.mark(1)\n  x\n\nfun main(io: Io) -> Int =\n  twice(|| io.mark(5))\n  pass(3, io)\n"
+    );
+    let (engine, module, _) = build(&src, false);
+    let (mut store, instance) = instantiate(&engine, &module);
+    let main = instance.get_typed_func::<(), i64>(&mut store, "main").unwrap();
+    assert_eq!(main.call(&mut store, ()).unwrap(), 3);
+    assert_eq!(store.data(), &vec![5, 5, 1]);
+}
+#[test]
+fn test_blocks_can_call_io_methods() {
+    let src = format!("{IO}test \"marks\"\n  io.mark(9)\n");
+    let (engine, module, names) = build(&src, true);
+    assert_eq!(names, vec!["marks".to_string()]);
+    let (mut store, instance) = instantiate(&engine, &module);
+    let f = instance.get_func(&mut store, "test#marks").expect("export");
+    let mut results = [wasmtime::Val::I32(0)];
+    f.call(&mut store, &[], &mut results).unwrap();
+    assert_eq!(store.data(), &vec![9]);
+}
+#[test]
+fn io_stored_in_a_generic_container_works() {
+    let src = format!(
+        "{IO}enum Opt[T] =\n  | Nope\n  | Yep(v: T)\n\nfun use(o: Opt[Io]) =\n  match o\n    Yep(x) => x.mark(4)\n    Nope => 0\n\nfun main(io: Io) -> Int =\n  use(Yep(v: io))\n  use(Nope)\n  1\n"
+    );
+    let (engine, module, _) = build(&src, false);
+    let (mut store, instance) = instantiate(&engine, &module);
+    let main = instance.get_typed_func::<(), i64>(&mut store, "main").unwrap();
+    assert_eq!(main.call(&mut store, ()).unwrap(), 1);
+    assert_eq!(store.data(), &vec![4]);
+}

plum-wasm-codegen/tests/wasm_codegen/e2e_types/mod.rs CHANGED Viewed

@@ -2,6 +2,7 @@
 mod closure_optional;
 mod closure_types;
 mod io_entry;
+mod io_primitive;
 mod list_and_shadow;
 mod question;
 mod subtyping;

plum-wasm-codegen/tests/wasm_codegen/fusion_alloc_test.rs CHANGED Viewed

@@ -289,3 +289,94 @@ fn million_pipeline_timed() {
         tOn.as_millis(), tOff.as_millis(), tBuild.as_millis(), tSlice.as_millis()
     ));
 }
+/// A self-contained program (no imports) parsed as is: `primitive Io` is only allowed in std files
+/// through the loader, so this skips it.
+fn loadRaw(src: &str) -> plum_core::ast::Source {
+    let mut source = plum_test_support::parseRawSource(src);
+    plum_core::lower::frontEndDiag(&mut source).expect("front end");
+    source
+}
+/// The host calls (`plum.mark`) a run of `main` makes, in order.
+fn markTrace(wasm: &[u8]) -> Vec<i32> {
+    let engine = engine(false);
+    let module = wasmtime::Module::new(&engine, wasm).unwrap();
+    let mut store = wasmtime::Store::new(&engine, Vec::<i32>::new());
+    let mut linker = wasmtime::Linker::new(&engine);
+    linker
+        .func_wrap("plum", "mark", |mut c: wasmtime::Caller<'_, Vec<i32>>, n: i32| c.data_mut().push(n))
+        .unwrap();
+    linker.define_unknown_imports_as_default_values(&mut store, &module).unwrap();
+    let instance = linker.instantiate(&mut store, &module).unwrap();
+    let main = instance.get_typed_func::<(), i64>(&mut store, "main").unwrap();
+    main.call(&mut store, ()).unwrap();
+    store.into_data()
+}
+const IO_MARK: &str = "primitive Io =
+  extern fun mark(self, n: Int)
+enum Lst =
+  | Nil
+  | Cons(head: Int, tail: Lst)
+fun build(n: Int) -> Lst = if n == 0 then Nil else Cons(head: n, tail: build(n - 1))
+fun mapL(xs: Lst) -> Lst = match xs
+  Nil => Nil
+  Cons(h, t) => Cons(head: h * 10, tail: mapL(t))
+";
+/// Fusion keeps every `io.mark(..)` call, once each and in order: the host-call trace of a
+/// fused run equals the unfused (`--no-fusion`) run. An `io` method is read-only, never
+/// pure, so a pure producer fuses into an `Io` consumer but no `io` call is moved, dropped or
+/// duplicated; an `io` call inside a producer keeps that producer unfused.
+#[test]
+fn fusion_keeps_io_calls_in_order() {
+    // Pure producer, consumer calls io per element (the producer's cells are fused away).
+    let consumer = format!(
+        "{IO_MARK}fun drawL(io: Io, xs: Lst) -> Int = match xs
+  Nil => 0
+  Cons(h, t) =>
+    io.mark(h)
+    io.mark(h + 1)
+    drawL(io, t)
+fun main(io: Io) -> Int =
+  a := drawL(io, mapL(build(5)))
+  a + drawL(io, mapL(build(2)))
+"
+    );
+    let src = loadRaw(&consumer);
+    let (fused, plain) = (compile(&src, true), compile(&src, false));
+    assert!(
+        functions(&fused).iter().any(|f| f.name.starts_with("drawL$mapL")),
+        "the pipeline should fuse (test is meaningful)"
+    );
+    let want: Vec<i32> = [5, 4, 3, 2, 1, 2, 1].iter().flat_map(|n| [n * 10, n * 10 + 1]).collect();
+    assert_eq!(markTrace(&plain), want);
+    assert_eq!(markTrace(&fused), want);
+    // io call in the producer: an impure producer stays unfused and still runs once per element.
+    let producer = format!(
+        "{IO_MARK}fun markL(io: Io, xs: Lst) -> Lst = match xs
+  Nil => Nil
+  Cons(h, t) =>
+    io.mark(h)
+    Cons(head: h, tail: markL(io, t))
+fun sumL(xs: Lst) -> Int = match xs
+  Nil => 0
+  Cons(h, t) => h + sumL(t)
+fun main(io: Io) -> Int =
+  a := sumL(markL(io, build(4)))
+  io.mark(99)
+  a + sumL(markL(io, build(2)))
+"
+    );
+    let src = loadRaw(&producer);
+    let (fused, plain) = (compile(&src, true), compile(&src, false));
+    let want = vec![4, 3, 2, 1, 99, 2, 1];
+    assert_eq!(markTrace(&plain), want);
+    assert_eq!(markTrace(&fused), want);
+}