wesl 0.6.0-pre10

package/src/parse/ImportGrammar.ts

@@ -0,0 +1,157 @@
+import {
+  delimited,
+  fn,
+  opt,
+  or,
+  Parser,
+  preceded,
+  repeat,
+  repeatPlus,
+  req,
+  seq,
+  seqObj,
+  span,
+  Stream,
+  tagScope,
+  terminated,
+  tracing,
+  withSepPlus,
+  yes,
+} from "mini-parse";
+import type {
+  ImportCollection,
+  ImportElem,
+  ImportItem,
+  ImportSegment,
+  ImportStatement,
+} from "../AbstractElems.js";
+import { assertUnreachable } from "../Assertions.js";
+import { importElem } from "../WESLCollect.js";
+import { word } from "./WeslBaseGrammar.js";
+import { WeslToken } from "./WeslStream.js";
+
+function makeStatement(
+  segments: ImportSegment[],
+  finalSegment: ImportCollection | ImportItem,
+): ImportStatement {
+  return { kind: "import-statement", segments, finalSegment };
+}
+function makeSegment(name: string): ImportSegment {
+  return { kind: "import-segment", name };
+}
+function makeCollection(subtrees: ImportStatement[]): ImportCollection {
+  return {
+    kind: "import-collection",
+    subtrees,
+  };
+}
+function makeItem(name: string, as?: string): ImportItem {
+  return { kind: "import-item", name, as };
+}
+function prependSegments(
+  segments: ImportSegment[],
+  statement: ImportStatement,
+): ImportStatement {
+  statement.segments = segments.concat(statement.segments);
+  return statement;
+}
+
+// forward references for mutual recursion
+let import_collection: Parser<
+  Stream<WeslToken>,
+  ImportCollection
+> = null as any;
+
+const import_path_or_item: Parser<Stream<WeslToken>, ImportStatement> = seq(
+  word,
+  or(
+    preceded(
+      "::",
+      req(
+        or(
+          fn(() => import_collection),
+          fn(() => import_path_or_item),
+        ),
+        "invalid import, expected '{' or name",
+      ),
+    ),
+    preceded("as", req(word, "invalid alias, expected name")).map(v =>
+      makeItem("", v),
+    ),
+    yes().map(() => makeItem("")), // Optional
+  ),
+).map(([name, next]): ImportStatement => {
+  if (next.kind === "import-collection") {
+    return makeStatement([makeSegment(name)], next);
+  } else if (next.kind === "import-statement") {
+    return prependSegments([makeSegment(name)], next);
+  } else if (next.kind === "import-item") {
+    next.name = name;
+    return makeStatement([], next);
+  } else {
+    assertUnreachable(next);
+  }
+});
+
+import_collection = delimited(
+  "{",
+  withSepPlus(",", () => import_path_or_item).map(makeCollection),
+  req("}", "invalid import collection, expected }"),
+);
+
+const import_relative = or(
+  terminated("package", req("::", "invalid import, expected '::'")).map(v => [
+    makeSegment(v),
+  ]),
+  repeatPlus(
+    terminated("super", req("::", "invalid import, expected '::'")).map(
+      makeSegment,
+    ),
+  ),
+);
+
+const import_statement = span(
+  delimited(
+    "import",
+    seqObj({
+      relative: opt(import_relative),
+      collection_or_statement: req(
+        or(import_collection, import_path_or_item),
+        "invalid import, expected { or name",
+      ),
+    }).map(({ relative, collection_or_statement }): ImportStatement => {
+      if (collection_or_statement.kind === "import-statement") {
+        return prependSegments(relative ?? [], collection_or_statement);
+      } else {
+        return makeStatement(relative ?? [], collection_or_statement);
+      }
+    }),
+    req(";", "invalid import, expected ';'"),
+  ),
+).map(
+  (v): ImportElem => ({
+    kind: "import",
+    imports: v.value,
+    start: v.span[0],
+    end: v.span[1],
+  }),
+);
+
+/** parse a WESL style wgsl import statement. */
+export const weslImports: Parser<Stream<WeslToken>, ImportElem[]> = tagScope(
+  repeat(import_statement).ptag("owo").collect(importElem),
+);
+
+if (tracing) {
+  const names: Record<string, Parser<Stream<WeslToken>, unknown>> = {
+    import_collection,
+    import_path_or_item,
+    import_relative,
+    import_statement,
+    weslImports,
+  };
+
+  Object.entries(names).forEach(([name, parser]) => {
+    parser.setTraceName(name);
+  });
+}

package/src/parse/Keywords.ts

@@ -0,0 +1,26 @@
+// Use https://github.com/wgsl-tooling-wg/wgsl-spec to check this list in the future
+// I recommend checking whether a new list and the current list are equal
+
+/** https://www.w3.org/TR/WGSL/#keyword-summary */
+export const keywords =
+  `alias break case const const_assert continue continuing 
+  default diagnostic discard else enable false fn for if 
+  let loop override requires return struct switch true var while`.split(/\s+/);
+
+/** https://www.w3.org/TR/WGSL/#reserved-words */
+export const reservedWords =
+  `NULL Self abstract active alignas alignof as asm asm_fragment async attribute auto await 
+  become binding_array cast catch class co_await co_return co_yield coherent column_major 
+  common compile compile_fragment concept const_cast consteval constexpr constinit crate 
+  debugger decltype delete demote demote_to_helper do dynamic_cast 
+  enum explicit export extends extern external fallthrough filter final finally friend from fxgroup 
+  get goto groupshared highp impl implements import inline instanceof interface layout lowp 
+  macro macro_rules match mediump meta mod module move mut mutable 
+  namespace new nil noexcept noinline nointerpolation non_coherent noncoherent noperspective null nullptr 
+  of operator package packoffset partition pass patch pixelfragment precise precision premerge 
+  priv protected pub public readonly ref regardless register reinterpret_cast require resource restrict 
+  self set shared sizeof smooth snorm static static_assert static_cast std subroutine super 
+  target template this thread_local throw trait try type typedef typeid typename typeof 
+  union unless unorm unsafe unsized use using varying virtual volatile wgsl where with writeonly yield`.split(
+    /\s+/,
+  );

package/src/parse/WeslBaseGrammar.ts

@@ -0,0 +1,8 @@
+import { kind, or, withSepPlus } from "mini-parse";
+import { WeslTokenKind } from "./WeslStream";
+
+export const word = kind<WeslTokenKind>("word");
+export const keyword = kind<WeslTokenKind>("keyword");
+
+export const qualified_ident = withSepPlus("::", or(word, "package", "super")); // LATER consider efficiency (it's a pretty hot area of the grammar.)
+export const number = kind<WeslTokenKind>("number");

package/src/parse/WeslExpression.ts

@@ -0,0 +1,207 @@
+import {
+  collectArray,
+  delimited,
+  fn,
+  opt,
+  or,
+  Parser,
+  preceded,
+  repeat,
+  repeatPlus,
+  req,
+  seq,
+  Stream,
+  tagScope,
+  tokenOf,
+  tracing,
+  withSep,
+  withSepPlus,
+  yes,
+} from "mini-parse";
+import {
+  expressionCollect,
+  memberRefCollect,
+  nameCollect,
+  refIdent,
+  stuffCollect,
+  typeRefCollect,
+} from "../WESLCollect";
+import { number, qualified_ident, word } from "./WeslBaseGrammar";
+import { templateClose, templateOpen, WeslToken } from "./WeslStream";
+
+export const opt_template_list = opt(
+  seq(
+    templateOpen,
+    withSepPlus(",", () => template_parameter),
+    req(templateClose, "invalid template, expected '>'"),
+  ),
+);
+
+// prettier-ignore
+const template_elaborated_ident = seq(
+  qualified_ident.collect(refIdent),
+  opt_template_list
+);
+const literal = or("true", "false", number);
+const paren_expression = seq(
+  "(",
+  () => expression,
+  req(")", "invalid expression, expected ')'"),
+);
+
+const primary_expression = or(
+  literal,
+  paren_expression,
+  seq(template_elaborated_ident, opt(fn(() => argument_expression_list))),
+);
+export const component_or_swizzle = repeatPlus(
+  or(
+    preceded(".", word),
+    collectArray(
+      delimited(
+        "[",
+        () => expression,
+        req("]", "invalid expression, expected ']'"),
+      ),
+    ),
+  ),
+);
+// LATER Remove
+// prettier-ignore
+/** parse simple struct.member style references specially, for binding struct lowering */
+export const simple_component_reference = tagScope(
+  seq(
+    qualified_ident.collect(refIdent, "structRef"),
+    seq(".", word.collect(nameCollect, "component")),
+    opt(component_or_swizzle.collect(stuffCollect, "extra_components"))
+  ).collect(memberRefCollect)
+);
+const unary_expression: Parser<Stream<WeslToken>, any> = or(
+  seq(tokenOf("symbol", ["!", "&", "*", "-", "~"]), () => unary_expression),
+  or(
+    simple_component_reference,
+    seq(primary_expression, opt(component_or_swizzle)),
+  ),
+);
+const bitwise_post_unary = or(
+  // LATER I can skip template list discovery in these cases, because a&b<c cannot be a comparison. Must be a template
+  repeatPlus(seq("&", unary_expression)),
+  repeatPlus(seq("^", unary_expression)),
+  repeatPlus(seq("|", unary_expression)),
+);
+const multiplicative_operator = or("%", "*", "/");
+const additive_operator = or("+", "-");
+const shift_post_unary = (inTemplate: boolean) => {
+  const shift_left = seq("<<", unary_expression);
+  const shift_right = seq(">>", unary_expression);
+  const mul_add = seq(
+    repeat(seq(multiplicative_operator, unary_expression)),
+    repeat(
+      seq(
+        additive_operator,
+        unary_expression,
+        repeat(seq(multiplicative_operator, unary_expression)),
+      ),
+    ),
+  );
+  return inTemplate ?
+      or(shift_left, mul_add)
+    : or(shift_left, shift_right, mul_add);
+};
+const relational_post_unary = (inTemplate: boolean) => {
+  return seq(
+    shift_post_unary(inTemplate),
+    opt(
+      seq(
+        // '<' is unambiguous, since templates were already caught by the primary expression inside of the previous unary_expression!
+        inTemplate ?
+          tokenOf("symbol", ["<", "<=", "!=", "=="])
+        : tokenOf("symbol", [">", ">=", "<", "<=", "!=", "=="]),
+        // LATER I can skip template list discovery in this cases, because a>=b<c cannot be a comparison. Must be a template
+        unary_expression,
+        shift_post_unary(inTemplate),
+      ),
+    ),
+  );
+};
+
+/** The expression parser exists in two variants
+ * `true` is template-expression: Refuses to parse parse symbols like `&&` and `||`.
+ * `false` is maybe-template-expression: Does the template disambiguation.
+ */
+const expressionParser = (
+  inTemplate: boolean,
+): Parser<Stream<WeslToken>, any> => {
+  return seq(
+    unary_expression,
+    or(
+      bitwise_post_unary,
+      seq(
+        relational_post_unary(inTemplate),
+        inTemplate ?
+          // Don't accept || or && in template mode
+          yes()
+        : or(
+            repeatPlus(
+              seq("||", seq(unary_expression, relational_post_unary(false))),
+            ),
+            repeatPlus(
+              seq("&&", seq(unary_expression, relational_post_unary(false))),
+            ),
+            yes().map(() => []),
+          ),
+      ),
+    ),
+  );
+};
+
+let maybe_template = false;
+export const expression = expressionParser(maybe_template);
+let is_template = true;
+const template_arg_expression = expressionParser(is_template);
+
+// prettier-ignore
+const std_type_specifier = seq(
+  qualified_ident                   .collect(refIdent, "typeRefName"),
+  () => opt_template_list,
+)                                   .collect(typeRefCollect);
+
+// prettier-ignore
+export const type_specifier: Parser<Stream<WeslToken>,any> = tagScope(
+   std_type_specifier,
+)                                   .ctag("typeRefElem");
+
+/** a template_arg_expression with additional collection for parameters
+ * that are types like array<f32> vs. expressions like 1+2 */
+// prettier-ignore
+const template_parameter = or(
+  // LATER Remove this, it's wrong. This should instead be done by inspecting the syntax tree.
+  type_specifier.ctag("templateParam"),
+  template_arg_expression.collect(expressionCollect, "templateParam")
+);
+
+export const argument_expression_list = seq(
+  "(",
+  withSep(",", expression),
+  req(")", "invalid fn arguments, expected ')'"),
+);
+
+if (tracing) {
+  const names: Record<string, Parser<Stream<WeslToken>, unknown>> = {
+    argument_expression_list,
+    type_specifier,
+    opt_template_list,
+    template_elaborated_ident,
+    literal,
+    paren_expression,
+    primary_expression,
+    component_or_swizzle,
+    unary_expression,
+    expression,
+    template_arg_expression,
+  };
+
+  Object.entries(names).forEach(([name, parser]) => {
+    parser.setTraceName(name);
+  });
+}