wesl 0.7.26 → 0.7.28

package/src/test/BevyLink.test.ts

@@ -11,13 +11,11 @@ const bevyBulkTest = {
   name: "Bevy",
   baseDir: "bevy-wgsl",
   git: {
-    url: "https://github.com/wgsl-tooling-wg/bevy-wgsl.git",
+    url: "https://github.com/webgpu-tools/bevy-wgsl.git",
     revision: "84977ff025eaf8d92e56a9c35b815fae70eb4af0",
   },
 };
 
-await fetchBulkTest(bevyBulkTest, fixturesDir);
-
 // Constants needed by various Bevy modules
 const bevyConstants = {
   MAX_CASCADES_PER_LIGHT: 4,
@@ -36,6 +34,7 @@ const conditionalFiles: Record<string, Conditions> = {
   "./pbr/decal/clustered.wesl": { CLUSTERED_DECALS_ARE_USABLE: true },
   "./pbr/decal/forward.wesl": { DEPTH_PREPASS: true },
   "./pbr/morph.wesl": { MORPH_TARGETS: true },
+  "./pbr/irradiance_volume.wesl": { IRRADIANCE_VOLUMES_ARE_USABLE: true },
 };
 
 // LATER: binding_array is a WGSL extension not yet supported
@@ -44,8 +43,21 @@ const skipFiles = [
   "./pbr/decal/clustered.wesl", // imports mesh_view_bindings which uses binding_array
 ];
 
-// Files that only contain imports (re-export modules) - always produce empty output
-const importOnlyFiles = ["./sprite/mesh2d_view_types.wesl"];
+// Files that produce empty WGSL with the default conditions: either pure
+// re-export modules (imports only), or modules whose every top-level decl is
+// behind an `@if` that is off by default (and whose only enabling condition
+// pulls in an as-yet-unsupported WGSL extension, so we can't link it non-empty).
+const emptyOutputFiles = [
+  "./sprite/mesh2d_view_types.wesl", // imports only
+  "./pbr/meshlet_visibility_buffer_resolve.wesl", // all decls behind @if(MESHLET_MESH_MATERIAL_PASS); enabling it needs binding_array (r64uint)
+];
+
+await fetchBulkTest(bevyBulkTest, fixturesDir);
+
+const weslSrc = await loadBevyBundle();
+const allFiles = Object.keys(weslSrc)
+  .filter(f => !skipFiles.includes(f))
+  .sort();
 
 async function loadBevyBundle(): Promise<Record<string, string>> {
   const bevyDir = new URL(
@@ -75,11 +87,6 @@ async function loadDir(
   }
 }
 
-const weslSrc = await loadBevyBundle();
-const allFiles = Object.keys(weslSrc)
-  .filter(f => !skipFiles.includes(f))
-  .sort();
-
 allFiles.forEach(file => {
   test(`bevy: link ${file}`, async () => {
     const conditions = conditionalFiles[file] ?? {};
@@ -91,7 +98,7 @@ allFiles.forEach(file => {
     );
 
     const wgsl = result.dest;
-    if (importOnlyFiles.includes(file)) {
+    if (emptyOutputFiles.includes(file)) {
       expect(wgsl).toBe("");
     } else {
       expect(wgsl.length).toBeGreaterThan(0);

package/src/test/ConditionalElif.test.ts

@@ -84,8 +84,10 @@ test("@elif on functions", async () => {
   `;
 
   const expected = `
-    fn compute() -> u32 { return 2; }
-    
+    fn compute() -> u32 {
+      return 2;
+    }
+
     fn main() -> u32 {
       return compute();
     }

package/src/test/DeclCommentEmit.test.ts

@@ -0,0 +1,122 @@
+import { expect, test } from "vitest";
+import { linkTest } from "./TestUtil.ts";
+import { expectTrimmedMatch } from "./TrimmedMatch.ts";
+
+// Comments attached to declaration-level nodes (module decls, struct members,
+// fn signatures) survive linking. Statement- and expression-level comments are
+// covered in StatementEmit / ParseComments.
+
+test("doc comment above a function", async () => {
+  const src = `
+    // describe foo
+    fn foo() { }
+  `;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("doc comment above a struct", async () => {
+  const src = `
+    // a point
+    struct Point { x: i32 }
+  `;
+  const result = await linkTest(src);
+  expect(result).toContain("// a point");
+});
+
+test("doc comment above a global const", async () => {
+  const src = `
+    // the answer
+    const answer = 42;
+  `;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("trailing comment on a global const", async () => {
+  const src = `const answer = 42; // the answer`;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("leading comment on a struct member", async () => {
+  const src = `
+    struct S {
+      // the x field
+      x: i32,
+      y: i32,
+    }
+  `;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("trailing comment on a struct member", async () => {
+  const src = `
+    struct S {
+      x: i32, // horizontal
+      y: i32,
+    }
+  `;
+  const result = await linkTest(src);
+  expect(result).toContain("// horizontal");
+});
+
+test("comment on a sole struct member forces the multi-line form", async () => {
+  const src = `struct S { /* the field */ x: i32 }`;
+  const result = await linkTest(src);
+  expect(result).toContain("/* the field */");
+  expect(result).toContain("x: i32");
+});
+
+test("comment leading a function parameter", async () => {
+  const src = `fn foo(/* count */ n: i32) { }`;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("comment trailing a function parameter", async () => {
+  const src = `fn foo(n: i32 /* count */) { }`;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("comment before a function name", async () => {
+  const src = `fn /* the entry point */ main() { }`;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("comment before a struct name", async () => {
+  const src = `struct /* a point */ Point { x: i32 }`;
+  const result = await linkTest(src);
+  expect(result).toContain("/* a point */");
+});
+
+test("comment before an alias name", async () => {
+  const src = `alias /* small int */ Byte = i32;`;
+  const result = await linkTest(src);
+  expect(result).toContain("/* small int */");
+});
+
+test("comment before a return type", async () => {
+  const src = `fn one() -> /* always one */ i32 { return 1; }`;
+  const result = await linkTest(src);
+  expect(result).toContain("/* always one */");
+});
+
+test("comment trailing an attribute", async () => {
+  const src = `@compute /* on the gpu */ @workgroup_size(1) fn main() { }`;
+  const result = await linkTest(src);
+  expect(result).toContain("/* on the gpu */");
+});
+
+test("comment before a local declaration name", async () => {
+  const src = `
+    fn main() {
+      let /* result */ x = 1;
+    }
+  `;
+  const result = await linkTest(src);
+  expect(result).toContain("/* result */");
+});

package/src/test/DoBlock.test.ts

@@ -0,0 +1,164 @@
+import { expect, test } from "vitest";
+import type { CallElem, DoBlockElem } from "../AbstractElems.ts";
+import { freshResolver, RecordResolver } from "../ModuleResolver.ts";
+import { linkTestOpts, parseTest } from "./TestUtil.ts";
+
+/** `do` blocks are an opt-in WESL extension (default off). */
+const doExt = { weslExtensions: { doBlocks: true } } as const;
+
+const example1 = `
+@buffer var<storage, read_write> grid: array<f32, 64>;
+
+@compute @workgroup_size(8)
+fn jacobi_step(@builtin(global_invocation_id) id: vec3u) {
+  let i = id.x;
+  if (i > 0u && i < 63u) { grid[i] = (grid[i - 1u] + grid[i + 1u]) * 0.5; }
+}
+
+@test
+do test_jacobi() {
+  for (var i = 0u; i < 100u; i++) { jacobi_step(8, 1, 1); }
+}
+`;
+
+const example2 = `
+do reduce(count: u32) {
+  let groups = count / 256u;
+  if groups > 1u {
+    reduce_step(groups, 1, 1);
+    reduce(groups);
+  } else {
+    reduce_step(1, 1, 1);
+  }
+}
+
+do frame(u: Uniforms, @slider(1, 100) steps: u32) {
+  if u.frame == 0u { init_min_max(1, 1, 1); }
+  for (var i = 0u; i < steps; i++) {
+    step_sim(u.resolution.x / 8u, u.resolution.y / 8u, 1);
+  }
+  render();
+}
+`;
+
+function doBlocks(src: string): DoBlockElem[] {
+  const ast = parseTest(src, doExt);
+  return ast.moduleElem.decls.filter((e): e is DoBlockElem => e.kind === "do");
+}
+
+test("parse do block: name, params, control flow body", () => {
+  const blocks = doBlocks(example1);
+  expect(blocks).toHaveLength(1);
+  const [block] = blocks;
+  expect(block.name.name).toBe("test_jacobi");
+  expect(block.params).toHaveLength(0);
+  expect(block.body.body.length).toBeGreaterThan(0);
+});
+
+test("do body call-expressions expose structured .arguments", () => {
+  // Expressions are first-class AST nodes, so call args are typed ExpressionElem
+  // trees - the interpreter reads them directly.
+  const src = `
+    do tick() {
+      fill(1, 1, 1);
+    }
+  `;
+  const [block] = doBlocks(src);
+  const stmt = block.body.body.find((c): c is CallElem => c.kind === "call");
+  expect(stmt).toBeDefined();
+  const call = stmt!.call;
+  expect(call.arguments).toHaveLength(3);
+  expect(call.arguments.every(a => a.kind === "literal")).toBe(true);
+});
+
+test("parse do blocks: recursion, if/else, uniforms + slider params", () => {
+  const blocks = doBlocks(example2);
+  expect(blocks.map(b => b.name.name)).toEqual(["reduce", "frame"]);
+
+  const [reduce, frame] = blocks;
+  expect(reduce.params).toHaveLength(1);
+  expect(reduce.params[0].name.decl.ident.originalName).toBe("count");
+
+  expect(frame.params).toHaveLength(2);
+  expect(frame.params.map(p => p.name.decl.ident.originalName)).toEqual([
+    "u",
+    "steps",
+  ]);
+  expect(frame.body.body.length).toBeGreaterThan(0);
+});
+
+test("link drops the do block, keeps surrounding declarations", async () => {
+  const wgsl = await linkTestOpts(doExt, example1);
+  expect(wgsl).toContain("fn jacobi_step");
+  expect(wgsl).toContain("grid");
+  expect(wgsl).toContain("@compute");
+  expect(wgsl).not.toContain("test_jacobi");
+  expect(wgsl).not.toMatch(/(^|\s)do\s/);
+});
+
+test("do block body links without spurious binding errors", async () => {
+  // example2 has no fn/global decls, only do blocks: a clean emit proves the
+  // do bodies (u.frame, steps, step_sim, render, reduce) bypass bindIdents.
+  const wgsl = await linkTestOpts(doExt, example2);
+  for (const name of [
+    "reduce",
+    "frame",
+    "step_sim",
+    "render",
+    "Uniforms",
+    "init_min_max",
+  ]) {
+    expect(wgsl).not.toContain(name);
+  }
+});
+
+test("error: fn and do block with the same name", () => {
+  const src = `
+    fn reduce() {}
+    do reduce() {}
+  `;
+  expect(() => parseTest(src, doExt)).toThrow(/declared as both fn and do/);
+});
+
+test("error: two do blocks with the same name", () => {
+  // runners key do blocks by name, so a duplicate would silently shadow the
+  // first; reject it at parse time instead of running the wrong block.
+  const src = `
+    do same() {}
+    do same() {}
+  `;
+  expect(() => parseTest(src, doExt)).toThrow(/declared as do more than once/);
+});
+
+test("default off: do block syntax is not recognized without the extension", () => {
+  // Without the extension, `do` stays a reserved word and module-level `do`
+  // fails to parse (no DoBlockElem is produced).
+  expect(() => parseTest(example1)).toThrow();
+  expect(() => parseTest("do tick() {}")).toThrow();
+});
+
+test("freshResolver preserves weslExtensions across re-parse", () => {
+  // Resolver reuse re-parses via parseSrcModule(ast.srcModule, ast.parseOptions);
+  // the do-block extension must survive that round trip.
+  const src = "do tick() {}";
+  const inner = new RecordResolver({ "package::main": src }, doExt);
+  const wrapped = freshResolver(freshResolver(inner));
+  const ast = wrapped.resolveModule("package::main")!;
+  const blocks = ast.moduleElem.decls.filter(
+    (e): e is DoBlockElem => e.kind === "do",
+  );
+  expect(blocks.map(b => b.name.name)).toEqual(["tick"]);
+
+  // an optionless resolver stays OFF (fails to parse `do`, as before)
+  const off = freshResolver(new RecordResolver({ "package::main": src }));
+  expect(() => off.resolveModule("package::main")).toThrow();
+});
+
+test("regression: a normal fn named do_something is unaffected", async () => {
+  const wgsl = await linkTestOpts({}, "fn do_something() {}");
+  expect(wgsl).toContain("fn do_something");
+});
+
+test("regression: do as a reserved word still errors when the extension is off", () => {
+  expect(() => parseTest("fn f() { do }")).toThrow(/Expected ';'/);
+});

package/src/test/FilterValidElements.test.ts

@@ -21,7 +21,6 @@ function mockElem(testId: string, attributes?: AttributeElem[]): TestElem {
     kind: "alias",
     testId,
     attributes,
-    contents: [],
     start: 0,
     end: 0,
   } as TestElem;
@@ -31,13 +30,15 @@ function ifAttr(condition: boolean): AttributeElem {
   const literal: Literal = {
     kind: "literal",
     value: condition ? "true" : "false",
-    span: [0, 0],
+    start: 0,
+    end: 0,
   };
 
   const translateTimeExpr: TranslateTimeExpressionElem = {
     kind: "translate-time-expression",
     expression: literal,
-    span: [0, 0],
+    start: 0,
+    end: 0,
   };
 
   const ifAttribute: IfAttribute = {
@@ -48,7 +49,6 @@ function ifAttr(condition: boolean): AttributeElem {
   return {
     kind: "attribute",
     attribute: ifAttribute,
-    contents: [],
     start: 0,
     end: 0,
   };
@@ -62,7 +62,6 @@ function elseAttr(): AttributeElem {
   return {
     kind: "attribute",
     attribute: elseAttribute,
-    contents: [],
     start: 0,
     end: 0,
   };
@@ -175,7 +174,6 @@ test("complex nested attributes", () => {
   const standardAttr = (name: string): AttributeElem => ({
     kind: "attribute",
     attribute: { kind: "@attribute", name, params: [] },
-    contents: [],
     start: 0,
     end: 0,
   });

package/src/test/Linker.test.ts

@@ -14,6 +14,12 @@ test("global diagnostic directive", async () => {
   expectTrimmedMatch(result, src);
 });
 
+test("consecutive top-level directives stay on separate lines", async () => {
+  const src = `requires readonly_and_readwrite_storage_textures;\nenable f16;`;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
 test("@diagnostic attribute on statement", async () => {
   const src = `fn foo() { @diagnostic(info, derivative_uniformity) if true { } }`;
   const result = await linkTest(src);
@@ -54,7 +60,9 @@ test("link an alias", async () => {
   const src = /* wgsl */ `
     alias Num = f32;
 
-    fn main() { Num(1.0); }
+    fn main() {
+      Num(1.0);
+    }
   `;
   const result = await linkTest(src);
   expectTrimmedMatch(result, src);
@@ -112,9 +120,9 @@ test("type inside fn with same name as fn", async () => {
   // illegal but shouldn't hang
   const src = `
     fn foo() {
-      var a:foo;
+      var a: foo;
     }
-    fn bar() {}
+    fn bar() { }
   `;
   const result = await linkTest(src);
   expectTrimmedMatch(result, src);
@@ -183,8 +191,12 @@ test("cross-module @location attribute const", async () => {
   `;
   const result = await linkTest(main, file1);
   const expected = `
-    fn main() { let x = foo(); }
-    fn foo() -> @location(loc) vec4f { return vec4f(); }
+    fn main() {
+      let x = foo();
+    }
+    fn foo() -> @location(loc) vec4f {
+      return vec4f();
+    }
     const loc = 0;
   `;
   expectTrimmedMatch(result, expected);
@@ -207,7 +219,9 @@ test("link with library bundle (tests CompositeResolver)", async () => {
   ];
   const result = await linkTestOpts({ libs }, main);
   const expected = `
-    fn main() { helper(); }
+    fn main() {
+      helper();
+    }
     fn helper() { }
   `;
   expectTrimmedMatch(result, expected);
@@ -221,7 +235,9 @@ test("inline ref in array size from another module", async () => {
   const file1 = `const SIZE = 4;`;
   const result = await linkTest(main, file1);
   const expected = `
-    fn main() { var a: array<f32, SIZE>; }
+    fn main() {
+      var a: array<f32, SIZE>;
+    }
     const SIZE = 4;
   `;
   expectTrimmedMatch(result, expected);

package/src/test/Mangling.test.ts

@@ -15,8 +15,10 @@ fn main() { bar(); }
 
   const linked = await linkTestOpts({ mangler: underscoreMangle }, main, file1);
   const expected = `
-    fn main() { package_file1_bar(); }
-    fn package_file1_bar() {}
+    fn main() {
+      package_file1_bar();
+    }
+    fn package_file1_bar() { }
   `;
   expectTrimmedMatch(linked, expected);
 });
@@ -38,8 +40,10 @@ fn main() { bar(); }
   });
 
   const expected = `
-    fn main() { package_container_file1_bar(); }
-    fn package_container_file1_bar() {}
+    fn main() {
+      package_container_file1_bar();
+    }
+    fn package_container_file1_bar() { }
   `;
   expectTrimmedMatch(linked.dest, expected);
 });