wesl 0.6.0-pre2

package/src/test/ImportCases.test.ts

@@ -0,0 +1,440 @@
+import { afterAll, expect, test } from "vitest";
+import { importCases } from "wesl-testsuite";
+import { linkWeslFiles } from "../Linker.js";
+import { matchTrimmed, trimSrc } from "./shared/StringUtil.js";
+
+/** so vitest triggers when this file changes */
+import("../../../../../wesl-testsuite/src/test-cases/ImportCases.js");
+
+interface LinkExpectation {
+  includes?: string[];
+  excludes?: string[];
+  linked?: string;
+}
+
+// wgsl example src, indexed by name
+const examplesByName = new Map(importCases.map(t => [t.name, t.src]));
+
+test("import ./bar/foo", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      fn main() {
+        foo();
+      }
+
+      fn foo() { }
+    `,
+  });
+});
+
+test("main has other root elements", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      struct Uniforms {
+        a: u32
+      }
+
+      @group(0) @binding(0) var<uniform> u: Uniforms;
+
+      fn main() { }
+    `,
+  });
+});
+
+test("import foo as bar", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      fn main() {
+        bar();
+      }
+
+      fn bar() { /* fooImpl */ }
+    `,
+  });
+});
+
+test("import twice doesn't get two copies", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      fn main() {
+        foo();
+        bar();
+      }
+
+      fn foo() { /* fooImpl */ }
+
+      fn bar() { foo(); }
+    `,
+  });
+});
+
+test("imported fn calls support fn with root conflict", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      fn main() { foo(); }
+
+      fn conflicted() { }
+
+      fn foo() {
+        conflicted0(0);
+        conflicted0(1);
+      }
+
+      fn conflicted0(a:i32) {}
+    `,
+  });
+});
+
+test("import twice with two as names", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      fn main() { bar(); bar(); }
+
+      fn bar() { }
+    `,
+  });
+});
+
+test("import transitive conflicts with main", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      fn main() {
+        mid();
+      }
+
+      fn grand() {
+        /* main impl */
+      }
+
+      fn mid() { grand0(); }
+
+      fn grand0() { /* grandImpl */ }
+    `,
+  });
+});
+
+test("multiple exports from the same module", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      fn main() {
+        foo();
+        bar();
+      }
+
+      fn foo() { }
+
+      fn bar() { }
+    `,
+  });
+});
+
+test("import and resolve conflicting support function", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      fn support() {
+        bar();
+      }
+
+      fn bar() {
+        support0();
+      }
+
+      fn support0() { }
+    `,
+  });
+});
+
+test("import support fn that references another import", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      fn support() {
+        foo();
+      }
+
+      fn foo() {
+        support0();
+        bar();
+      }
+
+      fn support0() { }
+
+      fn bar() {
+        support1();
+      }
+
+      fn support1() { }
+    `,
+  });
+});
+
+test("import support fn from two exports", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      fn main() {
+        foo();
+        bar();
+      }
+
+      fn foo() {
+        support();
+      }
+
+      fn bar() {
+        support();
+      }
+
+      fn support() { }
+    `,
+  });
+});
+
+test("import a struct", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      fn main() {
+        let a = AStruct(1u);
+      }
+
+      struct AStruct {
+        x: u32,
+      }
+    `,
+  });
+});
+
+test("struct referenced by a fn param", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+        fn main() { foo(); }
+
+        fn foo(a: AStruct) { 
+          let b = a.x;
+        }
+
+        struct AStruct {
+          x: u32
+        }
+    `,
+  });
+});
+
+test("import fn with support struct constructor", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      fn main() {
+        let ze = elemOne();
+      }
+
+      fn elemOne() -> Elem {
+        return Elem(1u);
+      }
+
+      struct Elem {
+        sum: u32
+      }
+    `,
+  });
+});
+
+test("import a transitive struct", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      struct SrcStruct {
+        a: AStruct,
+      }
+
+      struct AStruct {
+        s: BStruct,
+      }
+
+      struct BStruct {
+        x: u32,
+      }
+    `,
+  });
+});
+
+test("'import as' a struct", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      fn foo (a: AA) { }
+
+      struct AA { x: u32 }
+    `,
+  });
+});
+
+test("import a struct with name conflicting support struct", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      struct Base {
+        b: i32
+      }
+
+      fn foo() -> AStruct {var a:AStruct; return a;}
+
+      struct AStruct {
+        x: Base0
+      }
+
+      struct Base0 {
+        x: u32
+      }
+    `,
+  });
+});
+
+test("copy alias to output", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      alias MyType = u32;
+    `,
+  });
+});
+
+test("copy diagnostics to output", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+      diagnostic(off,derivative_uniformity);
+    `,
+  });
+});
+
+test("const referenced by imported fn", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+        fn main() { foo(); }
+
+        fn foo() {
+          let a = conA;
+        }
+
+        const conA = 7;
+    `,
+  });
+});
+
+test.skip("fn call with a separator", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+        fn main() { bar(); }
+
+        fn bar() { }
+    `,
+  });
+});
+
+test("local var to struct", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+        fn main() {
+          var a: AStruct; 
+        }
+        struct AStruct { x: u32 }
+    `,
+  });
+});
+
+test("global var to struct", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+        @group(0) @binding(0) var<uniform> u: Uniforms;      
+        struct Uniforms { model: mat4x4<f32> }
+    `,
+  });
+});
+
+test("return type of function", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+        fn b() -> A { }
+        struct A { y: i32 }
+    `,
+  });
+});
+
+test("import a const", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+        fn m() { let a = conA; }
+        const conA = 11;
+    `,
+  });
+});
+
+test("import an alias", ctx => {
+  linkTest2(ctx.task.name, {
+    linked: `
+        fn m() { let a: aliasA = 4; }
+        alias aliasA = u32;
+    `,
+  });
+});
+
+// test(, ctx => {
+//   linkTest2(ctx.task.name, {
+//     linked: `
+//     `,
+//   });
+// });
+
+// test(, ctx => {
+//   linkTest2(ctx.task.name, {
+//     linked: `
+//     `,
+//   });
+// });
+
+// test(, ctx => {
+//   linkTest2(ctx.task.name, {
+//     linked: `
+//     `,
+//   });
+// });
+
+// TODO add case for const_assert in non root module
+// TODO add case for diagnostic in non-root module (should fail?)
+
+afterAll(c => {
+  const testNameSet = new Set(c.tasks.map(t => t.name));
+  const cases = importCases.map(c => c.name);
+  const missing = cases.filter(name => !testNameSet.has(name));
+  if (missing.length) {
+    console.error("Missing tests for cases:", missing);
+    expect("missing test: " + missing.toString()).toBe("");
+  }
+});
+
+function linkTest2(name: string, expectation: LinkExpectation): void {
+  /* -- find and trim source texts -- */
+  const exampleSrc = examplesByName.get(name);
+  if (!exampleSrc) {
+    throw new Error(`Skipping test "${name}"\nNo example found.`);
+  }
+  const srcs = Object.entries(exampleSrc).map(([name, wgsl]) => {
+    const trimmedSrc = trimSrc(wgsl);
+    return [name, trimmedSrc] as [string, string];
+  });
+
+  const wesl = Object.fromEntries(srcs);
+
+  /* -- link -- */
+  const resultMap = linkWeslFiles(wesl, srcs[0][0]);
+  const result = resultMap.dest;
+
+  /* -- trim and verify results line by line -- */
+  const { linked, includes, excludes } = expectation;
+  if (linked !== undefined) {
+    matchTrimmed(result, linked);
+  }
+  if (includes !== undefined) {
+    includes.forEach(inc => {
+      expect(result).toContain(inc);
+    });
+  }
+  if (excludes !== undefined) {
+    excludes.forEach(exc => {
+      expect(result).not.toContain(exc);
+    });
+  }
+}

package/src/test/ImportSyntaxCases.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from "vitest";
+import { importSyntaxCases } from "wesl-testsuite";
+import { weslImport } from "../ImportGrammar.js";
+import { testAppParse } from "./TestUtil.js";
+
+function expectParseFail(src: string): void {
+  const result = testAppParse(weslImport, src);
+  expect(result.stable.imports).toEqual([]); // TODO tighten test, shouldn't parse
+}
+
+function expectParses(src: string): void {
+  const result = testAppParse(weslImport, src);
+  expect(result.stable.imports.length).toBeGreaterThan(0);
+}
+
+importSyntaxCases.forEach(c => {
+  if (c.fails) {
+    test(c.src, () => expectParseFail(c.src));
+  } else {
+    test(c.src, () => expectParses(c.src));
+  }
+});

package/src/test/LinkGlob.test.ts

@@ -0,0 +1,25 @@
+/// <reference types="vite/client" />
+import { expect, test } from "vitest";
+import { linkWeslFiles } from "../Linker.js";
+
+const wgsl1: Record<string, string> = import.meta.glob("./wgsl_1/*.wgsl", {
+  query: "?raw",
+  eager: true,
+  import: "default",
+});
+
+const wgsl2: Record<string, string> = import.meta.glob("./wgsl_2/*.wgsl", {
+  query: "?raw",
+  eager: true,
+  import: "default",
+});
+
+test("basic import glob", async () => {
+  const linked = linkWeslFiles(wgsl1, "wgsl_1/main");
+  expect(linked.dest).toContain("fn bar()");
+});
+
+test("#import from path ./util", async () => {
+  const linked = linkWeslFiles(wgsl2, "wgsl_2/main2");
+  expect(linked.dest).toContain("fn bar()");
+});

package/src/test/LinkPackage.test.ts

@@ -0,0 +1,26 @@
+import { expectNoLog } from "mini-parse/test-util";
+import { expect, test } from "vitest";
+import lib from "random_wgsl";
+import { linkWeslFiles } from "../Linker.ts";
+
+test("import rand() from a package", () => {
+  const src = `
+    import random_wgsl/pcg_2u_3f; 
+
+    struct Uniforms { frame: u32 }
+    @binding(0) @group(0) var<uniform> u: Uniforms;
+
+    @fragment
+    fn fragmentMain(@builtin(position) pos: vec4f) -> @location(0) vec4f {
+        let rand = pcg_2u_3f(vec2u(pos.xy) + u.frame);
+        return vec4(rand, 1f);
+    }
+  `;
+
+  const wgsl = { "./main.wesl": src };
+  const result = expectNoLog(() =>
+    linkWeslFiles(wgsl, "./main.wesl", {}, [lib]),
+  );
+  expect(result.dest).toContain("fn pcg_2u_3f");
+  expect(result.dest).not.toContain("sinRand");
+});

package/src/test/Linker.test.ts

@@ -0,0 +1,120 @@
+import { expect, test } from "vitest";
+import { link2Test } from "./TestUtil.js";
+import { matchTrimmed } from "./shared/StringUtil.js";
+import { dlog } from "berry-pretty";
+
+test("link global var", () => {
+  const src = `var x: i32 = 1;`;
+  const result = link2Test(src);
+  matchTrimmed(result, src);
+});
+
+test("link an alias", () => {
+  const src = `
+    alias Num = f32;
+
+    fn main() { Num(1.0); }
+  `;
+  const result = link2Test(src);
+  matchTrimmed(result, src);
+});
+
+test("link a const_assert", () => {
+  const src = `
+    var x = 1;
+    var y = 2;
+    const_assert x < y;
+  `;
+  const result = link2Test(src);
+  matchTrimmed(result, src);
+});
+
+test("link a struct", () => {
+  const src = `
+    struct Point {
+      x: i32,
+      y: i32,
+    }
+  `;
+  const result = link2Test(src);
+  matchTrimmed(result, src);
+});
+
+test("link a fn", () => {
+  const src = `
+    fn foo(x: i32, y: u32) -> f32 { 
+      return 1.0; 
+    }`;
+  const result = link2Test(src);
+  matchTrimmed(result, src);
+});
+
+test("handle a ptr type", () => {
+  const src = `
+    fn uint_bitfieldExtract_u1_i1_i1_(
+      value: ptr<function, u32>, 
+      bits: ptr<function, i32>) -> u32 { }
+  `;
+  const result = link2Test(src);
+  matchTrimmed(result, src);
+});
+
+test("struct after var", () => {
+  const src = `
+    var config: TwoPassConfig;
+
+    struct TwoPassConfig {
+      x: u32,
+    }
+  `;
+  const result = link2Test(src);
+  matchTrimmed(result, src);
+});
+
+test("type inside fn with same name as fn", () => {
+  // illegal but shouldn't hang
+  const src = `
+    fn foo() {
+      var a:foo;
+    }
+    fn bar() {}
+  `;
+  const result = link2Test(src);
+  matchTrimmed(result, src);
+});
+
+test("call cross reference", () => {
+  const src = `
+    fn foo() {
+      bar();
+    }
+
+    fn bar() {
+      foo();
+    }
+  `;
+
+  const result = link2Test(src);
+  matchTrimmed(result, src);
+});
+
+test("struct self reference", () => {
+  const src = `
+    struct A {
+      a: A,
+      b: B,
+    }
+    struct B {
+      f: f32,
+    }
+  `;
+
+  const result = link2Test(src);
+  matchTrimmed(result, src);
+});
+
+test("parse texture_storage_2d with texture format in typical type position", () => {
+  const src = `var t: texture_storage_2d<rgba8unorm, write>;`;
+  const result = link2Test(src);
+  matchTrimmed(result, src);
+});

package/src/test/MatchWgslD.test.ts

@@ -0,0 +1,16 @@
+import { matchingLexer } from "mini-parse";
+import { expect, test } from "vitest";
+import { mainTokens } from "../WESLTokens.js";
+
+test("lex #import foo", () => {
+  const lexer = matchingLexer(`#import foo`, mainTokens);
+  const tokens = [1, 2].map(lexer.next);
+  expect(tokens.map(t => t?.kind)).toEqual(["directive", "ident"]);
+});
+
+test("/* foo */", () => {
+  const lexer = matchingLexer(`/* foo */`, mainTokens);
+  const tokens = [1, 2, 3].map(lexer.next);
+  const tokenKinds = tokens.map(t => t?.kind);
+  expect(tokenKinds).toEqual(["symbol", "ident", "symbol"]);
+});

package/src/test/ParseComments.test.ts

@@ -0,0 +1,74 @@
+import { expectNoLog } from "mini-parse/test-util";
+
+import { expect, test } from "vitest";
+import { blockComment, lineComment } from "../CommentsGrammar.js";
+import { parseWESL } from "../ParseWESL.js";
+import { testAppParse } from "./TestUtil.js";
+import { astToString } from "../debug/ASTtoString.js";
+
+test("lineComment parse // foo bar", () => {
+  const src = "// foo bar";
+  const { position } = testAppParse(lineComment, src);
+  expect(position).toBe(src.length);
+});
+
+test("lineComment parse // foo bar \\n", () => {
+  const src = "// foo bar\n";
+  const { position } = testAppParse(lineComment, src);
+  expect(position).toBe(src.length);
+});
+
+test("blockComment parses /* comment */", () => {
+  const src = "/* comment */";
+  expectNoLog(() => {
+    const { parsed } = testAppParse(blockComment, src);
+    expect(parsed?.value).toMatchInlineSnapshot(`
+      [
+        "/*",
+        [
+          {
+            "kind": "ident",
+            "text": "comment",
+          },
+        ],
+        "*/",
+      ]
+    `);
+  });
+});
+
+test("skipBlockComment parses nested comment", () => {
+  const src = "/** comment1 /* comment2 */ */";
+  expectNoLog(() => testAppParse(blockComment, src));
+});
+
+test("parse fn with line comment", () => {
+  const src = `
+    fn binaryOp() { // binOpImpl
+    }`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      text '
+        '
+      fn binaryOp()
+        text 'fn '
+        decl %binaryOp
+        text '() { // binOpImpl
+        }'"
+  `);
+});
+
+test("parse empty line comment", () => {
+  const src = `
+  var workgroupThreads= 4;                          // 
+  `;
+  expectNoLog(() => parseWESL(src));
+});
+
+test("parse line comment with #replace", () => {
+  const src = ` 
+  const workgroupThreads= 4;                          // #replace 4=workgroupThreads
+  `;
+  expectNoLog(() => parseWESL(src));
+});