onejs-sl 0.1.4 → 0.1.6

package/src/lang/lexer.ts

@@ -32,6 +32,19 @@ export interface Token extends Pos {
     value?: number
 }
 
+/**
+ * A replacement for the characters an error marks, offered as one click.
+ *
+ * Only where the fix is certain: `mix` to `lerp` is, but `mod` to `%` is not
+ * (GLSL's `mod` floors and `%` truncates), so `mod` gets the hint and no fix.
+ */
+export interface SLFix {
+    /** What the editor's action says, as in "Replace mix with lerp". */
+    title: string
+    /** Text for the marked range, `offset` to `offset + length`. */
+    replacement: string
+}
+
 /**
  * An error with a place in a file.
  *
@@ -43,15 +56,23 @@ export class SLParseError extends SLError {
     readonly file: string
     readonly line: number
     readonly column: number
+    /** Into the source, where the marked range starts. */
+    readonly offset: number
     readonly length: number
+    /** The message alone, without `message`'s tag and its `file:line:col: `. */
+    readonly text: string
+    readonly fix?: SLFix
 
-    constructor(message: string, file: string, pos: Pos, length = 1) {
+    constructor(message: string, file: string, pos: Pos, length = 1, fix?: SLFix) {
         super(`${file}:${pos.line}:${pos.col}: ${message}`)
         this.name = "SLParseError"
         this.file = file
         this.line = pos.line
         this.column = pos.col
+        this.offset = pos.offset
         this.length = length
+        this.text = message
+        if (fix !== undefined) this.fix = fix
     }
 }
 
@@ -79,14 +100,37 @@ const isIdentStart = (c: string) => c === "_" || (c >= "a" && c <= "z") || (c >=
 const isIdentPart = (c: string) => isIdentStart(c) || isDigit(c)
 
 export function tokenize(source: string, file: string): Token[] {
-    const out: Token[] = []
+    return lex(source, file, false)
+}
+
+/** A token as `classify` sees it: comments kept, and whatever cannot be read marked rather than thrown. */
+export interface LexedToken extends Omit<Token, "kind"> {
+    kind: TokenKind | "comment" | "invalid"
+    /** Characters it covers, which for `1.0f` is one more than its text. */
+    length: number
+}
+
+/**
+ * The scanner behind `tokenize` and `classify`.
+ *
+ * With `keep` off it is `tokenize`: comments dropped, the first unreadable
+ * character thrown. With it on, nothing throws and nothing is dropped, because
+ * a highlighter runs on every keystroke over text that is half typed.
+ */
+export function lex(source: string, file: string, keep: true): LexedToken[]
+export function lex(source: string, file: string, keep: false): Token[]
+export function lex(source: string, file: string, keep: boolean): Token[] | LexedToken[] {
+    const out: LexedToken[] = []
     let i = 0
     let line = 1
     let lineStart = 0
     const here = (): Pos => ({ line, col: i - lineStart + 1, offset: i })
-    const fail = (message: string, at: Pos = here(), length = 1): never => {
-        throw new SLParseError(message, file, at, length)
+    /** Throws, or with `keep` records the span as invalid and lets the caller skip it. */
+    const fail = (message: string, at: Pos = here(), length = 1): void => {
+        if (!keep) throw new SLParseError(message, file, at, length)
+        out.push({ kind: "invalid", text: source.slice(at.offset, at.offset + length), length, ...at })
     }
+    const push = (t: Omit<LexedToken, "length">, end: number) => { out.push({ ...t, length: end - t.offset }) }
 
     while (i < source.length) {
         const c = source[i]!
@@ -95,18 +139,25 @@ export function tokenize(source: string, file: string): Token[] {
         if (c === " " || c === "\t" || c === "\r") { i++; continue }
 
         if (c === "/" && source[i + 1] === "/") {
+            const start = here()
             while (i < source.length && source[i] !== "\n") i++
+            if (keep) push({ kind: "comment", text: source.slice(start.offset, i), ...start }, i)
             continue
         }
         if (c === "/" && source[i + 1] === "*") {
             const open = here()
             i += 2
             for (;;) {
-                if (i >= source.length) fail("this block comment is never closed", open, 2)
+                if (i >= source.length) {
+                    // Highlighted to the end as the comment it will become once closed.
+                    if (!keep) fail("this block comment is never closed", open, 2)
+                    break
+                }
                 if (source[i] === "*" && source[i + 1] === "/") { i += 2; break }
                 if (source[i] === "\n") { line++; lineStart = i + 1 }
                 i++
             }
+            if (keep) push({ kind: "comment", text: source.slice(open.offset, i), ...open }, i)
             continue
         }
 
@@ -122,11 +173,11 @@ export function tokenize(source: string, file: string): Token[] {
                     `function, which inlines.`,
                     start, body.length + 1,
                 )
-            }
-            if (body.length === 0 || ![...body].every(isHex)) {
+            } else if (body.length === 0 || ![...body].every(isHex)) {
                 fail(`"#${body}" is not a colour; use #rgb, #rrggbb or #rrggbbaa`, start, body.length + 1)
+            } else {
+                push({ kind: "hex", text: "#" + body, ...start }, j)
             }
-            out.push({ kind: "hex", text: "#" + body, ...start })
             i = j
             continue
         }
@@ -150,7 +201,7 @@ export function tokenize(source: string, file: string): Token[] {
             }
             const value = Number(text)
             if (!Number.isFinite(value)) fail(`"${text}" is not a number`, start, text.length)
-            out.push({ kind: "number", text, value, ...start })
+            else push({ kind: "number", text, value, ...start }, j)
             i = j
             continue
         }
@@ -159,18 +210,24 @@ export function tokenize(source: string, file: string): Token[] {
             const start = here()
             let j = i
             while (j < source.length && isIdentPart(source[j]!)) j++
-            out.push({ kind: "ident", text: source.slice(i, j), ...start })
+            push({ kind: "ident", text: source.slice(i, j), ...start }, j)
             i = j
             continue
         }
 
         const start = here()
         const p = PUNCT.find((op) => source.startsWith(op, i))
-        if (p === undefined) fail(`"${c}" means nothing here`, start)
-        out.push({ kind: "punct", text: p!, ...start })
-        i += p!.length
+        if (p === undefined) {
+            fail(`"${c}" means nothing here`, start)
+            i++
+            continue
+        }
+        push({ kind: "punct", text: p, ...start }, i + p.length)
+        i += p.length
     }
 
-    out.push({ kind: "eof", text: "", line, col: i - lineStart + 1, offset: i })
-    return out
+    out.push({ kind: "eof", text: "", line, col: i - lineStart + 1, offset: i, length: 0 })
+    if (keep) return out
+    // `tokenize`'s tokens are the ones it always returned, with no length.
+    return out.map(({ length: _, ...t }) => t as Token)
 }

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!
@@ -106,7 +111,7 @@ export function lower(checked: Checked): Program {
     const located = (e: unknown, pos: Pos): unknown => {
         if (e instanceof SLParseError) return e
         const raw = e instanceof Error ? e.message : String(e)
-        return new SLParseError(raw.replace(/^\[onejs sl] /, ""), file, pos)
+        return new SLParseError(inFileWords(raw.replace(/^\[onejs sl] /, "")), file, pos)
     }
 
     const fail: (message: string, pos: Pos, length?: number) => never =
@@ -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]) {
@@ -676,3 +724,17 @@ function widthType(w: SLType): TypeName {
     return (["float", "float2", "float3", "float4"] as const)[w - 1]!
 }
 
+/**
+ * An EDSL message in the words of a `.sl` file.
+ *
+ * The EDSL names its types after its constructors, `sl.vec3`, so "cannot
+ * combine a vec3 with a vec2" is right for a TypeScript author and wrong for
+ * one who wrote float3 (`Specs/SL_NEXT.md` 5). One rewrite here, rather than a
+ * second set of messages, keeps both surfaces saying the same thing. A quoted
+ * name is the author's own and left as written.
+ */
+function inFileWords(message: string): string {
+    return message.split(/("[^"]*")/).map((part, i) =>
+        i % 2 === 1 ? part : part.replace(/\bsl\.vec([234])\(/g, "float$1(").replace(/\bvec([234])\b/g, "float$1"),
+    ).join("")
+}

package/src/lang/parser.ts

@@ -12,13 +12,11 @@
  */
 
 import {
-    TYPE_WIDTH,
     type AssignOp, type BinaryOp, type Expr, type FuncDecl, type Param, type Stmt,
     type TextureDecl, type TypeName, type UniformDecl, type Unit,
 } from "./ast"
-import { SLParseError, tokenize, type Pos, type Token } from "./lexer"
-
-const TYPE_NAMES = new Set(Object.keys(TYPE_WIDTH))
+import { SLParseError, tokenize, type Pos, type SLFix, type Token } from "./lexer"
+import { KEYWORD_SET, TYPE_SET } from "./words"
 
 /**
  * Type spellings that exist in HLSL or GLSL and not here, each with the reason.
@@ -45,6 +43,11 @@ const NOT_A_TYPE: Record<string, string> = {
     struct: "there are no structs",
 }
 
+/** The spellings above whose replacement is certain, so the error can offer it as a fix. */
+const TYPE_FIX: Record<string, TypeName> = {
+    vec2: "float2", vec3: "float3", vec4: "float4", half: "float", double: "float", fixed: "float",
+}
+
 /** Binding power per binary operator, HLSL's. Higher binds tighter. */
 const BINDING: Record<string, number> = {
     "||": 1,
@@ -64,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
@@ -73,14 +78,73 @@ class Parser {
     private at(text: string): boolean { const t = this.peek(); return t.kind !== "eof" && t.text === text }
     private eat(text: string): boolean { if (this.at(text)) { this.i++; return true } return false }
 
-    private fail(message: string, at: Token = this.peek()): never {
-        throw new SLParseError(message, this.file, at as Pos, Math.max(1, at.text.length))
+    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]!
+        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 {
         if (!this.at(text)) {
             const got = this.peek()
-            this.fail(`expected "${text}" ${what}, got ${describe(got)}`, got)
+            // Something missing at the end of a line is missing after the last
+            // token on it, which is where the author will look, not at the next line.
+            const prev = this.tokens[this.i - 1]
+            const at = prev !== undefined && got.line > prev.line ? prev : got
+            this.fail(`expected "${text}" ${what}, got ${describe(got)}`, at)
         }
         return this.next()
     }
@@ -91,11 +155,21 @@ class Parser {
         return this.next()
     }
 
+    /** A name being declared, which may not be a word the parser reads as syntax. */
+    private expectName(what: string): Token {
+        const t = this.expectIdent(what)
+        if (KEYWORD_SET.has(t.text)) this.fail(`"${t.text}" is a keyword, so it cannot be ${what}`, t)
+        if (TYPE_SET.has(t.text)) this.fail(`"${t.text}" is a type, so it cannot be ${what}`, t)
+        return t
+    }
+
     private expectType(what: string): TypeName {
         const t = this.expectIdent(what)
-        if (TYPE_NAMES.has(t.text)) return t.text as TypeName
+        if (TYPE_SET.has(t.text)) return t.text as TypeName
         const why = NOT_A_TYPE[t.text]
-        if (why !== undefined) this.fail(`"${t.text}" is not a type here: ${why}`, t)
+        const to = TYPE_FIX[t.text]
+        const fix = to === undefined ? undefined : { title: `Replace ${t.text} with ${to}`, replacement: to }
+        if (why !== undefined) this.fail(`"${t.text}" is not a type here: ${why}`, t, fix)
         this.fail(`"${t.text}" is not a type; the types are float, float2, float3 and float4`, t)
     }
 
@@ -107,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(),
@@ -143,10 +194,28 @@ 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")
-        const name = this.expectIdent("a uniform name")
+        const name = this.expectName("a uniform name")
         let init: Expr | null = null
         if (this.eat("=")) init = this.parseExpr()
         this.expect(";", "after a uniform declaration")
@@ -155,7 +224,7 @@ class Parser {
 
     private parseTexture(): TextureDecl {
         const kw = this.next()
-        const name = this.expectIdent("a texture name")
+        const name = this.expectName("a texture name")
         if (this.at("=")) {
             this.fail(
                 "a texture has no default; the host binds it by name through the textures prop",
@@ -169,7 +238,7 @@ class Parser {
     private parseConst(): Extract<Stmt, { k: "const" }> {
         const kw = this.next()
         const type = this.expectType("a type after const")
-        const name = this.expectIdent("a name")
+        const name = this.expectName("a const's name")
         this.expect("=", "after a const's name; a const has to have a value")
         const init = this.parseExpr()
         this.expect(";", "after a const")
@@ -179,7 +248,7 @@ class Parser {
     private parseFunction(): FuncDecl {
         const start = this.peek()
         const ret = this.expectType("a return type")
-        const name = this.expectIdent("a function name")
+        const name = this.expectName("a function name")
         if (!this.at("(")) {
             this.fail(
                 `expected "(" after ${name.text}. Only uniforms, textures, consts and functions live ` +
@@ -193,7 +262,7 @@ class Parser {
             for (;;) {
                 const p = this.peek()
                 const ptype = this.expectType("a parameter type")
-                const pname = this.expectIdent("a parameter name")
+                const pname = this.expectName("a parameter name")
                 params.push({ type: ptype, name: pname.text, pos: p })
                 if (!this.eat(",")) break
             }
@@ -210,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
@@ -238,6 +308,16 @@ class Parser {
         if (t.text === "discard") {
             this.fail("there is no discard; return a colour with alpha 0 instead", t)
         }
+        if (t.text === "break" || t.text === "continue") {
+            this.fail(
+                `there is no ${t.text}: a for loop unrolls, so every iteration runs. Put the rest of ` +
+                `the body under an if instead`,
+                t,
+            )
+        }
+        if (t.text === "switch") {
+            this.fail("there is no switch; write it as an if and else if", t)
+        }
         if (t.text === "return") {
             this.next()
             const value = this.parseExpr()
@@ -253,7 +333,7 @@ class Parser {
         // statement may be is the left of an assignment.
         if (t.kind === "ident" && this.peek(1).kind === "ident") {
             const type = this.expectType("a type")
-            const name = this.expectIdent("a name")
+            const name = this.expectName("a local's name")
             if (this.at("(")) {
                 this.fail(
                     "a function is declared at the top level of the file, not inside another function",
@@ -318,7 +398,7 @@ class Parser {
             )
         }
         this.next()
-        const counter = this.expectIdent("a counter name")
+        const counter = this.expectName("a counter name")
         this.expect("=", "after the counter")
         const from = this.parseExpr()
         this.expect(";", "after the counter's start")
@@ -446,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
@@ -456,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()
 }