@mpeggroup/mpeg-sdl-parser 4.0.0

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

@@ -0,0 +1,206 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import { StatementKind } from "../../ast/node/enum/statement-kind.ts";
+import type { SwitchStatement } from "../../ast/node/switch-statement.ts";
+import type { CaseClause } from "../../ast/node/case-clause.ts";
+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 { collectMemberVariableNames } from "./check-if-statement.ts";
+
+function collectMemberVariableNamesFromCaseClause(
+  caseClause: CaseClause,
+): Set<string> {
+  const names = new Set<string>();
+
+  for (const stmt of caseClause.statements) {
+    const stmtNames = collectMemberVariableNames(stmt as AbstractStatement);
+    for (const name of stmtNames) {
+      names.add(name);
+    }
+  }
+
+  return names;
+}
+
+function collectMemberVariableNamesFromDefaultClause(
+  defaultClause: DefaultClause,
+): Set<string> {
+  const names = new Set<string>();
+
+  for (const stmt of defaultClause.statements) {
+    if (isStatement(stmt)) {
+      const stmtNames = collectMemberVariableNames(stmt);
+      for (const name of stmtNames) {
+        names.add(name);
+      }
+    }
+  }
+
+  return names;
+}
+
+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 }
+  > = [];
+
+  // Process case clauses
+  for (const caseClause of switchStatement.caseClauses) {
+    if (isCaseClause(caseClause)) {
+      const names = collectMemberVariableNamesFromCaseClause(caseClause);
+
+      if (names.size > 0) {
+        allMemberNamesByClause.push({ names, clause: caseClause });
+      }
+    }
+  }
+
+  // Process default clause
+  if (isDefaultClause(switchStatement.defaultClause)) {
+    const names = collectMemberVariableNamesFromDefaultClause(
+      switchStatement.defaultClause,
+    );
+
+    if (names.size > 0) {
+      allMemberNamesByClause.push({
+        names,
+        clause: switchStatement.defaultClause,
+      });
+    }
+  }
+
+  // Check for overlapping names between clauses
+  const foundOverlaps = new Set<string>();
+
+  for (let i = 0; i < allMemberNamesByClause.length; i++) {
+    for (let j = i + 1; j < allMemberNamesByClause.length; j++) {
+      const names1 = allMemberNamesByClause[i].names;
+      const names2 = allMemberNamesByClause[j].names;
+
+      for (const name of names1) {
+        if (names2.has(name)) {
+          foundOverlaps.add(name);
+        }
+      }
+    }
+  }
+
+  if (foundOverlaps.size > 0) {
+    results.push({
+      message:
+        "This switch statement may result in duplicate class member variables being declared simultaneously.",
+      location: switchStatement.startToken!.getLocation(),
+      isWarning: true,
+    });
+  }
+
+  return results;
+}
+
+function checkDefiniteDuplicateMembers(
+  switchStatement: SwitchStatement,
+): CheckResult[] {
+  const results: CheckResult[] = [];
+
+  // Collect member variable names from all case clauses
+  const allCaseMemberNames: Array<Set<string>> = [];
+
+  for (const caseClause of switchStatement.caseClauses) {
+    if (isCaseClause(caseClause)) {
+      const names = collectMemberVariableNamesFromCaseClause(caseClause);
+
+      if (names.size > 0) {
+        allCaseMemberNames.push(names);
+      }
+    }
+  }
+
+  // Collect from default clause
+  let defaultMemberNames = new Set<string>();
+
+  if (isDefaultClause(switchStatement.defaultClause)) {
+    defaultMemberNames = collectMemberVariableNamesFromDefaultClause(
+      switchStatement.defaultClause,
+    );
+  }
+
+  // If we have at least 2 clauses with variables
+  if (allCaseMemberNames.length >= 2) {
+    // Find variables that appear in ALL case clauses
+    const firstCaseNames = allCaseMemberNames[0];
+    const definiteOverlaps = new Set<string>();
+
+    for (const name of firstCaseNames) {
+      let appearsInAll = true;
+
+      // Check if it appears in all other case clauses
+      for (let i = 1; i < allCaseMemberNames.length; i++) {
+        if (!allCaseMemberNames[i].has(name)) {
+          appearsInAll = false;
+          break;
+        }
+      }
+
+      // If there's a default clause, it must also have the variable
+      if (
+        appearsInAll && isDefaultClause(switchStatement.defaultClause) &&
+        defaultMemberNames.size > 0
+      ) {
+        if (!defaultMemberNames.has(name)) {
+          appearsInAll = false;
+        }
+      }
+
+      if (appearsInAll) {
+        definiteOverlaps.add(name);
+      }
+    }
+
+    if (definiteOverlaps.size > 0) {
+      results.push({
+        message:
+          "This switch statement will result in duplicate class member variables being declared simultaneously.",
+        location: switchStatement.startToken!.getLocation()!,
+      });
+    }
+  }
+
+  return results;
+}
+
+export const checkSwitchStatement: Check = {
+  nodeKind: NodeKind.STATEMENT,
+  subKind: StatementKind.SWITCH,
+  checkFunc: function (
+    switchStatement: SwitchStatement,
+    symbolTable: SymbolTable,
+    _strict: boolean,
+  ): CheckResult[] {
+    const results: CheckResult[] = [];
+
+    // Check if we're in a class scope
+    const classScope = symbolTable.getEnclosingClassScope();
+    if (!classScope) {
+      return results; // Not in a class scope, no need to check
+    }
+
+    // Check for possible duplicate members (warning)
+    results.push(...checkPossibleDuplicateMembers(switchStatement));
+
+    // Check for definite duplicate members (error)
+    results.push(...checkDefiniteDuplicateMembers(switchStatement));
+
+    return results;
+  },
+};

package/src/analyser/checks/check.ts

@@ -0,0 +1,20 @@
+import type { AbstractCompositeNode } from "../../ast/node/abstract-composite-node.ts";
+import type { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import type { Location } from "../../location.ts";
+import type { SymbolTable } from "../symbol-table.ts";
+
+export interface CheckResult {
+  message: string;
+  location: Location;
+  isWarning?: boolean;
+}
+
+export interface Check {
+  nodeKind: NodeKind;
+  subKind?: number;
+  checkFunc(
+    node: AbstractCompositeNode,
+    symbolTable: SymbolTable,
+    strict: boolean,
+  ): CheckResult[];
+}

package/src/analyser/create-sdl-analyser.ts

@@ -0,0 +1,85 @@
+import type { Check } from "./checks/check.ts";
+import { checkArrayDefinition } from "./checks/check-array-definition.ts";
+import { checkArrayElementAccess } from "./checks/check-array-element-access.ts";
+import { checkClassDeclaration } from "./checks/check-class-declaration.ts";
+import { checkComputedArrayDefinition } from "./checks/check-computed-array-definition.ts";
+import { checkComputedElementaryTypeDefinition } from "./checks/check-computed-elementary-type-definition.ts";
+import { checkElementaryTypeDefinition } from "./checks/check-elementary-type-definition.ts";
+import { checkExpressionBinary } from "./checks/check-expression-binary.ts";
+import { checkExpressionLengthof } from "./checks/check-expression-lengthof.ts";
+import { checkExpressionUnary } from "./checks/check-expression-unary.ts";
+import { checkIdentifier } from "./checks/check-identifier.ts";
+import { checkIfStatement } from "./checks/check-if-statement.ts";
+import { checkMapDeclaration } from "./checks/check-map-declaration.ts";
+import { checkMapDefinition } from "./checks/check-map-definition.ts";
+import { checkSwitchStatement } from "./checks/check-switch-statement.ts";
+import { checkNumberLiteralFloat } from "./checks/check-number-literal-float.ts";
+import { checkParameterList } from "./checks/check-parameter-list.ts";
+import { checkSpecification } from "./checks/check-specification.ts";
+import { SdlAnalyser } from "./sdl-analyser.ts";
+
+let lenientSdlAnalyser: SdlAnalyser | undefined;
+let strictSdlAnalyser: SdlAnalyser | undefined;
+
+export const defaultChecks: Check[] = [
+  checkComputedElementaryTypeDefinition,
+  checkSpecification,
+  checkMapDeclaration,
+  checkMapDefinition,
+  checkClassDeclaration,
+  checkParameterList,
+  checkArrayDefinition,
+  checkComputedArrayDefinition,
+  checkElementaryTypeDefinition,
+  checkIdentifier,
+  checkExpressionUnary,
+  checkExpressionBinary,
+  checkExpressionLengthof,
+  checkNumberLiteralFloat,
+  checkArrayElementAccess,
+  checkIfStatement,
+  checkSwitchStatement,
+];
+
+/**
+ * Create a lenient SDL analyser and store it as a "singleton".
+ *
+ * @param checks Optional `Check` implementations to use in the analyser. If not supplied `defaultChecks` will be applied.
+ *   NOTE: When passing a value for `checks`, `defaultChecks` must be included in this value if they are to be applied.
+ */
+export function createLenientSdlAnalyser(
+  checks?: Check[] | undefined,
+): SdlAnalyser {
+  if (!lenientSdlAnalyser) {
+    lenientSdlAnalyser = new SdlAnalyser();
+
+    // Configure the parser with default checks
+    lenientSdlAnalyser = lenientSdlAnalyser.configure({
+      checks: checks || defaultChecks,
+    });
+  }
+
+  return lenientSdlAnalyser;
+}
+
+/**
+ * Create a strict SDL analyser and store it as a "singleton".
+ *
+ * @param checks Optional `Check` implementations to use in the analyser. If not supplied `defaultChecks` will be applied.
+ *   NOTE: When passing a value for `checks`, `defaultChecks` must be included in this value if they are to be applied.
+ */
+export function createStrictSdlAnalyser(
+  checks?: Check[] | undefined,
+): SdlAnalyser {
+  if (!strictSdlAnalyser) {
+    strictSdlAnalyser = new SdlAnalyser();
+
+    // Configure the parser with default checks
+    strictSdlAnalyser = strictSdlAnalyser.configure({
+      checks: checks || defaultChecks,
+      strict: true,
+    });
+  }
+
+  return strictSdlAnalyser;
+}