@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/analyser/util/symbol-table-utils.ts

@@ -0,0 +1,458 @@
+import type { AbstractNode } from "../../ast/node/abstract-node.ts";
+import type { ElementaryType } from "../../ast/node/elementary-type.ts";
+import { ElementaryTypeKind } from "../../ast/node/enum/elementary-type-kind.ts";
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import { StringVariableKind } from "../../ast/node/enum/string-variable-kind.ts";
+import { TokenKind } from "../../ast/node/enum/token-kind.ts";
+import type { Identifier } from "../../ast/node/identifier.ts";
+import type { Token } from "../../ast/node/token.ts";
+import {
+  isAbstractExpression,
+  isElementaryType,
+  isIdentifier,
+  isNumberLiteral,
+  isToken,
+  type RequiredNode,
+} from "../../ast/util/types.ts";
+import { SemanticError } from "../../scanner-error.ts";
+import getLogger from "../../util/logger.ts";
+import {
+  NumericType,
+  type Scope,
+  ScopeKind,
+  StringType,
+  type Symbol,
+  SymbolKind,
+  type SymbolTable,
+} from "../symbol-table.ts";
+
+const logger = getLogger("SymbolTableUtils");
+
+/**
+ * Converts the given node to a required Identifier.
+ * If the node is undefined or not an Identifier, it throws a SemanticError in strict mode.
+ * In lenient mode, it logs a debug message and returns undefined.
+ *
+ * @param node the node to convert
+ * @param parentNode the parent node for error location context
+ * @param strict whether to operate in strict mode
+ * @return the node as an Identifier or undefined
+ */
+export function getRequiredIdentifier(
+  node: RequiredNode<AbstractNode>,
+  parentNode: AbstractNode,
+  strict: boolean,
+): Identifier | undefined {
+  if (node === undefined) {
+    if (strict) {
+      throw new SemanticError(
+        "Required identifier property is missing",
+        parentNode.leadingTrivia
+          ? parentNode.leadingTrivia[0].location
+          : undefined,
+      );
+    } else {
+      logger.debug(
+        "Ignoring missing required identifier property in lenient mode.",
+      );
+    }
+    return undefined;
+  }
+
+  if (isIdentifier(node)) {
+    return node;
+  }
+
+  if (strict) {
+    if (isToken(node)) {
+      throw new SemanticError(
+        `Required identifier property is a Token node: ${
+          TokenKind[node.tokenKind]
+        }`,
+        node.leadingTrivia ? node.leadingTrivia[0].location : undefined,
+      );
+    }
+    throw new SemanticError(
+      "Required identifier property is not an Identifier node: " +
+        NodeKind[node.nodeKind],
+      node.leadingTrivia ? node.leadingTrivia[0].location : undefined,
+    );
+  } else {
+    logger.debug(
+      "Ignoring invalid required identifier property in lenient mode.",
+    );
+    return undefined;
+  }
+}
+
+/**
+ * Converts the given node to a required Token.
+ * If the node is undefined or not an Token, it throws a SemanticError in strict mode.
+ * In lenient mode, it logs a debug message and returns undefined.
+ *
+ * @param node the node to convert
+ * @param parentNode the parent node for error location context
+ * @param strict whether to operate in strict mode
+ * @return the node as an Token or undefined
+ */
+export function getRequiredToken(
+  node: RequiredNode<AbstractNode>,
+  parentNode: AbstractNode,
+  strict: boolean,
+): Token | undefined {
+  if (node === undefined) {
+    if (strict) {
+      throw new SemanticError(
+        "Required token property is missing",
+        parentNode.leadingTrivia
+          ? parentNode.leadingTrivia[0].location
+          : undefined,
+      );
+    } else {
+      logger.debug(
+        "Ignoring missing required token property in lenient mode.",
+      );
+    }
+    return undefined;
+  }
+
+  if (isToken(node)) {
+    return node;
+  }
+
+  if (strict) {
+    throw new SemanticError(
+      "Required token property is not a Token node: " + NodeKind[node.nodeKind],
+      node.leadingTrivia ? node.leadingTrivia[0].location : undefined,
+    );
+  } else {
+    logger.debug(
+      "Ignoring invalid required token property in lenient mode.",
+    );
+    return undefined;
+  }
+}
+
+/**
+ * Converts the given node to a required ElementaryType.
+ * If the node is undefined or not an ElementaryType, it throws a SemanticError in strict mode.
+ * In lenient mode, it logs a debug message and returns undefined.
+ *
+ * @param node the node to convert
+ * @param parentNode the parent node for error location context
+ * @param strict whether to operate in strict mode
+ * @return the node as an ElementaryType or undefined
+ */
+export function getRequiredElementaryType(
+  node: RequiredNode<AbstractNode>,
+  parentNode: AbstractNode,
+  strict: boolean,
+): ElementaryType | undefined {
+  if (node === undefined) {
+    if (strict) {
+      throw new SemanticError(
+        "Required elementary type property is missing",
+        parentNode.leadingTrivia
+          ? parentNode.leadingTrivia[0].location
+          : undefined,
+      );
+    } else {
+      logger.debug(
+        "Ignoring missing required elementary type property in lenient mode.",
+      );
+    }
+    return undefined;
+  }
+
+  if (isElementaryType(node)) {
+    return node;
+  }
+  if (strict) {
+    if (isToken(node)) {
+      throw new SemanticError(
+        `Required identifier property is a Token node: ${
+          TokenKind[node.tokenKind]
+        }`,
+        node.leadingTrivia ? node.leadingTrivia[0].location : undefined,
+      );
+    }
+    throw new SemanticError(
+      "Required elementary type property is not an ElementaryType node: " +
+        NodeKind[node.nodeKind],
+      node.leadingTrivia ? node.leadingTrivia[0].location : undefined,
+    );
+  } else {
+    logger.debug(
+      "Ignoring invalid required elementary type property in lenient mode.",
+    );
+    return undefined;
+  }
+}
+
+/**
+ * Converts the ElementaryType node to a required ElementaryTypeKind.
+ * If the ElementaryType is not populated fully, it throws a SemanticError in strict mode.
+ * In lenient mode, it logs a debug message and returns undefined.
+ */
+export function getElementaryTypeKind(
+  elementaryType: ElementaryType,
+  strict: boolean,
+): ElementaryTypeKind | undefined {
+  if (elementaryType.unsignedQualifierKeyword) {
+    if (!isToken(elementaryType.unsignedQualifierKeyword)) {
+      if (strict) {
+        throw new SemanticError(
+          "Elementary type unsigned qualifier is not a Token node: " +
+            NodeKind[elementaryType.unsignedQualifierKeyword.nodeKind],
+          elementaryType.leadingTrivia
+            ? elementaryType.leadingTrivia[0].location
+            : undefined,
+        );
+      } else {
+        logger.debug(
+          "Ignoring invalid elementary type unsigned qualifier in lenient mode.",
+        );
+        return undefined;
+      }
+    }
+
+    if (
+      elementaryType.unsignedQualifierKeyword.tokenKind !== TokenKind.UNSIGNED
+    ) {
+      if (strict) {
+        throw new SemanticError(
+          `Elementary type unsigned qualifier has invalid token kind: ${
+            TokenKind[elementaryType.unsignedQualifierKeyword.tokenKind]
+          }`,
+          elementaryType.unsignedQualifierKeyword.getLocation(),
+        );
+      } else {
+        logger.debug(
+          `Ignoring invalid elementary type unsigned qualifier token kind: ${
+            TokenKind[elementaryType.unsignedQualifierKeyword.tokenKind]
+          } in lenient mode.`,
+        );
+        return undefined;
+      }
+    }
+  }
+
+  if (!isToken(elementaryType.typeKeyword)) {
+    if (strict) {
+      throw new SemanticError(
+        "Elementary type type keyword is not a Token node: " +
+          NodeKind[elementaryType.typeKeyword.nodeKind],
+        elementaryType.leadingTrivia
+          ? elementaryType.leadingTrivia[0].location
+          : undefined,
+      );
+    } else {
+      logger.debug(
+        "Ignoring invalid elementary type type keyword in lenient mode.",
+      );
+      return undefined;
+    }
+  }
+
+  const isUnsigned = elementaryType.unsignedQualifierKeyword !== undefined;
+  const typeToken = elementaryType.typeKeyword as Token;
+
+  switch (typeToken.tokenKind) {
+    case TokenKind.INT:
+      return isUnsigned
+        ? ElementaryTypeKind.UNSIGNED_INTEGER
+        : ElementaryTypeKind.INTEGER;
+    case TokenKind.FLOAT:
+      return ElementaryTypeKind.FLOATING_POINT;
+    case TokenKind.BIT:
+      return ElementaryTypeKind.BIT;
+    default:
+      if (strict) {
+        throw new SemanticError(
+          `Unsupported elementary type token kind: ${
+            TokenKind[typeToken.tokenKind]
+          }`,
+          typeToken.getLocation(),
+        );
+      } else {
+        logger.debug(
+          `Ignoring unsupported elementary type token kind: ${
+            TokenKind[typeToken.tokenKind]
+          } in lenient mode.`,
+        );
+        return undefined;
+      }
+  }
+}
+
+/**
+ * Converts the given string variable kind Token to a required StringVariableKind.
+ * If the Token is not populated fully, it throws a SemanticError in strict mode.
+ * In lenient mode, it logs a debug message and returns undefined.
+ */
+export function getStringVariableKind(
+  stringVariableKindToken: Token,
+  strict: boolean,
+): StringVariableKind | undefined {
+  switch (stringVariableKindToken.tokenKind) {
+    case TokenKind.BASE64_STRING:
+      return StringVariableKind.BASE64;
+    case TokenKind.UTF8_STRING:
+      return StringVariableKind.UTF8;
+    case TokenKind.UTF16_STRING:
+      return StringVariableKind.UTF16;
+    case TokenKind.UTF_STRING:
+      return StringVariableKind.UTF;
+    case TokenKind.UTF8_LIST:
+      return StringVariableKind.UTF8_LIST;
+    default:
+      if (strict) {
+        throw new SemanticError(
+          `Unsupported string variable kind token: ${
+            TokenKind[stringVariableKindToken.tokenKind]
+          }`,
+          stringVariableKindToken.getLocation(),
+        );
+      } else {
+        logger.debug(
+          `Ignoring unsupported string variable kind token: ${
+            TokenKind[stringVariableKindToken.tokenKind]
+          } in lenient mode.`,
+        );
+        return undefined;
+      }
+  }
+}
+
+/**
+ * Converts the given node to a required Operand.
+ * If the node is undefined or not an AbstractExpression, Identifier or
+ * NumberLiteral, it throws a SemanticError in strict mode.
+ * In lenient mode, it logs a debug message and returns undefined.
+ *
+ * @param node the node to convert
+ * @param parentNode the parent node for error location context
+ * @param strict whether to operate in strict mode
+ * @return the node or undefined
+ */
+export function getRequiredOperand(
+  node: RequiredNode<AbstractNode>,
+  parentNode: AbstractNode,
+  strict: boolean,
+): AbstractNode | undefined {
+  if (node === undefined) {
+    if (strict) {
+      throw new SemanticError(
+        "Required operand property is missing",
+        parentNode.leadingTrivia
+          ? parentNode.leadingTrivia[0].location
+          : undefined,
+      );
+    } else {
+      logger.debug(
+        "Ignoring missing required operand property in lenient mode.",
+      );
+    }
+    return undefined;
+  }
+
+  if (
+    isAbstractExpression(node) || isIdentifier(node) || isNumberLiteral(node)
+  ) {
+    return node;
+  }
+
+  if (strict) {
+    throw new SemanticError(
+      "Required operand property is not an AbstractExpression, Identifier or NumberLiteral node: " +
+        NodeKind[node.nodeKind],
+      node.leadingTrivia ? node.leadingTrivia[0].location : undefined,
+    );
+  } else {
+    logger.debug(
+      "Ignoring invalid required operand property in lenient mode.",
+    );
+    return undefined;
+  }
+}
+
+function getSymbolString(symbol: Symbol): string {
+  const kindName = SymbolKind[symbol.kind];
+  let attributesStr = "";
+
+  if (symbol.attributes) {
+    const attributes = symbol.attributes;
+    const parts: string[] = [];
+
+    if (attributes.stringType !== undefined) {
+      parts.push(StringType[attributes.stringType]);
+    }
+
+    if (attributes.numericType !== undefined) {
+      parts.push(NumericType[attributes.numericType]);
+    }
+
+    if (attributes.classType) {
+      parts.push("(class: " + attributes.classType + ")");
+    }
+
+    if (attributes.mapType) {
+      parts.push("(map: " + attributes.mapType + ")");
+    }
+
+    if (attributes.isComputed) {
+      parts.push("COMPUTED");
+    }
+
+    if (attributes.isConst) {
+      parts.push("CONST");
+    }
+
+    if (attributes.isArray) {
+      parts.push("[]");
+    }
+
+    attributesStr = parts.length > 0 ? ` ${parts.join(" ")}` : "";
+  }
+  return `${symbol.name} ${kindName}${attributesStr}`;
+}
+
+export function getSymbolTableString(symbolTable: SymbolTable): string {
+  const lines: string[] = [];
+  const formatScope = (scope: Scope, indent: number): void => {
+    const prefix = "  ".repeat(indent);
+
+    lines.push(
+      `${prefix}[${ScopeKind[scope.kind]}]${
+        scope.kind === ScopeKind.GLOBAL ? "" : " " + scope.name
+      }:`,
+    );
+
+    if (scope.classMemberSymbols && (scope.classMemberSymbols.size > 0)) {
+      lines.push(`${prefix}  members:`);
+
+      for (const memberEntries of scope.classMemberSymbols.values()) {
+        for (const entry of memberEntries) {
+          const branchStr = entry.branchId
+            ? ` (branch: ${entry.branchId})`
+            : "";
+          lines.push(
+            `${prefix}    ${getSymbolString(entry.symbol)}${branchStr}`,
+          );
+        }
+      }
+    }
+
+    for (const symbol of scope.symbols.values()) {
+      lines.push(`${prefix}  ${getSymbolString(symbol)}`);
+    }
+
+    for (const child of scope.children) {
+      formatScope(child, indent + 1);
+    }
+  };
+
+  formatScope(symbolTable.getGlobalScope(), 0);
+
+  return lines.join("\n").trim();
+}

package/src/analyser/util/type-utils.ts

@@ -0,0 +1,238 @@
+import type { AbstractExpression } from "../../ast/node/abstract-expression.ts";
+import type { AbstractNode } from "../../ast/node/abstract-node.ts";
+import { BinaryOperatorKind } from "../../ast/node/enum/binary-operator-kind.ts";
+import { ElementaryTypeKind } from "../../ast/node/enum/elementary-type-kind.ts";
+import { ExpressionKind } from "../../ast/node/enum/expression-kind.ts";
+import { NumberLiteralKind } from "../../ast/node/enum/number-literal-kind.ts";
+import type { Identifier } from "../../ast/node/identifier.ts";
+import type { BinaryExpression } from "../../ast/node/binary-expression.ts";
+import type { UnaryExpression } from "../../ast/node/unary-expression.ts";
+import {
+  isAbstractExpression,
+  isIdentifier,
+  isNumberLiteral,
+} from "../../ast/util/types.ts";
+import { NumericType, StringType, type SymbolTable } from "../symbol-table.ts";
+import { InternalScannerError } from "../../scanner-error.ts";
+import { StringVariableKind } from "../../ast/node/enum/string-variable-kind.ts";
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+
+export function getNumericTypeFromElementaryTypeKind(
+  kind: ElementaryTypeKind,
+): NumericType {
+  switch (kind) {
+    case ElementaryTypeKind.INTEGER:
+    case ElementaryTypeKind.UNSIGNED_INTEGER:
+    case ElementaryTypeKind.BIT:
+      return NumericType.INTEGER;
+    case ElementaryTypeKind.FLOATING_POINT:
+      return NumericType.FLOATING_POINT;
+    default: {
+      const exhaustiveCheck: never = kind;
+      throw new InternalScannerError(
+        "Unreachable code reached, kind == " + exhaustiveCheck,
+      );
+    }
+  }
+}
+
+export function getStringTypeFromStringVariableKind(
+  kind: StringVariableKind,
+): StringType {
+  switch (kind) {
+    case StringVariableKind.BASE64:
+      return StringType.BASIC;
+    case StringVariableKind.UTF8:
+    case StringVariableKind.UTF16:
+    case StringVariableKind.UTF:
+    case StringVariableKind.UTF8_LIST:
+      return StringType.UCS;
+    default: {
+      const exhaustiveCheck: never = kind;
+      throw new InternalScannerError(
+        "Unreachable code reached, kind == " + exhaustiveCheck,
+      );
+    }
+  }
+}
+
+function getNumericTypeFromNumberLiteralKind(
+  kind: NumberLiteralKind,
+): NumericType {
+  switch (kind) {
+    case NumberLiteralKind.BINARY:
+    case NumberLiteralKind.HEXADECIMAL:
+    case NumberLiteralKind.INTEGER:
+    case NumberLiteralKind.MULTIPLE_CHARACTER:
+      return NumericType.INTEGER;
+    case NumberLiteralKind.FLOATING_POINT:
+      return NumericType.FLOATING_POINT;
+    case NumberLiteralKind.DECIMAL:
+      return NumericType.DECIMAL;
+    default: {
+      const exhaustiveCheck: never = kind;
+      throw new InternalScannerError(
+        "Unreachable code reached, kind == " + exhaustiveCheck,
+      );
+    }
+  }
+}
+
+export function resolveNumericType(
+  node: AbstractNode,
+  symbolTable: SymbolTable,
+): NumericType | undefined {
+  if (isNumberLiteral(node)) {
+    return getNumericTypeFromNumberLiteralKind(node.numberLiteralKind);
+  }
+
+  if (isIdentifier(node)) {
+    return resolveNumericTypeFromIdentifier(node, symbolTable);
+  }
+
+  if (isAbstractExpression(node)) {
+    return resolveNumericTypeFromExpression(node, symbolTable);
+  }
+
+  throw new InternalScannerError(
+    `Undexpected node kind: ${NodeKind[node.nodeKind]}`,
+  );
+}
+
+function resolveNumericTypeFromIdentifier(
+  identifier: Identifier,
+  symbolTable: SymbolTable,
+): NumericType | undefined {
+  const symbol = symbolTable.lookupVariable(identifier.name);
+
+  if (symbol && (symbol.attributes.numericType !== undefined)) {
+    return symbol.attributes.numericType;
+  }
+
+  const classMembers = symbolTable.lookupClassMember(identifier.name);
+
+  // Use the first class member as they should all have the same type in different branches
+  if (classMembers && (classMembers.length > 0)) {
+    const memberSymbol = classMembers[0].symbol;
+
+    if (memberSymbol.attributes.numericType !== undefined) {
+      return memberSymbol.attributes.numericType;
+    }
+  }
+
+  // Identifier is not defined, there will already be an SemanticError for this
+  return undefined;
+}
+
+function resolveNumericTypeFromExpression(
+  expression: AbstractExpression,
+  symbolTable: SymbolTable,
+): NumericType | undefined {
+  const kind = expression.expressionKind;
+
+  switch (kind) {
+    case ExpressionKind.BINARY:
+      return resolveBinaryExpressionType(
+        expression as BinaryExpression,
+        symbolTable,
+      );
+    case ExpressionKind.UNARY:
+      return resolveNumericType(
+        (expression as UnaryExpression).operand,
+        symbolTable,
+      );
+    case ExpressionKind.LENGTHOF:
+      return NumericType.INTEGER;
+    default: {
+      const exhaustiveCheck: never = kind;
+      throw new InternalScannerError(
+        "Unreachable code reached, kind == " + exhaustiveCheck,
+      );
+    }
+  }
+}
+
+function resolveBinaryExpressionType(
+  expression: BinaryExpression,
+  symbolTable: SymbolTable,
+): NumericType | undefined {
+  const operatorKind = expression.binaryOperatorKind;
+  if (operatorKind === undefined) {
+    return undefined;
+  }
+
+  if (isRelationalOperator(operatorKind) || isLogicalOperator(operatorKind)) {
+    return NumericType.INTEGER;
+  }
+
+  if (operatorKind === BinaryOperatorKind.ASSIGNMENT) {
+    return resolveNumericType(
+      expression.leftOperand as AbstractNode,
+      symbolTable,
+    );
+  }
+
+  const leftNumericType = resolveNumericType(
+    expression.leftOperand as AbstractNode,
+    symbolTable,
+  );
+  const rightNumericType = resolveNumericType(
+    expression.rightOperand as AbstractNode,
+    symbolTable,
+  );
+
+  if (
+    (leftNumericType === NumericType.FLOATING_POINT) ||
+    (rightNumericType === NumericType.FLOATING_POINT)
+  ) {
+    return NumericType.FLOATING_POINT;
+  }
+
+  if (
+    (leftNumericType === NumericType.DECIMAL) ||
+    (rightNumericType === NumericType.DECIMAL)
+  ) {
+    return NumericType.DECIMAL;
+  }
+
+  if (
+    (leftNumericType === NumericType.INTEGER) ||
+    (rightNumericType === NumericType.INTEGER)
+  ) {
+    return NumericType.INTEGER;
+  }
+
+  return leftNumericType || rightNumericType;
+}
+
+export function isRelationalOperator(kind: BinaryOperatorKind): boolean {
+  return (kind === BinaryOperatorKind.LESS_THAN) ||
+    (kind === BinaryOperatorKind.LESS_THAN_OR_EQUAL) ||
+    (kind === BinaryOperatorKind.GREATER_THAN) ||
+    (kind === BinaryOperatorKind.GREATER_THAN_OR_EQUAL) ||
+    (kind === BinaryOperatorKind.EQUAL) ||
+    (kind === BinaryOperatorKind.NOT_EQUAL);
+}
+
+export function isLogicalOperator(kind: BinaryOperatorKind): boolean {
+  return (kind === BinaryOperatorKind.LOGICAL_AND) ||
+    (kind === BinaryOperatorKind.LOGICAL_OR);
+}
+
+export function isShiftOperator(kind: BinaryOperatorKind): boolean {
+  return (kind === BinaryOperatorKind.SHIFT_LEFT) ||
+    (kind === BinaryOperatorKind.SHIFT_RIGHT);
+}
+
+export function isBitwiseOperator(kind: BinaryOperatorKind): boolean {
+  return (kind === BinaryOperatorKind.BITWISE_AND) ||
+    (kind === BinaryOperatorKind.BITWISE_OR);
+}
+
+export function isArithmeticOperator(kind: BinaryOperatorKind): boolean {
+  return (kind === BinaryOperatorKind.ADD) ||
+    (kind === BinaryOperatorKind.SUBTRACT) ||
+    (kind === BinaryOperatorKind.MULTIPLY) ||
+    (kind === BinaryOperatorKind.DIVIDE) ||
+    (kind === BinaryOperatorKind.MODULUS);
+}