@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/analyser/checks/check-elementary-type-definition.ts

@@ -0,0 +1,167 @@
+import type { LengthAttribute } from "../../../dist/index.js";
+import type { ElementaryTypeDefinition } from "../../ast/node/elementary-type-definition.ts";
+import { ElementaryTypeKind } from "../../ast/node/enum/elementary-type-kind.ts";
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import { StatementKind } from "../../ast/node/enum/statement-kind.ts";
+import type { NumberLiteral } from "../../ast/node/number-literal.ts";
+import { isNumberLiteral } from "../../ast/util/types.ts";
+import {
+  getElementaryTypeKind,
+  getRequiredElementaryType,
+} from "../util/symbol-table-utils.ts";
+import type { Check, CheckResult } from "./check.ts";
+
+function checkOptionalCannotDefineRange(
+  definition: ElementaryTypeDefinition,
+): CheckResult[] {
+  if (
+    definition.assignmentOperator === undefined &&
+    definition.rangeOperator !== undefined
+  ) {
+    const location = definition.startToken?.getLocation();
+    if (location) {
+      return [{
+        message:
+          "An optional elementary type definition cannot define a range for a value.",
+        location,
+      }];
+    }
+  }
+  return [];
+}
+
+function checkRangeMinMaxValidation(
+  definition: ElementaryTypeDefinition,
+): CheckResult[] {
+  if (
+    definition.value && definition.endValue &&
+    isNumberLiteral(definition.value) && isNumberLiteral(definition.endValue)
+  ) {
+    const minValue = definition.value as NumberLiteral;
+    const maxValue = definition.endValue as NumberLiteral;
+
+    // Check that types match
+    if (minValue.numberLiteralKind !== maxValue.numberLiteralKind) {
+      const location = maxValue.startToken?.getLocation() ||
+        definition.startToken!.getLocation();
+      if (location) {
+        return [{
+          message:
+            "The min_value and max_value must be of the same type and the max_value must be greater than or equal to the min_value.",
+          location,
+        }];
+      }
+    }
+
+    // Check that max >= min
+    if (maxValue.value < minValue.value) {
+      const location = maxValue.startToken?.getLocation() ||
+        definition.startToken!.getLocation();
+      if (location) {
+        return [{
+          message:
+            "The min_value and max_value must be of the same type and the max_value must be greater than or equal to the min_value.",
+          location,
+        }];
+      }
+    }
+  }
+  return [];
+}
+
+function checkValueRepresentability(
+  definition: ElementaryTypeDefinition,
+  strict: boolean,
+): CheckResult[] {
+  const elementaryType = getRequiredElementaryType(
+    definition.elementaryType,
+    definition,
+    strict,
+  );
+
+  if (!elementaryType) {
+    return [];
+  }
+
+  const elementaryTypeKind = getElementaryTypeKind(elementaryType, strict);
+  if (elementaryTypeKind === undefined) {
+    return [];
+  }
+
+  // Get bit width from length attribute
+  if (
+    !definition.lengthAttribute ||
+    definition.lengthAttribute.nodeKind !== NodeKind.LENGTH_ATTRIBUTE
+  ) {
+    return [];
+  }
+
+  const lengthAttribute = definition.lengthAttribute as LengthAttribute;
+  if (!isNumberLiteral(lengthAttribute.length)) {
+    return [];
+  }
+
+  const lengthLiteral = lengthAttribute.length as NumberLiteral;
+  const bitWidth = lengthLiteral.value;
+
+  // Check if value is a NumberLiteral
+  if (definition.value && isNumberLiteral(definition.value)) {
+    const valueLiteral = definition.value as NumberLiteral;
+    const value = valueLiteral.value;
+
+    let isValid = false;
+
+    switch (elementaryTypeKind) {
+      case ElementaryTypeKind.UNSIGNED_INTEGER:
+      case ElementaryTypeKind.BIT:
+        isValid = value >= 0 && value < Math.pow(2, bitWidth);
+        break;
+      case ElementaryTypeKind.INTEGER: {
+        const minSigned = -Math.pow(2, bitWidth - 1);
+        const maxSigned = Math.pow(2, bitWidth - 1);
+        isValid = value >= minSigned && value < maxSigned;
+        break;
+      }
+      case ElementaryTypeKind.FLOATING_POINT:
+        isValid = true;
+        break;
+      default:
+        isValid = false;
+        break;
+    }
+
+    if (!isValid) {
+      const location = valueLiteral.startToken?.getLocation() ||
+        definition.startToken!.getLocation();
+      if (location) {
+        return [{
+          message:
+            "The specified value cannot be represented using the specific width of the variable.",
+          location,
+        }];
+      }
+    }
+  }
+
+  return [];
+}
+
+export const checkElementaryTypeDefinition: Check = {
+  nodeKind: NodeKind.STATEMENT,
+  subKind: StatementKind.ELEMENTARY_TYPE_DEFINITION,
+  checkFunc: function (
+    definition: ElementaryTypeDefinition,
+    _symbolTable,
+    strict: boolean,
+  ): CheckResult[] {
+    const results: CheckResult[] = [];
+
+    results.push(...checkOptionalCannotDefineRange(definition));
+
+    results.push(...checkRangeMinMaxValidation(definition));
+
+    results.push(...checkValueRepresentability(definition, strict));
+
+    return results;
+  },
+};

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

@@ -0,0 +1,242 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import type { BinaryExpression } from "../../ast/node/binary-expression.ts";
+import type { AbstractExpression } from "../../ast/node/abstract-expression.ts";
+import { BinaryOperatorKind } from "../../ast/node/enum/binary-operator-kind.ts";
+import { ExpressionKind } from "../../ast/node/enum/expression-kind.ts";
+import type { Identifier } from "../../ast/node/identifier.ts";
+import type { NumberLiteral } from "../../ast/node/number-literal.ts";
+import { isIdentifier, isNumberLiteral } from "../../ast/util/types.ts";
+import { resolveNumericType } from "../util/type-utils.ts";
+import { NumericType } from "../symbol-table.ts";
+import type { Check, CheckResult } from "./check.ts";
+import type { SymbolTable } from "../symbol-table.ts";
+
+function checkConstMutationViaAssignment(
+  node: BinaryExpression,
+  symbolTable: SymbolTable,
+): CheckResult[] {
+  if (node.binaryOperatorKind !== BinaryOperatorKind.ASSIGNMENT) {
+    return [];
+  }
+
+  if (!isIdentifier(node.leftOperand)) {
+    return [];
+  }
+
+  const identifier = node.leftOperand as Identifier;
+  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 [];
+}
+
+function checkModulusWithNegativeRhs(
+  node: BinaryExpression,
+): CheckResult[] {
+  if (node.binaryOperatorKind !== BinaryOperatorKind.MODULUS) {
+    return [];
+  }
+
+  if (!isNumberLiteral(node.rightOperand)) {
+    return [];
+  }
+
+  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 [];
+}
+
+function checkModulusWithFloatOperands(
+  node: BinaryExpression,
+  symbolTable: SymbolTable,
+): CheckResult[] {
+  if (node.binaryOperatorKind !== BinaryOperatorKind.MODULUS) {
+    return [];
+  }
+
+  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(),
+    }];
+  }
+
+  return [];
+}
+
+function checkModulusWithZeroRhs(
+  node: BinaryExpression,
+): CheckResult[] {
+  if (node.binaryOperatorKind !== BinaryOperatorKind.MODULUS) {
+    return [];
+  }
+
+  if (!isNumberLiteral(node.rightOperand)) {
+    return [];
+  }
+
+  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 [];
+}
+
+function checkDivisionByZero(
+  node: BinaryExpression,
+): CheckResult[] {
+  if (node.binaryOperatorKind !== BinaryOperatorKind.DIVIDE) {
+    return [];
+  }
+
+  if (!isNumberLiteral(node.rightOperand)) {
+    return [];
+  }
+
+  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 [];
+}
+
+function checkIntegerDivisionWithNegatives(
+  node: BinaryExpression,
+  symbolTable: SymbolTable,
+): CheckResult[] {
+  if (node.binaryOperatorKind !== BinaryOperatorKind.DIVIDE) {
+    return [];
+  }
+
+  const leftType = resolveNumericType(node.leftOperand, symbolTable);
+  const rightType = resolveNumericType(node.rightOperand, symbolTable);
+
+  if (leftType !== NumericType.INTEGER || rightType !== NumericType.INTEGER) {
+    return [];
+  }
+
+  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 [];
+}
+
+function checkRightShiftOnSignedInt(
+  node: BinaryExpression,
+  symbolTable: SymbolTable,
+): CheckResult[] {
+  if (node.binaryOperatorKind !== BinaryOperatorKind.SHIFT_RIGHT) {
+    return [];
+  }
+
+  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 [];
+}
+
+function checkLeftHandAssignmentConst(
+  node: BinaryExpression,
+  symbolTable: SymbolTable,
+): CheckResult[] {
+  if (node.binaryOperatorKind !== BinaryOperatorKind.ASSIGNMENT) {
+    return [];
+  }
+
+  if (!isIdentifier(node.leftOperand)) {
+    return [];
+  }
+
+  const identifier = node.leftOperand as Identifier;
+  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 [];
+}
+
+export const checkExpressionBinary: Check = {
+  nodeKind: NodeKind.EXPRESSION,
+  subKind: ExpressionKind.BINARY,
+  checkFunc: function (
+    node: AbstractExpression,
+    symbolTable: SymbolTable,
+    _strict: boolean,
+  ): CheckResult[] {
+    const results: CheckResult[] = [];
+
+    // Only process BinaryExpression nodes
+    if (node.expressionKind !== ExpressionKind.BINARY) {
+      return results;
+    }
+
+    const binaryExpression = node as BinaryExpression;
+
+    return [
+      ...checkConstMutationViaAssignment(binaryExpression, symbolTable),
+      ...checkModulusWithNegativeRhs(binaryExpression),
+      ...checkModulusWithFloatOperands(binaryExpression, symbolTable),
+      ...checkModulusWithZeroRhs(binaryExpression),
+      ...checkDivisionByZero(binaryExpression),
+      ...checkIntegerDivisionWithNegatives(binaryExpression, symbolTable),
+      ...checkRightShiftOnSignedInt(binaryExpression, symbolTable),
+      ...checkLeftHandAssignmentConst(binaryExpression, symbolTable),
+    ];
+  },
+};

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

@@ -0,0 +1,34 @@
+import { ExpressionKind } from "../../ast/node/enum/expression-kind.ts";
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import type { LengthofExpression } from "../../ast/node/length-of-expression.ts";
+import { isIdentifier } from "../../ast/util/types.ts";
+import type { Check, CheckResult } from "./check.ts";
+
+export const checkExpressionLengthof: Check = {
+  nodeKind: NodeKind.EXPRESSION,
+  subKind: ExpressionKind.LENGTHOF,
+  checkFunc: function (
+    node: LengthofExpression,
+    symbolTable,
+    _strict,
+  ): CheckResult[] {
+    const results: CheckResult[] = [];
+
+    // Check if operand is an identifier
+    if (isIdentifier(node.operand)) {
+      // Look up the variable in the symbol table
+      const variable = symbolTable.lookupVariable(node.operand.name);
+
+      // 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.",
+          location: node.operand.startToken!.getLocation(),
+        });
+      }
+    }
+
+    return results;
+  },
+};

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

@@ -0,0 +1,166 @@
+import type { ArrayDefinition } from "../../ast/node/array-definition.ts";
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import { StatementKind } from "../../ast/node/enum/statement-kind.ts";
+import { TokenKind } from "../../ast/node/enum/token-kind.ts";
+import type { UnaryExpression } from "../../ast/node/unary-expression.ts";
+import { ExpressionKind } from "../../ast/node/enum/expression-kind.ts";
+import { isIdentifier, isUnaryExpression } from "../../ast/util/types.ts";
+import type { SymbolTable } from "../symbol-table.ts";
+import type { Check, CheckResult } from "./check.ts";
+import type { AbstractStatement } from "../../ast/node/abstract-statement.ts";
+import type { Token } from "../../ast/node/token.ts";
+import type { Identifier } from "../../ast/node/identifier.ts";
+import type { NumberLiteral } from "../../ast/node/number-literal.ts";
+
+function checkConstMutationViaPostfix(
+  expression: UnaryExpression,
+  symbolTable: SymbolTable,
+): CheckResult[] {
+  const results: CheckResult[] = [];
+
+  if (
+    expression.postfixOperator !== undefined &&
+    ((expression.postfixOperator as Token).tokenKind ===
+        TokenKind.POSTFIX_INCREMENT ||
+      (expression.postfixOperator as Token).tokenKind ===
+        TokenKind.POSTFIX_DECREMENT)
+  ) {
+    let targetIdentifier: Identifier | undefined;
+    if (isIdentifier(expression.operand)) {
+      targetIdentifier = expression.operand;
+    } else if (
+      expression.operand.nodeKind === NodeKind.EXPRESSION &&
+      isIdentifier((expression.operand as UnaryExpression).operand)
+    ) {
+      targetIdentifier = (expression.operand as UnaryExpression)
+        .operand as Identifier;
+    }
+
+    if (targetIdentifier) {
+      const variable = symbolTable.lookupVariable(targetIdentifier.name);
+
+      if (
+        variable &&
+        variable.attributes.isConst &&
+        variable.attributes.isComputed
+      ) {
+        results.push({
+          message: "a const computed variable cannot be mutated.",
+          location: expression.startToken!.getLocation(),
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
+function checkArrayDimensionCountMismatch(
+  expression: UnaryExpression,
+  symbolTable: SymbolTable,
+): CheckResult[] {
+  const results: CheckResult[] = [];
+
+  if (expression.arrayElementAccess) {
+    // Find the base identifier by traversing nested UnaryExpressions
+    let baseIdentifier: Identifier | undefined;
+    let currentExpr: UnaryExpression | Identifier | NumberLiteral = expression;
+    let accessDimensions = 0;
+
+    // Count array access dimensions by traversing the nested structure
+    while (isUnaryExpression(currentExpr)) {
+      if (currentExpr.arrayElementAccess) {
+        accessDimensions++;
+      }
+
+      currentExpr = currentExpr.operand as UnaryExpression;
+    }
+
+    // Check if we found an identifier at the base
+    if (isIdentifier(currentExpr)) {
+      baseIdentifier = currentExpr;
+    }
+
+    if (baseIdentifier) {
+      const variable = symbolTable.lookupVariable(baseIdentifier.name);
+
+      if (variable && variable.attributes.isArray) {
+        // Get the array definition from the symbol's AST node
+        const arrayDefinition = variable.node as ArrayDefinition;
+
+        // Count dimensions in the array definition
+        let definedDimensions = 0;
+
+        if (arrayDefinition.implicitArrayDimension) {
+          definedDimensions++;
+        }
+        definedDimensions += arrayDefinition.dimensions.length;
+
+        if (definedDimensions !== accessDimensions) {
+          results.push({
+            message:
+              "The number of dimensions used when accessing an array element must match the number of dimensions in the array definition.",
+            location: expression.startToken!.getLocation()!,
+          });
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+function checkUninitializedComputedVariableAccess(
+  expression: UnaryExpression,
+  _symbolTable: SymbolTable,
+): CheckResult[] {
+  const results: CheckResult[] = [];
+
+  if (isIdentifier(expression.operand)) {
+    const variable = _symbolTable.lookupVariable(expression.operand.name);
+
+    if (variable && variable.attributes.isComputed) {
+      // 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)
+      ) {
+        const definition = variable.node as { value?: unknown };
+
+        if (!definition.value) {
+          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!,
+            isWarning: true,
+          });
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+export const checkExpressionUnary: Check = {
+  nodeKind: NodeKind.EXPRESSION,
+  subKind: ExpressionKind.UNARY,
+  checkFunc: function (
+    expression: UnaryExpression,
+    symbolTable: SymbolTable,
+    _strict: boolean,
+  ): CheckResult[] {
+    const results: CheckResult[] = [];
+
+    results.push(...checkConstMutationViaPostfix(expression, symbolTable));
+    results.push(...checkArrayDimensionCountMismatch(expression, symbolTable));
+    results.push(
+      ...checkUninitializedComputedVariableAccess(expression, symbolTable),
+    );
+
+    return results;
+  },
+};

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

@@ -0,0 +1,71 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import type { Identifier } from "../../ast/node/identifier.ts";
+import type { Check, CheckResult } from "./check.ts";
+
+// Build set of SDL keywords and literal prefixes
+const getReservedIdentifiers = (): Set<string> => {
+  // Add SDL keywords from token mapping
+  const reserved = new Set([
+    "abstract",
+    "aligned",
+    "base64string",
+    "bit",
+    "break",
+    "case",
+    "class",
+    "computed",
+    "const",
+    "default",
+    "do",
+    "else",
+    "expandable",
+    "extends",
+    "float",
+    "for",
+    "if",
+    "int",
+    "legacy",
+    "lengthof",
+    "map",
+    "reserved",
+    "switch",
+    "unsigned",
+    "utf8string",
+    "utf16string",
+    "utfstring",
+    "utf8list",
+    "while",
+  ]);
+
+  // Add literal prefixes
+  reserved.add("0b");
+  reserved.add("0x");
+
+  return reserved;
+};
+
+const reservedIdentifiers = getReservedIdentifiers();
+
+export const checkIdentifier: Check = {
+  nodeKind: NodeKind.IDENTIFIER,
+  checkFunc: function (
+    node: Identifier,
+    _symbolTable,
+    _strict,
+  ): CheckResult[] {
+    const results: CheckResult[] = [];
+
+    const identifierName = node.name.toLowerCase();
+
+    if (reservedIdentifiers.has(identifierName)) {
+      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!,
+      });
+    }
+
+    return results;
+  },
+};