wesl 0.6.0-pre10

package/src/test/LinkGlob.test.ts

@@ -0,0 +1,25 @@
+/// <reference types="vite/client" />
+import { expect, test } from "vitest";
+import { link } 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 = await link({ weslSrc: wgsl1, rootModuleName: "wgsl_1/main" });
+  expect(linked.dest).toContain("fn bar()");
+});
+
+test("#import from path ./util", async () => {
+  const linked = await link({ weslSrc: wgsl2, rootModuleName: "wgsl_2/main2" });
+  expect(linked.dest).toContain("fn bar()");
+});

package/src/test/LinkPackage.test.ts

@@ -0,0 +1,26 @@
+import { expectNoLogAsync } from "mini-parse/test-util";
+import lib from "random_wgsl";
+import { expect, test } from "vitest";
+import { link } from "../Linker.ts";
+
+test("import rand() from a package", async () => {
+  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 weslSrc = { "./main.wesl": src };
+  const result = await expectNoLogAsync(async () =>
+    link({ weslSrc, rootModuleName: "./main.wesl", libs: [lib] }),
+  );
+  expect(result.dest).toContain("fn pcg_2u_3f");
+  expect(result.dest).not.toContain("sinRand");
+});

package/src/test/Linker.test.ts

@@ -0,0 +1,125 @@
+import { expectTrimmedMatch } from "mini-parse/vitest-util";
+import { test } from "vitest";
+import { linkTest } from "./TestUtil.js";
+
+test("link global var", async () => {
+  const src = `var x: i32 = 1;`;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("link an alias", async () => {
+  const src = `
+    alias Num = f32;
+
+    fn main() { Num(1.0); }
+  `;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("link a const_assert", async () => {
+  const src = `
+    var x = 1;
+    var y = 2;
+    const_assert x < y;
+  `;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("link a struct", async () => {
+  const src = `
+    struct Point {
+      x: i32,
+      y: i32,
+    }
+  `;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("link a fn", async () => {
+  const src = `
+    fn foo(x: i32, y: u32) -> f32 { 
+      return 1.0; 
+    }`;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("handle a ptr type", async () => {
+  const src = `
+    fn uint_bitfieldExtract_u1_i1_i1_(value: ptr<function, u32>, bits: ptr<function, i32>) -> u32 { }
+  `;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("struct after var", async () => {
+  const src = `
+    var config: TwoPassConfig;
+
+    struct TwoPassConfig { x: u32 }
+  `;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("type inside fn with same name as fn", async () => {
+  // illegal but shouldn't hang
+  const src = `
+    fn foo() {
+      var a:foo;
+    }
+    fn bar() {}
+  `;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("call cross reference", async () => {
+  const src = `
+    fn foo() {
+      bar();
+    }
+
+    fn bar() {
+      foo();
+    }
+  `;
+
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("struct self reference", async () => {
+  const src = `
+    struct A {
+      a: A,
+      b: B,
+    }
+    struct B { f: f32 }
+  `;
+
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("parse texture_storage_2d with texture format in typical type position", async () => {
+  const src = `var t: texture_storage_2d<rgba8unorm, write>;`;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});
+
+test("struct member ref with extra component_or_swizzle", async () => {
+  const src = `
+    struct C { p: P }
+    struct P { x: u32 }
+    fn foo(c: C) {
+      let a = c.p.x;
+    }
+ `;
+  const result = await linkTest(src);
+  expectTrimmedMatch(result, src);
+});

package/src/test/Mangling.test.ts

@@ -0,0 +1,45 @@
+import { expectTrimmedMatch } from "mini-parse/vitest-util";
+import { test } from "vitest";
+import { link } from "../Linker.ts";
+import { underscoreMangle } from "../Mangler.ts";
+import { linkTestOpts } from "./TestUtil.ts";
+
+test("underscoreMangle", async () => {
+  const main = `
+    import package::file1::bar;
+fn main() { bar(); }
+  `;
+  const file1 = `
+    fn bar() {};
+  `;
+
+  const linked = await linkTestOpts({ mangler: underscoreMangle }, main, file1);
+  const expected = `
+    fn main() { package_file1_bar(); }
+    fn package_file1_bar() {}
+  `;
+  expectTrimmedMatch(linked, expected);
+});
+
+test("underscoreMangle longer ident", async () => {
+  const main = `
+    import package::container::file1::bar;
+fn main() { bar(); }
+  `;
+  const file1 = `
+    fn bar() {};
+  `;
+  const weslSrc = { "./main.wesl": main, "./container/file1.wesl": file1 };
+
+  const linked = await link({
+    mangler: underscoreMangle,
+    weslSrc,
+    debugWeslRoot: "main",
+  });
+
+  const expected = `
+    fn main() { package_container_file1_bar(); }
+    fn package_container_file1_bar() {}
+  `;
+  expectTrimmedMatch(linked.dest, expected);
+});

package/src/test/ParseComments.test.ts

@@ -0,0 +1,36 @@
+import { expectNoLog } from "mini-parse/test-util";
+
+import { expect, test } from "vitest";
+import { astToString } from "../debug/ASTtoString.js";
+import { parseWESL } from "../ParseWESL.js";
+
+test("parse fn with line comment", () => {
+  const src = `
+    fn binaryOp() { // binOpImpl
+    }`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      text '
+        '
+      fn binaryOp()
+        decl %binaryOp
+        statement
+          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));
+});

package/src/test/ParseConditions.test.ts

@@ -0,0 +1,183 @@
+import { expect, test } from "vitest";
+import { astToString } from "../debug/ASTtoString.ts";
+import { parseTest } from "./TestUtil.ts";
+
+test("parse complex condition", () => {
+  const ast = parseTest("@if(true || (!foo&&!!false) )\nfn a() {}");
+  expect(astToString(ast.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      fn a() @if
+        attribute @if(true || (!foo && !!false))
+        decl %a
+        statement
+          text '{}'"
+  `);
+});
+
+test("@if(false) enable f16", () => {
+  const src = `
+    @if(false) enable f16;
+  `;
+  const ast = parseTest(src);
+  const astString = astToString(ast.moduleElem);
+  expect(astString).toMatchInlineSnapshot(`
+    "module
+      text '
+        '
+      attribute @if(false)
+      directive enable f16 @if
+      text '
+      '"
+  `);
+});
+
+test("@if(false) const_assert true;", () => {
+  const src = `
+    @if(false) const_assert true;
+  `;
+  const ast = parseTest(src);
+  const astString = astToString(ast.moduleElem);
+  expect(astString).toMatchInlineSnapshot(`
+    "module
+      text '
+        '
+      assert
+        attribute @if(false)
+        text ' const_assert true;'
+      text '
+      '"
+  `);
+});
+
+test("@if(true) var x = 7", () => {
+  const src = `
+    @if(true) var x = 7; 
+  `;
+  const ast = parseTest(src);
+  const astString = astToString(ast.moduleElem);
+  expect(astString).toMatchInlineSnapshot(`
+    "module
+      text '
+        '
+      gvar %x @if
+        attribute @if(true)
+        text ' var '
+        typeDecl %x
+          decl %x
+        text ' = 7;'
+      text ' 
+      '"
+  `);
+});
+
+test("conditional statement", () => {
+  const src = `
+    fn main() {
+      var x = 1;
+      @if(true) x = 2 ;
+    }
+  `;
+  const ast = parseTest(src);
+  const astString = astToString(ast.moduleElem);
+  expect(astString).toMatchInlineSnapshot(`
+    "module
+      text '
+        '
+      fn main()
+        decl %main
+        statement
+          text '{
+          '
+          var %x
+            text 'var '
+            typeDecl %x
+              decl %x
+            text ' = 1'
+          text ';
+          '
+          statement @if
+            attribute @if(true)
+            text ' '
+            ref x
+            text ' = 2 ;'
+          text '
+        }'
+      text '
+      '"
+  `);
+});
+
+test("compound statement", () => {
+  const src = `
+    fn main() {
+      @if(false) {
+        let x = 1;
+      }
+    }
+  `;
+  const ast = parseTest(src);
+  const astString = astToString(ast.moduleElem);
+  expect(astString).toMatchInlineSnapshot(`
+    "module
+      text '
+        '
+      fn main()
+        decl %main
+        statement
+          text '{
+          '
+          statement @if
+            attribute @if(false)
+            text ' {
+            let '
+            typeDecl %x
+              decl %x
+            text ' = 1;
+          }'
+          text '
+        }'
+      text '
+      '"
+  `);
+});
+
+test("conditional local var", () => {
+  const src = `
+    fn main() {
+      @if(true) var x = 1;
+    }
+  `;
+  const ast = parseTest(src);
+  const astString = astToString(ast.moduleElem);
+  expect(astString).toMatchInlineSnapshot(`
+    "module
+      text '
+        '
+      fn main()
+        decl %main
+        statement
+          text '{
+          '
+          statement @if
+            attribute @if(true)
+            text ' '
+            var %x
+              text 'var '
+              typeDecl %x
+                decl %x
+              text ' = 1'
+            text ';'
+          text '
+        }'
+      text '
+      '"
+  `);
+});
+
+// test("", () => {
+//   const src = `
+//   `;
+//   const ast = parseTest(src);
+//   const astString = astToString(ast.moduleElem);
+//   expect(astString).toMatchInlineSnapshot('tbd');
+// });

package/src/test/ParseError.test.ts

@@ -0,0 +1,36 @@
+import { expect, test } from "vitest";
+import { errorHighlight } from "../Util.ts";
+import { parseTest } from "./TestUtil.ts";
+
+test("parse fn foo() { invalid }", () => {
+  const src = "fn foo() { let }";
+  expect(() => parseTest(src)).toThrowErrorMatchingInlineSnapshot(`
+    [Error: ./test.wesl:1:15 error: invalid ident
+    fn foo() { let }
+                  ^]
+  `);
+});
+
+test("parse invalid if", () => {
+  const src = `fn foo() { 
+  let a = 3;
+  if(1<1) { 🐈‍⬛ } else {  }
+  }`;
+  expect(() => parseTest(src)).toThrowErrorMatchingInlineSnapshot(`
+    [Error: ./test.wesl:3:15 error: Invalid token 🐈
+
+      if(1<1) { 🐈‍⬛ } else {  }
+                   ^]
+  `);
+});
+
+test("error highlight", () => {
+  expect(errorHighlight("foo", [0, 2]).join("\n")).toBe(`foo
+^^`);
+  expect(errorHighlight("foo", [0, 1]).join("\n")).toBe(`foo
+^`);
+  expect(errorHighlight("foo", [0, 0]).join("\n")).toBe(`foo
+^`);
+  expect(errorHighlight("foo", [1, 2]).join("\n")).toBe(`foo
+ ^`);
+});