@mpeggroup/mpeg-sdl-parser 4.1.1 → 4.1.3

package/dist/src/analyser/checks/check-expression-binary.js

@@ -0,0 +1,177 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { BinaryOperatorKind } from "../../ast/node/enum/binary-operator-kind.js";
+import { ExpressionKind } from "../../ast/node/enum/expression-kind.js";
+import { isIdentifier, isNumberLiteral } from "../../ast/util/types.js";
+import { resolveNumericType } from "../util/type-utils.js";
+import { NumericType } from "../symbol-table.js";
+function checkConstMutationViaAssignment(node, symbolTable) {
+    if (node.binaryOperatorKind !== BinaryOperatorKind.ASSIGNMENT) {
+        return [];
+    }
+    if (!isIdentifier(node.leftOperand)) {
+        return [];
+    }
+    const identifier = node.leftOperand;
+    const symbol = symbolTable.lookupVariable(identifier.name);
+    if (symbol && symbol.attributes.isConst && symbol.attributes.isComputed) {
+        return [
+            {
+                message: "a const computed variable cannot be mutated.",
+                location: node.startToken.getLocation(),
+            },
+        ];
+    }
+    return [];
+}
+function checkModulusWithNegativeRhs(node) {
+    if (node.binaryOperatorKind !== BinaryOperatorKind.MODULUS) {
+        return [];
+    }
+    if (!isNumberLiteral(node.rightOperand)) {
+        return [];
+    }
+    const rightLiteral = node.rightOperand;
+    if (rightLiteral.value < 0) {
+        return [
+            {
+                message: "Using the modulus operator with a negative right-hand operand will lead to undefined behavior.",
+                location: node.startToken.getLocation(),
+                isWarning: true,
+            },
+        ];
+    }
+    return [];
+}
+function checkModulusWithFloatOperands(node, symbolTable) {
+    if (node.binaryOperatorKind !== BinaryOperatorKind.MODULUS) {
+        return [];
+    }
+    const leftType = resolveNumericType(node.leftOperand, symbolTable);
+    const rightType = resolveNumericType(node.rightOperand, symbolTable);
+    if (leftType === NumericType.FLOATING_POINT || rightType === NumericType.FLOATING_POINT) {
+        return [
+            {
+                message: "Using the modulus operator cannot be used with float operands.",
+                location: node.startToken.getLocation(),
+            },
+        ];
+    }
+    return [];
+}
+function checkModulusWithZeroRhs(node) {
+    if (node.binaryOperatorKind !== BinaryOperatorKind.MODULUS) {
+        return [];
+    }
+    if (!isNumberLiteral(node.rightOperand)) {
+        return [];
+    }
+    const rightLiteral = node.rightOperand;
+    if (rightLiteral.value === 0) {
+        return [
+            {
+                message: "Using the modulus operator with a right-hand operand of zero will lead to undefined behavior.",
+                location: node.startToken.getLocation(),
+                isWarning: true,
+            },
+        ];
+    }
+    return [];
+}
+function checkDivisionByZero(node) {
+    if (node.binaryOperatorKind !== BinaryOperatorKind.DIVIDE) {
+        return [];
+    }
+    if (!isNumberLiteral(node.rightOperand)) {
+        return [];
+    }
+    const rightLiteral = node.rightOperand;
+    if (rightLiteral.value === 0) {
+        return [
+            {
+                message: "The value of division where the value of the second operand is zero will lead to undefined behavior.",
+                location: node.startToken.getLocation(),
+                isWarning: true,
+            },
+        ];
+    }
+    return [];
+}
+function checkIntegerDivisionWithNegatives(node, symbolTable) {
+    if (node.binaryOperatorKind !== BinaryOperatorKind.DIVIDE) {
+        return [];
+    }
+    const leftType = resolveNumericType(node.leftOperand, symbolTable);
+    const rightType = resolveNumericType(node.rightOperand, symbolTable);
+    if (leftType !== NumericType.INTEGER || rightType !== NumericType.INTEGER) {
+        return [];
+    }
+    const leftIsNegative = isNumberLiteral(node.leftOperand) && node.leftOperand.value < 0;
+    const rightIsNegative = isNumberLiteral(node.rightOperand) && node.rightOperand.value < 0;
+    if (leftIsNegative || rightIsNegative) {
+        return [
+            {
+                message: "The direction of truncation for integer division with negative operands is not defined by the SDL which will lead to undefined behavior.",
+                location: node.startToken.getLocation(),
+                isWarning: true,
+            },
+        ];
+    }
+    return [];
+}
+function checkRightShiftOnSignedInt(node, symbolTable) {
+    if (node.binaryOperatorKind !== BinaryOperatorKind.SHIFT_RIGHT) {
+        return [];
+    }
+    const leftType = resolveNumericType(node.leftOperand, symbolTable);
+    if (leftType === NumericType.INTEGER) {
+        return [
+            {
+                message: "The behaviour of the right shift operator applied to a signed int value is not defined by the SDL which will lead to undefined behavior.",
+                location: node.startToken.getLocation(),
+                isWarning: true,
+            },
+        ];
+    }
+    return [];
+}
+function checkLeftHandAssignmentConst(node, symbolTable) {
+    if (node.binaryOperatorKind !== BinaryOperatorKind.ASSIGNMENT) {
+        return [];
+    }
+    if (!isIdentifier(node.leftOperand)) {
+        return [];
+    }
+    const identifier = node.leftOperand;
+    const symbol = symbolTable.lookupVariable(identifier.name);
+    if (symbol && symbol.attributes.isConst) {
+        return [
+            {
+                message: "The left-hand operand of an assignment operator cannot be a const variable.",
+                location: node.startToken.getLocation(),
+            },
+        ];
+    }
+    return [];
+}
+export const checkExpressionBinary = {
+    nodeKind: NodeKind.EXPRESSION,
+    subKind: ExpressionKind.BINARY,
+    checkFunc: function (node, symbolTable, _strict) {
+        const results = [];
+        // Only process BinaryExpression nodes
+        if (node.expressionKind !== ExpressionKind.BINARY) {
+            return results;
+        }
+        const binaryExpression = node;
+        return [
+            ...checkConstMutationViaAssignment(binaryExpression, symbolTable),
+            ...checkModulusWithNegativeRhs(binaryExpression),
+            ...checkModulusWithFloatOperands(binaryExpression, symbolTable),
+            ...checkModulusWithZeroRhs(binaryExpression),
+            ...checkDivisionByZero(binaryExpression),
+            ...checkIntegerDivisionWithNegatives(binaryExpression, symbolTable),
+            ...checkRightShiftOnSignedInt(binaryExpression, symbolTable),
+            ...checkLeftHandAssignmentConst(binaryExpression, symbolTable),
+        ];
+    },
+};

package/dist/src/analyser/checks/check-expression-lengthof.d.ts

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

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

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

package/dist/src/analyser/checks/check-expression-lengthof.js

@@ -0,0 +1,23 @@
+import { ExpressionKind } from "../../ast/node/enum/expression-kind.js";
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { isIdentifier } from "../../ast/util/types.js";
+export const checkExpressionLengthof = {
+    nodeKind: NodeKind.EXPRESSION,
+    subKind: ExpressionKind.LENGTHOF,
+    checkFunc: function (node, symbolTable, _strict) {
+        const results = [];
+        // Check if operand is an identifier
+        if (isIdentifier(node.operand)) {
+            // Look up the variable in the symbol table
+            const variable = symbolTable.lookupVariable(node.operand.name);
+            // If variable exists and is computed, report error
+            if (variable && variable.attributes.isComputed) {
+                results.push({
+                    message: "The lengthof operator cannot be used with a computed variable.",
+                    location: node.operand.startToken.getLocation(),
+                });
+            }
+        }
+        return results;
+    },
+};

package/dist/src/analyser/checks/check-expression-unary.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"check-expression-unary.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-expression-unary.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AAmIrD,eAAO,MAAM,oBAAoB,EAAE,KAgBlC,CAAC"}

package/dist/src/analyser/checks/check-expression-unary.js

@@ -0,0 +1,104 @@
+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 { ExpressionKind } from "../../ast/node/enum/expression-kind.js";
+import { isIdentifier, isUnaryExpression } from "../../ast/util/types.js";
+function checkConstMutationViaPostfix(expression, symbolTable) {
+    const results = [];
+    if (expression.postfixOperator !== undefined &&
+        (expression.postfixOperator.tokenKind === TokenKind.POSTFIX_INCREMENT ||
+            expression.postfixOperator.tokenKind === TokenKind.POSTFIX_DECREMENT)) {
+        let targetIdentifier;
+        if (isIdentifier(expression.operand)) {
+            targetIdentifier = expression.operand;
+        }
+        else if (expression.operand.nodeKind === NodeKind.EXPRESSION &&
+            isIdentifier(expression.operand.operand)) {
+            targetIdentifier = expression.operand.operand;
+        }
+        if (targetIdentifier) {
+            const variable = symbolTable.lookupVariable(targetIdentifier.name);
+            if (variable && variable.attributes.isConst && variable.attributes.isComputed) {
+                results.push({
+                    message: "a const computed variable cannot be mutated.",
+                    location: expression.startToken.getLocation(),
+                });
+            }
+        }
+    }
+    return results;
+}
+function checkArrayDimensionCountMismatch(expression, symbolTable) {
+    const results = [];
+    if (expression.arrayElementAccess) {
+        // Find the base identifier by traversing nested UnaryExpressions
+        let baseIdentifier;
+        let currentExpr = expression;
+        let accessDimensions = 0;
+        // Count array access dimensions by traversing the nested structure
+        while (isUnaryExpression(currentExpr)) {
+            if (currentExpr.arrayElementAccess) {
+                accessDimensions++;
+            }
+            currentExpr = currentExpr.operand;
+        }
+        // Check if we found an identifier at the base
+        if (isIdentifier(currentExpr)) {
+            baseIdentifier = currentExpr;
+        }
+        if (baseIdentifier) {
+            const variable = symbolTable.lookupVariable(baseIdentifier.name);
+            if (variable && variable.attributes.isArray) {
+                // Get the array definition from the symbol's AST node
+                const arrayDefinition = variable.node;
+                // Count dimensions in the array definition
+                let definedDimensions = 0;
+                if (arrayDefinition.implicitArrayDimension) {
+                    definedDimensions++;
+                }
+                definedDimensions += arrayDefinition.dimensions.length;
+                if (definedDimensions !== accessDimensions) {
+                    results.push({
+                        message: "The number of dimensions used when accessing an array element must match the number of dimensions in the array definition.",
+                        location: expression.startToken.getLocation(),
+                    });
+                }
+            }
+        }
+    }
+    return results;
+}
+function checkUninitializedComputedVariableAccess(expression, _symbolTable) {
+    const results = [];
+    if (isIdentifier(expression.operand)) {
+        const variable = _symbolTable.lookupVariable(expression.operand.name);
+        if (variable && variable.attributes.isComputed) {
+            // Check if the variable definition has no initial value
+            // For computed variables, this would be AbstractElementaryTypeDefinition
+            if (variable.node.nodeKind === NodeKind.STATEMENT &&
+                variable.node.statementKind ===
+                    StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION) {
+                const definition = variable.node;
+                if (!definition.value) {
+                    results.push({
+                        message: "Accessing a computed variable value before it is initialised will result in undefined behaviour.",
+                        location: expression.operand.getLocation(),
+                        isWarning: true,
+                    });
+                }
+            }
+        }
+    }
+    return results;
+}
+export const checkExpressionUnary = {
+    nodeKind: NodeKind.EXPRESSION,
+    subKind: ExpressionKind.UNARY,
+    checkFunc: function (expression, symbolTable, _strict) {
+        const results = [];
+        results.push(...checkConstMutationViaPostfix(expression, symbolTable));
+        results.push(...checkArrayDimensionCountMismatch(expression, symbolTable));
+        results.push(...checkUninitializedComputedVariableAccess(expression, symbolTable));
+        return results;
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"check-identifier.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-identifier.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AA8CrD,eAAO,MAAM,eAAe,EAAE,KAiB7B,CAAC"}

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

@@ -0,0 +1,55 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+// Build set of SDL keywords and literal prefixes
+const getReservedIdentifiers = () => {
+    // Add SDL keywords from token mapping
+    const reserved = new Set([
+        "abstract",
+        "aligned",
+        "base64string",
+        "bit",
+        "break",
+        "case",
+        "class",
+        "computed",
+        "const",
+        "default",
+        "do",
+        "else",
+        "expandable",
+        "extends",
+        "float",
+        "for",
+        "if",
+        "int",
+        "legacy",
+        "lengthof",
+        "map",
+        "reserved",
+        "switch",
+        "unsigned",
+        "utf8string",
+        "utf16string",
+        "utfstring",
+        "utf8list",
+        "while",
+    ]);
+    // Add literal prefixes
+    reserved.add("0b");
+    reserved.add("0x");
+    return reserved;
+};
+const reservedIdentifiers = getReservedIdentifiers();
+export const checkIdentifier = {
+    nodeKind: NodeKind.IDENTIFIER,
+    checkFunc: function (node, _symbolTable, _strict) {
+        const results = [];
+        const identifierName = node.name.toLowerCase();
+        if (reservedIdentifiers.has(identifierName)) {
+            results.push({
+                message: "It is illegal to define an identifier which conflicts (ignoring case) with SDL syntax items such as keywords, binary, hexadecimal and string literal prefixes.",
+                location: node.getLocation(),
+            });
+        }
+        return results;
+    },
+};

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

@@ -0,0 +1,5 @@
+import type { AbstractStatement } from "../../ast/node/abstract-statement.ts";
+import type { Check } from "./check.ts";
+export declare function collectMemberVariableNames(statement: AbstractStatement): Set<string>;
+export declare const checkIfStatement: Check;
+//# sourceMappingURL=check-if-statement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check-if-statement.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-if-statement.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAE9E,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AAIrD,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,iBAAiB,GAAG,GAAG,CAAC,MAAM,CAAC,CAyEpF;AAyBD,eAAO,MAAM,gBAAgB,EAAE,KA6C9B,CAAC"}

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

@@ -0,0 +1,122 @@
+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";
+export function collectMemberVariableNames(statement) {
+    const names = new Set();
+    function traverse(stmt) {
+        // Check if this statement declares a member variable
+        if (stmt.nodeKind === NodeKind.STATEMENT) {
+            switch (stmt.statementKind) {
+                case StatementKind.ELEMENTARY_TYPE_DEFINITION:
+                case StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION:
+                case StatementKind.ARRAY_DEFINITION:
+                case StatementKind.COMPUTED_ARRAY_DEFINITION:
+                case StatementKind.STRING_DEFINITION:
+                case StatementKind.CLASS_DEFINITION:
+                case StatementKind.MAP_DEFINITION: {
+                    // These statements have an identifier property that represents the variable name
+                    const stmtWithIdentifier = stmt;
+                    if (stmtWithIdentifier.identifier?.name) {
+                        names.add(stmtWithIdentifier.identifier.name);
+                    }
+                    break;
+                }
+                case StatementKind.COMPOUND: {
+                    // Recursively check compound statements
+                    const compoundStmt = stmt;
+                    if (compoundStmt.statements) {
+                        for (const nestedStmt of compoundStmt.statements) {
+                            traverse(nestedStmt);
+                        }
+                    }
+                    break;
+                }
+                case StatementKind.IF: {
+                    // Recursively check if statements
+                    const ifStmt = stmt;
+                    if (!isStatement(ifStmt.ifStatement)) {
+                        break;
+                    }
+                    traverse(ifStmt.ifStatement);
+                    if (isStatement(ifStmt.elseStatement)) {
+                        traverse(ifStmt.elseStatement);
+                    }
+                    break;
+                }
+                case StatementKind.SWITCH: {
+                    // Recursively check switch statements
+                    const switchStmt = stmt;
+                    if (switchStmt.caseClauses) {
+                        for (const caseClause of switchStmt.caseClauses) {
+                            if (isCaseClause(caseClause) && caseClause.statements) {
+                                for (const nestedStmt of caseClause.statements) {
+                                    traverse(nestedStmt);
+                                }
+                            }
+                        }
+                    }
+                    if (isDefaultClause(switchStmt.defaultClause) && switchStmt.defaultClause.statements) {
+                        for (const nestedStmt of switchStmt.defaultClause.statements) {
+                            traverse(nestedStmt);
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    traverse(statement);
+    return names;
+}
+function collectAllBranchMemberNames(statement) {
+    const allNames = new Set();
+    function addBranchNames(stmt) {
+        const names = collectMemberVariableNames(stmt);
+        for (const name of names) {
+            allNames.add(name);
+        }
+        // Recursively check nested if statements (else if chains)
+        if (stmt.statementKind === StatementKind.IF) {
+            const ifStmt = stmt;
+            if (isStatement(ifStmt.elseStatement)) {
+                addBranchNames(ifStmt.elseStatement);
+            }
+        }
+    }
+    addBranchNames(statement);
+    return allNames;
+}
+export const checkIfStatement = {
+    nodeKind: NodeKind.STATEMENT,
+    subKind: StatementKind.IF,
+    checkFunc: function (ifStatement, symbolTable, _strict) {
+        const results = [];
+        const classScope = symbolTable.getEnclosingClassScope();
+        if (!classScope) {
+            return results;
+        }
+        if (!isStatement(ifStatement.ifStatement)) {
+            return results;
+        }
+        const ifMemberNames = collectMemberVariableNames(ifStatement.ifStatement);
+        // Handle else if chains by collecting all member names from the else branch
+        let elseMemberNames = new Set();
+        if (isStatement(ifStatement.elseStatement)) {
+            elseMemberNames = collectAllBranchMemberNames(ifStatement.elseStatement);
+        }
+        const overlappingNames = [];
+        for (const name of ifMemberNames) {
+            if (elseMemberNames.has(name)) {
+                overlappingNames.push(name);
+            }
+        }
+        if (overlappingNames.length > 0) {
+            results.push({
+                message: "This if-then-else clauses may result in duplicate class member variables being declared simultaneously.",
+                location: ifStatement.startToken.getLocation(),
+                isWarning: true,
+            });
+        }
+        return results;
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"check-map-declaration.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-map-declaration.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AA4JrD,eAAO,MAAM,mBAAmB,EAAE,KAcjC,CAAC"}

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

@@ -0,0 +1,130 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { StatementKind } from "../../ast/node/enum/statement-kind.js";
+import { isIdentifier, isNumberLiteral } from "../../ast/util/types.js";
+import { ScopeKind } from "../symbol-table.js";
+function countOutputValues(outputValue) {
+    return outputValue.outputValues.length;
+}
+function checkOutputValuesTypeMatch(declaration, symbolTable) {
+    const results = [];
+    if (declaration.outputElementaryType !== undefined) {
+        for (const entry of declaration.mapEntries) {
+            if (entry.nodeKind !== NodeKind.MAP_ENTRY) {
+                continue;
+            }
+            const mapEntry = entry;
+            if (mapEntry.outputValue &&
+                mapEntry.outputValue.nodeKind === NodeKind.AGGREGATE_OUTPUT_VALUE) {
+                const outputValue = mapEntry.outputValue;
+                if (countOutputValues(outputValue) !== 1) {
+                    results.push({
+                        message: "The type and number of constituent values within the aggregate output values of the map declaration must match the corresponding constituent types within the map's output_type.",
+                        location: outputValue.startToken.getLocation(),
+                    });
+                }
+            }
+        }
+    }
+    else if (declaration.outputClassIdentifier !== undefined &&
+        isIdentifier(declaration.outputClassIdentifier)) {
+        const className = declaration.outputClassIdentifier.name;
+        const classScope = symbolTable
+            .getGlobalScope()
+            .children.find((scope) => scope.name === className && scope.kind === ScopeKind.CLASS);
+        if (classScope?.classMemberSymbols) {
+            const expectedMemberCount = classScope.classMemberSymbols.size;
+            for (const entry of declaration.mapEntries) {
+                if (entry.nodeKind !== NodeKind.MAP_ENTRY) {
+                    continue;
+                }
+                const mapEntry = entry;
+                if (mapEntry.outputValue &&
+                    mapEntry.outputValue.nodeKind === NodeKind.AGGREGATE_OUTPUT_VALUE) {
+                    const outputValue = mapEntry.outputValue;
+                    if (countOutputValues(outputValue) !== expectedMemberCount) {
+                        results.push({
+                            message: "The type and number of constituent values within the aggregate output values of the map declaration must match the corresponding constituent types within the map's output_type.",
+                            location: outputValue.startToken.getLocation(),
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return results;
+}
+function hasParsableMembers(className, symbolTable, visited) {
+    if (visited.has(className)) {
+        return false;
+    }
+    visited.add(className);
+    const classScope = symbolTable
+        .getGlobalScope()
+        .children.find((scope) => scope.name === className && scope.kind === ScopeKind.CLASS);
+    if (!classScope?.classMemberSymbols) {
+        return false;
+    }
+    for (const memberEntries of classScope.classMemberSymbols.values()) {
+        for (const entry of memberEntries) {
+            if (entry.symbol.attributes.isComputed !== true) {
+                return true;
+            }
+            if (entry.symbol.attributes.classType &&
+                hasParsableMembers(entry.symbol.attributes.classType, symbolTable, visited)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function checkParsableClassOutput(declaration, symbolTable) {
+    if (declaration.outputClassIdentifier === undefined ||
+        !isIdentifier(declaration.outputClassIdentifier)) {
+        return [];
+    }
+    const className = declaration.outputClassIdentifier.name;
+    if (hasParsableMembers(className, symbolTable, new Set())) {
+        return [
+            {
+                message: "Declaring a map with an output_value consisting of a class with parsable members will result in undefined behaviour.",
+                location: declaration.outputClassIdentifier.startToken.getLocation(),
+                isWarning: true,
+            },
+        ];
+    }
+    return [];
+}
+function checkUniqueInputValues(declaration) {
+    const results = [];
+    const seenValues = new Map();
+    for (const entry of declaration.mapEntries) {
+        if (entry.nodeKind !== NodeKind.MAP_ENTRY) {
+            continue;
+        }
+        const mapEntry = entry;
+        if (isNumberLiteral(mapEntry.inputValue)) {
+            const value = mapEntry.inputValue.value;
+            if (seenValues.has(value)) {
+                results.push({
+                    message: "Input values in a map declaration must be unique.",
+                    location: mapEntry.inputValue.startToken.getLocation(),
+                });
+            }
+            else {
+                seenValues.set(value, true);
+            }
+        }
+    }
+    return results;
+}
+export const checkMapDeclaration = {
+    nodeKind: NodeKind.STATEMENT,
+    subKind: StatementKind.MAP_DECLARATION,
+    checkFunc: function (declaration, symbolTable, _strict) {
+        return [
+            ...checkOutputValuesTypeMatch(declaration, symbolTable),
+            ...checkParsableClassOutput(declaration, symbolTable),
+            ...checkUniqueInputValues(declaration),
+        ];
+    },
+};

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

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

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

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