onejs-sl 0.1.3 → 0.1.4

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.1.4
+
+Four things that were errors now compile, the most common mistakes in cold runs of authors writing from the docs alone (`Specs/SL_NEXT.md` 2). Every program that compiled before compiles to exactly what it did.
+
+- A swizzle can be assigned to: `p.x = 1;`, `c.rgb *= 0.5;`
+- A single number fills a vector in a declaration, an assignment or a uniform default: `float3 c = 0.5;`
+- A float4 goes into a float3 by dropping its fourth component: `float3 c = #ff8040;`
+- A local or a uniform may take a builtin's or a prelude function's name
+
 ## 0.1.3
 
 `onejs-sl/tables` names every parameter, so an editor can offer `lerp(x, y, s)` rather than an argument count. Nothing a program compiles to changes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onejs-sl",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "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/lang/README.md

@@ -127,11 +127,25 @@ is read unconverted.
 and colours, and nothing else. It is baked into the program before anything
 runs, so it cannot name a const, which could itself name a uniform.
 
-**Shadowing is refused.** A local may not take the name of an input, a uniform,
-a texture, a const or a builtin. Allowing it would make "is this a texture?"
-depend on where the question is asked, for no gain in a language whose
-functions are six lines long. A file function may shadow a *prelude* function,
-which is the sanctioned way to replace one.
+**Shadowing is refused between values.** A local may not take the name of an
+input, a uniform, a texture or a const. Allowing it would make "is this a
+texture?" depend on where the question is asked, for no gain in a language whose
+functions are six lines long. A value *may* take a builtin's or a prelude
+function's name (`float circle`, `uniform float turbulence`), which hides that
+function wherever the value is visible, and a call there says so. A file
+function may shadow a *prelude* function, which is the sanctioned way to replace
+one.
+
+**Declarations and assignments convert two ways, and only two.** A single
+number fills every component (`float3 c = 0.5;`, and a uniform default such as
+`uniform float2 offset = 0;`), and a float4 goes into a float3 by dropping its
+fourth component, which is how a colour becomes an rgb. Every other width change
+is refused with the swizzle that fixes it.
+
+**A swizzle can be assigned to.** `p.x *= aspect;` rebuilds `p` from the
+components it names and keeps the rest, so it is the same program as
+`p = float2(p.x * aspect, p.y);`. A swizzle that names a component twice, or
+one the local does not have, is refused.
 
 ## Not yet spellable
 

package/src/lang/check.ts

@@ -14,11 +14,18 @@
  * whether a name exists, whether a body is shaped like a body, and whether the
  * program fits the budgets before anything is built.
  *
- * SHADOWING IS REFUSED. HLSL would let a local called `time` hide the input, or
- * a parameter called `tint` hide a uniform. Allowing it would mean every later
- * question about a name ("is this a texture?") depends on where it is asked
- * from, for no expressive gain in a language whose functions are half a dozen
- * lines long.
+ * SHADOWING IS REFUSED, between values. HLSL would let a local called `time`
+ * hide the input, or a parameter called `tint` hide a uniform. Allowing it would
+ * mean every later question about a name ("is this a texture?") depends on where
+ * it is asked from, for no expressive gain in a language whose functions are
+ * half a dozen lines long.
+ *
+ * A value MAY take the name of a builtin or a prelude function: `float circle`,
+ * `uniform float turbulence`. Those are the names an author reaches for first,
+ * and refusing them was the most common error left once the others were fixed
+ * (`Specs/SL_NEXT.md` 2d). Calls and values never meet in one position, so the
+ * only question left is a call to the name where the value is visible, and that
+ * is refused with the reason.
  */
 
 import { INPUTS } from "../ir"
@@ -84,8 +91,8 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
      *
      * Functions are NOT in here, because a file function shadowing a prelude
      * function of the same name is the sanctioned way to replace one
-     * (`Specs/SL_TEXT.md` 3.8). Every other kind of declaration checks `asFunc`
-     * as well, so only a function may take a function's name.
+     * (`Specs/SL_TEXT.md` 3.8). Every other kind of declaration checks
+     * `valueClash`, which adds the file's own functions.
      */
     const taken = (n: string): string | null => {
         if (INPUT_NAMES.has(n)) return "an input"
@@ -98,14 +105,16 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
         return null
     }
 
-    const asFunc = (n: string): string | null => {
+    /** What a value may not be called: anything spoken for, except a builtin's or a prelude function's name. */
+    const valueClash = (n: string): string | null => {
+        const why = taken(n)
+        if (why !== null && why !== "a builtin") return why
         const fn = funcs.get(n)
-        if (fn === undefined) return null
-        return fn.prelude ? "a prelude function" : "a function"
+        return fn !== undefined && !fn.prelude ? "a function" : null
     }
 
     for (const u of unit.uniforms) {
-        const clash = taken(u.name) ?? asFunc(u.name)
+        const clash = valueClash(u.name)
         if (clash !== null) fail(`"${u.name}" already names ${clash}`, u.pos, u.name.length)
         uniforms.set(u.name, u)
     }
@@ -121,7 +130,7 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
     }
 
     for (const t of unit.textures) {
-        const clash = taken(t.name) ?? asFunc(t.name)
+        const clash = valueClash(t.name)
         if (clash !== null) fail(`"${t.name}" already names ${clash}`, t.pos, t.name.length)
         textures.set(t.name, t)
     }
@@ -136,7 +145,7 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
     }
 
     for (const c of unit.consts) {
-        const clash = taken(c.name) ?? asFunc(c.name)
+        const clash = valueClash(c.name)
         if (clash !== null) fail(`"${c.name}" already names ${clash}`, c.pos, c.name.length)
         consts.set(c.name, c)
     }
@@ -251,7 +260,7 @@ 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 = taken(p.name) ?? asFunc(p.name)
+            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)
@@ -275,7 +284,7 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
             switch (s.k) {
                 case "var":
                 case "const": {
-                    const clash = taken(s.name) ?? asFunc(s.name)
+                    const clash = valueClash(s.name)
                     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)
@@ -283,26 +292,32 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                     break
                 }
                 case "assign": {
-                    if (s.target.k === "member") {
-                        fail(
-                            "a swizzle is read only; build the value you want instead, as in " +
-                            "`p = float2(1, p.y);`",
-                            s.target.pos,
-                        )
+                    // `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 (s.target.k !== "ident") fail("only a local can be assigned to", s.target.pos)
-                    const n = s.target.name
+                    if (target.k !== "ident") fail("only a local can be assigned to", target.pos)
+                    const n = target.name
                     const why = taken(n)
-                    if (why !== null) fail(`"${n}" is ${why} and cannot be assigned to`, s.target.pos, n.length)
+                    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`,
-                            s.target.pos, n.length,
+                            target.pos, n.length,
                         )
                     }
                     if (!scope.has(n)) {
-                        fail(unknown(n, scope), s.target.pos, n.length)
+                        fail(unknown(n, scope), target.pos, n.length)
                     }
                     checkExpr(fn, s.value, scope)
                     break
@@ -313,7 +328,7 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                     checkBody(fn, s.else, new Set(scope), false)
                     break
                 case "for": {
-                    const clash = taken(s.counter) ?? asFunc(s.counter)
+                    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)
@@ -435,6 +450,16 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
             )
         }
 
+        // A value that took a builtin's or a prelude function's name hides it
+        // wherever the value is visible.
+        const value = scope.has(n) ? "a local" : uniforms.has(n) ? "a uniform" : consts.has(n) ? "a const" : null
+        if (value !== null) {
+            fail(`"${n}" is ${value} here, so it cannot be called. Rename it to call ${n}(...)`, callee.pos, n.length)
+        }
+        if (textures.has(n)) {
+            fail(`"${n}" is a texture; sample it with \`tex2D(${n}, uv)\``, callee.pos, n.length)
+        }
+
         const builtin = BUILTINS[n]
         if (builtin !== undefined) {
             if (n === "tex2D") {
@@ -471,9 +496,6 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
         if (SL_GLSL_HINT[n] !== undefined) {
             fail(`${n} is GLSL; this is HLSL, so write ${SL_GLSL_HINT[n]}`, callee.pos, n.length)
         }
-        if (textures.has(n)) {
-            fail(`"${n}" is a texture; sample it with \`tex2D(${n}, uv)\``, callee.pos, n.length)
-        }
         fail(unknown(n, scope), callee.pos, n.length)
     }
 

package/src/lang/lower.ts

@@ -158,7 +158,7 @@ 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 = lowerExpr(c.init, global)
+                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 })
             }
@@ -227,6 +227,8 @@ export function lower(checked: Checked): Program {
                 init.pos,
             )
         }
+        if (c.length === 1 && width > 1) return { components: new Array<number>(width).fill(c[0]!), colour: false }
+        if (c.length === 4 && width === 3) return { components: c.slice(0, 3), colour: false }
         if (c.length !== width) {
             fail(
                 `this default has ${c.length} component${c.length === 1 ? "" : "s"} and the uniform is ` +
@@ -284,19 +286,25 @@ export function lower(checked: Checked): Program {
             switch (s.k) {
                 case "var":
                 case "const": {
-                    const v = lowerExpr(s.init, scope)
+                    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": {
-                    const name = (s.target as Extract<Expr, { k: "ident" }>).name
+                    // The checker allowed exactly two shapes: a local, or a
+                    // swizzle of one with no component named twice.
+                    const member = s.target.k === "member" ? s.target : null
+                    const name = ((member?.obj ?? s.target) as Extract<Expr, { k: "ident" }>).name
                     const b = scope.lookup(name)!
                     let v = lowerExpr(s.value, scope)
                     if (s.op !== "=") {
                         const op = s.op[0] as ArithOp
-                        v = at(s.pos, () => arithmetic(op, b.value, v, s.pos))
+                        const old = member === null ? b.value : lowerExpr(member, scope)
+                        v = at(s.pos, () => arithmetic(op, old, v, s.pos))
                     }
+                    if (member !== null) v = writeComponents(b, member, v, s.pos)
+                    else v = fit(v, b.width, s.pos)
                     assertWidth(v, b.width, name, widthType(b.width), s.pos)
                     b.value = v
                     break
@@ -381,13 +389,52 @@ export function lower(checked: Checked): Program {
         return typeof a !== "number" && typeof b !== "number" && a.ref === b.ref && a.width === b.width
     }
 
+    /**
+     * The two conversions a declaration or an assignment makes for the author
+     * (`Specs/SL_NEXT.md` 2b and 2c): a single number fills every component, as
+     * `float3(0.5)` would, and a float4 goes into a float3 by dropping its
+     * fourth, which is how a colour (a hex, a ramp, a texture sample) becomes
+     * an rgb. Every other width change is left for `assertWidth` to refuse.
+     */
+    function fit(v: LV, want: SLType, pos: Pos): LV {
+        const got = typeof v === "number" ? 1 : v.width
+        if (got === 1 && want > 1) return at(pos, () => compose(want, new Array<LV>(want).fill(v)))
+        if (got === 4 && want === 3) return at(pos, () => asVal(v).swz("xyz") as unknown as Val)
+        return v
+    }
+
+    /**
+     * `p.x = v`, `c.rgb *= k`: the local rebuilt from the components the
+     * swizzle names, taken from `v`, and the rest kept from what it held. A
+     * single number fills every named component.
+     */
+    function writeComponents(b: Binding, member: Extract<Expr, { k: "member" }>, v: LV, pos: Pos): LV {
+        const letters = member.name.replace(/[rgba]/g, (c) => "xyzw"["rgba".indexOf(c)]!)
+        const names = "xyzw".slice(0, b.width)
+        for (const c of letters) {
+            if (!names.includes(c)) {
+                fail(`${member.name} writes a component a ${widthType(b.width)} does not have`, member.pos)
+            }
+        }
+        const got = typeof v === "number" ? 1 : v.width
+        if (got !== 1 && got !== letters.length) {
+            fail(`${member.name} is ${letters.length} components and this is a ${widthType(got as SLType)}`, pos)
+        }
+        const parts: LV[] = [...names].map((c) => {
+            const j = letters.indexOf(c)
+            if (j < 0) return b.width === 1 ? b.value : at(pos, () => asVal(b.value).swz(c) as unknown as Val)
+            return got === 1 ? v : at(pos, () => asVal(v).swz("xyzw"[j]!) as unknown as Val)
+        })
+        return b.width === 1 ? parts[0]! : at(pos, () => compose(b.width, parts))
+    }
+
     function assertWidth(v: LV, want: SLType, name: string, type: TypeName, pos: Pos): void {
         const got = typeof v === "number" ? 1 : v.width
         if (got === want) return
         // A declaration is an assertion, not an input to inference
         // (`Specs/SL_TEXT.md` 3.2), so this says which half is wrong rather
         // than quietly promoting one to the other.
-        const hint = got === 1 ? ` Wrap it in ${type}(...) to broadcast the value across ${want} components.` : ""
+        const hint = got > want ? ` Take the components you want with a swizzle, as in .${"xyzw".slice(0, want)}.` : ""
         fail(`${name} is declared ${type} and this is a ${widthType(got as SLType)}.${hint}`, pos)
     }