@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/ast/build/util/expression-kind-by-token-type-id-map.ts

@@ -0,0 +1,168 @@
+import { ExpressionKind } from "../../node/enum/expression-kind.ts";
+import { InternalScannerError } from "../../../scanner-error.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../../lezer/parser.terms.ts";
+
+export const expressionKindByTokenTypeId: Map<number, ExpressionKind> =
+  new Map();
+
+/**
+ * Map parsed token type ID to AST token type enum.
+ * Exhaustive switch statement to ensure all token type IDs are handled.
+ */
+Object.values(TokenTypeId).forEach((tokenTypeId) => {
+  switch (tokenTypeId) {
+    case TokenTypeId.AssignmentExpression:
+    case TokenTypeId.BinaryExpression:
+      expressionKindByTokenTypeId.set(
+        tokenTypeId,
+        ExpressionKind.BINARY,
+      );
+      break;
+    case TokenTypeId.UnaryExpression:
+      expressionKindByTokenTypeId.set(
+        tokenTypeId,
+        ExpressionKind.UNARY,
+      );
+      break;
+    case TokenTypeId.LengthofExpression:
+      expressionKindByTokenTypeId.set(
+        tokenTypeId,
+        ExpressionKind.LENGTHOF,
+      );
+      break;
+
+    case TokenTypeId.AlignedModifier:
+    case TokenTypeId.AggregateOutputValue:
+    case TokenTypeId.ArrayDefinition:
+    case TokenTypeId.ClassDefinition:
+    case TokenTypeId.ClassDeclaration:
+    case TokenTypeId.CompoundStatement:
+    case TokenTypeId.ComputedArrayDefinition:
+    case TokenTypeId.ComputedElementaryTypeDefinition:
+    case TokenTypeId.DoStatement:
+    case TokenTypeId.ElementaryTypeDefinition:
+    case TokenTypeId.ExpressionStatement:
+    case TokenTypeId.ForStatement:
+    case TokenTypeId.IfStatement:
+    case TokenTypeId.MapDeclaration:
+    case TokenTypeId.StringDefinition:
+    case TokenTypeId.SwitchStatement:
+    case TokenTypeId.WhileStatement:
+    case TokenTypeId.ArrayElementAccess:
+    case TokenTypeId.Base64StringLiteral:
+    case TokenTypeId.UtfStringLiteral:
+    case TokenTypeId.BitModifier:
+    case TokenTypeId.CaseClause:
+    case TokenTypeId.ClassId:
+    case TokenTypeId.ClassIdRange:
+    case TokenTypeId.ExtendedClassIdRange:
+    case TokenTypeId.ClassMemberAccess:
+    case TokenTypeId.DefaultClause:
+    case TokenTypeId.ElementaryType:
+    case TokenTypeId.ElementaryTypeOutputValue:
+    case TokenTypeId.ExpandableModifier:
+    case TokenTypeId.ExplicitArrayDimension:
+    case TokenTypeId.ImplicitArrayDimension:
+    case TokenTypeId.PartialArrayDimension:
+    case TokenTypeId.ExtendsModifier:
+    case TokenTypeId.LengthAttribute:
+    case TokenTypeId.MapDefinition:
+    case TokenTypeId.MapEntry:
+    case TokenTypeId.MultipleCharacterLiteral:
+    case TokenTypeId.Parameter:
+    case TokenTypeId.ParameterList:
+    case TokenTypeId.ParameterValueList:
+    case TokenTypeId.Specification:
+    case TokenTypeId._break:
+    case TokenTypeId._case:
+    case TokenTypeId._class:
+    case TokenTypeId._const:
+    case TokenTypeId._default:
+    case TokenTypeId._do:
+    case TokenTypeId._else:
+    case TokenTypeId._extends:
+    case TokenTypeId._for:
+    case TokenTypeId._if:
+    case TokenTypeId._switch:
+    case TokenTypeId._while:
+    case TokenTypeId.abstract:
+    case TokenTypeId.Addition:
+    case TokenTypeId.AlignmentBitCount8:
+    case TokenTypeId.AlignmentBitCount16:
+    case TokenTypeId.AlignmentBitCount32:
+    case TokenTypeId.AlignmentBitCount64:
+    case TokenTypeId.AlignmentBitCount128:
+    case TokenTypeId.aligned:
+    case TokenTypeId.Assignment:
+    case TokenTypeId.base64string:
+    case TokenTypeId.Base64StringLiteralCharacters:
+    case TokenTypeId.BinaryLiteral:
+    case TokenTypeId.bit:
+    case TokenTypeId.BitwiseAnd:
+    case TokenTypeId.BitwiseOr:
+    case TokenTypeId.BitwiseShiftLeft:
+    case TokenTypeId.BitwiseShiftRight:
+    case TokenTypeId.CloseBrace:
+    case TokenTypeId.CloseBracket:
+    case TokenTypeId.CloseParenthesis:
+    case TokenTypeId.Colon:
+    case TokenTypeId.Comma:
+    case TokenTypeId.Comment:
+    case TokenTypeId.computed:
+    case TokenTypeId.DecimalLiteral:
+    case TokenTypeId.Division:
+    case TokenTypeId.DoubleQuote:
+    case TokenTypeId.expandable:
+    case TokenTypeId.float:
+    case TokenTypeId.FloatingPointLiteral:
+    case TokenTypeId.HexadecimalLiteral:
+    case TokenTypeId.Identifier:
+    case TokenTypeId.int:
+    case TokenTypeId.IntegerLiteral:
+    case TokenTypeId.legacy:
+    case TokenTypeId.lengthof:
+    case TokenTypeId.LogicalAnd:
+    case TokenTypeId.LogicalOr:
+    case TokenTypeId.LookAhead:
+    case TokenTypeId.map:
+    case TokenTypeId.Modulus:
+    case TokenTypeId.MultipleCharacterLiteralCharacters:
+    case TokenTypeId.Multiplication:
+    case TokenTypeId.OpenBrace:
+    case TokenTypeId.OpenBracket:
+    case TokenTypeId.OpenParenthesis:
+    case TokenTypeId.Period:
+    case TokenTypeId.PostfixDecrement:
+    case TokenTypeId.PostfixIncrement:
+    case TokenTypeId.RangeOperator:
+    case TokenTypeId.reserved:
+    case TokenTypeId.RelationalEqual:
+    case TokenTypeId.RelationalGreaterThan:
+    case TokenTypeId.RelationalGreaterThanOrEqual:
+    case TokenTypeId.RelationalLessThan:
+    case TokenTypeId.RelationalLessThanOrEqual:
+    case TokenTypeId.RelationalNotEqual:
+    case TokenTypeId.Semicolon:
+    case TokenTypeId.SingleQuote:
+    case TokenTypeId.Subtraction:
+    case TokenTypeId.UnaryNegation:
+    case TokenTypeId.UnaryPlus:
+    case TokenTypeId.unsigned:
+    case TokenTypeId.utf16string:
+    case TokenTypeId.utf8list:
+    case TokenTypeId.utf8string:
+    case TokenTypeId.utfstring:
+    case TokenTypeId.UtfPrefix:
+    case TokenTypeId.UtfStringLiteralCharacters:
+    case TokenTypeId.Whitespace:
+      break;
+    default: {
+      const exhaustiveCheck: never = tokenTypeId;
+      throw new InternalScannerError(
+        "Unreachable code reached, tokenTypeId == " + exhaustiveCheck,
+      );
+    }
+  }
+});

package/src/ast/build/util/fetch-node.ts

@@ -0,0 +1,433 @@
+import getLogger, { debugEnabled } from "../../../util/logger.ts";
+import type { BuildContext } from "./build-context.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import { consumeAbstractNode } from "../consume/consume-abstract-node.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { InternalScannerError } from "../../../scanner-error.ts";
+import type { Token } from "../../node/token.ts";
+import {
+  isMissingError,
+  isToken,
+  isUnexpectedError,
+  type OneToManyList,
+  type OptionalNode,
+  type RequiredNode,
+  type ZeroToManyList,
+} from "../../util/types.ts";
+import type { AbstractStatement } from "../../node/abstract-statement.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+import { StatementKind } from "../../node/enum/statement-kind.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import type { NumberLiteral } from "../../node/number-literal.ts";
+import type { StringLiteral } from "../../node/string-literal.ts";
+import { MissingError } from "../../node/missing-error.ts";
+import { getLocationFromTextPosition } from "../../../util/location-utils.ts";
+import type { AbstractArrayDimension } from "../../node/abstract-array-dimension.ts";
+import type { ClassId } from "../../node/class-id.ts";
+import { ArrayDimensionKind } from "../../node/enum/array-dimension-kind.ts";
+import { ClassIdKind } from "../../node/enum/class-id-kind.ts";
+
+const logger = getLogger("fetchNode");
+
+function getRequestLogMessage(
+  requestedNodeKind?: number[] | number,
+  requestedSubKind?: number[] | number,
+): string {
+  const nodeKindStr = Array.isArray(requestedNodeKind)
+    ? requestedNodeKind.map((kind) => NodeKind[kind]).join(", ")
+    : requestedNodeKind !== undefined
+    ? NodeKind[requestedNodeKind]
+    : "any";
+  let message = ` for ${nodeKindStr}`;
+
+  if (requestedSubKind !== undefined) {
+    switch (requestedNodeKind) {
+      case NodeKind.TOKEN:
+        if (Array.isArray(requestedSubKind)) {
+          message += `, [${
+            requestedSubKind
+              .map((subKind) => TokenKind[subKind])
+              .join(", ")
+          }]`;
+          break;
+        }
+        message += `, ${TokenKind[requestedSubKind]}`;
+        break;
+      case NodeKind.STATEMENT:
+        if (Array.isArray(requestedSubKind)) {
+          message += `, [${
+            requestedSubKind
+              .map((subKind) => StatementKind[subKind])
+              .join(", ")
+          }]`;
+          break;
+        }
+        message += `, ${StatementKind[requestedSubKind]}`;
+        break;
+      case NodeKind.ARRAY_DIMENSION:
+        if (Array.isArray(requestedSubKind)) {
+          message += `, [${
+            requestedSubKind
+              .map((subKind) => ArrayDimensionKind[subKind])
+              .join(", ")
+          }]`;
+          break;
+        }
+        message += `, ${ArrayDimensionKind[requestedSubKind]}`;
+        break;
+      case NodeKind.CLASS_ID:
+        if (Array.isArray(requestedSubKind)) {
+          message += `, [${
+            requestedSubKind
+              .map((subKind) => ClassIdKind[subKind])
+              .join(", ")
+          }]`;
+          break;
+        }
+        message += `, ${ClassIdKind[requestedSubKind]}`;
+        break;
+      default:
+        throw new InternalScannerError(
+          `requestedSubKind matching not implemented for node kind: ${nodeKindStr}`,
+        );
+    }
+  }
+
+  return message;
+}
+
+function getNodeDetailsLogMessage(node: AbstractNode): string {
+  let message = "";
+  if (isToken(node)) {
+    message += ` ${node.text.replaceAll("\n", "\\n")}`;
+  } else if (node.nodeKind === NodeKind.IDENTIFIER) {
+    message += ` ${
+      (node as unknown as Identifier).name.replaceAll("\n", "\\n")
+    }`;
+  } else if (node.nodeKind === NodeKind.NUMBER_LITERAL) {
+    message += ` ${(node as unknown as NumberLiteral).value}`;
+  } else if (node.nodeKind === NodeKind.STRING_LITERAL) {
+    message += ` ${(node as unknown as StringLiteral).value}`;
+  }
+  return message;
+}
+
+function fetchAstNode<T extends AbstractNode>(
+  buildContext: BuildContext,
+  optional: boolean,
+  requestedNodeKind?: number[] | number,
+  requestedSubKind?: number[] | number,
+): T | undefined {
+  if (Array.isArray(requestedNodeKind) && (requestedSubKind !== undefined)) {
+    throw new InternalScannerError(
+      `Cannot specify multiple requestedNodeKind when specifying requestedSubKind.`,
+    );
+  }
+
+  // use a node if we already have one from a previous call
+  const currentState =
+    buildContext.stateStack[buildContext.stateStack.length - 1];
+  let node = currentState.nextNode as T | undefined;
+  delete currentState.nextNode;
+
+  // consume a node if we don't already have one
+  if (node === undefined) {
+    node = consumeAbstractNode(buildContext) as T;
+  }
+
+  // if we still don't have a node
+  if (node === undefined) {
+    // if the node was optional, return
+    if (optional) {
+      return undefined;
+    }
+
+    // if the node was required, and we have reached end of siblings, fabricate a MissingError node
+    // to satisfy the consumption request for remaining siblings
+    if (currentState.isEndOfSiblings) {
+      logger.debug(
+        currentState.indent +
+          "fabricating MissingError node at end of siblings" +
+          getRequestLogMessage(requestedNodeKind, requestedSubKind),
+      );
+      const location = getLocationFromTextPosition(
+        buildContext.text,
+        buildContext.cursor.from,
+      );
+
+      return new MissingError(location) as unknown as T;
+    }
+    // if the node was required, throw an error
+    throw new InternalScannerError(
+      `Required node of kind ${
+        Array.isArray(requestedNodeKind)
+          ? requestedNodeKind
+            .map((kind) => NodeKind[kind])
+            .join(", ")
+          : requestedNodeKind !== undefined
+          ? NodeKind[requestedNodeKind]
+          : "any"
+      }, but no node was available.`,
+    );
+  }
+
+  // return unexpected error node even if optional
+  if (isUnexpectedError(node)) {
+    return node;
+  }
+
+  // return missing error node if required
+  if (!optional && isMissingError(node)) {
+    return node;
+  }
+
+  if (
+    Array.isArray(requestedNodeKind)
+      ? requestedNodeKind.includes(node.nodeKind)
+      : requestedNodeKind !== undefined
+      ? node.nodeKind === requestedNodeKind
+      : true
+  ) {
+    // return the node if it matches the requested kind and there is no subKind requested
+    if (requestedSubKind === undefined) {
+      return node;
+    }
+
+    // return the node if it matches the requested kind and subKind
+    let subKind: number;
+    switch (node.nodeKind) {
+      case NodeKind.TOKEN:
+        subKind = (node as unknown as Token).tokenKind;
+        break;
+      case NodeKind.STATEMENT:
+        subKind = (node as unknown as AbstractStatement).statementKind;
+        break;
+      case NodeKind.ARRAY_DIMENSION:
+        subKind =
+          (node as unknown as AbstractArrayDimension).arrayDimensionKind;
+        break;
+      case NodeKind.CLASS_ID:
+        subKind = (node as unknown as ClassId).classIdKind;
+        break;
+      default:
+        throw new InternalScannerError(
+          `SubKind matching not implemented for node kind: ${
+            NodeKind[node.nodeKind]
+          }`,
+        );
+    }
+    if (Array.isArray(requestedSubKind)) {
+      if (requestedSubKind.includes(subKind)) {
+        return node;
+      }
+    } else {
+      if (requestedSubKind === subKind) {
+        return node;
+      }
+    }
+  }
+
+  if (optional) {
+    // if it was optional and the node kind did not match
+    // store the node for the next call and return undefined
+    if (currentState.nextNode) {
+      throw new InternalScannerError(
+        `Logic error: buildContext.nextNode should be undefined before storing a node.`,
+      );
+    }
+    currentState.nextNode = node;
+
+    return undefined;
+  }
+
+  throw new InternalScannerError(
+    "Logic error: should have returned a node by now.",
+  );
+}
+
+export function fetchRequiredNode<T extends AbstractNode>(
+  buildContext: BuildContext,
+  requestedNodeKind?: number[] | number,
+  requestedSubKind?: number[] | number,
+): RequiredNode<T> {
+  const currentState =
+    buildContext.stateStack[buildContext.stateStack.length - 1];
+  if (debugEnabled) {
+    logger.debug(
+      currentState.indent + "required node request" +
+        getRequestLogMessage(requestedNodeKind, requestedSubKind) + " ...",
+    );
+  }
+  const node = fetchAstNode<T>(
+    buildContext,
+    false,
+    requestedNodeKind,
+    requestedSubKind,
+  );
+
+  if (debugEnabled) {
+    let message = currentState.indent + "=> required node result" +
+      getRequestLogMessage(requestedNodeKind, requestedSubKind) + " => ";
+    message += `${NodeKind[node!.nodeKind]}`;
+    message += getNodeDetailsLogMessage(node!);
+    logger.debug(message);
+  }
+  return node!;
+}
+
+export function fetchOptionalNode<T extends AbstractNode>(
+  buildContext: BuildContext,
+  requestedNodeKind?: number[] | number,
+  requestedSubKind?: number[] | number,
+): OptionalNode<T> | undefined {
+  const currentState =
+    buildContext.stateStack[buildContext.stateStack.length - 1];
+  if (debugEnabled) {
+    logger.debug(
+      currentState.indent + "optional node request" +
+        getRequestLogMessage(requestedNodeKind, requestedSubKind) + "",
+    );
+  }
+  const node = fetchAstNode<T>(
+    buildContext,
+    true,
+    requestedNodeKind,
+    requestedSubKind,
+  ) as OptionalNode<T>;
+  if (debugEnabled) {
+    if (node) {
+      let message = currentState.indent + "=> optional node result" +
+        getRequestLogMessage(requestedNodeKind, requestedSubKind) + " => ";
+      message += `${NodeKind[node.nodeKind]}`;
+      message += getNodeDetailsLogMessage(node);
+      logger.debug(message);
+    }
+  }
+  return node;
+}
+
+export function fetchZeroToManyList<T extends AbstractNode>(
+  buildContext: BuildContext,
+  requestedNodeKind: number[] | number,
+  requestedSubKind?: number[] | number,
+): ZeroToManyList<T> {
+  const currentState =
+    buildContext.stateStack[buildContext.stateStack.length - 1];
+  const nodes: ZeroToManyList<T> = [];
+  if (debugEnabled) {
+    logger.debug(
+      currentState.indent + "zero to many list node request" +
+        getRequestLogMessage(requestedNodeKind, requestedSubKind) + " ...",
+    );
+  }
+  let node = fetchOptionalNode<T>(
+    buildContext,
+    requestedNodeKind,
+    requestedSubKind,
+  );
+  while (node !== undefined) {
+    nodes.push(node);
+    node = fetchOptionalNode<T>(
+      buildContext,
+      requestedNodeKind,
+      requestedSubKind,
+    );
+  }
+  if (debugEnabled) {
+    if (nodes.length > 0) {
+      logger.debug(
+        currentState.indent + "=> zero to many list node result" +
+          getRequestLogMessage(requestedNodeKind, requestedSubKind) +
+          " => count: " + nodes.length,
+      );
+    }
+  }
+  return nodes;
+}
+
+export function fetchOneToManyList<T extends AbstractNode>(
+  buildContext: BuildContext,
+  requestedNodeKind: number[] | number,
+  requestedSubKind?: number[] | number,
+): OneToManyList<T> {
+  const currentState =
+    buildContext.stateStack[buildContext.stateStack.length - 1];
+  const nodes: OneToManyList<T> = [];
+  if (debugEnabled) {
+    logger.debug(
+      currentState.indent + "one to many list node request" +
+        getRequestLogMessage(requestedNodeKind, requestedSubKind) + " ...",
+    );
+  }
+  let node = fetchRequiredNode<T>(
+    buildContext,
+    requestedNodeKind,
+    requestedSubKind,
+  ) as OptionalNode<T>;
+  while (node !== undefined) {
+    nodes.push(node);
+    node = fetchOptionalNode<T>(
+      buildContext,
+      requestedNodeKind,
+      requestedSubKind,
+    );
+  }
+  if (debugEnabled) {
+    logger.debug(
+      currentState.indent + "=> one to many list node result" +
+        getRequestLogMessage(requestedNodeKind, requestedSubKind) +
+        " => count: " + nodes.length,
+    );
+  }
+  return nodes;
+}
+
+export function fetchOneToManyCommaSeparatedList<T extends AbstractNode>(
+  buildContext: BuildContext,
+  requestedNodeKind: number[] | number,
+  requestedSubKind?: number[] | number,
+): { nodes: OneToManyList<T>; commaPunctuators: ZeroToManyList<Token> } {
+  const currentState =
+    buildContext.stateStack[buildContext.stateStack.length - 1];
+  const nodes: OneToManyList<T> = [];
+  const commaPunctuators: ZeroToManyList<Token> = [];
+  if (debugEnabled) {
+    logger.debug(
+      currentState.indent + "one to many comma separated list node request" +
+        getRequestLogMessage(requestedNodeKind, requestedSubKind) + " ...",
+    );
+  }
+  let node = fetchRequiredNode<T>(
+    buildContext,
+    requestedNodeKind,
+    requestedSubKind,
+  ) as OptionalNode<T>;
+  while (node !== undefined) {
+    nodes.push(node);
+
+    // now try to fetch a comma and if not found break
+    // otherwise continue to fetch the next node
+    const commaPunctuator = fetchOptionalNode<Token>(
+      buildContext,
+      NodeKind.TOKEN,
+      TokenKind.COMMA,
+    );
+    if (commaPunctuator === undefined) {
+      break;
+    }
+    commaPunctuators.push(commaPunctuator);
+    node = fetchOptionalNode<T>(
+      buildContext,
+      requestedNodeKind,
+      requestedSubKind,
+    );
+  }
+  if (debugEnabled) {
+    logger.debug(
+      currentState.indent + "=> one to many comma separated list node result" +
+        getRequestLogMessage(requestedNodeKind, requestedSubKind) +
+        " => count: " + nodes.length,
+    );
+  }
+  return { nodes, commaPunctuators };
+}