@mpeggroup/mpeg-sdl-parser 4.1.1 → 4.1.3

package/dist/src/analyser/node-handler/abstract-analysis-node-handler.js

@@ -0,0 +1,376 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { StatementKind } from "../../ast/node/enum/statement-kind.js";
+import { TokenKind } from "../../ast/node/enum/token-kind.js";
+import { isCaseClause, isDefaultClause, isStatement } from "../../ast/util/types.js";
+import { SemanticError, SemanticWarning } from "../../scanner-error.js";
+import getLogger from "../../util/logger.js";
+import { getRequiredIdentifier } from "../util/symbol-table-utils.js";
+const logger = getLogger("AbstractAnalysisNodeHandler");
+/**
+ * This abstract class provides a base implementation for node handlers that analyze
+ * abstract syntax tree (AST) nodes. It implements the `NodeHandler` interface and
+ * provides default behaviour to handle error nodes and missing required values in
+ * either strict or lenient mode.
+ *
+ * Handlers for specific node kinds (and optional sub-kinds) can be registered using the `registerBeforeNodeHandler`
+ * and `registerAfterNodeHandler` methods, which will be called before and after visiting nodes of the specified kinds, respectively.
+ *
+ * In strict mode, encountering an unexpected error node or an error token will throw a `SemanticError`.
+ * In lenient mode, these nodes will be ignored, and a debug message will be logged.
+ *
+ * Support for adding implicit block scopes for if, switch, while and for statements is implemented
+ * by registering these nodes in implicitScopeNodes (if required) in implicitScopeNodes. The implicit scopes
+ * are then entered and left within beforeVisit() and afterVisit().
+ */
+export class AbstractAnalysisNodeHandler {
+    symbolTable;
+    strict;
+    semanticErrors = [];
+    semanticWarnings = [];
+    handlersByNodeKind = new Map();
+    handlersByNodeKindAndSubKind = new Map();
+    // Set of nodes that we encounter that should implicitly create a new scope
+    // - if statements with non-compound bodies
+    // - switch case clauses with non-compound bodies
+    // - switch default clause with non-compound body
+    // - while statements with non-compound bodies
+    // - for statements with non-compound bodies
+    implicitScopeNodes = new Set();
+    subKindKey(nodeKind, subKind) {
+        return `${nodeKind}:${subKind}`;
+    }
+    constructor(symbolTable, strict) {
+        this.symbolTable = symbolTable;
+        this.strict = strict;
+        // use our own beforeVisit and afterVisit implementations for node kinds with sub-kinds
+        // to dispatch to any registered handlers based on node kind and sub-kind
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, undefined, (node) => {
+            this.handleBeforeStatementKinds(node);
+        });
+        this.registerAfterNodeHandler(NodeKind.STATEMENT, undefined, (node) => {
+            this.handleAfterStatementKinds(node);
+        });
+        this.registerBeforeNodeHandler(NodeKind.ARRAY_DIMENSION, undefined, (node) => {
+            this.handleBeforeArrayDimensionKinds(node);
+        });
+        this.registerAfterNodeHandler(NodeKind.ARRAY_DIMENSION, undefined, (node) => {
+            this.handleAfterArrayDimensionKinds(node);
+        });
+        this.registerBeforeNodeHandler(NodeKind.CLASS_ID, undefined, (node) => {
+            this.handleBeforeClassIdKinds(node);
+        });
+        this.registerAfterNodeHandler(NodeKind.CLASS_ID, undefined, (node) => {
+            this.handleAfterClassIdKinds(node);
+        });
+        this.registerBeforeNodeHandler(NodeKind.EXPRESSION, undefined, (node) => {
+            this.handleBeforeExpressionKinds(node);
+        });
+        this.registerAfterNodeHandler(NodeKind.EXPRESSION, undefined, (node) => {
+            this.handleAfterExpressionKinds(node);
+        });
+        // Implicit scope registration
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.IF, (node) => this.registerIfStatementImplicitScopes(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.SWITCH, (node) => this.registerSwitchStatementImplicitScopes(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.WHILE, (node) => this.registerWhileStatementImplicitScopes(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.FOR, (node) => this.registerForStatementImplicitScopes(node));
+        // Scope enter
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.FOR, (_node) => this.symbolTable.enterBlockScope(StatementKind[StatementKind.FOR]));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.COMPOUND, (_node) => this.symbolTable.enterBlockScope(StatementKind[StatementKind.COMPOUND]));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.WHILE, (_node) => this.symbolTable.enterBlockScope(StatementKind[StatementKind.WHILE]));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.DO, (_node) => this.symbolTable.enterBlockScope(StatementKind[StatementKind.DO]));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.SWITCH, (_node) => this.symbolTable.enterBlockScope(StatementKind[StatementKind.SWITCH]));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.CLASS_DECLARATION, (node) => this.handleBeforeClassDeclaration(node));
+        this.registerBeforeNodeHandler(NodeKind.STATEMENT, StatementKind.MAP_DECLARATION, (node) => this.handleBeforeMapDeclaration(node));
+        // Scope exit
+        this.registerAfterNodeHandler(NodeKind.STATEMENT, StatementKind.COMPOUND, () => this.symbolTable.exitScope());
+        this.registerAfterNodeHandler(NodeKind.STATEMENT, StatementKind.CLASS_DECLARATION, () => this.symbolTable.exitScope());
+        this.registerAfterNodeHandler(NodeKind.STATEMENT, StatementKind.MAP_DECLARATION, () => this.symbolTable.exitScope());
+        this.registerAfterNodeHandler(NodeKind.STATEMENT, StatementKind.FOR, () => this.symbolTable.exitScope());
+        this.registerAfterNodeHandler(NodeKind.STATEMENT, StatementKind.WHILE, () => this.symbolTable.exitScope());
+        this.registerAfterNodeHandler(NodeKind.STATEMENT, StatementKind.DO, () => this.symbolTable.exitScope());
+        this.registerAfterNodeHandler(NodeKind.STATEMENT, StatementKind.SWITCH, () => this.symbolTable.exitScope());
+    }
+    handleBeforeClassDeclaration(classDeclaration) {
+        const identifier = getRequiredIdentifier(classDeclaration.identifier, classDeclaration, this.strict);
+        if (!identifier) {
+            return;
+        }
+        this.symbolTable.enterClassScope(identifier.name);
+    }
+    handleBeforeMapDeclaration(mapDeclaration) {
+        const identifier = getRequiredIdentifier(mapDeclaration.identifier, mapDeclaration, this.strict);
+        if (!identifier) {
+            return;
+        }
+        this.symbolTable.enterMapScope(identifier.name);
+    }
+    handleBeforeStatementKinds(node) {
+        const key = this.subKindKey(node.nodeKind, node.statementKind);
+        if (this.handlersByNodeKindAndSubKind.has(key)) {
+            const handlers = this.handlersByNodeKindAndSubKind.get(key);
+            if (handlers && handlers.beforeVisit) {
+                for (const handler of handlers.beforeVisit) {
+                    handler(node);
+                }
+            }
+        }
+    }
+    handleAfterStatementKinds(node) {
+        const key = this.subKindKey(node.nodeKind, node.statementKind);
+        if (this.handlersByNodeKindAndSubKind.has(key)) {
+            const handlers = this.handlersByNodeKindAndSubKind.get(key);
+            if (handlers && handlers.afterVisit) {
+                for (const handler of handlers.afterVisit) {
+                    handler(node);
+                }
+            }
+        }
+    }
+    handleBeforeArrayDimensionKinds(node) {
+        const key = this.subKindKey(node.nodeKind, node.arrayDimensionKind);
+        if (this.handlersByNodeKindAndSubKind.has(key)) {
+            const handlers = this.handlersByNodeKindAndSubKind.get(key);
+            if (handlers && handlers.beforeVisit) {
+                for (const handler of handlers.beforeVisit) {
+                    handler(node);
+                }
+            }
+        }
+    }
+    handleAfterArrayDimensionKinds(node) {
+        const key = this.subKindKey(node.nodeKind, node.arrayDimensionKind);
+        if (this.handlersByNodeKindAndSubKind.has(key)) {
+            const handlers = this.handlersByNodeKindAndSubKind.get(key);
+            if (handlers && handlers.afterVisit) {
+                for (const handler of handlers.afterVisit) {
+                    handler(node);
+                }
+            }
+        }
+    }
+    handleBeforeClassIdKinds(node) {
+        const key = this.subKindKey(node.nodeKind, node.classIdKind);
+        if (this.handlersByNodeKindAndSubKind.has(key)) {
+            const handlers = this.handlersByNodeKindAndSubKind.get(key);
+            if (handlers && handlers.beforeVisit) {
+                for (const handler of handlers.beforeVisit) {
+                    handler(node);
+                }
+            }
+        }
+    }
+    handleAfterClassIdKinds(node) {
+        const key = this.subKindKey(node.nodeKind, node.classIdKind);
+        if (this.handlersByNodeKindAndSubKind.has(key)) {
+            const handlers = this.handlersByNodeKindAndSubKind.get(key);
+            if (handlers && handlers.afterVisit) {
+                for (const handler of handlers.afterVisit) {
+                    handler(node);
+                }
+            }
+        }
+    }
+    handleBeforeExpressionKinds(node) {
+        const key = this.subKindKey(node.nodeKind, node.expressionKind);
+        if (this.handlersByNodeKindAndSubKind.has(key)) {
+            const handlers = this.handlersByNodeKindAndSubKind.get(key);
+            if (handlers && handlers.beforeVisit) {
+                for (const handler of handlers.beforeVisit) {
+                    handler(node);
+                }
+            }
+        }
+    }
+    handleAfterExpressionKinds(node) {
+        const key = this.subKindKey(node.nodeKind, node.expressionKind);
+        if (this.handlersByNodeKindAndSubKind.has(key)) {
+            const handlers = this.handlersByNodeKindAndSubKind.get(key);
+            if (handlers && handlers.afterVisit) {
+                for (const handler of handlers.afterVisit) {
+                    handler(node);
+                }
+            }
+        }
+    }
+    registerIfStatementImplicitScopes(ifStatement) {
+        if (isStatement(ifStatement.ifStatement)) {
+            const ifNode = ifStatement.ifStatement;
+            if (ifNode.statementKind !== StatementKind.IF &&
+                ifNode.statementKind !== StatementKind.COMPOUND) {
+                this.implicitScopeNodes.add(ifNode);
+            }
+        }
+        if (isStatement(ifStatement.elseStatement)) {
+            const elseNode = ifStatement.elseStatement;
+            if (elseNode.statementKind !== StatementKind.IF &&
+                elseNode.statementKind !== StatementKind.COMPOUND) {
+                this.implicitScopeNodes.add(elseNode);
+            }
+        }
+    }
+    registerSwitchStatementImplicitScopes(switchStatement) {
+        for (const caseClause of switchStatement.caseClauses) {
+            if (isCaseClause(caseClause)) {
+                this.implicitScopeNodes.add(caseClause);
+            }
+        }
+        if (isDefaultClause(switchStatement.defaultClause)) {
+            this.implicitScopeNodes.add(switchStatement.defaultClause);
+        }
+    }
+    registerWhileStatementImplicitScopes(whileStatement) {
+        if (isStatement(whileStatement.statement)) {
+            const ifNode = whileStatement.statement;
+            if (ifNode.statementKind !== StatementKind.COMPOUND) {
+                this.implicitScopeNodes.add(ifNode);
+            }
+        }
+    }
+    registerForStatementImplicitScopes(forStatement) {
+        if (isStatement(forStatement.statement)) {
+            const ifNode = forStatement.statement;
+            if (ifNode.statementKind !== StatementKind.COMPOUND) {
+                this.implicitScopeNodes.add(ifNode);
+            }
+        }
+    }
+    registerBeforeNodeHandler(nodeKind, subKind, handler) {
+        if (subKind !== undefined) {
+            const key = this.subKindKey(nodeKind, subKind);
+            if (!this.handlersByNodeKindAndSubKind.has(key)) {
+                this.handlersByNodeKindAndSubKind.set(key, {});
+            }
+            const handlers = this.handlersByNodeKindAndSubKind.get(key);
+            if (handlers) {
+                if (!handlers.beforeVisit) {
+                    handlers.beforeVisit = [];
+                }
+                // Special case for class and declarations:
+                // The scope needs to be entered AFTER any sub-class implementation
+                // but it cannot be done via registerAfterNodeHandler as the child elements
+                // have been processed by then.
+                if (nodeKind === NodeKind.STATEMENT &&
+                    (subKind === StatementKind.CLASS_DECLARATION || subKind === StatementKind.MAP_DECLARATION)) {
+                    handlers.beforeVisit.unshift(handler);
+                }
+                else {
+                    handlers.beforeVisit.push(handler);
+                }
+            }
+        }
+        else {
+            if (!this.handlersByNodeKind.has(nodeKind)) {
+                this.handlersByNodeKind.set(nodeKind, {});
+            }
+            const handlers = this.handlersByNodeKind.get(nodeKind);
+            if (handlers) {
+                if (!handlers.beforeVisit) {
+                    handlers.beforeVisit = [];
+                }
+                handlers.beforeVisit.push(handler);
+            }
+        }
+    }
+    registerAfterNodeHandler(nodeKind, subKind, handler) {
+        if (subKind !== undefined) {
+            const key = this.subKindKey(nodeKind, subKind);
+            if (!this.handlersByNodeKindAndSubKind.has(key)) {
+                this.handlersByNodeKindAndSubKind.set(key, {});
+            }
+            const handlers = this.handlersByNodeKindAndSubKind.get(key);
+            if (handlers) {
+                if (!handlers.afterVisit) {
+                    handlers.afterVisit = [];
+                }
+                handlers.afterVisit.push(handler);
+            }
+        }
+        else {
+            if (!this.handlersByNodeKind.has(nodeKind)) {
+                this.handlersByNodeKind.set(nodeKind, {});
+            }
+            const handlers = this.handlersByNodeKind.get(nodeKind);
+            if (handlers) {
+                if (!handlers.afterVisit) {
+                    handlers.afterVisit = [];
+                }
+                handlers.afterVisit.push(handler);
+            }
+        }
+    }
+    /**
+     * If the node is an unexpected node, throw an error in strict mode or ignore in lenient mode.
+     *
+     * @param node the leaf node to visit
+     */
+    beforeVisit(node) {
+        if (node.nodeKind === NodeKind.UNEXPECTED_ERROR) {
+            if (this.strict) {
+                throw new SemanticError("UNEXPECTED_ERROR node encountered", node.leadingTrivia ? node.leadingTrivia[0].location : undefined);
+            }
+            // In lenient mode, we simply ignore the unexpected error node
+            logger.debug("Ignoring UNEXPECTED_ERROR node in lenient mode.");
+        }
+        // Enter any implicit scopes for this node
+        if (this.implicitScopeNodes.has(node)) {
+            this.symbolTable.enterBlockScope(StatementKind[StatementKind.COMPOUND]);
+        }
+        if (this.handlersByNodeKind.has(node.nodeKind)) {
+            const handlers = this.handlersByNodeKind.get(node.nodeKind);
+            if (handlers && handlers.beforeVisit) {
+                for (const handler of handlers.beforeVisit) {
+                    handler(node);
+                }
+            }
+        }
+    }
+    /**
+     * If the node is an error token or unexpected node, throw an error in strict mode or ignore in lenient mode.
+     *
+     * @param node the leaf node to visit
+     */
+    visit(node) {
+        if (node.nodeKind === NodeKind.UNEXPECTED_ERROR) {
+            if (this.strict) {
+                throw new SemanticError("UNEXPECTED_ERROR node encountered", node.leadingTrivia ? node.leadingTrivia[0].location : undefined);
+            }
+            // In lenient mode, we simply ignore the unexpected error node
+            logger.debug("Ignoring UNEXPECTED_ERROR node in lenient mode.");
+            return;
+        }
+        else if (node.nodeKind === NodeKind.TOKEN) {
+            const token = node;
+            if (token.tokenKind === TokenKind.ERROR_UNKNOWN_TOKEN) {
+                if (this.strict) {
+                    throw new SemanticError("ERROR_UNKNOWN_TOKEN encountered", token.getLocation());
+                }
+                // In lenient mode, we simply ignore the ERROR_UNKNOWN_TOKEN
+                logger.debug("Ignoring ERROR_UNKNOWN_TOKEN in lenient mode.");
+                return;
+            }
+            if (token.tokenKind === TokenKind.ERROR_MISSING_TOKEN) {
+                if (this.strict) {
+                    throw new SemanticError("ERROR_MISSING_TOKEN encountered", token.getLocation());
+                }
+                // In lenient mode, we simply ignore the ERROR_MISSING_TOKEN
+                logger.debug("Ignoring ERROR_MISSING_TOKEN in lenient mode.");
+                return;
+            }
+        }
+        // Leaf nodes do not need to be visited further for analysis
+    }
+    afterVisit(node) {
+        if (this.handlersByNodeKind.has(node.nodeKind)) {
+            const handlers = this.handlersByNodeKind.get(node.nodeKind);
+            if (handlers && handlers.afterVisit) {
+                for (const handler of handlers.afterVisit) {
+                    handler(node);
+                }
+            }
+        }
+        // Exit any implicit scopes we entered for this node
+        if (this.implicitScopeNodes.has(node)) {
+            this.symbolTable.exitScope();
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import { SymbolTable } from "../symbol-table.ts";
+import { AbstractAnalysisNodeHandler } from "./abstract-analysis-node-handler.ts";
+export declare class BuildSymbolTableNodeHandler extends AbstractAnalysisNodeHandler {
+    constructor(symbolTable: SymbolTable, strict: boolean);
+    private defineSymbol;
+    private addElementaryTypeDefinitionSymbol;
+    private addComputedElementaryTypeDefinitionSymbol;
+    private addArrayDefinitionSymbol;
+    private addComputedArrayDefinitionSymbol;
+    private addStringDefinitionSymbol;
+    private addClassDeclarationSymbol;
+    private addExpandableModifierSymbol;
+    private addMapDeclarationSymbol;
+    private addClassDefinitionSymbol;
+    private addMapDefinitionSymbol;
+    private addParameterSymbol;
+}
+//# sourceMappingURL=build-symbol-table-node-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build-symbol-table-node-handler.d.ts","sourceRoot":"","sources":["../../../../src/analyser/node-handler/build-symbol-table-node-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAc5B,OAAO,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAC;AAelF,qBAAa,2BAA4B,SAAQ,2BAA2B;gBAC9D,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO;IA6CrD,OAAO,CAAC,YAAY;IAgCpB,OAAO,CAAC,iCAAiC;IA6CzC,OAAO,CAAC,yCAAyC;IA8CjD,OAAO,CAAC,wBAAwB;IAmDhC,OAAO,CAAC,gCAAgC;IA4CxC,OAAO,CAAC,yBAAyB;IA4CjC,OAAO,CAAC,yBAAyB;IAwBjC,OAAO,CAAC,2BAA2B;IAkBnC,OAAO,CAAC,uBAAuB;IAoD/B,OAAO,CAAC,wBAAwB;IAoChC,OAAO,CAAC,sBAAsB;IAyD9B,OAAO,CAAC,kBAAkB;CA4C3B"}