@mpeggroup/mpeg-sdl-parser 4.1.2 → 4.1.4

package/dist/src/analyser/node-handler/validate-type-node-handler.js

@@ -0,0 +1,240 @@
+import { InternalScannerError, SemanticError, SemanticWarning } from "../../scanner-error.js";
+import { NumericType } from "../symbol-table.js";
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { StatementKind } from "../../ast/node/enum/statement-kind.js";
+import { ExpressionKind } from "../../ast/node/enum/expression-kind.js";
+import { TokenKind } from "../../ast/node/enum/token-kind.js";
+import { AbstractAnalysisNodeHandler } from "./abstract-analysis-node-handler.js";
+import { getElementaryTypeKind, getRequiredIdentifier, getRequiredOperand, getRequiredToken, } from "../util/symbol-table-utils.js";
+import { isElementaryType, isIdentifier } from "../../ast/util/types.js";
+import { getNumericTypeFromElementaryTypeKind, isArithmeticOperator, isBitwiseOperator, isLogicalOperator, isRelationalOperator, isShiftOperator, resolveNumericType, } from "../util/type-utils.js";
+import { BinaryOperatorKind } from "../../ast/node/enum/binary-operator-kind.js";
+export class ValidateTypeNodeHandler extends AbstractAnalysisNodeHandler {
+    symbolTable;
+    constructor(symbolTable, strict) {
+        super(symbolTable, strict);
+        this.symbolTable = symbolTable;
+        this.registerBeforeNodeHandler(NodeKind.EXPRESSION, ExpressionKind.BINARY, (node) => this.validateBinaryExpression(node));
+        this.registerBeforeNodeHandler(NodeKind.EXPRESSION, ExpressionKind.UNARY, (node) => this.validateUnaryExpression(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.ELEMENTARY_TYPE_DEFINITION, (node) => this.validateElementaryTypeDefinition(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION, (node) => this.validateComputedElementaryTypeDefinition(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.CLASS_DEFINITION, (node) => this.validateClassDefinition(node));
+    }
+    validateClassDefinition(classDefinition) {
+        if (!classDefinition.parameterValueList) {
+            return;
+        }
+        const classIdentifier = getRequiredIdentifier(classDefinition.classIdentifier, classDefinition, this.strict);
+        if (!classIdentifier) {
+            return;
+        }
+        const classSymbol = this.symbolTable.lookupClass(classIdentifier.name);
+        if (!classSymbol) {
+            return;
+        }
+        const identifier = getRequiredIdentifier(classDefinition.classIdentifier, classDefinition, this.strict);
+        if (!identifier) {
+            return;
+        }
+        const classDeclaration = classSymbol.node;
+        let parameters = [];
+        if (classDeclaration.parameterList) {
+            const parameterList = classDeclaration.parameterList;
+            parameters = parameterList.parameters.filter((p) => p.nodeKind === NodeKind.PARAMETER);
+        }
+        let values = [];
+        if (classDefinition.parameterValueList) {
+            const valueList = classDefinition.parameterValueList;
+            values = valueList.values;
+        }
+        if (parameters.length === 0 && values.length > 0) {
+            const error = new SemanticError(`Class '${classIdentifier.name}' does not expect parameters, but ${values.length} provided`, identifier.startToken.getLocation());
+            if (this.strict) {
+                throw error;
+            }
+            this.semanticErrors.push(error);
+            return;
+        }
+        if (parameters.length > 0 && values.length === 0) {
+            const error = new SemanticError(`Class '${classIdentifier.name}' expects ${parameters.length} parameter(s), but none provided`, identifier.startToken.getLocation());
+            if (this.strict) {
+                throw error;
+            }
+            this.semanticErrors.push(error);
+            return;
+        }
+        if (values.length !== parameters.length) {
+            const error = new SemanticError(`Class '${classIdentifier.name}' expects ${parameters.length} parameter(s), but ${values.length} provided`, identifier.startToken.getLocation());
+            if (this.strict) {
+                throw error;
+            }
+            this.semanticErrors.push(error);
+            return;
+        }
+        for (let i = 0; i < parameters.length; i++) {
+            const parameter = parameters[i];
+            const parameterIdentifier = getRequiredIdentifier(parameter.identifier, parameter, false);
+            if (!parameterIdentifier) {
+                continue;
+            }
+            const value = values[i];
+            let error = undefined;
+            let warning = undefined;
+            if (isElementaryType(parameter.elementaryType)) {
+                const elementaryTypeKind = getElementaryTypeKind(parameter.elementaryType, false);
+                if (elementaryTypeKind !== undefined) {
+                    const parameterNumericType = getNumericTypeFromElementaryTypeKind(elementaryTypeKind);
+                    const valueNumericType = resolveNumericType(value, this.symbolTable);
+                    // If the type cannot be determined (due to identifier not being defined etc.)
+                    // then just continue as there will already be a semantic error undefined symbol
+                    if (valueNumericType === undefined || parameterNumericType === undefined) {
+                        continue;
+                    }
+                    else if (valueNumericType !== parameterNumericType) {
+                        warning = new SemanticWarning(`Coercion required: parameter type: ${NumericType[parameterNumericType]}, value type: ${NumericType[valueNumericType]}`, value.getLocation());
+                    }
+                }
+            }
+            else if (isIdentifier(parameter.classIdentifier)) {
+                const parameterClassSymbol = this.symbolTable.lookupClass(parameter.classIdentifier.name);
+                if (parameterClassSymbol) {
+                    const valueClassIdentifier = isIdentifier(value) ? value : undefined;
+                    if (valueClassIdentifier) {
+                        const valueClassSymbol = this.symbolTable.lookupClass(valueClassIdentifier.name);
+                        if (valueClassSymbol) {
+                            // make sure the class declarations are the same by comparing valueClassSymbol.attributes.classType with parameterClassSymbol.attributes.classType
+                            if (valueClassSymbol.attributes.classType === undefined) {
+                                error = new SemanticError(`Class type could not be resolved for value of parameter '${parameterIdentifier.name}'`, value.getLocation());
+                            }
+                            else if (parameterClassSymbol.attributes.classType === undefined) {
+                                error = new SemanticError(`Class type could not be resolved for parameter '${parameterIdentifier.name}'`, parameterIdentifier.getLocation());
+                            }
+                            else if (valueClassSymbol.attributes.classType !== parameterClassSymbol.attributes.classType) {
+                                warning = new SemanticWarning(`Coercion required: parameter class type: ${parameterClassSymbol.attributes.classType}, value class type: ${valueClassSymbol.attributes.classType}`, value.getLocation());
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                continue;
+            }
+            if (warning) {
+                this.semanticWarnings.push(warning);
+            }
+            if (error) {
+                if (this.strict) {
+                    throw error;
+                }
+                this.semanticErrors.push(error);
+            }
+        }
+    }
+    validateElementaryTypeDefinition(elementaryTypeDefinition) {
+        this.validateElementaryTypeValueAndEndValue(elementaryTypeDefinition);
+    }
+    validateComputedElementaryTypeDefinition(computedElementaryTypeDefinition) {
+        this.validateElementaryTypeValueAndEndValue(computedElementaryTypeDefinition);
+    }
+    validateElementaryTypeValueAndEndValue(definition) {
+        // nothing to check if no value provided
+        if (definition.value === undefined) {
+            return;
+        }
+        const identifier = getRequiredIdentifier(definition.identifier, definition, this.strict);
+        if (!identifier) {
+            return;
+        }
+        // get the symbol using the identifier.name
+        const symbol = this.symbolTable.lookupVariable(identifier.name);
+        if (!symbol) {
+            return;
+        }
+        const declaredType = symbol.attributes.numericType;
+        if (!declaredType) {
+            return;
+        }
+        const valueType = resolveNumericType(definition.value, this.symbolTable);
+        // If the type cannot be determined (due to identifier not being defined etc.)
+        // then just continue as there will already be a semantic error undefined symbol
+        if (valueType !== undefined && valueType !== declaredType) {
+            const warning = new SemanticWarning(`Type coercion required for '${identifier.name}' value: expected ${NumericType[declaredType]}, got ${NumericType[valueType]}`, identifier.startToken.getLocation());
+            this.semanticWarnings.push(warning);
+        }
+        // nothing further to check if no end value provided
+        if (!definition.endValue) {
+            return;
+        }
+        const endValueType = resolveNumericType(definition.endValue, this.symbolTable);
+        // If the type cannot be determined (due to identifier not being defined etc.)
+        // then just continue as there will already be a semantic error undefined symbol
+        if (endValueType !== undefined && endValueType !== declaredType) {
+            const warning = new SemanticWarning(`Type coercion required for '${identifier.name}' end value: expected ${NumericType[declaredType]}, got ${NumericType[endValueType]}`, identifier.startToken.getLocation());
+            this.semanticWarnings.push(warning);
+        }
+    }
+    validateBinaryExpression(binaryExpression) {
+        const leftOperand = getRequiredOperand(binaryExpression.leftOperand, binaryExpression, this.strict);
+        if (!leftOperand) {
+            return;
+        }
+        const rightOperand = getRequiredOperand(binaryExpression.rightOperand, binaryExpression, this.strict);
+        if (!rightOperand) {
+            return;
+        }
+        const operatorToken = getRequiredToken(binaryExpression.binaryOperator, binaryExpression, this.strict);
+        if (!operatorToken) {
+            return;
+        }
+        const operatorKind = binaryExpression.binaryOperatorKind;
+        if (operatorKind === undefined) {
+            throw new InternalScannerError("Unreachable code reached, operatorKind is undefined");
+        }
+        const leftOperandNumericType = resolveNumericType(leftOperand, this.symbolTable);
+        const rightOperandNumericType = resolveNumericType(rightOperand, this.symbolTable);
+        // If the type cannot be determined (due to identifier not being defined etc.)
+        // then just return as there will already be a semantic error undefined symbol
+        if (leftOperandNumericType === undefined || rightOperandNumericType === undefined) {
+            return;
+        }
+        let isCoercionRequired = false;
+        if (operatorKind === BinaryOperatorKind.ASSIGNMENT ||
+            isArithmeticOperator(operatorKind) ||
+            isRelationalOperator(operatorKind) ||
+            isLogicalOperator(operatorKind)) {
+            isCoercionRequired = leftOperandNumericType !== rightOperandNumericType;
+        }
+        if (isShiftOperator(operatorKind) || isBitwiseOperator(operatorKind)) {
+            if (leftOperandNumericType !== NumericType.INTEGER ||
+                rightOperandNumericType !== NumericType.INTEGER) {
+                isCoercionRequired = true;
+            }
+        }
+        if (isCoercionRequired) {
+            const warning = new SemanticWarning(`Different types in binary expression, coercion required: ${NumericType[leftOperandNumericType]} vs ${NumericType[rightOperandNumericType]}`, operatorToken.getLocation());
+            this.semanticWarnings.push(warning);
+        }
+    }
+    validateUnaryExpression(unaryExpression) {
+        const operand = getRequiredOperand(unaryExpression.operand, unaryExpression, this.strict);
+        if (!operand) {
+            return;
+        }
+        const operandNumericType = resolveNumericType(operand, this.symbolTable);
+        // If the type cannot be determined (due to identifier not being defined etc.)
+        // then just return as there will already be a semantic error undefined symbol
+        if (operandNumericType === undefined) {
+            return;
+        }
+        if (unaryExpression.postfixOperator) {
+            const token = unaryExpression.postfixOperator;
+            if (token.tokenKind === TokenKind.POSTFIX_INCREMENT ||
+                token.tokenKind === TokenKind.POSTFIX_DECREMENT) {
+                if (operandNumericType !== NumericType.INTEGER) {
+                    const warning = new SemanticWarning(`Non-integer ${token.tokenKind === TokenKind.POSTFIX_INCREMENT ? "increment" : "decrement"} operand, coercion required: ${NumericType[operandNumericType]}`, token.getLocation());
+                    this.semanticWarnings.push(warning);
+                }
+            }
+        }
+    }
+}

package/dist/src/analyser/sdl-analyser.d.ts

@@ -0,0 +1,20 @@
+import type { Specification } from "../ast/node/specification.ts";
+import type { SemanticError, SemanticWarning } from "../scanner-error.ts";
+import type { Check } from "./checks/check.ts";
+import { SymbolTable } from "./symbol-table.ts";
+export interface SdlAnalysisResult {
+    semanticErrors: Array<SemanticError>;
+    semanticWarnings: Array<SemanticWarning>;
+    specification: Specification;
+    symbolTable: SymbolTable;
+}
+export declare class SdlAnalyser {
+    strict: boolean;
+    checks: Check[];
+    configure(options: {
+        checks?: Check[];
+        strict?: boolean;
+    }): SdlAnalyser;
+    analyse(specification: Specification): SdlAnalysisResult;
+}
+//# sourceMappingURL=sdl-analyser.d.ts.map

package/dist/src/analyser/sdl-analyser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdl-analyser.d.ts","sourceRoot":"","sources":["../../../src/analyser/sdl-analyser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE1E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAG/C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;IACrC,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;IACzC,aAAa,EAAE,aAAa,CAAC;IAC7B,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,qBAAa,WAAW;IACtB,MAAM,EAAE,OAAO,CAAS;IACxB,MAAM,EAAE,KAAK,EAAE,CAAM;IAErB,SAAS,CAAC,OAAO,EAAE;QAAE,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,WAAW;IAYvE,OAAO,CAAC,aAAa,EAAE,aAAa,GAAG,iBAAiB;CA0EzD"}

package/dist/src/analyser/sdl-analyser.js

@@ -0,0 +1,69 @@
+import { dispatchNodeHandler } from "../parse-helper.js";
+import { BuildSymbolTableNodeHandler } from "./node-handler/build-symbol-table-node-handler.js";
+import { ValidateScopeNodeHandler } from "./node-handler/validate-scope-node-handler.js";
+import { ValidateTypeNodeHandler } from "./node-handler/validate-type-node-handler.js";
+import { SymbolTable } from "./symbol-table.js";
+import { SpecificCheckNodeHandler } from "./node-handler/specific-check-node-handler.js";
+export class SdlAnalyser {
+    strict = false;
+    checks = [];
+    configure(options) {
+        if (options.checks) {
+            this.checks = options.checks;
+        }
+        if (options.strict !== undefined) {
+            this.strict = options.strict;
+        }
+        return this;
+    }
+    analyse(specification) {
+        const symbolTable = new SymbolTable();
+        const buildSymbolTableNodeHandler = new BuildSymbolTableNodeHandler(symbolTable, this.strict);
+        dispatchNodeHandler(specification, buildSymbolTableNodeHandler);
+        symbolTable.resetScope();
+        const validateScopeNodeHandler = new ValidateScopeNodeHandler(symbolTable, this.strict);
+        dispatchNodeHandler(specification, validateScopeNodeHandler);
+        symbolTable.resetScope();
+        const validateTypeNodeHandler = new ValidateTypeNodeHandler(symbolTable, this.strict);
+        dispatchNodeHandler(specification, validateTypeNodeHandler);
+        symbolTable.resetScope();
+        const specificCheckNodeHandler = new SpecificCheckNodeHandler(symbolTable, this.strict, this.checks);
+        dispatchNodeHandler(specification, specificCheckNodeHandler);
+        const allErrors = [
+            ...buildSymbolTableNodeHandler.semanticErrors,
+            ...validateScopeNodeHandler.semanticErrors,
+            ...validateTypeNodeHandler.semanticErrors,
+            ...specificCheckNodeHandler.semanticErrors,
+        ];
+        const seenErrors = new Set();
+        const semanticErrors = allErrors.filter((error) => {
+            const key = `${error.errorMessage}:${error.location?.row}:${error.location?.column}`;
+            if (seenErrors.has(key)) {
+                return false;
+            }
+            seenErrors.add(key);
+            return true;
+        });
+        const allWarnings = [
+            ...buildSymbolTableNodeHandler.semanticWarnings,
+            ...validateScopeNodeHandler.semanticWarnings,
+            ...validateTypeNodeHandler.semanticWarnings,
+            ...specificCheckNodeHandler.semanticWarnings,
+        ];
+        const seenWarnings = new Set();
+        const semanticWarnings = allWarnings.filter((warning) => {
+            const key = `${warning.errorMessage}:${warning.location?.row}:${warning.location?.column}`;
+            if (seenWarnings.has(key)) {
+                return false;
+            }
+            seenWarnings.add(key);
+            return true;
+        });
+        return {
+            semanticErrors,
+            semanticWarnings,
+            specification,
+            symbolTable,
+        };
+    }
+}

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

@@ -0,0 +1,103 @@
+import type { Location } from "../location.ts";
+import type { AbstractCompositeNode } from "../ast/node/abstract-composite-node.ts";
+/**
+ * Enum representing different numeric variable types.
+ */
+export declare enum NumericType {
+    INTEGER = 0,
+    DECIMAL = 1,
+    FLOATING_POINT = 2
+}
+/**
+ * Enum representing different string variable types.
+ */
+export declare enum StringType {
+    BASIC = 0,
+    UCS = 1
+}
+/**
+ * Enum representing different kinds of semantic symbols.
+ */
+export declare enum SymbolKind {
+    CLASS = 0,
+    MAP = 1,
+    VARIABLE = 2
+}
+export declare enum AddSymbolResult {
+    SUCCESS = 0,
+    DUPLICATE = 1,
+    MEMBER_CONFLICT = 2
+}
+/**
+ * Enum representing different kinds of scopes.
+ */
+export declare enum ScopeKind {
+    GLOBAL = 0,
+    BLOCK = 1,
+    CLASS = 2,
+    MAP = 3
+}
+export interface SymbolAttributes {
+    isComputed?: boolean;
+    isConst?: boolean;
+    isString?: boolean;
+    isArray?: boolean;
+    numericType?: NumericType;
+    stringType?: StringType;
+    classType?: string;
+    mapType?: string;
+}
+export interface Symbol {
+    name: string;
+    kind: SymbolKind;
+    attributes: SymbolAttributes;
+    location: Location;
+    node: AbstractCompositeNode;
+}
+/**
+ * Used to differentiate between class members defined in different branches of conditional statements within the same class scope.
+ * SDL allows such members to have the same name, but they are considered distinct members that may
+ * or may not be present at runtime depending on the conditions.
+ * The branchId is a string that represents the path of scopes from the class scope to the nested current scope.
+ */
+export interface ClassMemberSymbol {
+    symbol: Symbol;
+    branchId?: string;
+}
+export interface Scope {
+    name: string;
+    parent?: Scope;
+    children: Scope[];
+    symbols: Map<string, Symbol>;
+    classMemberSymbols?: Map<string, ClassMemberSymbol[]>;
+    kind: ScopeKind;
+}
+export declare enum Mode {
+    READ = 0,
+    WRITE = 1
+}
+export declare class SymbolTable {
+    private globalScope;
+    private currentScope;
+    private scopeNameCounters;
+    private mode;
+    constructor();
+    private nextScopeName;
+    private getCurrentBranchId;
+    private defineClassMember;
+    private enterScope;
+    getEnclosingClassScope(): Scope | undefined;
+    enterBlockScope(baseName: string): void;
+    enterClassScope(baseName: string): void;
+    enterMapScope(baseName: string): void;
+    exitScope(): void;
+    getCurrentScope(): Scope;
+    getGlobalScope(): Scope;
+    resetScope(): void;
+    addSymbol(symbol: Symbol): AddSymbolResult;
+    lookupClassMember(name: string): ClassMemberSymbol[] | undefined;
+    lookupVariable(name: string): Symbol | undefined;
+    lookupClass(name: string): Symbol | undefined;
+    lookupMap(name: string): Symbol | undefined;
+}
+//# sourceMappingURL=symbol-table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-table.d.ts","sourceRoot":"","sources":["../../../src/analyser/symbol-table.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,239 @@
+import { InternalScannerError } from "../scanner-error.js";
+import getLogger from "../util/logger.js";
+const logger = getLogger("SymbolTable");
+/**
+ * Enum representing different numeric variable types.
+ */
+export var NumericType;
+(function (NumericType) {
+    NumericType[NumericType["INTEGER"] = 0] = "INTEGER";
+    NumericType[NumericType["DECIMAL"] = 1] = "DECIMAL";
+    NumericType[NumericType["FLOATING_POINT"] = 2] = "FLOATING_POINT";
+})(NumericType || (NumericType = {}));
+/**
+ * Enum representing different string variable types.
+ */
+export var StringType;
+(function (StringType) {
+    StringType[StringType["BASIC"] = 0] = "BASIC";
+    StringType[StringType["UCS"] = 1] = "UCS";
+})(StringType || (StringType = {}));
+/**
+ * Enum representing different kinds of semantic symbols.
+ */
+export var SymbolKind;
+(function (SymbolKind) {
+    SymbolKind[SymbolKind["CLASS"] = 0] = "CLASS";
+    SymbolKind[SymbolKind["MAP"] = 1] = "MAP";
+    SymbolKind[SymbolKind["VARIABLE"] = 2] = "VARIABLE";
+})(SymbolKind || (SymbolKind = {}));
+export var AddSymbolResult;
+(function (AddSymbolResult) {
+    AddSymbolResult[AddSymbolResult["SUCCESS"] = 0] = "SUCCESS";
+    AddSymbolResult[AddSymbolResult["DUPLICATE"] = 1] = "DUPLICATE";
+    AddSymbolResult[AddSymbolResult["MEMBER_CONFLICT"] = 2] = "MEMBER_CONFLICT";
+})(AddSymbolResult || (AddSymbolResult = {}));
+/**
+ * Enum representing different kinds of scopes.
+ */
+export var ScopeKind;
+(function (ScopeKind) {
+    ScopeKind[ScopeKind["GLOBAL"] = 0] = "GLOBAL";
+    ScopeKind[ScopeKind["BLOCK"] = 1] = "BLOCK";
+    ScopeKind[ScopeKind["CLASS"] = 2] = "CLASS";
+    ScopeKind[ScopeKind["MAP"] = 3] = "MAP";
+})(ScopeKind || (ScopeKind = {}));
+export var Mode;
+(function (Mode) {
+    Mode[Mode["READ"] = 0] = "READ";
+    Mode[Mode["WRITE"] = 1] = "WRITE";
+})(Mode || (Mode = {}));
+export class SymbolTable {
+    globalScope;
+    currentScope;
+    scopeNameCounters = new Map();
+    mode = Mode.WRITE;
+    constructor() {
+        this.globalScope = {
+            symbols: new Map(),
+            children: [],
+            name: "GLOBAL",
+            kind: ScopeKind.GLOBAL,
+        };
+        this.currentScope = this.globalScope;
+    }
+    nextScopeName(baseName) {
+        if (!this.scopeNameCounters.has(this.currentScope)) {
+            this.scopeNameCounters.set(this.currentScope, new Map());
+        }
+        const counters = this.scopeNameCounters.get(this.currentScope);
+        const count = counters.get(baseName) ?? 0;
+        counters.set(baseName, count + 1);
+        return count === 0 ? baseName : `${baseName}#${count}`;
+    }
+    getCurrentBranchId() {
+        const classScope = this.getEnclosingClassScope();
+        if (!classScope || this.currentScope === classScope) {
+            return undefined;
+        }
+        const parts = [];
+        let scope = this.currentScope;
+        while (scope && scope !== classScope) {
+            if (scope.name) {
+                parts.unshift(scope.name);
+            }
+            scope = scope.parent;
+        }
+        return parts.length > 0 ? parts.join("/") : undefined;
+    }
+    defineClassMember(symbol) {
+        const classScope = this.getEnclosingClassScope();
+        if (!classScope) {
+            throw new InternalScannerError(`Attempt to define class member '${symbol.name}' outside of class scope`);
+        }
+        if (!classScope.classMemberSymbols) {
+            classScope.classMemberSymbols = new Map();
+        }
+        const members = classScope.classMemberSymbols;
+        if (!members.has(symbol.name)) {
+            members.set(symbol.name, []);
+        }
+        // check for existing member with same name but different elementary type or string variable kind defined in different branch of conditional statement
+        const existingMembers = members.get(symbol.name);
+        for (const memberEntry of existingMembers) {
+            const member = memberEntry.symbol;
+            if (member.attributes.numericType !== symbol.attributes.numericType) {
+                logger.debug(`Defined class member: ${symbol.name} in class scope: ${classScope.name ?? "anonymous"} conflicts with existing member type: ${symbol.attributes.numericType} != ${symbol.attributes.numericType}`);
+                return AddSymbolResult.MEMBER_CONFLICT;
+            }
+            else if (member.attributes.stringType !== symbol.attributes.stringType) {
+                logger.debug(`Defined class member: ${symbol.name} in class scope: ${classScope.name ?? "anonymous"} conflicts with existing member type: ${symbol.attributes.stringType} != ${symbol.attributes.stringType}`);
+                return AddSymbolResult.MEMBER_CONFLICT;
+            }
+        }
+        const branchId = this.getCurrentBranchId();
+        existingMembers.push({ symbol, branchId });
+        logger.debug(`Defined class member: ${symbol.name} in class scope: ${classScope.name ?? "anonymous"}${branchId ? ` (branch: ${branchId})` : ""}`);
+        return AddSymbolResult.SUCCESS;
+    }
+    enterScope(baseName, scopeKind) {
+        const name = this.nextScopeName(baseName);
+        let child = this.currentScope.children.find((c) => c.name === name);
+        if (child && this.mode === Mode.WRITE) {
+            throw new InternalScannerError(`Scope with name '${name}' already exists in current scope '${this.currentScope.name}'`);
+        }
+        if (!child && this.mode === Mode.READ) {
+            throw new InternalScannerError(`Scope with name '${name}' does not exist in current scope '${this.currentScope.name}'`);
+        }
+        // Add the scope if if doesn't already exist
+        if (!child) {
+            child = {
+                symbols: new Map(),
+                parent: this.currentScope,
+                children: [],
+                name,
+                kind: scopeKind,
+            };
+            this.currentScope.children.push(child);
+        }
+        this.currentScope = child;
+        logger.debug(`Entered ${ScopeKind[scopeKind]} scope: ${name}`);
+    }
+    getEnclosingClassScope() {
+        let scope = this.currentScope;
+        while (scope) {
+            if (scope.kind === ScopeKind.CLASS) {
+                return scope;
+            }
+            scope = scope.parent;
+        }
+        return undefined;
+    }
+    enterBlockScope(baseName) {
+        this.enterScope(baseName, ScopeKind.BLOCK);
+    }
+    enterClassScope(baseName) {
+        this.enterScope(baseName, ScopeKind.CLASS);
+    }
+    enterMapScope(baseName) {
+        this.enterScope(baseName, ScopeKind.MAP);
+    }
+    exitScope() {
+        if (this.currentScope.parent) {
+            logger.debug(`Exiting ${ScopeKind[this.currentScope.kind]} scope: ${this.currentScope.name}`);
+            this.currentScope = this.currentScope.parent;
+            return;
+        }
+        throw new InternalScannerError("Cannot exit global scope");
+    }
+    getCurrentScope() {
+        return this.currentScope;
+    }
+    getGlobalScope() {
+        return this.globalScope;
+    }
+    resetScope() {
+        this.currentScope = this.globalScope;
+        this.scopeNameCounters.clear();
+        this.mode = Mode.READ;
+    }
+    addSymbol(symbol) {
+        if (this.mode === Mode.READ) {
+            throw new InternalScannerError(`Attempt to add symbol '${symbol.name}' in read-only mode`);
+        }
+        if (this.currentScope.symbols.has(symbol.name)) {
+            return AddSymbolResult.DUPLICATE;
+        }
+        if (this.currentScope !== this.globalScope) {
+            if (symbol.kind === SymbolKind.CLASS) {
+                throw new InternalScannerError(`Class symbol '${symbol.name}' must be defined in global scope`);
+            }
+            if (symbol.kind === SymbolKind.MAP) {
+                throw new InternalScannerError(`Map symbol '${symbol.name}' must be defined in global scope`);
+            }
+        }
+        this.currentScope.symbols.set(symbol.name, symbol);
+        logger.debug(`Defined symbol: ${symbol.name} in scope: ${this.currentScope.name ?? "anonymous"}`);
+        // if in a class scope and if variable is parsed (regardless of nested level) or if
+        // variable is computed (and in in top level of class scope) then define variable as a class member
+        if (this.getEnclosingClassScope() &&
+            (symbol.attributes.isComputed !== true || this.currentScope.kind === ScopeKind.CLASS)) {
+            if (this.defineClassMember(symbol) !== AddSymbolResult.SUCCESS) {
+                return AddSymbolResult.MEMBER_CONFLICT;
+            }
+        }
+        return AddSymbolResult.SUCCESS;
+    }
+    lookupClassMember(name) {
+        const classScope = this.getEnclosingClassScope();
+        if (!classScope?.classMemberSymbols) {
+            return undefined;
+        }
+        return classScope.classMemberSymbols.get(name);
+    }
+    lookupVariable(name) {
+        let scope = this.currentScope;
+        while (scope) {
+            const symbol = scope.symbols.get(name);
+            if (symbol && symbol.kind === SymbolKind.VARIABLE) {
+                return symbol;
+            }
+            scope = scope.parent;
+        }
+        return undefined;
+    }
+    lookupClass(name) {
+        const symbol = this.globalScope.symbols.get(name);
+        if (symbol && symbol.kind === SymbolKind.CLASS) {
+            return symbol;
+        }
+        return undefined;
+    }
+    lookupMap(name) {
+        const symbol = this.globalScope.symbols.get(name);
+        if (symbol && symbol.kind === SymbolKind.MAP) {
+            return symbol;
+        }
+        return undefined;
+    }
+}