086f1c8 | plum | pyrossh

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

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

086f1c8 — Peter John 2026-11-05T18:05:48+05:30

Compiler cleanup phase 3b: pass-list driver and Diagnostic errors

Generated files not shown: Cargo.lock

Files changed (62) hide show

Cargo.toml +1 -1
docs/backlog.md +1 -1
docs/plans/2026-11-05-compiler-cleanup-phase3b.md +106 -0
docs/plans/2026-11-05-compiler-cleanup-phase3b.results.md +11 -0
docs/plans/2026-11-05-explicit-fn-generics.progress.md +5 -0
plum-checker/Cargo.toml +1 -0
plum-checker/src/lib.rs +47 -231
plum-checker/src/state.rs +35 -4
plum-checker/src/types.rs +19 -32
plum-checker/tests/checker/checker_tests.rs +9 -4
plum-checker/tests/checker/closure_hint_test.rs +2 -2
plum-checker/tests/checker/diagnostic_tests.rs +34 -0
plum-checker/tests/checker/explicit_generics_tests.rs +1 -1
plum-checker/tests/checker/features/io_capability.rs +1 -1
plum-checker/tests/checker/features/mutability.rs +1 -1
plum-checker/tests/checker/features/pattern_casing.rs +1 -1
plum-checker/tests/checker/features/variant_pattern.rs +1 -1
plum-checker/tests/checker/fusion_pipeline_test.rs +12 -18
plum-checker/tests/checker/inline_variants_tests.rs +1 -1
plum-checker/tests/checker/main.rs +1 -0
plum-checker/tests/checker/question_tests.rs +2 -2
plum-checker/tests/checker/subtyping_tests.rs +4 -4
plum-cli/Cargo.toml +1 -0
plum-cli/src/game.rs +1 -1
plum-cli/src/main.rs +39 -28
plum-cli/tests/cli/compile_tests.rs +16 -0
plum-cli/tests/cli/crash_test.rs +1 -1
plum-core/Cargo.toml +1 -0
plum-core/src/diag.rs +50 -0
plum-core/src/drive.rs +28 -9
plum-core/src/lib.rs +4 -1
plum-core/src/loader.rs +71 -48
plum-core/src/lower.rs +15 -9
plum-core/src/parser.rs +46 -24
plum-core/tests/core/closure_escape_test.rs +2 -2
plum-core/tests/core/closure_spec_test.rs +2 -2
plum-core/tests/core/diag_test.rs +37 -0
plum-core/tests/core/inline_variants_test.rs +21 -8
plum-core/tests/core/layout_test.rs +2 -2
plum-core/tests/core/loader_test.rs +43 -40
plum-core/tests/core/lower_test.rs +4 -4
plum-core/tests/core/main.rs +1 -0
plum-core/tests/core/session_test.rs +2 -2
plum-core/tests/core/trmc_test.rs +6 -4
plum-driver/Cargo.toml +11 -0
plum-driver/src/lib.rs +187 -0
plum-driver/tests/driver_tests.rs +75 -0
plum-game/tests/host_test.rs +1 -1
plum-lsp/Cargo.toml +1 -0
plum-lsp/src/main.rs +40 -26
plum-test-support/Cargo.toml +1 -1
plum-test-support/src/lib.rs +12 -6
plum-wasm-codegen/Cargo.toml +1 -0
plum-wasm-codegen/src/lib.rs +18 -53
plum-wasm-codegen/tests/wasm_codegen/codegen_tests.rs +16 -13
plum-wasm-codegen/tests/wasm_codegen/e2e_mem/reuse.rs +4 -4
plum-wasm-codegen/tests/wasm_codegen/e2e_mem/unique_inplace.rs +1 -1
plum-wasm-codegen/tests/wasm_codegen/e2e_mem/unique_spread.rs +2 -2
plum-wasm-codegen/tests/wasm_codegen/e2e_records/enum_init.rs +1 -1
plum-wasm-codegen/tests/wasm_codegen/e2e_types/subtyping.rs +2 -2
plum-wasm-codegen/tests/wasm_codegen/examples_test.rs +4 -4
plum-wasm-codegen/tests/wasm_codegen/fusion_alloc_test.rs +7 -7

Cargo.toml CHANGED Viewed

@@ -1,5 +1,5 @@
 [workspace]
-members = ["plum-core", "plum-cli", "plum-checker", "plum-wasm-codegen", "plum-lsp", "plum-test-support", "plum-host"]
+members = ["plum-core", "plum-driver", "plum-cli", "plum-checker", "plum-wasm-codegen", "plum-lsp", "plum-test-support", "plum-host"]
 resolver = "2"
 [profile.dev]

docs/backlog.md CHANGED Viewed

@@ -4,7 +4,7 @@ Open work, in the order the user queued it, plus smaller items found during buil
 ## Planned (in order)
-**Current order (user 2026-11-05):** explicit fn generics (running) → cleanup phase 3b (pass list, positioned errors) → Io primitive + extern methods → move Rust crates under `compiler/` → cleanup phase 4 (node ids, typed codegen) → phase 5 (file splits, enum kinds) → phase 6 (tests in Plum) → benchmark (incl. iterator unboxing / niche Option, run C game A/B) → FBIP (stop for user approval) → deterministic sim → kids' games. The items below keep their detail; this line wins on order.
+**Current order (user 2026-11-05):** explicit fn generics (done faa4d7e) → cleanup phase 3b (pass list, positioned errors; running)  → Io primitive + extern methods → move Rust crates under `compiler/` → cleanup phase 4 (node ids, typed codegen; also: `inferExpr` returns `Diagnostic` with spans, removing 3b's registered-message match for undefined names) → phase 5 (file splits, enum kinds) → phase 6 (tests in Plum) → benchmark (incl. iterator unboxing / niche Option, run C game A/B) → FBIP (stop for user approval) → deterministic sim → kids' games. The items below keep their detail; this line wins on order.
 1. **Compiler cleanup and architecture** — `docs/plans/2026-11-04-compiler-cleanup.review.md` (written in another session; meant to run after language-restrictions merged). Approved 2026-11-04; running on branch `superlite/compiler-cleanup`, phase 1 first.
    - **Explicit function generics** (user 2026-11-04: right after cleanup phase 2) — functions declare their generics (`fun map[B](...)`) instead of every single capital letter being a generic; allows longer generic names and one-letter concrete types/tags. Grammar change + about 140 signatures in std/examples. Phase 2's "generics by scope" makes this mostly a grammar + signature rewrite.

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

@@ -0,0 +1,106 @@
+# Compiler cleanup, phase 3b: pass-list driver and positioned errors
+**Review plan:** docs/plans/2026-11-04-compiler-cleanup.review.md (phase 3 rows "Pass list" and "Positioned errors")
+**Goal:** (1) A small driver owns the order of the post-check passes (closure specialisation, fusion, TRMC, tail marking) and the "adopt a rewrite only if it re-checks" rule; the checker only checks. (2) One error type `Diagnostic { file, line, column, kind, message }` replaces `Result<_, String>` error plumbing between parser/loader, checker, driver, codegen, CLI and LSP; no behaviour is decided by matching message text. No language change; compiled wasm for every example is byte-identical before/after.
+**Architecture:** plum-core (new `diag.rs`, parser, loader, drive), plum-checker, new crate plum-driver, plum-wasm-codegen, plum-cli, plum-lsp, plum-test-support.
+**Tech stack:** Rust 2021.
+**Detail:** contracts
+**Target-min:** 35
+## 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`, one test binary per crate in `target/debug/deps` (`core-*`, `checker-*`, `cli-*`, `wasm_codegen-*`, plus lib unit tests; newest by mtime `/bin/ls -t`). Plum sweep `cargo build -p plum-cli && target/debug/plum test plum-std plum-examples` (662).
+- Exact sub-expression positions need spans (phase 4, node ids). Here a diagnostic takes the most specific position the AST already has (FnCall/Stmt line+column, else the enclosing item) and always the item's `file`.
+- User-visible error text keeps its wording; the format becomes `file:line:column: message` (kind decides the prefix where one exists today, e.g. `type error:`). Tests asserting message text keep passing (update only the prefix/format parts).
+- Byte-identical wasm: before T1, compile every plum-examples/**/*.plum with `target/debug/plum compile` into a scratch dir and keep the hashes; T6 compares.
+## Task graph
+```mermaid
+flowchart LR
+  T1[Diagnostic type + parser/loader]
+  T2[checker on Diagnostic, kinds not text]
+  T3[plum-driver: pass list]
+  T4[codegen + CLI on Diagnostic]
+  T5[LSP + test-support on Diagnostic]
+  T6[verify]
+  %% taskgraph
+  T1 --> T2
+  T2 --> T3
+  T3 --> T4
+  T3 --> T5
+  T4 --> T6
+  T5 --> T6
+```
+Ruling: sequential [chain] - T1-T3 rewrite the same error plumbing and the checker entry points in order - cost: T1-T3 run alone.
+## Package A: errors and driver
+**Probe entry:** run=plum test plum-std plum-examples
+### T1 Diagnostic type, parser and loader · Complexity 3 · Est. context 40k
+**Owns:** plum-core/src/diag.rs, plum-core/src/lib.rs, plum-core/src/parser.rs, plum-core/src/loader.rs, plum-core/src/lower.rs, plum-core/tests/core/diag_test.rs, plum-core/tests/core/main.rs, plum-core/tests/core/loader_test.rs
+**Components:** 1
+**LOC owned:** 120
+**Tests:** fast
+**Model:** sonnet
+**Produces:** `plum_core::diag::Diagnostic { file: String, line: usize, column: usize, kind: DiagKind, message: String }`, `DiagKind::{Parse, Load, Resolution, Type, Codegen}`, `impl Display` = `file:line:column: message`; loader/lower return `Result<Source, Vec<Diagnostic>>`
+e.g. loading a file with `fun f( = 1` -> `[Diagnostic{file: "main.plum", line: 1, column: 7, kind: Parse, ..}]`; a missing import -> kind Load naming the import
+**Notes:** keep a thin `String`-returning wrapper where a caller outside plum-core needs it until T4/T5 switch (mark it `// removed in T4`). Parser placeholders (`unwrap_or(Expr::Int(0))` etc. on malformed nodes) become Parse diagnostics.
+**Test code:** diag_test: Display format; the two e.g. cases; loader_test green; all binaries + sweep green.
+### T2 checker on Diagnostic, kinds instead of text · Complexity 4 · Est. context 50k
+**Owns:** plum-checker/src/*.rs, plum-checker/tests/checker/*.rs, plum-checker/tests/checker/features/*.rs
+**Components:** 1
+**LOC owned:** 150
+**Tests:** fast
+**Consumes:** `plum_core::diag::Diagnostic { file: String, line: usize, column: usize, kind: DiagKind, message: String }`, `DiagKind::{Parse, Load, Resolution, Type, Codegen}`, `impl Display` = `file:line:column: message`; loader/lower return `Result<Source, Vec<Diagnostic>>` (T1)
+**Produces:** `CheckError` is `Diagnostic` (type alias or replaced); every checker error carries its item's file and the most specific known position; `isResolutionError` text matching replaced by `DiagKind::Resolution`
+e.g. `fun f() -> Int = g()` in main.plum -> one Diagnostic{file: "main.plum", line: 1, kind: Resolution, message: "undefined name 'g'"..}
+**Test code:** checker binary green (message assertions keep wording); a test that a resolution error in an uninstantiated generic body is still reported (the old text-match behaviour) via kind.
+### T3 plum-driver: the pass list · Complexity 5 · Est. context 50k
+**Owns:** plum-driver/**, Cargo.toml, plum-checker/src/lib.rs, plum-checker/src/state.rs
+**Components:** 1
+**LOC owned:** 160
+**Tests:** fast
+**Consumes:** `CheckError` is `Diagnostic` (type alias or replaced); every checker error carries its item's file and the most specific known position; `isResolutionError` text matching replaced by `DiagKind::Resolution` (T2)
+**Produces:** `plum_driver::check(source: &Source, opts: &PassOptions) -> Result<TypedInfo, Vec<Diagnostic>>` running `[ClosureSpec, Fusion, Trmc, TailMarks]` in order, each rewrite adopted only if it re-checks (dropped ones reported under `--explain`); plum-checker exposes only checking (`checkProgram`) plus what the passes need
+e.g. `plum_driver::check(&src, &PassOptions{fusion: false, ..})` -> no `$`-named fns; default -> same lowered program as today's `typedSourceWith`
+**Notes:** move `typedSourceWith`'s body, `adoptPre`, `recheckKeep`, `fusionRewrite`, `closureHints`, `preUnionSource` into the driver; `FusionOptions` becomes `PassOptions`. Keep `plum_checker::typedSource`/`typedSourceWith` as deprecated thin calls into... nothing — they can't call the driver (cycle): instead switch every caller in T4/T5; in T3 leave them working by keeping the old functions until T4/T5 land, then T6 deletes them.
+**Test code:** plum-driver unit tests: the e.g. cases, a rewrite that fails re-check is dropped and the previous program kept; all binaries + sweep green.
+## Package B: callers
+**Probe entry:** run=plum test plum-std plum-examples
+### T4 codegen and CLI on Diagnostic · Complexity 4 · Est. context 45k
+**Owns:** plum-wasm-codegen/src/*.rs, plum-wasm-codegen/Cargo.toml, plum-wasm-codegen/tests/wasm_codegen/**/*.rs, plum-cli/src/*.rs, plum-cli/tests/cli/*.rs, plum-core/src/drive.rs
+**Components:** 2
+**LOC owned:** 120
+**Tests:** fast
+**Consumes:** `plum_driver::check(source: &Source, opts: &PassOptions) -> Result<TypedInfo, Vec<Diagnostic>>` running `[ClosureSpec, Fusion, Trmc, TailMarks]` in order, each rewrite adopted only if it re-checks (dropped ones reported under `--explain`); plum-checker exposes only checking (`checkProgram`) plus what the passes need (T3)
+**Produces:** `plum_wasm_codegen::compile(source, opts) -> Result<Output, Vec<Diagnostic>>` via plum-driver; CLI prints diagnostics; `nameFileInErrors` and `starts_with("type error")` gone; drive.rs's `why.starts_with("consumer ")` becomes an enum
+e.g. `plum compile bad.plum` with an undefined name -> stderr `bad.plum:3:5: type error: undefined name 'g'` and exit 1
+**Test code:** cli test for the e.g. output; wasm_codegen + cli binaries green.
+### T5 LSP and test-support on Diagnostic · Complexity 3 · Est. context 35k
+**Owns:** plum-lsp/src/*.rs, plum-lsp/Cargo.toml, plum-test-support/src/*.rs, plum-test-support/Cargo.toml
+**Components:** 1
+**LOC owned:** 80
+**Tests:** fast
+**Consumes:** `plum_driver::check(source: &Source, opts: &PassOptions) -> Result<TypedInfo, Vec<Diagnostic>>` running `[ClosureSpec, Fusion, Trmc, TailMarks]` in order, each rewrite adopted only if it re-checks (dropped ones reported under `--explain`); plum-checker exposes only checking (`checkProgram`) plus what the passes need (T3)
+**Produces:** LSP publishes diagnostics from `Diagnostic` positions (no message parsing); test-support uses plum-driver
+e.g. an LSP document with `g()` undefined -> one LSP diagnostic at the call's line/column
+**Test code:** plum-lsp tests green incl. `readmeSnippetsHaveNoSyntaxDiagnostics`; all binaries green.
+### T6 verify and remove leftovers · Complexity 2 · Est. context 30k
+**Owns:** docs/plans/2026-11-05-compiler-cleanup-phase3b.results.md, plum-checker/src/lib.rs, plum-core/src/*.rs
+**Components:** 1
+**LOC owned:** 40
+**Tests:** slow
+**Consumes:** `plum_wasm_codegen::compile(source, opts) -> Result<Output, Vec<Diagnostic>>` via plum-driver; CLI prints diagnostics; `nameFileInErrors` and `starts_with("type error")` gone; drive.rs's `why.starts_with("consumer ")` becomes an enum (T4) · LSP publishes diagnostics from `Diagnostic` positions (no message parsing); test-support uses plum-driver (T5)
+**Produces:** phase 3b results
+**Notes:** delete the deprecated `typedSource`/`typedSourceWith` and any `// removed in T4` wrappers; grep src for `.contains("`/`.starts_with("` on error messages (none may decide behaviour). Byte-compare example wasm against the pre-T1 hashes (coordinator has them in .superlite/progress.md).
+**Test code:** workspace build zero warnings; all binaries; sweep 662; fixtures compile; wasm hashes identical (list any difference as a finding).
+## Review Focus
+- A: state — a dropped rewrite never leaves a half-adopted TypedInfo; pass order unchanged.
+- B: protocol — CLI exit codes and stderr format; LSP positions 0- vs 1-based.

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

@@ -0,0 +1,11 @@
+# Compiler cleanup phase 3b: results
+- Temporary shims deleted: loader `loadAndMerge`/`loadAndMergeWithOverrides`, lower `perFile`/`frontEnd`, `Diagnostic::legacyString`, `legacyJoin`, checker `typedSource`/`typedSourceWith`/`FusionOptions` and the old pass bodies (`preUnionSource`, `adoptPre`, `fusionRewrite`, `recheckKeep`), codegen `compileSource` and `typeCheckWith`. `CompileOptions.fusion` is now `passes: plum_driver::PassOptions`. `plum_driver::fusionNotes` is the public fusion body. Tests use `plum_driver::check`, the `*Diag` loader/lower functions, and `plum_test_support::compileSource`. `CheckErrorExt` stays: it is the constructor set for checker diagnostics, not a shim.
+- plum-driver: a TRMC rewrite that fails its re-check now prints the same "dropped" note under `--explain` as fusion and closure specialisation.
+- The only error-message match that decides behaviour is the registered undefined-name match (`isResolutionMessage`); phase 4 removes it.
+- `cargo build --workspace --tests`: zero warnings from our crates.
+- Test binaries (all green): core 391, checker 141, cli 16, wasm_codegen 207, plum_lsp 20 (incl. `typeDiagnosticUsesTheDiagnosticPosition`), driver 3, plum_test_support 7, plum_core 3, plum_wasm_codegen 3, plum 5, plum_checker 5.
+- `plum test plum-std plum-examples`: 662 passed, 0 failed (65/65 files).
+- All 9 fixtures in `plum-game/web-test/fixtures` compile.
+- wasm hashes of the 25 plum-examples are identical to `.superlite/wasm-before-3b.txt`.
+- `git diff --stat faa4d7e`: 55 files changed, 575 insertions(+), 612 deletions(-).

docs/plans/2026-11-05-explicit-fn-generics.progress.md ADDED Viewed

@@ -0,0 +1,5 @@
+- start 949dabf
+Ruling: skip Wave 0 - cost: none
+Ruling: user 2026-11-05: rename Float.Euler -> Float.E in T8 (after T7 frees single letters); Float.Epsilon unchanged - cost: none
+Ruling: final-review build-speed.progress.md - coordinator-written copy of the previous run's notes, checkpoint refusals are bookkeeping; committed with this run - cost: none
+Ruling: final-review shadowing (fun map[T] in struct Box[T]) - cannot occur: redeclaring an owner generic is an error with a test (T3) - cost: none

plum-checker/Cargo.toml CHANGED Viewed

@@ -8,5 +8,6 @@ plum-core = { path = "../plum-core" }
 [dev-dependencies]
 plum-test-support = { path = "../plum-test-support" }
+plum-driver = { path = "../plum-driver" }
 tree-sitter = "0.26"
 tree-sitter-plum = { path = "../plum-tooling/tree-sitter-plum" }

plum-checker/src/lib.rs CHANGED Viewed

@@ -5,10 +5,11 @@
 mod state;
 pub mod subtyping;
 pub mod types;
+pub use types::{CheckErrorExt, DiagKind};
 use plum_core::ast;
 use std::collections::{BTreeMap, BTreeSet, HashMap};
-use state::{resetCheck, withCheck};
+use state::{registerResolution, resetCheck, setCurrentFile, withCheck};
 use types::{CheckError, CheckResult, PlumType, TypeEnv, TypeScheme};
@@ -267,7 +268,11 @@ pub fn restoreScope(saved: SavedScope) {
 /// duration of `body`.
 pub fn withFnScope<R>(f: &ast::Fn, owner: &[String], body: impl FnOnce() -> R) -> R {
     let saved = setScope(Scope::of(owner, f), Some((f.file.clone(), f.line, f.name.clone())));
+    let prevFile = (!f.file.is_empty()).then(|| setCurrentFile(&f.file));
     let r = body();
+    if let Some(prev) = prevFile {
+        setCurrentFile(&prev);
+    }
     restoreScope(saved);
     r
 }
@@ -393,7 +398,7 @@ fn freshOwner(generics: &[String]) -> BTreeMap<String, PlumType> {
 }
 /// Remembers a variable binding made at any call site (variable names are
-/// globally unique) so `typedSource` can resolve recorded types at the end.
+/// globally unique) so `checkProgram` can resolve recorded types at the end.
 /// Applies the bindings recorded so far at any call site (e.g. `out := List()`
 /// then `out.push(x)` bound `_t1`) to a type, so a later `.field` or method
 /// call on a still-variable-typed value (`out.at(0).x`) sees the real type.
@@ -679,9 +684,15 @@ fn wrapHint(expected: &PlumType, actual: &PlumType, ctx: &CheckCtx) -> &'static
 }
 pub fn lookup(env: &TypeEnv, name: &str) -> Result<PlumType, String> {
-    env.get(name)
-        .map(|s| *s.body.clone())
+    env.get(name).map(|s| *s.body.clone()).ok_or_else(|| undefinedName(name))
+}
+/// The "undefined name" error text; registered, so the `CheckError` built from it (or from
+/// a message that wraps it) is a `DiagKind::Resolution`.
+fn undefinedName(name: &str) -> String {
-        .ok_or_else(|| format!("undefined name '{}'", name))
+    let message = format!("undefined name '{}'", name);
+    registerResolution(&message);
+    message
 }
 /// `(receiver type, method name) -> TFun` for every `name<Receiver>(...)` method.
@@ -902,24 +913,6 @@ pub fn checkSource(source: &ast::Source) -> CheckResult<()> {
     checkSourceFull(source).0
 }
-/// Type-checks the original source like `checkSource` and also returns the
-/// instantiated type of every expression (keyed by expression address) and the
-/// set of generic instantiations (see `TypedInfo`) for codegen.
-/// Switches for the supercompiler stage of `typedSource`.
-#[derive(Clone, Copy, Debug)]
-pub struct FusionOptions {
-    /// Run the fusion stage (`--no-fusion` clears it).
-    pub enabled: bool,
-    /// Print each fusion decision to stderr (`--explain-fusion`).
-    pub explain: bool,
-}
-impl Default for FusionOptions {
-    fn default() -> Self {
-        FusionOptions { enabled: true, explain: false }
-    }
-}
 /// Whether `obj_ty.field` is declared immutable (a record or enum field without `mut`).
 /// `None` for structs (value-local assignment stays allowed) and unknown types.
 fn immutableFieldOwner(obj_ty: &PlumType, field: &str, ctx: &CheckCtx) -> Option<String> {
@@ -943,142 +936,9 @@ fn immutableFieldOwner(obj_ty: &PlumType, field: &str, ctx: &CheckCtx) -> Option
     }
 }
-pub fn typedSource(source: &ast::Source) -> CheckResult<TypedInfo> {
-    typedSourceWith(source, FusionOptions::default())
-}
-/// Like `typedSource` with explicit fusion options (no thread-local read).
-pub fn typedSourceWith(source: &ast::Source, fusion: FusionOptions) -> CheckResult<TypedInfo> {
-    let (mut result, mut info) = checkSourceFull(source);
-    // Closure specialisation and fusion run on the checked program BEFORE union lowering
-    // (`pre`: own generics applied, `for` loops lowered), so the passes never see the
-    // hidden `List__Cons(Cons(..))` wrappers. Each rewrite is re-checked (with union
-    // lowering) and adopted only if it checks; on failure the previous program stays.
-    if result.is_ok() {
-        let mut pre = preUnionSource(source);
-        // Closure specialisation: copies of callees with the closure argument inlined.
-        {
-            // `info` is keyed by the addresses of the program it checked (`lowered`, or
-            // `source` itself), not of the clone `pre`; hints are keyed by call position,
-            // so read them off the checked program and apply them to its twin `pre`.
-            let hints = match info.lowered.clone() {
-                Some(checked) => closureHints(&checked, &info),
-                None => closureHints(source, &info),
-            };
-            let mut copy = pre.clone();
-            if !plum_core::closure_spec::specialiseWith(&mut copy, &hints).is_empty()
-                && adoptPre(&copy, &mut result, &mut info, "closure specialisation", fusion.explain)
-            {
-                pre = copy;
-            }
-        }
-        // Supercompiler stage: purity -> simplify -> drive -> uniqueness -> reuse.
-        // `--no-fusion` skips it.
-        if fusion.enabled {
-            let mut copy = pre.clone();
-            let notes = fusionRewrite(&mut copy);
-            if fusion.explain {
-                for n in &notes {
-                    eprintln!("fusion: {n}");
-                }
-            }
-            if !notes.is_empty() {
-                adoptPre(&copy, &mut result, &mut info, "fusion", fusion.explain);
-            }
-        }
-    }
-    // Tail recursion modulo cons: rewrite the lowered program, then check the
-    // rewrite again (types are recorded per expression address). If the rewrite
-    // does not check, keep the original program.
-    if result.is_ok() {
-        if let Some(lowered) = info.lowered.as_ref() {
-            let mut copy = (**lowered).clone();
-            if !plum_core::trmc::rewrite(&mut copy).is_empty() {
-                recheckKeep(copy, &mut result, &mut info);
-            }
-        }
-    }
-    // Mark tail calls on the final lowered program codegen compiles. Flags are set
-    // in place, so the address-keyed type info stays valid.
-    if let Some(lowered) = info.lowered.as_mut().and_then(std::rc::Rc::get_mut) {
-        plum_core::tail::markTailCalls(lowered);
-    }
-    result.map(|()| info)
-}
-/// The checked program before union lowering: own generics applied and `for` loops lowered.
-fn preUnionSource(source: &ast::Source) -> ast::Source {
-    let mut cur = source.clone();
-    while let Some(applied) = applyOwnGenerics(&cur) {
-        cur = applied;
-    }
-    if cur.formLoops {
-        plum_core::forms::begin(&cur);
-        let _ = checkSourceOnce(&cur);
-        cur = plum_core::forms::finish(&cur);
-    }
-    cur
-}
-/// Checks `copy` (a pre-union program) with union lowering; adopts the result and info only
-/// if it checks. Returns whether it was adopted.
-/// A rewrite that does not re-check is dropped; with `explain` the dropped stage and the
-/// first re-check errors are printed, so a lost optimisation cannot hide.
-fn adoptPre(copy: &ast::Source, result: &mut CheckResult<()>, info: &mut TypedInfo, stage: &str, explain: bool) -> bool {
-    // Type info is keyed by expression address: check the very program kept as `lowered`.
-    let kept = std::rc::Rc::new(copy.clone());
-    let (r2, mut i2) = checkSourceOnce(&kept);
-    if r2.is_ok() {
-        if i2.lowered.is_none() {
-            i2.lowered = Some(kept);
-        }
-        *result = r2;
-        *info = i2;
-        true
-    } else {
-        if explain {
-            eprintln!("fusion: {stage} dropped: the rewritten program failed its re-check");
-            if let Err(errs) = &r2 {
-                for e in errs.iter().take(3) {
-                    eprintln!("fusion:   {}:{}: {}", e.line, e.column, e.message);
-                }
-            }
-        }
-        false
-    }
-}
-/// Runs the fusion passes on `copy` and returns every note (empty = nothing changed).
-pub fn fusionRewrite(copy: &mut ast::Source) -> Vec<String> {
-    let pure = plum_core::purity::pureFns(copy);
-    let mut notes = plum_core::simplify::simplify(copy, &pure);
-    notes.extend(plum_core::drive::drive(copy, &pure));
-    let rep = plum_core::uniqueness::markUnique(copy);
-    notes.extend(rep.proved.iter().map(|l| format!("unique spread at {l}")));
-    notes.extend(rep.unproved.iter().map(|(l, why)| format!("uniqueness: not in place {l}: {why}")));
-    notes.retain(|n| !n.is_empty());
-    notes.extend(plum_core::reuse::markReuse(copy));
-    notes.retain(|n| !n.is_empty());
-    notes
-}
-/// Re-checks the rewritten `copy`; adopts it (result and info) only if it checks,
-/// otherwise the original `result`/`info` stay. Returns whether it was adopted.
-pub fn recheckKeep(copy: ast::Source, result: &mut CheckResult<()>, info: &mut TypedInfo) -> bool {
-    let (r2, mut i2) = checkSourceOnce(&copy);
-    if r2.is_ok() {
-        i2.lowered = Some(std::rc::Rc::new(copy));
-        *result = r2;
-        *info = i2;
-        true
-    } else {
-        false
-    }
-}
 /// Receiver type names of the method calls of `lowered`, for `closure_spec` (a call site
 /// whose receiver has no single known type gets no hint).
-fn closureHints(lowered: &ast::Source, info: &TypedInfo) -> plum_core::closure_spec::Hints {
+pub fn closureHints(lowered: &ast::Source, info: &TypedInfo) -> plum_core::closure_spec::Hints {
     let mut inst: HashMap<usize, Vec<&PlumType>> = HashMap::new();
     for ((_, addr), t) in &info.inst_expr_types {
         inst.entry(*addr).or_default().push(t);
@@ -1116,6 +976,12 @@ fn closureHints(lowered: &ast::Source, info: &TypedInfo) -> plum_core::closure_s
     hints
 }
+/// Checks `source` (own generics applied, `for` loops lowered) and returns the result with the
+/// typed program info. Checking only: the rewrite passes live in `plum-driver`.
+pub fn checkProgram(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
+    checkSourceFull(source)
+}
 fn checkSourceFull(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     if let Some(applied) = applyOwnGenerics(source) {
         // Check (and let codegen compile) the copy with bare own-generic names applied.
@@ -1212,6 +1078,12 @@ fn ioCapabilityErrors(source: &ast::Source) -> Vec<CheckError> {
     errors
 }
+/// One check of exactly `source` (no own-generics application, no loop lowering first); what
+/// the driver uses to re-check a rewritten program.
+pub fn checkOnce(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
+    checkSourceOnce(source)
+}
 fn checkSourceOnce(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     resetCheck();
     withCheck(|s| {
@@ -1255,7 +1127,7 @@ fn checkSourceOnce(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
 /// Returns a copy of `source` with every such type annotation (params, returns,
 /// annotated locals, explicit construction generics, fields) applied,
 /// so the checker and codegen both see the same `TApp`; `None` if there is none.
-fn applyOwnGenerics(source: &ast::Source) -> Option<ast::Source> {
+pub fn applyOwnGenerics(source: &ast::Source) -> Option<ast::Source> {
     let own: HashMap<&str, Vec<ast::Type>> = source
         .items
         .iter()
@@ -1700,6 +1572,7 @@ fn constUseError(n: &str, env: &TypeEnv, ctx: &CheckCtx) -> Option<String> {
 }
 fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
+    setCurrentFile(&source.file);
     // Generic items are checked once, structurally (`TApp`/`TParam`), on the
     // ORIGINAL source.
     let mut errors: Vec<CheckError> = checkPrimitives(source);
@@ -1814,7 +1687,7 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
             }
             let mut local_errors = checkFn(f, &global_env, &ctx);
             if !fnGenericNames(f, &ctx).is_empty() {
-                local_errors.retain(|e| isResolutionError(&e.message));
+                local_errors.retain(|e| e.kind == types::DiagKind::Resolution);
                 drainCalls();
             } else {
                 registerCalls(&mut inst, &fn_by_key, &ctx, None);
@@ -1826,6 +1699,7 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     for item in &source.items {
         if let ast::Item::Test(t) = item {
             withCheck(|s| { let l = &s.cur_pos; l.set((t.line, t.column)) });
+            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")) {
@@ -1840,6 +1714,9 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
                 &ctx,
             );
             errors.append(&mut block_errors);
+            if let Some(prev) = prevFile {
+                setCurrentFile(&prev);
+            }
             if !t.file.is_empty() && t.file != source.file {
                 // An imported file's tests are never compiled (see `desugarTestsToFns`):
                 // their calls must not instantiate generic fns the program does not use.
@@ -1885,7 +1762,7 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
             };
             let full = format!("{}{}", chain, msg);
             if seen_msgs.insert(full.clone()) {
-                errors.push(CheckError::at(e.line, e.column, full));
+                errors.push(CheckError { message: full, ..e });
             }
         }
         registerCalls(&mut inst, &fn_by_key, &ctx, Some(id));
@@ -1907,14 +1784,8 @@ struct InstState {
     file: String,
 }
-/// Errors a generic body keeps even when uninstantiated (name resolution and
+/// (A generic body keeps its `DiagKind::Resolution` errors even when uninstantiated; every
-/// declaration structure); everything else is a type error found per instantiation.
+/// other error is a type error found per instantiation.)
-fn isResolutionError(msg: &str) -> bool {
-    msg.contains("undefined name")
-        || msg.contains("extern")
-        || msg.contains("missing a body")
-}
 fn drainCalls() -> Vec<CallSite> {
     withCheck(|s| { let c = &s.calls; {
         c.borrow_mut()
@@ -2104,7 +1975,7 @@ fn checkFnBody(f: &ast::Fn, global_env: &TypeEnv, ctx: &CheckCtx) -> Vec<CheckEr
     match (f.is_extern, &f.body) {
         (true, ast::FnBody::Extern) => {
             if f.type_param.is_some() {
-                errors.push(CheckError::at(
+                errors.push(CheckError::resolution(
                     f.line,
                     f.column,
                     format!(
@@ -2116,7 +1987,7 @@ fn checkFnBody(f: &ast::Fn, global_env: &TypeEnv, ctx: &CheckCtx) -> Vec<CheckEr
             return errors;
         }
         (true, _) => {
-            errors.push(CheckError::at(
+            errors.push(CheckError::resolution(
                 f.line,
                 f.column,
                 format!("fn '{}': extern fn must not have a body", f.name),
@@ -2136,7 +2007,7 @@ fn checkFnBody(f: &ast::Fn, global_env: &TypeEnv, ctx: &CheckCtx) -> Vec<CheckEr
                 }
                 return errors;
             }
-            errors.push(CheckError::at(
+            errors.push(CheckError::resolution(
                 f.line,
                 f.column,
                 format!("fn '{}': missing a body (mark it abstract or extern)", f.name),
@@ -4589,9 +4460,11 @@ fn inferExprInner(
                 }
                 Ok(_) => Err(format!("'{}' is not a function", call.name)),
                 // `k => v` desugars to `Pair(k, v)`; without std/Map there is no Pair.
-                Err(_) if call.name == "Pair" => Err(
+                Err(_) if call.name == "Pair" => {
-                    "undefined name 'Pair' — `k => v` builds a std Pair; import std/Map".to_string(),
+                    let message = "undefined name 'Pair' — `k => v` builds a std Pair; import std/Map".to_string();
+                    registerResolution(&message);
+                    Err(message)
-                ),
+                }
                 Err(_) => Ok(PlumType::TVar("_".to_string())), // unknown fn: allow, codegen will catch
             }
         }
@@ -4687,60 +4560,3 @@ fn checkStaticUse(
     }
     Ok(())
 }
-#[cfg(test)]
-mod fusion_options_tests {
-    use super::*;
-    use plum_test_support::parse;
-    const SRC: &str = "\
-enum Cells =
-  | Cons(head: Int, tail: Cells)
-  | Nil
-fun mapCells(xs: Cells) -> Cells = match xs
-  Cons(h, t) => Cons(head: h * 2, tail: mapCells(t))
-  Nil => Nil
-fun sumL(xs: Cells) -> Int = match xs
-  Cons(h, t) => h + sumL(t)
-  Nil => 0
-fun total(xs: Cells) -> Int = sumL(mapCells(xs))
-fun count(n: Int) -> Int =
-  s := 0
-  for i := range n
-    s = s + i
-  s
-";
-    fn fnNames(info: &TypedInfo) -> Vec<String> {
-        info.lowered
-            .as_ref()
-            .unwrap()
-            .items
-            .iter()
-            .filter_map(|i| match i {
-                ast::Item::Fn(f) => Some(f.name.clone()),
-                _ => None,
-            })
-            .collect()
-    }
-    #[test]
-    fn defaultOptionsMatchTypedSource() {
-        let src = parse(SRC);
-        let a = typedSource(&src).expect("checks");
-        let b = typedSourceWith(&src, FusionOptions::default()).expect("checks");
-        assert_eq!(fnNames(&a), fnNames(&b));
-        assert!(fnNames(&b).iter().any(|n| n.contains("sumL$mapCells")));
-    }
-    #[test]
-    fn disabledHasNoFusedFns() {
-        let src = parse(SRC);
-        let info = typedSourceWith(&src, FusionOptions { enabled: false, explain: false }).expect("checks");
-        assert!(!fnNames(&info).iter().any(|n| n.contains('$')), "{:?}", fnNames(&info));
-    }
-}

plum-checker/src/state.rs CHANGED Viewed

@@ -18,7 +18,7 @@ pub(crate) struct CheckState {
     pub(crate) closure_hint: RefCell<Option<(Vec<PlumType>, bool)>>,
     /// Counter for the fresh `_t<N>` inference variables minted per generic call site.
     pub(crate) fresh: Cell<u32>,
-    /// When set, `inferExprWith` records every expression's type here (see `typedSource`).
+    /// When set, `inferExprWith` records every expression's type here (see `checkProgram`).
     pub(crate) record_binds: RefCell<Option<Binds>>,
     pub(crate) record: RefCell<Option<HashMap<usize, PlumType>>>,
     /// Generic-call sites seen while checking one body (see `CallSite`); `None` outside `checkSourceInner`.
@@ -51,6 +51,11 @@ pub(crate) struct CheckState {
     /// Generic names in scope in the fn (or enum) whose types are being converted, and
     /// where it is (file, line, fn name) for the implicit-generic report.
     pub(crate) scope: RefCell<plum_core::generics::Scope>,
+    /// The file of the declaration being checked, stamped on every error made meanwhile.
+    pub(crate) cur_file: RefCell<String>,
+    /// Exact messages of resolution errors (see `registerResolution`): an error whose text
+    /// contains one is a `DiagKind::Resolution`.
+    pub(crate) resolution_msgs: RefCell<Vec<String>>,
     pub(crate) scope_site: RefCell<Option<(String, usize, String)>>,
 }
@@ -65,6 +70,30 @@ pub(crate) fn withCheck<R>(f: impl FnOnce(&CheckState) -> R) -> R {
     CHECK.with(|c| f(&c.borrow()))
 }
+/// The file of the declaration being checked (empty outside one).
+pub(crate) fn currentFile() -> String {
+    withCheck(|s| s.cur_file.borrow().clone())
+}
+pub(crate) fn setCurrentFile(file: &str) -> String {
+    withCheck(|s| std::mem::replace(&mut *s.cur_file.borrow_mut(), file.to_string()))
+}
+/// Records a message created as a resolution error, so the `CheckError` later built from it
+/// (usually wrapped in a longer message) is classified by where it came from.
+pub(crate) fn registerResolution(message: &str) {
+    withCheck(|s| {
+        let mut m = s.resolution_msgs.borrow_mut();
+        if !m.iter().any(|x| x == message) {
+            m.push(message.to_string());
+        }
+    });
+}
+pub(crate) fn isResolutionMessage(message: &str) -> bool {
+    withCheck(|s| s.resolution_msgs.borrow().iter().any(|r| message.contains(r.as_str())))
+}
 /// Return every field to its initial value. Must not run inside `withCheck`.
 pub(crate) fn resetCheck() {
     CHECK.with(|c| *c.borrow_mut() = CheckState::default());
@@ -94,12 +123,14 @@ mod tests {
     }
     #[test]
-    fn typedSourceIsRepeatable() {
+    fn checkProgramIsRepeatable() {
         let src = plum_test_support::parse(
             "fun id[T](x: T) -> T = x\nfun main() -> Int =\n  a := id(1)\n  b := id(true)\n  a\n",
         );
-        let first = crate::typedSource(&src).expect("checks");
+        let (r1, first) = crate::checkProgram(&src);
-        let second = crate::typedSource(&src).expect("checks");
+        let (r2, second) = crate::checkProgram(&src);
+        r1.expect("checks");
+        r2.expect("checks");
         // generated names (closure copies, `_t<N>` vars) must not depend on earlier checks
         let names = |i: &crate::TypedInfo| format!("{:?}", i.lowered.as_ref().map(|l| l.items.len()));
         assert_eq!(names(&first), names(&second));

plum-checker/src/types.rs CHANGED Viewed

@@ -85,42 +85,29 @@ impl TypeScheme {
 pub type TypeEnv = BTreeMap<String, TypeScheme>;
+/// A checker error is a `Diagnostic`; the position is the enclosing declaration's (see
+/// `ast::Fn`/`ast::Enum`/`ast::Test`) unless a more specific one is known, `(0, 0)` when unknown.
+pub type CheckError = plum_core::diag::Diagnostic;
-#[derive(Debug, Clone)]
+pub use plum_core::diag::DiagKind;
+/// Constructors for `CheckError` that fill the file from the declaration being checked
+/// (`state::CheckState::cur_file`) and the kind from where the error is created.
-pub struct CheckError {
+pub trait CheckErrorExt: Sized {
-    pub message: String,
-    /// 1-based source position the error is about — the position of the
-    /// enclosing `fn`/`enum`/`test` declaration (see `ast::Fn`/`ast::Enum`/
-    /// `ast::Test`'s own `line`/`column`), not the exact sub-expression.
+    /// A type error at `line:column` of the declaration being checked.
+    fn at(line: usize, column: usize, message: String) -> Self;
-    /// `(0, 0)` when unknown (e.g. a cross-cutting error with no single
+    /// A name-resolution or declaration-structure error (kept even in an uninstantiated
-    /// declaration to blame, like a duplicate top-level name).
+    /// generic body).
-    pub line: usize,
-    pub column: usize,
+    fn resolution(line: usize, column: usize, message: String) -> Self;
 }
-impl CheckError {
+impl CheckErrorExt for CheckError {
-    /// A `CheckError` with no known position — equivalent to the old
-    /// `CheckError { message }` literal, kept as the default for error sites
-    /// that aren't (yet) scoped to a single declaration.
-    pub fn new(message: String) -> Self {
+    fn at(line: usize, column: usize, message: String) -> Self {
+        let kind = if crate::state::isResolutionMessage(&message) { DiagKind::Resolution } else { DiagKind::Type };
-        CheckError {
+        CheckError::new(kind, crate::state::currentFile(), line, column, message)
-            message,
-            line: 0,
-            column: 0,
-        }
     }
-    pub fn at(line: usize, column: usize, message: String) -> Self {
+    fn resolution(line: usize, column: usize, message: String) -> Self {
-        CheckError {
-            message,
-            line,
-            column,
-        }
-    }
-}
-impl std::fmt::Display for CheckError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        CheckError::new(DiagKind::Resolution, crate::state::currentFile(), line, column, message)
-        write!(f, "{}", self.message)
     }
 }

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

@@ -1,10 +1,15 @@
 #![allow(non_snake_case)]
 use plum_checker::types::*;
-use plum_checker::{checkSource, plumTypeFromAst, typedSource, unify, CheckCtx};
+use plum_checker::{checkSource, plumTypeFromAst, unify, CheckCtx, TypedInfo};
 use plum_core::ast::Type as AstType;
 use plum_core::ast::*;
 use plum_test_support::{parse, parse as parseClean};
+/// The checker plus the default pass list.
+fn typedSource(source: &Source) -> Result<TypedInfo, Vec<plum_core::Diagnostic>> {
+    plum_driver::check(source, &plum_driver::PassOptions::default())
+}
 fn emptyCtx() -> CheckCtx<'static> {
     use std::sync::OnceLock;
     static METHODS: OnceLock<plum_checker::MethodEnv> = OnceLock::new();
@@ -233,7 +238,7 @@ fn instantiation_set_listed() {
         "{}fun main() -> Int =\n  a := Slice(items: 1).map(|n| n * 2)\n  b := Slice(items: \"x\").map(|s| s)\n  0\n",
         GENERIC_DEFS
     );
-    let info = plum_checker::typedSource(&parseClean(&src)).unwrap_or_else(|e| panic!("{:?}", e));
+    let info = typedSource(&parseClean(&src)).unwrap_or_else(|e| panic!("{:?}", e));
     let has = |t: PlumType| {
         info.instantiations
             .iter()
@@ -295,10 +300,10 @@ fn typed_source_has_no_unresolved_infer_vars() {
         if skip.iter().any(|s| path.ends_with(s)) {
             continue;
         }
-        let ast = match plum_core::loadAndMerge(&path, &root) {
+        let ast = match plum_core::loadAndMergeDiag(&path, &root) {
             Ok(a) => a,
             Err(e) => {
-                bad.push(format!("{}: load failed: {}", path.display(), e));
+                bad.push(format!("{}: load failed: {}", path.display(), e.iter().map(|d| d.to_string()).collect::<Vec<_>>().join("\n")));
                 continue;
             }
         };

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

@@ -1,7 +1,7 @@
 #![allow(non_snake_case)]
 //! Closure specialisation resolves a method call by the receiver's checked type, not
 //! by the method name being unique: `Box.apply` and `Bag.apply` both exist here.
-use plum_checker::{typedSourceWith, FusionOptions};
+use plum_driver::{check, PassOptions};
 use plum_core::ast::{Expr, Item};
 use plum_core::visit::walkRef;
 use plum_test_support::parse;
@@ -18,7 +18,7 @@ fun useBox(b: Box) -> Int = b.apply(|x| x + 1)
 /// Method names `useBox` calls, in the checked (and specialised) program fusion would see.
 fn calledByUse(src: &str) -> Vec<String> {
-    let info = typedSourceWith(&parse(src), FusionOptions { enabled: false, explain: false }).expect("checks");
+    let info = check(&parse(src), &PassOptions { fusion: false, ..PassOptions::default() }).expect("checks");
     let low = info.lowered.as_ref().expect("closure specialisation adopted a rewrite");
     let f = low
         .items

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

@@ -0,0 +1,34 @@
+#![allow(non_snake_case)]
+//! Checker errors are `Diagnostic`s: they carry the item's file and a kind.
+use plum_checker::{checkSource, DiagKind};
+fn errors(src: &str) -> Vec<plum_checker::types::CheckError> {
+    let mut source = plum_test_support::parseRawSource(src);
+    source.stampFile("main.plum");
+    plum_core::lower::frontEndDiag(&mut source).expect("front end");
+    checkSource(&source).unwrap_err()
+}
+#[test]
+fn undefinedNameIsAResolutionDiagnosticWithItsFile() {
+    let es = errors("fun f() -> Int = g\n\nfun main() -> Int = f()\n");
+    assert!(es.iter().all(|e| e.file == "main.plum"), "{es:?}");
+    let e = es.iter().find(|e| e.message.contains("undefined name 'g'")).expect("undefined name");
+    assert_eq!(e.kind, DiagKind::Resolution, "{e:?}");
+    assert_eq!(e.line, 1);
+}
+#[test]
+fn typeMismatchIsATypeDiagnostic() {
+    let es = errors("fun main() -> Int = true\n");
+    assert!(es.iter().all(|e| e.kind == DiagKind::Type && e.file == "main.plum"), "{es:?}");
+}
+#[test]
+fn resolutionErrorInAnUninstantiatedGenericBodyIsStillReported() {
+    let es = errors("fun id[T](x: T) -> T = nope\n\nfun main() -> Int = 1\n");
+    assert!(
+        es.iter().any(|e| e.kind == DiagKind::Resolution && e.message.contains("undefined name 'nope'")),
+        "{es:?}"
+    );
+}

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

@@ -4,7 +4,7 @@ use plum_checker::checkSource;
 fn run(src: &str) -> Result<(), String> {
     let mut source = plum_test_support::parseRawSource(src);
-    plum_core::lower::frontEnd(&mut source).map_err(|e| format!("lower: {e}"))?;
+    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(" | "))
 }

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

@@ -3,7 +3,7 @@ use plum_checker::checkSource;
 fn run(src: &str) -> Result<(), String> {
     let mut source = plum_test_support::parse(src);
-    plum_core::lower::frontEnd(&mut source).expect("front end");
+    plum_core::lower::frontEndDiag(&mut source).expect("front end");
     let r = checkSource(&source).map_err(|e| e.into_iter().map(|x| x.message).collect::<Vec<_>>().join(" | "));
     r
 }

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

@@ -3,7 +3,7 @@ use plum_checker::checkSource;
 fn run(src: &str) -> Result<(), String> {
     let mut source = plum_test_support::parseRawSource(src);
-    plum_core::lower::frontEnd(&mut source).expect("front end");
+    plum_core::lower::frontEndDiag(&mut source).expect("front end");
     let r = checkSource(&source)
         .map_err(|e| e.into_iter().map(|x| x.message).collect::<Vec<_>>().join(" | "));
     r

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

@@ -9,7 +9,7 @@ enum Shape = Ring(r: Float) | Dot
 fn run(body: &str) -> Result<(), String> {
     let src = format!("{DEFS}\n{body}\n");
     let mut source = plum_test_support::parse(&src);
-    plum_core::lower::frontEnd(&mut source).expect("front end");
+    plum_core::lower::frontEndDiag(&mut source).expect("front end");
     let r = checkSource(&source).map_err(|e| e.into_iter().map(|x| x.message).collect::<Vec<_>>().join(" | "));
     r
 }

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

@@ -9,7 +9,7 @@ enum Shape = Ring(r: Float) | Dot
 fn run(body: &str) -> Result<(), Vec<String>> {
     let src = format!("{DEFS}\n{body}\n");
     let mut source = plum_test_support::parse(&src);
-    plum_core::lower::frontEnd(&mut source).expect("front end");
+    plum_core::lower::frontEndDiag(&mut source).expect("front end");
     let r = checkSource(&source).map_err(|e| e.into_iter().map(|x| x.message).collect());
     r
 }

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

@@ -1,6 +1,8 @@
 #![allow(non_snake_case)]
-//! The supercompiler stage of `typedSource`: switches, explain notes, re-check fallback.
+//! The supercompiler stage of `plum_driver::check`: switches, explain notes, re-check fallback.
-use plum_checker::{checkSource, fusionRewrite, recheckKeep, typedSource};
+use plum_checker::{checkSource, TypedInfo};
+use plum_core::Diagnostic;
+use plum_driver::{fusionNotes, PassOptions};
 use plum_core::ast::Source;
 use plum_test_support::parse;
@@ -27,6 +29,11 @@ fun count(n: Int) -> Int =
   s
 ";
+/// The checker plus the default pass list.
+fn typedSource(source: &Source) -> Result<TypedInfo, Vec<Diagnostic>> {
+    plum_driver::check(source, &PassOptions::default())
+}
 fn lowered(src: &str) -> Source {
     let info = typedSource(&parse(src)).expect("checks");
     (**info.lowered.as_ref().unwrap()).clone()
@@ -51,23 +58,10 @@ fn fused_site_is_in_lowered_program() {
 #[test]
 fn rewritten_program_still_checks() {
     let mut copy = lowered(SRC);
-    fusionRewrite(&mut copy);
+    fusionNotes(&mut copy);
     assert!(checkSource(&copy).is_ok());
     // an already-fused program yields no further notes
-    assert!(fusionRewrite(&mut copy).is_empty());
+    assert!(fusionNotes(&mut copy).is_empty());
-}
-#[test]
-fn failed_recheck_keeps_original() {
-    let src = parse(SRC);
-    let mut info = typedSource(&src).expect("checks");
-    let before = std::rc::Rc::as_ptr(info.lowered.as_ref().unwrap());
-    let mut result = Ok(());
-    // A copy that cannot type-check: `total` now returns a Bool for an Int.
-    let bad = parse(&SRC.replace("sumL(mapCells(xs))", "True"));
-    assert!(!recheckKeep(bad, &mut result, &mut info));
-    assert!(result.is_ok());
-    assert_eq!(std::rc::Rc::as_ptr(info.lowered.as_ref().unwrap()), before);
 }
 fn plumBin() -> Option<std::path::PathBuf> {
@@ -128,7 +122,7 @@ fn fusion_runs_without_loops_or_unions() {
 fn explain_lists_unproved_uniqueness() {
     let src = "struct Pt(x: Int, y: Int)\nfun bad(s: Pt) -> Pt =\n  k := s\n  Pt(..s, x: 1)\n";
     let mut copy = parse(src);
-    let notes = fusionRewrite(&mut copy);
+    let notes = fusionNotes(&mut copy);
     let n = notes.iter().find(|n| n.contains("not in place")).unwrap_or_else(|| panic!("{notes:?}"));
     assert!(n.contains("aliased"), "{n}");
 }

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

@@ -13,7 +13,7 @@ struct Circle(r: Float)
 fn run(defs: &str, body: &str) -> Result<(), Vec<String>> {
     let src = format!("{defs}\n{body}\n");
     let mut source = plum_test_support::parse(&src);
-    plum_core::lower::frontEnd(&mut source).expect("front end");
+    plum_core::lower::frontEndDiag(&mut source).expect("front end");
     checkSource(&source).map_err(|e| e.into_iter().map(|x| x.message).collect())
 }

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

@@ -2,6 +2,7 @@
 //! Single integration-test binary for plum-checker (one link instead of one per file).
 mod checker_tests;
 mod closure_hint_test;
+mod diagnostic_tests;
 mod explicit_generics_tests;
 mod features;
 mod fusion_pipeline_test;

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

@@ -24,7 +24,7 @@ enum ErrB =
 fn run(body: &str) -> Result<(), Vec<String>> {
     let src = format!("{DEFS}\n{body}\n");
     let mut source = plum_test_support::parse(&src);
-    plum_core::lower::frontEnd(&mut source).expect("front end");
+    plum_core::lower::frontEndDiag(&mut source).expect("front end");
     checkSource(&source).map_err(|e| e.into_iter().map(|x| x.message).collect())
 }
@@ -221,7 +221,7 @@ fn removed_forms_fail_to_compile() {
         let failed = match parsed {
             Err(_) => true,
             Ok(mut source) => {
-                plum_core::lower::frontEnd(&mut source).is_err() || checkSource(&source).is_err()
+                plum_core::lower::frontEndDiag(&mut source).is_err() || checkSource(&source).is_err()
             }
         };
         assert!(failed, "should fail to compile: {body}");

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

@@ -20,7 +20,7 @@ struct Plain(q: Int)
 fn run(body: &str) -> Result<(), String> {
     let src = format!("{DEFS}\n{body}\n");
     let mut source = plum_test_support::parseRawSource(&src);
-    plum_core::lower::frontEnd(&mut source).map_err(|e| format!("lower: {e}"))?;
+    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(" | "))
 }
@@ -86,7 +86,7 @@ fn noWildcardMessageIsClear() {
 fn abstractStructMethodAccepted() {
     let src = "struct Actor(x: Int) =\n  abstract fun draw(self) -> Int\n\nstruct Ship(Actor(x)) =\n  override fun draw(self) -> Int = 2\n\nfun f(a: Actor) -> Int = a.draw()\n";
     let mut source = plum_test_support::parseRawSource(src);
-    plum_core::lower::frontEnd(&mut source).unwrap();
+    plum_core::lower::frontEndDiag(&mut source).unwrap();
     checkSource(&source).unwrap();
 }
@@ -94,14 +94,14 @@ fn abstractStructMethodAccepted() {
 fn bodilessTopLevelFnStillErrors() {
     let src = "fun g() -> Int\n";
     let mut source = plum_test_support::parseRawSource(src);
-    plum_core::lower::frontEnd(&mut source).unwrap();
+    plum_core::lower::frontEndDiag(&mut source).unwrap();
     let e = checkSource(&source).unwrap_err();
     assert!(e.iter().any(|x| x.message.contains("missing a body")));
 }
 fn checkErrs(src: &str) -> Vec<String> {
     let mut source = plum_test_support::parseRawSource(src);
-    plum_core::lower::frontEnd(&mut source).unwrap();
+    plum_core::lower::frontEndDiag(&mut source).unwrap();
     checkSource(&source).unwrap_err().into_iter().map(|x| x.message).collect()
 }

plum-cli/Cargo.toml CHANGED Viewed

@@ -11,6 +11,7 @@ path = "src/main.rs"
 [dependencies]
 plum-core = { path = "../plum-core" }
 plum-checker = { path = "../plum-checker" }
+plum-driver = { path = "../plum-driver" }
 plum-wasm-codegen = { path = "../plum-wasm-codegen" }
 clap = { version = "4", features = ["derive"] }
 anyhow = "1"

plum-cli/src/game.rs CHANGED Viewed

@@ -227,7 +227,7 @@ pub fn cmdGame(
     port: Option<u16>,
     noOpen: bool,
     lib_path: Option<PathBuf>,
-    fusion: plum_checker::FusionOptions,
+    fusion: plum_driver::PassOptions,
 ) -> Result<()> {
     let lib_path = lib_path.unwrap_or_else(repoRoot);
     let wasm = crate::compileToWasm(&file, &lib_path, fusion)?;

plum-cli/src/main.rs CHANGED Viewed

@@ -9,6 +9,7 @@ use std::process;
 use anyhow::{Context, Result};
 use clap::{Parser, Subcommand};
+use plum_core::diag::{DiagKind, Diagnostic};
 use plum_core::formatSource;
 mod editor;
@@ -138,14 +139,31 @@ fn main() {
 }
 /// The `--no-fusion` / `--explain-fusion` flags of a command, as explicit fusion options.
-fn fusionFlags(explain: bool, no_fusion: bool) -> plum_checker::FusionOptions {
+fn fusionFlags(explain: bool, no_fusion: bool) -> plum_driver::PassOptions {
-    plum_checker::FusionOptions { enabled: !no_fusion, explain }
+    plum_driver::PassOptions { fusion: !no_fusion, explain, ..plum_driver::PassOptions::default() }
 }
-/// `compile` reports positioned type errors without a file name; name `file` in them
+/// One diagnostic as `file:line:col: <kind>: message`. `entry` names the file when the
-/// (the entry file, since positions refer to the merged source).
+/// diagnostic carries none (positions then refer to the merged entry source).
-fn nameFileInErrors(msg: &str, file: &std::path::Path) -> String {
+fn renderDiag(d: &Diagnostic, entry: &std::path::Path) -> String {
+    let prefix = match d.kind {
+        DiagKind::Parse => "parse error: ",
+        DiagKind::Type | DiagKind::Resolution => "type error: ",
+        DiagKind::Codegen => "codegen error: ",
+        DiagKind::Load => "",
+    };
+    let file = if d.file.is_empty() { entry.display().to_string() } else { d.file.clone() };
+    if d.line > 0 {
+        format!("{}:{}:{}: {}{}", file, d.line, d.column, prefix, d.message)
+    } else if d.kind == DiagKind::Load || (d.file.is_empty() && d.kind == DiagKind::Codegen) {
+        format!("{}{}", prefix, d.message)
+    } else {
+        format!("{}: {}{}", file, prefix, d.message)
+    }
+}
+fn renderAll(ds: &[Diagnostic], entry: &std::path::Path) -> String {
-    msg.replace("type error at line", &format!("type error in '{}' at line", file.display()))
+    ds.iter().map(|d| renderDiag(d, entry)).collect::<Vec<_>>().join("\n")
 }
 fn run() -> Result<()> {
@@ -225,25 +243,24 @@ fn cmdFormat(file: Option<std::path::PathBuf>, check: bool, use_stdin: bool) ->
 fn compileToWasm(
     file: &std::path::Path,
     lib_path: &std::path::Path,
-    fusion: plum_checker::FusionOptions,
+    fusion: plum_driver::PassOptions,
 ) -> Result<Vec<u8>> {
-    let ast = plum_core::loadAndMerge(file, lib_path).map_err(|e| anyhow::anyhow!("{e}"))?;
+    let ast = plum_core::loadAndMergeDiag(file, lib_path).map_err(|e| anyhow::anyhow!("{}", renderAll(&e, file)))?;
-    plum_wasm_codegen::compile(&ast, &plum_wasm_codegen::CompileOptions { tests: false, fusion }).map(|o| o.wasm).map_err(|e| {
+    plum_wasm_codegen::compile(&ast, &plum_wasm_codegen::CompileOptions { tests: false, passes: fusion })
+        .map(|o| o.wasm)
-        if e.starts_with("type error") {
+        .map_err(|ds| {
-            eprintln!("{}", nameFileInErrors(&e, file));
+            eprintln!("{}", renderAll(&ds, file));
             process::exit(1);
-        }
-        anyhow::anyhow!("codegen error: {e}")
-    })
+        })
 }
 fn compileToTestWasm(
     file: &std::path::Path,
     lib_path: &std::path::Path,
-    fusion: plum_checker::FusionOptions,
+    fusion: plum_driver::PassOptions,
 ) -> Result<(Vec<u8>, Vec<String>)> {
-    let ast = plum_core::loadAndMerge(file, lib_path).map_err(|e| anyhow::anyhow!("{e}"))?;
+    let ast = plum_core::loadAndMergeDiag(file, lib_path).map_err(|e| anyhow::anyhow!("{}", renderAll(&e, file)))?;
     // Returns an error (rather than exiting the process directly, as
     // `compileToWasm`'s equivalent check does for the single-file
@@ -252,13 +269,7 @@ fn compileToTestWasm(
     // continue to the rest of the directory instead of the whole run
     // dying on the first file with a type error. Checked once, on the
     // test-desugared source codegen then compiles.
-    let out = plum_wasm_codegen::compile(&ast, &plum_wasm_codegen::CompileOptions { tests: true, fusion }).map_err(|e| {
+    let out = plum_wasm_codegen::compile(&ast, &plum_wasm_codegen::CompileOptions { tests: true, passes: fusion }).map_err(|ds| anyhow::anyhow!("{}", renderAll(&ds, file)))?;
-        if e.starts_with("type error") {
-            anyhow::anyhow!(nameFileInErrors(&e, file))
-        } else {
-            anyhow::anyhow!("codegen error: {e}")
-        }
-    })?;
     let compiled = (out.wasm, out.test_names);
     // Debug aid: `PLUM_DUMP_WASM=out.wasm plum test file.plum` keeps the module.
     if let Some(path) = std::env::var_os("PLUM_DUMP_WASM") {
@@ -272,7 +283,7 @@ fn cmdCompile(
     output: Option<std::path::PathBuf>,
     lib_path: std::path::PathBuf,
 ) -> Result<()> {
-    let wasm_bytes = compileToWasm(&file, &lib_path, plum_checker::FusionOptions::default())?;
+    let wasm_bytes = compileToWasm(&file, &lib_path, plum_driver::PassOptions::default())?;
     let out_path = output.unwrap_or_else(|| file.with_extension("wasm"));
     fs::write(&out_path, &wasm_bytes)
@@ -285,7 +296,7 @@ fn cmdCompile(
 fn cmdRun(
     file: std::path::PathBuf,
     lib_path: std::path::PathBuf,
-    fusion: plum_checker::FusionOptions,
+    fusion: plum_driver::PassOptions,
 ) -> Result<()> {
     let wasm_bytes = compileToWasm(&file, &lib_path, fusion)?;
@@ -356,7 +367,7 @@ fn collectPlumFiles(path: &std::path::Path) -> Result<Vec<std::path::PathBuf>> {
 fn cmdTest(
     paths: Vec<std::path::PathBuf>,
     lib_path: std::path::PathBuf,
-    fusion: plum_checker::FusionOptions,
+    fusion: plum_driver::PassOptions,
 ) -> Result<()> {
     // A single plain file keeps the exact original single-file UX (no
     // `=== path ===` header, no aggregate summary line, no "N/1 files
@@ -438,7 +449,7 @@ fn cmdTest(
 fn runTestFile(
     file: &std::path::Path,
     lib_path: &std::path::Path,
-    fusion: plum_checker::FusionOptions,
+    fusion: plum_driver::PassOptions,
 ) -> Result<(usize, usize)> {
     let (wasm_bytes, names) = compileToTestWasm(file, lib_path, fusion)?;
     if let Ok(path) = std::env::var("PLUM_DUMP_WASM") {
@@ -562,7 +573,7 @@ fn cmdBuild(
     file: std::path::PathBuf,
     output: Option<std::path::PathBuf>,
     lib_path: std::path::PathBuf,
-    fusion: plum_checker::FusionOptions,
+    fusion: plum_driver::PassOptions,
 ) -> Result<()> {
     let wasm_bytes = compileToWasm(&file, &lib_path, fusion)?;

plum-cli/tests/cli/compile_tests.rs CHANGED Viewed

@@ -107,3 +107,19 @@ fn returnBodySuggestedByTheParseErrorHintCompiles() {
         String::from_utf8_lossy(&output.stderr)
     );
 }
+#[test]
+fn undefinedNameIsReportedAsFileLineColumnTypeError() {
+    let dir = freshTempDir("undefined_name");
+    let src_path = dir.join("bad.plum");
+    std::fs::write(&src_path, "fun f(a: Unit) -> Unit =\n  b\n").unwrap();
+    let out = Command::new(plumBin())
+        .args(["compile", src_path.to_str().unwrap(), "-o", dir.join("bad.wasm").to_str().unwrap()])
+        .output()
+        .expect("failed to run plum compile");
+    assert_eq!(out.status.code(), Some(1));
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    let line = stderr.lines().find(|l| l.contains("undefined name")).unwrap_or_else(|| panic!("{stderr}"));
+    assert!(line.contains("bad.plum:2:3: type error: "), "{line}");
+    assert!(line.contains("undefined name 'b'"), "{line}");
+}

plum-cli/tests/cli/crash_test.rs CHANGED Viewed

@@ -61,5 +61,5 @@ fn int_literal_overflow_error_has_position() {
         all.contains("integer literal out of range"),
         "output: {all}"
     );
-    assert!(all.contains("lit.plum' at line 4, column"), "output: {all}");
+    assert!(all.contains("lit.plum:4:"), "output: {all}");
 }

plum-core/Cargo.toml CHANGED Viewed

@@ -13,6 +13,7 @@ topiary-tree-sitter-facade = "0.7.3"
 plum-test-support = { path = "../plum-test-support" }
 tempfile = "3"
 plum-checker = { path = "../plum-checker" }
+plum-driver = { path = "../plum-driver" }
 plum-wasm-codegen = { path = "../plum-wasm-codegen" }
 wasmparser = "0.220"
 wasmtime = "47"

plum-core/src/diag.rs ADDED Viewed

@@ -0,0 +1,50 @@
+//! The one error value between parser, loader, lowering, checker, driver, codegen and tools.
+use std::fmt;
+/// What produced a diagnostic. Callers decide behaviour from the kind, never from the text.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DiagKind {
+    /// Syntax: a token tree-sitter could not fit, a malformed node, a misplaced top-level form.
+    Parse,
+    /// Reading or resolving files: unreadable file, missing import, duplicate declaration.
+    Load,
+    /// A name that does not resolve, or a declaration rule (imports, extension rules).
+    Resolution,
+    /// A type or lowering error.
+    Type,
+    /// A failure while generating code.
+    Codegen,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct Diagnostic {
+    /// The file the error is in; empty when unknown.
+    pub file: String,
+    /// 1-based; 0 when no position is known.
+    pub line: usize,
+    pub column: usize,
+    pub kind: DiagKind,
+    pub message: String,
+}
+impl Diagnostic {
+    pub fn new(kind: DiagKind, file: impl Into<String>, line: usize, column: usize, message: impl Into<String>) -> Self {
+        Diagnostic { file: file.into(), line, column, kind, message: message.into() }
+    }
+    /// A diagnostic with no position (and no file).
+    pub fn bare(kind: DiagKind, message: impl Into<String>) -> Self {
+        Diagnostic::new(kind, "", 0, 0, message)
+    }
+}
+impl fmt::Display for Diagnostic {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match (self.file.is_empty(), self.line) {
+            (true, 0) => write!(f, "{}", self.message),
+            (true, l) => write!(f, "{}:{}: {}", l, self.column, self.message),
+            (false, 0) => write!(f, "{}: {}", self.file, self.message),
+            (false, l) => write!(f, "{}:{}:{}: {}", self.file, l, self.column, self.message),
+        }
+    }
+}

plum-core/src/drive.rs CHANGED Viewed

@@ -33,6 +33,25 @@ pub fn drive(src: &mut Source, pure: &HashSet<String>) -> Vec<String> {
     d.notes
 }
+/// Why a consumer could not be unfolded as a one-expression wrapper.
+enum Unfold {
+    /// Its body is not one expression: no wrapper, so no candidate unless handed a just-built value.
+    NotAConsumer,
+    Other(String),
+}
+impl From<String> for Unfold {
+    fn from(s: String) -> Self {
+        Unfold::Other(s)
+    }
+}
+impl From<&str> for Unfold {
+    fn from(s: &str) -> Self {
+        Unfold::Other(s.to_string())
+    }
+}
 #[derive(Clone)]
 struct Call {
     key: String,
@@ -912,7 +931,7 @@ impl Driver {
                     }
                     // a fn that neither matches nor wraps is no consumer: not a candidate,
                     // unless it is handed a just-built value it could have taken apart
-                    Err(why) if why.starts_with("consumer ") => {
+                    Err(Unfold::NotAConsumer) => {
                         if let Some(t) = &built {
                             self.note(format!(
                                 "not specialised: {} on a just-built {}: its body is not one match on that parameter",
@@ -920,7 +939,7 @@ impl Driver {
                             ));
                         }
                     }
-                    Err(why) => self.note(format!("not fused: {} of {}: {}", c.key, pk, why)),
+                    Err(Unfold::Other(why)) => self.note(format!("not fused: {} of {}: {}", c.key, pk, why)),
                 }
                 continue;
             };
@@ -1268,10 +1287,10 @@ impl Driver {
     /// A non-recursive consumer whose body is one expression, instantiated at the call
     /// (its own effects stay; arguments must be pure or used at most once).
-    fn unfold(&mut self, c: &Call) -> Result<Expr, String> {
+    fn unfold(&mut self, c: &Call) -> Result<Expr, Unfold> {
         let b = bodyBlock(&c.f).ok_or("extern consumer")?;
         let [Stmt::Expr(body, ..)] = &b.stmts[..] else {
-            return Err(format!("consumer {} is neither a single match on a parameter nor a one-expression wrapper", c.key));
+            return Err(Unfold::NotAConsumer);
         };
         let mut recursive = false;
         walkRef(body, &mut |x| match x {
@@ -1284,22 +1303,22 @@ impl Driver {
             _ => {}
         });
         if recursive {
-            return Err(format!("wrapper {} is recursive", c.key));
+            return Err(format!("wrapper {} is recursive", c.key).into());
         }
         if c.args.len() != pnames(&c.f).len() {
-            return Err("argument count".to_string());
+            return Err("argument count".to_string().into());
         }
         let (names, rb) = self.renamed(&c.f, "$u").ok_or("extern consumer")?;
         let mut stmts = rb.stmts;
-        let Some(Stmt::Expr(mut body, ..)) = stmts.pop() else { return Err("wrapper body".to_string()) };
+        let Some(Stmt::Expr(mut body, ..)) = stmts.pop() else { return Err("wrapper body".into()) };
         for (n, a) in names.iter().zip(&c.args) {
             let uses = cnt(&body, n, true);
             let trivial = matches!(a, Expr::Var(_) | Expr::Int(_) | Expr::Float(_) | Expr::BoolLit(_) | Expr::TypeName(_));
             if !self.argPure(a) {
-                return Err(format!("argument of wrapper {} has effects", c.key));
+                return Err(format!("argument of wrapper {} has effects", c.key).into());
             }
             if uses > 1 && !trivial {
-                return Err(format!("wrapper {} uses an argument {} times", c.key, uses));
+                return Err(format!("wrapper {} uses an argument {} times", c.key, uses).into());
             }
         }
         let map: HashMap<&String, &Expr> = names.iter().zip(c.args.iter()).collect();

plum-core/src/lib.rs CHANGED Viewed

@@ -7,6 +7,7 @@ pub mod builtin_usage;
 pub mod closure_escape;
 pub mod closure_spec;
 pub mod ctors;
+pub mod diag;
 pub mod drive;
 pub mod embeds;
 pub mod formatter;
@@ -33,7 +34,9 @@ pub mod whistle;
 pub use formatter::{
     formatSource, formatSourceWithOpts, inlineSingleStatementCaseBodies, FormatterError,
 };
+pub use diag::{DiagKind, Diagnostic};
 pub use loader::{
+    loadAndMergeDiag, loadAndMergeWithOverridesDiag,
-    loadAndMerge, loadAndMergeWithOverrides, syntaxErrors, SyntaxError, SyntaxErrorKind,
+    syntaxErrors, SyntaxError, SyntaxErrorKind,
 };
 pub use parser::AstParser;

plum-core/src/loader.rs CHANGED Viewed

@@ -3,6 +3,7 @@ use std::path::{Path, PathBuf};
 use crate::ast::{Import, Item, PrimitiveDecl, Source, BUILTIN_PRIMITIVES};
 use crate::builtin_usage::usedBuiltinTypeNames;
+use crate::diag::{DiagKind, Diagnostic};
 use crate::parser::AstParser;
 /// Resolves `entry`'s `import` statements (transitively, and tolerating
@@ -15,8 +16,19 @@ use crate::parser::AstParser;
 /// `import "std/option"` resolves to `<lib_path>/plum-std/option.plum` — the
 /// on-disk stdlib directory is `plum-std`, but source files keep writing
 /// `std/...` imports, so the `std/` prefix is remapped here.
-pub fn loadAndMerge(entry: &Path, lib_path: &Path) -> Result<Source, String> {
+pub fn loadAndMergeDiag(entry: &Path, lib_path: &Path) -> Result<Source, Vec<Diagnostic>> {
-    loadAndMergeWithOverrides(entry, lib_path, &HashMap::new())
+    loadAndMergeWithOverridesDiag(entry, lib_path, &HashMap::new())
+}
+/// What the loader's internal steps fail with.
+type Loaded_<T> = Result<T, Vec<Diagnostic>>;
+fn load(message: String) -> Vec<Diagnostic> {
+    vec![Diagnostic::bare(DiagKind::Load, message)]
+}
+fn resolution(message: String) -> Vec<Diagnostic> {
+    vec![Diagnostic::bare(DiagKind::Resolution, message)]
 }
 /// Same as [`loadAndMerge`], but `overrides` (keyed by canonicalized path)
@@ -27,11 +39,11 @@ pub fn loadAndMerge(entry: &Path, lib_path: &Path) -> Result<Source, String> {
 /// This exists for editor tooling (see `plum-lsp`): an LSP client's `entry`
 /// document is often unsaved, so its on-disk content is stale or, for a
 /// brand-new file, doesn't exist at all yet.
-pub fn loadAndMergeWithOverrides(
+pub fn loadAndMergeWithOverridesDiag(
     entry: &Path,
     lib_path: &Path,
     overrides: &HashMap<PathBuf, String>,
-) -> Result<Source, String> {
+) -> Result<Source, Vec<Diagnostic>> {
     // `entry` itself may not exist on disk yet (a new, never-saved buffer),
     // so canonicalize its parent instead and rejoin the file name — same
     // trick `std::fs::canonicalize` can't do for us since it requires the
@@ -71,7 +83,7 @@ pub fn loadAndMergeWithOverrides(
         formLoops: false,
         primitives: prims,
     };
-    crate::lower::frontEnd(&mut merged)?;
+    crate::lower::frontEndDiag(&mut merged)?;
     Ok(merged)
 }
@@ -81,7 +93,7 @@ pub fn loadAndMergeWithOverrides(
 /// stateless namespace, so it leaves the namespace list. Outside std this
 /// form is an error. A built-in's `primitive` block is extended the same way
 /// with no extra rule: its methods are flat items.
-fn dropExtensions(items: &[Item], prims: &mut Vec<PrimitiveDecl>) -> Result<(), String> {
+fn dropExtensions(items: &[Item], prims: &mut Vec<PrimitiveDecl>) -> Loaded_<()> {
     let declared = |n: &str| items.iter().any(|i| matches!(i, Item::Enum(e) if e.name == n));
     let bad = USER_PRIMS.with(|u| {
         u.borrow()
@@ -90,17 +102,19 @@ fn dropExtensions(items: &[Item], prims: &mut Vec<PrimitiveDecl>) -> Result<(),
             .map(|(n, f)| (n.clone(), f.clone()))
     });
     if let Some((n, f)) = bad {
-        return Err(format!(
+        return Err(vec![Diagnostic::new(
+            DiagKind::Resolution,
+            f.display().to_string(),
+            0,
+            0,
-            "{}: primitive {} extends a declared type and is only allowed in std",
+            format!("primitive {} extends a declared type and is only allowed in std", n),
-            f.display(),
-            n
-        ));
+        )]);
     }
     prims.retain(|p| !declared(&p.name));
     Ok(())
 }
-fn canonicalizeMaybeMissing(path: &Path) -> Result<PathBuf, String> {
+fn canonicalizeMaybeMissing(path: &Path) -> Loaded_<PathBuf> {
     if let Ok(canon) = std::fs::canonicalize(path) {
         return Ok(canon);
     }
@@ -109,13 +123,13 @@ fn canonicalizeMaybeMissing(path: &Path) -> Result<PathBuf, String> {
         .filter(|p| !p.as_os_str().is_empty())
         .unwrap_or(Path::new("."));
     let file_name = path.file_name().ok_or_else(|| {
-        format!(
+        load(format!(
             "cannot read entry file '{}': not a file path",
             path.display()
-        )
+        ))
     })?;
     let parent_canon = std::fs::canonicalize(parent)
-        .map_err(|e| format!("cannot read entry file '{}': {}", path.display(), e))?;
+        .map_err(|e| load(format!("cannot read entry file '{}': {}", path.display(), e)))?;
     Ok(parent_canon.join(file_name))
 }
@@ -131,18 +145,18 @@ fn isStdFile(path: &Path) -> bool {
 }
 /// `import std/x` -> `<lib_path>/plum-std/x.plum`, canonicalized.
-fn resolveImport(import: &Import, lib_path: &Path) -> Result<PathBuf, String> {
+fn resolveImport(import: &Import, lib_path: &Path) -> Loaded_<PathBuf> {
     let resolved_path = match import.path.strip_prefix("std/") {
         Some(rest) => format!("plum-std/{}", rest),
         None => import.path.clone(),
     };
     let target = lib_path.join(format!("{}.plum", resolved_path));
     std::fs::canonicalize(&target).map_err(|_| {
-        format!(
+        load(format!(
             "import '{}': no such file '{}'",
             import.path,
             target.display()
-        )
+        ))
     })
 }
@@ -154,7 +168,7 @@ fn collectImport(
     overrides: &HashMap<PathBuf, String>,
     visited: &mut HashSet<PathBuf>,
     files: &mut Vec<Loaded>,
-) -> Result<(), String> {
+) -> Loaded_<()> {
     let target_canon = resolveImport(import, lib_path)?;
     if !visited.insert(target_canon.clone()) {
         // Already loaded — a diamond import or a cycle.
@@ -187,7 +201,7 @@ fn declaredTypes(source: &Source) -> Vec<String> {
 /// on its own, e.g. `std/Int` importing `std/Pair`). The std type is renamed in
 /// every std file (`Pair` -> `PairStd`), so std code keeps its own type and the
 /// user's name means the user's type. A directly imported one stays a duplicate.
-fn shadowStdTypes(files: &mut [Loaded], lib_path: &Path) -> Result<(), String> {
+fn shadowStdTypes(files: &mut [Loaded], lib_path: &Path) -> Loaded_<()> {
     let mut user: HashSet<String> = HashSet::new();
     let mut direct: HashSet<PathBuf> = HashSet::new();
     let mut all: HashSet<String> = HashSet::new();
@@ -234,8 +248,8 @@ fn shadowStdTypes(files: &mut [Loaded], lib_path: &Path) -> Result<(), String> {
 /// `text` with every `type_identifier` token named in `rename` replaced (comments and
 /// string text untouched); `None` when none occurs.
-fn renameTypeIdents(text: &str, rename: &HashMap<String, String>) -> Result<Option<String>, String> {
+fn renameTypeIdents(text: &str, rename: &HashMap<String, String>) -> Loaded_<Option<String>> {
-    let tree = treeOf(text)?;
+    let tree = treeOf(text).map_err(load)?;
     let mut spans: Vec<(usize, usize, &str)> = Vec::new();
     let mut cursor = tree.root_node().walk();
     let mut stack = vec![tree.root_node()];
@@ -271,7 +285,7 @@ fn renameTypeIdents(text: &str, rename: &HashMap<String, String>) -> Result<Opti
 /// `import std/Int` / `import std/Float` / `import std/Str` — except in
 /// `Int.plum`/`Float.plum`/`Str.plum` themselves, which declare the type
 /// rather than import it.
-fn checkBuiltinImports(path: &Path, source: &Source) -> Result<(), String> {
+fn checkBuiltinImports(path: &Path, source: &Source) -> Loaded_<()> {
     checkExtends(path, source)?;
     let used = usedBuiltinTypeNames(source);
     for name in ["Int", "Float", "Str"] {
@@ -292,12 +306,12 @@ fn checkBuiltinImports(path: &Path, source: &Source) -> Result<(), String> {
         let import_path = format!("std/{}", name);
         let already_imported = source.imports.iter().any(|imp| imp.path == import_path);
         if !already_imported {
-            return Err(format!(
+            return Err(resolution(format!(
                 "'{}' uses type '{}' but doesn't import it: add `import {}`",
                 path.display(),
                 name,
                 import_path
-            ));
+            )));
         }
     }
     Ok(())
@@ -311,11 +325,11 @@ fn displayPath(path: &Path) -> String {
     rel.as_deref().unwrap_or(path).display().to_string()
 }
-fn readText(path: &Path, overrides: &HashMap<PathBuf, String>) -> Result<String, String> {
+fn readText(path: &Path, overrides: &HashMap<PathBuf, String>) -> Loaded_<String> {
     match overrides.get(path) {
         Some(text) => Ok(text.clone()),
         None => std::fs::read_to_string(path)
-            .map_err(|e| format!("cannot read '{}': {}", path.display(), e)),
+            .map_err(|e| load(format!("cannot read '{}': {}", path.display(), e))),
     }
 }
@@ -327,8 +341,12 @@ fn treeOf(text: &str) -> Result<tree_sitter::Tree, String> {
     parser.parse(text, None).ok_or_else(|| "parse failed".to_string())
 }
+fn treeOfIn(text: &str, path: &Path) -> Loaded_<tree_sitter::Tree> {
+    treeOf(text).map_err(|e| vec![Diagnostic::bare(DiagKind::Parse, format!("{} for '{}'", e, path.display()))])
+}
-fn parseText(path: &Path, text: &str) -> Result<Source, String> {
+fn parseText(path: &Path, text: &str) -> Loaded_<Source> {
-    let tree = treeOf(text).map_err(|e| format!("{} for '{}'", e, path.display()))?;
+    let tree = treeOfIn(text, path)?;
     let root = tree.root_node();
     // `Parser::parse` only returns `None` on a timeout/cancellation — an
     // unparseable token still produces a tree, just with an `ERROR` node
@@ -338,20 +356,25 @@ fn parseText(path: &Path, text: &str) -> Result<Source, String> {
     // anywhere in the file silently discarded every top-level item after
     // it — no parse error, just fewer items than the file actually has.
     if let Some(err) = syntaxErrors(root, &text).into_iter().next() {
-        return Err(format!(
+        return Err(vec![Diagnostic::new(
-            "parse error in '{}' at line {}, column {}: {}",
+            DiagKind::Parse,
-            path.display(),
+            path.display().to_string(),
             err.start.row + 1,
             err.start.column + 1,
             err.message(),
-        ));
+        )]);
     }
     let ap = AstParser::new(&text);
     let mut source = ap.parseSourceRaw(root);
+    // A malformed node the grammar let through: report the first one.
+    if let Some(mut d) = ap.diagnostics().into_iter().next() {
+        d.file = path.display().to_string();
+        return Err(vec![d]);
+    }
     source.stampFile(&displayPath(path));
-    source
-        .checkTopLevelOrder()
+    source.checkTopLevelOrder().map_err(|e| {
-        .map_err(|e| format!("{} in '{}'", e, path.display()))?;
+        vec![Diagnostic::new(DiagKind::Parse, path.display().to_string(), 0, 0, e)]
+    })?;
     Ok(source)
 }
@@ -631,10 +654,10 @@ fn mergeItems(
     items: &mut Vec<Item>,
     names: &mut HashMap<String, PathBuf>,
     prims: &mut Vec<PrimitiveDecl>,
-) -> Result<(), String> {
+) -> Loaded_<()> {
     // Removed forms, then inline variants as hidden records (per-file lowering).
     let mut hoisted = source.clone();
-    crate::lower::perFile(&mut hoisted)?;
+    crate::lower::perFileDiag(&mut hoisted)?;
     let source = &hoisted;
     // Parse-time literal errors (out-of-range integers) of every merged file.
     MERGED_LIT_ERRORS.with(|e| e.borrow_mut().extend(source.formErrors.iter().cloned()));
@@ -676,23 +699,23 @@ fn mergeItems(
                     .get(&key)
                     .map(|f| f.display().to_string())
                     .unwrap_or_default();
-                return Err(format!(
+                return Err(load(format!(
                     "duplicate constant '{}': defined in {}:{} and {}:{}",
                     c.name,
                     prev_file,
                     prev.line,
                     file.display(),
                     c.line
-                ));
+                )));
             }
         }
         if let Some(existing_file) = names.get(&key) {
-            return Err(format!(
+            return Err(load(format!(
                 "duplicate declaration '{}': declared in both '{}' and '{}'",
                 key,
                 existing_file.display(),
                 file.display()
-            ));
+            )));
         }
         names.insert(key, file.to_path_buf());
         items.push(item.clone());
@@ -719,17 +742,17 @@ fn itemNameKey(item: &Item) -> String {
 /// A `primitive` named after a compiler built-in declares that type's API, so
 /// it is only for std; any other name is a stateless namespace, usable anywhere.
-fn checkExtends(path: &Path, source: &Source) -> Result<(), String> {
+fn checkExtends(path: &Path, source: &Source) -> Loaded_<()> {
     let inStd = path.components().any(|c| c.as_os_str() == "plum-std");
     for p in &source.primitives {
         if !inStd && BUILTIN_PRIMITIVES.contains(&p.name.as_str()) {
-            return Err(format!(
+            return Err(vec![Diagnostic::new(
-                "{}:{}:{}: primitive {} declares a built-in type and is only allowed in std",
+                DiagKind::Resolution,
-                path.display(),
+                path.display().to_string(),
                 p.line,
                 p.column,
-                p.name
+                format!("primitive {} declares a built-in type and is only allowed in std", p.name),
-            ));
+            )]);
         }
     }
     Ok(())

plum-core/src/lower.rs CHANGED Viewed

@@ -1,41 +1,47 @@
 use crate::ast::Source;
+use crate::diag::{DiagKind, Diagnostic};
+fn diags(kind: DiagKind, errors: Vec<String>) -> Vec<Diagnostic> {
+    errors.into_iter().map(|m| Diagnostic::bare(kind, m)).collect()
+}
 /// Per-file steps, run on each file before it is merged (and by single-file
 /// `parseSource`): removed-form errors and inline-variant checks. Inline variants stay
 /// ordinary named-field enum variants.
-pub fn perFile(source: &mut Source) -> Result<(), String> {
+pub fn perFileDiag(source: &mut Source) -> Result<(), Vec<Diagnostic>> {
     let legacy: Vec<String> = crate::unions::legacyErrors(source);
     if !legacy.is_empty() {
-        return Err(legacy.join("\n"));
+        return Err(diags(DiagKind::Parse, legacy));
     }
     let inlineErrors = crate::unions::inlineVariantErrors(source);
     if !inlineErrors.is_empty() {
-        return Err(inlineErrors.join("\n"));
+        return Err(diags(DiagKind::Type, inlineErrors));
     }
     Ok(())
 }
 /// Front-end lowering of a merged program: embeds, constructors, inline-variant
 /// type checks, union-enum errors, then forms. The first failing stage returns its
-/// errors joined with "\n".
+/// errors.
-pub fn frontEnd(source: &mut Source) -> Result<(), String> {
+pub fn frontEndDiag(source: &mut Source) -> Result<(), Vec<Diagnostic>> {
     crate::session::begin();
     let embedErrors = crate::embeds::lowerEmbeds(source);
     if !embedErrors.is_empty() {
-        return Err(embedErrors.join("\n"));
+        return Err(diags(DiagKind::Type, embedErrors));
     }
     let ctorErrors = crate::ctors::lowerCtors(source);
     if !ctorErrors.is_empty() {
-        return Err(ctorErrors.join("\n"));
+        return Err(diags(DiagKind::Type, ctorErrors));
     }
     let typeErrors = crate::unions::inlineVariantTypeErrors(source);
     if !typeErrors.is_empty() {
-        return Err(typeErrors.join("\n"));
+        return Err(diags(DiagKind::Type, typeErrors));
     }
     let memberErrors = crate::unions::unionMemberErrors(source);
     if !memberErrors.is_empty() {
-        return Err(memberErrors.join("\n"));
+        return Err(diags(DiagKind::Type, memberErrors));
     }
     crate::forms::prepareForms(source);
     Ok(())
 }

plum-core/src/parser.rs CHANGED Viewed

@@ -6,6 +6,8 @@ pub struct AstParser<'a> {
     /// Errors found while parsing literals (out-of-range integers); reported by
     /// the checker through `Source::formErrors`.
     litErrors: std::cell::RefCell<Vec<(usize, usize, String)>>,
+    /// Malformed nodes that got a placeholder instead of a real value.
+    malformed: std::cell::RefCell<Vec<crate::diag::Diagnostic>>,
 }
 impl<'a> AstParser<'a> {
@@ -13,9 +15,29 @@ impl<'a> AstParser<'a> {
         AstParser {
             source: source.as_bytes(),
             litErrors: std::cell::RefCell::new(Vec::new()),
+            malformed: std::cell::RefCell::new(Vec::new()),
         }
     }
+    /// The malformed nodes met so far (each got a placeholder expression); empty for any
+    /// tree the loader's syntax check accepted.
+    pub fn diagnostics(&self) -> Vec<crate::diag::Diagnostic> {
+        self.malformed.borrow().clone()
+    }
+    /// The placeholder for a missing child of `node`, recorded as a Parse diagnostic.
+    fn missing(&self, node: Node) -> Expr {
+        let pos = node.start_position();
+        self.malformed.borrow_mut().push(crate::diag::Diagnostic::new(
+            crate::diag::DiagKind::Parse,
+            "",
+            pos.row + 1,
+            pos.column + 1,
+            format!("incomplete {}", node.kind().replace('_', " ")),
+        ));
+        Expr::Int(0)
+    }
     fn text(&self, node: Node) -> String {
         node.utf8_text(self.source).unwrap_or("").to_string()
     }
@@ -64,8 +86,8 @@ impl<'a> AstParser<'a> {
     pub fn parseSource(&self, node: Node) -> Source {
         let mut source = self.parseSourceRaw(node);
         // Single-file path: errors are discarded; callers needing them call `lower::perFile` and `lower::frontEnd`.
-        let _ = crate::lower::perFile(&mut source);
+        let _ = crate::lower::perFileDiag(&mut source);
-        let _ = crate::lower::frontEnd(&mut source);
+        let _ = crate::lower::frontEndDiag(&mut source);
         source
     }
@@ -499,7 +521,7 @@ impl<'a> AstParser<'a> {
                 let unwrapped = self.unwrapExprNode(n);
                 self.parseExpression(unwrapped)
             })
-            .unwrap_or(Expr::Int(0));
+            .unwrap_or_else(|| self.missing(node));
         Const {
             name,
             value,
@@ -666,7 +688,7 @@ impl<'a> AstParser<'a> {
                         let u = self.unwrapExprNode(n);
                         self.parseExpression(u)
                     })
-                    .unwrap_or(Expr::Int(0)),
+                    .unwrap_or_else(|| self.missing(node)),
             ),
             "assert" => Stmt::Assert(self.parseCheck(node)),
             "while" => Stmt::While(self.parseWhile(node)),
@@ -784,7 +806,7 @@ impl<'a> AstParser<'a> {
                 let u = self.unwrapExprNode(*n);
                 self.parseExpression(u)
             })
-            .unwrap_or(Expr::Int(0));
+            .unwrap_or_else(|| self.missing(node));
         let body = named
             .last()
             .filter(|n| n.kind() == "body")
@@ -803,7 +825,7 @@ impl<'a> AstParser<'a> {
                 let u = self.unwrapExprNode(*n);
                 self.parseExpression(u)
             })
-            .unwrap_or(Expr::Int(0));
+            .unwrap_or_else(|| self.missing(node));
         let body = named
             .get(1)
             .filter(|n| n.kind() == "body")
@@ -836,7 +858,7 @@ impl<'a> AstParser<'a> {
                 let u = self.unwrapExprNode(*n);
                 self.parseExpression(u)
             })
-            .unwrap_or(Expr::Int(0));
+            .unwrap_or_else(|| self.missing(node));
         let body = named
             .last()
             .filter(|n| n.kind() == "body")
@@ -951,7 +973,7 @@ impl<'a> AstParser<'a> {
                         let u = self.unwrapExprNode(n);
                         self.parseExpression(u)
                     })
-                    .unwrap_or(Expr::Int(0));
+                    .unwrap_or_else(|| self.missing(node));
                 Expr::Not(Box::new(arg))
             }
             "boolean_operator" => self.parseBoolOp(node),
@@ -988,7 +1010,7 @@ impl<'a> AstParser<'a> {
                     value: node
                         .child_by_field_name("value")
                         .map(|n| self.parseExpression(self.unwrapExprNode(n)))
-                        .unwrap_or(Expr::Int(0)),
+                        .unwrap_or_else(|| self.missing(node)),
                 }))
             }
             "closure" => Expr::Closure(Box::new(self.parseClosure(node))),
@@ -1062,7 +1084,7 @@ impl<'a> AstParser<'a> {
                 let value = node
                     .child_by_field_name("value")
                     .map(|n| self.parsePrimaryExpression(self.unwrapExprNode(n)))
-                    .unwrap_or(Expr::Int(0));
+                    .unwrap_or_else(|| self.missing(node));
                 Expr::Bang(Box::new(BangExpr {
                     value,
                     line: pos.row + 1,
@@ -1080,7 +1102,7 @@ impl<'a> AstParser<'a> {
                         let u = self.unwrapExprNode(n);
                         self.parseExpression(u)
                     })
-                    .unwrap_or(Expr::Int(0));
+                    .unwrap_or_else(|| self.missing(node));
                 inner
             }
             "string" => Expr::String(self.parseString(node)),
@@ -1121,14 +1143,14 @@ impl<'a> AstParser<'a> {
                 let u = self.unwrapExprNode(*n);
                 self.parsePrimaryExpression(u)
             })
-            .unwrap_or(Expr::Int(0));
+            .unwrap_or_else(|| self.missing(node));
         let right = named
             .last()
             .map(|n| {
                 let u = self.unwrapExprNode(*n);
                 self.parsePrimaryExpression(u)
             })
-            .unwrap_or(Expr::Int(0));
+            .unwrap_or_else(|| self.missing(node));
         Expr::Binary(Box::new(BinaryExpr { op, left, right }))
     }
@@ -1153,7 +1175,7 @@ impl<'a> AstParser<'a> {
                 let u = self.unwrapExprNode(n);
                 self.parsePrimaryExpression(u)
             })
-            .unwrap_or(Expr::Int(0));
+            .unwrap_or_else(|| self.missing(node));
         Expr::Unary(Box::new(UnaryExpr { op, operand }))
     }
@@ -1171,14 +1193,14 @@ impl<'a> AstParser<'a> {
                 let u = self.unwrapExprNode(*n);
                 self.parseExpression(u)
             })
-            .unwrap_or(Expr::Int(0));
+            .unwrap_or_else(|| self.missing(node));
         let right = named
             .last()
             .map(|n| {
                 let u = self.unwrapExprNode(*n);
                 self.parseExpression(u)
             })
-            .unwrap_or(Expr::Int(0));
+            .unwrap_or_else(|| self.missing(node));
         Expr::Bool(Box::new(BoolExpr { op, left, right }))
     }
@@ -1201,14 +1223,14 @@ impl<'a> AstParser<'a> {
                 let u = self.unwrapExprNode(*n);
                 self.parseExpression(u)
             })
-            .unwrap_or(Expr::Int(0));
+            .unwrap_or_else(|| self.missing(node));
         let right = named
             .last()
             .map(|n| {
                 let u = self.unwrapExprNode(*n);
                 self.parseExpression(u)
             })
-            .unwrap_or(Expr::Int(0));
+            .unwrap_or_else(|| self.missing(node));
         Expr::Compare(Box::new(CompareExpr { op, left, right }))
     }
@@ -1220,7 +1242,7 @@ impl<'a> AstParser<'a> {
                     let u = self.unwrapExprNode(n);
                     self.parseExpression(u)
                 })
-                .unwrap_or(Expr::Int(0))
+                .unwrap_or_else(|| self.missing(node))
         };
         Expr::InlineIf(Box::new(InlineIf {
             condition: field("condition"),
@@ -1240,7 +1262,7 @@ impl<'a> AstParser<'a> {
                 let u = self.unwrapExprNode(*n);
                 self.parsePrimaryExpression(u)
             })
-            .unwrap_or(Expr::Int(0));
+            .unwrap_or_else(|| self.missing(node));
         let member = named.get(1).map(|n| self.text(*n)).unwrap_or_default();
         let attr = match named.get(2) {
             Some(args_node) => {
@@ -1304,7 +1326,7 @@ impl<'a> AstParser<'a> {
         if pairs > 0 && !mixed {
             let mut out = call(Expr::TypeName("Map".to_string()), "empty", vec![]);
             for p in elems {
-                let part = |i: u32| p.named_child(i).map(expr).unwrap_or(Expr::Int(0));
+                let part = |i: u32| p.named_child(i).map(expr).unwrap_or_else(|| self.missing(node));
                 out = call(out, "with", vec![part(0), part(1)]);
             }
             return out;
@@ -1313,7 +1335,7 @@ impl<'a> AstParser<'a> {
         let mut out = Expr::TypeName("Nil".to_string());
         for e in elems.into_iter().rev() {
             let value = match e.kind() {
-                "pair_argument" => e.named_child(0).map(expr).unwrap_or(Expr::Int(0)),
+                "pair_argument" => e.named_child(0).map(expr).unwrap_or_else(|| self.missing(node)),
                 _ => expr(e),
             };
             out = Expr::ClassCall(ClassCall {
@@ -1339,7 +1361,7 @@ impl<'a> AstParser<'a> {
                 let u = self.unwrapExprNode(n);
                 self.parsePrimaryExpression(u)
             })
-            .unwrap_or(Expr::Int(0));
+            .unwrap_or_else(|| self.missing(node));
         Expr::Question(Box::new(value))
     }
@@ -1384,7 +1406,7 @@ impl<'a> AstParser<'a> {
                         let u = self.unwrapExprNode(n);
                         self.parseExpression(u)
                     })
-                    .unwrap_or(Expr::Int(0));
+                    .unwrap_or_else(|| self.missing(node));
                 Arg::Keyword { name, value }
             }
             "pair_argument" => {

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

@@ -91,9 +91,9 @@ fn std_list_combinators_non_escaping() {
     let path = dir.join("main.plum");
     std::fs::write(&path, "import std/Int\nimport std/List\n\nfun main() =\n  [1]\n").unwrap();
     let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
-    let r = plum_core::loadAndMerge(&path, &root);
+    let r = plum_core::loadAndMergeDiag(&path, &root);
     let _ = std::fs::remove_dir_all(&dir);
-    let m = nonEscapingFnParams(&r.unwrap_or_else(|e| panic!("load: {e}")));
+    let m = nonEscapingFnParams(&r.unwrap_or_else(|e| panic!("load: {e:?}")));
     assert_eq!(m.get("List.map"), Some(&vec![0]), "{m:?}");
     assert_eq!(m.get("List.filter"), Some(&vec![0]));
     assert_eq!(m.get("List.fold"), Some(&vec![1]));

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

@@ -2,7 +2,7 @@
 //! Closure specialisation (`plum_core::closure_spec`): which calls get a copy of the
 //! callee with the closure inlined, and that the program still computes the same thing
 //! (compiled and run through the real pipeline, where the pass is wired in).
-use plum_wasm_codegen::compileSource;
+use plum_test_support::compileSource;
 fn gcEngine() -> wasmtime::Engine {
     let mut config = wasmtime::Config::new();
@@ -40,7 +40,7 @@ fn runInt(name: &str, src: &str) -> i64 {
 fn lowered(name: &str, src: &str) -> std::rc::Rc<plum_core::ast::Source> {
     let source = load(name, src);
-    let info = plum_checker::typedSource(&source).unwrap_or_else(|e| panic!("check: {e:?}"));
+    let info = plum_driver::check(&source, &plum_driver::PassOptions::default()).unwrap_or_else(|e| panic!("check: {e:?}"));
     info.lowered.expect("lowered program")
 }

plum-core/tests/core/diag_test.rs ADDED Viewed

@@ -0,0 +1,37 @@
+#![allow(non_snake_case)]
+use plum_core::diag::{DiagKind, Diagnostic};
+use plum_core::loadAndMergeDiag;
+use std::fs;
+use tempfile::TempDir;
+fn load(src: &str) -> Vec<Diagnostic> {
+    let dir = TempDir::new().unwrap();
+    let entry = dir.path().join("main.plum");
+    fs::write(&entry, src).unwrap();
+    loadAndMergeDiag(&entry, dir.path()).unwrap_err()
+}
+#[test]
+fn displayIsFileLineColumnMessage() {
+    let d = Diagnostic::new(DiagKind::Type, "main.plum", 3, 5, "undefined name 'g'");
+    assert_eq!(d.to_string(), "main.plum:3:5: undefined name 'g'");
+    assert_eq!(Diagnostic::bare(DiagKind::Type, "oops").to_string(), "oops");
+}
+#[test]
+fn syntaxErrorIsAPositionedParseDiagnostic() {
+    let ds = load("fun f( = 1\n");
+    assert_eq!(ds.len(), 1, "{ds:?}");
+    let d = &ds[0];
+    assert_eq!(d.kind, DiagKind::Parse);
+    assert_eq!((d.line, d.column), (1, 6), "{d:?}");
+    assert!(d.file.ends_with("main.plum"), "{d:?}");
+}
+#[test]
+fn missingImportIsALoadDiagnosticNamingIt() {
+    let ds = load("import std/Nope\n\nfun f(u: Unit) -> Unit = u\n");
+    assert_eq!(ds.len(), 1, "{ds:?}");
+    assert_eq!(ds[0].kind, DiagKind::Load);
+    assert!(ds[0].message.contains("std/Nope"), "{:?}", ds[0]);
+}

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

@@ -86,7 +86,7 @@ fn mixed_tags_and_inline_variants_stay_variants() {
 #[test]
 fn per_file_keeps_inline_variants() {
     let mut s = plum_test_support::parseRawSource("enum Link[T] = Nil | Cons(head: T, tail: Link[T])\n");
-    assert_eq!(plum_core::lower::perFile(&mut s), Ok(()));
+    assert_eq!(perFile(&mut s), Ok(()));
     assert_eq!(names(&s), vec!["Link"]);
     let l = enumOf(&s, "Link");
     assert_eq!(l.variants[1].name, "Cons");
@@ -97,25 +97,38 @@ fn per_file_keeps_inline_variants() {
 fn per_file_errors() {
     let mut s = plum_test_support::parseRawSource("enum Opt[T] = Nn | Sm(T)\n");
     assert_eq!(
-        plum_core::lower::perFile(&mut s),
+        perFile(&mut s),
         Err("variant Sm(T) needs named fields: Sm(value: T)".to_string())
     );
     let mut s = plum_test_support::parseRawSource("struct Cons(a: Int)\nenum Link = Nil | Cons(head: Int)\n");
-    assert!(plum_core::lower::perFile(&mut s).unwrap_err().contains("already declared"));
+    assert!(perFile(&mut s).unwrap_err().contains("already declared"));
 }
 #[test]
 fn union_enum_rejected() {
     let mut s = plum_test_support::parseRawSource("struct Circle(r: Int)\nenum Shape = Circle | Dot\n");
-    assert_eq!(plum_core::lower::perFile(&mut s), Ok(()));
+    assert_eq!(perFile(&mut s), Ok(()));
     assert_eq!(
-        plum_core::lower::frontEnd(&mut s),
+        frontEnd(&mut s),
         Err("enum Shape lists struct Circle as a member; union enums are removed \u{2014} declare it inline: Circle(..)".to_string())
     );
     let mut s = plum_test_support::parseRawSource("enum Num = Int | Dot\n");
-    assert!(plum_core::lower::frontEnd(&mut s).unwrap_err().contains("lists type Int as a member"));
+    assert!(frontEnd(&mut s).unwrap_err().contains("lists type Int as a member"));
     let mut s = plum_test_support::parseRawSource("enum Color = Red | Green\n");
-    assert_eq!(plum_core::lower::frontEnd(&mut s), Ok(()));
+    assert_eq!(frontEnd(&mut s), Ok(()));
+}
+/// The checks' messages, joined: the tests assert on the text, not on the positions.
+fn messages(r: Result<(), Vec<plum_core::Diagnostic>>) -> Result<(), String> {
+    r.map_err(|ds| ds.iter().map(|d| d.message.clone()).collect::<Vec<_>>().join("\n"))
+}
+fn perFile(s: &mut Source) -> Result<(), String> {
+    messages(plum_core::lower::perFileDiag(s))
+}
+fn frontEnd(s: &mut Source) -> Result<(), String> {
+    messages(plum_core::lower::frontEndDiag(s))
 }
 fn loadSrc(src: &str) -> Result<Source, String> {
@@ -124,7 +137,7 @@ fn loadSrc(src: &str) -> Result<Source, String> {
     std::fs::create_dir_all(&lib).unwrap();
     let entry = lib.join("main.plum");
     std::fs::write(&entry, src).unwrap();
-    plum_core::loadAndMerge(&entry, &lib)
+    plum_core::loadAndMergeDiag(&entry, &lib).map_err(|ds| ds.iter().map(|d| d.to_string()).collect::<Vec<_>>().join("\n"))
 }
 #[test]

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

@@ -85,9 +85,9 @@ fn std_and_examples_layouts() {
     let mut boxed = 0;
     let mut known: Vec<(String, Layout)> = Vec::new();
     for f in &files {
-        let s = match plum_core::loadAndMerge(f, root) {
+        let s = match plum_core::loadAndMergeDiag(f, root) {
             Ok(s) => s,
-            Err(e) => panic!("{}: {e}", f.display()),
+            Err(e) => panic!("{}: {e:?}", f.display()),
         };
         let all = enums(&s);
         for e in all.iter().filter(|e| e.isStruct) {

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

@@ -1,5 +1,5 @@
 #![allow(non_snake_case)]
-use plum_core::loadAndMerge;
+use plum_core::loadAndMergeDiag;
 use std::fs;
 use tempfile::TempDir;
@@ -35,7 +35,7 @@ fn importSeesImportedDeclarations() {
         "module fixtures\n\nimport helper\n\nfun main(u: Unit) -> Unit =\n  helperFn(u)\n",
     );
-    let merged = loadAndMerge(&entry, &lib_path).expect("loadAndMerge failed");
+    let merged = loadAndMergeDiag(&entry, &lib_path).expect("loadAndMerge failed");
     let names: Vec<&str> = merged
         .items
         .iter()
@@ -76,7 +76,7 @@ fn transitiveImportSurfacesGrandchildDeclarations() {
         "module fixtures\n\nimport b\n\nfun main(u: Unit) -> Unit =\n  bFn(u)\n",
     );
-    let merged = loadAndMerge(&entry, &lib_path).expect("loadAndMerge failed");
+    let merged = loadAndMergeDiag(&entry, &lib_path).expect("loadAndMerge failed");
     let names: Vec<&str> = merged
         .items
         .iter()
@@ -117,7 +117,7 @@ fn diamondImportIncludesSharedDependencyOnce() {
         "module fixtures\n\nimport b\nimport c\n\nfun main(u: Unit) -> Unit =\n  bFn(cFn(u))\n",
     );
-    let merged = loadAndMerge(&entry, &lib_path).expect("loadAndMerge failed");
+    let merged = loadAndMergeDiag(&entry, &lib_path).expect("loadAndMerge failed");
     let d_count = merged
         .items
         .iter()
@@ -145,7 +145,7 @@ fn importCycleResolvesWithoutHangingOrErroring() {
         "module fixtures\n\nimport b\n\nfun main(u: Unit) -> Unit =\n  bFn(u)\n",
     );
-    let merged = loadAndMerge(&entry, &lib_path).expect("import cycle should resolve, not error");
+    let merged = loadAndMergeDiag(&entry, &lib_path).expect("import cycle should resolve, not error");
     let names: Vec<&str> = merged
         .items
         .iter()
@@ -168,9 +168,9 @@ fn unresolvableImportIsAClearError() {
         "module fixtures\n\nimport does_not_exist\n\nfun main(u: Unit) -> Unit =\n  u\n",
     );
-    let result = loadAndMerge(&entry, &lib_path);
+    let result = loadAndMergeDiag(&entry, &lib_path);
     assert!(result.is_err());
-    let msg = result.unwrap_err();
+    let msg = errText(result.unwrap_err());
     assert!(
         msg.contains("does_not_exist"),
         "expected error to name the missing import, got: {}",
@@ -193,9 +193,9 @@ fn duplicateTopLevelNameAcrossFilesIsAClearError() {
         "module fixtures\n\nimport helper\n\nfun sharedFn(u: Unit) -> Unit =\n  u\n",
     );
-    let result = loadAndMerge(&entry, &lib_path);
+    let result = loadAndMergeDiag(&entry, &lib_path);
     assert!(result.is_err());
-    let msg = result.unwrap_err();
+    let msg = errText(result.unwrap_err());
     assert!(
         msg.contains("sharedFn"),
         "expected error to name the duplicate 'sharedFn', got: {}",
@@ -237,7 +237,7 @@ fun main(u: Unit) -> Unit =
 ",
     );
-    let merged = loadAndMerge(&entry, &lib_path)
+    let merged = loadAndMergeDiag(&entry, &lib_path)
         .expect("same method name on different receivers should not collide");
     let method_count = merged
         .items
@@ -251,6 +251,11 @@ fun main(u: Unit) -> Unit =
     );
 }
+/// Diagnostics as the plain text a user sees.
+fn errText(ds: Vec<plum_core::Diagnostic>) -> String {
+    ds.iter().map(|d| d.to_string()).collect::<Vec<_>>().join("\n")
+}
 #[test]
 fn removedSyntaxIsAParseError() {
     for src in [
@@ -263,8 +268,8 @@ fn removedSyntaxIsAParseError() {
         let dir = TempDir::new().unwrap();
         let entry = dir.path().join("main.plum");
         fs::write(&entry, src).unwrap();
-        let err = loadAndMerge(&entry, dir.path()).unwrap_err();
+        let errs = loadAndMergeDiag(&entry, dir.path()).unwrap_err();
-        assert!(err.contains("parse error"), "{src}: {err}");
+        assert!(errs.iter().all(|d| d.kind == plum_core::DiagKind::Parse), "{src}: {errs:?}");
     }
 }
@@ -272,7 +277,7 @@ fn parseErrorOf(src: &str) -> String {
     let dir = TempDir::new().unwrap();
     let entry = dir.path().join("main.plum");
     fs::write(&entry, src).unwrap();
-    loadAndMerge(&entry, dir.path()).unwrap_err()
+    errText(loadAndMergeDiag(&entry, dir.path()).unwrap_err())
 }
 #[test]
@@ -281,7 +286,7 @@ fn parseErrorBlamesTheTokenNotTheWholeFunction() {
         "import std/Float\n\nexport fun update(w: Float, dt: Float) =\n  ()\n\nfun ok() =\n  _ := 1.0\n",
     );
     assert!(
-        err.contains("at line 4, column 3: unexpected '()'"),
+        err.contains(":4:3: unexpected '()'"),
         "{err}"
     );
     assert!(
@@ -295,7 +300,7 @@ fn parseErrorBlamesTheTokenNotTheWholeFunction() {
 fn parseErrorOnStrayTokenMidExpression() {
     let err = parseErrorOf("fun f() =\n  x := 1 + * 2\n");
     assert!(
-        err.contains("at line 2, column 12: unexpected '*'"),
+        err.contains(":2:12: unexpected '*'"),
         "{err}"
     );
     assert!(!err.contains("hint:"), "{err}");
@@ -304,35 +309,35 @@ fn parseErrorOnStrayTokenMidExpression() {
 #[test]
 fn parseErrorOnMissingClosingDelimiter() {
     let err = parseErrorOf("fun f() =\n  x := (1 + 2\n");
-    assert!(err.contains("at line 2, column 8: unclosed '('"), "{err}");
+    assert!(err.contains(":2:8: unclosed '('"), "{err}");
     let err = parseErrorOf("fun f() =\n  x := foo(1, 2\n  y := 3\n\nfun g() =\n  z := 1\n");
-    assert!(err.contains("at line 3, column 3: unexpected 'y'"), "{err}");
+    assert!(err.contains(":3:3: unexpected 'y'"), "{err}");
 }
 #[test]
 fn unclosedOpenerAtEndOfFileIsReportedAtTheOpener() {
     let err = parseErrorOf("import std/Int\n\nfun f(a: Int) -> Int =\n  g(a, 2\n");
-    assert!(err.contains("at line 4, column 4: unclosed '('"), "{err}");
+    assert!(err.contains(":4:4: unclosed '('"), "{err}");
     let err = parseErrorOf("fun f() =\n  x := [1, 2\n");
-    assert!(err.contains("at line 2, column 8: unclosed '['"), "{err}");
+    assert!(err.contains(":2:8: unclosed '['"), "{err}");
     let err = parseErrorOf("fun f() =\n  x := g(h(1), 2\n");
-    assert!(err.contains("at line 2, column 9: unclosed '('"), "{err}");
+    assert!(err.contains(":2:9: unclosed '('"), "{err}");
     let err = parseErrorOf("fun f() =\n  x := { 1 + 2\n");
-    assert!(err.contains("at line 2, column 8: unclosed '{'"), "{err}");
+    assert!(err.contains(":2:8: unclosed '{'"), "{err}");
 }
 #[test]
 fn parseErrorAtEndOfFile() {
     let err = parseErrorOf("fun f() =\n  x := 1 +\n");
     assert!(
-        err.contains("at line 2, column 11: unexpected end of file"),
+        err.contains(":2:11: unexpected end of file"),
         "{err}"
     );
     let err = parseErrorOf("fun f() =\n  x := foo(1, 2");
-    assert!(err.contains("at line 2, column 11: unclosed '('"), "{err}");
+    assert!(err.contains(":2:11: unclosed '('"), "{err}");
     let err = parseErrorOf("fun f() =\n  if true\n    x := 1\n  else\n");
     assert!(
-        err.contains("at line 4, column 7: unexpected end of file"),
+        err.contains(":4:7: unexpected end of file"),
         "{err}"
     );
 }
@@ -346,7 +351,7 @@ fn duplicate_const_in_one_body() {
         "main",
         "module fixtures\n\nprimitive Consts =\n  Pi = true\n  Pi = false\n",
     );
-    let msg = loadAndMerge(&entry, &lib_path).unwrap_err();
+    let msg = errText(loadAndMergeDiag(&entry, &lib_path).unwrap_err());
     assert!(msg.contains("duplicate constant 'Consts.Pi'"), "{}", msg);
 }
@@ -364,7 +369,7 @@ fn assoc_const_names_are_per_type_across_modules() {
         "main",
         "module fixtures\n\nimport helper\n\nprimitive Beta =\n  Flag = false\n",
     );
-    let merged = loadAndMerge(&entry, &lib_path).unwrap();
+    let merged = loadAndMergeDiag(&entry, &lib_path).unwrap();
     let names: Vec<String> = merged
         .items
         .iter()
@@ -389,7 +394,7 @@ fn primitive_builtin_std_only() {
         "primitive Int =\n  fun f(self) -> Byte =\n    self\n",
     )
     .unwrap();
-    let err = loadAndMerge(&entry, dir.path()).unwrap_err();
+    let err = errText(loadAndMergeDiag(&entry, dir.path()).unwrap_err());
     assert!(err.contains("only allowed in std"), "{err}");
     // A namespace is fine anywhere.
     let ok = dir.path().join("ns.plum");
@@ -398,7 +403,7 @@ fn primitive_builtin_std_only() {
         "primitive Util =\n  Enabled = true\n  fun f() -> Unit =\n    todo\n",
     )
     .unwrap();
-    assert!(loadAndMerge(&ok, dir.path()).is_ok());
+    assert!(loadAndMergeDiag(&ok, dir.path()).is_ok());
     // Inside std, a built-in: fine.
     let std = dir.path().join("plum-std");
     fs::create_dir_all(&std).unwrap();
@@ -408,7 +413,7 @@ fn primitive_builtin_std_only() {
         "primitive Byte =\n  fun f(self) -> Byte =\n    self\n",
     )
     .unwrap();
-    assert!(loadAndMerge(&byte, dir.path()).is_ok());
+    assert!(loadAndMergeDiag(&byte, dir.path()).is_ok());
 }
 #[test]
@@ -425,7 +430,7 @@ fn source_and_fns_carry_their_file_path() {
         "main",
         "module fixtures\n\nimport std/Util\n\nfun mainFn(b: Bool) -> Bool =\n  b\n",
     );
-    let source = loadAndMerge(&entry, &lib_path).unwrap();
+    let source = loadAndMergeDiag(&entry, &lib_path).unwrap();
     assert!(source.file.ends_with("main.plum"), "{}", source.file);
     let fileOf = |name: &str| {
         source
@@ -464,7 +469,7 @@ fn outOfRangeLiteralInEntryOrImportSurvivesTheMerge() {
         "main",
         "module fixtures\n\nimport helper\n\nfun main(u: Unit) -> Unit =\n  big(u)\n",
     );
-    let merged = loadAndMerge(&entry, &lib_path).expect("loadAndMerge failed");
+    let merged = loadAndMergeDiag(&entry, &lib_path).expect("loadAndMerge failed");
     assert!(
         merged
             .formErrors
@@ -484,7 +489,7 @@ fn inlineVariantStaysAVariant() {
         "main",
         "module fixtures\n\nenum Shape =\n  | Circle(r: Unit)\n  | Dot\n",
     );
-    let merged = loadAndMerge(&entry, &lib_path).unwrap();
+    let merged = loadAndMergeDiag(&entry, &lib_path).unwrap();
     assert!(!merged.items.iter().any(|i| matches!(i, plum_core::ast::Item::Enum(e) if e.name == "Circle")));
     let shape = merged.items.iter().find_map(|i| match i {
         plum_core::ast::Item::Enum(e) if e.name == "Shape" => Some(e),
@@ -502,11 +507,9 @@ fn legacySingleSelfVariantIsAnError() {
         "main",
         "module fixtures\n\nenum User =\n  | User(name: Unit)\n",
     );
-    let err = loadAndMerge(&entry, &lib_path).unwrap_err();
+    let err = loadAndMergeDiag(&entry, &lib_path).unwrap_err();
-    assert_eq!(
+    assert_eq!(err.len(), 1, "{err:?}");
-        err,
-        "enum User has a single variant named User — write struct User(...)"
+    assert_eq!(err[0].message, "enum User has a single variant named User — write struct User(...)");
-    );
 }
 #[test]
@@ -523,7 +526,7 @@ fn nestedStdImportResolvesToASubdirectory() {
         "main",
         "module fixtures\n\nimport std/game/Util\n\nfun mainFn(b: Bool) -> Bool =\n  helperFn(b)\n",
     );
-    let source = loadAndMerge(&entry, &lib_path).expect("nested std import loads");
+    let source = loadAndMergeDiag(&entry, &lib_path).expect("nested std import loads");
     assert!(source.items.iter().any(
         |i| matches!(i, plum_core::ast::Item::Fn(f) if f.name == "helperFn" && f.file.ends_with("game/Util.plum"))
     ));
@@ -532,7 +535,7 @@ fn nestedStdImportResolvesToASubdirectory() {
         "other",
         "module fixtures\n\nimport std/Util\n\nfun f(b: Bool) -> Bool =\n  b\n",
     );
-    assert!(loadAndMerge(&missing, &lib_path).is_err());
+    assert!(loadAndMergeDiag(&missing, &lib_path).is_err());
 }
 /// Import-free programs (every plum-examples file imports std, so small inline programs are used):
@@ -554,7 +557,7 @@ fn single_file_equals_loader() {
         parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();
         let tree = parser.parse(src, None).unwrap();
         let single = plum_core::AstParser::new(src).parseSource(tree.root_node());
-        let merged = loadAndMerge(&entry, dir.path()).expect("loadAndMerge failed");
+        let merged = loadAndMergeDiag(&entry, dir.path()).expect("loadAndMerge failed");
         // The loader stamps each item with its path; blank those out before comparing.
         let norm = |x: &plum_core::ast::Source| {
             // the loader drops `topLevelOrder` after merging; items are the lowered program

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

@@ -1,12 +1,12 @@
 #![allow(non_snake_case)]
-use plum_core::lower::frontEnd;
+use plum_core::lower::frontEndDiag;
 #[test]
 fn lowersEmbeds() {
     let mut s = plum_test_support::parseRawSource(
         "struct Actor(x: Int) =\n  fun up(self) -> Int = 0\n\nstruct Hut(Actor(x), k: Int) =\n  override fun up(self) -> Int = 1\n",
     );
-    assert_eq!(frontEnd(&mut s), Ok(()));
+    assert_eq!(frontEndDiag(&mut s), Ok(()));
 }
 #[test]
@@ -22,6 +22,6 @@ fn second_embed_errors() {
     let mut s = plum_test_support::parseRawSource(
         "struct Aa(x: Int)\nstruct Bb(y: Int)\nstruct Ss(Aa(x), Bb(y))\n",
     );
-    let e = frontEnd(&mut s).unwrap_err();
+    let e = frontEndDiag(&mut s).unwrap_err();
-    assert!(e.contains("struct Ss embeds Aa and Bb; a struct can embed only one struct"), "{e}");
+    assert!(e.iter().any(|d| d.message.contains("struct Ss embeds Aa and Bb; a struct can embed only one struct")), "{e:?}");
 }

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

@@ -1,6 +1,7 @@
 mod closure_escape_test;
 mod closure_spec_test;
 mod closure_types_parse_test;
+mod diag_test;
 mod drive_test;
 mod for_next_test;
 mod formatter_test;

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

@@ -1,5 +1,5 @@
 #![allow(non_snake_case)]
-use plum_core::lower::frontEnd;
+use plum_core::lower::frontEndDiag;
 const SRC: &str = "\
 enum Shape =
@@ -13,7 +13,7 @@ fun main() =
 fn lowered() -> String {
     let mut s = plum_test_support::parseRawSource(SRC);
-    frontEnd(&mut s).unwrap();
+    frontEndDiag(&mut s).unwrap();
     format!("{:?}", s.items)
 }

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

@@ -2,12 +2,14 @@
 //! Tail recursion modulo cons (`plum_core::trmc`): which fns are rewritten, and
 //! that the rewrite computes what the recursion would (compiled and run through
 //! the real pipeline, which is where `trmc::rewrite` is wired in).
-use plum_checker::FusionOptions;
+use plum_driver::PassOptions;
 use plum_wasm_codegen::CompileOptions;
 fn compileWith(source: &plum_core::ast::Source, fusion: bool) -> Result<Vec<u8>, String> {
-    let opts = CompileOptions { fusion: FusionOptions { enabled: fusion, explain: false }, ..Default::default() };
+    let opts = CompileOptions { passes: plum_driver::PassOptions { fusion: fusion, explain: false, ..plum_driver::PassOptions::default() }, ..Default::default() };
-    plum_wasm_codegen::compile(source, &opts).map(|o| o.wasm)
+    plum_wasm_codegen::compile(source, &opts)
+        .map(|o| o.wasm)
+        .map_err(|ds| ds.iter().map(|d| d.to_string()).collect::<Vec<_>>().join("\n"))
 }
 fn compileSource(source: &plum_core::ast::Source) -> Result<Vec<u8>, String> {
@@ -20,7 +22,7 @@ fn compileUnfused(source: &plum_core::ast::Source) -> Result<Vec<u8>, String> {
 }
 fn typedSource(source: &plum_core::ast::Source) -> plum_checker::types::CheckResult<plum_checker::TypedInfo> {
-    plum_checker::typedSourceWith(source, FusionOptions::default())
+    plum_driver::check(source, &PassOptions::default())
 }
 fn gcEngine() -> wasmtime::Engine {

plum-driver/Cargo.toml ADDED Viewed

@@ -0,0 +1,11 @@
+[package]
+name = "plum-driver"
+version = "0.1.0"
+edition = "2021"
+[dependencies]
+plum-core = { path = "../plum-core" }
+plum-checker = { path = "../plum-checker" }
+[dev-dependencies]
+plum-test-support = { path = "../plum-test-support" }

plum-driver/src/lib.rs ADDED Viewed

@@ -0,0 +1,187 @@
+//! The post-check pass list. `plum_checker` only checks; this crate owns the order of the
+//! rewrite passes (closure specialisation, fusion, TRMC, tail marks) and the one rule they
+//! share: a rewrite is adopted only if the rewritten program checks again.
+#![allow(non_snake_case)]
+use plum_checker::{checkOnce, checkProgram, TypedInfo};
+use plum_core::ast::Source;
+use plum_core::closure_spec::Hints;
+use plum_core::diag::Diagnostic;
+use std::rc::Rc;
+/// Which passes run, and whether dropped or applied rewrites are explained on stderr.
+#[derive(Clone, Copy, Debug)]
+pub struct PassOptions {
+    pub closureSpec: bool,
+    /// The supercompiler stage (`--no-fusion` clears it).
+    pub fusion: bool,
+    pub trmc: bool,
+    /// Print each fusion decision and each dropped rewrite (`--explain-fusion`).
+    pub explain: bool,
+}
+impl Default for PassOptions {
+    fn default() -> Self {
+        PassOptions { closureSpec: true, fusion: true, trmc: true, explain: false }
+    }
+}
+/// What a pass rewrites.
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum Target {
+    /// The checked program before union lowering (own generics applied, `for` loops lowered),
+    /// so the passes never see the hidden `List__Cons(Cons(..))` wrappers.
+    Pre,
+    /// The final lowered program codegen compiles.
+    Lowered,
+}
+/// What a rewrite may read besides the program.
+pub struct Env<'a> {
+    pub explain: bool,
+    /// Receiver types of method calls, read off the checked program (see `closureHints`).
+    pub hints: &'a Hints,
+}
+/// One rewrite pass: changes the program in place, returns whether anything changed.
+pub struct Pass {
+    pub name: &'static str,
+    pub target: Target,
+    pub needsHints: bool,
+    pub enabled: fn(&PassOptions) -> bool,
+    pub rewrite: fn(&mut Source, &Env) -> bool,
+}
+fn closureSpec(copy: &mut Source, env: &Env) -> bool {
+    !plum_core::closure_spec::specialiseWith(copy, env.hints).is_empty()
+}
+/// Purity -> simplify -> drive -> uniqueness -> reuse; returns every note (empty = nothing changed).
+pub fn fusionNotes(copy: &mut Source) -> Vec<String> {
+    let pure = plum_core::purity::pureFns(copy);
+    let mut notes = plum_core::simplify::simplify(copy, &pure);
+    notes.extend(plum_core::drive::drive(copy, &pure));
+    let rep = plum_core::uniqueness::markUnique(copy);
+    notes.extend(rep.proved.iter().map(|l| format!("unique spread at {l}")));
+    notes.extend(rep.unproved.iter().map(|(l, why)| format!("uniqueness: not in place {l}: {why}")));
+    notes.retain(|n| !n.is_empty());
+    notes.extend(plum_core::reuse::markReuse(copy));
+    notes.retain(|n| !n.is_empty());
+    notes
+}
+fn fusion(copy: &mut Source, env: &Env) -> bool {
+    let notes = fusionNotes(copy);
+    if env.explain {
+        for n in &notes {
+            eprintln!("fusion: {n}");
+        }
+    }
+    !notes.is_empty()
+}
+/// Tail recursion modulo cons.
+fn trmc(copy: &mut Source, _: &Env) -> bool {
+    !plum_core::trmc::rewrite(copy).is_empty()
+}
+/// The rewrite passes, in the order they run. Tail marks (flags set in place on the final
+/// program) run last and need no re-check.
+pub const PASSES: [Pass; 3] = [
+    Pass { name: "closure specialisation", target: Target::Pre, needsHints: true, enabled: |o| o.closureSpec, rewrite: closureSpec },
+    Pass { name: "fusion", target: Target::Pre, needsHints: false, enabled: |o| o.fusion, rewrite: fusion },
+    Pass { name: "trmc", target: Target::Lowered, needsHints: false, enabled: |o| o.trmc, rewrite: trmc },
+];
+/// The state the passes thread through: the pre-union program and the checked result.
+struct State {
+    pre: Source,
+    result: Result<(), Vec<Diagnostic>>,
+    info: TypedInfo,
+}
+/// Checks `source`, then runs the enabled passes of `PASSES` in order, each adopted only if
+/// it re-checks, then marks tail calls. A dropped rewrite leaves the previous program and
+/// its `TypedInfo` untouched (with `explain` the drop and its first errors are printed).
+pub fn check(source: &Source, opts: &PassOptions) -> Result<TypedInfo, Vec<Diagnostic>> {
+    check_with(source, opts, &PASSES)
+}
+/// `check` with an explicit pass list.
+pub fn check_with(source: &Source, opts: &PassOptions, passes: &[Pass]) -> Result<TypedInfo, Vec<Diagnostic>> {
+    let (result, info) = checkProgram(source);
+    let mut st = State { pre: preUnionSource(source), result, info };
+    if st.result.is_ok() {
+        for pass in passes.iter().filter(|p| (p.enabled)(opts)) {
+            runPass(pass, source, opts, &mut st);
+        }
+    }
+    // Flags are set in place, so the address-keyed type info stays valid.
+    if let Some(lowered) = st.info.lowered.as_mut().and_then(Rc::get_mut) {
+        plum_core::tail::markTailCalls(lowered);
+    }
+    st.result.map(|()| st.info)
+}
+fn runPass(pass: &Pass, original: &Source, opts: &PassOptions, st: &mut State) {
+    // Type info is keyed by the addresses of the program it checked (`lowered`, or the
+    // original source itself), not of the clone `pre`; hints are keyed by call position, so
+    // read them off the checked program and apply them to its twin.
+    let hints = if pass.needsHints {
+        match st.info.lowered.clone() {
+            Some(checked) => plum_checker::closureHints(&checked, &st.info),
+            None => plum_checker::closureHints(original, &st.info),
+        }
+    } else {
+        Hints::new()
+    };
+    let env = Env { explain: opts.explain, hints: &hints };
+    let mut copy = match pass.target {
+        Target::Pre => st.pre.clone(),
+        Target::Lowered => match st.info.lowered.as_ref() {
+            Some(l) => (**l).clone(),
+            None => return,
+        },
+    };
+    if !(pass.rewrite)(&mut copy, &env) {
+        return;
+    }
+    // Type info is keyed by expression address: check the very program kept as `lowered`.
+    let kept = Rc::new(copy);
+    let (r2, mut i2) = checkOnce(&kept);
+    match r2 {
+        Ok(()) => {
+            if pass.target == Target::Pre {
+                st.pre = (*kept).clone();
+            }
+            // A pre-union program is lowered by its check; an already lowered one is kept as is.
+            if pass.target == Target::Lowered || i2.lowered.is_none() {
+                i2.lowered = Some(kept);
+            }
+            st.result = Ok(());
+            st.info = i2;
+        }
+        Err(errs) => {
+            if opts.explain {
+                eprintln!("fusion: {} dropped: the rewritten program failed its re-check", pass.name);
+                for e in errs.iter().take(3) {
+                    eprintln!("fusion:   {}:{}: {}", e.line, e.column, e.message);
+                }
+            }
+        }
+    }
+}
+/// The checked program before union lowering: own generics applied and `for` loops lowered.
+fn preUnionSource(source: &Source) -> Source {
+    let mut cur = source.clone();
+    while let Some(applied) = plum_checker::applyOwnGenerics(&cur) {
+        cur = applied;
+    }
+    if cur.formLoops {
+        plum_core::forms::begin(&cur);
+        let _ = checkOnce(&cur);
+        cur = plum_core::forms::finish(&cur);
+    }
+    cur
+}

plum-driver/tests/driver_tests.rs ADDED Viewed

@@ -0,0 +1,75 @@
+#![allow(non_snake_case)]
+use plum_core::ast::{Item, Source};
+use plum_driver::{check, check_with, Env, Pass, PassOptions, Target, PASSES};
+const SRC: &str = "\
+import std/Int
+import std/List
+fun total(xs: List[Int]) -> Int = xs.map(|x| x + 1).fold(0, |a, x| a + x)
+fun main() -> Int = total([1, 2, 3])
+";
+fn load(name: &str, src: &str) -> Source {
+    plum_test_support::load(name, src).expect("loads")
+}
+fn fnNames(s: &Source) -> Vec<String> {
+    s.items
+        .iter()
+        .filter_map(|i| if let Item::Fn(f) = i { Some(f.name.clone()) } else { None })
+        .collect()
+}
+fn loweredNames(src: &Source, opts: &PassOptions) -> Vec<String> {
+    let info = check(src, opts).expect("checks");
+    fnNames(info.lowered.as_ref().expect("lowered"))
+}
+#[test]
+fn noPassesMeansNoGeneratedFns() {
+    let src = load("drv_none", SRC);
+    let opts = PassOptions { closureSpec: false, fusion: false, trmc: false, explain: false };
+    let names = loweredNames(&src, &opts);
+    assert!(names.iter().all(|n| !n.contains('$')), "{names:?}");
+}
+#[test]
+fn defaultPassesSpecialise() {
+    let src = load("drv_default", SRC);
+    let names = loweredNames(&src, &PassOptions::default());
+    assert!(names.iter().any(|n| n.contains('$')), "the default passes specialise: {names:?}");
+}
+/// A rewrite that breaks the program (a call to a fn that takes another type) fails its
+/// re-check and is dropped: the result equals the run without it.
+fn breakProgram(copy: &mut Source, _: &Env) -> bool {
+    for item in &mut copy.items {
+        if let Item::Fn(f) = item {
+            if f.name == "main" {
+                f.returns = Some(plum_core::ast::Type { name: "Bool".to_string(), generics: vec![] });
+                return true;
+            }
+        }
+    }
+    false
+}
+#[test]
+fn aRewriteThatFailsItsRecheckIsDropped() {
+    let src = load("drv_drop", SRC);
+    let opts = PassOptions::default();
+    let bad = Pass {
+        name: "break",
+        target: Target::Pre,
+        needsHints: false,
+        enabled: |_| true,
+        rewrite: breakProgram,
+    };
+    let mut passes: Vec<Pass> = vec![bad];
+    passes.extend(PASSES.into_iter());
+    let with = fnNames(check_with(&src, &opts, &passes).expect("still checks").lowered.as_ref().unwrap());
+    let without = loweredNames(&src, &opts);
+    assert_eq!(with, without);
+}

plum-game/tests/host_test.rs CHANGED Viewed

@@ -8,7 +8,7 @@ fn root() -> PathBuf {
 }
 fn compile(src_path: &Path) -> Vec<u8> {
-    let source = plum_core::loadAndMerge(src_path, &root()).expect("load");
+    let source = plum_core::loadAndMergeDiag(src_path, &root()).expect("load");
     plum_wasm_codegen::compile(&source, &plum_wasm_codegen::CompileOptions::default()).expect("compile").wasm
 }

plum-lsp/Cargo.toml CHANGED Viewed

@@ -10,6 +10,7 @@ path = "src/main.rs"
 [dependencies]
 plum-core = { path = "../plum-core" }
 plum-checker = { path = "../plum-checker" }
+plum-driver = { path = "../plum-driver" }
 tree-sitter = "0.26"
 tree-sitter-plum = { path = "../plum-tooling/tree-sitter-plum" }
 tower-lsp = "0.20"

plum-lsp/src/main.rs CHANGED Viewed

@@ -3,14 +3,12 @@
 //   1. Syntax errors — read directly off the tree-sitter parse tree (ERROR /
 //      MISSING nodes), which carries real byte/line/column spans.
 //
-//   2. Type errors — from `plum_checker::checkSource`. `CheckError` carries a
+//   2. Type errors — from `plum_driver::check`. A `plum_core::Diagnostic` carries a
-//      `line`/`column` pointing at the enclosing `fn`/`enum`/`test`
+//      1-based `line`/`column`; the diagnostic range runs from that column to the
-//      declaration (not the exact sub-expression/token within it — the
-//      checker doesn't track spans that fine yet), so the diagnostic range
-//      covers that declaration's line rather than the whole document.
+//      end of its line.
 //
 // Both are republished on every `did_open`/`did_change`/`did_save`. Type
-// checking goes through `plum_core::loadAndMergeWithOverrides`, passing the
+// checking goes through `plum_core::loadAndMergeWithOverridesDiag`, passing the
 // live in-memory buffer for the edited document while every other
 // (transitively imported) file still reads from disk — so it reflects
 // unsaved edits, not just the last save.
@@ -82,7 +80,7 @@ impl Backend {
     }
     /// Diagnostics from `plum_checker::checkSource`, run against the live
-    /// in-memory buffer (via `loadAndMergeWithOverrides`) rather than
+    /// in-memory buffer (via `loadAndMergeWithOverridesDiag`) rather than
     /// whatever's on disk, so an unsaved edit is reflected immediately.
     /// Every other (transitively imported) file still resolves from disk.
     /// Returns `None` (rather than an error) if the document has no on-disk
@@ -102,7 +100,7 @@ impl Backend {
         let canon = std::fs::canonicalize(&path).unwrap_or(path.clone());
         let mut overrides = HashMap::new();
         overrides.insert(canon, text.to_string());
-        plum_core::loadAndMergeWithOverrides(&path, &self.libPath, &overrides).ok()
+        plum_core::loadAndMergeWithOverridesDiag(&path, &self.libPath, &overrides).ok()
     }
     async fn completionItems(&self, uri: &Url, pos: Position) -> Vec<CompletionItem> {
@@ -308,28 +306,28 @@ fn typeDiagnosticsFor(path: &Path, libPath: &Path, text: &str) -> Option<Vec<Dia
     let canon = std::fs::canonicalize(path).unwrap_or(path.to_path_buf());
     let mut overrides = HashMap::new();
     overrides.insert(canon, text.to_string());
-    let ast = plum_core::loadAndMergeWithOverrides(path, libPath, &overrides).ok()?;
+    let ast = plum_core::loadAndMergeWithOverridesDiag(path, libPath, &overrides).ok()?;
     let lastLine = text.lines().count().max(1) as u32 - 1;
+    let opts = plum_driver::PassOptions { closureSpec: false, fusion: false, trmc: false, explain: false };
-    match plum_checker::checkSource(&ast) {
+    match plum_driver::check(&ast, &opts) {
-        Ok(()) => Some(Vec::new()),
+        Ok(_) => Some(Vec::new()),
-        Err(errors) => Some(
+        Err(diags) => Some(
-            errors
+            diags
                 .into_iter()
-                .map(|e| {
+                .map(|d| {
-                    // `CheckError`'s position is 1-based and points at the
+                    // `plum_core::Diagnostic` positions are 1-based (0 = unknown); LSP's
-                    // enclosing declaration, not a sub-expression — clamp
-                    // to the document and cover the whole line so an
+                    // are 0-based. The range runs from the reported column to the end of
-                    // editor still shows something sensible even if the
-                    // line itself is short/blank.
+                    // its line, clamped to the document.
-                    let line = e.line.saturating_sub(1).min(lastLine as usize) as u32;
+                    let line = d.line.saturating_sub(1).min(lastLine as usize) as u32;
+                    let col = d.column.saturating_sub(1) as u32;
                     Diagnostic {
                         range: Range {
-                            start: Position::new(line, 0),
+                            start: Position::new(line, col),
                             end: Position::new(line, u32::MAX),
                         },
                         severity: Some(DiagnosticSeverity::ERROR),
                         source: Some("plum-check".into()),
-                        message: e.message,
+                        message: d.message,
                         ..Default::default()
                     }
                 })
@@ -350,7 +348,7 @@ fn memberCompletionFor(
     let canon = std::fs::canonicalize(path).unwrap_or(path.to_path_buf());
     let mut overrides = HashMap::new();
     overrides.insert(canon, text.to_string());
-    let Ok(merged) = plum_core::loadAndMergeWithOverrides(path, libPath, &overrides) else {
+    let Ok(merged) = plum_core::loadAndMergeWithOverridesDiag(path, libPath, &overrides) else {
         return Vec::new();
     };
     let tree = Backend::parseTree(text);
@@ -534,7 +532,7 @@ fn resolveTarget(
     let canon = std::fs::canonicalize(path).unwrap_or(path.to_path_buf());
     let mut overrides = HashMap::new();
     overrides.insert(canon, text.to_string());
-    let merged = plum_core::loadAndMergeWithOverrides(path, libPath, &overrides).ok()?;
+    let merged = plum_core::loadAndMergeWithOverridesDiag(path, libPath, &overrides).ok()?;
     if s > 0 && lineText.as_bytes()[s - 1] == b'.' {
         let before = &lineText[..s - 1];
         let rs = before
@@ -622,7 +620,7 @@ fn inheritedDefinition(
     let canon = std::fs::canonicalize(path).unwrap_or(path.to_path_buf());
     let mut overrides = HashMap::new();
     overrides.insert(canon.clone(), text.to_string());
-    let merged = plum_core::loadAndMergeWithOverrides(path, libPath, &overrides).ok()?;
+    let merged = plum_core::loadAndMergeWithOverridesDiag(path, libPath, &overrides).ok()?;
     let (file, line, needle) = match loc {
         Some((f, l, _)) => (f.clone(), *l, format!("fun {name}")),
         None => {
@@ -1002,7 +1000,7 @@ mod tests {
             b64.iter().any(|l| l == "encode") && b64.iter().any(|l| l == "decode"),
             "{b64:?}"
         );
-        let merged = plum_core::loadAndMerge(&path, &repoRoot()).expect("loads");
+        let merged = plum_core::loadAndMergeDiag(&path, &repoRoot()).expect("loads");
         let top: Vec<String> = completion::topLevelItems(&merged)
             .into_iter()
             .map(|i| i.label)
@@ -1152,6 +1150,22 @@ mod tests {
         assert!(n > 20, "found only {n} README snippets");
     }
+    /// A type error is published at the position its `Diagnostic` reports (1-based there,
+    /// 0-based here), not on a line parsed out of the message.
+    #[test]
+    fn typeDiagnosticUsesTheDiagnosticPosition() {
+        let dir = std::env::temp_dir().join(format!("plum_lsp_pos_{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("main.plum");
+        let text = "import std/Int\n\nfun main() -> Int =\n  nope\n";
+        std::fs::write(&path, text).unwrap();
+        let diags = typeDiagnosticsFor(&path, &repoRoot(), text).expect("loads");
+        let _ = std::fs::remove_dir_all(&dir);
+        assert_eq!(diags.len(), 1, "{diags:?}");
+        assert_eq!(diags[0].range.start, Position::new(3, 2), "{:?}", diags[0].range);
+        assert!(diags[0].message.contains("nope"), "{}", diags[0].message);
+    }
     #[test]
     fn syntaxDiagnosticUnderlinesTheTokenNotTheFunction() {
         let src = "import std/Float\n\nexport fun update(w: Float, dt: Float) =\n  ()\n\nfun ok() =\n  _ := 1.0\n";

plum-test-support/Cargo.toml CHANGED Viewed

@@ -5,7 +5,7 @@ edition = "2021"
 [dependencies]
 plum-core = { path = "../plum-core" }
-plum-checker = { path = "../plum-checker" }
+plum-driver = { path = "../plum-driver" }
 plum-wasm-codegen = { path = "../plum-wasm-codegen" }
 tree-sitter = "0.26"
 tree-sitter-plum = { path = "../plum-tooling/tree-sitter-plum" }

plum-test-support/src/lib.rs CHANGED Viewed

@@ -60,16 +60,22 @@ pub fn load(name: &str, src: &str) -> Result<Source, String> {
     std::fs::create_dir_all(&dir).unwrap();
     let path = dir.join("main.plum");
     std::fs::write(&path, src).unwrap();
-    let r = plum_core::loadAndMerge(&path, &repoRoot());
+    let r = plum_core::loader::loadAndMergeDiag(&path, &repoRoot());
     let _ = std::fs::remove_dir_all(&dir);
-    r.map_err(|e| format!("{e}"))
+    r.map_err(|ds| ds.iter().map(|d| d.to_string()).collect::<Vec<_>>().join("\n"))
+}
+/// Compiles a loaded `source` with the default options; the errors are one text.
+pub fn compileSource(source: &Source) -> Result<Vec<u8>, String> {
+    plum_wasm_codegen::compile(source, &plum_wasm_codegen::CompileOptions::default())
+        .map(|o| o.wasm)
+        .map_err(|ds| ds.iter().map(|d| d.to_string()).collect::<Vec<_>>().join("\n"))
 }
 /// load + compileSource + validate; panics on any error.
 pub fn compile(name: &str, src: &str) -> Vec<u8> {
     let source = load(name, src).unwrap_or_else(|e| panic!("load failed: {e}"));
-    let bytes = plum_wasm_codegen::compileSource(&source)
-        .unwrap_or_else(|e| panic!("compile failed: {e}"));
+    let bytes = compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
     wasmparser::validate(&bytes).expect("valid wasm");
     bytes
 }
@@ -125,11 +131,11 @@ pub fn runStr(name: &str, src: &str) -> String {
     String::from_utf8_lossy(&buf[start..start + len]).into_owned()
 }
-/// load + typedSource; the checker's messages (a load error is returned as one string).
+/// load + `plum_driver::check`; the checker's messages (a load error is returned as one string).
 pub fn checkErrors(name: &str, src: &str) -> Vec<String> {
     match load(name, src) {
         Err(e) => vec![e],
-        Ok(source) => match plum_checker::typedSource(&source) {
+        Ok(source) => match plum_driver::check(&source, &plum_driver::PassOptions::default()) {
             Ok(_) => vec![],
             Err(errs) => errs.iter().map(|e| e.message.clone()).collect(),
         },

plum-wasm-codegen/Cargo.toml CHANGED Viewed

@@ -7,6 +7,7 @@ edition = "2021"
 wasm-encoder = "0.220"
 plum-core = { path = "../plum-core" }
 plum-checker = { path = "../plum-checker" }
+plum-driver = { path = "../plum-driver" }
 [dev-dependencies]
 plum-test-support = { path = "../plum-test-support" }

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

@@ -5,6 +5,7 @@
 use plum_checker::types::{PlumType, TypeEnv, TypeScheme};
 use plum_checker::{EnumParams, EnumVariantInfo, EnumVariants, MethodEnv};
 use plum_core::ast;
+use plum_core::diag::{DiagKind, Diagnostic};
 use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, HashSet};
 use wasm_encoder::*;
@@ -1471,43 +1472,11 @@ fn inferFallbackType(expr: &ast::Expr, ctx: &LocalCtx) -> PlumType {
     plum_checker::inferExpr(expr, &env, &cctx).unwrap_or(PlumType::TInt)
 }
-/// Type-checks `source` once, returning the per-expression types codegen needs
+/// Type-checks `source` through the pass list (`plum_driver::check`), returning the
-/// (`plum_checker::typedSource`) or the joined `type error: ...` lines.
+/// per-expression types codegen needs.
-pub fn typeCheck(source: &ast::Source) -> Result<plum_checker::TypedInfo, String> {
-    typeCheckIn(source, "")
-}
-/// Like `typeCheck`, naming `file` in positioned errors. Positions refer to the
-/// merged source, so imported-file errors are attributed to the entry file.
+/// An internal codegen failure as a diagnostic.
-pub fn typeCheckIn(source: &ast::Source, file: &str) -> Result<plum_checker::TypedInfo, String> {
-    typeCheckWith(source, file, plum_checker::FusionOptions::default())
-}
-fn typeCheckWith(
-    source: &ast::Source,
-    file: &str,
-    fusion: plum_checker::FusionOptions,
-) -> Result<plum_checker::TypedInfo, String> {
+fn codegenDiag(message: String) -> Vec<Diagnostic> {
-    plum_checker::typedSourceWith(source, fusion).map_err(|errs| {
-        errs.iter()
-            .map(|e| {
-                if e.line > 0 && !file.is_empty() {
-                    format!(
-                        "type error in '{}' at line {}, column {}: {}",
-                        file, e.line, e.column, e.message
-                    )
-                } else if e.line > 0 {
-                    format!(
-                        "type error at line {}, column {}: {}",
-                        e.line, e.column, e.message
-                    )
-                } else {
-                    format!("type error: {}", e.message)
+    vec![Diagnostic::bare(DiagKind::Codegen, message)]
-                }
-            })
-            .collect::<Vec<_>>()
-            .join("\n")
-    })
 }
 /// What `compile` does besides compiling.
@@ -1516,12 +1485,13 @@ pub struct CompileOptions {
     /// Lower `test` blocks into exported `"test#<name>"` fns (`plum test`); otherwise
     /// they are stripped.
     pub tests: bool,
+    /// Which rewrite passes run (`--no-fusion`, `--explain-fusion`).
-    pub fusion: plum_checker::FusionOptions,
+    pub passes: plum_driver::PassOptions,
 }
 impl Default for CompileOptions {
     fn default() -> Self {
-        CompileOptions { tests: false, fusion: plum_checker::FusionOptions::default() }
+        CompileOptions { tests: false, passes: plum_driver::PassOptions::default() }
     }
 }
@@ -1535,23 +1505,23 @@ pub struct Output {
     pub test_names: Vec<String>,
 }
-/// The one compile entry: type-checks `source` (fusion per `opts.fusion`) and compiles it.
+/// The one compile entry: type-checks `source` (passes per `opts.passes`) and compiles it.
 /// With `opts.tests`, `test` blocks are first lowered to ordinary fns (see
 /// `plum_core::tests_lower`) and exported.
-pub fn compile(source: &ast::Source, opts: &CompileOptions) -> Result<Output, String> {
+pub fn compile(source: &ast::Source, opts: &CompileOptions) -> Result<Output, Vec<Diagnostic>> {
-    if opts.fusion.explain {
+    if opts.passes.explain {
         for line in explainLayouts(source) {
             eprintln!("{line}");
         }
     }
     if opts.tests {
         let prog = plum_core::tests_lower::lowerTests(source);
-        let typed = typeCheckWith(&prog.source, "", opts.fusion)?;
+        let typed = plum_driver::check(&prog.source, &opts.passes)?;
-        let (wasm, fn_keys) = compileSourceInner(&prog.source, &prog.extraExports, typed)?;
+        let (wasm, fn_keys) = compileSourceInner(&prog.source, &prog.extraExports, typed).map_err(codegenDiag)?;
         Ok(Output { wasm, fn_keys, test_names: prog.names })
     } else {
-        let typed = typeCheckWith(source, "", opts.fusion)?;
+        let typed = plum_driver::check(source, &opts.passes)?;
-        let (wasm, fn_keys) = compileSourceInner(source, &[], typed)?;
+        let (wasm, fn_keys) = compileSourceInner(source, &[], typed).map_err(codegenDiag)?;
         Ok(Output { wasm, fn_keys, test_names: Vec::new() })
     }
 }
@@ -1571,10 +1541,6 @@ pub fn explainLayouts(source: &ast::Source) -> Vec<String> {
         .collect()
 }
-pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
-    compile(source, &CompileOptions::default()).map(|o| o.wasm)
-}
 pub use plum_core::tests_lower::{TestProgram, ASSERT_REPORT_MARK};
 #[cfg(test)]
@@ -1587,15 +1553,14 @@ mod compileEntryTests {
         std::fs::create_dir_all(&dir).unwrap();
         let path = dir.join("main.plum");
         std::fs::write(&path, SRC).unwrap();
-        plum_core::loadAndMerge(&path, &plum_test_support::repoRoot()).expect("load")
+        plum_core::loadAndMergeDiag(&path, &plum_test_support::repoRoot()).expect("load")
     }
     #[test]
-    fn defaultMatchesCompileSource() {
+    fn defaultOptionsCompileWithoutTests() {
         let src = load();
         let out = compile(&src, &CompileOptions::default()).expect("compiles");
         assert!(out.test_names.is_empty());
-        assert_eq!(out.wasm, compileSource(&src).expect("compiles"));
     }
     #[test]

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

@@ -1,8 +1,11 @@
 #![allow(non_snake_case)]
+use plum_test_support::compileSource;
-use plum_wasm_codegen::{compile, compileSource, CompileOptions};
+use plum_wasm_codegen::{compile, CompileOptions};
 fn compileTestSource(source: &plum_core::ast::Source) -> Result<(Vec<u8>, Vec<String>), String> {
-    compile(source, &CompileOptions { tests: true, ..CompileOptions::default() }).map(|o| (o.wasm, o.test_names))
+    compile(source, &CompileOptions { tests: true, ..CompileOptions::default() })
+        .map(|o| (o.wasm, o.test_names))
+        .map_err(|ds| ds.iter().map(|d| d.to_string()).collect::<Vec<_>>().join("\n"))
 }
 use wasm_encoder::Encode;
@@ -81,7 +84,7 @@ test \"hard assert traps\"
     std::fs::create_dir_all(&dir).unwrap();
     let path = dir.join("main.plum");
     std::fs::write(&path, src).unwrap();
-    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let source = plum_core::loadAndMergeDiag(&path, &repoRoot()).expect("load");
     let (bytes, names) = compileTestSource(&source).expect("test source should compile");
     let result = wasmparser::validate(&bytes);
     assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());
@@ -169,7 +172,7 @@ test \"fb int\"
     std::fs::create_dir_all(&dir).unwrap();
     let path = dir.join("main.plum");
     std::fs::write(&path, src).unwrap();
-    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let source = plum_core::loadAndMergeDiag(&path, &repoRoot()).expect("load");
     let (bytes, _names) = compileTestSource(&source).expect("test source should compile");
     let engine = gcEngine();
     let module = wasmtime::Module::new(&engine, &bytes).expect("module should be loadable");
@@ -1049,7 +1052,7 @@ fn runMerged<R: wasmtime::WasmResults>(name: &str, src: &str) -> R {
     std::fs::create_dir_all(&dir).unwrap();
     let path = dir.join("main.plum");
     std::fs::write(&path, src).unwrap();
-    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let source = plum_core::loadAndMergeDiag(&path, &repoRoot()).expect("load");
     plum_checker::checkSource(&source).unwrap_or_else(|e| {
         panic!(
             "check errors: {:?}",
@@ -1083,7 +1086,7 @@ fn compiledKeys(name: &str, src: &str) -> (Vec<u8>, Vec<String>) {
     std::fs::create_dir_all(&dir).unwrap();
     let path = dir.join("main.plum");
     std::fs::write(&path, src).unwrap();
-    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let source = plum_core::loadAndMergeDiag(&path, &repoRoot()).expect("load");
     let o = compile(&source, &CompileOptions::default()).expect("compile");
     let r = (o.wasm, o.fn_keys);
     let _ = std::fs::remove_dir_all(&dir);
@@ -1537,7 +1540,7 @@ fun main() -> Int =
     std::fs::create_dir_all(&dir).unwrap();
     let path = dir.join("main.plum");
     std::fs::write(&path, src).unwrap();
-    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let source = plum_core::loadAndMergeDiag(&path, &repoRoot()).expect("load");
     // Same as any other method of a std type that was not imported: rejected by the checker.
     assert!(
         plum_checker::checkSource(&source).is_err(),
@@ -1911,7 +1914,7 @@ fn checkErrorsMerged(name: &str, src: &str) -> String {
     std::fs::create_dir_all(&dir).unwrap();
     let path = dir.join("main.plum");
     std::fs::write(&path, src).unwrap();
-    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let source = plum_core::loadAndMergeDiag(&path, &repoRoot()).expect("load");
     let _ = std::fs::remove_dir_all(&dir);
     match plum_checker::checkSource(&source) {
         Ok(()) => String::new(),
@@ -1963,7 +1966,7 @@ fn runWithCrash(name: &str, src: &str) -> (Result<i64, String>, Vec<String>) {
     std::fs::create_dir_all(&dir).unwrap();
     let path = dir.join("main.plum");
     std::fs::write(&path, src).unwrap();
-    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let source = plum_core::loadAndMergeDiag(&path, &repoRoot()).expect("load");
     plum_checker::checkSource(&source).unwrap_or_else(|e| {
         panic!(
             "check errors: {:?}",
@@ -2229,7 +2232,7 @@ fn strIsAViewOfAPackedByteArray() {
     std::fs::create_dir_all(&dir).unwrap();
     let path = dir.join("main.plum");
     std::fs::write(&path, src).unwrap();
-    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let source = plum_core::loadAndMergeDiag(&path, &repoRoot()).expect("load");
     let bytes = compileSource(&source).expect("compile failed");
     let _ = std::fs::remove_dir_all(&dir);
     let mut byte_arrays = std::collections::HashSet::new();
@@ -2305,7 +2308,7 @@ fun main() -> Float =
     std::fs::create_dir_all(&dir).unwrap();
     let path = dir.join("main.plum");
     std::fs::write(&path, src).unwrap();
-    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let source = plum_core::loadAndMergeDiag(&path, &repoRoot()).expect("load");
     plum_checker::checkSource(&source).expect("check");
     let bytes = compileSource(&source).expect("compile failed");
     let _ = std::fs::remove_dir_all(&dir);
@@ -2386,7 +2389,7 @@ fn instantiateExports(name: &str, src: &str) -> (wasmtime::Store<()>, wasmtime::
     let path = dir.join("main.plum");
     let full = format!("import std/Int\nimport std/Float\nimport std/Bool\nimport std/Str\n{src}");
     std::fs::write(&path, full).unwrap();
-    let source = plum_core::loadAndMerge(&path, &exportRepoRoot());
+    let source = plum_core::loadAndMergeDiag(&path, &exportRepoRoot());
     let _ = std::fs::remove_dir_all(&dir);
     let source = source.expect("load");
     let bytes = compileSource(&source).expect("compile failed");
@@ -2713,7 +2716,7 @@ fun main() -> Int =
     std::fs::create_dir_all(&dir).unwrap();
     let path = dir.join("main.plum");
     std::fs::write(&path, src).unwrap();
-    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let source = plum_core::loadAndMergeDiag(&path, &repoRoot()).expect("load");
     let bytes = compileSource(&source).expect("compile");
     let engine = gcEngine();
     let module = wasmtime::Module::new(&engine, &bytes).unwrap();

plum-wasm-codegen/tests/wasm_codegen/e2e_mem/reuse.rs CHANGED Viewed

@@ -9,7 +9,7 @@ fn load(name: &str, src: &str, reuse: bool) -> Result<plum_core::ast::Source, St
 fn runInt(name: &str, src: &str, reuse: bool) -> i64 {
     let source = load(name, src, reuse).expect("load");
-    let bytes = plum_wasm_codegen::compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
+    let bytes = plum_test_support::compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
     wasmparser::validate(&bytes).expect("valid wasm");
     let engine = engine();
     let module = wasmtime::Module::new(&engine, &bytes).unwrap();
@@ -36,12 +36,12 @@ fn structNewCount(name: &str, src: &str, reuse: bool) -> usize {
 fn structNewCountWith(name: &str, src: &str, reuse: bool, fusion: bool) -> usize {
     let source = load(name, src, reuse).expect("load");
     let opts = plum_wasm_codegen::CompileOptions {
-        fusion: plum_checker::FusionOptions { enabled: fusion, explain: false },
+        passes: plum_driver::PassOptions { fusion: fusion, explain: false, ..plum_driver::PassOptions::default() },
         ..Default::default()
     };
     let bytes = plum_wasm_codegen::compile(&source, &opts)
         .map(|o| o.wasm)
-        .unwrap_or_else(|e| panic!("compile failed: {e}"));
+        .unwrap_or_else(|e| panic!("compile failed: {}", e.iter().map(|d| d.to_string()).collect::<Vec<_>>().join("\n")));
     wasmparser::validate(&bytes).expect("valid wasm");
     let mut n = 0;
     for payload in wasmparser::Parser::new(0).parse_all(&bytes) {
@@ -97,7 +97,7 @@ fn bump_reuses_cells() {
 fn pipeline_marks_bump_reuse() {
     let p = format!("{PRE}{INC}{BUMP}");
     let source = load("bump_pipeline", &p, false).expect("load");
-    let info = plum_checker::typedSource(&source).expect("checks");
+    let info = plum_driver::check(&source, &plum_driver::PassOptions::default()).expect("checks");
     let low = info.lowered.as_ref().expect("lowered");
     let bump = low
         .items

plum-wasm-codegen/tests/wasm_codegen/e2e_mem/unique_inplace.rs CHANGED Viewed

@@ -4,7 +4,7 @@ use plum_test_support::*;
 /// fn `name` as unique, i.e. proved written in place by uniqueness alone.
 fn spreadIsUnique(name: &str, fnName: &str, src: &str) -> bool {
     let source = load(name, src).expect("load");
-    let info = plum_checker::typedSource(&source).expect("checks");
+    let info = plum_driver::check(&source, &plum_driver::PassOptions::default()).expect("checks");
     let low = info.lowered.as_ref().expect("lowered");
     low.items
         .iter()

plum-wasm-codegen/tests/wasm_codegen/e2e_mem/unique_spread.rs CHANGED Viewed

@@ -19,7 +19,7 @@ fn load(name: &str, src: &str, unique: bool) -> Result<plum_core::ast::Source, S
 fn runInt(name: &str, src: &str, unique: bool) -> i64 {
     let source = load(name, src, unique).expect("load");
-    let bytes = plum_wasm_codegen::compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
+    let bytes = plum_test_support::compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
     wasmparser::validate(&bytes).expect("valid wasm");
     let engine = engine();
     let module = wasmtime::Module::new(&engine, &bytes).unwrap();
@@ -38,7 +38,7 @@ fn runInt(name: &str, src: &str, unique: bool) -> i64 {
 /// Number of `struct.new` instructions in the whole module.
 fn structNewCount(name: &str, src: &str, unique: bool) -> usize {
     let source = load(name, src, unique).expect("load");
-    let bytes = plum_wasm_codegen::compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
+    let bytes = plum_test_support::compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
     wasmparser::validate(&bytes).expect("valid wasm");
     let mut n = 0;
     for payload in wasmparser::Parser::new(0).parse_all(&bytes) {

plum-wasm-codegen/tests/wasm_codegen/e2e_records/enum_init.rs CHANGED Viewed

@@ -1,5 +1,5 @@
 use plum_test_support::{load, runInt};
-use plum_wasm_codegen::compileSource;
+use plum_test_support::compileSource;
 const LINK: &str = "enum Link[T] =
   | Nil
   | Cons(head: T, tail: Link[T])

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

@@ -10,11 +10,11 @@ fn prog(body: &str) -> String {
 fn runWith(name: &str, src: &str, fusion: bool) -> i64 {
     let source = load(name, src).unwrap_or_else(|e| panic!("load failed: {e}"));
     let opts = plum_wasm_codegen::CompileOptions {
-        fusion: plum_checker::FusionOptions { enabled: fusion, explain: false },
+        passes: plum_driver::PassOptions { fusion: fusion, explain: false, ..plum_driver::PassOptions::default() },
         ..plum_wasm_codegen::CompileOptions::default()
     };
     let bytes = plum_wasm_codegen::compile(&source, &opts)
-        .unwrap_or_else(|e| panic!("compile failed: {e}"))
+        .unwrap_or_else(|e| panic!("compile failed: {}", e.iter().map(|d| d.to_string()).collect::<Vec<_>>().join("\n")))
         .wasm;
     wasmparser::validate(&bytes).expect("valid wasm");
     let engine = engine();

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

@@ -1,6 +1,6 @@
 #![allow(non_snake_case)]
 use plum_test_support::{engine, repoRoot};
-use plum_wasm_codegen::compileSource;
+use plum_test_support::compileSource;
 fn examplesDir() -> std::path::PathBuf {
     std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../plum-examples")
@@ -13,8 +13,8 @@ fn examplesDir() -> std::path::PathBuf {
 /// single-file parse would leave those names undeclared.
 fn parseFile(name: &str) -> plum_core::ast::Source {
     let path = examplesDir().join(name);
-    plum_core::loadAndMerge(&path, &repoRoot())
+    plum_core::loadAndMergeDiag(&path, &repoRoot())
-        .unwrap_or_else(|e| panic!("failed to load {}: {}", path.display(), e))
+        .unwrap_or_else(|e| panic!("failed to load {}: {}", path.display(), e.iter().map(|d| d.to_string()).collect::<Vec<_>>().join("\n")))
 }
 fn assertCompiles(name: &str) -> Vec<u8> {
@@ -175,7 +175,7 @@ fn const_table_1000_entries() {
     std::fs::create_dir_all(&dir).unwrap();
     let path = dir.join("t.plum");
     std::fs::write(&path, src).unwrap();
-    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("1000-const file should load");
+    let source = plum_core::loadAndMergeDiag(&path, &repoRoot()).expect("1000-const file should load");
     let bytes = compileSource(&source).expect("1000-const file should compile");
     assert!(wasmparser::validate(&bytes).is_ok());
     std::fs::remove_dir_all(&dir).ok();

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

@@ -6,19 +6,19 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 fn loadFile(path: &std::path::Path) -> plum_core::ast::Source {
-    plum_core::loadAndMerge(path, &repoRoot()).unwrap_or_else(|e| panic!("load: {e}"))
+    plum_core::loadAndMergeDiag(path, &repoRoot()).unwrap_or_else(|e| panic!("load: {e:?}"))
 }
 fn load(name: &str, src: &str) -> plum_core::ast::Source {
-    plum_test_support::load(name, src).unwrap_or_else(|e| panic!("load: {e}"))
+    plum_test_support::load(name, src).unwrap_or_else(|e| panic!("load: {e:?}"))
 }
 fn compile(source: &plum_core::ast::Source, fusion: bool) -> Vec<u8> {
     let opts = plum_wasm_codegen::CompileOptions {
-        fusion: plum_checker::FusionOptions { enabled: fusion, explain: false },
+        passes: plum_driver::PassOptions { fusion: fusion, explain: false, ..plum_driver::PassOptions::default() },
         ..Default::default()
     };
-    let bytes = plum_wasm_codegen::compile(source, &opts).map(|o| o.wasm).unwrap_or_else(|e| panic!("compile failed: {e}"));
+    let bytes = plum_wasm_codegen::compile(source, &opts).map(|o| o.wasm).unwrap_or_else(|e| panic!("compile failed: {}", e.iter().map(|d| d.to_string()).collect::<Vec<_>>().join("\n")));
     wasmparser::validate(&bytes).expect("valid wasm");
     bytes
 }
@@ -120,16 +120,16 @@ const PRE: &str = "import std/Str\nimport std/Int\nimport std/List\nimport std/S
 /// The fusion notes for `source` (what `--explain-fusion` prints): the stage is run
 /// by hand on the checker's lowered program, built without fusion.
 fn notes(source: &plum_core::ast::Source) -> Vec<String> {
-    let info = plum_checker::typedSourceWith(
+    let info = plum_driver::check(
         source,
-        plum_checker::FusionOptions { enabled: false, explain: false },
+        &plum_driver::PassOptions { fusion: false, explain: false, ..plum_driver::PassOptions::default() },
     )
     .unwrap_or_else(|e| panic!("check: {e:?}"));
     let mut copy = match info.lowered.as_ref() {
         Some(l) => (**l).clone(),
         None => source.clone(),
     };
-    plum_checker::fusionRewrite(&mut copy)
+    plum_driver::fusionNotes(&mut copy)
 }
 /// `struct.new` descriptions of every function reachable from `root` through direct calls,