@mpeggroup/mpeg-sdl-parser 4.0.0

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

@@ -0,0 +1,164 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import { StatementKind } from "../../ast/node/enum/statement-kind.ts";
+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 type { SwitchStatement } from "../../ast/node/switch-statement.ts";
+
+export function collectMemberVariableNames(
+  statement: AbstractStatement,
+): Set<string> {
+  const names = new Set<string>();
+
+  function traverse(stmt: AbstractStatement) {
+    // Check if this statement declares a member variable
+    if (stmt.nodeKind === NodeKind.STATEMENT) {
+      switch (stmt.statementKind) {
+        case StatementKind.ELEMENTARY_TYPE_DEFINITION:
+        case StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION:
+        case StatementKind.ARRAY_DEFINITION:
+        case StatementKind.COMPUTED_ARRAY_DEFINITION:
+        case StatementKind.STRING_DEFINITION:
+        case StatementKind.CLASS_DEFINITION:
+        case StatementKind.MAP_DEFINITION: {
+          // These statements have an identifier property that represents the variable name
+          const stmtWithIdentifier = stmt as { identifier?: { name?: string } };
+          if (stmtWithIdentifier.identifier?.name) {
+            names.add(stmtWithIdentifier.identifier.name);
+          }
+          break;
+        }
+        case StatementKind.COMPOUND: {
+          // Recursively check compound statements
+          const compoundStmt = stmt as { statements?: AbstractStatement[] };
+          if (compoundStmt.statements) {
+            for (const nestedStmt of compoundStmt.statements) {
+              traverse(nestedStmt);
+            }
+          }
+          break;
+        }
+        case StatementKind.IF: {
+          // Recursively check if statements
+          const ifStmt = stmt as IfStatement;
+
+          if (!isStatement(ifStmt.ifStatement)) {
+            break;
+          }
+
+          traverse(ifStmt.ifStatement);
+
+          if (isStatement(ifStmt.elseStatement)) {
+            traverse(ifStmt.elseStatement);
+          }
+          break;
+        }
+        case StatementKind.SWITCH: {
+          // Recursively check switch statements
+          const switchStmt = stmt as SwitchStatement;
+
+          if (switchStmt.caseClauses) {
+            for (const caseClause of switchStmt.caseClauses) {
+              if (isCaseClause(caseClause) && caseClause.statements) {
+                for (const nestedStmt of caseClause.statements) {
+                  traverse(nestedStmt as AbstractStatement);
+                }
+              }
+            }
+          }
+          if (
+            isDefaultClause(switchStmt.defaultClause) &&
+            switchStmt.defaultClause.statements
+          ) {
+            for (const nestedStmt of switchStmt.defaultClause.statements) {
+              traverse(nestedStmt as AbstractStatement);
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  traverse(statement);
+
+  return names;
+}
+
+function collectAllBranchMemberNames(
+  statement: AbstractStatement,
+): Set<string> {
+  const allNames = new Set<string>();
+
+  function addBranchNames(stmt: AbstractStatement) {
+    const names = collectMemberVariableNames(stmt);
+    for (const name of names) {
+      allNames.add(name);
+    }
+
+    // Recursively check nested if statements (else if chains)
+    if (stmt.statementKind === StatementKind.IF) {
+      const ifStmt = stmt as IfStatement;
+      if (isStatement(ifStmt.elseStatement)) {
+        addBranchNames(ifStmt.elseStatement);
+      }
+    }
+  }
+
+  addBranchNames(statement);
+
+  return allNames;
+}
+
+export const checkIfStatement: Check = {
+  nodeKind: NodeKind.STATEMENT,
+  subKind: StatementKind.IF,
+  checkFunc: function (
+    ifStatement: IfStatement,
+    symbolTable: SymbolTable,
+    _strict: boolean,
+  ): CheckResult[] {
+    const results: CheckResult[] = [];
+
+    const classScope = symbolTable.getEnclosingClassScope();
+    if (!classScope) {
+      return results;
+    }
+
+    if (!isStatement(ifStatement.ifStatement)) {
+      return results;
+    }
+
+    const ifMemberNames = collectMemberVariableNames(ifStatement.ifStatement);
+
+    // Handle else if chains by collecting all member names from the else branch
+    let elseMemberNames = new Set<string>();
+    if (isStatement(ifStatement.elseStatement)) {
+      elseMemberNames = collectAllBranchMemberNames(ifStatement.elseStatement);
+    }
+
+    const overlappingNames: string[] = [];
+    for (const name of ifMemberNames) {
+      if (elseMemberNames.has(name)) {
+        overlappingNames.push(name);
+      }
+    }
+
+    if (overlappingNames.length > 0) {
+      results.push({
+        message:
+          "This if-then-else clauses may result in duplicate class member variables being declared simultaneously.",
+        location: ifStatement.startToken!.getLocation(),
+        isWarning: true,
+      });
+    }
+
+    return results;
+  },
+};

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

@@ -0,0 +1,180 @@
+import type { MapDeclaration } from "../../ast/node/map-declaration.ts";
+import type { MapEntry } from "../../ast/node/map-entry.ts";
+import type { AggregateOutputValue } from "../../ast/node/aggregate-output-value.ts";
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import { StatementKind } from "../../ast/node/enum/statement-kind.ts";
+import { isIdentifier, isNumberLiteral } from "../../ast/util/types.ts";
+import { ScopeKind, type SymbolTable } from "../symbol-table.ts";
+import type { Check, CheckResult } from "./check.ts";
+
+function countOutputValues(outputValue: AggregateOutputValue): number {
+  return outputValue.outputValues.length;
+}
+
+function checkOutputValuesTypeMatch(
+  declaration: MapDeclaration,
+  symbolTable: SymbolTable,
+): CheckResult[] {
+  const results: CheckResult[] = [];
+
+  if (declaration.outputElementaryType !== undefined) {
+    for (const entry of declaration.mapEntries) {
+      if (entry.nodeKind !== NodeKind.MAP_ENTRY) {
+        continue;
+      }
+      const mapEntry = entry as MapEntry;
+      if (
+        mapEntry.outputValue &&
+        mapEntry.outputValue.nodeKind === NodeKind.AGGREGATE_OUTPUT_VALUE
+      ) {
+        const outputValue = mapEntry.outputValue as AggregateOutputValue;
+        if (countOutputValues(outputValue) !== 1) {
+          results.push({
+            message:
+              "The type and number of constituent values within the aggregate output values of the map declaration must match the corresponding constituent types within the map's output_type.",
+            location: outputValue.startToken!.getLocation(),
+          });
+        }
+      }
+    }
+  } else if (
+    declaration.outputClassIdentifier !== undefined &&
+    isIdentifier(declaration.outputClassIdentifier)
+  ) {
+    const className = declaration.outputClassIdentifier.name;
+    const classScope = symbolTable.getGlobalScope().children.find(
+      (scope) => scope.name === className && scope.kind === ScopeKind.CLASS,
+    );
+
+    if (classScope?.classMemberSymbols) {
+      const expectedMemberCount = classScope.classMemberSymbols.size;
+
+      for (const entry of declaration.mapEntries) {
+        if (entry.nodeKind !== NodeKind.MAP_ENTRY) {
+          continue;
+        }
+        const mapEntry = entry as MapEntry;
+        if (
+          mapEntry.outputValue &&
+          mapEntry.outputValue.nodeKind === NodeKind.AGGREGATE_OUTPUT_VALUE
+        ) {
+          const outputValue = mapEntry.outputValue as AggregateOutputValue;
+          if (countOutputValues(outputValue) !== expectedMemberCount) {
+            results.push({
+              message:
+                "The type and number of constituent values within the aggregate output values of the map declaration must match the corresponding constituent types within the map's output_type.",
+              location: outputValue.startToken!.getLocation(),
+            });
+          }
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+function hasParsableMembers(
+  className: string,
+  symbolTable: SymbolTable,
+  visited: Set<string>,
+): boolean {
+  if (visited.has(className)) {
+    return false;
+  }
+  visited.add(className);
+
+  const classScope = symbolTable.getGlobalScope().children.find(
+    (scope) => scope.name === className && scope.kind === ScopeKind.CLASS,
+  );
+
+  if (!classScope?.classMemberSymbols) {
+    return false;
+  }
+
+  for (const memberEntries of classScope.classMemberSymbols.values()) {
+    for (const entry of memberEntries) {
+      if (entry.symbol.attributes.isComputed !== true) {
+        return true;
+      }
+      if (
+        entry.symbol.attributes.classType &&
+        hasParsableMembers(
+          entry.symbol.attributes.classType,
+          symbolTable,
+          visited,
+        )
+      ) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+function checkParsableClassOutput(
+  declaration: MapDeclaration,
+  symbolTable: SymbolTable,
+): CheckResult[] {
+  if (
+    declaration.outputClassIdentifier === undefined ||
+    !isIdentifier(declaration.outputClassIdentifier)
+  ) {
+    return [];
+  }
+
+  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 [];
+}
+
+function checkUniqueInputValues(declaration: MapDeclaration): CheckResult[] {
+  const results: CheckResult[] = [];
+  const seenValues = new Map<number, boolean>();
+
+  for (const entry of declaration.mapEntries) {
+    if (entry.nodeKind !== NodeKind.MAP_ENTRY) {
+      continue;
+    }
+    const mapEntry = entry as MapEntry;
+    if (isNumberLiteral(mapEntry.inputValue)) {
+      const value = mapEntry.inputValue.value;
+      if (seenValues.has(value)) {
+        results.push({
+          message: "Input values in a map declaration must be unique.",
+          location: mapEntry.inputValue.startToken!.getLocation(),
+        });
+      } else {
+        seenValues.set(value, true);
+      }
+    }
+  }
+
+  return results;
+}
+
+export const checkMapDeclaration: Check = {
+  nodeKind: NodeKind.STATEMENT,
+  subKind: StatementKind.MAP_DECLARATION,
+  checkFunc: function (
+    declaration: MapDeclaration,
+    symbolTable: SymbolTable,
+    _strict,
+  ): CheckResult[] {
+    return [
+      ...checkOutputValuesTypeMatch(declaration, symbolTable),
+      ...checkParsableClassOutput(declaration, symbolTable),
+      ...checkUniqueInputValues(declaration),
+    ];
+  },
+};

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

@@ -0,0 +1,118 @@
+import type { MapDefinition } from "../../ast/node/map-definition.ts";
+import type { MapDeclaration } from "../../ast/node/map-declaration.ts";
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import { StatementKind } from "../../ast/node/enum/statement-kind.ts";
+import { isIdentifier } from "../../ast/util/types.ts";
+import type { SymbolTable } from "../symbol-table.ts";
+import type { Check, CheckResult } from "./check.ts";
+import type { ElementaryType } from "../../ast/node/elementary-type.ts";
+import { ElementaryTypeKind } from "../../ast/node/enum/elementary-type-kind.ts";
+import { getElementaryTypeKind } from "../util/symbol-table-utils.ts";
+
+function checkMapTypeMatchesDeclaration(
+  definition: MapDefinition,
+  symbolTable: SymbolTable,
+  strict: boolean,
+): CheckResult[] {
+  const results: CheckResult[] = [];
+
+  if (!isIdentifier(definition.mapIdentifier)) {
+    return results;
+  }
+
+  const mapSymbol = symbolTable.lookupMap(definition.mapIdentifier.name);
+  if (!mapSymbol) {
+    return results;
+  }
+
+  const mapDeclaration = mapSymbol.node as MapDeclaration;
+
+  // Compare element types
+  const defHasElementaryType = definition.elementaryType !== 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() ||
+      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.",
+      location,
+    });
+  } else if (defHasElementaryType && declHasElementaryType) {
+    // Both have elementary types - compare them
+    const defType = definition.elementaryType! as ElementaryType;
+    const declType = mapDeclaration.outputElementaryType! as ElementaryType;
+
+    const defTypeKind = getElementaryTypeKind(defType, strict);
+    const declTypeKind = getElementaryTypeKind(declType, strict);
+
+    const isIntegerCompatible = (
+      k1: ElementaryTypeKind | undefined,
+      k2: ElementaryTypeKind | undefined,
+    ): boolean => {
+      if (k1 === undefined || k2 === undefined) return false;
+      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))
+    ) {
+      results.push({
+        message:
+          "The type of the map definition must match the output_type of the map declaration.",
+        location: definition.elementaryType!.startToken!.getLocation(),
+      });
+    }
+  } else if (defHasClassType && declHasClassType) {
+    // Both have class types - compare them
+    if (
+      isIdentifier(definition.classIdentifier) &&
+      isIdentifier(mapDeclaration.outputClassIdentifier)
+    ) {
+      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.",
+          location: definition.classIdentifier.startToken!.getLocation(),
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
+export const checkMapDefinition: Check = {
+  nodeKind: NodeKind.STATEMENT,
+  subKind: StatementKind.MAP_DEFINITION,
+  checkFunc: function (
+    definition: MapDefinition,
+    symbolTable: SymbolTable,
+    strict: boolean,
+  ): CheckResult[] {
+    const results: CheckResult[] = [];
+
+    results.push(
+      ...checkMapTypeMatchesDeclaration(definition, symbolTable, strict),
+    );
+
+    return results;
+  },
+};

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

@@ -0,0 +1,28 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import { NumberLiteralKind } from "../../ast/node/enum/number-literal-kind.ts";
+import type { NumberLiteral } from "../../ast/node/number-literal.ts";
+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[] {
+    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!,
+        isWarning: true,
+      });
+    }
+
+    return results;
+  },
+};

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

@@ -0,0 +1,42 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import type { Parameter } from "../../ast/node/parameter.ts";
+import type { ParameterList } from "../../ast/node/parameter-list.ts";
+import { getRequiredIdentifier } from "../util/symbol-table-utils.ts";
+import type { Check, CheckResult } from "./check.ts";
+
+export const checkParameterList: Check = {
+  nodeKind: NodeKind.PARAMETER_LIST,
+  checkFunc: function (
+    node: ParameterList,
+    _symbolTable,
+    strict: boolean,
+  ): CheckResult[] {
+    const results: CheckResult[] = [];
+
+    for (const param of node.parameters) {
+      if (param.nodeKind !== NodeKind.PARAMETER) {
+        continue;
+      }
+      const parameter = param as Parameter;
+
+      // 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,
+        );
+        if (identifier) {
+          results.push({
+            message:
+              "String variables are not supported in class parameter lists.",
+            location: identifier.startToken!.getLocation(),
+          });
+        }
+      }
+    }
+
+    return results;
+  },
+};

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

@@ -0,0 +1,53 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import { StatementKind } from "../../ast/node/enum/statement-kind.ts";
+import type { Specification } from "../../ast/node/specification.ts";
+import type { ComputedElementaryTypeDefinition } from "../../ast/node/computed-elementary-type-definition.ts";
+import { isStatement } from "../../ast/util/types.ts";
+import type { Check, CheckResult } from "./check.ts";
+
+export const checkSpecification: Check = {
+  nodeKind: NodeKind.SPECIFICATION,
+  checkFunc: function (
+    node: Specification,
+    _symbolTable,
+    _strict,
+  ): CheckResult[] {
+    const results: CheckResult[] = [];
+
+    for (const child of node.children) {
+      if (!isStatement(child)) {
+        continue;
+      }
+
+      const statement = child;
+
+      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!,
+          });
+        }
+      } else if (statement.statementKind === StatementKind.MAP_DECLARATION) {
+        continue;
+      } else if (statement.statementKind === StatementKind.CLASS_DECLARATION) {
+        continue;
+      } else {
+        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!,
+        });
+      }
+    }
+
+    return results;
+  },
+};