wesl 0.6.48 → 0.7.0

package/src/test/Expression.test.ts

@@ -1,22 +0,0 @@
-import { eof, seq } from "mini-parse";
-import { expect, test } from "vitest";
-import { expression } from "../parse/WeslExpression.ts";
-import { testAppParse } from "./TestUtil.ts";
-
-test("parse number", () => {
-  const src = "3";
-  const { parsed } = testAppParse(seq(expression, eof), src);
-  expect(parsed).not.toBeNull();
-});
-
-test("parse comparisons with && ||", () => {
-  const src = "a<3   &&   4>(5)";
-  const { parsed } = testAppParse(seq(expression, eof), src);
-  expect(parsed).not.toBeNull();
-});
-
-test("parse vec templated type", () => {
-  const src = "vec2<f32>";
-  const { parsed } = testAppParse(seq(expression, eof), src);
-  expect(parsed).not.toBeNull();
-});

package/src/test/ImportSyntaxCases.test.ts

@@ -1,24 +0,0 @@
-import { withLogSpy } from "mini-parse/test-util";
-import { expect, test } from "vitest";
-import { importSyntaxCases } from "wesl-testsuite";
-import { weslImports } from "../parse/ImportGrammar.ts";
-import { testAppParse } from "./TestUtil.ts";
-
-function expectParseFail(src: string): void {
-  withLogSpy(() => {
-    expect(() => testAppParse(weslImports, src)).toThrow(); // LATER catch specific error only
-  });
-}
-
-function expectParses(src: string): void {
-  const result = testAppParse(weslImports, 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/ParseError.test.ts

@@ -1,45 +0,0 @@
-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:13 error: Invalid token 🐈
-
-      if(1<1) { 🐈‍⬛ } else {  }
-                 ^^]
-  `);
-});
-
-test("parse invalid name", () => {
-  const src = "var package = 3;";
-  expect(() => parseTest(src)).toThrowErrorMatchingInlineSnapshot(`
-    [Error: ./test.wesl:1:4 error: expected identifier
-    var package = 3;
-       ^^^^^^^^]
-  `);
-});
-
-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
- ^`);
-});

package/src/test/Reflection.test.ts

@@ -1,176 +0,0 @@
-import { expect, test } from "vitest";
-import type { BindingStructElem, StructElem } from "../AbstractElems.ts";
-import { astToString } from "../debug/ASTtoString.ts";
-import {
-  bindingGroupLayoutTs,
-  reportBindingStructsPlugin,
-} from "../Reflection.ts";
-import { bindingStructsPlugin } from "../TransformBindingStructs.ts";
-import { linkTestOpts } from "./TestUtil.ts";
-
-test("extract binding struct", () => {
-  const src = `
-    struct Bindings {
-      @group(0) @binding(0) particles: ptr<storage, array<f32>, read_write>, 
-    }
-
-    @compute fn main(b: Bindings) {
-      let x = b.particles;
-    }
-  `;
-  let found: StructElem[] | undefined;
-  const config = {
-    plugins: [
-      bindingStructsPlugin(),
-      reportBindingStructsPlugin(report => {
-        found = report;
-      }),
-    ],
-  };
-  linkTestOpts({ config }, src);
-
-  // verify struct found
-  expect(found).toBeDefined();
-  const s = found?.[0] as StructElem;
-  expect(s).toBeDefined();
-  expect(astToString(s)).toMatchInlineSnapshot(`
-    "struct Bindings
-      text 'struct '
-      decl %Bindings
-      text ' {
-          '
-      member @group @binding particles: ptr<storage, array<f32>, read_write>
-        attribute @group('0')
-          expression '0'
-            text '0'
-        text ' '
-        attribute @binding('0')
-          expression '0'
-            text '0'
-        text ' '
-        name particles
-        text ': '
-        type ptr<storage, array<f32>, read_write>
-          ref ptr
-          text '<'
-          type storage
-            ref storage
-          text ', '
-          type array<f32>
-            ref array
-            text '<'
-            type f32
-              ref f32
-            text '>'
-          text ', '
-          type read_write
-            ref read_write
-          text '>'
-      text ', 
-        }'"
-  `);
-  expect(s.bindingStruct).toBeTruthy();
-  expect((s as BindingStructElem).entryFn).toBeDefined();
-
-  // verify struct members
-  const members = s.members.filter(e => e.kind === "member");
-  const membersAst = members.map(e => astToString(e)).join("\n");
-  expect(membersAst).toMatchInlineSnapshot(
-    `
-    "member @group @binding particles: ptr<storage, array<f32>, read_write>
-      attribute @group('0')
-        expression '0'
-          text '0'
-      text ' '
-      attribute @binding('0')
-        expression '0'
-          text '0'
-      text ' '
-      name particles
-      text ': '
-      type ptr<storage, array<f32>, read_write>
-        ref ptr
-        text '<'
-        type storage
-          ref storage
-        text ', '
-        type array<f32>
-          ref array
-          text '<'
-          type f32
-            ref f32
-          text '>'
-        text ', '
-        type read_write
-          ref read_write
-        text '>'"
-  `,
-  );
-});
-
-test("binding struct to ts", () => {
-  const src = `
-    struct Uniforms {
-      foo: u32
-    }
-    struct MyBindings {
-      @group(0) @binding(0) particles: ptr<storage, array<f32>, read_write>, 
-      @group(0) @binding(1) uniforms: ptr<uniform, Uniforms>, 
-      @group(0) @binding(2) tex: texture_2d<f32>,
-      @group(0) @binding(3) samp: sampler,
-      @group(0) @binding(4) stTex: texture_storage_2d<rgba8unorm, read>,
-    }
-    @compute fn main(b: MyBindings) {
-      let x = b.particles;
-    }
-  `;
-  let found: StructElem[] | undefined;
-  const config = {
-    plugins: [
-      bindingStructsPlugin(),
-      reportBindingStructsPlugin(report => {
-        found = report;
-      }),
-    ],
-  };
-  linkTestOpts({ config }, src);
-  const ts = bindingGroupLayoutTs(found?.[0] as BindingStructElem);
-  expect(ts).toMatchInlineSnapshot(`
-    "
-    const myBindingsEntries = [ 
-          {
-            binding: 0,
-            visibility: GPUShaderStage.COMPUTE,
-            buffer: { type: "storage" }
-          },
-          {
-            binding: 1,
-            visibility: GPUShaderStage.COMPUTE,
-            buffer: { type: "uniform" }
-          },
-          {
-            binding: 2,
-            visibility: GPUShaderStage.COMPUTE,
-            texture: { sampleType: "float" }
-          },
-          {
-            binding: 3,
-            visibility: GPUShaderStage.COMPUTE,
-            sampler: { type: "filtering" }
-          },
-          {
-            binding: 4,
-            visibility: GPUShaderStage.COMPUTE,
-            storageTexture: { format: "rgba8unorm", sampleType: "float", access: "read-only" }
-          } ];
-    function myBindingsLayout(device: GPUDevice): GPUBindGroupLayout {
-      return device.createBindGroupLayout({
-        entries: myBindingsEntries 
-      });
-    }
-
-    export const layoutFunctions = { myBindingsLayout };
-    export const layouts = { myBindingsEntries };
-      "
-  `);
-});

package/src/test/TransformBindingStructs.test.ts

@@ -1,238 +0,0 @@
-import { SrcMapBuilder } from "mini-parse";
-import { expectTrimmedMatch } from "mini-parse/vitest-util";
-import { expect, test } from "vitest";
-import { bindIdents } from "../BindIdents.ts";
-import { astToString } from "../debug/ASTtoString.ts";
-import { lowerAndEmit } from "../LowerAndEmit.ts";
-import { RecordResolver } from "../ModuleResolver.ts";
-import {
-  bindingStructsPlugin,
-  findRefsToBindingStructs,
-  lowerBindingStructs,
-  markBindingStructs,
-  transformBindingReference,
-  transformBindingStruct,
-} from "../TransformBindingStructs.ts";
-import { linkTestOpts, parseTest } from "./TestUtil.ts";
-
-test("markBindingStructs true", () => {
-  const src = `
-    struct Bindings {
-      @group(0) @binding(0) particles: ptr<storage, array<f32>, read_write>, 
-    }
-  `;
-
-  const ast = parseTest(src);
-  const structs = markBindingStructs(ast.moduleElem);
-  expect(structs.length).toBe(1);
-  expect(structs[0].bindingStruct).toBe(true);
-});
-
-test("markBindingStructs false", () => {
-  const src = `
-    struct Bindings {
-      particles: ptr<storage, array<f32>, read_write>, 
-    }
-  `;
-
-  const ast = parseTest(src);
-  const structs = markBindingStructs(ast.moduleElem);
-  expect(structs.length).toBe(0);
-});
-
-test("transformBindingStruct", () => {
-  const src = `
-    struct Bindings {
-      @group(0) @binding(0) particles: ptr<storage, array<f32>, read_write>, 
-    }
-  `;
-
-  const rootAst = parseTest(src);
-  bindIdents({ rootAst, resolver: new RecordResolver({}) });
-  const bindingStruct = markBindingStructs(rootAst.moduleElem)[0];
-  const newVars = transformBindingStruct(bindingStruct, new Set());
-
-  const srcBuilder = new SrcMapBuilder({ text: rootAst.srcModule.src });
-  lowerAndEmit({ srcBuilder, rootElems: newVars, conditions: {} });
-  const linked = SrcMapBuilder.build([srcBuilder]).dest.text;
-  expect(linked).toMatchInlineSnapshot(
-    `
-    "@group(0) @binding(0) var<storage, read_write> particles : array<f32>;
-    "
-  `,
-  );
-});
-
-test("findRefsToBindingStructs", () => {
-  const src = `
-    struct Bindings {
-      @group(0) @binding(0) particles: ptr<storage, array<f32>, read_write>, 
-    }
-    struct NotBindings { a: i32 }
-    var y: NotBindings;
-
-    fn main(b: Bindings) {
-      let x = b.particles;
-      let z = y.a;
-    }
-  `;
-
-  const rootAst = parseTest(src);
-  bindIdents({ rootAst, resolver: new RecordResolver({}) });
-  markBindingStructs(rootAst.moduleElem);
-  const found = findRefsToBindingStructs(rootAst.moduleElem);
-  expect(found.length).toBe(1);
-  const foundAst = astToString(found[0].memberRef);
-  expect(foundAst).toMatchInlineSnapshot(`
-    "memberRef b.particles
-      ref b
-      text '.'
-      name particles"
-  `);
-});
-
-test("transformBindingReference", () => {
-  const src = `
-    struct Bindings {
-      @group(0) @binding(0) particles: ptr<storage, array<f32>, read_write>, 
-    }
-    fn main(b: Bindings) {
-      let x = b.particles;
-    }
-  `;
-
-  const rootAst = parseTest(src);
-  bindIdents({ rootAst, resolver: new RecordResolver({}) });
-  const bindingStruct = markBindingStructs(rootAst.moduleElem)[0];
-  transformBindingStruct(bindingStruct, new Set());
-  const found = findRefsToBindingStructs(rootAst.moduleElem);
-  expect(found.length).toBe(1);
-  const { memberRef, struct } = found[0];
-  const synthElem = transformBindingReference(memberRef, struct);
-  const synthAst = astToString(synthElem);
-  expect(synthAst).toMatchInlineSnapshot(`"synthetic 'particles'"`);
-});
-
-test("lower binding structs", () => {
-  const src = `
-    struct Bindings {
-      @group(0) @binding(0) particles: ptr<storage, array<f32>, read_write>, 
-    }
-    fn main(b: Bindings) {
-      let x = b.particles;
-    }
-  `;
-
-  const expected = `
-@group(0) @binding(0) var<storage, read_write> particles : array<f32>;
-       
-    fn main() {
-      let x = particles;
-    }
-  `;
-  const rootAst = parseTest(src);
-  const { globalNames } = bindIdents({
-    rootAst,
-    resolver: new RecordResolver({}),
-  });
-  const tAst = { ...rootAst, globalNames, notableElems: {} };
-  const lowered = lowerBindingStructs(tAst);
-
-  const loweredAst = astToString(lowered.moduleElem);
-  expect(loweredAst).toMatchInlineSnapshot(`
-    "module
-      synthetic '@group(0) @binding(0) var<storage, read_write> particles : array<f32>;
-    '
-      text '
-        '
-      text '
-        '
-      fn main(b: Bindings)
-        decl %main
-        param
-        statement
-          text '{
-          let '
-          typeDecl %x
-            decl %x
-          text ' = '
-          memberRef b.particles
-            synthetic 'particles'
-          text ';
-        }'
-      text '
-      '"
-  `);
-
-  const srcBuilder = new SrcMapBuilder({ text: lowered.srcModule.src });
-  lowerAndEmit({
-    srcBuilder,
-    rootElems: [lowered.moduleElem],
-    conditions: {},
-    extracting: false,
-  });
-  const linked = SrcMapBuilder.build([srcBuilder]).dest.text;
-  expectTrimmedMatch(linked, expected);
-});
-
-test("lower binding structs with conflicting root name", async () => {
-  const src = `
-    struct Bindings {
-      @group(0) @binding(0) particles: ptr<storage, array<f32>, read_write>, 
-    }
-    const particles = 7;
-    fn main(b: Bindings) {
-      let x = b.particles;
-    }
-  `;
-
-  const expected = `
-@group(0) @binding(0) var<storage, read_write> particles0 : array<f32>;
-       
-    const particles = 7;
-    fn main() {
-      let x = particles0;
-    }
-  `;
-
-  const opts = { config: { plugins: [bindingStructsPlugin()] } };
-  const linked = await linkTestOpts(opts, src);
-  expectTrimmedMatch(linked, expected);
-});
-
-test("lower 5 bindings", async () => {
-  const src = `
-    struct Uniforms {
-      foo: u32
-    }
-
-    struct MyBindings {
-      @group(0) @binding(0) particles: ptr<storage, array<u32>, read_write>, 
-      @group(0) @binding(1) uniforms: ptr<uniform, Uniforms>, 
-      @group(0) @binding(2) tex: texture_2d<rgba8unorm>,
-      @group(0) @binding(3) samp: sampler,
-      @group(0) @binding(4) stTex: texture_storage_2d<rgba8unorm, read>,
-    }
-
-    @compute fn main(b: MyBindings) {
-      b.particles[0] = b.uniforms.foo;
-    }
-  `;
-
-  const expected = `
-@group(0) @binding(0) var<storage, read_write> particles : array<u32>;
-@group(0) @binding(1) var<uniform> uniforms : Uniforms;
-@group(0) @binding(2) var tex : texture_2d<rgba8unorm>;
-@group(0) @binding(3) var samp : sampler;
-@group(0) @binding(4) var stTex : texture_storage_2d<rgba8unorm, read>;
-
-    struct Uniforms { foo: u32 }
-    @compute fn main() {
-      particles[0] = uniforms.foo;
-    }
-`;
-
-  const opts = { config: { plugins: [bindingStructsPlugin()] } };
-  const linked = await linkTestOpts(opts, src);
-  expectTrimmedMatch(linked, expected);
-});