@mpeggroup/mpeg-sdl-parser 4.1.2 → 4.1.4

package/dist/src/analyser/node-handler/build-symbol-table-node-handler.js

@@ -0,0 +1,350 @@
+import { AddSymbolResult, NumericType, SymbolKind, SymbolTable, } from "../symbol-table.js";
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { StatementKind } from "../../ast/node/enum/statement-kind.js";
+import { SemanticError } from "../../scanner-error.js";
+import { AbstractAnalysisNodeHandler } from "./abstract-analysis-node-handler.js";
+import { getElementaryTypeKind, getRequiredElementaryType, getRequiredIdentifier, getRequiredToken, getStringVariableKind, } from "../util/symbol-table-utils.js";
+import { isElementaryType, isIdentifier } from "../../ast/util/types.js";
+import { getNumericTypeFromElementaryTypeKind, getStringTypeFromStringVariableKind, } from "../util/type-utils.js";
+export class BuildSymbolTableNodeHandler extends AbstractAnalysisNodeHandler {
+    constructor(symbolTable, strict) {
+        super(symbolTable, strict);
+        this.registerBeforeNodeHandler(NodeKind.PARAMETER, undefined, (node) => this.addParameterSymbol(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.CLASS_DECLARATION, (node) => this.addClassDeclarationSymbol(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.MAP_DECLARATION, (node) => this.addMapDeclarationSymbol(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.ELEMENTARY_TYPE_DEFINITION, (node) => this.addElementaryTypeDefinitionSymbol(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION, (node) => this.addComputedElementaryTypeDefinitionSymbol(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.ARRAY_DEFINITION, (node) => this.addArrayDefinitionSymbol(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.COMPUTED_ARRAY_DEFINITION, (node) => this.addComputedArrayDefinitionSymbol(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.STRING_DEFINITION, (node) => this.addStringDefinitionSymbol(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.CLASS_DEFINITION, (node) => this.addClassDefinitionSymbol(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.MAP_DEFINITION, (node) => this.addMapDefinitionSymbol(node));
+        this.registerBeforeNodeHandler(NodeKind.EXPANDABLE_MODIFIER, undefined, (node) => this.addExpandableModifierSymbol(node));
+    }
+    defineSymbol(symbol) {
+        const addSymbolResult = this.symbolTable.addSymbol(symbol);
+        if (addSymbolResult === AddSymbolResult.SUCCESS) {
+            return;
+        }
+        let error;
+        if (addSymbolResult === AddSymbolResult.DUPLICATE) {
+            error = new SemanticError(`Variable: ${symbol.name} is already declared in scope: ${this.symbolTable.getCurrentScope().name}`, symbol.location);
+        }
+        else if (addSymbolResult === AddSymbolResult.MEMBER_CONFLICT) {
+            const classScope = this.symbolTable.getEnclosingClassScope();
+            error = new SemanticError(`Duplicate member variable: ${symbol.name} conflicts with type defined in different conditional branch within scope: ${classScope.name}`, symbol.location);
+        }
+        if (this.strict) {
+            throw error;
+        }
+        this.semanticErrors.push(error);
+    }
+    addElementaryTypeDefinitionSymbol(elementaryTypeDefinition) {
+        const identifier = getRequiredIdentifier(elementaryTypeDefinition.identifier, elementaryTypeDefinition, this.strict);
+        if (!identifier) {
+            return;
+        }
+        const elementaryType = getRequiredElementaryType(elementaryTypeDefinition.elementaryType, elementaryTypeDefinition, this.strict);
+        if (!elementaryType) {
+            return;
+        }
+        const elementaryTypeKind = getElementaryTypeKind(elementaryType, this.strict);
+        if (elementaryTypeKind === undefined) {
+            return;
+        }
+        const name = identifier.name;
+        const location = identifier.startToken.getLocation();
+        const attributes = {
+            isConst: !!elementaryTypeDefinition.constKeyword,
+            numericType: getNumericTypeFromElementaryTypeKind(elementaryTypeKind),
+        };
+        this.defineSymbol({
+            node: elementaryTypeDefinition,
+            name,
+            kind: SymbolKind.VARIABLE,
+            attributes,
+            location,
+        });
+    }
+    addComputedElementaryTypeDefinitionSymbol(computedElementaryTypeDefinition) {
+        const identifier = getRequiredIdentifier(computedElementaryTypeDefinition.identifier, computedElementaryTypeDefinition, this.strict);
+        if (!identifier) {
+            return;
+        }
+        const elementaryType = getRequiredElementaryType(computedElementaryTypeDefinition.elementaryType, computedElementaryTypeDefinition, this.strict);
+        if (!elementaryType) {
+            return;
+        }
+        const elementaryTypeKind = getElementaryTypeKind(elementaryType, this.strict);
+        if (elementaryTypeKind === undefined) {
+            return;
+        }
+        const name = identifier.name;
+        const location = identifier.startToken.getLocation();
+        const attributes = {
+            isConst: !!computedElementaryTypeDefinition.constKeyword,
+            numericType: getNumericTypeFromElementaryTypeKind(elementaryTypeKind),
+            isComputed: true,
+        };
+        this.defineSymbol({
+            node: computedElementaryTypeDefinition,
+            name,
+            kind: SymbolKind.VARIABLE,
+            attributes,
+            location,
+        });
+    }
+    addArrayDefinitionSymbol(arrayDefinition) {
+        const identifier = getRequiredIdentifier(arrayDefinition.identifier, arrayDefinition, this.strict);
+        if (!identifier) {
+            return;
+        }
+        const name = identifier.name;
+        const location = identifier.startToken.getLocation();
+        const attributes = {
+            isArray: true,
+        };
+        if (isElementaryType(arrayDefinition.elementaryType)) {
+            const elementaryTypeKind = getElementaryTypeKind(arrayDefinition.elementaryType, this.strict);
+            if (elementaryTypeKind !== undefined) {
+                attributes.numericType = getNumericTypeFromElementaryTypeKind(elementaryTypeKind);
+            }
+        }
+        else if (isIdentifier(arrayDefinition.classIdentifier)) {
+            attributes.classType = arrayDefinition.classIdentifier.name;
+        }
+        // check that at least one of elementaryType or classIdentifier is present
+        if (attributes.numericType === undefined && !attributes.classType) {
+            const error = new SemanticError(`Array definition must have either an elementary type or a class identifier`, identifier.startToken.getLocation());
+            if (this.strict) {
+                throw error;
+            }
+            this.semanticErrors.push(error);
+            return;
+        }
+        this.defineSymbol({
+            node: arrayDefinition,
+            name,
+            kind: SymbolKind.VARIABLE,
+            attributes,
+            location,
+        });
+    }
+    addComputedArrayDefinitionSymbol(computedArrayDefinition) {
+        const identifier = getRequiredIdentifier(computedArrayDefinition.identifier, computedArrayDefinition, this.strict);
+        if (!identifier) {
+            return;
+        }
+        const elementaryType = getRequiredElementaryType(computedArrayDefinition.elementaryType, computedArrayDefinition, this.strict);
+        if (!elementaryType) {
+            return;
+        }
+        const elementaryTypeKind = getElementaryTypeKind(elementaryType, this.strict);
+        if (elementaryTypeKind === undefined) {
+            return;
+        }
+        const name = identifier.name;
+        const location = identifier.startToken.getLocation();
+        const attributes = {
+            isArray: true,
+            isComputed: true,
+            numericType: getNumericTypeFromElementaryTypeKind(elementaryTypeKind),
+        };
+        this.defineSymbol({
+            node: computedArrayDefinition,
+            name,
+            kind: SymbolKind.VARIABLE,
+            attributes,
+            location,
+        });
+    }
+    addStringDefinitionSymbol(stringDefinition) {
+        const identifier = getRequiredIdentifier(stringDefinition.identifier, stringDefinition, this.strict);
+        if (!identifier) {
+            return;
+        }
+        const stringVariableKindToken = getRequiredToken(stringDefinition.stringVariableKindToken, stringDefinition, this.strict);
+        if (!stringVariableKindToken) {
+            return;
+        }
+        const stringVariableKind = getStringVariableKind(stringVariableKindToken, this.strict);
+        if (stringVariableKind === undefined) {
+            return;
+        }
+        const name = identifier.name;
+        const location = identifier.startToken.getLocation();
+        const attributes = {
+            isString: true,
+            isConst: !!stringDefinition.constKeyword,
+            stringType: getStringTypeFromStringVariableKind(stringVariableKind),
+        };
+        this.defineSymbol({
+            node: stringDefinition,
+            name,
+            kind: SymbolKind.VARIABLE,
+            attributes,
+            location,
+        });
+    }
+    addClassDeclarationSymbol(classDeclaration) {
+        const identifier = getRequiredIdentifier(classDeclaration.identifier, classDeclaration, this.strict);
+        if (!identifier) {
+            return;
+        }
+        const name = identifier.name;
+        const location = identifier.startToken.getLocation();
+        const attributes = {};
+        this.defineSymbol({
+            node: classDeclaration,
+            name,
+            kind: SymbolKind.CLASS,
+            attributes,
+            location,
+        });
+    }
+    addExpandableModifierSymbol(expandableModifier) {
+        const sizeOfInstanceLocation = expandableModifier.startToken.getLocation();
+        const sizeOfInstanceAttributes = {
+            isComputed: true,
+            isConst: true,
+            numericType: NumericType.INTEGER,
+        };
+        this.defineSymbol({
+            node: expandableModifier,
+            name: "sizeOfInstance",
+            kind: SymbolKind.VARIABLE,
+            attributes: sizeOfInstanceAttributes,
+            location: sizeOfInstanceLocation,
+        });
+    }
+    addMapDeclarationSymbol(mapDeclaration) {
+        const identifier = getRequiredIdentifier(mapDeclaration.identifier, mapDeclaration, this.strict);
+        if (!identifier) {
+            return;
+        }
+        const name = identifier.name;
+        const location = identifier.startToken.getLocation();
+        const attributes = {};
+        if (isElementaryType(mapDeclaration.outputElementaryType)) {
+            const elementaryTypeKind = getElementaryTypeKind(mapDeclaration.outputElementaryType, this.strict);
+            if (elementaryTypeKind !== undefined) {
+                attributes.numericType = getNumericTypeFromElementaryTypeKind(elementaryTypeKind);
+            }
+        }
+        else if (isIdentifier(mapDeclaration.outputClassIdentifier)) {
+            attributes.classType = mapDeclaration.outputClassIdentifier.name;
+        }
+        // check that at least one of elementaryType or classIdentifier is present
+        if (attributes.numericType === undefined && !attributes.classType) {
+            const error = new SemanticError(`Map declaration must have either an elementary type or a class identifier`, identifier.startToken.getLocation());
+            if (this.strict) {
+                throw error;
+            }
+            this.semanticErrors.push(error);
+            return;
+        }
+        this.defineSymbol({
+            node: mapDeclaration,
+            name,
+            kind: SymbolKind.MAP,
+            attributes,
+            location,
+        });
+    }
+    addClassDefinitionSymbol(classDefinition) {
+        const identifier = getRequiredIdentifier(classDefinition.identifier, classDefinition, this.strict);
+        if (!identifier) {
+            return;
+        }
+        const classIdentifier = getRequiredIdentifier(classDefinition.classIdentifier, classDefinition, this.strict);
+        if (!classIdentifier) {
+            return;
+        }
+        const name = identifier.name;
+        const location = identifier.startToken.getLocation();
+        const attributes = {
+            classType: classIdentifier.name,
+        };
+        this.defineSymbol({
+            node: classDefinition,
+            name,
+            kind: SymbolKind.VARIABLE,
+            attributes,
+            location,
+        });
+    }
+    addMapDefinitionSymbol(mapDefinition) {
+        const identifier = getRequiredIdentifier(mapDefinition.identifier, mapDefinition, this.strict);
+        if (!identifier) {
+            return;
+        }
+        const mapIdentifier = getRequiredIdentifier(mapDefinition.mapIdentifier, mapDefinition, this.strict);
+        if (!mapIdentifier) {
+            return;
+        }
+        const name = identifier.name;
+        const location = identifier.startToken.getLocation();
+        const attributes = {
+            mapType: mapIdentifier.name,
+        };
+        if (isElementaryType(mapDefinition.elementaryType)) {
+            const elementaryTypeKind = getElementaryTypeKind(mapDefinition.elementaryType, this.strict);
+            if (elementaryTypeKind !== undefined) {
+                attributes.numericType = getNumericTypeFromElementaryTypeKind(elementaryTypeKind);
+            }
+        }
+        else if (isIdentifier(mapDefinition.classIdentifier)) {
+            attributes.classType = mapDefinition.classIdentifier.name;
+        }
+        // check that at least one of elementaryType or classIdentifier is present
+        if (attributes.numericType === undefined && !attributes.classType) {
+            const error = new SemanticError(`Map definition must have either an elementary type or a class identifier`, identifier.startToken.getLocation());
+            if (this.strict) {
+                throw error;
+            }
+            this.semanticErrors.push(error);
+            return;
+        }
+        this.defineSymbol({
+            node: mapDefinition,
+            name,
+            kind: SymbolKind.VARIABLE,
+            attributes,
+            location,
+        });
+    }
+    addParameterSymbol(parameter) {
+        const identifier = getRequiredIdentifier(parameter.identifier, parameter, this.strict);
+        if (!identifier) {
+            return;
+        }
+        const name = identifier.name;
+        const location = identifier.startToken.getLocation();
+        const attributes = {};
+        if (isElementaryType(parameter.elementaryType)) {
+            const elementaryTypeKind = getElementaryTypeKind(parameter.elementaryType, this.strict);
+            if (elementaryTypeKind !== undefined) {
+                attributes.numericType = getNumericTypeFromElementaryTypeKind(elementaryTypeKind);
+            }
+        }
+        else if (isIdentifier(parameter.classIdentifier)) {
+            attributes.classType = parameter.classIdentifier.name;
+        }
+        // check that at least one of elementaryType or classIdentifier is present
+        if (attributes.numericType === undefined && !attributes.classType) {
+            const error = new SemanticError(`Parameter must have either an elementary type or a class identifier`, identifier.startToken.getLocation());
+            if (this.strict) {
+                throw error;
+            }
+            this.semanticErrors.push(error);
+            return;
+        }
+        this.defineSymbol({
+            node: parameter,
+            name,
+            kind: SymbolKind.VARIABLE,
+            attributes,
+            location,
+        });
+    }
+}

package/dist/src/analyser/node-handler/specific-check-node-handler.d.ts

@@ -0,0 +1,9 @@
+import type { SymbolTable } from "../symbol-table.ts";
+import { AbstractAnalysisNodeHandler } from "./abstract-analysis-node-handler.ts";
+import type { Check } from "../checks/check.ts";
+export declare class SpecificCheckNodeHandler extends AbstractAnalysisNodeHandler {
+    readonly symbolTable: SymbolTable;
+    private readonly checks;
+    constructor(symbolTable: SymbolTable, strict: boolean, checks: Check[]);
+}
+//# sourceMappingURL=specific-check-node-handler.d.ts.map

package/dist/src/analyser/node-handler/specific-check-node-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specific-check-node-handler.d.ts","sourceRoot":"","sources":["../../../../src/analyser/node-handler/specific-check-node-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAC;AAClF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAGhD,qBAAa,wBAAyB,SAAQ,2BAA2B;aAErD,WAAW,EAAE,WAAW;IAExC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAFP,WAAW,EAAE,WAAW,EACxC,MAAM,EAAE,OAAO,EACE,MAAM,EAAE,KAAK,EAAE;CA0BnC"}

package/dist/src/analyser/node-handler/specific-check-node-handler.js

@@ -0,0 +1,29 @@
+import { AbstractAnalysisNodeHandler } from "./abstract-analysis-node-handler.js";
+import { SemanticError, SemanticWarning } from "../../scanner-error.js";
+export class SpecificCheckNodeHandler extends AbstractAnalysisNodeHandler {
+    symbolTable;
+    checks;
+    constructor(symbolTable, strict, checks) {
+        super(symbolTable, strict);
+        this.symbolTable = symbolTable;
+        this.checks = checks;
+        this.checks.forEach((check) => {
+            this.registerBeforeNodeHandler(check.nodeKind, check.subKind, (node) => {
+                const checkResults = check.checkFunc(node, symbolTable, strict);
+                for (const checkResult of checkResults) {
+                    if (checkResult.isWarning) {
+                        const warning = new SemanticWarning(checkResult.message, checkResult.location);
+                        this.semanticWarnings.push(warning);
+                    }
+                    else {
+                        const error = new SemanticError(checkResult.message, checkResult.location);
+                        if (this.strict) {
+                            throw error;
+                        }
+                        this.semanticErrors.push(error);
+                    }
+                }
+            });
+        });
+    }
+}

package/dist/src/analyser/node-handler/validate-scope-node-handler.d.ts

@@ -0,0 +1,18 @@
+import type { SymbolTable } from "../symbol-table.ts";
+import { AbstractAnalysisNodeHandler } from "./abstract-analysis-node-handler.ts";
+export declare class ValidateScopeNodeHandler extends AbstractAnalysisNodeHandler {
+    readonly symbolTable: SymbolTable;
+    constructor(symbolTable: SymbolTable, strict: boolean);
+    private handleMapDeclaration;
+    private validateClassDefinition;
+    private validateMapDefinition;
+    private validateArrayDefinition;
+    private validateExtendsModifier;
+    private validateUnaryExpression;
+    private validateBinaryExpression;
+    private validateLengthofExpression;
+    private checkClassReference;
+    private checkMapReference;
+    private checkIdentifierReference;
+}
+//# sourceMappingURL=validate-scope-node-handler.d.ts.map

package/dist/src/analyser/node-handler/validate-scope-node-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-scope-node-handler.d.ts","sourceRoot":"","sources":["../../../../src/analyser/node-handler/validate-scope-node-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAatD,OAAO,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAC;AAKlF,qBAAa,wBAAyB,SAAQ,2BAA2B;aAErD,WAAW,EAAE,WAAW;gBAAxB,WAAW,EAAE,WAAW,EACxC,MAAM,EAAE,OAAO;IA8BjB,OAAO,CAAC,oBAAoB;IA0B5B,OAAO,CAAC,uBAAuB;IAc/B,OAAO,CAAC,qBAAqB;IA4B7B,OAAO,CAAC,uBAAuB;IAgB/B,OAAO,CAAC,uBAAuB;IAc/B,OAAO,CAAC,uBAAuB;IAc/B,OAAO,CAAC,wBAAwB;IAuBhC,OAAO,CAAC,0BAA0B;IAYlC,OAAO,CAAC,mBAAmB;IAkB3B,OAAO,CAAC,iBAAiB;IAkBzB,OAAO,CAAC,wBAAwB;CA0BjC"}

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

@@ -0,0 +1,144 @@
+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 { SemanticError } from "../../scanner-error.js";
+import { AbstractAnalysisNodeHandler } from "./abstract-analysis-node-handler.js";
+import { getRequiredIdentifier, getRequiredOperand } from "../util/symbol-table-utils.js";
+import { isIdentifier } from "../../ast/util/types.js";
+export class ValidateScopeNodeHandler extends AbstractAnalysisNodeHandler {
+    symbolTable;
+    constructor(symbolTable, strict) {
+        super(symbolTable, strict);
+        this.symbolTable = symbolTable;
+        this.registerBeforeNodeHandler(NodeKind.EXTENDS_MODIFIER, undefined, (node) => this.validateExtendsModifier(node));
+        this.registerBeforeNodeHandler(NodeKind.EXPRESSION, ExpressionKind.UNARY, (node) => this.validateUnaryExpression(node));
+        this.registerBeforeNodeHandler(NodeKind.EXPRESSION, ExpressionKind.BINARY, (node) => this.validateBinaryExpression(node));
+        this.registerBeforeNodeHandler(NodeKind.EXPRESSION, ExpressionKind.LENGTHOF, (node) => this.validateLengthofExpression(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.MAP_DECLARATION, (node) => this.handleMapDeclaration(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.CLASS_DEFINITION, (node) => this.validateClassDefinition(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.MAP_DEFINITION, (node) => this.validateMapDefinition(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.ARRAY_DEFINITION, (node) => this.validateArrayDefinition(node));
+    }
+    handleMapDeclaration(mapDeclaration) {
+        const identifier = getRequiredIdentifier(mapDeclaration.identifier, mapDeclaration, this.strict);
+        if (!identifier) {
+            return;
+        }
+        if (isIdentifier(mapDeclaration.outputClassIdentifier)) {
+            const classIdentifier = getRequiredIdentifier(mapDeclaration.outputClassIdentifier, mapDeclaration, this.strict);
+            if (!classIdentifier) {
+                return;
+            }
+            this.checkClassReference(classIdentifier);
+        }
+    }
+    validateClassDefinition(classDefinition) {
+        const classIdentifier = getRequiredIdentifier(classDefinition.classIdentifier, classDefinition, this.strict);
+        if (!classIdentifier) {
+            return;
+        }
+        this.checkClassReference(classIdentifier);
+    }
+    validateMapDefinition(mapDefinition) {
+        const mapIdentifier = getRequiredIdentifier(mapDefinition.mapIdentifier, mapDefinition, this.strict);
+        if (!mapIdentifier) {
+            return;
+        }
+        this.checkMapReference(mapIdentifier);
+        if (isIdentifier(mapDefinition.classIdentifier)) {
+            const classIdentifier = getRequiredIdentifier(mapDefinition.classIdentifier, mapDefinition, this.strict);
+            if (!classIdentifier) {
+                return;
+            }
+            this.checkClassReference(classIdentifier);
+        }
+    }
+    validateArrayDefinition(arrayDefinition) {
+        if (isIdentifier(arrayDefinition.classIdentifier)) {
+            const classIdentifier = getRequiredIdentifier(arrayDefinition.classIdentifier, arrayDefinition, this.strict);
+            if (!classIdentifier) {
+                return;
+            }
+            this.checkClassReference(classIdentifier);
+        }
+    }
+    validateExtendsModifier(extendsModifier) {
+        const identifier = getRequiredIdentifier(extendsModifier.identifier, extendsModifier, this.strict);
+        if (!identifier) {
+            return;
+        }
+        this.checkClassReference(identifier);
+    }
+    validateUnaryExpression(unaryExpression) {
+        const operand = getRequiredOperand(unaryExpression.operand, unaryExpression, this.strict);
+        if (!operand) {
+            return;
+        }
+        if (isIdentifier(operand)) {
+            this.checkIdentifierReference(operand);
+        }
+        // Nested expressions will be visited recursively by the traversal
+    }
+    validateBinaryExpression(binaryExpression) {
+        const leftOperand = getRequiredOperand(binaryExpression.leftOperand, binaryExpression, this.strict);
+        const rightOperand = getRequiredOperand(binaryExpression.rightOperand, binaryExpression, this.strict);
+        if (isIdentifier(leftOperand)) {
+            this.checkIdentifierReference(leftOperand);
+        }
+        if (isIdentifier(rightOperand)) {
+            this.checkIdentifierReference(rightOperand);
+        }
+        // Nested expressions will be visited recursively by the traversal
+    }
+    validateLengthofExpression(lengthofExpression) {
+        const operand = getRequiredOperand(lengthofExpression.operand, lengthofExpression, this.strict);
+        if (!operand) {
+            return;
+        }
+        if (isIdentifier(operand)) {
+            this.checkIdentifierReference(operand);
+        }
+    }
+    checkClassReference(classIdentifier) {
+        const name = classIdentifier.name;
+        const classSymbol = this.symbolTable.lookupClass(name);
+        if (!classSymbol) {
+            const error = new SemanticError(`Class: ${name} is not declared`, classIdentifier.startToken.getLocation());
+            if (this.strict) {
+                throw error;
+            }
+            this.semanticErrors.push(error);
+        }
+    }
+    checkMapReference(mapIdentifier) {
+        const name = mapIdentifier.name;
+        const mapSymbol = this.symbolTable.lookupMap(name);
+        if (!mapSymbol) {
+            const error = new SemanticError(`Map: ${name} is not declared`, mapIdentifier.startToken.getLocation());
+            if (this.strict) {
+                throw error;
+            }
+            this.semanticErrors.push(error);
+        }
+    }
+    checkIdentifierReference(identifier) {
+        const name = identifier.name;
+        const location = identifier.startToken?.getLocation();
+        const symbol = this.symbolTable.lookupVariable(name);
+        if (!symbol) {
+            const classMembers = this.symbolTable.lookupClassMember(name);
+            if (classMembers && classMembers.length > 0) {
+                return;
+            }
+            const classSymbol = this.symbolTable.lookupClass(name);
+            const mapSymbol = this.symbolTable.lookupMap(name);
+            if (!classSymbol && !mapSymbol) {
+                const error = new SemanticError(`Identifier: ${name} is not declared`, location);
+                if (this.strict) {
+                    throw error;
+                }
+                this.semanticErrors.push(error);
+            }
+        }
+    }
+}

package/dist/src/analyser/node-handler/validate-type-node-handler.d.ts

@@ -0,0 +1,13 @@
+import { type SymbolTable } from "../symbol-table.ts";
+import { AbstractAnalysisNodeHandler } from "./abstract-analysis-node-handler.ts";
+export declare class ValidateTypeNodeHandler extends AbstractAnalysisNodeHandler {
+    readonly symbolTable: SymbolTable;
+    constructor(symbolTable: SymbolTable, strict: boolean);
+    private validateClassDefinition;
+    private validateElementaryTypeDefinition;
+    private validateComputedElementaryTypeDefinition;
+    private validateElementaryTypeValueAndEndValue;
+    private validateBinaryExpression;
+    private validateUnaryExpression;
+}
+//# sourceMappingURL=validate-type-node-handler.d.ts.map

package/dist/src/analyser/node-handler/validate-type-node-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-type-node-handler.d.ts","sourceRoot":"","sources":["../../../../src/analyser/node-handler/validate-type-node-handler.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAgBnE,OAAO,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAC;AAsBlF,qBAAa,uBAAwB,SAAQ,2BAA2B;aAEpD,WAAW,EAAE,WAAW;gBAAxB,WAAW,EAAE,WAAW,EACxC,MAAM,EAAE,OAAO;IA0BjB,OAAO,CAAC,uBAAuB;IAiL/B,OAAO,CAAC,gCAAgC;IAMxC,OAAO,CAAC,wCAAwC;IAMhD,OAAO,CAAC,sCAAsC;IAkE9C,OAAO,CAAC,wBAAwB;IA6EhC,OAAO,CAAC,uBAAuB;CAiChC"}