wesl 0.6.49 → 0.7.1

package/src/test/TestSetup.ts

@@ -1,4 +1,10 @@
-import { enableTracing } from "mini-parse";
+import { beforeEach } from "vitest";
+import { resetScopeIds } from "wesl";
+import { resetScopeIds as resetSourceScopeIds } from "../Scope.ts";
 
-// enable parser tracing features
-enableTracing();
+// Auto-reset scope IDs before each test for consistent output
+// Reset both source and built counters (nodebug tests alias wesl to dist-nodebug)
+beforeEach(() => {
+  resetScopeIds();
+  resetSourceScopeIds();
+});

package/src/test/TestUtil.ts

@@ -1,134 +1,104 @@
-import { type Parser, type Stream, withLoggerAsync } from "mini-parse";
-import {
-  expectNoLog,
-  logCatch,
-  type TestParseResult,
-  testParseWithStream,
-} from "mini-parse/test-util";
+import { expect } from "vitest";
 import { type BoundAndTransformed, RecordResolver, type SrcModule } from "wesl";
 import { bindAndTransform, type LinkParams, link } from "../Linker.ts";
-import {
-  parseSrcModule,
-  syntheticWeslParseState,
-  type WeslAST,
-} from "../ParseWESL.ts";
-import { WeslStream, type WeslToken } from "../parse/WeslStream.ts";
-import { resetScopeIds } from "../Scope.ts";
+import { withLoggerAsync } from "../Logging.ts";
+import { parseSrcModule, type WeslAST } from "../ParseWESL.ts";
+import { expectNoLog, logCatch } from "./LogCatcher.ts";
+import { stripWesl } from "./StripWesl.ts";
 
-/** Parse a single wesl file */
+export type LinkTestOpts = Pick<
+  LinkParams,
+  "conditions" | "libs" | "config" | "virtualLibs" | "constants" | "mangler"
+>;
+
+interface BindTestResult {
+  bound: BoundAndTransformed;
+  resolver: RecordResolver;
+}
+
+/** Compare WGSL/WESL by token sequence, ignoring whitespace. */
+export function expectTokenMatch(actual: string, expected: string): void {
+  expect(stripWesl(actual)).toBe(stripWesl(expected));
+}
+
+/** Parse a single wesl file. */
 export function parseWESL(src: string): WeslAST {
   const srcModule: SrcModule = {
-    modulePath: "package::test", // TODO this ought not be used outside of tests
+    modulePath: "package::test",
     debugFilePath: "./test.wesl",
     src,
   };
-
   return parseSrcModule(srcModule);
 }
 
-/** Parse a single wesl file, returning the parse state as well as the WeslAST */ // LATER get rid of this
-export function testAppParse<T>(
-  parser: Parser<Stream<WeslToken>, T>,
-  src: string,
-): TestParseResult<T, WeslAST> {
-  const appState = syntheticWeslParseState();
-  const stream = new WeslStream(src);
-  return testParseWithStream(parser, stream, appState);
-}
-
-/** Convenience wrapper to link wgsl for tests.
- * The first module is named "./test.wesl",
- * subsequent modules are named "./file1.wesl", "./file2.wesl", etc.
- */
+/** Link wesl for tests. First module is ./test.wesl, rest are ./file1.wesl, etc. */
 export async function linkTest(...rawWgsl: string[]): Promise<string> {
   return linkTestOpts({}, ...rawWgsl);
 }
 
-export type LinkTestOpts = Pick<
-  LinkParams,
-  "conditions" | "libs" | "config" | "virtualLibs" | "constants" | "mangler"
->;
-
-export async function linkTestOpts(
-  opts: LinkTestOpts,
-  ...rawWgsl: string[]
-): Promise<string> {
+export async function linkTestOpts(opts: LinkTestOpts, ...rawWgsl: string[]) {
   const weslSrc = makeTestBundle(rawWgsl);
-
-  const rootModuleName = "test";
-  const srcMap = await link({ weslSrc, rootModuleName, ...opts });
+  const srcMap = await link({ weslSrc, rootModuleName: "test", ...opts });
   return srcMap.dest;
 }
 
-/** Link wesl for tests, capturing console output */
-export async function linkWithLog(...rawWgsl: string[]): Promise<{
+interface LogResult {
   log: string;
   result: string;
-}> {
-  return linkWithLogInternal(rawWgsl);
 }
 
-/** Link wesl for tests, capturing console output and swallowing exceptions */
-export async function linkWithLogQuietly(...rawWgsl: string[]): Promise<{
-  log: string;
-  result: string;
-}> {
+/** Link wesl for tests, capturing console output. */
+export async function linkWithLog(...rawWgsl: string[]): Promise<LogResult> {
+  return linkWithLogInternal(rawWgsl, false);
+}
+
+/** Link wesl for tests, capturing console output and swallowing exceptions. */
+export async function linkWithLogQuietly(
+  ...rawWgsl: string[]
+): Promise<LogResult> {
   return linkWithLogInternal(rawWgsl, true);
 }
 
 async function linkWithLogInternal(
   rawWgsl: string[],
-  quiet = false,
-): Promise<{
-  log: string;
-  result: string;
-}> {
+  quiet: boolean,
+): Promise<LogResult> {
   const { log, logged } = logCatch();
   let result = "??";
   try {
-    result = await withLoggerAsync(log, async () => linkTest(...rawWgsl));
+    result = await withLoggerAsync(log, () => linkTest(...rawWgsl));
   } catch (e) {
     if (!quiet) console.error(e);
   }
   return { result, log: logged() };
 }
 
-/** Parse wesl for testing, ensuring no logged warnings */
+/** Parse wesl for testing, ensuring no logged warnings. */
 export function parseTest(src: string): WeslAST {
-  return expectNoLog(() => parseTestRaw(src));
+  return expectNoLog(() => parseWESL(src));
 }
 
-/** Parse wesl without log collection (for debugging) */
-export function parseTestRaw(src: string) {
+/** Parse wesl without log collection (for debugging). */
+export function parseTestRaw(src: string): WeslAST {
   return parseWESL(src);
 }
 
-interface BindTestResult {
-  bound: BoundAndTransformed;
-  resolver: RecordResolver;
-}
-
-/** Parse and bind wesl source for testing. Returns bound result and resolver for inspection. */
+/** Parse and bind wesl source for testing. Returns bound result and resolver. */
 export function bindTest(...rawWesl: string[]): BindTestResult {
-  resetScopeIds();
   const weslSrc = makeTestBundle(rawWesl);
-
   const resolver = new RecordResolver(weslSrc, {
     packageName: "package",
     debugWeslRoot: "test",
   });
-  const bound = bindAndTransform({
-    rootModuleName: "test",
-    resolver,
-  });
+  const bound = bindAndTransform({ rootModuleName: "test", resolver });
   return { bound, resolver };
 }
 
-/** Synthesize test file bundle. Root module is ./test.wesl, others are ./file1.wesl, ./file2.wesl, etc. */
+/** Synthesize test file bundle: ./test.wesl, ./file1.wesl, ./file2.wesl, etc. */
 function makeTestBundle(rawWgsl: string[]): Record<string, string> {
   const [root, ...rest] = rawWgsl;
-  const restWgsl = Object.fromEntries(
+  const restFiles = Object.fromEntries(
     rest.map((src, i) => [`./file${i + 1}.wesl`, src]),
   );
-  return { "./test.wesl": root, ...restWgsl };
+  return { "./test.wesl": root, ...restFiles };
 }

package/src/test/TrimmedMatch.ts

@@ -0,0 +1,40 @@
+import { expect } from "vitest";
+
+/**
+ * Trim source for test comparisons:
+ * - Remove blank lines
+ * - Remove leading and trailing white space
+ */
+export function trimSrc(src: string): string {
+  const rawLines = src.split("\n");
+  const trimmed = rawLines.map(l => l.trim());
+  const nonBlank = trimmed.filter(l => l !== "");
+  return nonBlank.join("\n");
+}
+
+/**
+ * Expect a match between two strings with blank lines and
+ * any consistent leading indent removed.
+ */
+export function expectTrimmedMatch(result: string, expected: string): void {
+  const resultTrimmed = trimSrc(result);
+  const expectTrimmed = trimSrc(expected);
+  if (resultTrimmed !== expectTrimmed) {
+    const expectLines = expectTrimmed.split("\n");
+    const resultLines = resultTrimmed.split("\n");
+    const len = Math.max(expectLines.length, resultLines.length);
+    for (let i = 0; i < len; i++) {
+      const diff = expectLines[i] !== resultLines[i];
+      if (diff) {
+        console.log(`...failed.  Line ${i + 1} differs:
+  expected: ${expectLines[i]}
+    actual: ${resultLines[i] ?? ""}`);
+        break;
+      }
+    }
+    console.log(
+      `\ntrimmed result:\n${resultTrimmed}\n\ntrimmed expected:\n${expectTrimmed}\n`,
+    );
+  }
+  expect(resultTrimmed).toBe(expectTrimmed);
+}

package/src/test/VirtualModules.test.ts

@@ -1,6 +1,7 @@
-import { expectTrimmedMatch } from "mini-parse/vitest-util";
-import { test } from "vitest";
+import { expect, test } from "vitest";
+import { link } from "../Linker.ts";
 import { linkTestOpts } from "./TestUtil.ts";
+import { expectTrimmedMatch } from "./TrimmedMatch.ts";
 
 test("simple virtual module", async () => {
   const src = `
@@ -35,3 +36,33 @@ test("virtual constants", async () => {
   `;
   expectTrimmedMatch(result, expected);
 });
+
+// WGSL reserved words (like 'common') are allowed in module paths per WESL spec.
+test("inline reference to virtual module with reserved word name", async () => {
+  const result = await link({
+    weslSrc: { "./main.wesl": "fn main() { let x = common::value; }" },
+    rootModuleName: "main",
+    virtualLibs: { common: () => "const value = 42;" },
+  });
+  expect(result.dest).toContain("const value = 42");
+});
+
+test("inline constant in array template param", async () => {
+  const src = `
+    fn main() {
+      var data: array<f32, constants::size>;
+    }
+  `;
+  const result = await linkTestOpts({ constants: { size: 4 } }, src);
+  expect(result).toContain("const size = 4");
+});
+
+test("function call with inline ref in template param", async () => {
+  const src = `
+    fn main() {
+      var data: array<f32, u32(constants::size)>;
+    }
+  `;
+  const result = await linkTestOpts({ constants: { size: 4 } }, src);
+  expect(result).toContain("const size = 4");
+});

package/src/test/WeslDevice.test.ts

@@ -1,7 +1,7 @@
 import { setTimeout } from "node:timers";
-import { SrcMap } from "mini-parse";
 import { expect, test, vi } from "vitest";
 import { LinkedWesl } from "../LinkedWesl";
+import { SrcMap } from "../SrcMap.ts";
 import { makeWeslDevice } from "../WeslDevice";
 
 test("WeslDevice doesn't conflict with uncapturederror", async () => {
@@ -199,7 +199,14 @@ test("Invokes error throwing", async () => {
     this.message = message;
   });
   vi.stubGlobal("GPUValidationError", GPUValidationErrorMock);
-  const GPUUncapturedErrorEventMock = vi.fn(() => {});
+  const GPUUncapturedErrorEventMock = vi.fn(function (
+    this: any,
+    type: string,
+    options: { error: GPUError },
+  ) {
+    this.type = type;
+    this.error = options.error;
+  });
   vi.stubGlobal("GPUUncapturedErrorEvent", GPUUncapturedErrorEventMock);
 
   const dispatchEventPromise = Promise.withResolvers();

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

@@ -0,0 +1,67 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`parse unicode ident 1`] = `
+"module
+  text '
+  '
+  fn Δέλτα()
+    decl %Δέλτα
+    statement
+      text '{}'
+  text ' 
+  '
+  fn réflexion()
+    decl %réflexion
+    statement
+      text '{}'
+  text ' 
+  '
+  fn Кызыл()
+    decl %Кызыл
+    statement
+      text '{}'
+  text ' 
+  '
+  fn 𐰓𐰏𐰇()
+    decl %𐰓𐰏𐰇
+    statement
+      text '{}'
+  text ' 
+  '
+  fn 朝焼け()
+    decl %朝焼け
+    statement
+      text '{}'
+  text '
+  '
+  fn سلام()
+    decl %سلام
+    statement
+      text '{}'
+  text ' 
+  '
+  fn 검정()
+    decl %검정
+    statement
+      text '{}'
+  text ' 
+  '
+  fn שָׁלוֹם()
+    decl %שָׁלוֹם
+    statement
+      text '{}'
+  text '
+  '
+  fn गुलाबी()
+    decl %गुलाबी
+    statement
+      text '{}'
+  text '
+  '
+  fn փիրուզ()
+    decl %փիրուզ
+    statement
+      text '{}'
+  text '
+  '"
+`;

package/src/test-util.ts

@@ -0,0 +1,7 @@
+export {
+  expectNoLog,
+  expectNoLogAsync,
+  logCatch,
+  withLogSpyAsync,
+} from "./test/LogCatcher.ts";
+export { expectTrimmedMatch, trimSrc } from "./test/TrimmedMatch.ts";