@mpeggroup/mpeg-sdl-parser 4.1.2 → 4.1.3

package/dist/src/analyser/checks/check-map-definition.js

@@ -0,0 +1,72 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { StatementKind } from "../../ast/node/enum/statement-kind.js";
+import { isIdentifier } from "../../ast/util/types.js";
+import { ElementaryTypeKind } from "../../ast/node/enum/elementary-type-kind.js";
+import { getElementaryTypeKind } from "../util/symbol-table-utils.js";
+function checkMapTypeMatchesDeclaration(definition, symbolTable, strict) {
+    const results = [];
+    if (!isIdentifier(definition.mapIdentifier)) {
+        return results;
+    }
+    const mapSymbol = symbolTable.lookupMap(definition.mapIdentifier.name);
+    if (!mapSymbol) {
+        return results;
+    }
+    const mapDeclaration = mapSymbol.node;
+    // Compare element types
+    const defHasElementaryType = definition.elementaryType !== undefined;
+    const declHasElementaryType = mapDeclaration.outputElementaryType !== undefined;
+    const defHasClassType = definition.classIdentifier !== undefined;
+    const declHasClassType = mapDeclaration.outputClassIdentifier !== undefined;
+    if (defHasElementaryType !== declHasElementaryType || defHasClassType !== declHasClassType) {
+        const location = definition.elementaryType?.startToken?.getLocation() ||
+            definition.classIdentifier?.startToken?.getLocation() ||
+            definition.mapIdentifier.startToken.getLocation();
+        results.push({
+            message: "The type of the map definition must match the output_type of the map declaration.",
+            location,
+        });
+    }
+    else if (defHasElementaryType && declHasElementaryType) {
+        // Both have elementary types - compare them
+        const defType = definition.elementaryType;
+        const declType = mapDeclaration.outputElementaryType;
+        const defTypeKind = getElementaryTypeKind(defType, strict);
+        const declTypeKind = getElementaryTypeKind(declType, strict);
+        const isIntegerCompatible = (k1, k2) => {
+            if (k1 === undefined || k2 === undefined)
+                return false;
+            const intTypes = new Set([ElementaryTypeKind.INTEGER, ElementaryTypeKind.UNSIGNED_INTEGER]);
+            return intTypes.has(k1) && intTypes.has(k2);
+        };
+        if (defType.nodeKind !== declType.nodeKind ||
+            (defTypeKind !== declTypeKind && !isIntegerCompatible(defTypeKind, declTypeKind))) {
+            results.push({
+                message: "The type of the map definition must match the output_type of the map declaration.",
+                location: definition.elementaryType.startToken.getLocation(),
+            });
+        }
+    }
+    else if (defHasClassType && declHasClassType) {
+        // Both have class types - compare them
+        if (isIdentifier(definition.classIdentifier) &&
+            isIdentifier(mapDeclaration.outputClassIdentifier)) {
+            if (definition.classIdentifier.name !== mapDeclaration.outputClassIdentifier.name) {
+                results.push({
+                    message: "The type of the map definition must match the output_type of the map declaration.",
+                    location: definition.classIdentifier.startToken.getLocation(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export const checkMapDefinition = {
+    nodeKind: NodeKind.STATEMENT,
+    subKind: StatementKind.MAP_DEFINITION,
+    checkFunc: function (definition, symbolTable, strict) {
+        const results = [];
+        results.push(...checkMapTypeMatchesDeclaration(definition, symbolTable, strict));
+        return results;
+    },
+};

package/dist/src/analyser/checks/check-number-literal-float.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "./check.ts";
+export declare const checkNumberLiteralFloat: Check;
+//# sourceMappingURL=check-number-literal-float.d.ts.map

package/dist/src/analyser/checks/check-number-literal-float.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-number-literal-float.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-number-literal-float.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AAErD,eAAO,MAAM,uBAAuB,EAAE,KAiBrC,CAAC"}

package/dist/src/analyser/checks/check-number-literal-float.js

@@ -0,0 +1,17 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { NumberLiteralKind } from "../../ast/node/enum/number-literal-kind.js";
+export const checkNumberLiteralFloat = {
+    nodeKind: NodeKind.NUMBER_LITERAL,
+    subKind: NumberLiteralKind.FLOATING_POINT,
+    checkFunc: function (node, _symbolTable, _strict) {
+        const results = [];
+        if (Object.is(node.value, -0)) {
+            results.push({
+                message: "Usage of signed zero for a floating point literal will lead to undefined behaviour.",
+                location: node.getLocation(),
+                isWarning: true,
+            });
+        }
+        return results;
+    },
+};

package/dist/src/analyser/checks/check-parameter-list.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "./check.ts";
+export declare const checkParameterList: Check;
+//# sourceMappingURL=check-parameter-list.d.ts.map

package/dist/src/analyser/checks/check-parameter-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-parameter-list.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-parameter-list.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AAErD,eAAO,MAAM,kBAAkB,EAAE,KA0BhC,CAAC"}

package/dist/src/analyser/checks/check-parameter-list.js

@@ -0,0 +1,26 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { getRequiredIdentifier } from "../util/symbol-table-utils.js";
+export const checkParameterList = {
+    nodeKind: NodeKind.PARAMETER_LIST,
+    checkFunc: function (node, _symbolTable, strict) {
+        const results = [];
+        for (const param of node.parameters) {
+            if (param.nodeKind !== NodeKind.PARAMETER) {
+                continue;
+            }
+            const parameter = param;
+            // Check if both elementaryType and classIdentifier are undefined/null
+            // This indicates a string type parameter which is not supported
+            if (!parameter.elementaryType && !parameter.classIdentifier) {
+                const identifier = getRequiredIdentifier(parameter.identifier, parameter, strict);
+                if (identifier) {
+                    results.push({
+                        message: "String variables are not supported in class parameter lists.",
+                        location: identifier.startToken.getLocation(),
+                    });
+                }
+            }
+        }
+        return results;
+    },
+};

package/dist/src/analyser/checks/check-specification.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "./check.ts";
+export declare const checkSpecification: Check;
+//# sourceMappingURL=check-specification.d.ts.map

package/dist/src/analyser/checks/check-specification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-specification.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-specification.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AAErD,eAAO,MAAM,kBAAkB,EAAE,KAoChC,CAAC"}

package/dist/src/analyser/checks/check-specification.js

@@ -0,0 +1,37 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { StatementKind } from "../../ast/node/enum/statement-kind.js";
+import { isStatement } from "../../ast/util/types.js";
+export const checkSpecification = {
+    nodeKind: NodeKind.SPECIFICATION,
+    checkFunc: function (node, _symbolTable, _strict) {
+        const results = [];
+        for (const child of node.children) {
+            if (!isStatement(child)) {
+                continue;
+            }
+            const statement = child;
+            if (statement.statementKind === StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION) {
+                const definition = statement;
+                if (definition.constKeyword === undefined) {
+                    results.push({
+                        message: "The only items that may be present in global scope are: constant computed elementary variable definitions, map declarations, class declarations.",
+                        location: child.getLocation(),
+                    });
+                }
+            }
+            else if (statement.statementKind === StatementKind.MAP_DECLARATION) {
+                continue;
+            }
+            else if (statement.statementKind === StatementKind.CLASS_DECLARATION) {
+                continue;
+            }
+            else {
+                results.push({
+                    message: "The only items that may be present in global scope are: constant computed elementary variable definitions, map declarations, class declarations.",
+                    location: child.getLocation(),
+                });
+            }
+        }
+        return results;
+    },
+};

package/dist/src/analyser/checks/check-switch-statement.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "./check.ts";
+export declare const checkSwitchStatement: Check;
+//# sourceMappingURL=check-switch-statement.d.ts.map

package/dist/src/analyser/checks/check-switch-statement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-switch-statement.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-switch-statement.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AA8JrD,eAAO,MAAM,oBAAoB,EAAE,KAwBlC,CAAC"}

package/dist/src/analyser/checks/check-switch-statement.js

@@ -0,0 +1,140 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { StatementKind } from "../../ast/node/enum/statement-kind.js";
+import { isCaseClause, isDefaultClause, isStatement } from "../../ast/util/types.js";
+import { collectMemberVariableNames } from "./check-if-statement.js";
+function collectMemberVariableNamesFromCaseClause(caseClause) {
+    const names = new Set();
+    for (const stmt of caseClause.statements) {
+        const stmtNames = collectMemberVariableNames(stmt);
+        for (const name of stmtNames) {
+            names.add(name);
+        }
+    }
+    return names;
+}
+function collectMemberVariableNamesFromDefaultClause(defaultClause) {
+    const names = new Set();
+    for (const stmt of defaultClause.statements) {
+        if (isStatement(stmt)) {
+            const stmtNames = collectMemberVariableNames(stmt);
+            for (const name of stmtNames) {
+                names.add(name);
+            }
+        }
+    }
+    return names;
+}
+function checkPossibleDuplicateMembers(switchStatement) {
+    const results = [];
+    // Collect member variable names from all case clauses and default clause
+    const allMemberNamesByClause = [];
+    // Process case clauses
+    for (const caseClause of switchStatement.caseClauses) {
+        if (isCaseClause(caseClause)) {
+            const names = collectMemberVariableNamesFromCaseClause(caseClause);
+            if (names.size > 0) {
+                allMemberNamesByClause.push({ names, clause: caseClause });
+            }
+        }
+    }
+    // Process default clause
+    if (isDefaultClause(switchStatement.defaultClause)) {
+        const names = collectMemberVariableNamesFromDefaultClause(switchStatement.defaultClause);
+        if (names.size > 0) {
+            allMemberNamesByClause.push({
+                names,
+                clause: switchStatement.defaultClause,
+            });
+        }
+    }
+    // Check for overlapping names between clauses
+    const foundOverlaps = new Set();
+    for (let i = 0; i < allMemberNamesByClause.length; i++) {
+        for (let j = i + 1; j < allMemberNamesByClause.length; j++) {
+            const names1 = allMemberNamesByClause[i].names;
+            const names2 = allMemberNamesByClause[j].names;
+            for (const name of names1) {
+                if (names2.has(name)) {
+                    foundOverlaps.add(name);
+                }
+            }
+        }
+    }
+    if (foundOverlaps.size > 0) {
+        results.push({
+            message: "This switch statement may result in duplicate class member variables being declared simultaneously.",
+            location: switchStatement.startToken.getLocation(),
+            isWarning: true,
+        });
+    }
+    return results;
+}
+function checkDefiniteDuplicateMembers(switchStatement) {
+    const results = [];
+    // Collect member variable names from all case clauses
+    const allCaseMemberNames = [];
+    for (const caseClause of switchStatement.caseClauses) {
+        if (isCaseClause(caseClause)) {
+            const names = collectMemberVariableNamesFromCaseClause(caseClause);
+            if (names.size > 0) {
+                allCaseMemberNames.push(names);
+            }
+        }
+    }
+    // Collect from default clause
+    let defaultMemberNames = new Set();
+    if (isDefaultClause(switchStatement.defaultClause)) {
+        defaultMemberNames = collectMemberVariableNamesFromDefaultClause(switchStatement.defaultClause);
+    }
+    // If we have at least 2 clauses with variables
+    if (allCaseMemberNames.length >= 2) {
+        // Find variables that appear in ALL case clauses
+        const firstCaseNames = allCaseMemberNames[0];
+        const definiteOverlaps = new Set();
+        for (const name of firstCaseNames) {
+            let appearsInAll = true;
+            // Check if it appears in all other case clauses
+            for (let i = 1; i < allCaseMemberNames.length; i++) {
+                if (!allCaseMemberNames[i].has(name)) {
+                    appearsInAll = false;
+                    break;
+                }
+            }
+            // If there's a default clause, it must also have the variable
+            if (appearsInAll &&
+                isDefaultClause(switchStatement.defaultClause) &&
+                defaultMemberNames.size > 0) {
+                if (!defaultMemberNames.has(name)) {
+                    appearsInAll = false;
+                }
+            }
+            if (appearsInAll) {
+                definiteOverlaps.add(name);
+            }
+        }
+        if (definiteOverlaps.size > 0) {
+            results.push({
+                message: "This switch statement will result in duplicate class member variables being declared simultaneously.",
+                location: switchStatement.startToken.getLocation(),
+            });
+        }
+    }
+    return results;
+}
+export const checkSwitchStatement = {
+    nodeKind: NodeKind.STATEMENT,
+    subKind: StatementKind.SWITCH,
+    checkFunc: function (switchStatement, symbolTable, _strict) {
+        const results = [];
+        // Check if we're in a class scope
+        const classScope = symbolTable.getEnclosingClassScope();
+        if (!classScope) {
+            return results; // Not in a class scope, no need to check
+        }
+        // Check for possible duplicate members (warning)
+        results.push(...checkPossibleDuplicateMembers(switchStatement));
+        // Check for definite duplicate members (error)
+        results.push(...checkDefiniteDuplicateMembers(switchStatement));
+        return results;
+    },
+};

package/dist/src/analyser/checks/check.d.ts

@@ -0,0 +1,15 @@
+import type { AbstractCompositeNode } from "../../ast/node/abstract-composite-node.ts";
+import type { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import type { Location } from "../../location.ts";
+import type { SymbolTable } from "../symbol-table.ts";
+export interface CheckResult {
+    message: string;
+    location: Location;
+    isWarning?: boolean;
+}
+export interface Check {
+    nodeKind: NodeKind;
+    subKind?: number;
+    checkFunc(node: AbstractCompositeNode, symbolTable: SymbolTable, strict: boolean): CheckResult[];
+}
+//# sourceMappingURL=check.d.ts.map

package/dist/src/analyser/checks/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2CAA2C,CAAC;AACvF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,EAAE,QAAQ,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,IAAI,EAAE,qBAAqB,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,GAAG,WAAW,EAAE,CAAC;CAClG"}

package/dist/src/analyser/checks/check.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,18 @@
+import type { Check } from "./checks/check.ts";
+import { SdlAnalyser } from "./sdl-analyser.ts";
+export declare const defaultChecks: Check[];
+/**
+ * Create a lenient SDL analyser and store it as a "singleton".
+ *
+ * @param checks Optional `Check` implementations to use in the analyser. If not supplied `defaultChecks` will be applied.
+ *   NOTE: When passing a value for `checks`, `defaultChecks` must be included in this value if they are to be applied.
+ */
+export declare function createLenientSdlAnalyser(checks?: Check[] | undefined): SdlAnalyser;
+/**
+ * Create a strict SDL analyser and store it as a "singleton".
+ *
+ * @param checks Optional `Check` implementations to use in the analyser. If not supplied `defaultChecks` will be applied.
+ *   NOTE: When passing a value for `checks`, `defaultChecks` must be included in this value if they are to be applied.
+ */
+export declare function createStrictSdlAnalyser(checks?: Check[] | undefined): SdlAnalyser;
+//# sourceMappingURL=create-sdl-analyser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-sdl-analyser.d.ts","sourceRoot":"","sources":["../../../src/analyser/create-sdl-analyser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAkB/C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKhD,eAAO,MAAM,aAAa,EAAE,KAAK,EAkBhC,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,GAAG,SAAS,GAAG,WAAW,CAWlF;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,GAAG,SAAS,GAAG,WAAW,CAYjF"}

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

@@ -0,0 +1,72 @@
+import { checkArrayDefinition } from "./checks/check-array-definition.js";
+import { checkArrayElementAccess } from "./checks/check-array-element-access.js";
+import { checkClassDeclaration } from "./checks/check-class-declaration.js";
+import { checkComputedArrayDefinition } from "./checks/check-computed-array-definition.js";
+import { checkComputedElementaryTypeDefinition } from "./checks/check-computed-elementary-type-definition.js";
+import { checkElementaryTypeDefinition } from "./checks/check-elementary-type-definition.js";
+import { checkExpressionBinary } from "./checks/check-expression-binary.js";
+import { checkExpressionLengthof } from "./checks/check-expression-lengthof.js";
+import { checkExpressionUnary } from "./checks/check-expression-unary.js";
+import { checkIdentifier } from "./checks/check-identifier.js";
+import { checkIfStatement } from "./checks/check-if-statement.js";
+import { checkMapDeclaration } from "./checks/check-map-declaration.js";
+import { checkMapDefinition } from "./checks/check-map-definition.js";
+import { checkSwitchStatement } from "./checks/check-switch-statement.js";
+import { checkNumberLiteralFloat } from "./checks/check-number-literal-float.js";
+import { checkParameterList } from "./checks/check-parameter-list.js";
+import { checkSpecification } from "./checks/check-specification.js";
+import { SdlAnalyser } from "./sdl-analyser.js";
+let lenientSdlAnalyser;
+let strictSdlAnalyser;
+export const defaultChecks = [
+    checkComputedElementaryTypeDefinition,
+    checkSpecification,
+    checkMapDeclaration,
+    checkMapDefinition,
+    checkClassDeclaration,
+    checkParameterList,
+    checkArrayDefinition,
+    checkComputedArrayDefinition,
+    checkElementaryTypeDefinition,
+    checkIdentifier,
+    checkExpressionUnary,
+    checkExpressionBinary,
+    checkExpressionLengthof,
+    checkNumberLiteralFloat,
+    checkArrayElementAccess,
+    checkIfStatement,
+    checkSwitchStatement,
+];
+/**
+ * Create a lenient SDL analyser and store it as a "singleton".
+ *
+ * @param checks Optional `Check` implementations to use in the analyser. If not supplied `defaultChecks` will be applied.
+ *   NOTE: When passing a value for `checks`, `defaultChecks` must be included in this value if they are to be applied.
+ */
+export function createLenientSdlAnalyser(checks) {
+    if (!lenientSdlAnalyser) {
+        lenientSdlAnalyser = new SdlAnalyser();
+        // Configure the parser with default checks
+        lenientSdlAnalyser = lenientSdlAnalyser.configure({
+            checks: checks || defaultChecks,
+        });
+    }
+    return lenientSdlAnalyser;
+}
+/**
+ * Create a strict SDL analyser and store it as a "singleton".
+ *
+ * @param checks Optional `Check` implementations to use in the analyser. If not supplied `defaultChecks` will be applied.
+ *   NOTE: When passing a value for `checks`, `defaultChecks` must be included in this value if they are to be applied.
+ */
+export function createStrictSdlAnalyser(checks) {
+    if (!strictSdlAnalyser) {
+        strictSdlAnalyser = new SdlAnalyser();
+        // Configure the parser with default checks
+        strictSdlAnalyser = strictSdlAnalyser.configure({
+            checks: checks || defaultChecks,
+            strict: true,
+        });
+    }
+    return strictSdlAnalyser;
+}

package/dist/src/analyser/node-handler/abstract-analysis-node-handler.d.ts

@@ -0,0 +1,63 @@
+import type { AbstractCompositeNode } from "../../ast/node/abstract-composite-node.ts";
+import type { AbstractLeafNode } from "../../ast/node/abstract-leaf-node.ts";
+import { NodeKind } from "../../ast/node/enum/node-kind.ts";
+import type { NodeHandler } from "../../ast/visitor/node-handler.ts";
+import { SemanticError, SemanticWarning } from "../../scanner-error.ts";
+import type { SymbolTable } from "../symbol-table.ts";
+/**
+ * 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 declare abstract class AbstractAnalysisNodeHandler implements NodeHandler {
+    readonly symbolTable: SymbolTable;
+    readonly strict: boolean;
+    readonly semanticErrors: Array<SemanticError>;
+    readonly semanticWarnings: Array<SemanticWarning>;
+    private handlersByNodeKind;
+    private handlersByNodeKindAndSubKind;
+    private implicitScopeNodes;
+    private subKindKey;
+    constructor(symbolTable: SymbolTable, strict: boolean);
+    private handleBeforeClassDeclaration;
+    private handleBeforeMapDeclaration;
+    private handleBeforeStatementKinds;
+    private handleAfterStatementKinds;
+    private handleBeforeArrayDimensionKinds;
+    private handleAfterArrayDimensionKinds;
+    private handleBeforeClassIdKinds;
+    private handleAfterClassIdKinds;
+    private handleBeforeExpressionKinds;
+    private handleAfterExpressionKinds;
+    private registerIfStatementImplicitScopes;
+    private registerSwitchStatementImplicitScopes;
+    private registerWhileStatementImplicitScopes;
+    private registerForStatementImplicitScopes;
+    protected registerBeforeNodeHandler(nodeKind: NodeKind, subKind: number | undefined, handler: (node: AbstractCompositeNode) => void): void;
+    protected registerAfterNodeHandler(nodeKind: NodeKind, subKind: number | undefined, handler: (node: AbstractCompositeNode) => void): void;
+    /**
+     * 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: AbstractCompositeNode): void;
+    /**
+     * 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: AbstractLeafNode): void;
+    afterVisit(node: AbstractCompositeNode): void;
+}
+//# sourceMappingURL=abstract-analysis-node-handler.d.ts.map

package/dist/src/analyser/node-handler/abstract-analysis-node-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-analysis-node-handler.d.ts","sourceRoot":"","sources":["../../../../src/analyser/node-handler/abstract-analysis-node-handler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2CAA2C,CAAC;AAEvF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAG7E,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAU5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAExE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAKtD;;;;;;;;;;;;;;;GAeG;AACH,8BAAsB,2BAA4B,YAAW,WAAW;aAiCpD,WAAW,EAAE,WAAW;aACxB,MAAM,EAAE,OAAO;IAjCjC,SAAgB,cAAc,EAAE,KAAK,CAAC,aAAa,CAAC,CAAM;IAC1D,SAAgB,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,CAAM;IAE9D,OAAO,CAAC,kBAAkB,CAMZ;IAEd,OAAO,CAAC,4BAA4B,CAMtB;IAQd,OAAO,CAAC,kBAAkB,CAAyC;IAEnE,OAAO,CAAC,UAAU;gBAKA,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,OAAO;IAqGjC,OAAO,CAAC,4BAA4B;IAcpC,OAAO,CAAC,0BAA0B;IAclC,OAAO,CAAC,0BAA0B;IAalC,OAAO,CAAC,yBAAyB;IAajC,OAAO,CAAC,+BAA+B;IAavC,OAAO,CAAC,8BAA8B;IAatC,OAAO,CAAC,wBAAwB;IAahC,OAAO,CAAC,uBAAuB;IAa/B,OAAO,CAAC,2BAA2B;IAanC,OAAO,CAAC,0BAA0B;IAalC,OAAO,CAAC,iCAAiC;IAwBzC,OAAO,CAAC,qCAAqC;IAY7C,OAAO,CAAC,oCAAoC;IAU5C,OAAO,CAAC,kCAAkC;IAU1C,SAAS,CAAC,yBAAyB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,OAAO,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GAC7C,IAAI;IA6CP,SAAS,CAAC,wBAAwB,CAChC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,OAAO,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GAC7C,IAAI;IAgCP;;;;OAIG;IAEH,WAAW,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI;IA6B9C;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;IA0CnC,UAAU,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI;CAgB9C"}