@mpeggroup/mpeg-sdl-parser 4.1.2 → 4.1.3

package/src/analyser/util/symbol-table-utils.ts

@@ -47,14 +47,10 @@ export function getRequiredIdentifier(
     if (strict) {
       throw new SemanticError(
         "Required identifier property is missing",
-        parentNode.leadingTrivia
-          ? parentNode.leadingTrivia[0].location
-          : undefined,
+        parentNode.leadingTrivia ? parentNode.leadingTrivia[0].location : undefined,
       );
     } else {
-      logger.debug(
-        "Ignoring missing required identifier property in lenient mode.",
-      );
+      logger.debug("Ignoring missing required identifier property in lenient mode.");
     }
     return undefined;
   }
@@ -66,21 +62,16 @@ export function getRequiredIdentifier(
   if (strict) {
     if (isToken(node)) {
       throw new SemanticError(
-        `Required identifier property is a Token node: ${
-          TokenKind[node.tokenKind]
-        }`,
+        `Required identifier property is a Token node: ${TokenKind[node.tokenKind]}`,
         node.leadingTrivia ? node.leadingTrivia[0].location : undefined,
       );
     }
     throw new SemanticError(
-      "Required identifier property is not an Identifier node: " +
-        NodeKind[node.nodeKind],
+      "Required identifier property is not an Identifier node: " + NodeKind[node.nodeKind],
       node.leadingTrivia ? node.leadingTrivia[0].location : undefined,
     );
   } else {
-    logger.debug(
-      "Ignoring invalid required identifier property in lenient mode.",
-    );
+    logger.debug("Ignoring invalid required identifier property in lenient mode.");
     return undefined;
   }
 }
@@ -104,14 +95,10 @@ export function getRequiredToken(
     if (strict) {
       throw new SemanticError(
         "Required token property is missing",
-        parentNode.leadingTrivia
-          ? parentNode.leadingTrivia[0].location
-          : undefined,
+        parentNode.leadingTrivia ? parentNode.leadingTrivia[0].location : undefined,
       );
     } else {
-      logger.debug(
-        "Ignoring missing required token property in lenient mode.",
-      );
+      logger.debug("Ignoring missing required token property in lenient mode.");
     }
     return undefined;
   }
@@ -126,9 +113,7 @@ export function getRequiredToken(
       node.leadingTrivia ? node.leadingTrivia[0].location : undefined,
     );
   } else {
-    logger.debug(
-      "Ignoring invalid required token property in lenient mode.",
-    );
+    logger.debug("Ignoring invalid required token property in lenient mode.");
     return undefined;
   }
 }
@@ -152,14 +137,10 @@ export function getRequiredElementaryType(
     if (strict) {
       throw new SemanticError(
         "Required elementary type property is missing",
-        parentNode.leadingTrivia
-          ? parentNode.leadingTrivia[0].location
-          : undefined,
+        parentNode.leadingTrivia ? parentNode.leadingTrivia[0].location : undefined,
       );
     } else {
-      logger.debug(
-        "Ignoring missing required elementary type property in lenient mode.",
-      );
+      logger.debug("Ignoring missing required elementary type property in lenient mode.");
     }
     return undefined;
   }
@@ -170,21 +151,16 @@ export function getRequiredElementaryType(
   if (strict) {
     if (isToken(node)) {
       throw new SemanticError(
-        `Required identifier property is a Token node: ${
-          TokenKind[node.tokenKind]
-        }`,
+        `Required identifier property is a Token node: ${TokenKind[node.tokenKind]}`,
         node.leadingTrivia ? node.leadingTrivia[0].location : undefined,
       );
     }
     throw new SemanticError(
-      "Required elementary type property is not an ElementaryType node: " +
-        NodeKind[node.nodeKind],
+      "Required elementary type property is not an ElementaryType node: " + NodeKind[node.nodeKind],
       node.leadingTrivia ? node.leadingTrivia[0].location : undefined,
     );
   } else {
-    logger.debug(
-      "Ignoring invalid required elementary type property in lenient mode.",
-    );
+    logger.debug("Ignoring invalid required elementary type property in lenient mode.");
     return undefined;
   }
 }
@@ -204,21 +180,15 @@ export function getElementaryTypeKind(
         throw new SemanticError(
           "Elementary type unsigned qualifier is not a Token node: " +
             NodeKind[elementaryType.unsignedQualifierKeyword.nodeKind],
-          elementaryType.leadingTrivia
-            ? elementaryType.leadingTrivia[0].location
-            : undefined,
+          elementaryType.leadingTrivia ? elementaryType.leadingTrivia[0].location : undefined,
         );
       } else {
-        logger.debug(
-          "Ignoring invalid elementary type unsigned qualifier in lenient mode.",
-        );
+        logger.debug("Ignoring invalid elementary type unsigned qualifier in lenient mode.");
         return undefined;
       }
     }
 
-    if (
-      elementaryType.unsignedQualifierKeyword.tokenKind !== TokenKind.UNSIGNED
-    ) {
+    if (elementaryType.unsignedQualifierKeyword.tokenKind !== TokenKind.UNSIGNED) {
       if (strict) {
         throw new SemanticError(
           `Elementary type unsigned qualifier has invalid token kind: ${
@@ -242,14 +212,10 @@ export function getElementaryTypeKind(
       throw new SemanticError(
         "Elementary type type keyword is not a Token node: " +
           NodeKind[elementaryType.typeKeyword.nodeKind],
-        elementaryType.leadingTrivia
-          ? elementaryType.leadingTrivia[0].location
-          : undefined,
+        elementaryType.leadingTrivia ? elementaryType.leadingTrivia[0].location : undefined,
       );
     } else {
-      logger.debug(
-        "Ignoring invalid elementary type type keyword in lenient mode.",
-      );
+      logger.debug("Ignoring invalid elementary type type keyword in lenient mode.");
       return undefined;
     }
   }
@@ -259,9 +225,7 @@ export function getElementaryTypeKind(
 
   switch (typeToken.tokenKind) {
     case TokenKind.INT:
-      return isUnsigned
-        ? ElementaryTypeKind.UNSIGNED_INTEGER
-        : ElementaryTypeKind.INTEGER;
+      return isUnsigned ? ElementaryTypeKind.UNSIGNED_INTEGER : ElementaryTypeKind.INTEGER;
     case TokenKind.FLOAT:
       return ElementaryTypeKind.FLOATING_POINT;
     case TokenKind.BIT:
@@ -269,9 +233,7 @@ export function getElementaryTypeKind(
     default:
       if (strict) {
         throw new SemanticError(
-          `Unsupported elementary type token kind: ${
-            TokenKind[typeToken.tokenKind]
-          }`,
+          `Unsupported elementary type token kind: ${TokenKind[typeToken.tokenKind]}`,
           typeToken.getLocation(),
         );
       } else {
@@ -308,9 +270,7 @@ export function getStringVariableKind(
     default:
       if (strict) {
         throw new SemanticError(
-          `Unsupported string variable kind token: ${
-            TokenKind[stringVariableKindToken.tokenKind]
-          }`,
+          `Unsupported string variable kind token: ${TokenKind[stringVariableKindToken.tokenKind]}`,
           stringVariableKindToken.getLocation(),
         );
       } else {
@@ -344,21 +304,15 @@ export function getRequiredOperand(
     if (strict) {
       throw new SemanticError(
         "Required operand property is missing",
-        parentNode.leadingTrivia
-          ? parentNode.leadingTrivia[0].location
-          : undefined,
+        parentNode.leadingTrivia ? parentNode.leadingTrivia[0].location : undefined,
       );
     } else {
-      logger.debug(
-        "Ignoring missing required operand property in lenient mode.",
-      );
+      logger.debug("Ignoring missing required operand property in lenient mode.");
     }
     return undefined;
   }
 
-  if (
-    isAbstractExpression(node) || isIdentifier(node) || isNumberLiteral(node)
-  ) {
+  if (isAbstractExpression(node) || isIdentifier(node) || isNumberLiteral(node)) {
     return node;
   }
 
@@ -369,9 +323,7 @@ export function getRequiredOperand(
       node.leadingTrivia ? node.leadingTrivia[0].location : undefined,
     );
   } else {
-    logger.debug(
-      "Ignoring invalid required operand property in lenient mode.",
-    );
+    logger.debug("Ignoring invalid required operand property in lenient mode.");
     return undefined;
   }
 }
@@ -428,17 +380,13 @@ export function getSymbolTableString(symbolTable: SymbolTable): string {
       }:`,
     );
 
-    if (scope.classMemberSymbols && (scope.classMemberSymbols.size > 0)) {
+    if (scope.classMemberSymbols && scope.classMemberSymbols.size > 0) {
       lines.push(`${prefix}  members:`);
 
       for (const memberEntries of scope.classMemberSymbols.values()) {
         for (const entry of memberEntries) {
-          const branchStr = entry.branchId
-            ? ` (branch: ${entry.branchId})`
-            : "";
-          lines.push(
-            `${prefix}    ${getSymbolString(entry.symbol)}${branchStr}`,
-          );
+          const branchStr = entry.branchId ? ` (branch: ${entry.branchId})` : "";
+          lines.push(`${prefix}    ${getSymbolString(entry.symbol)}${branchStr}`);
         }
       }
     }

package/src/analyser/util/type-utils.ts

@@ -7,19 +7,13 @@ import { NumberLiteralKind } from "../../ast/node/enum/number-literal-kind.ts";
 import type { Identifier } from "../../ast/node/identifier.ts";
 import type { BinaryExpression } from "../../ast/node/binary-expression.ts";
 import type { UnaryExpression } from "../../ast/node/unary-expression.ts";
-import {
-  isAbstractExpression,
-  isIdentifier,
-  isNumberLiteral,
-} from "../../ast/util/types.ts";
+import { isAbstractExpression, isIdentifier, isNumberLiteral } from "../../ast/util/types.ts";
 import { NumericType, StringType, type SymbolTable } from "../symbol-table.ts";
 import { InternalScannerError } from "../../scanner-error.ts";
 import { StringVariableKind } from "../../ast/node/enum/string-variable-kind.ts";
 import { NodeKind } from "../../ast/node/enum/node-kind.ts";
 
-export function getNumericTypeFromElementaryTypeKind(
-  kind: ElementaryTypeKind,
-): NumericType {
+export function getNumericTypeFromElementaryTypeKind(kind: ElementaryTypeKind): NumericType {
   switch (kind) {
     case ElementaryTypeKind.INTEGER:
     case ElementaryTypeKind.UNSIGNED_INTEGER:
@@ -29,16 +23,12 @@ export function getNumericTypeFromElementaryTypeKind(
       return NumericType.FLOATING_POINT;
     default: {
       const exhaustiveCheck: never = kind;
-      throw new InternalScannerError(
-        "Unreachable code reached, kind == " + exhaustiveCheck,
-      );
+      throw new InternalScannerError("Unreachable code reached, kind == " + exhaustiveCheck);
     }
   }
 }
 
-export function getStringTypeFromStringVariableKind(
-  kind: StringVariableKind,
-): StringType {
+export function getStringTypeFromStringVariableKind(kind: StringVariableKind): StringType {
   switch (kind) {
     case StringVariableKind.BASE64:
       return StringType.BASIC;
@@ -49,16 +39,12 @@ export function getStringTypeFromStringVariableKind(
       return StringType.UCS;
     default: {
       const exhaustiveCheck: never = kind;
-      throw new InternalScannerError(
-        "Unreachable code reached, kind == " + exhaustiveCheck,
-      );
+      throw new InternalScannerError("Unreachable code reached, kind == " + exhaustiveCheck);
     }
   }
 }
 
-function getNumericTypeFromNumberLiteralKind(
-  kind: NumberLiteralKind,
-): NumericType {
+function getNumericTypeFromNumberLiteralKind(kind: NumberLiteralKind): NumericType {
   switch (kind) {
     case NumberLiteralKind.BINARY:
     case NumberLiteralKind.HEXADECIMAL:
@@ -71,9 +57,7 @@ function getNumericTypeFromNumberLiteralKind(
       return NumericType.DECIMAL;
     default: {
       const exhaustiveCheck: never = kind;
-      throw new InternalScannerError(
-        "Unreachable code reached, kind == " + exhaustiveCheck,
-      );
+      throw new InternalScannerError("Unreachable code reached, kind == " + exhaustiveCheck);
     }
   }
 }
@@ -94,9 +78,7 @@ export function resolveNumericType(
     return resolveNumericTypeFromExpression(node, symbolTable);
   }
 
-  throw new InternalScannerError(
-    `Undexpected node kind: ${NodeKind[node.nodeKind]}`,
-  );
+  throw new InternalScannerError(`Undexpected node kind: ${NodeKind[node.nodeKind]}`);
 }
 
 function resolveNumericTypeFromIdentifier(
@@ -105,14 +87,14 @@ function resolveNumericTypeFromIdentifier(
 ): NumericType | undefined {
   const symbol = symbolTable.lookupVariable(identifier.name);
 
-  if (symbol && (symbol.attributes.numericType !== undefined)) {
+  if (symbol && symbol.attributes.numericType !== undefined) {
     return symbol.attributes.numericType;
   }
 
   const classMembers = symbolTable.lookupClassMember(identifier.name);
 
   // Use the first class member as they should all have the same type in different branches
-  if (classMembers && (classMembers.length > 0)) {
+  if (classMembers && classMembers.length > 0) {
     const memberSymbol = classMembers[0].symbol;
 
     if (memberSymbol.attributes.numericType !== undefined) {
@@ -132,22 +114,14 @@ function resolveNumericTypeFromExpression(
 
   switch (kind) {
     case ExpressionKind.BINARY:
-      return resolveBinaryExpressionType(
-        expression as BinaryExpression,
-        symbolTable,
-      );
+      return resolveBinaryExpressionType(expression as BinaryExpression, symbolTable);
     case ExpressionKind.UNARY:
-      return resolveNumericType(
-        (expression as UnaryExpression).operand,
-        symbolTable,
-      );
+      return resolveNumericType((expression as UnaryExpression).operand, symbolTable);
     case ExpressionKind.LENGTHOF:
       return NumericType.INTEGER;
     default: {
       const exhaustiveCheck: never = kind;
-      throw new InternalScannerError(
-        "Unreachable code reached, kind == " + exhaustiveCheck,
-      );
+      throw new InternalScannerError("Unreachable code reached, kind == " + exhaustiveCheck);
     }
   }
 }
@@ -166,39 +140,24 @@ function resolveBinaryExpressionType(
   }
 
   if (operatorKind === BinaryOperatorKind.ASSIGNMENT) {
-    return resolveNumericType(
-      expression.leftOperand as AbstractNode,
-      symbolTable,
-    );
+    return resolveNumericType(expression.leftOperand as AbstractNode, symbolTable);
   }
 
-  const leftNumericType = resolveNumericType(
-    expression.leftOperand as AbstractNode,
-    symbolTable,
-  );
-  const rightNumericType = resolveNumericType(
-    expression.rightOperand as AbstractNode,
-    symbolTable,
-  );
+  const leftNumericType = resolveNumericType(expression.leftOperand as AbstractNode, symbolTable);
+  const rightNumericType = resolveNumericType(expression.rightOperand as AbstractNode, symbolTable);
 
   if (
-    (leftNumericType === NumericType.FLOATING_POINT) ||
-    (rightNumericType === NumericType.FLOATING_POINT)
+    leftNumericType === NumericType.FLOATING_POINT ||
+    rightNumericType === NumericType.FLOATING_POINT
   ) {
     return NumericType.FLOATING_POINT;
   }
 
-  if (
-    (leftNumericType === NumericType.DECIMAL) ||
-    (rightNumericType === NumericType.DECIMAL)
-  ) {
+  if (leftNumericType === NumericType.DECIMAL || rightNumericType === NumericType.DECIMAL) {
     return NumericType.DECIMAL;
   }
 
-  if (
-    (leftNumericType === NumericType.INTEGER) ||
-    (rightNumericType === NumericType.INTEGER)
-  ) {
+  if (leftNumericType === NumericType.INTEGER || rightNumericType === NumericType.INTEGER) {
     return NumericType.INTEGER;
   }
 
@@ -206,33 +165,34 @@ function resolveBinaryExpressionType(
 }
 
 export function isRelationalOperator(kind: BinaryOperatorKind): boolean {
-  return (kind === BinaryOperatorKind.LESS_THAN) ||
-    (kind === BinaryOperatorKind.LESS_THAN_OR_EQUAL) ||
-    (kind === BinaryOperatorKind.GREATER_THAN) ||
-    (kind === BinaryOperatorKind.GREATER_THAN_OR_EQUAL) ||
-    (kind === BinaryOperatorKind.EQUAL) ||
-    (kind === BinaryOperatorKind.NOT_EQUAL);
+  return (
+    kind === BinaryOperatorKind.LESS_THAN ||
+    kind === BinaryOperatorKind.LESS_THAN_OR_EQUAL ||
+    kind === BinaryOperatorKind.GREATER_THAN ||
+    kind === BinaryOperatorKind.GREATER_THAN_OR_EQUAL ||
+    kind === BinaryOperatorKind.EQUAL ||
+    kind === BinaryOperatorKind.NOT_EQUAL
+  );
 }
 
 export function isLogicalOperator(kind: BinaryOperatorKind): boolean {
-  return (kind === BinaryOperatorKind.LOGICAL_AND) ||
-    (kind === BinaryOperatorKind.LOGICAL_OR);
+  return kind === BinaryOperatorKind.LOGICAL_AND || kind === BinaryOperatorKind.LOGICAL_OR;
 }
 
 export function isShiftOperator(kind: BinaryOperatorKind): boolean {
-  return (kind === BinaryOperatorKind.SHIFT_LEFT) ||
-    (kind === BinaryOperatorKind.SHIFT_RIGHT);
+  return kind === BinaryOperatorKind.SHIFT_LEFT || kind === BinaryOperatorKind.SHIFT_RIGHT;
 }
 
 export function isBitwiseOperator(kind: BinaryOperatorKind): boolean {
-  return (kind === BinaryOperatorKind.BITWISE_AND) ||
-    (kind === BinaryOperatorKind.BITWISE_OR);
+  return kind === BinaryOperatorKind.BITWISE_AND || kind === BinaryOperatorKind.BITWISE_OR;
 }
 
 export function isArithmeticOperator(kind: BinaryOperatorKind): boolean {
-  return (kind === BinaryOperatorKind.ADD) ||
-    (kind === BinaryOperatorKind.SUBTRACT) ||
-    (kind === BinaryOperatorKind.MULTIPLY) ||
-    (kind === BinaryOperatorKind.DIVIDE) ||
-    (kind === BinaryOperatorKind.MODULUS);
+  return (
+    kind === BinaryOperatorKind.ADD ||
+    kind === BinaryOperatorKind.SUBTRACT ||
+    kind === BinaryOperatorKind.MULTIPLY ||
+    kind === BinaryOperatorKind.DIVIDE ||
+    kind === BinaryOperatorKind.MODULUS
+  );
 }

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

@@ -34,9 +34,7 @@ export enum NodeScenario {
   EMPTY_AST_NODE,
 }
 
-function determineNodeScenario(
-  buildContext: BuildContext,
-): NodeScenario {
+function determineNodeScenario(buildContext: BuildContext): NodeScenario {
   const { cursor, text, lenient } = buildContext;
   const isError = cursor.type.isError;
 
@@ -93,12 +91,9 @@ function determineNodeScenario(
 /*
  * Iterate through the syntax tree and consume parse tree tokens to create an AST node.
  */
-export function consumeAbstractNode(
-  buildContext: BuildContext,
-): AbstractNode | undefined {
+export function consumeAbstractNode(buildContext: BuildContext): AbstractNode | undefined {
   const { cursor } = buildContext;
-  const currentState =
-    buildContext.stateStack[buildContext.stateStack.length - 1];
+  const currentState = buildContext.stateStack[buildContext.stateStack.length - 1];
 
   // Get any leading trivia for the node
   const leadingTrivia = consumeTrivia(buildContext, false);
@@ -107,9 +102,7 @@ export function consumeAbstractNode(
   if (currentState.isEndOfSiblings) {
     if (leadingTrivia.length > 0) {
       if (buildContext.unconsumedTrivia) {
-        throw new InternalScannerError(
-          `Expected no unconsumed trivia, but found some.`,
-        );
+        throw new InternalScannerError(`Expected no unconsumed trivia, but found some.`);
       }
       buildContext.unconsumedTrivia = leadingTrivia;
     }
@@ -120,7 +113,9 @@ export function consumeAbstractNode(
   const nodeScenario = determineNodeScenario(buildContext);
 
   logger.debug(
-    currentState.indent + "consuming node: " + cursor.name +
+    currentState.indent +
+      "consuming node: " +
+      cursor.name +
       ` (scenario: ${NodeScenario[nodeScenario]})`,
   );
 
@@ -191,7 +186,9 @@ export function consumeAbstractNode(
   }
 
   logger.debug(
-    currentState.indent + "current node: " + cursor.name +
+    currentState.indent +
+      "current node: " +
+      cursor.name +
       (currentState.isEndOfSiblings ? ": end of siblings" : ""),
   );
 

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

@@ -69,9 +69,7 @@ function consumeArrayDimension(
   parentTypeId: number,
   parentTypeName: string,
 ): AbstractNode {
-  const arrayDimensionKind = arrayDimensionKindByTokenTypeId.get(
-    parentTypeId,
-  );
+  const arrayDimensionKind = arrayDimensionKindByTokenTypeId.get(parentTypeId);
 
   if (arrayDimensionKind === undefined) {
     throw new InternalScannerError(
@@ -89,8 +87,7 @@ function consumeArrayDimension(
     default: {
       const exhaustiveCheck: never = arrayDimensionKind;
       throw new InternalScannerError(
-        "Unreachable code reached, arrayDimensionKind == " +
-          exhaustiveCheck,
+        "Unreachable code reached, arrayDimensionKind == " + exhaustiveCheck,
       );
     }
   }
@@ -101,9 +98,7 @@ function consumeClassId(
   parentTypeId: number,
   parentTypeName: string,
 ): AbstractNode {
-  const classIdKind = classIdKindByTokenTypeId.get(
-    parentTypeId,
-  );
+  const classIdKind = classIdKindByTokenTypeId.get(parentTypeId);
 
   if (classIdKind === undefined) {
     throw new InternalScannerError(
@@ -119,10 +114,7 @@ function consumeClassId(
       return buildExtendedClassIdRange(buildContext);
     default: {
       const exhaustiveCheck: never = classIdKind;
-      throw new InternalScannerError(
-        "Unreachable code reached, classIdKind == " +
-          exhaustiveCheck,
-      );
+      throw new InternalScannerError("Unreachable code reached, classIdKind == " + exhaustiveCheck);
     }
   }
 }
@@ -132,9 +124,7 @@ function consumeExpression(
   parentTypeId: number,
   parentTypeName: string,
 ): AbstractNode {
-  const expressionKind = expressionKindByTokenTypeId.get(
-    parentTypeId,
-  );
+  const expressionKind = expressionKindByTokenTypeId.get(parentTypeId);
 
   if (expressionKind === undefined) {
     throw new InternalScannerError(
@@ -151,8 +141,7 @@ function consumeExpression(
     default: {
       const exhaustiveCheck: never = expressionKind;
       throw new InternalScannerError(
-        "Unreachable code reached, expressionKind == " +
-          exhaustiveCheck,
+        "Unreachable code reached, expressionKind == " + exhaustiveCheck,
       );
     }
   }
@@ -163,9 +152,7 @@ function consumeStatement(
   parentTypeId: number,
   parentTypeName: string,
 ): AbstractNode {
-  const statementKind = statementKindByTokenTypeId.get(
-    parentTypeId,
-  );
+  const statementKind = statementKindByTokenTypeId.get(parentTypeId);
 
   if (statementKind === undefined) {
     throw new InternalScannerError(
@@ -208,8 +195,7 @@ function consumeStatement(
     default: {
       const exhaustiveCheck: never = statementKind;
       throw new InternalScannerError(
-        "Unreachable code reached, statementKind == " +
-          exhaustiveCheck,
+        "Unreachable code reached, statementKind == " + exhaustiveCheck,
       );
     }
   }
@@ -220,9 +206,7 @@ function consumeStringLiteral(
   parentTypeId: number,
   parentTypeName: string,
 ): AbstractNode {
-  const stringLiteralKind = stringLiteralKindByTokenTypeId.get(
-    parentTypeId,
-  );
+  const stringLiteralKind = stringLiteralKindByTokenTypeId.get(parentTypeId);
 
   if (stringLiteralKind === undefined) {
     throw new InternalScannerError(
@@ -237,8 +221,7 @@ function consumeStringLiteral(
     default: {
       const exhaustiveCheck: never = stringLiteralKind;
       throw new InternalScannerError(
-        "Unreachable code reached, stringLiteralKind == " +
-          exhaustiveCheck,
+        "Unreachable code reached, stringLiteralKind == " + exhaustiveCheck,
       );
     }
   }
@@ -246,8 +229,7 @@ function consumeStringLiteral(
 
 export function consumeAstNode(buildContext: BuildContext): AbstractNode {
   const { cursor } = buildContext;
-  const currentState =
-    buildContext.stateStack[buildContext.stateStack.length - 1];
+  const currentState = buildContext.stateStack[buildContext.stateStack.length - 1];
   const parentTypeId = cursor.type.id;
   const parentTypeName = cursor.type.name;
 
@@ -265,9 +247,7 @@ export function consumeAstNode(buildContext: BuildContext): AbstractNode {
     );
   }
 
-  logger.debug(
-    currentState.indent + "consuming AST node: " + NodeKind[nodeKind] + "...",
-  );
+  logger.debug(currentState.indent + "consuming AST node: " + NodeKind[nodeKind] + "...");
 
   const childStack = {
     isEndOfSiblings: false,
@@ -277,9 +257,7 @@ export function consumeAstNode(buildContext: BuildContext): AbstractNode {
   buildContext.stateStack.push(childStack);
 
   if (!cursor.firstChild()) {
-    throw new InternalScannerError(
-      `Expected AST node to have children: ${NodeKind[nodeKind]}`,
-    );
+    throw new InternalScannerError(`Expected AST node to have children: ${NodeKind[nodeKind]}`);
   }
 
   let node: AbstractNode;
@@ -365,9 +343,7 @@ export function consumeAstNode(buildContext: BuildContext): AbstractNode {
       );
     default: {
       const exhaustiveCheck: never = nodeKind;
-      throw new InternalScannerError(
-        "Unreachable code reached, nodeKind == " + exhaustiveCheck,
-      );
+      throw new InternalScannerError("Unreachable code reached, nodeKind == " + exhaustiveCheck);
     }
   }
 
@@ -377,9 +353,7 @@ export function consumeAstNode(buildContext: BuildContext): AbstractNode {
 
     if (!childStack.isEndOfSiblings) {
       throw new InternalScannerError(
-        `Expected to have consumed all child nodes of ${
-          NodeKind[nodeKind]
-        }, but some remain.`,
+        `Expected to have consumed all child nodes of ${NodeKind[nodeKind]}, but some remain.`,
       );
     }
   }
@@ -388,9 +362,7 @@ export function consumeAstNode(buildContext: BuildContext): AbstractNode {
 
   if (!cursor.parent()) {
     throw new InternalScannerError(
-      `Expected to move cursor back to parent of ${
-        NodeKind[nodeKind]
-      }, but failed.`,
+      `Expected to move cursor back to parent of ${NodeKind[nodeKind]}, but failed.`,
     );
   }