wesl 0.7.26 → 0.7.28

package/src/test/ParseComments.test.ts

@@ -10,13 +10,9 @@ test("parse fn with line comment", () => {
   const parsed = parseWESL(src);
   expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       fn binaryOp()
         decl %binaryOp
-        statement
-          text '{ // binOpImpl
-        }'"
+        block inner['// binOpImpl']"
   `);
 });
 
@@ -28,8 +24,240 @@ test("parse empty line comment", () => {
 });
 
 test("parse line comment with #replace", () => {
-  const src = ` 
+  const src = `
   const workgroupThreads= 4;                          // #replace 4=workgroupThreads
   `;
   expectNoLog(() => parseWESL(src));
 });
+
+test("attach leading and trailing comments to a statement", () => {
+  const src = `
+    fn f() {
+      // leading
+      let x = 1; // trailing
+    }`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      fn f()
+        decl %f
+        block
+          let %x before['// leading'] after['// trailing']
+            typeDecl %x
+              decl %x
+            literal literal(1)"
+  `);
+});
+
+test("split comments between two statements", () => {
+  const src = `
+    fn f() {
+      let x = 1; // after x
+      // before y
+      let y = 2;
+    }`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      fn f()
+        decl %f
+        block
+          let %x after['// after x']
+            typeDecl %x
+              decl %x
+            literal literal(1)
+          let %y before['// before y']
+            typeDecl %y
+              decl %y
+            literal literal(2)"
+  `);
+});
+
+test("attach a dangling comment before the closing brace", () => {
+  const src = `
+    fn f() {
+      let x = 1;
+      // dangling
+    }`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      fn f()
+        decl %f
+        block
+          let %x after['// dangling']
+            typeDecl %x
+              decl %x
+            literal literal(1)"
+  `);
+});
+
+test("preserve a blank line above a module declaration comment", () => {
+  const src = `const x = 1;
+
+// y comment
+const y = 2;`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      const %x
+        typeDecl %x
+          decl %x
+        literal literal(1)
+      const %y before['// y comment'(blank)]
+        typeDecl %y
+          decl %y
+        literal literal(2)"
+  `);
+});
+
+test("attach a nested block comment", () => {
+  const src = `
+    fn f() {
+      /* outer /* inner */ outer */
+      let x = 1;
+    }`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      fn f()
+        decl %f
+        block
+          let %x before['/* outer /* inner */ outer */']
+            typeDecl %x
+              decl %x
+            literal literal(1)"
+  `);
+});
+
+test("attach a multi-line block comment", () => {
+  const src = `
+    fn f() {
+      /* one
+         two */
+      let x = 1;
+    }`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      fn f()
+        decl %f
+        block
+          let %x before['/* one
+             two */']
+            typeDecl %x
+              decl %x
+            literal literal(1)"
+  `);
+});
+
+test("attach a leading comment to a control-flow statement", () => {
+  const src = `
+    fn f() {
+      // before if
+      if true { }
+      // before for
+      for (var i = 0; i < 1; i++) { }
+    }`;
+  const parsed = parseWESL(src);
+  const out = astToString(parsed.moduleElem);
+  expect(out).toContain("if before['// before if']");
+  expect(out).toContain("for before['// before for']");
+});
+
+test("keep a comment between switch clauses", () => {
+  const src = `
+    fn f() {
+      switch 0 {
+        case 0: { }
+        // between clauses
+        default: { }
+      }
+    }`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      fn f()
+        decl %f
+        block
+          switch
+            literal literal(0)
+            switch-clause
+              literal literal(0)
+              block
+            switch-clause before['// between clauses']
+              block"
+  `);
+});
+
+test("attach a comment before 'else if' to the else branch", () => {
+  // The else-if branch starts at the 'else' keyword, so a leading comment falls
+  // in the gap and leads the branch instead of being swallowed by its condition.
+  const src = `
+    fn f() {
+      if (a) { }
+      // before else
+      else if (b) { }
+    }`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toContain(
+    "if before['// before else']",
+  );
+});
+
+test("attach an inline comment to the following call argument", () => {
+  const src = `const x = max(1, /* big */ 2);`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      const %x
+        typeDecl %x
+          decl %x
+        call-expression call
+          ref max
+          literal literal(1)
+          literal literal(2) before['/* big */']"
+  `);
+});
+
+test("attach an inline comment hugging the previous call argument", () => {
+  const src = `const x = max(1 /* big */, 2);`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      const %x
+        typeDecl %x
+          decl %x
+        call-expression call
+          ref max
+          literal literal(1) after['/* big */']
+          literal literal(2)"
+  `);
+});
+
+test("attach an inline comment between binary operands", () => {
+  const src = `const x = 1 + /* mid */ 2;`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      const %x
+        typeDecl %x
+          decl %x
+        binary-expression binop(+)
+          literal literal(1)
+          literal literal(2) before['/* mid */']"
+  `);
+});
+
+test("attach a comment inside parentheses", () => {
+  const src = `const x = ( /* inner */ 1);`;
+  const parsed = parseWESL(src);
+  expect(astToString(parsed.moduleElem)).toMatchInlineSnapshot(`
+    "module
+      const %x
+        typeDecl %x
+          decl %x
+        parenthesized-expression parens
+          literal literal(1) before['/* inner */']"
+  `);
+});

package/src/test/ParseConditionsV2.test.ts

@@ -1,6 +1,12 @@
 import { expect, test } from "vitest";
 import { astToString } from "../debug/ASTtoString.ts";
-import { parseTest } from "./TestUtil.ts";
+import { parseTest, parseWESL } from "./TestUtil.ts";
+
+test("@if() with an empty condition is a parse error", () => {
+  // Past `@if(` the parser is committed: a missing condition must error rather
+  // than silently return null on a half-consumed stream.
+  expect(() => parseWESL("@if() fn a() {}")).toThrow(/Expected expression/);
+});
 
 test("parse complex condition", () => {
   const ast = parseTest("@if(true || (!foo&&!!false) )\nfn a() {}");
@@ -9,8 +15,7 @@ test("parse complex condition", () => {
       fn a() @if
         attribute @if(true || (!foo && !!false))
         decl %a
-        statement
-          text '{}'"
+        block"
   `);
 });
 
@@ -22,11 +27,8 @@ test("@if(false) enable f16", () => {
   const astString = astToString(ast.moduleElem);
   expect(astString).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       directive enable f16 @if
-      text '
-      '"
+        attribute @if(false)"
   `);
 });
 
@@ -38,13 +40,9 @@ test("@if(false) const_assert true;", () => {
   const astString = astToString(ast.moduleElem);
   expect(astString).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       assert
         attribute @if(false)
-        text ' const_assert true;'
-      text '
-      '"
+        literal literal(true)"
   `);
 });
 
@@ -56,16 +54,11 @@ test("@if(true) var x = 7", () => {
   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 '
-      '"
+        literal literal(7)"
   `);
 });
 
@@ -80,29 +73,17 @@ test("conditional statement", () => {
   const astString = astToString(ast.moduleElem);
   expect(astString).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       fn main()
         decl %main
-        statement
-          text '{
-          '
+        block
           var %x
-            text 'var '
             typeDecl %x
               decl %x
-            text ' = 1;'
-          text '
-          '
-          statement @if
+            literal literal(1)
+          assign @if
             attribute @if(true)
-            text ' '
             ref x
-            text ' = 2 ;'
-          text '
-        }'
-      text '
-      '"
+            literal literal(2)"
   `);
 });
 
@@ -118,28 +99,15 @@ test("compound statement", () => {
   const astString = astToString(ast.moduleElem);
   expect(astString).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       fn main()
         decl %main
-        statement
-          text '{
-          '
-          statement @if
+        block
+          block @if
             attribute @if(false)
-            text ' {
-            '
             let %x
-              text 'let '
               typeDecl %x
                 decl %x
-              text ' = 1;'
-            text '
-          }'
-          text '
-        }'
-      text '
-      '"
+              literal literal(1)"
   `);
 });
 
@@ -153,23 +121,14 @@ test("conditional local var", () => {
   const astString = astToString(ast.moduleElem);
   expect(astString).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       fn main()
         decl %main
-        statement
-          text '{
-          '
+        block
           var %x @if
             attribute @if(true)
-            text ' var '
             typeDecl %x
               decl %x
-            text ' = 1;'
-          text '
-        }'
-      text '
-      '"
+            literal literal(1)"
   `);
 });
 
@@ -181,16 +140,11 @@ test("@if(MOBILE) const x = 1", () => {
   const astString = astToString(ast.moduleElem);
   expect(astString).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       const %x @if
         attribute @if(MOBILE)
-        text ' const '
         typeDecl %x
           decl %x
-        text ' = 1;'
-      text '
-      '"
+        literal literal(1)"
   `);
 });
 
@@ -203,24 +157,16 @@ test("@else after @if", () => {
   const astString = astToString(ast.moduleElem);
   expect(astString).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       const %x @if
         attribute @if(false)
-        text ' const '
         typeDecl %x
           decl %x
-        text ' = 1;'
-      text '
-        '
+        literal literal(1)
       const %x @else
         attribute @else
-        text ' const '
         typeDecl %x
           decl %x
-        text ' = 2;'
-      text '
-      '"
+        literal literal(2)"
   `);
 });
 
@@ -233,28 +179,18 @@ test("@else with function", () => {
   const astString = astToString(ast.moduleElem);
   expect(astString).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       fn foo() @if
         attribute @if(DEBUG)
         decl %foo
-        statement
-          text '{'
-          statement
-            text ' return 1;'
-          text ' }'
-      text '
-        '
+        block
+          return
+            literal literal(1)
       fn foo() @else
         attribute @else
         decl %foo
-        statement
-          text '{'
-          statement
-            text ' return 2;'
-          text ' }'
-      text '
-      '"
+        block
+          return
+            literal literal(2)"
   `);
 });
 
@@ -269,31 +205,19 @@ test("@else with statement", () => {
   const astString = astToString(ast.moduleElem);
   expect(astString).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       fn main()
         decl %main
-        statement
-          text '{
-          '
+        block
           let %x @if
             attribute @if(A)
-            text ' let '
             typeDecl %x
               decl %x
-            text ' = 1.0;'
-          text '
-          '
+            literal literal(1.0)
           let %x @else
             attribute @else
-            text ' let '
             typeDecl %x
               decl %x
-            text ' = 2.0;'
-          text '
-        }'
-      text '
-      '"
+            literal literal(2.0)"
   `);
 });
 
@@ -308,37 +232,21 @@ test("@else compound statement", () => {
   const astString = astToString(ast.moduleElem);
   expect(astString).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       fn test()
         decl %test
-        statement
-          text '{
-          '
-          statement @if
+        block
+          block @if
             attribute @if(MOBILE)
-            text ' { '
             let %a
-              text 'let '
               typeDecl %a
                 decl %a
-              text ' = 1;'
-            text ' }'
-          text '
-          '
-          statement @else
+              literal literal(1)
+          block @else
             attribute @else
-            text ' { '
             let %a
-              text 'let '
               typeDecl %a
                 decl %a
-              text ' = 2;'
-            text ' }'
-          text '
-        }'
-      text '
-      '"
+              literal literal(2)"
   `);
 });
 
@@ -353,36 +261,19 @@ test("@else with struct member", () => {
   const astString = astToString(ast.moduleElem);
   expect(astString).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       struct Point
-        text 'struct '
         decl %Point
-        text ' {
-          '
         member @if x: f32
           attribute @if(DIMENSIONS_2)
-          text ' '
           name x
-          text ': '
           type f32
             ref f32
-        text ',
-          '
-        member @else x: vec3<ref f32>
+        member @else x: vec3<f32>
           attribute @else
-          text ' '
           name x
-          text ': '
-          type vec3<ref f32>
+          type vec3<f32>
             ref vec3
-            text '<'
-            ref f32
-            text '>'
-        text ',
-        }'
-      text '
-      '"
+            ref f32"
   `);
 });
 
@@ -395,11 +286,8 @@ test("@if with import", () => {
   // Expected output once grammar supports @if on imports:
   expect(astString).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       import package::debug; @if
-      text '
-      '"
+        attribute @if(DEBUG)"
   `);
 });
 
@@ -413,14 +301,10 @@ test("@else with import", () => {
   // Expected output once grammar supports @if/@else on imports:
   expect(astString).toMatchInlineSnapshot(`
     "module
-      text '
-        '
       import package::a; @if
-      text '
-        '
+        attribute @if(false)
       import package::b; @else
-      text '
-      '"
+        attribute @else"
   `);
 });
 
@@ -436,34 +320,22 @@ test("parse @else fn", () => {
   expect(astString).toMatchInlineSnapshot(
     `
     "module
-      text '
-        '
       fn testFn() @if
         attribute @if(FOO)
         decl %testFn
-        statement
-          text '{ '
+        block
           let %a
-            text 'let '
             typeDecl %a
               decl %a
-            text ' = 0;'
-          text ' }'
-      text '
-        '
+            literal literal(0)
       fn testFn() @else
         attribute @else
         decl %testFn
-        statement
-          text '{ '
+        block
           let %a
-            text 'let '
             typeDecl %a
               decl %a
-            text ' = 1;'
-          text ' }'
-      text '
-      '"
+            literal literal(1)"
   `,
   );
 });