wesl 0.6.0-pre2

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,21 @@
+import { or, parserToString, seq } from "mini-parse";
+import { expect, test } from "vitest";
+// import { weslRoot } from "../WESLGrammar.ts";
+
+test("print grammar", () => {
+  const p: any = or("a", "b", () => p);
+  const s = seq("a", "b", () => p);
+  const result = parserToString(s);
+  expect(result).toMatchInlineSnapshot(`
+    "collect
+      'a'
+      'b'
+      fn()
+        or
+          'a'
+          'b'
+          fn()
+            ->or
+    "
+  `);
+});

package/src/test/ScopeWESL.test.ts

@@ -0,0 +1,272 @@
+import { expect, test } from "vitest";
+import { parseWESL } from "../ParseWESL.ts";
+import { scopeToString } from "../debug/ScopeToString.ts";
+import { DeclIdent } from "../Scope.ts";
+
+test("scope from simple fn", () => {
+  const src = `
+    fn main() {
+      var x: i32 = 1;
+    }
+  `;
+  const { rootScope } = parseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %main
+      { %x, i32 }
+    }"
+  `);
+});
+
+test("scope from fn with reference", () => {
+  const src = `
+    fn main() {
+      var x: i32 = 1;
+      x++;
+    }
+  `;
+  const { rootScope } = parseWESL(src);
+  const scopeIdents = rootScope.idents.map(i => i.originalName);
+  expect(scopeIdents).toEqual(["main"]);
+  const firstChildIdents = rootScope.children[0].idents.map(
+    i => i.originalName,
+  );
+  expect(firstChildIdents).toEqual(["x", "i32", "x"]);
+});
+
+test("two fns", () => {
+  const src = `
+    fn foo() {}
+    fn bar() {}
+  `;
+  const { rootScope } = parseWESL(src);
+  const scopeIdents = rootScope.idents.map(i => i.originalName);
+  expect(scopeIdents).toEqual(["foo", "bar"]);
+});
+
+test("two fns, one with a decl", () => {
+  const src = `
+    fn foo() {
+      var a:u32;
+    }
+    fn bar() {}
+  `;
+  const { rootScope } = parseWESL(src);
+  const scopeIdents = rootScope.idents.map(i => i.originalName);
+  expect(scopeIdents).toEqual(["foo", "bar"]);
+});
+
+test("fn ref", () => {
+  const src = `
+    fn foo() {
+      bar();
+    }
+    fn bar() {}
+  `;
+  const result = parseWESL(src);
+  const { children } = result.rootScope;
+  expect(children.length).toBe(2);
+  const firstChildIdents = children[0].idents.map(i => i.originalName);
+  expect(firstChildIdents).toEqual(["bar"]);
+});
+
+test("struct", () => {
+  const src = `
+    struct A {
+      a: B,
+    }
+  `;
+  const { rootScope } = parseWESL(src);
+  const scopeIdents = rootScope.idents.map(i => i.originalName);
+  expect(scopeIdents).toEqual(["A"]);
+
+  const { children } = rootScope;
+  expect(children.length).toBe(1);
+  const firstChildIdents = children[0].idents.map(i => i.originalName);
+  expect(firstChildIdents).toEqual(["B"]);
+});
+
+test("alias", () => {
+  const src = `
+    alias A = B;
+  `;
+  const { rootScope } = parseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %A
+      { B }
+    }"
+  `);
+});
+
+test("switch", () => {
+  const src = `
+    fn main() {
+      var code = 1u;
+      switch ( code ) {
+        case 5u: { if 1 > 0 { var x = 7;} }
+        default: { break; }
+      }
+    }`;
+  const { rootScope } = parseWESL(src);
+
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %main
+      { %code, code
+        { 
+          { %x }
+        }
+        {  }
+      }
+    }"
+  `);
+});
+
+test("for()", () => {
+  const src = `
+    fn main() {
+      var i = 1.0;
+      for (var i = 0; i < 10; i++) { }
+    }`;
+  const { rootScope } = parseWESL(src);
+
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %main
+      { %i
+        { %i, i, i }
+      }
+    }"
+  `);
+});
+
+test("fn with param", () => {
+  const src = `
+    fn main(i: i32) {
+      var x = 10 + i;
+      for (var i = 0; i < x; i++) { }
+    }`;
+  const { rootScope } = parseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %main
+      { %i, i32, %x, i
+        { %i, i, x, i }
+      }
+    }"
+  `);
+});
+
+test("fn decl scope", () => {
+  const src = `
+    fn main(i: i32) {
+      var x = i;
+    }`;
+  const { rootScope } = parseWESL(src);
+  const mainIdent = rootScope.idents[0] as DeclIdent;
+  expect(scopeToString(mainIdent.scope)).toMatchInlineSnapshot(
+    `"{ %i, i32, %x, i }"`,
+  );
+});
+
+test("builtin scope", () => {
+  const src = `fn main( @builtin(vertex_index) a: u32) { }`;
+  const { rootScope } = parseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %main
+      { %a, u32 }
+    }"
+  `);
+});
+
+test("texture_storage_2d", () => {
+  const src = `
+    @binding(3) @group(0) var tex_out : texture_storage_2d<rgba8unorm, write>;
+  `;
+  const { rootScope } = parseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`"{ %tex_out }"`);
+});
+
+test("ptr 2 params", () => {
+  const src = `
+    fn foo(ptr: ptr<private, u32>) { }
+  `;
+  const { rootScope } = parseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %foo
+      { %ptr, u32 }
+    }"
+  `);
+});
+
+test("ptr 3 params", () => {
+  const src = `
+    fn foo(ptr: ptr<storage, array<u32, 128>, read>) { }
+  `;
+  const { rootScope } = parseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %foo
+      { %ptr, array, u32 }
+    }"
+  `);
+});
+
+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 } = parseWESL(src);
+  expect(scopeToString(rootScope)).toMatchInlineSnapshot(`
+    "{ %UBO, %Buffer, %ubo, UBO, %buf_in, Buffer, %buf_out, 
+      Buffer, %tex_in, texture_2d, f32, %tex_out, %import_level, 
+      %export_level
+      { u32 }
+      { array, f32 }
+      { %coord, vec3u, buf_in, %offset, coord, coord, ubo, 
+        buf_out, offset, textureLoad, tex_in, vec2i, coord
+      }
+      { %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
+        }
+      }
+    }"
+  `);
+});

package/src/test/Slicer.test.ts

@@ -0,0 +1,103 @@
+import { SrcMap } from "mini-parse";
+import { expect, test } from "vitest";
+import { sliceReplace } from "../Slicer.js";
+
+test("slice middle", () => {
+  const src = "aaabbbc";
+  const srcMap = sliceReplace(src, [{ start: 3, end: 6, replacement: "X" }]);
+  const { dest, entries } = srcMap;
+  expect(dest).toBe("aaaXc");
+  expect(entries).toMatchInlineSnapshot(`
+    [
+      {
+        "destEnd": 3,
+        "destStart": 0,
+        "src": "aaabbbc",
+        "srcEnd": 3,
+        "srcStart": 0,
+      },
+      {
+        "destEnd": 4,
+        "destStart": 3,
+        "src": "aaabbbc",
+        "srcEnd": 6,
+        "srcStart": 3,
+      },
+      {
+        "destEnd": 5,
+        "destStart": 4,
+        "src": "aaabbbc",
+        "srcEnd": 7,
+        "srcStart": 6,
+      },
+    ]
+  `);
+});
+
+test("slice end", () => {
+  const src = "aaabbb";
+  const srcMap = sliceReplace(src, [{ start: 3, end: 6, replacement: "X" }]);
+  expect(srcMap.dest).toBe("aaaX");
+  validateDestCovered(srcMap);
+});
+
+test("slice beginning", () => {
+  const src = "aaabbb";
+  const srcMap = sliceReplace(src, [{ start: 0, end: 3, replacement: "X" }]);
+  validateDestCovered(srcMap);
+  expect(srcMap.dest).toBe("Xbbb");
+});
+
+test("slice multiple", () => {
+  const src = "aaabbbc";
+  const srcMap = sliceReplace(src, [
+    { start: 3, end: 6, replacement: "B" },
+    { start: 0, end: 3, replacement: "A" },
+  ]);
+  validateDestCovered(srcMap);
+  expect(srcMap.dest).toBe("ABc");
+  expect(srcMap.entries.length).toBe(3);
+});
+
+test("slice none", () => {
+  const src = "aaabbbc";
+  const srcMap = sliceReplace(src, []);
+  validateDestCovered(srcMap);
+  expect(srcMap.dest).toBe(src);
+});
+
+test("slice none with start and end", () => {
+  const src = "aaabbbc";
+  const srcMap = sliceReplace(src, [], 3, 6);
+  validateDestCovered(srcMap);
+  expect(srcMap.dest).toBe("bbb");
+});
+
+test("slice one with start and end", () => {
+  const src = "aaabbbc";
+
+  const slices = [{ start: 3, end: 6, replacement: "B" }];
+  const srcMap = sliceReplace(src, slices, 2);
+  validateDestCovered(srcMap);
+  expect(srcMap.dest).toBe("aBc");
+});
+
+test("slice with empty replacement", () => {
+  const src = "aaabbbc";
+
+  const slices = [{ start: 3, end: 6, replacement: "" }];
+  const srcMap = sliceReplace(src, slices);
+  validateDestCovered(srcMap);
+  expect(srcMap.dest).toBe("aaac");
+});
+
+/** verify that the srcMap covers every part of the destination text */
+function validateDestCovered(srcMap: SrcMap): void {
+  const { dest, entries } = srcMap;
+  let destPos = 0;
+  entries.forEach(e => {
+    expect(e.destStart).toBe(destPos);
+    destPos = e.destEnd;
+  });
+  expect(destPos).toBe(dest.length);
+}

package/src/test/TestSetup.ts

@@ -0,0 +1,4 @@
+import { enableTracing } from "mini-parse";
+
+// enable parser tracing features
+enableTracing();

package/src/test/TestUtil.ts

@@ -0,0 +1,52 @@
+import { _withBaseLogger, NoTags, Parser, TagRecord } from "mini-parse";
+import {
+  expectNoLog,
+  logCatch,
+  testParse,
+  TestParseResult,
+} from "mini-parse/test-util";
+import { linkWesl } from "../Linker.js";
+import { mainTokens } from "../WESLTokens.js";
+import { parseWESL, syntheticWeslParseState, WeslAST } from "../ParseWESL.js";
+
+export function testAppParse<T, N extends TagRecord = NoTags>(
+  parser: Parser<T, N>,
+  src: string,
+): TestParseResult<T, N, WeslAST> {
+  const appState = syntheticWeslParseState();
+  return testParse(parser, src, mainTokens, appState);
+}
+
+/** Convenience wrapper to link wgsl for tests.
+ * The first module is named "package::root",
+ * subsequent modules are named "package::file1", "package::file2", etc.
+ */
+export function link2Test(...rawWgsl: string[]): string {
+  const [root, ...rest] = rawWgsl;
+  const restWgsl = Object.fromEntries(
+    rest.map((src, i) => [`package::file${i + 1}`, src]),
+  );
+  const wesl = { "package::root": root, ...restWgsl };
+
+  const srcMap = linkWesl(wesl, "root");
+  return srcMap.dest;
+}
+
+/** link wesl for tests, and return the console log as well */
+export function linkWithLog(...rawWgsl: string[]): {
+  log: string;
+  result: string;
+} {
+  const { log, logged } = logCatch();
+  let result = "???";
+  _withBaseLogger(log, () => {
+    try {
+      result = link2Test(...rawWgsl);
+    } catch (e) {}
+  });
+  return { result, log: logged() };
+}
+
+export function parse2Test(src: string): WeslAST {
+  return expectNoLog(() => parseWESL(src, undefined, 500));
+}

package/src/test/Util.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from "vitest";
+import { overlapTail, scan } from "../Util.js";
+
+test("scan", () => {
+  const result = scan([1, 2, 1], (a, b: string) => b.slice(a), "foobar");
+  expect(result).toEqual(["foobar", "oobar", "bar", "ar"]);
+});
+
+test("overlap 0", () => {
+  const result = overlapTail([2, 3], [4, 5]);
+  expect(result).toBeUndefined();
+});
+
+test("overlap 1", () => {
+  const result = overlapTail([2, 3], [3, 4, 5]);
+  expect(result).toEqual([4, 5]);
+});
+
+test("overlap 2", () => {
+  const result = overlapTail([2, 3], [2, 3]);
+  expect(result).toEqual([]);
+});

package/src/test/__snapshots__/ParseDirectives.test.ts.snap

@@ -0,0 +1,25 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`parse import foo/bar 1`] = `
+[
+  {
+    "end": 14,
+    "imports": ImportTree {
+      "segments": [
+        SimpleSegment {
+          "args": undefined,
+          "as": undefined,
+          "name": "foo",
+        },
+        SimpleSegment {
+          "args": undefined,
+          "as": undefined,
+          "name": "bar",
+        },
+      ],
+    },
+    "kind": "treeImport",
+    "start": 0,
+  },
+]
+`;

package/src/test/__snapshots__/ParseWESL.test.ts.snap

@@ -0,0 +1,119 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`parse foo::bar();  1`] = `
+[
+  {
+    "calls": [
+      {
+        "end": 20,
+        "kind": "call",
+        "name": "foo::bar",
+        "start": 12,
+      },
+    ],
+    "end": 25,
+    "kind": "fn",
+    "name": "main",
+    "nameElem": {
+      "end": 7,
+      "kind": "fnName",
+      "name": "main",
+      "start": 3,
+    },
+    "start": 0,
+    "typeRefs": [],
+  },
+]
+`;
+
+exports[`parse let x: foo::bar;  1`] = `
+[
+  {
+    "calls": [],
+    "end": 34,
+    "kind": "fn",
+    "name": "main",
+    "nameElem": {
+      "end": 7,
+      "kind": "fnName",
+      "name": "main",
+      "start": 3,
+    },
+    "start": 0,
+    "typeRefs": [
+      {
+        "end": 27,
+        "kind": "typeRef",
+        "name": "foo::bar",
+        "start": 19,
+      },
+    ],
+  },
+]
+`;
+
+exports[`parse unicode ident 1`] = `
+"module
+  text '
+  '
+  fn Δέλτα()
+    text 'fn '
+    decl %Δέλτα
+    text '(){}'
+  text ' 
+  '
+  fn réflexion()
+    text 'fn '
+    decl %réflexion
+    text '(){}'
+  text ' 
+  '
+  fn Кызыл()
+    text 'fn '
+    decl %Кызыл
+    text '(){}'
+  text ' 
+  '
+  fn 𐰓𐰏𐰇()
+    text 'fn '
+    decl %𐰓𐰏𐰇
+    text '(){}'
+  text ' 
+  '
+  fn 朝焼け()
+    text 'fn '
+    decl %朝焼け
+    text '(){}'
+  text '
+  '
+  fn سلام()
+    text 'fn '
+    decl %سلام
+    text '(){}'
+  text ' 
+  '
+  fn 검정()
+    text 'fn '
+    decl %검정
+    text '(){}'
+  text ' 
+  '
+  fn שָׁלוֹם()
+    text 'fn '
+    decl %שָׁלוֹם
+    text '(){}'
+  text '
+  '
+  fn गुलाबी()
+    text 'fn '
+    decl %गुलाबी
+    text '(){}'
+  text '
+  '
+  fn փիրուզ()
+    text 'fn '
+    decl %փիրուզ
+    text '(){}'
+  text '
+  '"
+`;