wesl 0.6.0-pre10

package/src/test/WeslDevice.test.ts

@@ -0,0 +1,265 @@
+import { SrcMap } from "mini-parse";
+import { setTimeout } from "node:timers";
+import { expect, test, vi } from "vitest";
+import { LinkedWesl } from "../LinkedWesl";
+import { makeWeslDevice } from "../WeslDevice";
+
+test("WeslDevice doesn't conflict with uncapturederror", async () => {
+  const GPUDeviceMock = vi.fn(function (this: GPUDevice) {
+    let errorListener: EventListener;
+    this.createShaderModule = () => {
+      let errorEvent: Partial<GPUUncapturedErrorEvent> = {
+        error: {
+          message: "shader compilation failed",
+        },
+        defaultPrevented: false,
+      };
+      errorListener(errorEvent as any);
+      return {} as any;
+    };
+    this.pushErrorScope = () => {
+      throw new Error("Should not be called");
+    };
+    this.popErrorScope = () => {
+      throw new Error("Should not be called");
+    };
+    this.addEventListener = (type: string, listener: EventListener) => {
+      expect(type).toBe("uncapturederror");
+
+      errorListener = listener;
+    };
+  });
+  const device = makeWeslDevice(new GPUDeviceMock() as any);
+
+  const errorPromise = new Promise<GPUError>((resolve, reject) => {
+    const TIMEOUT = setTimeout(() => {
+      reject();
+    }, 1000);
+    device.addEventListener("uncapturederror", ev => {
+      clearTimeout(TIMEOUT);
+      resolve(ev.error);
+    });
+  });
+  const shader = device.createShaderModule({
+    code: "🐈",
+  });
+
+  const error = await errorPromise;
+
+  expect(error.message).toBe("shader compilation failed");
+});
+
+test("WeslDevice doesn't conflict with popErrorsScope", async () => {
+  const GPUDeviceMock = vi.fn(function (this: GPUDevice) {
+    this.createShaderModule = () => {
+      return {} as any;
+    };
+    this.pushErrorScope = () => {};
+    this.popErrorScope = () => {
+      return Promise.resolve({
+        message: ":1:1 shader compilation failed",
+      });
+    };
+  });
+  const device = makeWeslDevice(new GPUDeviceMock() as any);
+  const createShaderModuleSpy = vi.spyOn(device, "createShaderModule");
+  device.pushErrorScope("validation");
+  const shader = device.createShaderModule({
+    code: "🐈",
+  });
+  const errorPromise = new Promise<GPUError | null>((resolve, reject) => {
+    const TIMEOUT = setTimeout(() => {
+      reject();
+    }, 1000);
+    device.popErrorScope().then(v => {
+      clearTimeout(TIMEOUT);
+      resolve(v);
+    });
+  });
+
+  const error = await errorPromise;
+
+  expect(error).not.toBe(null);
+  expect(error?.message).toContain("shader compilation failed");
+  expect(error?.message).toContain(":1:1");
+  expect(createShaderModuleSpy).toHaveBeenCalledTimes(1);
+});
+
+test("LinkedWesl createShaderModule skips if it's not a WeslDevice", async () => {
+  const GPUDeviceMock = vi.fn(function (this: GPUDevice) {
+    this.createShaderModule = () => {
+      return {} as any;
+    };
+    this.pushErrorScope = () => {
+      throw new Error("Should not be called");
+    };
+    this.popErrorScope = () => {
+      throw new Error("Should not be called");
+    };
+    this.addEventListener = () => {
+      throw new Error("Should not be called");
+    };
+    this.createRenderPipeline = () => {
+      return null as any;
+    };
+  });
+  const device: GPUDevice = new GPUDeviceMock() as any;
+
+  const createShaderModuleSpy = vi.spyOn(device, "createShaderModule");
+  const linkedWesl = new LinkedWesl(
+    new SrcMap(
+      {
+        text: "cute generated code",
+      },
+      [],
+    ),
+  );
+
+  // Test that this doesnt' throw
+  linkedWesl.createShaderModule(device, {});
+
+  expect(createShaderModuleSpy).toHaveBeenCalledTimes(1);
+});
+
+test("Point at WESL code", async () => {
+  const GPUValidationErrorMock = vi.fn(function (this: any, message: string) {
+    this.message = message;
+  });
+  vi.stubGlobal("GPUValidationError", GPUValidationErrorMock);
+
+  const GPUDeviceMock = vi.fn(function (this: GPUDevice) {
+    this.createShaderModule = () => {
+      return {
+        getCompilationInfo(): Promise<GPUCompilationInfo> {
+          return Promise.resolve({
+            __brand: "GPUCompilationInfo",
+            messages: [
+              {
+                __brand: "GPUCompilationMessage",
+                type: "error",
+                offset: 0,
+                length: 4,
+                lineNum: 1,
+                linePos: 1,
+                message: "shader compilation failed",
+              },
+            ],
+          });
+        },
+      } as any;
+    };
+    this.pushErrorScope = () => {};
+    this.popErrorScope = () => {
+      return Promise.resolve({
+        message: "this message gets ignored",
+      });
+    };
+    this.dispatchEvent = () => {
+      throw new Error("Should not be called");
+    };
+  });
+  const device = makeWeslDevice(new GPUDeviceMock() as any);
+
+  const linkedWesl = new LinkedWesl(
+    new SrcMap(
+      {
+        text: "cute generated code",
+      },
+      [
+        {
+          src: {
+            text: "\ncute source code",
+            path: "main.wesl",
+          },
+          // Point at start of line 2
+          srcStart: 1,
+          srcEnd: 11,
+          destStart: 0,
+          destEnd: 10,
+        },
+      ],
+    ),
+  );
+
+  device.pushErrorScope("validation");
+  linkedWesl.createShaderModule(device, {});
+  let result = await device.popErrorScope();
+
+  // Expect that it's not the original, but instead the changed version
+  expect(result?.message).not.toContain("this message gets ignored");
+  expect(result?.message).not.toContain(":1:1");
+  expect(result?.message).toContain(":2:1");
+  expect(result?.message).toContain("shader compilation failed");
+
+  vi.unstubAllGlobals();
+});
+
+test("Invokes error throwing", async () => {
+  const GPUValidationErrorMock = vi.fn(function (this: any, message: string) {
+    this.message = message;
+  });
+  vi.stubGlobal("GPUValidationError", GPUValidationErrorMock);
+  const GPUUncapturedErrorEventMock = vi.fn(function () {});
+  vi.stubGlobal("GPUUncapturedErrorEvent", GPUUncapturedErrorEventMock);
+
+  const dispatchEventPromise = Promise.withResolvers();
+  const dispatchEventTimer = setTimeout(() => {
+    dispatchEventPromise.reject();
+  }, 500);
+  const GPUDeviceMock = vi.fn(function (this: GPUDevice) {
+    this.createShaderModule = () => {
+      return {
+        getCompilationInfo(): Promise<GPUCompilationInfo> {
+          return Promise.resolve({
+            __brand: "GPUCompilationInfo",
+            messages: [
+              {
+                __brand: "GPUCompilationMessage",
+                type: "error",
+                offset: 1,
+                length: 4,
+                lineNum: 1,
+                linePos: 2,
+                message: "shader compilation failed",
+              },
+            ],
+          });
+        },
+      } as any;
+    };
+    this.pushErrorScope = () => {};
+    this.popErrorScope = () => {
+      return Promise.resolve({
+        message: "this message gets ignored",
+      });
+    };
+    this.addEventListener = () => {};
+    this.dispatchEvent = () => {
+      clearTimeout(dispatchEventTimer);
+      dispatchEventPromise.resolve(true);
+      return true;
+    };
+  });
+  const device = makeWeslDevice(new GPUDeviceMock() as any);
+  const dispatchEventSpy = vi.spyOn(device, "dispatchEvent");
+  const injectErrorSpy = vi.spyOn(device, "injectError");
+
+  const linkedWesl = new LinkedWesl(
+    new SrcMap({
+      text: "cute generated code",
+    }),
+  );
+
+  linkedWesl.createShaderModule(device, {});
+
+  expect(injectErrorSpy).toHaveBeenCalledTimes(1);
+
+  await dispatchEventPromise.promise;
+  expect(dispatchEventSpy).toHaveBeenCalledTimes(1);
+
+  vi.unstubAllGlobals();
+});
+
+// LATER
+// Test injecterror
+// Test mapGPUCompilationInfo

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 Δέλτα()
+    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 '
+  '"
+`;