@woosh/meep-engine 3.30.0 → 3.31.0

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js

@@ -365,6 +365,64 @@ function literalType(text) {
     return T_UNKNOWN;
 }
 
+// =========================================================================
+// Identifiers — WGSL names JavaScript cannot bind verbatim
+// =========================================================================
+
+/**
+ * Names a WGSL identifier cannot keep in the generated JavaScript. {@link identToJs} renames them.
+ *
+ * - JavaScript's reserved words, strict-mode ones included. A struct becomes a class and a class
+ *   body is strict code, so `struct private` fails to load even though sloppy code would accept it.
+ * - `arguments` and `eval`, which strict code refuses as bindings. Inside a function, `arguments`
+ *   also means the call's arguments object, so a function reading a module-scope one got that
+ *   object instead of the WGSL value.
+ * - The free names the generated code refers to: the `wgsl` runtime and the globals it builds
+ *   values with. A WGSL `struct Object` shadowed the `Object` whose `defineProperty` exports the
+ *   module's state, and the module failed to load. Any global that new emitted code refers to
+ *   belongs here too.
+ *
+ * WGSL reserves most of these itself, so a device rejects them. The tree-sitter grammar does not,
+ * so any of them can reach this compiler. `in` is the one real shaders use, as the parameter of a
+ * fragment entry: `fn fs_main(in : VertexOut)`.
+ *
+ * @type {Set<string>}
+ */
+const JS_RESERVED_NAMES = new Set([
+    // reserved words
+    'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete',
+    'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import',
+    'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try',
+    'typeof', 'var', 'void', 'while', 'with', 'yield',
+    // reserved in strict code
+    'implements', 'interface', 'let', 'package', 'private', 'protected', 'public', 'static',
+    // refused as bindings in strict code
+    'arguments', 'eval',
+    // referred to by the generated code
+    'wgsl', 'undefined', 'Object', 'Array', 'Float32Array', 'Float16Array', 'Int32Array', 'Uint32Array',
+]);
+
+/**
+ * The JavaScript binding a WGSL identifier is emitted as: the identifier itself, or the identifier
+ * with a `$` suffix when it is one of {@link JS_RESERVED_NAMES} (`in` becomes `in$`).
+ *
+ * The suffix cannot collide with anything. The WGSL grammar has no `$` in an identifier, so a
+ * source that spells one does not parse. None of the compiler's own names (`wgsl`, `__entry__`, …)
+ * contain one. Appending it to two different names leaves them different.
+ *
+ * Every declaration of, and reference to, a function, parameter, local, module-scope variable or
+ * struct type goes through this. Struct members do not: a member is a property, and `x.in` is
+ * legal JavaScript. Nothing a caller sees is renamed either. The module exports everything under
+ * its WGSL name, `entry_name` and `param_names` hold WGSL names, and bindings and workgroup
+ * variables are keyed by their WGSL names.
+ *
+ * @param {string} name a WGSL identifier
+ * @returns {string}
+ */
+function identToJs(name) {
+    return JS_RESERVED_NAMES.has(name) ? `${name}$` : name;
+}
+
 // =========================================================================
 // Operator handling
 // =========================================================================
@@ -393,6 +451,20 @@ const INTEGER_WRAPPING_OP = {
     '*': 'mul',
 };
 
+/**
+ * Scalar arithmetic that has to round to f32, by operator.
+ *
+ * A vector's lanes always rounded — they are written into a Float32Array — and the scalar path did
+ * not, so one function ran at two precisions and the scalar one was more accurate than the device.
+ * @type {Object<string, string>}
+ */
+const F32_SCALAR_OP = {
+    '+': 'add_f32',
+    '-': 'sub_f32',
+    '*': 'mul_f32',
+    '/': 'div_f32',
+};
+
 // =========================================================================
 // Compiler context — central state during compilation
 // =========================================================================
@@ -431,6 +503,13 @@ class Compiler {
         /** @type {{ name: string, params: Array<{ name: string, type: WgslType, builtin: string | null }>, workgroup_size: number[] } | null} */
         this.entry = null;
 
+        /**
+         * Name of the function whose body is being emitted, `null` outside one. `discard` reads it:
+         * it compiles to a `return`, which only ends the invocation from inside the entry.
+         * @type {string | null}
+         */
+        this.function_name = null;
+
         /**
          * Label of the enclosing `loop` body block when that loop has a `continuing`
          * block: WGSL `continue` must transfer control INTO the continuing block, so it
@@ -483,6 +562,9 @@ export class WGSLJavaScriptCompiler {
      * Without a `@compute` entry the result is a "library" module — useful for testing
      * pure WGSL helper code chunks (hashes, packing, math) one function at a time.
      *
+     * Every name on the module is the WGSL one, including where the generated JavaScript had to
+     * bind it under another (a parameter `in` is bound as `in$`; see {@link identToJs}).
+     *
      * @param {Tree} ast — tree-sitter WGSL AST (returned by `WGSLParser.parse`)
      * @returns {string}
      */
@@ -536,10 +618,10 @@ function compileTranslationUnit(c, root) {
     //    these on each dispatch so that user functions see them via their enclosing closure
     //    — WGSL functions can read globals freely.
     for (const b of c.globalBindings) {
-        c.out.add(`let ${b.name} = undefined;`);
+        c.out.add(`let ${identToJs(b.name)} = undefined;`);
     }
     for (const wv of c.workgroupVars) {
-        c.out.add(`let ${wv.name} = undefined;`);
+        c.out.add(`let ${identToJs(wv.name)} = undefined;`);
     }
 
     // 3) Module-scope `var<private>` and `const` declarations.
@@ -577,27 +659,32 @@ function compileTranslationUnit(c, root) {
 
 /**
  * Emit the `return { ... }` block of the factory. Every top-level user function and struct
- * class is exposed by name; module-scope `var<private>` slots become getter/setter properties
- * (so tests can inspect or seed RNG state etc.), and module-scope `const`s become read-only
- * getters. `reset_private` is always included. When the WGSL had a `@compute` entry, the dispatch
- * trio (`entry_name`, `workgroup_size`, `param_names`, `entry`, `create_workgroup_state`) is
- * included too.
+ * class is exposed by its WGSL name; module-scope `var<private>` slots become getter/setter
+ * properties (so tests can inspect or seed RNG state etc.), and module-scope `const`s become
+ * read-only getters. `reset_private` is always included. When the WGSL had a `@compute` entry, the
+ * dispatch trio (`entry_name`, `workgroup_size`, `param_names`, `entry`, `create_workgroup_state`)
+ * is included too.
  */
 function emitModuleReturn(c) {
     c.out.add('const __module__ = {};');
 
     for (const fn_name of c.functions.keys()) {
-        c.out.add(`__module__.${fn_name} = ${fn_name};`);
+        c.out.add(`__module__.${fn_name} = ${identToJs(fn_name)};`);
     }
     for (const struct_name of c.structs.keys()) {
-        c.out.add(`__module__.${struct_name} = ${struct_name};`);
+        c.out.add(`__module__.${struct_name} = ${identToJs(struct_name)};`);
     }
 
     for (const g of c.privateGlobals) {
+        const js_name = identToJs(g.name);
+
         if (g.kind === 'let') {
-            c.out.add(`Object.defineProperty(__module__, ${JSON.stringify(g.name)}, { get: () => ${g.name}, set: (v) => { ${g.name} = v; } });`);
+            // The setter's parameter uses a name WGSL cannot spell. When it was `v`, a
+            // `var<private> v` compiled to `v = v`, which assigned the parameter to itself and
+            // left the variable untouched.
+            c.out.add(`Object.defineProperty(__module__, ${JSON.stringify(g.name)}, { get: () => ${js_name}, set: (__value__) => { ${js_name} = __value__; } });`);
         } else {
-            c.out.add(`Object.defineProperty(__module__, ${JSON.stringify(g.name)}, { get: () => ${g.name} });`);
+            c.out.add(`Object.defineProperty(__module__, ${JSON.stringify(g.name)}, { get: () => ${js_name} });`);
         }
     }
 
@@ -656,7 +743,7 @@ function emitStruct(c, node) {
     const name = ident.text;
     const info = c.structs.get(name);
 
-    c.out.add(`class ${name} {`);
+    c.out.add(`class ${identToJs(name)} {`);
     c.out.indent();
     c.out.add('constructor() {');
     c.out.indent();
@@ -696,7 +783,7 @@ function defaultValueForType(type) {
             return '[]';
         }
         case 'struct':
-            return `new ${type.name}()`;
+            return `new ${identToJs(type.name)}()`;
         case 'atomic':
             return '{ value: 0 }';
         default:
@@ -818,7 +905,7 @@ function emitFunction(c, node) {
 
     const param_names = param_nodes.map(p => namedChildByType(p, 'ident').text);
 
-    c.out.add(`function ${name}(${param_names.join(', ')}) {`);
+    c.out.add(`function ${identToJs(name)}(${param_names.map(identToJs).join(', ')}) {`);
     c.out.indent();
 
     c.scope = c.scope.push();
@@ -827,7 +914,9 @@ function emitFunction(c, node) {
     }
 
     const body = namedChildByType(node, 'compound_statement');
+    c.function_name = name;
     emitCompoundStatementBody(c, body);
+    c.function_name = null;
 
     c.scope = c.scope.parent;
 
@@ -910,7 +999,7 @@ function collectGlobalVariable(c, node) {
     c.privateGlobals.push({
         name,
         kind: 'let',
-        code: `let ${name} = ${init_code};`,
+        code: `let ${identToJs(name)} = ${init_code};`,
         init: init_code,
     });
 }
@@ -949,7 +1038,7 @@ function collectGlobalValue(c, node) {
     c.privateGlobals.push({
         name,
         kind: 'const',
-        code: `const ${name} = ${expr.code};`,
+        code: `const ${identToJs(name)} = ${expr.code};`,
         init: expr.code,
     });
 }
@@ -978,7 +1067,7 @@ function emitPrivateStateReset(c) {
     c.out.indent();
     for (const g of c.privateGlobals) {
         if (g.kind !== 'let') continue;
-        c.out.add(`${g.name} = ${g.init};`);
+        c.out.add(`${identToJs(g.name)} = ${g.init};`);
     }
     c.out.dedent();
     c.out.add('}');
@@ -999,25 +1088,32 @@ function emitWorkgroupStateFactory(c) {
 }
 
 function emitEntryWrapper(c) {
-    const param_names = c.entry.params.map(p => p.name);
+    // The wrapper refers to the entry function and to every binding and workgroup slot, all by
+    // name, so its own parameters use names WGSL cannot spell. When they took the entry's WGSL
+    // parameter names, `fn main(main: vec4<f32>)` wrapped to `main(main)`, which called the
+    // argument. A parameter that shared a binding's name was assigned the binding in place of its
+    // argument, and the binding's slot, which the entry's helpers read, stayed unset.
+    const arg_names = c.entry.params.map((_, i) => `__arg${i}__`);
+    const entry_fn = identToJs(c.entry.name);
     const is_compute = c.entry.stage === 'compute';
     // Compute entries take a per-dispatch workgroup-state object; fragment entries don't have
     // var<workgroup> at all, so the wrapper signature drops it.
     const fixed_args = is_compute ? '__bindings__, __workgroup__' : '__bindings__';
-    const all_args = param_names.length > 0 ? `${fixed_args}, ${param_names.join(', ')}` : fixed_args;
+    const all_args = arg_names.length > 0 ? `${fixed_args}, ${arg_names.join(', ')}` : fixed_args;
 
     c.out.add(`function __entry__(${all_args}) {`);
     c.out.indent();
 
     // Refresh each module-scope binding/workgroup slot before invoking the user's main.
     // User functions read these via their enclosing closure, so this assignment makes the
-    // current dispatch's bindings visible to every helper they may call.
+    // current dispatch's bindings visible to every helper they may call. The caller keys both
+    // objects by WGSL name; only the slot takes the JS name.
     for (const b of c.globalBindings) {
-        c.out.add(`${b.name} = __bindings__.${b.name};`);
+        c.out.add(`${identToJs(b.name)} = __bindings__.${b.name};`);
     }
     if (is_compute) {
         for (const wv of c.workgroupVars) {
-            c.out.add(`${wv.name} = __workgroup__.${wv.name};`);
+            c.out.add(`${identToJs(wv.name)} = __workgroup__.${wv.name};`);
         }
     }
 
@@ -1027,13 +1123,13 @@ function emitEntryWrapper(c) {
         // state object's field, not the field. Writing it back is what lets the next lane see it,
         // which is the whole point of workgroup memory (an array slot already persists, since the
         // slot holds a reference and the lane mutates it in place).
-        c.out.add(`const __result__ = ${c.entry.name}(${param_names.join(', ')});`);
+        c.out.add(`const __result__ = ${entry_fn}(${arg_names.join(', ')});`);
         for (const wv of c.workgroupVars) {
-            c.out.add(`__workgroup__.${wv.name} = ${wv.name};`);
+            c.out.add(`__workgroup__.${wv.name} = ${identToJs(wv.name)};`);
         }
         c.out.add('return __result__;');
     } else {
-        c.out.add(`return ${c.entry.name}(${param_names.join(', ')});`);
+        c.out.add(`return ${entry_fn}(${arg_names.join(', ')});`);
     }
 
     c.out.dedent();
@@ -1074,6 +1170,10 @@ function emitCompoundStatement(c, node) {
  */
 function emitStatement(c, node) {
     const inner = node.namedChildren[0];
+    if (inner === undefined) {
+        emitBareStatement(c, node);
+        return;
+    }
     switch (inner.type) {
         case 'variable_or_value_statement':
             emitVariableOrValueStatement(c, inner);
@@ -1112,9 +1212,6 @@ function emitStatement(c, node) {
                 c.out.add('continue;');
             }
             break;
-        case 'discard_statement':
-            c.out.add('return;');
-            break;
         case 'compound_statement':
             emitCompoundStatement(c, inner);
             break;
@@ -1129,6 +1226,31 @@ function emitStatement(c, node) {
     }
 }
 
+/**
+ * A `statement` with no named child. tree-sitter-wgsl builds `discard;` and the empty statement
+ * `;` from anonymous tokens alone — `(statement)` — so there is no child type to switch on, and
+ * they are told apart by their text.
+ * @param {Compiler} c
+ * @param {Node} node
+ */
+function emitBareStatement(c, node) {
+    switch (node.text.replace(/\s+/g, '')) {
+        case ';':
+            break;
+        case 'discard;':
+            // The fragment has no output, so `dispatch` returns undefined. That takes a return from
+            // the entry itself: in a helper it would only hand control back to the caller, and the
+            // fragment would carry on and write its colour.
+            if (c.entry === null || c.function_name !== c.entry.name) {
+                c.error(node, `discard is only supported in the entry function, not in '${c.function_name}'`);
+            }
+            c.out.add('return;');
+            break;
+        default:
+            c.error(node, 'unsupported statement');
+    }
+}
+
 /**
  * `let x = expr;` or `var x: T = expr;` or `var x: T;`
  */
@@ -1167,11 +1289,51 @@ function emitVariableOrValueStatement(c, node) {
             type = expr.abstract_int === true ? T_I32 : expr.type;
         }
         c.scope.declare(name, type);
-        c.out.add(`${kind} ${name} = ${expr.code};`);
+        c.out.add(`${kind} ${identToJs(name)} = ${expr.code};`);
     } else {
         c.scope.declare(name, type);
-        c.out.add(`${kind} ${name} = ${defaultValueForType(type)};`);
+        c.out.add(`${kind} ${identToJs(name)} = ${defaultValueForType(type)};`);
+    }
+}
+
+/**
+ * The `wgsl.*` helper a compound arithmetic assignment has to go through.
+ *
+ * The same selection the binary operators make, made again here off the LHS type — a compound
+ * assignment's result type IS the LHS type. Without it `x *= y` on a u32 computed the product in
+ * f64 and left the truncation to the write, and a 32-bit product passes 2^53 as soon as both
+ * factors are large: the low bits fall off, which is precisely the part an integer hash keeps.
+ * `hash_lowbias32`, written with `*=`, then disagreed with the CPU twin every CPU-built hash table
+ * is probed with.
+ *
+ * @param {string} helper the untyped helper name
+ * @param {string} op_text the compound operator, e.g. `*=`
+ * @param {WgslType} lhs_type
+ * @returns {string}
+ */
+function compoundArithmeticHelper(helper, op_text, lhs_compiled, rhs_compiled) {
+    const binary_op = op_text.slice(0, -1);
+
+    const arith_type = inferBinaryArithResultType(lhs_compiled.type, rhs_compiled.type);
+
+    const wrapping = INTEGER_WRAPPING_OP[binary_op];
+
+    if (wrapping !== undefined && isIntegerType(arith_type)) {
+        return `${wrapping}_${integerScalarName(arith_type)}`;
+    }
+
+    if (op_text === '/=' && integerDivision(lhs_compiled, rhs_compiled)) {
+        // WGSL `/` on integers is truncated integer division, as at the binary site
+        return 'idiv';
     }
+
+    const f32_scalar = F32_SCALAR_OP[binary_op];
+
+    if (f32_scalar !== undefined && isScalarF32(arith_type)) {
+        return f32_scalar;
+    }
+
+    return helper;
 }
 
 /**
@@ -1198,30 +1360,7 @@ function emitVariableUpdatingStatement(c, node) {
             '+=': 'add', '-=': 'sub', '*=': 'mul', '/=': 'div', '%=': 'rem',
         };
         if (arith.hasOwnProperty(op_text)) {
-            let helper = arith[op_text];
-
-            /**
-             * The same integer dispatch the binary path does, which this used not to have at all.
-             * WGSL `+` / `-` / `*` on integers wrap at 32 bits; JS numbers grow instead, and the bits
-             * an overflowing f64 drops are the low ones — exactly the ones an output permutation
-             * exists to mix. And compound assignment is the WGSL idiom for a hash, so every hash
-             * chunk in the tree took the unwrapped path while its `x = x * K` spelling took the
-             * correct one: `v *= 0x21f0aaadu` at 123456789 gave 70298821705959730 where the device
-             * gives 3890841905, and the shipped `chunk_hash_lowbias32` disagreed with the CPU
-             * `lowbias32` on 4,076 of its first 4,096 inputs, half of them not u32 values at all.
-             *
-             * That is the second tier of the GPU testing strategy: `chunk/random` and `chunk/noise`
-             * can only be tested here, because a hash cannot be eyeballed.
-             */
-            const arith_type = inferBinaryArithResultType(lhs_compiled.type, rhs_compiled.type);
-            const wrapping = INTEGER_WRAPPING_OP[op_text.slice(0, -1)];
-
-            if (wrapping !== undefined && isIntegerType(arith_type)) {
-                helper = `${wrapping}_${integerScalarName(arith_type)}`;
-            } else if (op_text === '/=' && integerDivision(lhs_compiled, rhs_compiled)) {
-                //WGSL `/` on integers is truncated integer division, as at the binary site
-                helper = 'idiv';
-            }
+            const helper = compoundArithmeticHelper(arith[op_text], op_text, lhs_compiled, rhs_compiled);
 
             c.out.add(emitWriteStatement(lhs_compiled, `wgsl.${helper}(${lhs_compiled.code}, ${rhs_compiled.code})`));
             return;
@@ -1410,7 +1549,7 @@ function emitForInitInline(c, node) {
         // `var i = …` (mutable, common in `for (var i = 0; ...; i = i + 1)`) → JS `let`.
         // `let i = …` / `const i = …` (immutable) → JS `const`.
         const kind = var_decl !== null ? 'let' : 'const';
-        c.out.add(`${kind} ${name} = ${value};`);
+        c.out.add(`${kind} ${identToJs(name)} = ${value};`);
         return;
     }
     if (node.type === 'variable_updating_statement') {
@@ -1443,10 +1582,12 @@ function emitForUpdateInline(c, node) {
             }
             const arith = { '+=': 'add', '-=': 'sub', '*=': 'mul', '/=': 'div', '%=': 'rem' };
             if (arith.hasOwnProperty(op_text)) {
+                const helper = compoundArithmeticHelper(arith[op_text], op_text, lhs_compiled, rhs_compiled);
+
                 if (lhs_compiled.through_pointer === true) {
-                    return `${lhs_compiled.code} = wgsl.store_ptr(${lhs_compiled.code}, wgsl.${arith[op_text]}(${lhs_compiled.code}, ${rhs_compiled.code}))`;
+                    return `${lhs_compiled.code} = wgsl.store_ptr(${lhs_compiled.code}, wgsl.${helper}(${lhs_compiled.code}, ${rhs_compiled.code}))`;
                 }
-                return `${lhs_compiled.code} = wgsl.${arith[op_text]}(${lhs_compiled.code}, ${rhs_compiled.code})`;
+                return `${lhs_compiled.code} = wgsl.${helper}(${lhs_compiled.code}, ${rhs_compiled.code})`;
             }
             return `${lhs_compiled.code} ${op_text} ${rhs_compiled.code}`;
         }
@@ -1685,10 +1826,10 @@ function compileExpression(c, node) {
     if (u.type === 'template_elaborated_ident') {
         const ident = namedChildByType(u, 'ident');
         const name = ident !== null ? ident.text : u.text;
-        return { code: name, type: c.scope.lookup(name) };
+        return { code: identToJs(name), type: c.scope.lookup(name) };
     }
     if (u.type === 'ident') {
-        return { code: u.text, type: c.scope.lookup(u.text) };
+        return { code: identToJs(u.text), type: c.scope.lookup(u.text) };
     }
 
     c.error(u, `unsupported expression: ${u.type}`);
@@ -1759,6 +1900,14 @@ function compileBinaryExpression(c, node, op_type, mode) {
             if (wrapping !== undefined && isIntegerType(arith_type)) {
                 actual_helper = `${wrapping}_${integerScalarName(arith_type)}`;
             }
+
+            // Same shape for f32 scalars: only when the result type is KNOWN to be one, so an
+            // AbstractFloat const-expression — which WGSL evaluates at higher precision — is left
+            // alone. A vec is already rounded lane by lane through its Float32Array.
+            const f32_scalar = F32_SCALAR_OP[op_text];
+            if (f32_scalar !== undefined && isScalarF32(arith_type)) {
+                actual_helper = f32_scalar;
+            }
             return {
                 code: `wgsl.${actual_helper}(${left.code}, ${right.code})`,
                 type: arith_type,
@@ -1847,6 +1996,11 @@ function integerScalarName(t) {
     return t.scalar;
 }
 
+/** True if `t` is an `f32` SCALAR — a vec's lanes round through their Float32Array already. */
+function isScalarF32(t) {
+    return t !== undefined && t !== null && t.kind === 'primitive' && t.name === 'f32';
+}
+
 /** True if `t` is an integer type (scalar or vec/mat of i32/u32). */
 function isIntegerType(t) {
     if (!t) return false;
@@ -2226,7 +2380,7 @@ function compileCallPhraseTyped(c, node) {
     // 7) Struct constructor.
     if (c.structs.has(callee_name)) {
         const info = c.structs.get(callee_name);
-        const parts = [`(() => { const __s__ = new ${callee_name}();`];
+        const parts = [`(() => { const __s__ = new ${identToJs(callee_name)}();`];
         for (let i = 0; i < info.fields.length && i < args.length; i++) {
             parts.push(`__s__.${info.fields[i].name} = ${args[i]};`);
         }
@@ -2237,18 +2391,45 @@ function compileCallPhraseTyped(c, node) {
     // 8) User-defined function.
     if (c.functions.has(callee_name)) {
         return {
-            code: `${callee_name}(${args.join(', ')})`,
+            code: `${identToJs(callee_name)}(${args.join(', ')})`,
             type: c.functions.get(callee_name).returnType,
         };
     }
 
     // 9) WGSL builtins — best-effort type inference for common helpers.
+    //
+    // A few of them mean different things on i32 and on u32, and the operand type is the only
+    // thing that says which — the same selection the arithmetic operators make.
+    if (INTEGER_TYPED_BUILTIN.has(callee_name)) {
+        const operand_type = arg_results[0] === undefined ? undefined : arg_results[0].type;
+
+        if (isIntegerType(operand_type)) {
+            return {
+                code: `wgsl.${callee_name}_${integerScalarName(operand_type)}(${args.join(', ')})`,
+                type: inferBuiltinReturnType(callee_name, arg_results),
+            };
+        }
+    }
+
     return {
         code: `wgsl.${callee_name}(${args.join(', ')})`,
         type: inferBuiltinReturnType(callee_name, arg_results),
     };
 }
 
+/**
+ * Builtins whose answer depends on whether the operand is i32 or u32, dispatched to a
+ * `<name>_i32` / `<name>_u32` pair in the runtime core.
+ *
+ * `abs` wraps at the most negative i32 and is the identity on u32; `firstLeadingBit` scans for the
+ * most significant bit unlike the sign bit on i32 and for the most significant set bit on u32, which
+ * are different functions rather than the same one read differently. Taking the JS meaning for both
+ * made the emulator answer things no device does, on the oracle the chunk specs are checked against.
+ *
+ * @type {Set<string>}
+ */
+const INTEGER_TYPED_BUILTIN = new Set(['abs', 'firstLeadingBit', 'firstTrailingBit']);
+
 /**
  * Best-effort return type for WGSL builtins commonly used in compute shaders.
  * Handles the cases needed for accurate swizzle / member-access codegen downstream.
@@ -2354,7 +2535,7 @@ function compileLhs(c, node) {
     if (core !== null) {
         const ident = namedChildByType(core, 'ident');
         if (ident !== null) {
-            code = ident.text;
+            code = identToJs(ident.text);
             type = c.scope.lookup(ident.text);
         } else {
             const nested = namedChildByType(core, 'lhs_expression');

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":"AA0PA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAykCd"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":"AAkRA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAwpCd"}