wesl 0.6.49 → 0.7.1

package/src/parse/AttributeGrammar.ts

@@ -1,232 +0,0 @@
-import {
-  delimited,
-  fn,
-  opt,
-  or,
-  type Parser,
-  preceded,
-  repeatPlus,
-  req,
-  type Span,
-  type Stream,
-  seq,
-  span,
-  tagScope,
-  token,
-  tokenKind,
-  tokenOf,
-  yes,
-} from "mini-parse";
-import type {
-  BinaryExpression,
-  BinaryOperator,
-  ElifAttribute,
-  ElseAttribute,
-  ExpressionElem,
-  IfAttribute,
-  Literal,
-  ParenthesizedExpression,
-  TranslateTimeExpressionElem,
-  TranslateTimeFeature,
-  UnaryExpression,
-  UnaryOperator,
-} from "../AbstractElems.ts";
-import { specialAttribute } from "../WESLCollect.ts";
-import type { WeslToken } from "./WeslStream.ts";
-import { weslExtension } from "./WeslStream.ts";
-
-// Expression parsers for @if conditions - supports literals (true/false),
-// parenthesized expressions, translate-time features, and binary operators (&&, ||)
-const attribute_if_primary_expression: Parser<
-  Stream<WeslToken>,
-  Literal | ParenthesizedExpression | TranslateTimeFeature
-> = or(
-  tokenOf("keyword", ["true", "false"]).map(makeLiteral),
-  delimited(
-    token("symbol", "("),
-    fn(() => attribute_if_expression),
-    token("symbol", ")"),
-  ).map(makeParenthesizedExpression),
-  tokenKind("word").map(makeTranslateTimeFeature),
-);
-
-const attribute_if_unary_expression: Parser<
-  Stream<WeslToken>,
-  ExpressionElem
-> = or(
-  seq(
-    token("symbol", "!").map(makeUnaryOperator),
-    fn(() => attribute_if_unary_expression),
-  ).map(makeUnaryExpression),
-  attribute_if_primary_expression,
-);
-
-const attribute_if_expression: Parser<
-  Stream<WeslToken>,
-  ExpressionElem
-> = weslExtension(
-  seq(
-    attribute_if_unary_expression,
-    or(
-      repeatPlus(
-        seq(
-          token("symbol", "||").map(makeBinaryOperator),
-          req(
-            attribute_if_unary_expression,
-            "invalid expression, expected expression",
-          ),
-        ),
-      ),
-      repeatPlus(
-        seq(
-          token("symbol", "&&").map(makeBinaryOperator),
-          req(
-            attribute_if_unary_expression,
-            "invalid expression, expected expression",
-          ),
-        ),
-      ),
-      yes().map(() => []),
-    ),
-  ).map(makeRepeatingBinaryExpression),
-);
-
-/** Base parser for @if attributes without collection - use in seq() compositions */
-// prettier-ignore
-export const if_attribute_base = preceded(
-  seq("@", weslExtension("if")),
-  span(
-    delimited(
-      "(",
-      fn(() => attribute_if_expression),
-      seq(opt(","), ")"),
-    ),
-  ).map(makeTranslateTimeExpressionElem),
-)
-  .map(makeIfAttribute)
-  .ptag("attr_variant");
-
-/** Base parser for @elif attributes without collection - use in seq() compositions */
-// prettier-ignore
-export const elif_attribute_base = preceded(
-  seq("@", weslExtension("elif")),
-  span(
-    delimited(
-      "(",
-      fn(() => attribute_if_expression),
-      seq(opt(","), ")"),
-    ),
-  ).map(makeTranslateTimeExpressionElem),
-)
-  .map(makeElifAttribute)
-  .ptag("attr_variant");
-
-/** Base parser for @else attributes without collection - use in seq() compositions */
-// prettier-ignore
-export const else_attribute_base = preceded(
-  seq("@", weslExtension("else")),
-  yes,
-)
-  .map(makeElseAttribute)
-  .ptag("attr_variant");
-
-/** Collected parser for @if attributes - use standalone, not in seq() */
-// prettier-ignore
-export const if_attribute = tagScope(
-  if_attribute_base.collect(specialAttribute),
-);
-
-/** Collected parser for @elif attributes - use standalone, not in seq() */
-// prettier-ignore
-export const elif_attribute = tagScope(
-  elif_attribute_base.collect(specialAttribute),
-);
-
-/** Collected parser for @else attributes - use standalone, not in seq() */
-// prettier-ignore
-export const else_attribute = tagScope(
-  else_attribute_base.collect(specialAttribute),
-);
-
-// Helper functions
-function makeIfAttribute(param: TranslateTimeExpressionElem): IfAttribute {
-  return { kind: "@if", param };
-}
-
-function makeElifAttribute(param: TranslateTimeExpressionElem): ElifAttribute {
-  return { kind: "@elif", param };
-}
-
-function makeElseAttribute(): ElseAttribute {
-  return { kind: "@else" };
-}
-
-function makeTranslateTimeExpressionElem(args: {
-  value: ExpressionElem;
-  span: Span;
-}): TranslateTimeExpressionElem {
-  return {
-    kind: "translate-time-expression",
-    expression: args.value,
-    span: args.span,
-  };
-}
-
-function makeLiteral(token: WeslToken<"keyword" | "number">): Literal {
-  return {
-    kind: "literal",
-    value: token.text,
-    span: token.span,
-  };
-}
-
-function makeTranslateTimeFeature(
-  token: WeslToken<"word">,
-): TranslateTimeFeature {
-  return {
-    kind: "translate-time-feature",
-    name: token.text,
-    span: token.span,
-  };
-}
-
-function makeParenthesizedExpression(
-  expression: ExpressionElem,
-): ParenthesizedExpression {
-  return {
-    kind: "parenthesized-expression",
-    expression,
-  };
-}
-
-function makeUnaryOperator(token: WeslToken<"symbol">): UnaryOperator {
-  return { value: token.text as any, span: token.span };
-}
-
-function makeBinaryOperator(token: WeslToken<"symbol">): BinaryOperator {
-  return { value: token.text as any, span: token.span };
-}
-
-function makeUnaryExpression([operator, expression]: [
-  UnaryOperator,
-  ExpressionElem,
-]): UnaryExpression {
-  return { kind: "unary-expression", operator, expression };
-}
-
-function makeRepeatingBinaryExpression([start, repeating]: [
-  ExpressionElem,
-  [BinaryOperator, ExpressionElem][],
-]): ExpressionElem {
-  let result: ExpressionElem = start;
-  for (const [op, left] of repeating) {
-    const binaryExpression: BinaryExpression = {
-      kind: "binary-expression",
-      operator: op,
-      left: result,
-      right: left,
-    };
-    result = binaryExpression;
-  }
-  return result;
-}

package/src/parse/ImportGrammar.ts

@@ -1,195 +0,0 @@
-import {
-  delimited,
-  fn,
-  not,
-  opt,
-  or,
-  type Parser,
-  preceded,
-  repeat,
-  repeatPlus,
-  req,
-  type Stream,
-  seq,
-  seqObj,
-  span,
-  tagScope,
-  terminated,
-  tracing,
-  withSepPlus,
-  yes,
-} from "mini-parse";
-import type {
-  AttributeElem,
-  ElifAttribute,
-  ElseAttribute,
-  IfAttribute,
-  ImportCollection,
-  ImportElem,
-  ImportItem,
-  ImportSegment,
-  ImportStatement,
-} from "../AbstractElems.ts";
-import { assertUnreachable } from "../Assertions.ts";
-import { importElem } from "../WESLCollect.ts";
-import {
-  elif_attribute_base,
-  else_attribute_base,
-  if_attribute_base,
-} from "./AttributeGrammar.ts";
-import { keyword, word } from "./WeslBaseGrammar.ts";
-import type { WeslToken } from "./WeslStream.ts";
-
-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 segment_blacklist = or("super", "package", "import", "as");
-
-/** words allowed in an import segment (after the package:: or super::super:: part if any) */
-const packageWord = preceded(not(segment_blacklist), or(word, keyword));
-
-const import_path_or_item: Parser<Stream<WeslToken>, ImportStatement> = seq(
-  packageWord,
-  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
-  ),
-  // biome-ignore lint/suspicious/useIterableCallbackReturn: biome doesn't recognize assertUnreachable's never return type
-).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_base = 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 ';'"),
-);
-
-function wrapAttributes(
-  rawAttributes: (IfAttribute | ElifAttribute | ElseAttribute)[],
-): AttributeElem[] {
-  return rawAttributes.map(attribute => ({
-    kind: "attribute",
-    attribute,
-    contents: [],
-    start: 0,
-    end: 0,
-  }));
-}
-
-const import_statement = span(
-  seq(
-    repeat(or(if_attribute_base, elif_attribute_base, else_attribute_base)),
-    import_statement_base,
-  ),
-).map(({ value: [rawAttributes, imports], span }): ImportElem => {
-  const importElem: ImportElem = {
-    kind: "import",
-    imports,
-    start: span[0],
-    end: span[1],
-  };
-
-  if (rawAttributes.length > 0) {
-    return { ...importElem, attributes: wrapAttributes(rawAttributes) };
-  }
-  return importElem;
-});
-
-/** 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/WeslBaseGrammar.ts

@@ -1,11 +0,0 @@
-import { kind, or, withSepPlus } from "mini-parse";
-import type { WeslTokenKind } from "./WeslStream";
-
-export const word = kind<WeslTokenKind>("word");
-export const keyword = kind<WeslTokenKind>("keyword");
-
-export const qualified_ident = withSepPlus(
-  "::",
-  or(word, keyword, "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

@@ -1,231 +0,0 @@
-import {
-  collectArray,
-  delimited,
-  fn,
-  opt,
-  or,
-  type Parser,
-  preceded,
-  repeat,
-  repeatPlus,
-  req,
-  type Stream,
-  seq,
-  tagScope,
-  tokenOf,
-  tracing,
-  withSep,
-  withSepPlus,
-  yes,
-} from "mini-parse";
-import {
-  expressionCollect,
-  memberRefCollect,
-  nameCollect,
-  refIdent,
-  stuffCollect,
-  typeRefCollect,
-} from "../WESLCollect.ts";
-import { number, qualified_ident, word } from "./WeslBaseGrammar.ts";
-import { templateClose, templateOpen, type WeslToken } from "./WeslStream.ts";
-
-export const opt_template_list = opt(
-  seq(
-    templateOpen,
-    withSepPlus(",", () => template_parameter),
-    req(templateClose, "invalid template, expected '>'"),
-  ),
-);
-
-const other_address_space = or("private", "workgroup", "uniform", "function");
-
-const storage_address_space = seq(
-  "storage",
-  opt(seq(",", or("read", "read_write"))),
-);
-
-export const var_template_list = opt(
-  seq(
-    templateOpen,
-    or(storage_address_space, other_address_space),
-    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(() => []),
-            ),
-      ),
-    ),
-  );
-};
-
-const maybe_template = false;
-export const expression = expressionParser(maybe_template);
-const 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>> = {
-    opt_template_list,
-    other_address_space,
-    storage_address_space,
-    var_template_list,
-    template_elaborated_ident,
-    primary_expression,
-    literal,
-    paren_expression,
-    component_or_swizzle,
-    simple_component_reference,
-    unary_expression,
-    bitwise_post_unary,
-    multiplicative_operator,
-    additive_operator,
-    expression,
-    template_arg_expression,
-    std_type_specifier,
-    type_specifier,
-    template_parameter,
-    argument_expression_list,
-  };
-
-  Object.entries(names).forEach(([name, parser]) => {
-    parser.setTraceName(name);
-  });
-}