onejs-sl 0.1.5 → 0.1.7

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.1.7
+
+`diagnose` finds a mistake inside a refused call's arguments and on both sides of an operator, found by the Play editor's first run in a real browser. Nothing a program compiles to changes.
+
+- `fract(uv * wrap)` reports both `fract` and `wrap`
+
+## 0.1.6
+
+`diagnose(source)` returns every error in a file, for an editor checking as it is typed (`Specs/SL_NEXT.md` 5). Nothing a program compiles to changes.
+
+- `diagnose` finds a mistake in each statement and declaration, in source order, and never throws one
+- A refused local is still declared, so its uses are not reported again
+
 ## 0.1.5
 
 What an editor needs, and errors that fix themselves (`Specs/SL_NEXT.md` 5 and 9). Every program that compiled before compiles to exactly what it did, unless it names something after a keyword or a type.

package/README.md

@@ -35,7 +35,7 @@ only what it calls.
 
 | Entry | Contents |
 |---|---|
-| `onejs-sl` | `parse` and `analyze`, `classify` (every token with its class, comments kept, never throws), the TypeScript form `sl`, the IR types, `SL_IR_VERSION`, `toJSON`/`fromJSON`, `SLParseError` (file, line, column, offset, length, the bare `text`, and a `fix` where one is certain) |
+| `onejs-sl` | `parse` and `analyze`, `diagnose` (every error in a file, not just the first), `classify` (every token with its class, comments kept, never throws), the TypeScript form `sl`, the IR types, `SL_IR_VERSION`, `toJSON`/`fromJSON`, `SLParseError` (file, line, column, offset, length, the bare `text`, and a `fix` where one is certain) |
 | `onejs-sl/core` | the same without the parser: what a game needs at run time |
 | `onejs-sl/tables` | `BUILTINS`, `SL_HLSL`, `INPUTS`, `SL_SDF_SHAPES`, `SL_SDF_PARAMS`, `SL_KEYWORDS`, `SL_TYPES`, `TYPE_WIDTH`, `PRELUDE_NAMES`: what completion and highlighting read. `BUILTIN_PARAMS`, `SL_SDF_PARAM_NAMES` and `LIB_SIGNATURES` name every parameter, so an editor can show `lerp(x, y, s)`, and `BUILTIN_DOCS`, `INPUT_DOCS` and `PRELUDE_DOCS` give each a line for its tooltip |
 | `onejs-sl/limits` | `vmFit(program)`: whether the VM runs it, and why not, without encoding |
@@ -159,11 +159,25 @@ and QuickJS (Magerie). Two checks hold it to that:
 
 Push a tag `v<version>` matching `package.json`; `.github/workflows/publish.yml`
 publishes through npm trusted publishing (OIDC), so no token exists anywhere.
-Note the release in `CHANGELOG.md` first. The one exception is the first version: npm
-attaches a trusted publisher to a package that already exists, so 0.1.0 was
-published by hand, and the workflow checks its tag and publishes nothing. In the OneJS container this package
-is checked out at `JSModules/onejs-sl`, and `onejs-unity` links it with
-`file:../onejs-sl` as a dev dependency beside its `^` peer range.
+Before the tag:
+
+1. Note the release in `CHANGELOG.md` and bump `package.json`.
+2. Prove the corpus: a program that compiled before compiles to the same bytes,
+   unless the release says otherwise.
+3. Run PlaySite's checks in the container, where the Play editor bundles this
+   package: `node scripts/gen-sl-parser.mjs`, then `npx vitest run`, in
+   `PlaySite/`. It is a private repo, so no workflow here can.
+4. Push `main` and wait for CI, whose `consumers` job runs onejs-unity's
+   typecheck and tests against the commit (`consumers.yml`). `publish.yml`
+   runs the same job and publishes nothing if it fails. When a consumer has to
+   follow a change, land it here, fix the consumer, then re-run and tag.
+
+The one exception to publishing by tag is the first version: npm attaches a
+trusted publisher to a package that already exists, so 0.1.0 was published by
+hand, and the workflow checks its tag and publishes nothing. In the OneJS
+container this package is checked out at `JSModules/onejs-sl`, and
+`onejs-unity` links it with `file:../onejs-sl` as a dev dependency beside its
+`^` peer range.
 
 ## The one idea
 
@@ -179,7 +193,7 @@ generated HLSL after an eject, with no edit in between. Both backends exist:
 and `hlsl.ts` feeds its `Editor/SLShaderGenerator.cs`. Nobody writes a manifest for the
 second: an editor that interprets a program asks the encoded program for its
 `hlsl` (a lazy getter, never read in Play), records it into
-`Assets/OneJS.Generated/Shaders/Recorded.sl.json`, generates the shader and
+`Assets/OneJS/Recorded.sl.json`, generates the shader and
 moves the live material onto it. `manifest()` is still there for an app that
 would rather write its programs out at build time.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onejs-sl",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "The OneJS shader language: a small typed language for per pixel programs, compiled to a portable IR and emitted as HLSL, WGSL, GLSL ES or a VM buffer",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/index.ts

@@ -6,7 +6,7 @@
  * HLSL, WGSL or GLSL ES) is a separate entry, so a host bundles only what it
  * calls:
  *
- *   onejs-sl             this: parse, classify, the TypeScript form, the IR, its JSON
+ *   onejs-sl             this: parse, diagnose, classify, the TypeScript form, the IR, its JSON
  *   onejs-sl/core        the same without the parser, for a game at run time
  *   onejs-sl/tables      builtins, opcodes, inputs, shapes: what an editor reads
  *   onejs-sl/limits      whether a program fits the VM, without encoding it
@@ -19,7 +19,7 @@
  */
 export * from "./core"
 export {
-    analyze, classify, parse, parseUnit, preludeFunctions, tokenize, PRELUDE_SOURCE, SLParseError,
+    analyze, classify, diagnose, parse, parseUnit, preludeFunctions, tokenize, PRELUDE_SOURCE, SLParseError,
 } from "./lang"
 export type {
     Checked, Expr, FuncDecl, ParseOptions, Pos, SLClassifiedToken, SLFix, SLTokenClass, Stmt, Token, Unit,

package/src/lang/README.md

@@ -186,6 +186,19 @@ and `%` truncates, and neither does `int`, since float would change what
 dividing it does. That is Decision 1 kept as `Specs/SL_NEXT.md` 5 A has it:
 one spelling, and every hint a fix.
 
+## Several errors at once
+
+`parse` throws the first error; `diagnose(source)` returns all of them, in
+source order, and never throws one, for an editor checking as the file is
+typed. Each stage carries on past a mistake: the parser skips to the next
+statement or declaration, the checker and the lowering move to the next one,
+and a local whose line was refused is still declared, as a zero of its type, so
+its uses are not reported again. A later stage runs only when the earlier ones
+found nothing: names are not checked in a file that cannot be read, since those
+errors would be about the hole. `diagnose.test.ts` holds it to the property that
+matters, that whatever `parse` refuses a file with, `diagnose` reports at the
+same place, over every program one token short of a real one.
+
 ## For an editor
 
 `classify(source)` is every token with its class (keyword, type, builtin,

package/src/lang/check.ts

@@ -69,6 +69,8 @@ export interface Checked {
 export interface CheckOptions {
     /** Off for the prelude, which is functions only. See `parseUnit`. */
     requireMain?: boolean
+    /** Where to collect errors instead of throwing the first. See `diagnose`. */
+    errors?: SLParseError[]
 }
 
 export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {}): Checked {
@@ -82,6 +84,23 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
             throw new SLParseError(message, file, pos, length, fix)
         }
 
+    /**
+     * One declaration's or one statement's checks. Collecting, an error is
+     * recorded and the next one is checked; the name it declares is still
+     * declared, so a later use of it is not a second, false error.
+     */
+    const attempt = (check: () => void): boolean => {
+        if (options.errors === undefined) { check(); return true }
+        try {
+            check()
+            return true
+        } catch (e) {
+            if (!(e instanceof SLParseError)) throw e
+            options.errors.push(e)
+            return false
+        }
+    }
+
     const funcs = new Map<string, FuncDecl>()
     for (const fn of prelude) funcs.set(fn.name, fn)
 
@@ -126,11 +145,14 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
     }
 
     for (const u of unit.uniforms) {
-        const clash = valueClash(u.name)
-        if (clash !== null) fail(`"${u.name}" already names ${clash}`, u.pos, u.name.length)
-        uniforms.set(u.name, u)
+        attempt(() => {
+            const clash = valueClash(u.name)
+            if (clash !== null) fail(`"${u.name}" already names ${clash}`, u.pos, u.name.length)
+        })
+        if (!uniforms.has(u.name)) uniforms.set(u.name, u)
     }
-    if (uniforms.size > VM_UNIFORMS) {
+    attempt(() => {
+        if (uniforms.size <= VM_UNIFORMS) return
         const over = unit.uniforms[VM_UNIFORMS]!
         fail(
             `this file declares ${uniforms.size} uniforms and a program may hold ${VM_UNIFORMS}. ` +
@@ -139,14 +161,17 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
             `a float4.`,
             over.pos, over.name.length,
         )
-    }
+    })
 
     for (const t of unit.textures) {
-        const clash = valueClash(t.name)
-        if (clash !== null) fail(`"${t.name}" already names ${clash}`, t.pos, t.name.length)
-        textures.set(t.name, t)
+        attempt(() => {
+            const clash = valueClash(t.name)
+            if (clash !== null) fail(`"${t.name}" already names ${clash}`, t.pos, t.name.length)
+        })
+        if (!textures.has(t.name)) textures.set(t.name, t)
     }
-    if (textures.size > VM_TEXTURES) {
+    attempt(() => {
+        if (textures.size <= VM_TEXTURES) return
         const over = unit.textures[VM_TEXTURES]!
         fail(
             `this file declares ${textures.size} textures and a program may sample ${VM_TEXTURES}. ` +
@@ -154,24 +179,28 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
             `and its own after an eject, which is two different pictures from one file.`,
             over.pos, over.name.length,
         )
-    }
+    })
 
     for (const c of unit.consts) {
-        const clash = valueClash(c.name)
-        if (clash !== null) fail(`"${c.name}" already names ${clash}`, c.pos, c.name.length)
-        consts.set(c.name, c)
+        attempt(() => {
+            const clash = valueClash(c.name)
+            if (clash !== null) fail(`"${c.name}" already names ${clash}`, c.pos, c.name.length)
+        })
+        if (!consts.has(c.name)) consts.set(c.name, c)
     }
 
     for (const fn of unit.funcs) {
-        const clash = taken(fn.name)
-        if (clash !== null) fail(`"${fn.name}" already names ${clash}`, fn.pos, fn.name.length)
-        if (unit.funcs.filter((f) => f.name === fn.name).length > 1) {
-            fail(
-                `this file declares ${fn.name} more than once. There is no overloading: a function ` +
-                `inlines, so two bodies under one name have nothing to pick between them`,
-                fn.pos, fn.name.length,
-            )
-        }
+        attempt(() => {
+            const clash = taken(fn.name)
+            if (clash !== null) fail(`"${fn.name}" already names ${clash}`, fn.pos, fn.name.length)
+            if (unit.funcs.filter((f) => f.name === fn.name).length > 1) {
+                fail(
+                    `this file declares ${fn.name} more than once. There is no overloading: a function ` +
+                    `inlines, so two bodies under one name have nothing to pick between them`,
+                    fn.pos, fn.name.length,
+                )
+            }
+        })
         funcs.set(fn.name, fn)
     }
 
@@ -179,19 +208,23 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
     if (main === null) {
         if (options.requireMain ?? true) throw new Error("check() reached a unit with no main")
         for (const fn of unit.funcs) checkFunction(fn)
-        refuseRecursion()
+        attempt(refuseRecursion)
         return { unit, funcs, uniforms, textures, consts }
     }
-    if (main.ret !== "float4") {
-        fail(`main returns a colour, so it is declared \`float4 main()\`, not ${main.ret}`, main.pos)
-    }
-    if (main.params.length > 0) {
-        fail(
-            "main takes no parameters: what a program is given are the free identifiers uv, " +
-            "fragCoord, resolution, time and aspect",
-            main.params[0]!.pos,
-        )
-    }
+    attempt(() => {
+        if (main.ret !== "float4") {
+            fail(`main returns a colour, so it is declared \`float4 main()\`, not ${main.ret}`, main.pos)
+        }
+    })
+    attempt(() => {
+        if (main.params.length > 0) {
+            fail(
+                "main takes no parameters: what a program is given are the free identifiers uv, " +
+                "fragCoord, resolution, time and aspect",
+                main.params[0]!.pos,
+            )
+        }
+    })
 
     // MARK: bodies
 
@@ -201,7 +234,7 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
     // which is not the author's mistake and not a name they can see.
     for (const fn of [...unit.funcs, main]) checkFunction(fn)
 
-    refuseRecursion()
+    attempt(refuseRecursion)
 
     /**
      * A function inlines, so a cycle is not slow, it is infinite.
@@ -272,9 +305,11 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
     function checkFunction(fn: FuncDecl): void {
         const params = new Set<string>()
         for (const p of fn.params) {
-            const clash = valueClash(p.name)
-            if (clash !== null) fail(`"${p.name}" already names ${clash}`, p.pos, p.name.length)
-            if (params.has(p.name)) fail(`${fn.name} already has a parameter called "${p.name}"`, p.pos)
+            attempt(() => {
+                const clash = valueClash(p.name)
+                if (clash !== null) fail(`"${p.name}" already names ${clash}`, p.pos, p.name.length)
+                if (params.has(p.name)) fail(`${fn.name} already has a parameter called "${p.name}"`, p.pos)
+            })
             params.add(p.name)
         }
         checkBody(fn, fn.body, new Set(params), true)
@@ -291,8 +326,20 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
         let returned: Stmt | null = null
         for (const s of body) {
             if (returned !== null) {
-                fail("this is after the return, so it can never run", s.pos)
+                // Once: everything after it is the same mistake.
+                attempt(() => fail("this is after the return, so it can never run", s.pos))
+                break
             }
+            attempt(() => checkStmt(s))
+            if (s.k === "var" || s.k === "const") scope.add(s.name)
+            // Only the outermost return ends a body; one inside an if is refused as that.
+            if (s.k === "return" && outermost) returned = s
+        }
+        if (outermost && returned === null) {
+            attempt(() => fail(`${fn.name} never returns a ${fn.ret}`, fn.pos, fn.name.length))
+        }
+
+        function checkStmt(s: Stmt): void {
             switch (s.k) {
                 case "var":
                 case "const": {
@@ -300,7 +347,6 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                     if (clash !== null) fail(`"${s.name}" already names ${clash}`, s.pos, s.name.length)
                     if (scope.has(s.name)) fail(`"${s.name}" is already declared in this body`, s.pos)
                     checkExpr(fn, s.init, scope)
-                    scope.add(s.name)
                     break
                 }
                 case "assign": {
@@ -347,8 +393,11 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                     const inner = new Set(scope)
                     inner.add(s.counter)
                     counters.add(s.counter)
-                    checkBody(fn, s.body, inner, false)
-                    counters.delete(s.counter)
+                    try {
+                        checkBody(fn, s.body, inner, false)
+                    } finally {
+                        counters.delete(s.counter)
+                    }
                     break
                 }
                 case "return":
@@ -361,13 +410,9 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                         )
                     }
                     checkExpr(fn, s.value, scope)
-                    returned = s
                     break
             }
         }
-        if (outermost && returned === null) {
-            fail(`${fn.name} never returns a ${fn.ret}`, fn.pos, fn.name.length)
-        }
     }
 
     // MARK: expressions
@@ -408,20 +453,31 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                 }
                 checkExpr(fn, e.obj, scope)
                 return
-            case "call":
-                checkCall(fn, e, scope)
+            case "call": {
+                if (attempt(() => checkCall(fn, e, scope))) return
+                // Only reached while collecting: the call was refused, and its
+                // arguments are separate questions, so a mistake inside one is
+                // not hidden by the call's own. `fract(uv * wrap)` is two
+                // mistakes. tex2D's first argument is the texture, which is a
+                // value only there.
+                const tex = e.callee.k === "ident" && e.callee.name === "tex2D"
+                for (const a of tex ? e.args.slice(1) : e.args) attempt(() => checkExpr(fn, a, scope))
                 return
+            }
+            // Each operand on its own, so that while collecting a mistake on one
+            // side does not hide one on the other. Without a collector, `attempt`
+            // is the plain call, and the first error throws as it always did.
             case "unary":
                 checkExpr(fn, e.arg, scope)
                 return
             case "binary":
-                checkExpr(fn, e.a, scope)
-                checkExpr(fn, e.b, scope)
+                attempt(() => checkExpr(fn, e.a, scope))
+                attempt(() => checkExpr(fn, e.b, scope))
                 return
             case "cond":
-                checkExpr(fn, e.cond, scope)
-                checkExpr(fn, e.then, scope)
-                checkExpr(fn, e.else, scope)
+                attempt(() => checkExpr(fn, e.cond, scope))
+                attempt(() => checkExpr(fn, e.then, scope))
+                attempt(() => checkExpr(fn, e.else, scope))
                 return
         }
     }

package/src/lang/index.ts

@@ -19,6 +19,7 @@
 
 import type { Program } from "../ir"
 import { check, type Checked } from "./check"
+import { SLParseError } from "./lexer"
 import { lower } from "./lower"
 import { parseUnit, type ParseOptions } from "./parser"
 import { preludeFunctions } from "./prelude"
@@ -29,7 +30,7 @@ export type {
     Expr, FuncDecl, Param, Stmt, TextureDecl, TypeName, UniformDecl, Unit,
 } from "./ast"
 export { TYPE_WIDTH } from "./ast"
-export { SLParseError } from "./lexer"
+export { SLParseError }
 export type { Pos, SLFix, Token } from "./lexer"
 export { tokenize } from "./lexer"
 export { classify } from "./classify"
@@ -56,3 +57,38 @@ export function analyze(source: string, options: ParseOptions = {}): Checked {
     const unit = parseUnit(source, options)
     return check(unit, preludeFunctions(), { requireMain: options.requireMain })
 }
+
+/**
+ * Every error in a file, in source order, for an editor checking as it is
+ * typed. Empty when the file compiles. Never throws a `SLParseError`.
+ *
+ * Errors of one kind at a time, the first kind the file has: what cannot be
+ * read, then names and shapes (`check`), then types and widths (lowering).
+ * Each stage carries on past an error, a statement or a declaration at a time;
+ * a later stage runs only on a file the earlier ones passed, since its errors
+ * about a file with a hole in it would be about the hole.
+ */
+export function diagnose(source: string, options: ParseOptions = {}): SLParseError[] {
+    const errors: SLParseError[] = []
+    try {
+        const unit = parseUnit(source, { ...options, errors })
+        if (errors.length === 0) {
+            const checked = check(unit, preludeFunctions(), { requireMain: options.requireMain, errors })
+            if (errors.length === 0) lower(checked, errors)
+        }
+    } catch (e) {
+        // The lexer's, which stops at the first character it cannot read.
+        if (!(e instanceof SLParseError)) throw e
+        errors.push(e)
+    }
+    // An error in a loop body or an inlined function is found once per copy.
+    const seen = new Set<string>()
+    return errors
+        .filter((e) => {
+            const key = `${e.offset}:${e.text}`
+            if (seen.has(key)) return false
+            seen.add(key)
+            return true
+        })
+        .sort((a, b) => a.offset - b.offset)
+}

package/src/lang/lower.ts

@@ -82,7 +82,12 @@ class Scope {
     }
 }
 
-export function lower(checked: Checked): Program {
+/**
+ * `errors`, when given, collects every error lowering finds and carries on past
+ * each, one statement or declaration at a time, for `diagnose`. The program it
+ * returns then is not one to draw.
+ */
+export function lower(checked: Checked, errors?: SLParseError[]): Program {
     const { unit, funcs } = checked
     const file = unit.file
     const main = unit.main!
@@ -114,6 +119,26 @@ export function lower(checked: Checked): Program {
             throw new SLParseError(message, file, pos, length)
         }
 
+    /**
+     * Collecting, runs one statement or declaration, recording its error and
+     * returning `fallback()` instead of throwing. The fallback declares what the
+     * broken line would have, so a later use of that name is not a second error.
+     */
+    const recover = <T,>(step: () => T, fallback: () => T): T => {
+        if (errors === undefined) return step()
+        try {
+            return step()
+        } catch (e) {
+            if (!(e instanceof SLParseError)) throw e
+            errors.push(e)
+            return fallback()
+        }
+    }
+
+    /** A zero of a width, standing in for a value whose line was refused. */
+    const blank = (width: SLType, pos: Pos): LV =>
+        width === 1 ? 0 : at(pos, () => compose(width, new Array<LV>(width).fill(0)))
+
     // The globals every helper below reads, built inside the recording callback
     // and held out here so a function being inlined can see them and nothing
     // else the caller had in scope.
@@ -143,7 +168,10 @@ export function lower(checked: Checked): Program {
             // declaration still takes its slot and still reaches the host.
             for (const u of unit.uniforms) {
                 const width = TYPE_WIDTH[u.type]
-                const { components, colour } = uniformDefault(u.type, u.init)
+                const { components, colour } = recover(
+                    () => uniformDefault(u.type, u.init),
+                    () => ({ ...uniformDefault(u.type, null), colour: false }),
+                )
                 // A hex default says the uniform IS a colour, so every read of it
                 // converts, exactly as a hex literal in an expression does. Without
                 // that, `#ff8040` and a uniform defaulting to `#ff8040` would be two
@@ -158,12 +186,18 @@ export function lower(checked: Checked): Program {
             for (const t of unit.textures) samplers.set(t.name, at(t.pos, () => sl.texture(t.name)))
 
             for (const c of unit.consts) {
-                const v = fit(lowerExpr(c.init, global), TYPE_WIDTH[c.type], c.pos)
-                assertWidth(v, TYPE_WIDTH[c.type], c.name, c.type, c.pos)
-                global.declare(c.name, { width: TYPE_WIDTH[c.type], value: v })
+                const width = TYPE_WIDTH[c.type]
+                const v = recover(() => {
+                    const v = fit(lowerExpr(c.init, global), width, c.pos)
+                    assertWidth(v, width, c.name, c.type, c.pos)
+                    return v
+                }, () => blank(width, c.pos))
+                global.declare(c.name, { width, value: v })
             }
 
-            const out = exec(main.body, new Scope(global))
+            const out = exec(main.body, new Scope(global), 4)
+            // What a refused line left behind is not the program's colour.
+            if (errors !== undefined && errors.length > 0) return blank(4, main.pos) as never
             // Checked here rather than left to `sl.program`, which would refuse it
             // in the EDSL's words ("a vec4") about a file whose types are spelled
             // float4, and from outside the reach of a position.
@@ -280,17 +314,34 @@ export function lower(checked: Checked): Program {
 
     // MARK: statements
 
-    /** Runs a body. The value of its `return`, or nothing when it has none. */
-    function exec(body: Stmt[], scope: Scope): LV | undefined {
+    /**
+     * Runs a body. The value of its `return`, or nothing when it has none.
+     * `ret` is the width that return has, for the stand in when it is refused.
+     */
+    function exec(body: Stmt[], scope: Scope, ret: SLType): LV | undefined {
         for (const s of body) {
+            if (s.k === "return") {
+                returnedAt = s.pos
+                return recover(() => lowerExpr(s.value, scope), () => blank(ret, s.pos))
+            }
+            if (s.k === "var" || s.k === "const") {
+                const width = TYPE_WIDTH[s.type]
+                const v = recover(() => {
+                    const v = fit(lowerExpr(s.init, scope), width, s.pos)
+                    assertWidth(v, width, s.name, s.type, s.pos)
+                    return v
+                }, () => blank(width, s.pos))
+                scope.declare(s.name, { width, value: v })
+                continue
+            }
+            recover(() => run(s, scope, ret), () => undefined)
+        }
+        return undefined
+    }
+
+    /** An assignment, an if or a for. */
+    function run(s: Stmt, scope: Scope, ret: SLType): void {
             switch (s.k) {
-                case "var":
-                case "const": {
-                    const v = fit(lowerExpr(s.init, scope), TYPE_WIDTH[s.type], s.pos)
-                    assertWidth(v, TYPE_WIDTH[s.type], s.name, s.type, s.pos)
-                    scope.declare(s.name, { width: TYPE_WIDTH[s.type], value: v })
-                    break
-                }
                 case "assign": {
                     // The checker allowed exactly two shapes: a local, or a
                     // swizzle of one with no component named twice.
@@ -314,15 +365,15 @@ export function lower(checked: Checked): Program {
                     if (typeof cond === "number") {
                         // The one case where a branch really does vanish: the
                         // other side is never lowered, so it costs nothing.
-                        exec(cond >= 0.5 ? s.then : s.else, new Scope(scope))
+                        exec(cond >= 0.5 ? s.then : s.else, new Scope(scope), ret)
                         break
                     }
                     const locals = scope.locals()
                     const before = locals.map((b) => b.value)
-                    exec(s.then, new Scope(scope))
+                    exec(s.then, new Scope(scope), ret)
                     const whenTrue = locals.map((b) => b.value)
                     locals.forEach((b, i) => { b.value = before[i]! })
-                    exec(s.else, new Scope(scope))
+                    exec(s.else, new Scope(scope), ret)
                     const whenFalse = locals.map((b) => b.value)
                     locals.forEach((b, i) => {
                         const t = whenTrue[i]!
@@ -358,17 +409,14 @@ export function lower(checked: Checked): Program {
                         for (let i = from; s.inclusive ? i <= to : i < to; i += step) {
                             const inner = new Scope(scope)
                             inner.declare(s.counter, { width: 1, value: i })
-                            exec(s.body, inner)
+                            exec(s.body, inner, ret)
                         }
                     }))
                     break
                 }
-                case "return":
-                    returnedAt = s.pos
-                    return lowerExpr(s.value, scope)
+                default:
+                    break
             }
-        }
-        return undefined
     }
 
     function constantBound(e: Expr, what: string, scope: Scope): number {
@@ -609,7 +657,7 @@ export function lower(checked: Checked): Program {
             }
             scope.declare(p.name, { width: TYPE_WIDTH[p.type], value: v })
         })
-        const out = exec(fn.body, scope)
+        const out = exec(fn.body, scope, TYPE_WIDTH[fn.ret])
         if (out === undefined) fail(`${fn.name} never returns a value`, e.pos)
         const got = typeof out === "number" ? 1 : out.width
         if (got !== TYPE_WIDTH[fn.ret]) {

package/src/lang/parser.ts

@@ -67,6 +67,8 @@ class Parser {
         private readonly tokens: Token[],
         private readonly file: string,
         private readonly requireMain: boolean,
+        /** Collects errors and carries on, for `diagnose`; without it the first error throws. */
+        private readonly errors?: SLParseError[],
     ) {}
 
     // MARK: token plumbing
@@ -77,10 +79,62 @@ class Parser {
     private eat(text: string): boolean { if (this.at(text)) { this.i++; return true } return false }
 
     private fail(message: string, at: Token = this.peek(), fix?: SLFix): never {
+        throw this.error(message, at, fix)
+    }
+
+    private error(message: string, at: Token, fix?: SLFix): SLParseError {
         // The end of the file is no character, so an error there marks the last
         // token instead of one past it, where an editor has nothing to underline.
         if (at.kind === "eof" && this.tokens.length > 1) at = this.tokens[this.tokens.length - 2]!
-        throw new SLParseError(message, this.file, at as Pos, Math.max(1, at.text.length), fix)
+        return new SLParseError(message, this.file, at as Pos, Math.max(1, at.text.length), fix)
+    }
+
+    /** An error about something already read in full, so there is nothing to skip to carry on. */
+    private report(message: string, at: Token): void {
+        const e = this.error(message, at)
+        if (this.errors === undefined) throw e
+        this.errors.push(e)
+    }
+
+    // MARK: recovery
+
+    /**
+     * Runs one statement's or one declaration's parse. Collecting, an error is
+     * recorded and the tokens are skipped to where the next one starts, so a
+     * second mistake further down the file is found too.
+     */
+    private recover<T>(parse: () => T, level: "statement" | "declaration"): T | null {
+        if (this.errors === undefined) return parse()
+        const start = this.i
+        try {
+            return parse()
+        } catch (e) {
+            if (!(e instanceof SLParseError)) throw e
+            this.errors.push(e)
+            this.skip(level)
+            // A parse that failed on its first token and a skip that stopped there
+            // would try the same token forever.
+            if (this.i === start && this.peek().kind !== "eof" && !this.at("}")) this.i++
+            return null
+        }
+    }
+
+    /**
+     * Past the end of the broken statement: through its `;`, or through the
+     * block it opened, or up to the `}` of the body it is in. A declaration
+     * ends at a `;` or at the `}` of its own body.
+     */
+    private skip(level: "statement" | "declaration"): void {
+        let depth = 0
+        for (;;) {
+            const t = this.peek()
+            if (t.kind === "eof") return
+            if (t.text === "}" && depth === 0 && level === "statement") return
+            this.i++
+            if (t.text === "{") depth++
+            else if (t.text === "}") { depth--; if (depth <= 0) return }
+            else if (t.text === ";" && depth === 0) return
+        }
     }
 
     private expect(text: string, what: string): Token {
@@ -127,34 +181,11 @@ class Parser {
         }
 
         while (this.peek().kind !== "eof") {
-            const t = this.peek()
-
-            if (t.text === "uniform") { unit.uniforms.push(this.parseUniform()); continue }
-            if (t.text === "texture2D") { unit.textures.push(this.parseTexture()); continue }
-            if (t.text === "const") {
-                const c = this.parseConst()
-                unit.consts.push(c)
-                continue
-            }
-            if (t.kind === "ident") {
-                const fn = this.parseFunction()
-                if (fn.name === "main") {
-                    if (unit.main !== null) {
-                        this.fail("this file already declares main; a .sl file is exactly one fragment function", t)
-                    }
-                    unit.main = fn
-                } else {
-                    unit.funcs.push(fn)
-                }
-                continue
-            }
-            this.fail(
-                `expected a declaration (uniform, texture2D, const, or a function), got ${describe(t)}`, t,
-            )
+            this.recover(() => this.parseDeclaration(unit), "declaration")
         }
 
         if (unit.main === null && this.requireMain) {
-            this.fail(
+            this.report(
                 "this file declares no main. A .sl file is one fragment function: add " +
                 "`float4 main() { ... }`",
                 this.peek(),
@@ -163,6 +194,24 @@ class Parser {
         return unit
     }
 
+    private parseDeclaration(unit: Unit): void {
+        const t = this.peek()
+
+        if (t.text === "uniform") { unit.uniforms.push(this.parseUniform()); return }
+        if (t.text === "texture2D") { unit.textures.push(this.parseTexture()); return }
+        if (t.text === "const") { unit.consts.push(this.parseConst()); return }
+        if (t.kind === "ident") {
+            const fn = this.parseFunction()
+            if (fn.name !== "main") unit.funcs.push(fn)
+            else if (unit.main === null) unit.main = fn
+            else this.report("this file already declares main; a .sl file is exactly one fragment function", t)
+            return
+        }
+        this.fail(
+            `expected a declaration (uniform, texture2D, const, or a function), got ${describe(t)}`, t,
+        )
+    }
+
     private parseUniform(): UniformDecl {
         const kw = this.next()
         const type = this.expectType("a type after uniform")
@@ -230,7 +279,8 @@ class Parser {
         const out: Stmt[] = []
         while (!this.at("}")) {
             if (this.peek().kind === "eof") this.fail("this body is never closed", this.peek())
-            out.push(this.parseStmt())
+            const s = this.recover(() => this.parseStmt(), "statement")
+            if (s !== null) out.push(s)
         }
         this.next()
         return out
@@ -476,6 +526,11 @@ function describe(t: Token): string {
 
 export interface ParseOptions {
     file?: string
+    /**
+     * Where to collect errors instead of throwing the first: the parse carries
+     * on past each one and returns what it could read. What `diagnose` uses.
+     */
+    errors?: SLParseError[]
     /**
      * Off for the prelude, which is a library of functions and has no main.
      * Nothing else should turn it off: a `.sl` file without a main renders
@@ -486,5 +541,5 @@ export interface ParseOptions {
 
 export function parseUnit(source: string, options: ParseOptions = {}): Unit {
     const file = options.file ?? "program.sl"
-    return new Parser(tokenize(source, file), file, options.requireMain ?? true).parseUnit()
+    return new Parser(tokenize(source, file), file, options.requireMain ?? true, options.errors).parseUnit()
 }