@mpeggroup/mpeg-sdl-parser 4.1.1 → 4.1.3

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

@@ -0,0 +1,67 @@
+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 { StringVariableKind } from "../../ast/node/enum/string-variable-kind.ts";
+import type { Identifier } from "../../ast/node/identifier.ts";
+import type { Token } from "../../ast/node/token.ts";
+import { type RequiredNode } from "../../ast/util/types.ts";
+import { type SymbolTable } from "../symbol-table.ts";
+/**
+ * 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 declare function getRequiredIdentifier(node: RequiredNode<AbstractNode>, parentNode: AbstractNode, strict: boolean): Identifier | 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 declare function getRequiredToken(node: RequiredNode<AbstractNode>, parentNode: AbstractNode, strict: boolean): Token | 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 declare function getRequiredElementaryType(node: RequiredNode<AbstractNode>, parentNode: AbstractNode, strict: boolean): ElementaryType | 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 declare function getElementaryTypeKind(elementaryType: ElementaryType, strict: boolean): ElementaryTypeKind | 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 declare function getStringVariableKind(stringVariableKindToken: Token, strict: boolean): StringVariableKind | 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 declare function getRequiredOperand(node: RequiredNode<AbstractNode>, parentNode: AbstractNode, strict: boolean): AbstractNode | undefined;
+export declare function getSymbolTableString(symbolTable: SymbolTable): string;
+//# sourceMappingURL=symbol-table-utils.d.ts.map

package/dist/src/analyser/util/symbol-table-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-table-utils.d.ts","sourceRoot":"","sources":["../../../../src/analyser/util/symbol-table-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6CAA6C,CAAC;AAEjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,6CAA6C,CAAC;AAEjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAML,KAAK,YAAY,EAClB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAOL,KAAK,WAAW,EACjB,MAAM,oBAAoB,CAAC;AAI5B;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,YAAY,CAAC,YAAY,CAAC,EAChC,UAAU,EAAE,YAAY,EACxB,MAAM,EAAE,OAAO,GACd,UAAU,GAAG,SAAS,CAgCxB;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,YAAY,CAAC,YAAY,CAAC,EAChC,UAAU,EAAE,YAAY,EACxB,MAAM,EAAE,OAAO,GACd,KAAK,GAAG,SAAS,CA0BnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,YAAY,CAAC,YAAY,CAAC,EAChC,UAAU,EAAE,YAAY,EACxB,MAAM,EAAE,OAAO,GACd,cAAc,GAAG,SAAS,CA+B5B;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,cAAc,EAC9B,MAAM,EAAE,OAAO,GACd,kBAAkB,GAAG,SAAS,CAwEhC;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,uBAAuB,EAAE,KAAK,EAC9B,MAAM,EAAE,OAAO,GACd,kBAAkB,GAAG,SAAS,CA2BhC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,YAAY,CAAC,YAAY,CAAC,EAChC,UAAU,EAAE,YAAY,EACxB,MAAM,EAAE,OAAO,GACd,YAAY,GAAG,SAAS,CA2B1B;AA2CD,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAkCrE"}

package/dist/src/analyser/util/symbol-table-utils.js

@@ -0,0 +1,279 @@
+import { ElementaryTypeKind } from "../../ast/node/enum/elementary-type-kind.js";
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { StringVariableKind } from "../../ast/node/enum/string-variable-kind.js";
+import { TokenKind } from "../../ast/node/enum/token-kind.js";
+import { isAbstractExpression, isElementaryType, isIdentifier, isNumberLiteral, isToken, } from "../../ast/util/types.js";
+import { SemanticError } from "../../scanner-error.js";
+import getLogger from "../../util/logger.js";
+import { NumericType, ScopeKind, StringType, SymbolKind, } from "../symbol-table.js";
+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, parentNode, strict) {
+    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, parentNode, strict) {
+    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, parentNode, strict) {
+    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, strict) {
+    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;
+    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, strict) {
+    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, parentNode, strict) {
+    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) {
+    const kindName = SymbolKind[symbol.kind];
+    let attributesStr = "";
+    if (symbol.attributes) {
+        const attributes = symbol.attributes;
+        const parts = [];
+        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) {
+    const lines = [];
+    const formatScope = (scope, indent) => {
+        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/dist/src/analyser/util/type-utils.d.ts

@@ -0,0 +1,14 @@
+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 { NumericType, StringType, type SymbolTable } from "../symbol-table.ts";
+import { StringVariableKind } from "../../ast/node/enum/string-variable-kind.ts";
+export declare function getNumericTypeFromElementaryTypeKind(kind: ElementaryTypeKind): NumericType;
+export declare function getStringTypeFromStringVariableKind(kind: StringVariableKind): StringType;
+export declare function resolveNumericType(node: AbstractNode, symbolTable: SymbolTable): NumericType | undefined;
+export declare function isRelationalOperator(kind: BinaryOperatorKind): boolean;
+export declare function isLogicalOperator(kind: BinaryOperatorKind): boolean;
+export declare function isShiftOperator(kind: BinaryOperatorKind): boolean;
+export declare function isBitwiseOperator(kind: BinaryOperatorKind): boolean;
+export declare function isArithmeticOperator(kind: BinaryOperatorKind): boolean;
+//# sourceMappingURL=type-utils.d.ts.map

package/dist/src/analyser/util/type-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-utils.d.ts","sourceRoot":"","sources":["../../../../src/analyser/util/type-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,6CAA6C,CAAC;AAOjF,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAE/E,OAAO,EAAE,kBAAkB,EAAE,MAAM,6CAA6C,CAAC;AAGjF,wBAAgB,oCAAoC,CAAC,IAAI,EAAE,kBAAkB,GAAG,WAAW,CAa1F;AAED,wBAAgB,mCAAmC,CAAC,IAAI,EAAE,kBAAkB,GAAG,UAAU,CAcxF;AAoBD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,YAAY,EAClB,WAAW,EAAE,WAAW,GACvB,WAAW,GAAG,SAAS,CAczB;AAqFD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAStE;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAEnE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAEjE;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAEnE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAQtE"}

package/dist/src/analyser/util/type-utils.js

@@ -0,0 +1,147 @@
+import { BinaryOperatorKind } from "../../ast/node/enum/binary-operator-kind.js";
+import { ElementaryTypeKind } from "../../ast/node/enum/elementary-type-kind.js";
+import { ExpressionKind } from "../../ast/node/enum/expression-kind.js";
+import { NumberLiteralKind } from "../../ast/node/enum/number-literal-kind.js";
+import { isAbstractExpression, isIdentifier, isNumberLiteral } from "../../ast/util/types.js";
+import { NumericType, StringType } from "../symbol-table.js";
+import { InternalScannerError } from "../../scanner-error.js";
+import { StringVariableKind } from "../../ast/node/enum/string-variable-kind.js";
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+export function getNumericTypeFromElementaryTypeKind(kind) {
+    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 = kind;
+            throw new InternalScannerError("Unreachable code reached, kind == " + exhaustiveCheck);
+        }
+    }
+}
+export function getStringTypeFromStringVariableKind(kind) {
+    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 = kind;
+            throw new InternalScannerError("Unreachable code reached, kind == " + exhaustiveCheck);
+        }
+    }
+}
+function getNumericTypeFromNumberLiteralKind(kind) {
+    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 = kind;
+            throw new InternalScannerError("Unreachable code reached, kind == " + exhaustiveCheck);
+        }
+    }
+}
+export function resolveNumericType(node, symbolTable) {
+    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, symbolTable) {
+    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, symbolTable) {
+    const kind = expression.expressionKind;
+    switch (kind) {
+        case ExpressionKind.BINARY:
+            return resolveBinaryExpressionType(expression, symbolTable);
+        case ExpressionKind.UNARY:
+            return resolveNumericType(expression.operand, symbolTable);
+        case ExpressionKind.LENGTHOF:
+            return NumericType.INTEGER;
+        default: {
+            const exhaustiveCheck = kind;
+            throw new InternalScannerError("Unreachable code reached, kind == " + exhaustiveCheck);
+        }
+    }
+}
+function resolveBinaryExpressionType(expression, symbolTable) {
+    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, symbolTable);
+    }
+    const leftNumericType = resolveNumericType(expression.leftOperand, symbolTable);
+    const rightNumericType = resolveNumericType(expression.rightOperand, 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) {
+    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) {
+    return kind === BinaryOperatorKind.LOGICAL_AND || kind === BinaryOperatorKind.LOGICAL_OR;
+}
+export function isShiftOperator(kind) {
+    return kind === BinaryOperatorKind.SHIFT_LEFT || kind === BinaryOperatorKind.SHIFT_RIGHT;
+}
+export function isBitwiseOperator(kind) {
+    return kind === BinaryOperatorKind.BITWISE_AND || kind === BinaryOperatorKind.BITWISE_OR;
+}
+export function isArithmeticOperator(kind) {
+    return (kind === BinaryOperatorKind.ADD ||
+        kind === BinaryOperatorKind.SUBTRACT ||
+        kind === BinaryOperatorKind.MULTIPLY ||
+        kind === BinaryOperatorKind.DIVIDE ||
+        kind === BinaryOperatorKind.MODULUS);
+}

package/dist/src/ast/build/consume/consume-abstract-node.d.ts

@@ -0,0 +1,20 @@
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import type { BuildContext } from "../util/build-context.ts";
+export declare enum NodeScenario {
+    /** Missing Error Node */
+    MISSING_NODE = 0,
+    /** Unexpected Error Node containing a child which is the unexpected token */
+    UNEXPECTED_NODE = 1,
+    /** Unknown Error Node which has text of an unknown token */
+    UNKNOWN_TOKEN = 2,
+    /** Primitive Node e.g. Identifier, IntegerLiteral... */
+    PRIMITIVE = 3,
+    /** Terminal Token Node e.g. class, int... */
+    TOKEN = 4,
+    /** Non-Terminal AST Node e.g. ClassDeclaration, ExpressionStatement... */
+    AST_NODE = 5,
+    /** Terminal AST Node with missing children e.g. ClassDeclaration, ExpressionStatement... */
+    EMPTY_AST_NODE = 6
+}
+export declare function consumeAbstractNode(buildContext: BuildContext): AbstractNode | undefined;
+//# sourceMappingURL=consume-abstract-node.d.ts.map

package/dist/src/ast/build/consume/consume-abstract-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consume-abstract-node.d.ts","sourceRoot":"","sources":["../../../../../src/ast/build/consume/consume-abstract-node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAkB7D,oBAAY,YAAY;IACtB,yBAAyB;IACzB,YAAY,IAAA;IACZ,6EAA6E;IAC7E,eAAe,IAAA;IACf,4DAA4D;IAC5D,aAAa,IAAA;IACb,wDAAwD;IACxD,SAAS,IAAA;IACT,6CAA6C;IAC7C,KAAK,IAAA;IACL,0EAA0E;IAC1E,QAAQ,IAAA;IACR,4FAA4F;IAC5F,cAAc,IAAA;CACf;AA2DD,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,YAAY,GAAG,YAAY,GAAG,SAAS,CAsGxF"}