@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/ast/build/consume/consume-abstract-node.ts

@@ -0,0 +1,199 @@
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import { createSyntaxErrorFromTextAndCursor } from "../../../lezer/create-syntax-error-from-text-and-cursor.ts";
+import { primitiveNodeProp } from "../../../lezer/props/primitive-node-prop-source.ts";
+import { buildToken } from "../node/build-token.ts";
+import { consumeTrivia } from "./consume-trivia.ts";
+import { InternalScannerError } from "../../../scanner-error.ts";
+import getLogger from "../../../util/logger.ts";
+import { buildMissingError } from "../node/build-missing-error.ts";
+import { consumePrimitive } from "./consume-primitive.ts";
+import { consumeAstNode } from "./consume-ast-node.ts";
+import { Specification } from "../../node/specification.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { tokenKindByTokenTypeId } from "../util/token-kind-by-token-type-id-map.ts";
+import { nodeKindByTokenTypeId } from "../util/node-kind-by-token-type-id-map.ts";
+import { UnexpectedError } from "../../node/unexpected-error.ts";
+
+const logger = getLogger("consumeAbstractNode");
+
+export enum NodeScenario {
+  /** Missing Error Node */
+  MISSING_NODE,
+  /** Unexpected Error Node containing a child which is the unexpected token */
+  UNEXPECTED_NODE,
+  /** Unknown Error Node which has text of an unknown token */
+  UNKNOWN_TOKEN,
+  /** Primitive Node e.g. Identifier, IntegerLiteral... */
+  PRIMITIVE,
+  /** Terminal Token Node e.g. class, int... */
+  TOKEN,
+  /** Non-Terminal AST Node e.g. ClassDeclaration, ExpressionStatement... */
+  AST_NODE,
+  /** Terminal AST Node with missing children e.g. ClassDeclaration, ExpressionStatement... */
+  EMPTY_AST_NODE,
+}
+
+function determineNodeScenario(
+  buildContext: BuildContext,
+): NodeScenario {
+  const { cursor, text, lenient } = buildContext;
+  const isError = cursor.type.isError;
+
+  if (isError && !lenient) {
+    throw createSyntaxErrorFromTextAndCursor(text, cursor);
+  }
+
+  // Check if current sytax node is a terminal token by attempting to move to first child
+  const childExists = cursor.firstChild();
+
+  if (isError) {
+    // If the cursor was an error and it has a child, it is an unexpected token error
+    // In this case the child is the unexpected token, we can treat it like an AST node
+    // so move back to parent
+    if (childExists) {
+      cursor.parent();
+      return NodeScenario.UNEXPECTED_NODE;
+    }
+
+    // If it is an error and no child exists, check if there is text, if so treat this as an
+    // unknown token error.
+    if (cursor.to > cursor.from) {
+      return NodeScenario.UNKNOWN_TOKEN;
+    }
+
+    // Otherwise it is a missing node error.
+    return NodeScenario.MISSING_NODE;
+  }
+
+  // If we have a child, we should not use it yet, so move back to parent
+  if (childExists) {
+    cursor.parent();
+  }
+
+  // Primitive is a terminal custom text rather than a syntax token, this will be treated slightly differently
+  if (cursor.type.prop(primitiveNodeProp)) {
+    return NodeScenario.PRIMITIVE;
+  }
+
+  // Check if it is a token type
+  if (tokenKindByTokenTypeId.get(cursor.type.id) !== undefined) {
+    return NodeScenario.TOKEN;
+  }
+
+  // If it has no children, it is an empty AST node
+  if (!childExists) {
+    return NodeScenario.EMPTY_AST_NODE;
+  }
+
+  // Otherwise it is a non-terminal AST node
+  return NodeScenario.AST_NODE;
+}
+
+/*
+ * Iterate through the syntax tree and consume parse tree tokens to create an AST node.
+ */
+export function consumeAbstractNode(
+  buildContext: BuildContext,
+): AbstractNode | undefined {
+  const { cursor } = buildContext;
+  const currentState =
+    buildContext.stateStack[buildContext.stateStack.length - 1];
+
+  // Get any leading trivia for the node
+  const leadingTrivia = consumeTrivia(buildContext, false);
+
+  // If no siblings remain to be consumed, return undefined
+  if (currentState.isEndOfSiblings) {
+    if (leadingTrivia.length > 0) {
+      if (buildContext.unconsumedTrivia) {
+        throw new InternalScannerError(
+          `Expected no unconsumed trivia, but found some.`,
+        );
+      }
+      buildContext.unconsumedTrivia = leadingTrivia;
+    }
+    return undefined;
+  }
+
+  // Determine what kind of node we are about to consume
+  const nodeScenario = determineNodeScenario(buildContext);
+
+  logger.debug(
+    currentState.indent + "consuming node: " + cursor.name +
+      ` (scenario: ${NodeScenario[nodeScenario]})`,
+  );
+
+  let node;
+
+  switch (nodeScenario) {
+    case NodeScenario.MISSING_NODE:
+      node = buildMissingError(buildContext);
+      break;
+    case NodeScenario.PRIMITIVE:
+      node = consumePrimitive(buildContext);
+      break;
+    case NodeScenario.UNKNOWN_TOKEN: {
+      const unknownToken = buildToken(buildContext);
+      // wrap unknown token in unexpected node
+      node = new UnexpectedError(unknownToken);
+      break;
+    }
+    case NodeScenario.TOKEN:
+      node = buildToken(buildContext);
+      break;
+    case NodeScenario.UNEXPECTED_NODE:
+    case NodeScenario.AST_NODE:
+      node = consumeAstNode(buildContext);
+      break;
+    case NodeScenario.EMPTY_AST_NODE: {
+      const nodeKind = nodeKindByTokenTypeId.get(cursor.type.id);
+
+      if (nodeKind === undefined) {
+        throw new InternalScannerError(
+          `No nodeKind mapping found for token type id: ${cursor.type.id} (${cursor.type.name})`,
+        );
+      }
+
+      // Allow specification to have no children
+      if (nodeKind == NodeKind.SPECIFICATION) {
+        return new Specification([]);
+      } else {
+        throw new InternalScannerError(
+          `Expected node to have at least one child: ${NodeKind[nodeKind]}`,
+        );
+      }
+    }
+    default: {
+      const exhaustiveCheck: never = nodeScenario;
+      throw new InternalScannerError(
+        "Unreachable code reached, nodeScenario == " + exhaustiveCheck,
+      );
+    }
+  }
+
+  // Set any leading trivia now we have the node
+  if (leadingTrivia.length > 0) {
+    node.leadingTrivia = leadingTrivia;
+  }
+
+  // Now that we have consumed a node, move to next sibling
+  if (cursor.nextSibling()) {
+    currentState.isEndOfSiblings = false;
+  } else {
+    currentState.isEndOfSiblings = true;
+  }
+
+  // Get any trailing trivia for the node
+  const trailingTrivia = consumeTrivia(buildContext, true);
+  if (trailingTrivia.length > 0) {
+    node.trailingTrivia = trailingTrivia;
+  }
+
+  logger.debug(
+    currentState.indent + "current node: " + cursor.name +
+      (currentState.isEndOfSiblings ? ": end of siblings" : ""),
+  );
+
+  return node;
+}

package/src/ast/build/consume/consume-ast-node.ts

@@ -0,0 +1,400 @@
+import getLogger from "../../../util/logger.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import { buildAggregateOutputValue } from "../node/build-aggregate-output-value.ts";
+import { buildAlignedModifier } from "../node/build-aligned-modifier.ts";
+import { buildArrayDefinition } from "../node/build-array-definition.ts";
+import { buildArrayElementAccess } from "../node/build-array-element-access.ts";
+import { buildBase64StringLiteral } from "../node/build-base64-string-literal.ts";
+import { buildBinaryExpression } from "../node/build-binary-expression.ts";
+import { buildBitModifier } from "../node/build-bit-modifier.ts";
+import { buildCaseClause } from "../node/build-case-clause.ts";
+import { buildClassDeclaration } from "../node/build-class-declaration.ts";
+import { buildClassDefinition } from "../node/build-class-definition.ts";
+import { buildClassIdRange } from "../node/build-class-id-range.ts";
+import { buildClassId } from "../node/build-class-id.ts";
+import { buildClassMemberAccess } from "../node/build-class-member-access.ts";
+import { buildCompoundStatement } from "../node/build-compound-statement.ts";
+import { buildComputedArrayDefinition } from "../node/build-computed-array-definition.ts";
+import { buildComputedElementaryTypeDefinition } from "../node/build-computed-elementary-type-definition.ts";
+import { buildDefaultClause } from "../node/build-default-clause.ts";
+import { buildDoStatement } from "../node/build-do-statement.ts";
+import { buildElementaryTypeDefinition } from "../node/build-elementary-type-definition.ts";
+import { buildElementaryTypeOutputValue } from "../node/build-elementary-type-output-value.ts";
+import { buildElementaryType } from "../node/build-elementary-type.ts";
+import { buildExpandableModifier } from "../node/build-expandable-modifier.ts";
+import { buildExplicitArrayDimension } from "../node/build-explicit-array-dimension.ts";
+import { buildExpressionStatement } from "../node/build-expression-statement.ts";
+import { buildExtendedClassIdRange } from "../node/build-extended-class-id-range.ts";
+import { buildExtendsModifier } from "../node/build-extends-modifier.ts";
+import { buildForStatement } from "../node/build-for-statement.ts";
+import { buildIfStatement } from "../node/build-if-statement.ts";
+import { buildImplicitArrayDimension } from "../node/build-implicit-array-dimension.ts";
+import { buildLengthAttribute } from "../node/build-length-attribute.ts";
+import { buildLengthofExpression } from "../node/build-lengthof-expression.ts";
+import { buildMapDeclaration } from "../node/build-map-declaration.ts";
+import { buildMapEntry } from "../node/build-map-entry.ts";
+import { buildMultipleCharacterLiteral } from "../node/build-multiple-character-literal.ts";
+import { buildParameterList } from "../node/build-parameter-list.ts";
+import { buildParameterValueList } from "../node/build-parameter-value-list.ts";
+import { buildParameter } from "../node/build-parameter.ts";
+import { buildPartialArrayDimension } from "../node/build-partial-array-dimension.ts";
+import { buildSpecification } from "../node/build-specification.ts";
+import { buildStringDefinition } from "../node/build-string-definition.ts";
+import { buildSwitchStatement } from "../node/build-switch-statement.ts";
+import { buildUnaryExpression } from "../node/build-unary-expression.ts";
+import { buildUtfStringLiteral } from "../node/build-utf-string-literal.ts";
+import { buildWhileStatement } from "../node/build-while-statement.ts";
+import { InternalScannerError } from "../../../scanner-error.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { buildUnexpectedError } from "../node/build-unexpected-error.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import { nodeKindByTokenTypeId } from "../util/node-kind-by-token-type-id-map.ts";
+import { ArrayDimensionKind } from "../../node/enum/array-dimension-kind.ts";
+import { arrayDimensionKindByTokenTypeId } from "../util/array-dimension-kind-by-token-type-id-map.ts";
+import { stringLiteralKindByTokenTypeId } from "../util/string-literal-kind-by-token-type-id-map.ts";
+import { statementKindByTokenTypeId } from "../util/statement-kind-by-token-type-id-map.ts";
+import { expressionKindByTokenTypeId } from "../util/expression-kind-by-token-type-id-map.ts";
+import { classIdKindByTokenTypeId } from "../util/class-id-kind-by-token-type-id-map.ts";
+import { ClassIdKind } from "../../node/enum/class-id-kind.ts";
+import { ExpressionKind } from "../../node/enum/expression-kind.ts";
+import { StatementKind } from "../../node/enum/statement-kind.ts";
+import { buildMapDefinition } from "../node/build-map-definition.ts";
+import { StringLiteralKind } from "../../node/enum/string-literal-kind.ts";
+import { consumeWhiteSpaceAndMissingErrors } from "./consume-white-space-and-missing-errors.ts";
+
+const logger = getLogger("consumeAstNode");
+
+function consumeArrayDimension(
+  buildContext: BuildContext,
+  parentTypeId: number,
+  parentTypeName: string,
+): AbstractNode {
+  const arrayDimensionKind = arrayDimensionKindByTokenTypeId.get(
+    parentTypeId,
+  );
+
+  if (arrayDimensionKind === undefined) {
+    throw new InternalScannerError(
+      `No arrayDimensionKind mapping found for token type id: ${parentTypeId} (${parentTypeName})`,
+    );
+  }
+
+  switch (arrayDimensionKind) {
+    case ArrayDimensionKind.EXPLICIT:
+      return buildExplicitArrayDimension(buildContext);
+    case ArrayDimensionKind.IMPLICIT:
+      return buildImplicitArrayDimension(buildContext);
+    case ArrayDimensionKind.PARTIAL:
+      return buildPartialArrayDimension(buildContext);
+    default: {
+      const exhaustiveCheck: never = arrayDimensionKind;
+      throw new InternalScannerError(
+        "Unreachable code reached, arrayDimensionKind == " +
+          exhaustiveCheck,
+      );
+    }
+  }
+}
+
+function consumeClassId(
+  buildContext: BuildContext,
+  parentTypeId: number,
+  parentTypeName: string,
+): AbstractNode {
+  const classIdKind = classIdKindByTokenTypeId.get(
+    parentTypeId,
+  );
+
+  if (classIdKind === undefined) {
+    throw new InternalScannerError(
+      `No classIdKind mapping found for token type id: ${parentTypeId} (${parentTypeName})`,
+    );
+  }
+  switch (classIdKind) {
+    case ClassIdKind.SINGLE:
+      return buildClassId(buildContext);
+    case ClassIdKind.RANGE:
+      return buildClassIdRange(buildContext);
+    case ClassIdKind.EXTENDED_RANGE:
+      return buildExtendedClassIdRange(buildContext);
+    default: {
+      const exhaustiveCheck: never = classIdKind;
+      throw new InternalScannerError(
+        "Unreachable code reached, classIdKind == " +
+          exhaustiveCheck,
+      );
+    }
+  }
+}
+
+function consumeExpression(
+  buildContext: BuildContext,
+  parentTypeId: number,
+  parentTypeName: string,
+): AbstractNode {
+  const expressionKind = expressionKindByTokenTypeId.get(
+    parentTypeId,
+  );
+
+  if (expressionKind === undefined) {
+    throw new InternalScannerError(
+      `No expressionKind mapping found for token type id: ${parentTypeId} (${parentTypeName})`,
+    );
+  }
+  switch (expressionKind) {
+    case ExpressionKind.BINARY:
+      return buildBinaryExpression(buildContext);
+    case ExpressionKind.UNARY:
+      return buildUnaryExpression(buildContext);
+    case ExpressionKind.LENGTHOF:
+      return buildLengthofExpression(buildContext);
+    default: {
+      const exhaustiveCheck: never = expressionKind;
+      throw new InternalScannerError(
+        "Unreachable code reached, expressionKind == " +
+          exhaustiveCheck,
+      );
+    }
+  }
+}
+
+function consumeStatement(
+  buildContext: BuildContext,
+  parentTypeId: number,
+  parentTypeName: string,
+): AbstractNode {
+  const statementKind = statementKindByTokenTypeId.get(
+    parentTypeId,
+  );
+
+  if (statementKind === undefined) {
+    throw new InternalScannerError(
+      `No statementKind mapping found for token type id: ${parentTypeId} (${parentTypeName})`,
+    );
+  }
+  switch (statementKind) {
+    case StatementKind.ARRAY_DEFINITION:
+      return buildArrayDefinition(buildContext);
+    case StatementKind.CLASS_DECLARATION:
+      return buildClassDeclaration(buildContext);
+    case StatementKind.CLASS_DEFINITION:
+      return buildClassDefinition(buildContext);
+    case StatementKind.COMPOUND:
+      return buildCompoundStatement(buildContext);
+    case StatementKind.COMPUTED_ARRAY_DEFINITION:
+      return buildComputedArrayDefinition(buildContext);
+    case StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION:
+      return buildComputedElementaryTypeDefinition(buildContext);
+    case StatementKind.DO:
+      return buildDoStatement(buildContext);
+    case StatementKind.ELEMENTARY_TYPE_DEFINITION:
+      return buildElementaryTypeDefinition(buildContext);
+    case StatementKind.EXPRESSION:
+      return buildExpressionStatement(buildContext);
+    case StatementKind.FOR:
+      return buildForStatement(buildContext);
+    case StatementKind.IF:
+      return buildIfStatement(buildContext);
+    case StatementKind.MAP_DECLARATION:
+      return buildMapDeclaration(buildContext);
+    case StatementKind.MAP_DEFINITION:
+      return buildMapDefinition(buildContext);
+    case StatementKind.STRING_DEFINITION:
+      return buildStringDefinition(buildContext);
+    case StatementKind.SWITCH:
+      return buildSwitchStatement(buildContext);
+    case StatementKind.WHILE:
+      return buildWhileStatement(buildContext);
+    default: {
+      const exhaustiveCheck: never = statementKind;
+      throw new InternalScannerError(
+        "Unreachable code reached, statementKind == " +
+          exhaustiveCheck,
+      );
+    }
+  }
+}
+
+function consumeStringLiteral(
+  buildContext: BuildContext,
+  parentTypeId: number,
+  parentTypeName: string,
+): AbstractNode {
+  const stringLiteralKind = stringLiteralKindByTokenTypeId.get(
+    parentTypeId,
+  );
+
+  if (stringLiteralKind === undefined) {
+    throw new InternalScannerError(
+      `No stringLiteralKind mapping found for token type id: ${parentTypeId} (${parentTypeName})`,
+    );
+  }
+  switch (stringLiteralKind) {
+    case StringLiteralKind.BASIC:
+      return buildBase64StringLiteral(buildContext);
+    case StringLiteralKind.UTF:
+      return buildUtfStringLiteral(buildContext);
+    default: {
+      const exhaustiveCheck: never = stringLiteralKind;
+      throw new InternalScannerError(
+        "Unreachable code reached, stringLiteralKind == " +
+          exhaustiveCheck,
+      );
+    }
+  }
+}
+
+export function consumeAstNode(buildContext: BuildContext): AbstractNode {
+  const { cursor } = buildContext;
+  const currentState =
+    buildContext.stateStack[buildContext.stateStack.length - 1];
+  const parentTypeId = cursor.type.id;
+  const parentTypeName = cursor.type.name;
+
+  let nodeKind: NodeKind | undefined;
+
+  if (cursor.type.isError) {
+    nodeKind = NodeKind.UNEXPECTED_ERROR;
+  } else {
+    nodeKind = nodeKindByTokenTypeId.get(parentTypeId);
+  }
+
+  if (nodeKind === undefined) {
+    throw new InternalScannerError(
+      `No nodeKind mapping found for token type id: ${parentTypeId} (${parentTypeName})`,
+    );
+  }
+
+  logger.debug(
+    currentState.indent + "consuming AST node: " + NodeKind[nodeKind] + "...",
+  );
+
+  const childStack = {
+    isEndOfSiblings: false,
+    indent: currentState.indent + "  ",
+  };
+
+  buildContext.stateStack.push(childStack);
+
+  if (!cursor.firstChild()) {
+    throw new InternalScannerError(
+      `Expected AST node to have children: ${NodeKind[nodeKind]}`,
+    );
+  }
+
+  let node: AbstractNode;
+
+  switch (nodeKind) {
+    case NodeKind.ARRAY_DIMENSION:
+      node = consumeArrayDimension(buildContext, parentTypeId, parentTypeName);
+      break;
+    case NodeKind.CLASS_ID:
+      node = consumeClassId(buildContext, parentTypeId, parentTypeName);
+      break;
+    case NodeKind.EXPRESSION:
+      node = consumeExpression(buildContext, parentTypeId, parentTypeName);
+      break;
+    case NodeKind.STATEMENT:
+      node = consumeStatement(buildContext, parentTypeId, parentTypeName);
+      break;
+    case NodeKind.STRING_LITERAL:
+      node = consumeStringLiteral(buildContext, parentTypeId, parentTypeName);
+      break;
+    case NodeKind.AGGREGATE_OUTPUT_VALUE:
+      node = buildAggregateOutputValue(buildContext);
+      break;
+    case NodeKind.ALIGNED_MODIFIER:
+      node = buildAlignedModifier(buildContext);
+      break;
+    case NodeKind.ARRAY_ELEMENT_ACCESS:
+      node = buildArrayElementAccess(buildContext);
+      break;
+    case NodeKind.BIT_MODIFIER:
+      node = buildBitModifier(buildContext);
+      break;
+    case NodeKind.CASE_CLAUSE:
+      node = buildCaseClause(buildContext);
+      break;
+    case NodeKind.CLASS_MEMBER_ACCESS:
+      node = buildClassMemberAccess(buildContext);
+      break;
+    case NodeKind.DEFAULT_CLAUSE:
+      node = buildDefaultClause(buildContext);
+      break;
+    case NodeKind.ELEMENTARY_TYPE:
+      node = buildElementaryType(buildContext);
+      break;
+    case NodeKind.ELEMENTARY_TYPE_OUTPUT_VALUE:
+      node = buildElementaryTypeOutputValue(buildContext);
+      break;
+    case NodeKind.EXPANDABLE_MODIFIER:
+      node = buildExpandableModifier(buildContext);
+      break;
+    case NodeKind.EXTENDS_MODIFIER:
+      node = buildExtendsModifier(buildContext);
+      break;
+    case NodeKind.LENGTH_ATTRIBUTE:
+      node = buildLengthAttribute(buildContext);
+      break;
+    case NodeKind.MAP_ENTRY:
+      node = buildMapEntry(buildContext);
+      break;
+    case NodeKind.NUMBER_LITERAL:
+      node = buildMultipleCharacterLiteral(buildContext);
+      break;
+    case NodeKind.PARAMETER:
+      node = buildParameter(buildContext);
+      break;
+    case NodeKind.PARAMETER_LIST:
+      node = buildParameterList(buildContext);
+      break;
+    case NodeKind.PARAMETER_VALUE_LIST:
+      node = buildParameterValueList(buildContext);
+      break;
+    case NodeKind.SPECIFICATION:
+      node = buildSpecification(buildContext);
+      break;
+    case NodeKind.UNEXPECTED_ERROR:
+      node = buildUnexpectedError(buildContext);
+      break;
+    // These are node types that should be handled by other consumers
+    case NodeKind.IDENTIFIER:
+    case NodeKind.TOKEN:
+      throw new InternalScannerError(
+        `consumeAstNode cannot consume node of kind: ${NodeKind[nodeKind]}`,
+      );
+    default: {
+      const exhaustiveCheck: never = nodeKind;
+      throw new InternalScannerError(
+        "Unreachable code reached, nodeKind == " + exhaustiveCheck,
+      );
+    }
+  }
+
+  if (!childStack.isEndOfSiblings) {
+    // skip any whitespace or missing error nodes as these are inserted by parser when recovering
+    consumeWhiteSpaceAndMissingErrors(buildContext);
+
+    if (!childStack.isEndOfSiblings) {
+      throw new InternalScannerError(
+        `Expected to have consumed all child nodes of ${
+          NodeKind[nodeKind]
+        }, but some remain.`,
+      );
+    }
+  }
+
+  buildContext.stateStack.pop();
+
+  if (!cursor.parent()) {
+    throw new InternalScannerError(
+      `Expected to move cursor back to parent of ${
+        NodeKind[nodeKind]
+      }, but failed.`,
+    );
+  }
+
+  logger.debug(currentState.indent + "...consumed node: " + NodeKind[nodeKind]);
+
+  return node;
+}

package/src/ast/build/consume/consume-primitive.ts

@@ -0,0 +1,59 @@
+import type { BuildContext } from "../util/build-context.ts";
+import getLogger from "../../../util/logger.ts";
+import { buildToken } from "../node/build-token.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { buildBinaryLiteral } from "../node/build-binary-literal.ts";
+import { buildDecimalLiteral } from "../node/build-decimal-literal.ts";
+import { buildFloatingPointLiteral } from "../node/build-floating-point-literal.ts";
+import { buildHexadecimalLiteral } from "../node/build-hexadecimal-literal.ts";
+import { buildIdentifier } from "../node/build-identifier.ts";
+import { buildIntegerLiteral } from "../node/build-integer-literal.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import { InternalScannerError } from "../../../scanner-error.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../../lezer/parser.terms.ts";
+
+const logger = getLogger("consumePrimitive");
+
+export function consumePrimitive(buildContext: BuildContext): AbstractNode {
+  const { cursor } = buildContext;
+  const currentState =
+    buildContext.stateStack[buildContext.stateStack.length - 1];
+  const token = buildToken(buildContext);
+
+  let node: AbstractNode;
+
+  switch (cursor.type.id) {
+    case TokenTypeId.Identifier:
+      node = buildIdentifier(token);
+      break;
+    case TokenTypeId.HexadecimalLiteral:
+      node = buildHexadecimalLiteral(token);
+      break;
+    case TokenTypeId.IntegerLiteral:
+      node = buildIntegerLiteral(token);
+      break;
+    case TokenTypeId.BinaryLiteral:
+      node = buildBinaryLiteral(token);
+      break;
+    case TokenTypeId.DecimalLiteral:
+      node = buildDecimalLiteral(token);
+      break;
+    case TokenTypeId.FloatingPointLiteral:
+      node = buildFloatingPointLiteral(token);
+      break;
+    default:
+      throw new InternalScannerError(
+        `Unsupported primitive type: ${cursor.type.name}`,
+      );
+  }
+  logger.debug(
+    currentState.indent + "consumed primitive node: " +
+      NodeKind[node.nodeKind] +
+      " " +
+      token.text.replaceAll("\n", "\\n"),
+  );
+
+  return node;
+}