onejs-sl 0.3.0 → 0.5.0

package/src/lang/check.ts

@@ -33,7 +33,7 @@ import { TEXTURE_SLOTS, UNIFORM_SLOTS } from "../ops"
 import { SL_GLSL_HINT } from "../ops"
 import { BUILTINS, NOT_YET } from "./builtins"
 import { SL_SDF_SHAPES } from "../shapes"
-import type { Expr, FuncDecl, Stmt, Unit } from "./ast"
+import { TYPE_WIDTH, type Expr, type FuncDecl, type Stmt, type Unit } from "./ast"
 import { readAttributes } from "./attributes"
 import { SLParseError, type Pos, type SLFix } from "./lexer"
 
@@ -49,11 +49,15 @@ const DERIVED_NAMES = new Set(Object.keys(DERIVED_INPUTS))
  * The GLSL spellings whose HLSL name means the same wherever it is written, so
  * the hint can be a one click fix (`Specs/SL_NEXT.md` 5, Decision 1 A). The
  * rest of `SL_GLSL_HINT` gets the hint alone: `mod` floors where `%` truncates,
- * `ivec2` truncates where `float2` does not, `atan` is `atan2` only with two
- * arguments (handled at the call), and `textureLod` names a builtin that is not
- * implemented yet.
+ * `ivec2` truncates where `float2` does not, and `atan` is `atan2` only with two
+ * arguments (handled at the call).
  */
-const GLSL_RENAMES = new Set(["mix", "fract", "texture", "vec2", "vec3", "vec4", "gl_FragCoord", "iTime", "iResolution"])
+const GLSL_RENAMES = new Set([
+    "mix", "fract", "texture", "textureLod", "vec2", "vec3", "vec4", "gl_FragCoord", "iTime", "iResolution",
+])
+
+/** The builtins whose first argument is a texture, which is not a value anywhere else. */
+const SAMPLES = new Set(["tex2D", "tex2Dlod"])
 
 const rename = (from: string, to: string): SLFix => ({ title: `Replace ${from} with ${to}`, replacement: to })
 
@@ -292,8 +296,16 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                 case "const": expr(s.init); return
                 case "assign": expr(s.value); return
                 case "if": expr(s.cond); s.then.forEach(stmt); s.else.forEach(stmt); return
-                case "for": expr(s.from); expr(s.to); expr(s.step); s.body.forEach(stmt); return
+                case "for": expr(s.from); expr(s.cond); stmt(s.update); s.body.forEach(stmt); return
+                case "while": expr(s.cond); s.body.forEach(stmt); return
+                case "switch":
+                    expr(s.value)
+                    for (const c of s.cases) { c.labels.forEach((l) => { if (l !== null) expr(l) }); c.body.forEach(stmt) }
+                    return
                 case "return": expr(s.value); return
+                case "block": s.body.forEach(stmt); return
+                case "break":
+                case "continue": return
             }
         }
         body.forEach(stmt)
@@ -310,31 +322,33 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
             })
             params.add(p.name)
         }
-        checkBody(fn, fn.body, new Set(params), true)
+        checkBody(fn, fn.body, new Set(params), { loop: false, switchCase: false })
+        if (!terminates(fn.body)) {
+            attempt(() => fail(
+                returnsSomewhere(fn.body)
+                    ? `not every way through ${fn.name} returns a ${fn.ret}; add a return at the end`
+                    : `${fn.name} never returns a ${fn.ret}`,
+                fn.pos, fn.name.length,
+            ))
+        }
     }
 
     /**
-     * `outermost` is the only place a `return` may stand.
-     *
-     * `Specs/SL_TEXT.md` 9.2: an `if` lowers to a `select`, which evaluates both
-     * sides, so there is nothing for an early return to skip. Refusing it is
-     * what keeps that cost honest rather than pretending a branch happened.
+     * `where` says what a break or a continue would leave. A break inside a
+     * case, other than the one that ends it, is refused: it would leave the
+     * switch early, which an if says more plainly.
      */
-    function checkBody(fn: FuncDecl, body: Stmt[], scope: Set<string>, outermost: boolean): void {
-        let returned: Stmt | null = null
+    function checkBody(fn: FuncDecl, body: Stmt[], scope: Set<string>, where: { loop: boolean; switchCase: boolean }): void {
+        let ended: Stmt | null = null
         for (const s of body) {
-            if (returned !== null) {
+            if (ended !== null) {
                 // Once: everything after it is the same mistake.
-                attempt(() => fail("this is after the return, so it can never run", s.pos))
+                attempt(() => fail(unreachable(ended!), 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))
+            if (terminates([s])) ended = s
         }
 
         function checkStmt(s: Stmt): void {
@@ -347,72 +361,120 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                     checkExpr(fn, s.init, scope)
                     break
                 }
-                case "assign": {
-                    // `p.x = 1` and `c.rgb *= 0.5` write the components they name
-                    // and keep the rest; lowering rebuilds the local from both.
-                    let target = s.target
-                    if (target.k === "member") {
-                        const sw = target.name
-                        if (!/^([xyzw]{1,4}|[rgba]{1,4})$/.test(sw)) {
-                            fail(`${sw} is not a swizzle that can be assigned to; name components with xyzw or rgba`, target.pos, sw.length)
-                        }
-                        if (new Set(sw).size !== sw.length) {
-                            fail(`${sw} names a component twice, so assigning to it would write one component two ways`, target.pos, sw.length)
-                        }
-                        target = target.obj
-                    }
-                    if (target.k !== "ident") fail("only a local can be assigned to", target.pos)
-                    const n = target.name
-                    // A local shadows what it is named after, a builtin or a
-                    // derived input, so it is assignable like any other local.
-                    const why = scope.has(n) ? null : taken(n)
-                    if (why !== null) fail(`"${n}" is ${why} and cannot be assigned to`, target.pos, n.length)
-                    if (counters.has(n)) {
-                        fail(
-                            `"${n}" is a loop counter. The loop unrolls and substitutes it as a ` +
-                            `number, so assigning to it would change nothing. Use another local`,
-                            target.pos, n.length,
-                        )
-                    }
-                    if (!scope.has(n)) unknown(n, scope, target.pos)
-                    checkExpr(fn, s.value, scope)
+                case "assign":
+                    checkAssign(s, scope)
                     break
-                }
                 case "if":
                     checkExpr(fn, s.cond, scope)
-                    checkBody(fn, s.then, new Set(scope), false)
-                    checkBody(fn, s.else, new Set(scope), false)
+                    checkBody(fn, s.then, new Set(scope), where)
+                    checkBody(fn, s.else, new Set(scope), where)
                     break
                 case "for": {
                     const clash = valueClash(s.counter)
                     if (clash !== null) fail(`"${s.counter}" already names ${clash}`, s.pos, s.counter.length)
                     if (scope.has(s.counter)) fail(`"${s.counter}" is already declared in this body`, s.pos)
                     checkExpr(fn, s.from, scope)
-                    checkExpr(fn, s.to, scope)
-                    checkExpr(fn, s.step, scope)
                     const inner = new Set(scope)
                     inner.add(s.counter)
+                    checkExpr(fn, s.cond, inner)
+                    checkExpr(fn, s.update.value, inner)
                     counters.add(s.counter)
                     try {
-                        checkBody(fn, s.body, inner, false)
+                        checkBody(fn, s.body, new Set(inner), { loop: true, switchCase: false })
                     } finally {
                         counters.delete(s.counter)
                     }
                     break
                 }
-                case "return":
-                    if (!outermost) {
+                case "while":
+                    checkExpr(fn, s.cond, scope)
+                    checkBody(fn, s.body, new Set(scope), { loop: true, switchCase: false })
+                    break
+                case "break":
+                    if (where.switchCase) {
                         fail(
-                            "a return inside an if or a for has nothing to skip: an if evaluates " +
-                            "both sides and a for unrolls, so there is no branch to leave early. " +
-                            "Assign to a local and return it once at the end, or use ?:",
-                            s.pos,
+                            "this break would leave the switch before the end of its case. Put the rest " +
+                            "of the case under an if instead",
+                            s.pos, 5,
                         )
                     }
+                    if (!where.loop) fail("break leaves a loop, or ends a switch's case, and this is in neither", s.pos, 5)
+                    break
+                case "continue":
+                    if (!where.loop) fail("continue starts a loop's next turn, and this is not in a loop", s.pos, 8)
+                    break
+                case "switch": {
+                    checkExpr(fn, s.value, scope)
+                    let defaults = 0
+                    for (const c of s.cases) {
+                        for (const l of c.labels) {
+                            if (l === null) {
+                                defaults++
+                                if (defaults > 1) fail("this switch already has a default", c.pos, 7)
+                            } else {
+                                checkExpr(fn, l, scope)
+                            }
+                        }
+                        if (c.body.length === 0 && !c.closed) {
+                            fail("this case has no body; a case that shares the next one's body stacks its label on it", c.pos, 4)
+                        }
+                        checkBody(fn, c.body, new Set(scope), { loop: where.loop, switchCase: true })
+                        if (!c.closed && !terminates(c.body)) {
+                            fail(
+                                "this case does not end in break or return. Cases never fall through into the " +
+                                "next one here, so end it with `break;`",
+                                c.pos, 4,
+                            )
+                        }
+                    }
+                    break
+                }
+                case "return":
                     checkExpr(fn, s.value, scope)
                     break
+                case "block":
+                    checkBody(fn, s.body, new Set(scope), where)
+                    break
             }
         }
+
+        function checkAssign(s: Extract<Stmt, { k: "assign" }>, scope: Set<string>): void {
+            // `p.x = 1` and `c.rgb *= 0.5` write the components they name
+            // and keep the rest; lowering rebuilds the local from both.
+            let target = s.target
+            if (target.k === "member") {
+                const sw = target.name
+                if (!/^([xyzw]{1,4}|[rgba]{1,4})$/.test(sw)) {
+                    fail(`${sw} is not a swizzle that can be assigned to; name components with xyzw or rgba`, target.pos, sw.length)
+                }
+                if (new Set(sw).size !== sw.length) {
+                    fail(`${sw} names a component twice, so assigning to it would write one component two ways`, target.pos, sw.length)
+                }
+                target = target.obj
+            }
+            if (target.k !== "ident") fail("only a local can be assigned to", target.pos)
+            const n = target.name
+            // A local shadows what it is named after, a builtin or a
+            // derived input, so it is assignable like any other local.
+            const why = scope.has(n) ? null : taken(n)
+            if (why !== null) fail(`"${n}" is ${why} and cannot be assigned to`, target.pos, n.length)
+            if (counters.has(n)) {
+                fail(
+                    `"${n}" is a loop counter, which only the loop's update changes, so the loop's ` +
+                    `turns can be counted. Use another local`,
+                    target.pos, n.length,
+                )
+            }
+            if (!scope.has(n)) unknown(n, scope, target.pos)
+            checkExpr(fn, s.value, scope)
+        }
+    }
+
+    /** Why the statement after `s` never runs. */
+    function unreachable(s: Stmt): string {
+        if (s.k === "return" || s.k === "break" || s.k === "continue") return `this is after the ${s.k}, so it can never run`
+        const above = s.k === "block" ? "braces" : s.k
+        return `this can never run: every way through the ${above} above ends in a return, break or continue`
     }
 
     // MARK: expressions
@@ -421,13 +483,14 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
         switch (e.k) {
             case "num":
             case "hex":
+            case "bool":
                 return
             case "ident": {
                 if (scope.has(e.name) || INPUT_NAMES.has(e.name) || DERIVED_NAMES.has(e.name) || uniforms.has(e.name) || consts.has(e.name)) return
                 if (textures.has(e.name)) {
                     fail(
                         `"${e.name}" is a texture, and a texture is only ever the first argument of ` +
-                        `tex2D. Write \`tex2D(${e.name}, uv)\``,
+                        `tex2D or tex2Dlod. Write \`tex2D(${e.name}, uv)\``,
                         e.pos, e.name.length,
                     )
                 }
@@ -458,9 +521,9 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                 // 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"
+                // mistakes. A sample's first argument is the texture, which is
+                // not a value.
+                const tex = e.callee.k === "ident" && SAMPLES.has(e.callee.name)
                 for (const a of tex ? e.args.slice(1) : e.args) attempt(() => checkExpr(fn, a, scope))
                 return
             }
@@ -503,7 +566,8 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
         }
         const n = callee.name
 
-        if (n === "float2" || n === "float3" || n === "float4" || n === "float") {
+        // A constructor, or a conversion: `float3(...)`, `int(x)`, `bool(x)`.
+        if (n in TYPE_WIDTH) {
             for (const a of e.args) checkExpr(fn, a, scope)
             if (e.args.length === 0) fail(`${n}() needs at least one component`, e.pos)
             return
@@ -529,13 +593,22 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
 
         const builtin = BUILTINS[n]
         if (builtin !== undefined) {
-            if (n === "tex2D") {
+            if (SAMPLES.has(n)) {
                 const [tex, ...rest] = e.args
+                // HLSL's own tex2Dlod packs the level into a float4 with the uv.
+                if (n === "tex2Dlod" && e.args.length === 2) {
+                    fail(
+                        "tex2Dlod takes the uv and the mip level separately, `tex2Dlod(t, uv, lod)`, " +
+                        "rather than HLSL's float4(uv, 0, lod)",
+                        e.pos,
+                    )
+                }
                 arity(e, n, builtin.min, builtin.max)
                 if (tex === undefined || tex.k !== "ident" || !textures.has(tex.name)) {
+                    const lod = n === "tex2Dlod" ? ", 0" : ""
                     fail(
-                        `tex2D samples a texture declared in this file, as in \`texture2D grain;\` ` +
-                        `then \`tex2D(grain, uv)\``,
+                        `${n} samples a texture declared in this file, as in \`texture2D grain;\` ` +
+                        `then \`${n}(grain, uv${lod})\``,
                         (tex ?? e).pos,
                     )
                 }
@@ -635,3 +708,39 @@ function distance(a: string, b: string): number {
     }
     return rows[a.length]![b.length]!
 }
+
+/**
+ * Whether a body ends on every way through it in a return, a break or a
+ * continue, so nothing after it runs. A loop never counts: its condition, or
+ * its turn limit, can always end it. The lowering reads this too, to put what
+ * follows an if into the side that does not end.
+ */
+export function terminates(body: Stmt[]): boolean {
+    return body.some((s) => {
+        switch (s.k) {
+            case "return":
+            case "break":
+            case "continue": return true
+            case "if": return terminates(s.then) && terminates(s.else)
+            case "block": return terminates(s.body)
+            // A case's break only ends the switch, so it counts only when every
+            // case leaves by some other way and a default leaves nothing out.
+            case "switch": return s.cases.some((c) => c.labels.includes(null)) && s.cases.every((c) => !c.closed && terminates(c.body))
+            default: return false
+        }
+    })
+}
+
+function returnsSomewhere(body: Stmt[]): boolean {
+    return body.some((s) => {
+        switch (s.k) {
+            case "return": return true
+            case "if": return returnsSomewhere(s.then) || returnsSomewhere(s.else)
+            case "block": return returnsSomewhere(s.body)
+            case "for":
+            case "while": return returnsSomewhere(s.body)
+            case "switch": return s.cases.some((c) => returnsSomewhere(c.body))
+            default: return false
+        }
+    })
+}

package/src/lang/glsl.ts

@@ -75,10 +75,13 @@ const GLSL_TYPES = new Set(["float", "int", "uint", "bool", "vec2", "vec3", "vec
 /** A straight rename, the meaning unchanged. */
 const RENAME: Record<string, string> = {
     vec2: "float2", vec3: "float3", vec4: "float4", mix: "lerp", fract: "frac",
-    texture: "tex2D", texture2D: "tex2D", iTime: "time", iGlobalTime: "time", gl_FragCoord: "fragCoord",
+    texture: "tex2D", texture2D: "tex2D", textureLod: "tex2Dlod", iTime: "time", iGlobalTime: "time", gl_FragCoord: "fragCoord",
 }
 
-/** A rename that changes what the value can hold, so it is said. */
+/**
+ * A rename that changes what the value can hold, so it is said. `int`, `uint`
+ * and `bool` are types here too and are kept; their vectors are not yet.
+ */
 const NARROW: Record<string, [string, string]> = {
     ivec2: ["float2", "an ivec2 is a float2 here, so dividing one no longer truncates"],
     ivec3: ["float3", "an ivec3 is a float3 here, so dividing one no longer truncates"],
@@ -87,9 +90,6 @@ const NARROW: Record<string, [string, string]> = {
     uvec4: ["float4", "a uvec4 is a float4 here"],
     bvec2: ["float2", "a bvec2 is a float2 of 0s and 1s here"], bvec3: ["float3", "a bvec3 is a float3 of 0s and 1s here"],
     bvec4: ["float4", "a bvec4 is a float4 of 0s and 1s here"],
-    bool: ["float", "a bool is a float that is 0 or 1 here; a comparison already is one"],
-    int: ["float", "an int is a float here, so dividing one no longer truncates; wrap it in floor() where that mattered"],
-    uint: ["float", "a uint is a float here"],
 }
 
 /** Shadertoy's inputs with no counterpart yet, and why. */
@@ -101,7 +101,6 @@ const MISSING: Record<string, string> = {
     iChannelTime: "a texture has no time of its own",
     iChannelResolution: "a texture's size cannot be read yet",
     iSampleRate: "there is no audio",
-    textureLod: "tex2Dlod is not implemented yet; tex2D samples with the texture's own filtering",
     texelFetch: "a texture cannot be read without filtering yet",
     textureSize: "a texture's size cannot be read yet",
     dFdx: "there are no derivatives", dFdy: "there are no derivatives", fwidth: "there are no derivatives",
@@ -502,7 +501,7 @@ export function fromGLSL(glsl: string, options: { file?: string } = {}): FromGLS
             const span = spans.get(i)
             if (span !== undefined && span.end < to) { out += span.render(inEntry); i = span.end; continue }
             if (t.kind === "directive") { out += directive(t); continue }
-            if (t.kind === "number") { out += t.text.replace(/[uU]$/, ""); continue }
+            if (t.kind === "number") { out += t.text.replace(/U$/, "u"); continue }
             if (t.kind !== "ident") { out += t.text; continue }
 
             const name = t.text
@@ -548,9 +547,6 @@ export function fromGLSL(glsl: string, options: { file?: string } = {}): FromGLS
                 continue
             }
             if (NARROW[name] !== undefined) {
-                // A for loop's counter is the one int the language has.
-                const forCounter = name === "int" && is(back(i - 1), "(") && is(back(back(i - 1) - 1), "for")
-                if (forCounter) { out += name; continue }
                 const [to2, why] = NARROW[name]!
                 noteOnce("narrow:" + name, t.line, why)
                 out += to2

package/src/lang/lexer.ts

@@ -31,6 +31,10 @@ export interface Token extends Pos {
     text: string
     /** Numbers only: the parsed value. */
     value?: number
+    /** Numbers only: written with no point, no exponent and no `f`, as `3` or `0xff`. */
+    whole?: boolean
+    /** Numbers only: written with a `u`, as `3u`. */
+    unsigned?: boolean
     /** Strings only: the text between the quotes, with `\"` and `\\` read. */
     str?: string
 }
@@ -87,9 +91,10 @@ export class SLParseError extends SLError {
  * baffling about the second half.
  */
 const PUNCT = [
-    "<=", ">=", "==", "!=", "&&", "||", "++", "--", "+=", "-=", "*=", "/=", "%=",
+    "<<=", ">>=",
+    "<=", ">=", "==", "!=", "&&", "||", "++", "--", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<", ">>",
     "(", ")", "{", "}", "[", "]", ",", ";", ".", "+", "-", "*", "/", "%",
-    "<", ">", "!", "?", ":", "=",
+    "<", ">", "!", "?", ":", "=", "&", "|", "^", "~",
 ]
 
 /** Directives that exist in HLSL and deliberately do not exist here. */
@@ -185,6 +190,19 @@ export function lex(source: string, file: string, keep: boolean): Token[] | Lexe
             continue
         }
 
+        // A whole number in hex, as an integer hash writes its constants: `0x9E3779B9u`.
+        if (c === "0" && (source[i + 1] === "x" || source[i + 1] === "X") && isHex(source[i + 2] ?? "")) {
+            const start = here()
+            let j = i + 2
+            while (j < source.length && isHex(source[j]!)) j++
+            const text = source.slice(i, j)
+            const unsigned = source[j] === "u" || source[j] === "U"
+            if (unsigned) j++
+            push({ kind: "number", text, value: Number(text), whole: true, unsigned, ...start }, j)
+            i = j
+            continue
+        }
+
         if (isDigit(c) || (c === "." && isDigit(source[i + 1] ?? ""))) {
             const start = here()
             let j = i
@@ -196,15 +214,21 @@ export function lex(source: string, file: string, keep: boolean): Token[] | Lexe
                 if (isDigit(source[k] ?? "")) { k++; while (k < source.length && isDigit(source[k]!)) k++; j = k }
             }
             const text = source.slice(i, j)
+            let whole = /^[0-9]+$/.test(text)
+            let unsigned = false
             // HLSL's float suffix. Accepted and dropped: `1.0f` is the same
             // number, and refusing it would only teach the author that this is
-            // not quite the language they think it is.
-            if (source[j] === "f" || source[j] === "F") {
-                if (!isIdentPart(source[j + 1] ?? "")) j++
+            // not quite the language they think it is. It does make a float.
+            if ((source[j] === "f" || source[j] === "F") && !isIdentPart(source[j + 1] ?? "")) {
+                j++
+                whole = false
+            } else if ((source[j] === "u" || source[j] === "U") && whole && !isIdentPart(source[j + 1] ?? "")) {
+                j++
+                unsigned = true
             }
             const value = Number(text)
             if (!Number.isFinite(value)) fail(`"${text}" is not a number`, start, text.length)
-            else push({ kind: "number", text, value, ...start }, j)
+            else push({ kind: "number", text, value, whole, unsigned, ...start }, j)
             i = j
             continue
         }