wesl 0.6.0-pre10

package/src/test/PathUtil.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from "vitest";
+import { normalize } from "../PathUtil.js";
+
+// ../../../lib/webgpu-samples/src/anim/anim.wgsl
+
+test("normalize ./foo", () => {
+  const n = normalize("./foo");
+  expect(n).toBe("foo");
+});
+
+test("normalize ./foo/./", () => {
+  const n = normalize("./foo/./");
+  expect(n).toBe("foo");
+});
+
+test("normalize foo/bar/..", () => {
+  const n = normalize("foo/bar/..");
+  expect(n).toBe("foo");
+});
+
+test("normalize ./foo/bar/../.", () => {
+  const n = normalize("./foo/bar/../.");
+  expect(n).toBe("foo");
+});
+
+test("normalize ../foo", () => {
+  const n = normalize("../foo");
+  expect(n).toBe("../foo");
+});
+
+test("normalize ../../foo", () => {
+  const n = normalize("../../foo");
+  expect(n).toBe("../../foo");
+});

package/src/test/PrettyGrammar.test.ts

@@ -0,0 +1,20 @@
+import { or, parserToString, seq } from "mini-parse";
+import { expect, test } from "vitest";
+
+test("print grammar", () => {
+  const p: any = or("a", "b", () => p);
+  const s = seq("a", "b", () => p);
+  const result = parserToString(s);
+  expect(result).toMatchInlineSnapshot(`
+    "seq
+      'a'
+      'b'
+      fn()
+        or
+          'a'
+          'b'
+          fn()
+            ->or
+    "
+  `);
+});

package/src/test/Reflection.test.ts

@@ -0,0 +1,172 @@
+import { expect, test } from "vitest";
+import { BindingStructElem, StructElem } from "../AbstractElems.ts";
+import { astToString } from "../debug/ASTtoString.ts";
+import {
+  bindingGroupLayoutTs,
+  reportBindingStructsPlugin,
+} from "../Reflection.ts";
+import { bindingStructsPlugin } from "../TransformBindingStructs.ts";
+import { linkTestOpts } from "./TestUtil.ts";
+
+test("extract binding struct", () => {
+  const src = `
+    struct Bindings {
+      @group(0) @binding(0) particles: ptr<storage, array<f32>, read_write>, 
+    }
+
+    @compute fn main(b: Bindings) {
+      let x = b.particles;
+    }
+  `;
+  let found: StructElem[] | undefined;
+  const config = {
+    plugins: [
+      bindingStructsPlugin(),
+      reportBindingStructsPlugin(report => (found = report)),
+    ],
+  };
+  linkTestOpts({ config }, src);
+
+  // verify struct found
+  expect(found).toBeDefined();
+  const s = found![0];
+  expect(s).toBeDefined();
+  expect(astToString(s)).toMatchInlineSnapshot(`
+    "struct Bindings
+      text 'struct '
+      decl %Bindings
+      text ' {
+          '
+      member @group @binding particles: ptr<storage, array<f32>, read_write>
+        attribute @group('0')
+          expression '0'
+            text '0'
+        text ' '
+        attribute @binding('0')
+          expression '0'
+            text '0'
+        text ' '
+        name particles
+        text ': '
+        type ptr<storage, array<f32>, read_write>
+          ref ptr
+          text '<'
+          type storage
+            ref storage
+          text ', '
+          type array<f32>
+            ref array
+            text '<'
+            type f32
+              ref f32
+            text '>'
+          text ', '
+          type read_write
+            ref read_write
+          text '>'
+      text ', 
+        }'"
+  `);
+  expect(s.bindingStruct).toBeTruthy();
+  expect((s as BindingStructElem).entryFn).toBeDefined();
+
+  // verify struct members
+  const members = s.members.filter(e => e.kind === "member");
+  const membersAst = members.map(e => astToString(e)).join("\n");
+  expect(membersAst).toMatchInlineSnapshot(
+    `
+    "member @group @binding particles: ptr<storage, array<f32>, read_write>
+      attribute @group('0')
+        expression '0'
+          text '0'
+      text ' '
+      attribute @binding('0')
+        expression '0'
+          text '0'
+      text ' '
+      name particles
+      text ': '
+      type ptr<storage, array<f32>, read_write>
+        ref ptr
+        text '<'
+        type storage
+          ref storage
+        text ', '
+        type array<f32>
+          ref array
+          text '<'
+          type f32
+            ref f32
+          text '>'
+        text ', '
+        type read_write
+          ref read_write
+        text '>'"
+  `,
+  );
+});
+
+test("binding struct to ts", () => {
+  const src = `
+    struct Uniforms {
+      foo: u32
+    }
+    struct MyBindings {
+      @group(0) @binding(0) particles: ptr<storage, array<f32>, read_write>, 
+      @group(0) @binding(1) uniforms: ptr<uniform, Uniforms>, 
+      @group(0) @binding(2) tex: texture_2d<f32>,
+      @group(0) @binding(3) samp: sampler,
+      @group(0) @binding(4) stTex: texture_storage_2d<rgba8unorm, read>,
+    }
+    @compute fn main(b: MyBindings) {
+      let x = b.particles;
+    }
+  `;
+  let found: StructElem[] | undefined;
+  const config = {
+    plugins: [
+      bindingStructsPlugin(),
+      reportBindingStructsPlugin(report => (found = report)),
+    ],
+  };
+  linkTestOpts({ config }, src);
+  const ts = bindingGroupLayoutTs(found![0] as BindingStructElem);
+  expect(ts).toMatchInlineSnapshot(`
+    "
+    const myBindingsEntries = [ 
+          {
+            binding: 0,
+            visibility: GPUShaderStage.COMPUTE,
+            buffer: { type: "storage" }
+          },
+          {
+            binding: 1,
+            visibility: GPUShaderStage.COMPUTE,
+            buffer: { type: "uniform" }
+          },
+          {
+            binding: 2,
+            visibility: GPUShaderStage.COMPUTE,
+            texture: { sampleType: "float" }
+          },
+          {
+            binding: 3,
+            visibility: GPUShaderStage.COMPUTE,
+            sampler: { type: "filtering" }
+          },
+          {
+            binding: 4,
+            visibility: GPUShaderStage.COMPUTE,
+            storageTexture: { format: "rgba8unorm", sampleType: "float", access: "read-only" }
+          } ];
+    function myBindingsLayout(device: GPUDevice): GPUBindGroupLayout {
+      return device.createBindGroupLayout({
+        entries: myBindingsEntries 
+      });
+    }
+
+    export const layoutFunctions = { myBindingsLayout };
+    export const layoutEntries = { myBindingsEntries };
+      "
+  `);
+});

package/src/test/ScopeWESL.test.ts

@@ -0,0 +1,462 @@
+import { expect, test } from "vitest";
+import { findValidRootDecls } from "../BindIdents.ts";
+import { scopeToString } from "../debug/ScopeToString.ts";
+import { parseWESL, WeslAST } from "../ParseWESL.ts";
+import { resetScopeIds } from "../Scope.ts";
+
+function testParseWESL(src: string): WeslAST {
+  resetScopeIds();
+  return parseWESL(src);
+}
+
+test("scope from simple fn", () => {
+  const src = `
+    fn main() {
+      var x: i32 = 1;
+    }
+  `;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %main 
+        { %x i32 } #2
+      } #1
+    } #0"
+  `);
+});
+
+test("scope from fn with reference", () => {
+  const src = `
+    fn main() {
+      var x: i32 = 1;
+      x++;
+    }
+  `;
+  const { rootScope } = testParseWESL(src);
+
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %main 
+        { %x i32 x } #2
+      } #1
+    } #0"
+  `);
+});
+
+test("two fns", () => {
+  const src = `
+    fn foo() {}
+    fn bar() {}
+  `;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %foo 
+        {  } #2
+      } #1
+      -{ %bar 
+        {  } #5
+      } #4
+    } #0"
+  `);
+});
+
+test("two fns, one with a decl", () => {
+  const src = `
+    fn foo() {
+      var a:u32;
+    }
+    fn bar() {}
+  `;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %foo 
+        { %a u32 } #2
+      } #1
+      -{ %bar 
+        {  } #5
+      } #4
+    } #0"
+  `);
+});
+
+test("fn ref", () => {
+  const src = `
+    fn foo() {
+      bar();
+    }
+    fn bar() {}
+  `;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %foo 
+        { bar } #2
+      } #1
+      -{ %bar 
+        {  } #5
+      } #4
+    } #0"
+  `);
+});
+
+test("struct", () => {
+  const src = `
+    struct A {
+      a: B,
+    }
+  `;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %A 
+      { B } #1
+    } #0"
+  `);
+});
+
+test("alias", () => {
+  const src = `
+    alias A = B;
+  `;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %A 
+      { B } #1
+    } #0"
+  `);
+});
+
+test("switch", () => {
+  const src = `
+    fn main() {
+      var code = 1u;
+      switch ( code ) {
+        case 5u: { if 1 > 0 { var x = 7;} }
+        default: { break; }
+      }
+    }`;
+  const { rootScope } = testParseWESL(src);
+
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %main 
+        { %code code 
+          { 
+            { %x } #5
+          } #4
+          {  } #6
+        } #2
+      } #1
+    } #0"
+  `);
+});
+
+test("for()", () => {
+  const src = `
+    fn main() {
+      var i = 1.0;
+      for (var i = 0; i < 10; i++) { }
+    }`;
+  const { rootScope } = testParseWESL(src);
+
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %main 
+        { %i 
+          { %i i i } #4
+        } #2
+      } #1
+    } #0"
+  `);
+});
+
+test("fn with param", () => {
+  const src = `
+    fn main(i: i32) {
+      var x = 10 + i;
+      for (var i = 0; i < x; i++) { }
+    }`;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %main 
+        { %i i32 %x i 
+          { %i i x i } #4
+        } #2
+      } #1
+    } #0"
+  `);
+});
+
+test("fn decl scope", () => {
+  const src = `
+    fn main(i: i32) {
+      var x = i;
+    }`;
+  const { rootScope } = testParseWESL(src);
+  const decls = findValidRootDecls(rootScope, {});
+  const mainIdent = decls[0];
+  expect(scopeToString(mainIdent.scope)).toMatchInlineSnapshot(
+    `"{ %i i32 %x i } #2"`,
+  );
+});
+
+test("builtin scope", () => {
+  const src = `fn main( @builtin(vertex_index) a: u32) { }`;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %main 
+        { %a u32 } #2
+      } #1
+    } #0"
+  `);
+});
+
+test("builtin enums", () => {
+  const src = `struct read { a: vec2f } var<storage, read_write> storage_buffer: read;`;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %read 
+      { vec2f } #1
+      storage read_write %storage_buffer read
+    } #0"
+  `);
+});
+
+test("texture_storage_2d", () => {
+  const src = `
+    @binding(3) @group(0) var tex_out : texture_storage_2d<rgba8unorm, write>;
+  `;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(
+    `"{ %tex_out texture_storage_2d rgba8unorm write } #0"`,
+  );
+});
+
+test("ptr 2 params", () => {
+  const src = `
+    fn foo(ptr: ptr<private, u32>) { }
+  `;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %foo 
+        { %ptr ptr private u32 } #2
+      } #1
+    } #0"
+  `);
+});
+
+test("ptr 3 params", () => {
+  const src = `
+    fn foo(ptr: ptr<storage, array<u32, 128>, read>) { }
+  `;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %foo 
+        { %ptr ptr storage array u32 read } #2
+      } #1
+    } #0"
+  `);
+});
+
+test("larger example", () => {
+  const src = `
+    struct UBO { width : u32, }
+
+    struct Buffer { weights : array<f32>, }
+
+    @binding(0) @group(0) var<uniform> ubo : UBO;
+    @binding(1) @group(0) var<storage, read> buf_in : Buffer;
+    @binding(2) @group(0) var<storage, read_write> buf_out : Buffer;
+    @binding(3) @group(0) var tex_in : texture_2d<f32>;
+    @binding(3) @group(0) var tex_out : texture_storage_2d<rgba8unorm, write>;
+
+    @compute @workgroup_size(64)
+    fn import_level(@builtin(global_invocation_id) coord : vec3u) {
+      _ = &buf_in;
+      let offset = coord.x + coord.y * ubo.width;
+      buf_out.weights[offset] = textureLoad(tex_in, vec2i(coord.xy), 0).w;
+    }
+
+    @compute @workgroup_size(64)
+    fn export_level(@builtin(global_invocation_id) coord : vec3u) {
+      if (all(coord.xy < vec2u(textureDimensions(tex_out)))) {
+        let dst_offset = coord.x    + coord.y    * ubo.width;
+        let src_offset = coord.x*2u + coord.y*2u * ubo.width;
+
+        let a = buf_in.weights[src_offset + 0u];
+        let b = buf_in.weights[src_offset + 1u];
+        let c = buf_in.weights[src_offset + 0u + ubo.width];
+        let d = buf_in.weights[src_offset + 1u + ubo.width];
+        let sum = dot(vec4f(a, b, c, d), vec4f(1.0));
+
+        buf_out.weights[dst_offset] = sum / 4.0;
+
+        let probabilities = vec4f(a, a+b, a+b+c, sum) / max(sum, 0.0001);
+        textureStore(tex_out, vec2i(coord.xy), probabilities);
+      }
+    }
+  `;
+
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %UBO 
+      { u32 } #1
+      %Buffer 
+      { array f32 } #2
+      uniform %ubo UBO storage read %buf_in Buffer storage 
+      read_write %buf_out Buffer %tex_in texture_2d f32 %tex_out 
+      texture_storage_2d rgba8unorm write 
+      -{ %import_level 
+        { %coord vec3u buf_in %offset coord coord ubo buf_out 
+          offset textureLoad tex_in vec2i coord} #4
+      } #3
+      -{ %export_level 
+        { %coord vec3u all coord vec2u textureDimensions tex_out
+           
+          { %dst_offset coord coord ubo %src_offset coord coord 
+            ubo %a buf_in src_offset %b buf_in src_offset %c 
+            buf_in src_offset ubo %d buf_in src_offset ubo %sum 
+            dot vec4f a b c d vec4f buf_out dst_offset sum 
+            %probabilities vec4f a a b a b c sum max sum 
+            textureStore tex_out vec2i coord probabilities} #9
+        } #7
+      } #6
+    } #0"
+  `);
+});
+
+test("scope with an attribute", () => {
+  const src = `
+    fn main() {
+      @if(foo){ }
+    }
+  `;
+  const { rootScope } = testParseWESL(src);
+
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %main 
+        { 
+           @if(foo) {  } #4
+        } #2
+      } #1
+    } #0"
+  `);
+});
+
+test("partial scope", () => {
+  const src = `
+    fn main() {
+      var x = 1;
+
+      @if(false) y = 2;
+    }
+  `;
+  const { rootScope } = testParseWESL(src);
+
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %main 
+        { %x 
+           @if(false) -{ y } #4
+        } #2
+      } #1
+    } #0"
+  `);
+});
+
+test("loop scope", () => {
+  const src = `
+    fn main() {
+      let a = 7;
+      loop {
+        let a = 1;
+        continuing {
+          let a = 2;
+        }
+      }
+    }
+  `;
+  const { rootScope } = testParseWESL(src);
+
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %main 
+        { %a 
+          { %a 
+            { %a } #5
+          } #4
+        } #2
+      } #1
+    } #0"
+  `);
+});
+
+test("nested scope test", () => {
+  const src = `
+    fn main() {
+      let bar = 72;
+      if (true) {
+        if (true) {
+          let new_bar = bar; // Should be 72!
+        }
+        let bar = 5;
+      }
+    }
+  `;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ 
+      -{ %main 
+        { %bar 
+          { 
+            { %new_bar bar } #5
+            %bar
+          } #4
+        } #2
+      } #1
+    } #0"
+  `);
+});
+
+test("@if fn", () => {
+  const src = `
+    const loc = 0;
+
+    @if(true) @fragment
+    fn fragmentMain(@location(0) p: vec3f) -> @location(loc) vec4f { 
+      let x = p;
+    }
+  `;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %loc 
+      {  } #1
+       @if(true) -{ %fragmentMain loc 
+        { %p vec3f vec4f %x p } #3
+      } #2
+    } #0"
+  `);
+});
+
+test.skip("@if const", () => {
+  const src = `
+    @if(true) const a = 0;
+  `;
+  const { rootScope } = testParseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot("tbd");
+});
+
+// test("", () => {
+//   const src = `
+//   `;
+//   const { rootScope } = testParseWESL(src);
+
+//   expect(scopeToString(rootScope)).toMatchInlineSnapshot('tbd');
+
+// });