@mpeggroup/mpeg-sdl-parser 4.1.1 → 4.1.3

package/src/ast/node/map-definition.ts

@@ -19,9 +19,6 @@ export class MapDefinition extends AbstractStatement {
     public readonly semicolonPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      StatementKind.MAP_DEFINITION,
-      children,
-    );
+    super(StatementKind.MAP_DEFINITION, children);
   }
 }

package/src/ast/node/number-literal.ts

@@ -12,7 +12,5 @@ export class NumberLiteral extends AbstractCompositeNode {
     public readonly literals: OneToManyList<Token>,
   ) {
     super(NodeKind.NUMBER_LITERAL, literals);
-    this.numberLiteralKind = numberLiteralKind;
-    this.value = value;
   }
 }

package/src/ast/node/parameter-list.ts

@@ -1,8 +1,4 @@
-import type {
-  OneToManyList,
-  RequiredNode,
-  ZeroToManyList,
-} from "../util/types.ts";
+import type { OneToManyList, RequiredNode, ZeroToManyList } from "../util/types.ts";
 import { AbstractCompositeNode } from "./abstract-composite-node.ts";
 import type { AbstractNode } from "./abstract-node.ts";
 import { NodeKind } from "./enum/node-kind.ts";
@@ -17,9 +13,6 @@ export class ParameterList extends AbstractCompositeNode {
     public readonly closeParenthesisPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.PARAMETER_LIST,
-      children,
-    );
+    super(NodeKind.PARAMETER_LIST, children);
   }
 }

package/src/ast/node/parameter-value-list.ts

@@ -1,8 +1,4 @@
-import type {
-  OneToManyList,
-  RequiredNode,
-  ZeroToManyList,
-} from "../util/types.ts";
+import type { OneToManyList, RequiredNode, ZeroToManyList } from "../util/types.ts";
 import { AbstractCompositeNode } from "./abstract-composite-node.ts";
 import type { AbstractExpression } from "./abstract-expression.ts";
 import type { AbstractNode } from "./abstract-node.ts";
@@ -14,16 +10,11 @@ import type { Token } from "./token.ts";
 export class ParameterValueList extends AbstractCompositeNode {
   constructor(
     public readonly openParenthesisPunctuator: RequiredNode<Token>,
-    public readonly values: OneToManyList<
-      AbstractExpression | Identifier | NumberLiteral
-    >,
+    public readonly values: OneToManyList<AbstractExpression | Identifier | NumberLiteral>,
     public readonly commaPunctuators: ZeroToManyList<Token>,
     public readonly closeParenthesisPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.PARAMETER_VALUE_LIST,
-      children,
-    );
+    super(NodeKind.PARAMETER_VALUE_LIST, children);
   }
 }

package/src/ast/node/parameter.ts

@@ -12,9 +12,6 @@ export class Parameter extends AbstractCompositeNode {
     public readonly identifier: RequiredNode<Identifier>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.PARAMETER,
-      children,
-    );
+    super(NodeKind.PARAMETER, children);
   }
 }

package/src/ast/node/partial-array-dimension.ts

@@ -11,18 +11,11 @@ export class PartialArrayDimension extends AbstractArrayDimension {
   constructor(
     openBracketPunctuator: RequiredNode<Token>,
     public readonly innerOpenBracketPunctuator: RequiredNode<Token>,
-    public readonly index: RequiredNode<
-      AbstractExpression | Identifier | NumberLiteral
-    >,
+    public readonly index: RequiredNode<AbstractExpression | Identifier | NumberLiteral>,
     public readonly innerCloseBracketPunctuator: RequiredNode<Token>,
     closeBracketPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      ArrayDimensionKind.PARTIAL,
-      openBracketPunctuator,
-      closeBracketPunctuator,
-      children,
-    );
+    super(ArrayDimensionKind.PARTIAL, openBracketPunctuator, closeBracketPunctuator, children);
   }
 }

package/src/ast/node/specification.ts

@@ -7,15 +7,8 @@ import type { ZeroToManyList } from "../util/types.ts";
 
 export class Specification extends AbstractCompositeNode {
   constructor(
-    globals: ZeroToManyList<
-      | ComputedElementaryTypeDefinition
-      | MapDeclaration
-      | ClassDeclaration
-    >,
+    globals: ZeroToManyList<ComputedElementaryTypeDefinition | MapDeclaration | ClassDeclaration>,
   ) {
-    super(
-      NodeKind.SPECIFICATION,
-      globals,
-    );
+    super(NodeKind.SPECIFICATION, globals);
   }
 }

package/src/ast/node/string-definition.ts

@@ -20,9 +20,6 @@ export class StringDefinition extends AbstractStatement {
     public readonly semicolonPunctuator: RequiredNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      StatementKind.STRING_DEFINITION,
-      children,
-    );
+    super(StatementKind.STRING_DEFINITION, children);
   }
 }

package/src/ast/node/string-literal.ts

@@ -13,9 +13,6 @@ export class StringLiteral extends AbstractCompositeNode {
     public readonly literals: OneToManyList<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      NodeKind.STRING_LITERAL,
-      children,
-    );
+    super(NodeKind.STRING_LITERAL, children);
   }
 }

package/src/ast/node/switch-statement.ts

@@ -5,11 +5,7 @@ import type { Identifier } from "./identifier.ts";
 import type { NumberLiteral } from "./number-literal.ts";
 import type { CaseClause } from "./case-clause.ts";
 import type { DefaultClause } from "./default-clause.ts";
-import type {
-  OptionalNode,
-  RequiredNode,
-  ZeroToManyList,
-} from "../util/types.ts";
+import type { OptionalNode, RequiredNode, ZeroToManyList } from "../util/types.ts";
 import type { Token } from "./token.ts";
 import type { AbstractNode } from "./abstract-node.ts";
 
@@ -17,9 +13,7 @@ export class SwitchStatement extends AbstractStatement {
   constructor(
     public readonly switchKeyword: RequiredNode<Token>,
     public readonly openParenthesisPunctuator: RequiredNode<Token>,
-    public readonly expression: RequiredNode<
-      AbstractExpression | Identifier | NumberLiteral
-    >,
+    public readonly expression: RequiredNode<AbstractExpression | Identifier | NumberLiteral>,
     public readonly closeParenthesisPunctuator: RequiredNode<Token>,
     public readonly openBracePunctuator: RequiredNode<Token>,
     public readonly caseClauses: ZeroToManyList<CaseClause>,

package/src/ast/node/token.ts

@@ -9,9 +9,7 @@ export class Token extends AbstractLeafNode {
     public readonly text: string,
     private readonly location: Location,
   ) {
-    super(
-      NodeKind.TOKEN,
-    );
+    super(NodeKind.TOKEN);
   }
 
   getLocation(): Location {

package/src/ast/node/unary-expression.ts

@@ -12,20 +12,13 @@ export class UnaryExpression extends AbstractExpression {
   constructor(
     public readonly unaryOperator: OptionalNode<Token>,
     public readonly openParenthesisPunctuator: OptionalNode<Token>,
-    public readonly operand: RequiredNode<
-      | AbstractExpression
-      | Identifier
-      | NumberLiteral
-    >,
+    public readonly operand: RequiredNode<AbstractExpression | Identifier | NumberLiteral>,
     public readonly closeParenthesisPunctuator: OptionalNode<Token>,
     public readonly arrayElementAccess: OptionalNode<ArrayElementAccess>,
     public readonly classMemberAccess: OptionalNode<ClassMemberAccess>,
     public readonly postfixOperator: OptionalNode<Token>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      ExpressionKind.UNARY,
-      children,
-    );
+    super(ExpressionKind.UNARY, children);
   }
 }

package/src/ast/node/unexpected-error.ts

@@ -4,9 +4,7 @@ import type { AbstractNode } from "./abstract-node.ts";
 import { NodeKind } from "./enum/node-kind.ts";
 
 export class UnexpectedError extends AbstractCompositeNode {
-  constructor(
-    public readonly unexpectedToken: RequiredNode<AbstractNode>,
-  ) {
+  constructor(public readonly unexpectedToken: RequiredNode<AbstractNode>) {
     super(NodeKind.UNEXPECTED_ERROR, [unexpectedToken]);
   }
 }

package/src/ast/node/while-statement.ts

@@ -11,16 +11,11 @@ export class WhileStatement extends AbstractStatement {
   constructor(
     public readonly whileKeyword: RequiredNode<Token>,
     public readonly openParenthesisPunctuator: RequiredNode<Token>,
-    public readonly condition: RequiredNode<
-      AbstractExpression | Identifier | NumberLiteral
-    >,
+    public readonly condition: RequiredNode<AbstractExpression | Identifier | NumberLiteral>,
     public readonly closeParenthesisPunctuator: RequiredNode<Token>,
     public readonly statement: RequiredNode<AbstractStatement>,
     children: Array<AbstractNode>,
   ) {
-    super(
-      StatementKind.WHILE,
-      children,
-    );
+    super(StatementKind.WHILE, children);
   }
 }

package/src/ast/util/types.ts

@@ -28,111 +28,83 @@ export type ZeroToManyList<T> = Array<T | UnexpectedError>;
 
 export type OneToManyList<T> = Array<T | MissingError | UnexpectedError>;
 
-export function isCompositeNode(
-  node: AbstractNode | undefined,
-): node is AbstractCompositeNode {
+export function isCompositeNode(node: AbstractNode | undefined): node is AbstractCompositeNode {
   return node?.isComposite === true;
 }
 
-export function isToken(
-  node: AbstractNode | undefined,
-): node is Token {
+export function isToken(node: AbstractNode | undefined): node is Token {
   return node?.nodeKind === NodeKind.TOKEN;
 }
 
-export function isUnexpectedError(
-  node: AbstractNode | undefined,
-): node is UnexpectedError {
+export function isUnexpectedError(node: AbstractNode | undefined): node is UnexpectedError {
   return node?.nodeKind === NodeKind.UNEXPECTED_ERROR;
 }
 
-export function isMissingError(
-  node: AbstractNode | undefined,
-): node is MissingError {
-  return node?.nodeKind === NodeKind.TOKEN &&
-    ((node as Token).tokenKind === TokenKind.ERROR_MISSING_TOKEN);
+export function isMissingError(node: AbstractNode | undefined): node is MissingError {
+  return (
+    node?.nodeKind === NodeKind.TOKEN && (node as Token).tokenKind === TokenKind.ERROR_MISSING_TOKEN
+  );
 }
 
-export function isStatement(
-  node: AbstractNode | undefined,
-): node is AbstractStatement {
-  return node?.nodeKind === NodeKind.STATEMENT &&
-    (Object.values(StatementKind) as number[]).includes(
-      (node as AbstractStatement).statementKind,
-    );
+export function isStatement(node: AbstractNode | undefined): node is AbstractStatement {
+  return (
+    node?.nodeKind === NodeKind.STATEMENT &&
+    (Object.values(StatementKind) as number[]).includes((node as AbstractStatement).statementKind)
+  );
 }
 
-export function isIdentifier(
-  node: AbstractNode | undefined,
-): node is Identifier {
+export function isIdentifier(node: AbstractNode | undefined): node is Identifier {
   return node?.nodeKind === NodeKind.IDENTIFIER;
 }
 
-export function isElementaryType(
-  node: AbstractNode | undefined,
-): node is ElementaryType {
+export function isElementaryType(node: AbstractNode | undefined): node is ElementaryType {
   return node?.nodeKind === NodeKind.ELEMENTARY_TYPE;
 }
 
-export function isAbstractExpression(
-  node: AbstractNode | undefined,
-): node is AbstractExpression {
+export function isAbstractExpression(node: AbstractNode | undefined): node is AbstractExpression {
   return node?.nodeKind === NodeKind.EXPRESSION;
 }
 
-export function isUnaryExpression(
-  node: AbstractNode | undefined,
-): node is AbstractExpression {
-  return (node?.nodeKind === NodeKind.EXPRESSION) &&
-    (node as AbstractExpression).expressionKind === ExpressionKind.UNARY;
+export function isUnaryExpression(node: AbstractNode | undefined): node is AbstractExpression {
+  return (
+    node?.nodeKind === NodeKind.EXPRESSION &&
+    (node as AbstractExpression).expressionKind === ExpressionKind.UNARY
+  );
 }
 
-export function isNumberLiteral(
-  node: AbstractNode | undefined,
-): node is NumberLiteral {
+export function isNumberLiteral(node: AbstractNode | undefined): node is NumberLiteral {
   return node?.nodeKind === NodeKind.NUMBER_LITERAL;
 }
 
 export function isComputedElementaryTypeDefinition(
   node: AbstractNode | undefined,
 ): node is ComputedElementaryTypeDefinition {
-  return node?.nodeKind === NodeKind.STATEMENT &&
-    (node as AbstractStatement).statementKind ===
-      StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION;
+  return (
+    node?.nodeKind === NodeKind.STATEMENT &&
+    (node as AbstractStatement).statementKind === StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION
+  );
 }
 
-export function isExpandableModifier(
-  node: AbstractNode | undefined,
-): node is ExpandableModifier {
+export function isExpandableModifier(node: AbstractNode | undefined): node is ExpandableModifier {
   return node?.nodeKind === NodeKind.EXPANDABLE_MODIFIER;
 }
 
-export function isAlignedModifier(
-  node: AbstractNode | undefined,
-): node is AlignedModifier {
+export function isAlignedModifier(node: AbstractNode | undefined): node is AlignedModifier {
   return node?.nodeKind === NodeKind.ALIGNED_MODIFIER;
 }
 
-export function isExtendsModifier(
-  node: AbstractNode | undefined,
-): node is ExtendsModifier {
+export function isExtendsModifier(node: AbstractNode | undefined): node is ExtendsModifier {
   return node?.nodeKind === NodeKind.EXTENDS_MODIFIER;
 }
 
-export function isCaseClause(
-  node: AbstractNode | undefined,
-): node is CaseClause {
+export function isCaseClause(node: AbstractNode | undefined): node is CaseClause {
   return node?.nodeKind === NodeKind.CASE_CLAUSE;
 }
 
-export function isDefaultClause(
-  node: AbstractNode | undefined,
-): node is DefaultClause {
+export function isDefaultClause(node: AbstractNode | undefined): node is DefaultClause {
   return node?.nodeKind === NodeKind.DEFAULT_CLAUSE;
 }
 
-export function isBitModifier(
-  node: AbstractNode | undefined,
-): node is BitModifier {
+export function isBitModifier(node: AbstractNode | undefined): node is BitModifier {
   return node?.nodeKind === NodeKind.BIT_MODIFIER;
 }

package/src/ast/visitor/traversing-visitor.ts

@@ -31,25 +31,18 @@ export class TraversingVisitor implements NodeVisitor {
       }
 
       if (node.leadingTrivia) {
-        tokenText += ` => leadingTrivia: ${
-          node.leadingTrivia.map((t) => `"${t.text.replace(/\n/g, "\\n")}"`)
-            .join(", ")
-        }`;
+        tokenText += ` => leadingTrivia: ${node.leadingTrivia
+          .map((t) => `"${t.text.replace(/\n/g, "\\n")}"`)
+          .join(", ")}`;
       }
 
       if (node.trailingTrivia) {
-        tokenText += ` => trailingTrivia: ${
-          node.trailingTrivia.map((t) => `"${t.text.replace(/\n/g, "\\n")}"`)
-            .join(", ")
-        }`;
+        tokenText += ` => trailingTrivia: ${node.trailingTrivia
+          .map((t) => `"${t.text.replace(/\n/g, "\\n")}"`)
+          .join(", ")}`;
       }
 
-      logger.debug(
-        "visit: %s %s%s",
-        indent,
-        NodeKind[node.nodeKind],
-        tokenText,
-      );
+      logger.debug("visit: %s %s%s", indent, NodeKind[node.nodeKind], tokenText);
     }
 
     if (isCompositeNode(node)) {

package/src/completion/completion-rules.ts

@@ -59,31 +59,22 @@ const logger = getLogger("completionRules");
 /**
  * A map from parent token type ID to a HierarchicalSearch of previous sibling token type IDs to expected token type IDs.
  */
-export const completionRulesByParentMap: Map<
-  number,
-  HierarchicalSearch<number[]>
-> = new Map();
+export const completionRulesByParentMap: Map<number, HierarchicalSearch<number[]>> = new Map();
 
 /**
  * A map from token type ID to potential starting syntactic tokens.
  */
-export const potentialSyntacticTokensByTokenTypeId: Map<number, string[]> =
-  new Map();
+export const potentialSyntacticTokensByTokenTypeId: Map<number, string[]> = new Map();
 
 type CompletionRule = {
   previous: number | number[];
   expected: number | number[];
 };
 
-function addRulesForParent(
-  parentTokenId: number,
-  rules: CompletionRule | CompletionRule[],
-) {
+function addRulesForParent(parentTokenId: number, rules: CompletionRule | CompletionRule[]) {
   if (completionRulesByParentMap.has(parentTokenId)) {
     throw new InternalScannerError(
-      `Completion rules for parent token ${
-        nodeTypes[parentTokenId].name
-      } already exist`,
+      `Completion rules for parent token ${nodeTypes[parentTokenId].name} already exist`,
     );
   }
 
@@ -92,32 +83,22 @@ function addRulesForParent(
   }
 
   if (rules.length === 0) {
-    logger.warn(
-      `No completion rules provided for parent token ${
-        nodeTypes[parentTokenId].name
-      }`,
-    );
+    logger.warn(`No completion rules provided for parent token ${nodeTypes[parentTokenId].name}`);
     return;
   }
 
   const hierarchicalSearch = new HierarchicalSearch<number[]>();
 
   for (const rule of rules) {
-    const previousTokens = Array.isArray(rule.previous)
-      ? rule.previous
-      : [rule.previous];
-    const expectedTokens = Array.isArray(rule.expected)
-      ? rule.expected
-      : [rule.expected];
+    const previousTokens = Array.isArray(rule.previous) ? rule.previous : [rule.previous];
+    const expectedTokens = Array.isArray(rule.expected) ? rule.expected : [rule.expected];
 
     hierarchicalSearch.set(previousTokens, expectedTokens);
   }
 
   completionRulesByParentMap.set(parentTokenId, hierarchicalSearch);
 
-  logger.debug(
-    `Added completion rules for parent token ${nodeTypes[parentTokenId].name}`,
-  );
+  logger.debug(`Added completion rules for parent token ${nodeTypes[parentTokenId].name}`);
 }
 
 /**
@@ -129,25 +110,16 @@ Object.values(TokenTypeId).forEach((tokenTypeId) => {
       addRulesForParent(TokenTypeId.AlignedModifier, alignedModifierRules);
       break;
     case TokenTypeId.AggregateOutputValue:
-      addRulesForParent(
-        TokenTypeId.AggregateOutputValue,
-        aggregateOutputValueRules,
-      );
+      addRulesForParent(TokenTypeId.AggregateOutputValue, aggregateOutputValueRules);
       break;
     case TokenTypeId.ArrayDefinition:
       addRulesForParent(TokenTypeId.ArrayDefinition, arrayDefinitionRules);
       break;
     case TokenTypeId.AssignmentExpression:
-      addRulesForParent(
-        TokenTypeId.AssignmentExpression,
-        assignmentExpressionRules,
-      );
+      addRulesForParent(TokenTypeId.AssignmentExpression, assignmentExpressionRules);
       break;
     case TokenTypeId.ArrayElementAccess:
-      addRulesForParent(
-        TokenTypeId.ArrayElementAccess,
-        arrayElementAccessRules,
-      );
+      addRulesForParent(TokenTypeId.ArrayElementAccess, arrayElementAccessRules);
       break;
     case TokenTypeId.BinaryExpression:
       addRulesForParent(TokenTypeId.BinaryExpression, binaryExpressionRules);
@@ -177,16 +149,10 @@ Object.values(TokenTypeId).forEach((tokenTypeId) => {
       addRulesForParent(TokenTypeId.CompoundStatement, compoundStatementRules);
       break;
     case TokenTypeId.ComputedArrayDefinition:
-      addRulesForParent(
-        TokenTypeId.ComputedArrayDefinition,
-        computedArrayDefinitionRules,
-      );
+      addRulesForParent(TokenTypeId.ComputedArrayDefinition, computedArrayDefinitionRules);
       break;
     case TokenTypeId.ComputedElementaryTypeDefinition:
-      addRulesForParent(
-        TokenTypeId.ComputedElementaryTypeDefinition,
-        computedElementaryTypeRules,
-      );
+      addRulesForParent(TokenTypeId.ComputedElementaryTypeDefinition, computedElementaryTypeRules);
       break;
     case TokenTypeId.DefaultClause:
       addRulesForParent(TokenTypeId.DefaultClause, defaultClauseRules);
@@ -198,40 +164,22 @@ Object.values(TokenTypeId).forEach((tokenTypeId) => {
       addRulesForParent(TokenTypeId.ElementaryType, elementaryTypeRules);
       break;
     case TokenTypeId.ElementaryTypeDefinition:
-      addRulesForParent(
-        TokenTypeId.ElementaryTypeDefinition,
-        elementaryTypeDefinitionRules,
-      );
+      addRulesForParent(TokenTypeId.ElementaryTypeDefinition, elementaryTypeDefinitionRules);
       break;
     case TokenTypeId.ElementaryTypeOutputValue:
-      addRulesForParent(
-        TokenTypeId.ElementaryTypeOutputValue,
-        elementaryTypeOutputValueRules,
-      );
+      addRulesForParent(TokenTypeId.ElementaryTypeOutputValue, elementaryTypeOutputValueRules);
       break;
     case TokenTypeId.ExpandableModifier:
-      addRulesForParent(
-        TokenTypeId.ExpandableModifier,
-        expandableModifierRules,
-      );
+      addRulesForParent(TokenTypeId.ExpandableModifier, expandableModifierRules);
       break;
     case TokenTypeId.ExplicitArrayDimension:
-      addRulesForParent(
-        TokenTypeId.ExplicitArrayDimension,
-        explicitArrayDimensionRules,
-      );
+      addRulesForParent(TokenTypeId.ExplicitArrayDimension, explicitArrayDimensionRules);
       break;
     case TokenTypeId.ExpressionStatement:
-      addRulesForParent(
-        TokenTypeId.ExpressionStatement,
-        expressionStatementRules,
-      );
+      addRulesForParent(TokenTypeId.ExpressionStatement, expressionStatementRules);
       break;
     case TokenTypeId.ExtendedClassIdRange:
-      addRulesForParent(
-        TokenTypeId.ExtendedClassIdRange,
-        extendedClassIdRangeRules,
-      );
+      addRulesForParent(TokenTypeId.ExtendedClassIdRange, extendedClassIdRangeRules);
       break;
     case TokenTypeId.ExtendsModifier:
       addRulesForParent(TokenTypeId.ExtendsModifier, extendsModifierRules);
@@ -243,19 +191,13 @@ Object.values(TokenTypeId).forEach((tokenTypeId) => {
       addRulesForParent(TokenTypeId.IfStatement, ifStatementRules);
       break;
     case TokenTypeId.ImplicitArrayDimension:
-      addRulesForParent(
-        TokenTypeId.ImplicitArrayDimension,
-        implicitArrayDimensionRules,
-      );
+      addRulesForParent(TokenTypeId.ImplicitArrayDimension, implicitArrayDimensionRules);
       break;
     case TokenTypeId.LengthAttribute:
       addRulesForParent(TokenTypeId.LengthAttribute, lengthAttributeRules);
       break;
     case TokenTypeId.LengthofExpression:
-      addRulesForParent(
-        TokenTypeId.LengthofExpression,
-        lengthofExpressionRules,
-      );
+      addRulesForParent(TokenTypeId.LengthofExpression, lengthofExpressionRules);
       break;
     case TokenTypeId.MapDeclaration:
       addRulesForParent(TokenTypeId.MapDeclaration, mapDeclarationRules);
@@ -273,16 +215,10 @@ Object.values(TokenTypeId).forEach((tokenTypeId) => {
       addRulesForParent(TokenTypeId.ParameterList, parameterListRules);
       break;
     case TokenTypeId.ParameterValueList:
-      addRulesForParent(
-        TokenTypeId.ParameterValueList,
-        parameterValueListRules,
-      );
+      addRulesForParent(TokenTypeId.ParameterValueList, parameterValueListRules);
       break;
     case TokenTypeId.PartialArrayDimension:
-      addRulesForParent(
-        TokenTypeId.PartialArrayDimension,
-        partialArrayDimensionRules,
-      );
+      addRulesForParent(TokenTypeId.PartialArrayDimension, partialArrayDimensionRules);
       break;
     case TokenTypeId.StringDefinition:
       addRulesForParent(TokenTypeId.StringDefinition, stringDefinitionRules);
@@ -390,9 +326,7 @@ Object.values(TokenTypeId).forEach((tokenTypeId) => {
       break;
     default: {
       const exhaustiveCheck: never = tokenTypeId;
-      throw new InternalScannerError(
-        "Unreachable code reached, tokenTypeId == " + exhaustiveCheck,
-      );
+      throw new InternalScannerError("Unreachable code reached, tokenTypeId == " + exhaustiveCheck);
     }
   }
 });
@@ -405,9 +339,7 @@ Object.values(TokenTypeId).forEach((tokenTypeId) => {
   const resolveTokenTypeId = (tokenTypeId: number) => {
     if (completionRulesByParentMap.has(tokenTypeId)) {
       // recurse
-      const childHierarchicalSearch = completionRulesByParentMap.get(
-        tokenTypeId,
-      )!;
+      const childHierarchicalSearch = completionRulesByParentMap.get(tokenTypeId)!;
       const childPotentialTokenTypeIds = childHierarchicalSearch.get([-1]);
 
       if (childPotentialTokenTypeIds) {