@mpeggroup/mpeg-sdl-parser 4.1.2 → 4.1.4

package/src/analyser/checks/check-expression-binary.ts

@@ -27,18 +27,18 @@ function checkConstMutationViaAssignment(
   const symbol = symbolTable.lookupVariable(identifier.name);
 
   if (symbol && symbol.attributes.isConst && symbol.attributes.isComputed) {
-    return [{
-      message: "a const computed variable cannot be mutated.",
-      location: node.startToken!.getLocation(),
-    }];
+    return [
+      {
+        message: "a const computed variable cannot be mutated.",
+        location: node.startToken!.getLocation(),
+      },
+    ];
   }
 
   return [];
 }
 
-function checkModulusWithNegativeRhs(
-  node: BinaryExpression,
-): CheckResult[] {
+function checkModulusWithNegativeRhs(node: BinaryExpression): CheckResult[] {
   if (node.binaryOperatorKind !== BinaryOperatorKind.MODULUS) {
     return [];
   }
@@ -49,12 +49,14 @@ function checkModulusWithNegativeRhs(
 
   const rightLiteral = node.rightOperand as NumberLiteral;
   if (rightLiteral.value < 0) {
-    return [{
-      message:
-        "Using the modulus operator with a negative right-hand operand will lead to undefined behavior.",
-      location: node.startToken!.getLocation(),
-      isWarning: true,
-    }];
+    return [
+      {
+        message:
+          "Using the modulus operator with a negative right-hand operand will lead to undefined behavior.",
+        location: node.startToken!.getLocation(),
+        isWarning: true,
+      },
+    ];
   }
 
   return [];
@@ -71,22 +73,19 @@ function checkModulusWithFloatOperands(
   const leftType = resolveNumericType(node.leftOperand, symbolTable);
   const rightType = resolveNumericType(node.rightOperand, symbolTable);
 
-  if (
-    leftType === NumericType.FLOATING_POINT ||
-    rightType === NumericType.FLOATING_POINT
-  ) {
-    return [{
-      message: "Using the modulus operator cannot be used with float operands.",
-      location: node.startToken!.getLocation(),
-    }];
+  if (leftType === NumericType.FLOATING_POINT || rightType === NumericType.FLOATING_POINT) {
+    return [
+      {
+        message: "Using the modulus operator cannot be used with float operands.",
+        location: node.startToken!.getLocation(),
+      },
+    ];
   }
 
   return [];
 }
 
-function checkModulusWithZeroRhs(
-  node: BinaryExpression,
-): CheckResult[] {
+function checkModulusWithZeroRhs(node: BinaryExpression): CheckResult[] {
   if (node.binaryOperatorKind !== BinaryOperatorKind.MODULUS) {
     return [];
   }
@@ -97,20 +96,20 @@ function checkModulusWithZeroRhs(
 
   const rightLiteral = node.rightOperand as NumberLiteral;
   if (rightLiteral.value === 0) {
-    return [{
-      message:
-        "Using the modulus operator with a right-hand operand of zero will lead to undefined behavior.",
-      location: node.startToken!.getLocation(),
-      isWarning: true,
-    }];
+    return [
+      {
+        message:
+          "Using the modulus operator with a right-hand operand of zero will lead to undefined behavior.",
+        location: node.startToken!.getLocation(),
+        isWarning: true,
+      },
+    ];
   }
 
   return [];
 }
 
-function checkDivisionByZero(
-  node: BinaryExpression,
-): CheckResult[] {
+function checkDivisionByZero(node: BinaryExpression): CheckResult[] {
   if (node.binaryOperatorKind !== BinaryOperatorKind.DIVIDE) {
     return [];
   }
@@ -121,12 +120,14 @@ function checkDivisionByZero(
 
   const rightLiteral = node.rightOperand as NumberLiteral;
   if (rightLiteral.value === 0) {
-    return [{
-      message:
-        "The value of division where the value of the second operand is zero will lead to undefined behavior.",
-      location: node.startToken!.getLocation(),
-      isWarning: true,
-    }];
+    return [
+      {
+        message:
+          "The value of division where the value of the second operand is zero will lead to undefined behavior.",
+        location: node.startToken!.getLocation(),
+        isWarning: true,
+      },
+    ];
   }
 
   return [];
@@ -147,18 +148,20 @@ function checkIntegerDivisionWithNegatives(
     return [];
   }
 
-  const leftIsNegative = isNumberLiteral(node.leftOperand) &&
-    (node.leftOperand as NumberLiteral).value < 0;
-  const rightIsNegative = isNumberLiteral(node.rightOperand) &&
-    (node.rightOperand as NumberLiteral).value < 0;
+  const leftIsNegative =
+    isNumberLiteral(node.leftOperand) && (node.leftOperand as NumberLiteral).value < 0;
+  const rightIsNegative =
+    isNumberLiteral(node.rightOperand) && (node.rightOperand as NumberLiteral).value < 0;
 
   if (leftIsNegative || rightIsNegative) {
-    return [{
-      message:
-        "The direction of truncation for integer division with negative operands is not defined by the SDL which will lead to undefined behavior.",
-      location: node.startToken!.getLocation(),
-      isWarning: true,
-    }];
+    return [
+      {
+        message:
+          "The direction of truncation for integer division with negative operands is not defined by the SDL which will lead to undefined behavior.",
+        location: node.startToken!.getLocation(),
+        isWarning: true,
+      },
+    ];
   }
 
   return [];
@@ -174,12 +177,14 @@ function checkRightShiftOnSignedInt(
 
   const leftType = resolveNumericType(node.leftOperand, symbolTable);
   if (leftType === NumericType.INTEGER) {
-    return [{
-      message:
-        "The behaviour of the right shift operator applied to a signed int value is not defined by the SDL which will lead to undefined behavior.",
-      location: node.startToken!.getLocation(),
-      isWarning: true,
-    }];
+    return [
+      {
+        message:
+          "The behaviour of the right shift operator applied to a signed int value is not defined by the SDL which will lead to undefined behavior.",
+        location: node.startToken!.getLocation(),
+        isWarning: true,
+      },
+    ];
   }
 
   return [];
@@ -201,11 +206,12 @@ function checkLeftHandAssignmentConst(
   const symbol = symbolTable.lookupVariable(identifier.name);
 
   if (symbol && symbol.attributes.isConst) {
-    return [{
-      message:
-        "The left-hand operand of an assignment operator cannot be a const variable.",
-      location: node.startToken!.getLocation(),
-    }];
+    return [
+      {
+        message: "The left-hand operand of an assignment operator cannot be a const variable.",
+        location: node.startToken!.getLocation(),
+      },
+    ];
   }
 
   return [];

package/src/analyser/checks/check-expression-lengthof.ts

@@ -7,11 +7,7 @@ import type { Check, CheckResult } from "./check.ts";
 export const checkExpressionLengthof: Check = {
   nodeKind: NodeKind.EXPRESSION,
   subKind: ExpressionKind.LENGTHOF,
-  checkFunc: function (
-    node: LengthofExpression,
-    symbolTable,
-    _strict,
-  ): CheckResult[] {
+  checkFunc: function (node: LengthofExpression, symbolTable, _strict): CheckResult[] {
     const results: CheckResult[] = [];
 
     // Check if operand is an identifier
@@ -22,8 +18,7 @@ export const checkExpressionLengthof: Check = {
       // If variable exists and is computed, report error
       if (variable && variable.attributes.isComputed) {
         results.push({
-          message:
-            "The lengthof operator cannot be used with a computed variable.",
+          message: "The lengthof operator cannot be used with a computed variable.",
           location: node.operand.startToken!.getLocation(),
         });
       }

package/src/analyser/checks/check-expression-unary.ts

@@ -20,10 +20,8 @@ function checkConstMutationViaPostfix(
 
   if (
     expression.postfixOperator !== undefined &&
-    ((expression.postfixOperator as Token).tokenKind ===
-        TokenKind.POSTFIX_INCREMENT ||
-      (expression.postfixOperator as Token).tokenKind ===
-        TokenKind.POSTFIX_DECREMENT)
+    ((expression.postfixOperator as Token).tokenKind === TokenKind.POSTFIX_INCREMENT ||
+      (expression.postfixOperator as Token).tokenKind === TokenKind.POSTFIX_DECREMENT)
   ) {
     let targetIdentifier: Identifier | undefined;
     if (isIdentifier(expression.operand)) {
@@ -32,18 +30,13 @@ function checkConstMutationViaPostfix(
       expression.operand.nodeKind === NodeKind.EXPRESSION &&
       isIdentifier((expression.operand as UnaryExpression).operand)
     ) {
-      targetIdentifier = (expression.operand as UnaryExpression)
-        .operand as Identifier;
+      targetIdentifier = (expression.operand as UnaryExpression).operand as Identifier;
     }
 
     if (targetIdentifier) {
       const variable = symbolTable.lookupVariable(targetIdentifier.name);
 
-      if (
-        variable &&
-        variable.attributes.isConst &&
-        variable.attributes.isComputed
-      ) {
+      if (variable && variable.attributes.isConst && variable.attributes.isComputed) {
         results.push({
           message: "a const computed variable cannot be mutated.",
           location: expression.startToken!.getLocation(),
@@ -123,9 +116,9 @@ function checkUninitializedComputedVariableAccess(
       // Check if the variable definition has no initial value
       // For computed variables, this would be AbstractElementaryTypeDefinition
       if (
-        (variable.node.nodeKind === NodeKind.STATEMENT) &&
-        ((variable.node as AbstractStatement).statementKind ===
-          StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION)
+        variable.node.nodeKind === NodeKind.STATEMENT &&
+        (variable.node as AbstractStatement).statementKind ===
+          StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION
       ) {
         const definition = variable.node as { value?: unknown };
 
@@ -133,8 +126,7 @@ function checkUninitializedComputedVariableAccess(
           results.push({
             message:
               "Accessing a computed variable value before it is initialised will result in undefined behaviour.",
-            location: expression.operand.startToken?.getLocation() ||
-              expression.operand.leadingTrivia?.[0]?.location!,
+            location: expression.operand.getLocation(),
             isWarning: true,
           });
         }
@@ -157,9 +149,7 @@ export const checkExpressionUnary: Check = {
 
     results.push(...checkConstMutationViaPostfix(expression, symbolTable));
     results.push(...checkArrayDimensionCountMismatch(expression, symbolTable));
-    results.push(
-      ...checkUninitializedComputedVariableAccess(expression, symbolTable),
-    );
+    results.push(...checkUninitializedComputedVariableAccess(expression, symbolTable));
 
     return results;
   },

package/src/analyser/checks/check-identifier.ts

@@ -48,11 +48,7 @@ const reservedIdentifiers = getReservedIdentifiers();
 
 export const checkIdentifier: Check = {
   nodeKind: NodeKind.IDENTIFIER,
-  checkFunc: function (
-    node: Identifier,
-    _symbolTable,
-    _strict,
-  ): CheckResult[] {
+  checkFunc: function (node: Identifier, _symbolTable, _strict): CheckResult[] {
     const results: CheckResult[] = [];
 
     const identifierName = node.name.toLowerCase();
@@ -61,8 +57,7 @@ export const checkIdentifier: Check = {
       results.push({
         message:
           "It is illegal to define an identifier which conflicts (ignoring case) with SDL syntax items such as keywords, binary, hexadecimal and string literal prefixes.",
-        location: node.startToken?.getLocation() ||
-          node.leadingTrivia?.[0]?.location!,
+        location: node.getLocation(),
       });
     }
 

package/src/analyser/checks/check-if-statement.ts

@@ -4,16 +4,10 @@ import type { IfStatement } from "../../ast/node/if-statement.ts";
 import type { AbstractStatement } from "../../ast/node/abstract-statement.ts";
 import type { SymbolTable } from "../symbol-table.ts";
 import type { Check, CheckResult } from "./check.ts";
-import {
-  isCaseClause,
-  isDefaultClause,
-  isStatement,
-} from "../../ast/util/types.ts";
+import { isCaseClause, isDefaultClause, isStatement } from "../../ast/util/types.ts";
 import type { SwitchStatement } from "../../ast/node/switch-statement.ts";
 
-export function collectMemberVariableNames(
-  statement: AbstractStatement,
-): Set<string> {
+export function collectMemberVariableNames(statement: AbstractStatement): Set<string> {
   const names = new Set<string>();
 
   function traverse(stmt: AbstractStatement) {
@@ -72,10 +66,7 @@ export function collectMemberVariableNames(
               }
             }
           }
-          if (
-            isDefaultClause(switchStmt.defaultClause) &&
-            switchStmt.defaultClause.statements
-          ) {
+          if (isDefaultClause(switchStmt.defaultClause) && switchStmt.defaultClause.statements) {
             for (const nestedStmt of switchStmt.defaultClause.statements) {
               traverse(nestedStmt as AbstractStatement);
             }
@@ -91,9 +82,7 @@ export function collectMemberVariableNames(
   return names;
 }
 
-function collectAllBranchMemberNames(
-  statement: AbstractStatement,
-): Set<string> {
+function collectAllBranchMemberNames(statement: AbstractStatement): Set<string> {
   const allNames = new Set<string>();
 
   function addBranchNames(stmt: AbstractStatement) {

package/src/analyser/checks/check-map-declaration.ts

@@ -42,9 +42,9 @@ function checkOutputValuesTypeMatch(
     isIdentifier(declaration.outputClassIdentifier)
   ) {
     const className = declaration.outputClassIdentifier.name;
-    const classScope = symbolTable.getGlobalScope().children.find(
-      (scope) => scope.name === className && scope.kind === ScopeKind.CLASS,
-    );
+    const classScope = symbolTable
+      .getGlobalScope()
+      .children.find((scope) => scope.name === className && scope.kind === ScopeKind.CLASS);
 
     if (classScope?.classMemberSymbols) {
       const expectedMemberCount = classScope.classMemberSymbols.size;
@@ -84,9 +84,9 @@ function hasParsableMembers(
   }
   visited.add(className);
 
-  const classScope = symbolTable.getGlobalScope().children.find(
-    (scope) => scope.name === className && scope.kind === ScopeKind.CLASS,
-  );
+  const classScope = symbolTable
+    .getGlobalScope()
+    .children.find((scope) => scope.name === className && scope.kind === ScopeKind.CLASS);
 
   if (!classScope?.classMemberSymbols) {
     return false;
@@ -99,11 +99,7 @@ function hasParsableMembers(
       }
       if (
         entry.symbol.attributes.classType &&
-        hasParsableMembers(
-          entry.symbol.attributes.classType,
-          symbolTable,
-          visited,
-        )
+        hasParsableMembers(entry.symbol.attributes.classType, symbolTable, visited)
       ) {
         return true;
       }
@@ -127,12 +123,14 @@ function checkParsableClassOutput(
   const className = declaration.outputClassIdentifier.name;
 
   if (hasParsableMembers(className, symbolTable, new Set())) {
-    return [{
-      message:
-        "Declaring a map with an output_value consisting of a class with parsable members will result in undefined behaviour.",
-      location: declaration.outputClassIdentifier.startToken!.getLocation(),
-      isWarning: true,
-    }];
+    return [
+      {
+        message:
+          "Declaring a map with an output_value consisting of a class with parsable members will result in undefined behaviour.",
+        location: declaration.outputClassIdentifier.startToken!.getLocation(),
+        isWarning: true,
+      },
+    ];
   }
 
   return [];

package/src/analyser/checks/check-map-definition.ts

@@ -29,21 +29,17 @@ function checkMapTypeMatchesDeclaration(
 
   // Compare element types
   const defHasElementaryType = definition.elementaryType !== undefined;
-  const declHasElementaryType =
-    mapDeclaration.outputElementaryType !== undefined;
+  const declHasElementaryType = mapDeclaration.outputElementaryType !== undefined;
   const defHasClassType = definition.classIdentifier !== undefined;
   const declHasClassType = mapDeclaration.outputClassIdentifier !== undefined;
 
-  if (
-    defHasElementaryType !== declHasElementaryType ||
-    defHasClassType !== declHasClassType
-  ) {
-    const location = definition.elementaryType?.startToken?.getLocation() ||
+  if (defHasElementaryType !== declHasElementaryType || defHasClassType !== declHasClassType) {
+    const location =
+      definition.elementaryType?.startToken?.getLocation() ||
       definition.classIdentifier?.startToken?.getLocation() ||
       definition.mapIdentifier.startToken!.getLocation();
     results.push({
-      message:
-        "The type of the map definition must match the output_type of the map declaration.",
+      message: "The type of the map definition must match the output_type of the map declaration.",
       location,
     });
   } else if (defHasElementaryType && declHasElementaryType) {
@@ -59,17 +55,13 @@ function checkMapTypeMatchesDeclaration(
       k2: ElementaryTypeKind | undefined,
     ): boolean => {
       if (k1 === undefined || k2 === undefined) return false;
-      const intTypes = new Set([
-        ElementaryTypeKind.INTEGER,
-        ElementaryTypeKind.UNSIGNED_INTEGER,
-      ]);
+      const intTypes = new Set([ElementaryTypeKind.INTEGER, ElementaryTypeKind.UNSIGNED_INTEGER]);
       return intTypes.has(k1) && intTypes.has(k2);
     };
 
     if (
       defType.nodeKind !== declType.nodeKind ||
-      (defTypeKind !== declTypeKind &&
-        !isIntegerCompatible(defTypeKind, declTypeKind))
+      (defTypeKind !== declTypeKind && !isIntegerCompatible(defTypeKind, declTypeKind))
     ) {
       results.push({
         message:
@@ -83,10 +75,7 @@ function checkMapTypeMatchesDeclaration(
       isIdentifier(definition.classIdentifier) &&
       isIdentifier(mapDeclaration.outputClassIdentifier)
     ) {
-      if (
-        definition.classIdentifier.name !==
-          mapDeclaration.outputClassIdentifier.name
-      ) {
+      if (definition.classIdentifier.name !== mapDeclaration.outputClassIdentifier.name) {
         results.push({
           message:
             "The type of the map definition must match the output_type of the map declaration.",
@@ -109,9 +98,7 @@ export const checkMapDefinition: Check = {
   ): CheckResult[] {
     const results: CheckResult[] = [];
 
-    results.push(
-      ...checkMapTypeMatchesDeclaration(definition, symbolTable, strict),
-    );
+    results.push(...checkMapTypeMatchesDeclaration(definition, symbolTable, strict));
 
     return results;
   },

package/src/analyser/checks/check-number-literal-float.ts

@@ -6,19 +6,14 @@ import type { Check, CheckResult } from "./check.ts";
 export const checkNumberLiteralFloat: Check = {
   nodeKind: NodeKind.NUMBER_LITERAL,
   subKind: NumberLiteralKind.FLOATING_POINT,
-  checkFunc: function (
-    node: NumberLiteral,
-    _symbolTable,
-    _strict,
-  ): CheckResult[] {
+  checkFunc: function (node: NumberLiteral, _symbolTable, _strict): CheckResult[] {
     const results: CheckResult[] = [];
 
     if (Object.is(node.value, -0)) {
       results.push({
         message:
           "Usage of signed zero for a floating point literal will lead to undefined behaviour.",
-        location: node.startToken?.getLocation() ||
-          node.leadingTrivia?.[0]?.location!,
+        location: node.getLocation(),
         isWarning: true,
       });
     }

package/src/analyser/checks/check-parameter-list.ts

@@ -6,11 +6,7 @@ import type { Check, CheckResult } from "./check.ts";
 
 export const checkParameterList: Check = {
   nodeKind: NodeKind.PARAMETER_LIST,
-  checkFunc: function (
-    node: ParameterList,
-    _symbolTable,
-    strict: boolean,
-  ): CheckResult[] {
+  checkFunc: function (node: ParameterList, _symbolTable, strict: boolean): CheckResult[] {
     const results: CheckResult[] = [];
 
     for (const param of node.parameters) {
@@ -22,15 +18,10 @@ export const checkParameterList: Check = {
       // Check if both elementaryType and classIdentifier are undefined/null
       // This indicates a string type parameter which is not supported
       if (!parameter.elementaryType && !parameter.classIdentifier) {
-        const identifier = getRequiredIdentifier(
-          parameter.identifier,
-          parameter,
-          strict,
-        );
+        const identifier = getRequiredIdentifier(parameter.identifier, parameter, strict);
         if (identifier) {
           results.push({
-            message:
-              "String variables are not supported in class parameter lists.",
+            message: "String variables are not supported in class parameter lists.",
             location: identifier.startToken!.getLocation(),
           });
         }

package/src/analyser/checks/check-specification.ts

@@ -7,11 +7,7 @@ import type { Check, CheckResult } from "./check.ts";
 
 export const checkSpecification: Check = {
   nodeKind: NodeKind.SPECIFICATION,
-  checkFunc: function (
-    node: Specification,
-    _symbolTable,
-    _strict,
-  ): CheckResult[] {
+  checkFunc: function (node: Specification, _symbolTable, _strict): CheckResult[] {
     const results: CheckResult[] = [];
 
     for (const child of node.children) {
@@ -21,17 +17,13 @@ export const checkSpecification: Check = {
 
       const statement = child;
 
-      if (
-        statement.statementKind ===
-          StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION
-      ) {
+      if (statement.statementKind === StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION) {
         const definition = statement as ComputedElementaryTypeDefinition;
         if (definition.constKeyword === undefined) {
           results.push({
             message:
               "The only items that may be present in global scope are: constant computed elementary variable definitions, map declarations, class declarations.",
-            location: child.startToken?.getLocation() ||
-              child.leadingTrivia?.[0]?.location!,
+            location: child.getLocation(),
           });
         }
       } else if (statement.statementKind === StatementKind.MAP_DECLARATION) {
@@ -42,8 +34,7 @@ export const checkSpecification: Check = {
         results.push({
           message:
             "The only items that may be present in global scope are: constant computed elementary variable definitions, map declarations, class declarations.",
-          location: child.startToken?.getLocation() ||
-            child.leadingTrivia?.[0]?.location!,
+          location: child.getLocation(),
         });
       }
     }

package/src/analyser/checks/check-switch-statement.ts

@@ -6,16 +6,10 @@ import type { DefaultClause } from "../../ast/node/default-clause.ts";
 import type { AbstractStatement } from "../../ast/node/abstract-statement.ts";
 import type { SymbolTable } from "../symbol-table.ts";
 import type { Check, CheckResult } from "./check.ts";
-import {
-  isCaseClause,
-  isDefaultClause,
-  isStatement,
-} from "../../ast/util/types.ts";
+import { isCaseClause, isDefaultClause, isStatement } from "../../ast/util/types.ts";
 import { collectMemberVariableNames } from "./check-if-statement.ts";
 
-function collectMemberVariableNamesFromCaseClause(
-  caseClause: CaseClause,
-): Set<string> {
+function collectMemberVariableNamesFromCaseClause(caseClause: CaseClause): Set<string> {
   const names = new Set<string>();
 
   for (const stmt of caseClause.statements) {
@@ -28,9 +22,7 @@ function collectMemberVariableNamesFromCaseClause(
   return names;
 }
 
-function collectMemberVariableNamesFromDefaultClause(
-  defaultClause: DefaultClause,
-): Set<string> {
+function collectMemberVariableNamesFromDefaultClause(defaultClause: DefaultClause): Set<string> {
   const names = new Set<string>();
 
   for (const stmt of defaultClause.statements) {
@@ -45,15 +37,12 @@ function collectMemberVariableNamesFromDefaultClause(
   return names;
 }
 
-function checkPossibleDuplicateMembers(
-  switchStatement: SwitchStatement,
-): CheckResult[] {
+function checkPossibleDuplicateMembers(switchStatement: SwitchStatement): CheckResult[] {
   const results: CheckResult[] = [];
 
   // Collect member variable names from all case clauses and default clause
-  const allMemberNamesByClause: Array<
-    { names: Set<string>; clause: CaseClause | DefaultClause }
-  > = [];
+  const allMemberNamesByClause: Array<{ names: Set<string>; clause: CaseClause | DefaultClause }> =
+    [];
 
   // Process case clauses
   for (const caseClause of switchStatement.caseClauses) {
@@ -68,9 +57,7 @@ function checkPossibleDuplicateMembers(
 
   // Process default clause
   if (isDefaultClause(switchStatement.defaultClause)) {
-    const names = collectMemberVariableNamesFromDefaultClause(
-      switchStatement.defaultClause,
-    );
+    const names = collectMemberVariableNamesFromDefaultClause(switchStatement.defaultClause);
 
     if (names.size > 0) {
       allMemberNamesByClause.push({
@@ -108,9 +95,7 @@ function checkPossibleDuplicateMembers(
   return results;
 }
 
-function checkDefiniteDuplicateMembers(
-  switchStatement: SwitchStatement,
-): CheckResult[] {
+function checkDefiniteDuplicateMembers(switchStatement: SwitchStatement): CheckResult[] {
   const results: CheckResult[] = [];
 
   // Collect member variable names from all case clauses
@@ -130,9 +115,7 @@ function checkDefiniteDuplicateMembers(
   let defaultMemberNames = new Set<string>();
 
   if (isDefaultClause(switchStatement.defaultClause)) {
-    defaultMemberNames = collectMemberVariableNamesFromDefaultClause(
-      switchStatement.defaultClause,
-    );
+    defaultMemberNames = collectMemberVariableNamesFromDefaultClause(switchStatement.defaultClause);
   }
 
   // If we have at least 2 clauses with variables
@@ -154,7 +137,8 @@ function checkDefiniteDuplicateMembers(
 
       // If there's a default clause, it must also have the variable
       if (
-        appearsInAll && isDefaultClause(switchStatement.defaultClause) &&
+        appearsInAll &&
+        isDefaultClause(switchStatement.defaultClause) &&
         defaultMemberNames.size > 0
       ) {
         if (!defaultMemberNames.has(name)) {