onejs-sl 0.1.6 → 0.1.7

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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.

package/README.md

@@ -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
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onejs-sl",
-  "version": "0.1.6",
+  "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/lang/check.ts

@@ -453,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
         }
     }