@minduscript/compiler 1.0.0

package/dist/ir/symbol-table.js

@@ -0,0 +1,385 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSymbolTable = exports.BuildSymbolTableError = void 0;
+const parser_1 = require("@minduscript/parser");
+class BuildSymbolTableError extends Error {
+    node;
+    constructor(node, message) {
+        super(message);
+        this.node = node;
+    }
+}
+exports.BuildSymbolTableError = BuildSymbolTableError;
+// 拷贝符号表，只拷贝2层，以节省内存以及保证引用的一致性
+const copySymbolTable = (source) => ({
+    vars: { ...source.vars },
+    consts: { ...source.consts },
+    macros: { ...source.macros },
+});
+const hasOwn = (record, name) => Object.prototype.hasOwnProperty.call(record, name);
+const hasAnySymbol = (table, name) => hasOwn(table.vars, name) || hasOwn(table.consts, name) || hasOwn(table.macros, name);
+const findVarOrConst = (scope, globalTable, name) => {
+    if (hasOwn(scope.vars, name)) {
+        return scope.vars[name];
+    }
+    if (hasOwn(scope.consts, name)) {
+        return scope.consts[name];
+    }
+    if (hasOwn(globalTable.vars, name)) {
+        return globalTable.vars[name];
+    }
+    if (hasOwn(globalTable.consts, name)) {
+        return globalTable.consts[name];
+    }
+    return undefined;
+};
+const isConstSymbol = (scope, globalTable, name) => {
+    if (hasOwn(scope.consts, name)) {
+        return true;
+    }
+    if (hasOwn(scope.vars, name)) {
+        return false;
+    }
+    return hasOwn(globalTable.consts, name);
+};
+const createSyntheticIdentifier = (name, identifierType) => ({
+    type: parser_1.NodeType.IDENTIFIER_EXPRESSION,
+    tokens: [],
+    value: name,
+    identifierType,
+    isMindustry: false,
+});
+const ensureMindustryGlobal = (identifier, scope, globalTable) => {
+    if (!identifier.isMindustry) {
+        return;
+    }
+    if (hasAnySymbol(globalTable, identifier.value)) {
+        return;
+    }
+    const source = createSyntheticIdentifier(identifier.value, parser_1.IdentifierType.SIMPLE);
+    globalTable.vars[identifier.value] = source;
+    if (!hasAnySymbol(scope, identifier.value)) {
+        scope.vars[identifier.value] = source;
+    }
+};
+const defineVariable = (name, isConst, source, node, scope, context) => {
+    if (hasAnySymbol(scope, name)) {
+        throw new BuildSymbolTableError(node, `Symbol "${name}" is already defined in current scope`);
+    }
+    if (!context.isTopLevel && hasAnySymbol(context.globalTable, name)) {
+        throw new BuildSymbolTableError(node, `Local symbol "${name}" conflicts with global symbol`);
+    }
+    if (isConst) {
+        scope.consts[name] = source;
+    }
+    else {
+        scope.vars[name] = source;
+    }
+};
+const defineMacro = (name, source, node, scope) => {
+    if (hasAnySymbol(scope, name)) {
+        throw new BuildSymbolTableError(node, `Symbol "${name}" is already defined in current scope`);
+    }
+    scope.macros[name] = source;
+};
+const attachSymbolTable = (node, scope, patch) => {
+    return {
+        ...node,
+        ...(patch ?? {}),
+        symbolTable: copySymbolTable(scope),
+    };
+};
+const buildSymbolTable = (document) => {
+    const globalTable = {
+        vars: {},
+        consts: {},
+        macros: {},
+    };
+    const processExpression = (expression, scope, context) => {
+        const processOutputIdentifier = (identifier, localScope, localContext) => {
+            const transformed = attachSymbolTable(identifier, localScope);
+            if (identifier.isMindustry) {
+                ensureMindustryGlobal(identifier, localScope, localContext.globalTable);
+                return transformed;
+            }
+            if (identifier.identifierType === parser_1.IdentifierType.LET ||
+                identifier.identifierType === parser_1.IdentifierType.CONST) {
+                defineVariable(identifier.value, identifier.identifierType === parser_1.IdentifierType.CONST, identifier, identifier, localScope, localContext);
+                return transformed;
+            }
+            const symbol = findVarOrConst(localScope, localContext.globalTable, identifier.value);
+            if (!symbol) {
+                throw new BuildSymbolTableError(identifier, `Undefined variable or constant "${identifier.value}"`);
+            }
+            if (isConstSymbol(localScope, localContext.globalTable, identifier.value)) {
+                throw new BuildSymbolTableError(identifier, `Cannot assign to constant "${identifier.value}"`);
+            }
+            return transformed;
+        };
+        const processExpressionChild = (child, localScope, localContext) => {
+            switch (child.type) {
+                case parser_1.NodeType.UNARY_OP_EXPRESSION:
+                    return attachSymbolTable(child, localScope, {
+                        child: processExpressionChild(child.child, localScope, localContext),
+                    });
+                case parser_1.NodeType.BINARY_OP_EXPRESSION:
+                    return attachSymbolTable(child, localScope, {
+                        lChild: processExpressionChild(child.lChild, localScope, localContext),
+                        rChild: processExpressionChild(child.rChild, localScope, localContext),
+                    });
+                case parser_1.NodeType.FUNCTION_CALL_EXPRESSION:
+                    return attachSymbolTable(child, localScope, {
+                        args: child.args.map((arg) => processExpressionChild(arg, localScope, localContext)),
+                    });
+                case parser_1.NodeType.MACRO_CALL_EXPRESSION: {
+                    const macroCall = child;
+                    if (!hasOwn(localScope.macros, macroCall.name) &&
+                        !hasOwn(localContext.globalTable.macros, macroCall.name)) {
+                        throw new BuildSymbolTableError(child, `Undefined macro "${macroCall.name}"`);
+                    }
+                    return attachSymbolTable(child, localScope, {
+                        inputArgs: macroCall.inputArgs.map((arg) => processExpressionChild(arg, localScope, localContext)),
+                        outputArgs: macroCall.outputArgs.map((arg) => processOutputIdentifier(arg, localScope, localContext)),
+                    });
+                }
+                case parser_1.NodeType.LITERAL_EXPRESSION:
+                    return attachSymbolTable(child, localScope);
+                case parser_1.NodeType.IDENTIFIER_EXPRESSION:
+                    if (child.isMindustry) {
+                        ensureMindustryGlobal(child, localScope, localContext.globalTable);
+                        return attachSymbolTable(child, localScope);
+                    }
+                    if (!findVarOrConst(localScope, localContext.globalTable, child.value)) {
+                        throw new BuildSymbolTableError(child, `Undefined variable or constant "${child.value}"`);
+                    }
+                    return attachSymbolTable(child, localScope);
+                default:
+                    return child;
+            }
+        };
+        return attachSymbolTable(expression, scope, {
+            child: processExpressionChild(expression.child, scope, context),
+        });
+    };
+    const processStatementList = (statements, scope, context) => {
+        const output = [];
+        for (const statement of statements) {
+            output.push(processStatement(statement, scope, context));
+        }
+        return output;
+    };
+    const processControlStatement = (statement, scope, context) => {
+        const patch = {};
+        for (const [key, value] of Object.entries(statement)) {
+            if (key === 'type' || key === 'statementType' || key === 'controlType' || key === 'tokens') {
+                continue;
+            }
+            if (!value || typeof value !== 'object') {
+                continue;
+            }
+            const maybeNode = value;
+            if (maybeNode.type === parser_1.NodeType.EXPRESSION) {
+                patch[key] = processExpression(value, scope, context);
+            }
+        }
+        for (const [key, value] of Object.entries(statement)) {
+            if (key in patch) {
+                continue;
+            }
+            if (!value || typeof value !== 'object') {
+                continue;
+            }
+            const maybeNode = value;
+            if (maybeNode.type !== parser_1.NodeType.IDENTIFIER_EXPRESSION) {
+                continue;
+            }
+            const identifier = value;
+            patch[key] = attachSymbolTable(identifier, scope);
+            if (identifier.isMindustry) {
+                ensureMindustryGlobal(identifier, scope, context.globalTable);
+                continue;
+            }
+            if (identifier.identifierType === parser_1.IdentifierType.LET ||
+                identifier.identifierType === parser_1.IdentifierType.CONST) {
+                defineVariable(identifier.value, identifier.identifierType === parser_1.IdentifierType.CONST, identifier, statement, scope, context);
+                continue;
+            }
+            const symbol = findVarOrConst(scope, context.globalTable, identifier.value);
+            if (!symbol) {
+                throw new BuildSymbolTableError(statement, `Undefined variable or constant "${identifier.value}"`);
+            }
+            if (isConstSymbol(scope, context.globalTable, identifier.value)) {
+                throw new BuildSymbolTableError(statement, `Cannot assign to constant "${identifier.value}"`);
+            }
+        }
+        return attachSymbolTable(statement, scope, patch);
+    };
+    const processStatement = (statement, scope, context) => {
+        switch (statement.statementType) {
+            case parser_1.StatementType.EMPTY:
+                return attachSymbolTable(statement, scope);
+            case parser_1.StatementType.VARIABLE_DEFINE: {
+                const variableStatement = statement;
+                const expression = processExpression(variableStatement.expression, scope, context);
+                const output = attachSymbolTable(statement, scope, {
+                    expression,
+                });
+                defineVariable(variableStatement.variableName, variableStatement.isConst, variableStatement, statement, scope, context);
+                return output;
+            }
+            case parser_1.StatementType.ASSIGN: {
+                const expression = processExpression(statement.expression, scope, context);
+                if (!findVarOrConst(scope, context.globalTable, statement.variableName)) {
+                    throw new BuildSymbolTableError(statement, `Undefined variable or constant "${statement.variableName}"`);
+                }
+                if (isConstSymbol(scope, context.globalTable, statement.variableName)) {
+                    throw new BuildSymbolTableError(statement, `Cannot assign to constant "${statement.variableName}"`);
+                }
+                return attachSymbolTable(statement, scope, { expression });
+            }
+            case parser_1.StatementType.CONTROL:
+                return processControlStatement(statement, scope, context);
+            case parser_1.StatementType.MACRO_CALL: {
+                const macroCall = statement;
+                if (!hasOwn(scope.macros, macroCall.name) && !hasOwn(context.globalTable.macros, macroCall.name)) {
+                    throw new BuildSymbolTableError(statement, `Undefined macro "${macroCall.name}"`);
+                }
+                const inputArgs = macroCall.inputArgs.map((arg) => processExpression(arg, scope, context));
+                const outputArgs = macroCall.outputArgs.map((identifier) => {
+                    const transformed = attachSymbolTable(identifier, scope);
+                    if (identifier.isMindustry) {
+                        ensureMindustryGlobal(identifier, scope, context.globalTable);
+                        return transformed;
+                    }
+                    if (identifier.identifierType === parser_1.IdentifierType.LET ||
+                        identifier.identifierType === parser_1.IdentifierType.CONST) {
+                        defineVariable(identifier.value, identifier.identifierType === parser_1.IdentifierType.CONST, identifier, statement, scope, context);
+                        return transformed;
+                    }
+                    if (!findVarOrConst(scope, context.globalTable, identifier.value)) {
+                        throw new BuildSymbolTableError(statement, `Undefined variable or constant "${identifier.value}"`);
+                    }
+                    if (isConstSymbol(scope, context.globalTable, identifier.value)) {
+                        throw new BuildSymbolTableError(statement, `Cannot assign to constant "${identifier.value}"`);
+                    }
+                    return transformed;
+                });
+                return attachSymbolTable(statement, scope, { inputArgs, outputArgs });
+            }
+            case parser_1.StatementType.MACRO_DEFINE: {
+                const macroDefine = statement;
+                if (!context.isTopLevel) {
+                    throw new BuildSymbolTableError(statement, 'Macro definition is only allowed at top level');
+                }
+                defineMacro(macroDefine.name, macroDefine, statement, scope);
+                const macroScope = copySymbolTable(scope);
+                const macroContext = {
+                    ...context,
+                    inLoop: 0,
+                    inMacro: context.inMacro + 1,
+                    isTopLevel: false,
+                };
+                for (const inputName of macroDefine.inputParams) {
+                    defineVariable(inputName, true, createSyntheticIdentifier(inputName, parser_1.IdentifierType.CONST), statement, macroScope, macroContext);
+                }
+                for (const outputName of macroDefine.outputParams) {
+                    defineVariable(outputName, false, createSyntheticIdentifier(outputName, parser_1.IdentifierType.LET), statement, macroScope, macroContext);
+                }
+                const body = processStatementList(macroDefine.body, macroScope, macroContext);
+                return attachSymbolTable(statement, scope, { body });
+            }
+            case parser_1.StatementType.IF: {
+                const ifStatement = statement;
+                const condition = processExpression(ifStatement.condition, scope, context);
+                const ifBody = processStatementList(ifStatement.ifBody, copySymbolTable(scope), {
+                    ...context,
+                    isTopLevel: false,
+                });
+                return attachSymbolTable(statement, scope, { condition, ifBody });
+            }
+            case parser_1.StatementType.IF_ELSE: {
+                const ifElse = statement;
+                const condition = processExpression(ifElse.condition, scope, context);
+                const ifBody = processStatementList(ifElse.ifBody, copySymbolTable(scope), {
+                    ...context,
+                    isTopLevel: false,
+                });
+                const elseBody = processStatementList(ifElse.elseBody, copySymbolTable(scope), {
+                    ...context,
+                    isTopLevel: false,
+                });
+                return attachSymbolTable(statement, scope, { condition, ifBody, elseBody });
+            }
+            case parser_1.StatementType.FOR: {
+                const forStatement = statement;
+                const forScope = copySymbolTable(scope);
+                const loopContext = {
+                    ...context,
+                    isTopLevel: false,
+                };
+                const init = processStatement(forStatement.init, forScope, loopContext);
+                const condition = processExpression(forStatement.condition, forScope, loopContext);
+                const increment = forStatement.increment
+                    ? processStatement(forStatement.increment, forScope, loopContext)
+                    : undefined;
+                const body = processStatementList(forStatement.body, copySymbolTable(forScope), {
+                    ...loopContext,
+                    inLoop: loopContext.inLoop + 1,
+                });
+                return attachSymbolTable(statement, scope, { init, condition, increment, body });
+            }
+            case parser_1.StatementType.WHILE: {
+                const whileStatement = statement;
+                const condition = processExpression(whileStatement.condition, scope, context);
+                const body = processStatementList(whileStatement.body, copySymbolTable(scope), {
+                    ...context,
+                    isTopLevel: false,
+                    inLoop: context.inLoop + 1,
+                });
+                return attachSymbolTable(statement, scope, { condition, body });
+            }
+            case parser_1.StatementType.LOOP_CONTROL:
+                if (context.inLoop <= 0) {
+                    throw new BuildSymbolTableError(statement, 'break/continue can only be used inside loops');
+                }
+                return attachSymbolTable(statement, scope);
+            case parser_1.StatementType.RETURN:
+                if (context.inMacro <= 0) {
+                    throw new BuildSymbolTableError(statement, 'return can only be used inside macros');
+                }
+                return attachSymbolTable(statement, scope, {
+                    expression: processExpression(statement.expression, scope, context),
+                });
+            case parser_1.StatementType.BIND: {
+                const bindStatement = statement;
+                if (!context.isTopLevel) {
+                    throw new BuildSymbolTableError(statement, 'bind can only be used at top level');
+                }
+                const output = attachSymbolTable(statement, scope);
+                defineVariable(bindStatement.variableName, true, bindStatement, statement, scope, context);
+                return output;
+            }
+            default:
+                return statement;
+        }
+    };
+    const importList = document.importList.map((importStatement) => {
+        const transformedImport = attachSymbolTable(importStatement, globalTable);
+        defineMacro(importStatement.asName, importStatement, importStatement, globalTable);
+        return transformedImport;
+    });
+    const statementList = processStatementList(document.statementList, globalTable, {
+        globalTable,
+        inLoop: 0,
+        inMacro: 0,
+        isTopLevel: true,
+    });
+    return {
+        ...document,
+        importList,
+        statementList,
+        symbolTable: copySymbolTable(globalTable),
+    };
+};
+exports.buildSymbolTable = buildSymbolTable;
+//# sourceMappingURL=symbol-table.js.map

package/dist/macro/check-macro.d.ts

@@ -0,0 +1,14 @@
+import type { MacroCallExpressionNode, MacroCallStatementNode } from '@minduscript/parser';
+import type { Project } from '../ir/project';
+export declare enum ErrorPosition {
+    INPUT = 0,
+    OUTPUT = 1
+}
+export declare class CheckMacroError extends Error {
+    readonly node: MacroCallExpressionNode | MacroCallStatementNode;
+    readonly position: ErrorPosition;
+    readonly expectedArgs: number;
+    readonly actualArgs: number;
+    constructor(node: MacroCallExpressionNode | MacroCallStatementNode, position: ErrorPosition, expectedArgs: number, actualArgs: number);
+}
+export declare const checkMacro: (project: Project) => void;

package/dist/macro/check-macro.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMacro = exports.CheckMacroError = exports.ErrorPosition = void 0;
+const parser_1 = require("@minduscript/parser");
+var ErrorPosition;
+(function (ErrorPosition) {
+    ErrorPosition[ErrorPosition["INPUT"] = 0] = "INPUT";
+    ErrorPosition[ErrorPosition["OUTPUT"] = 1] = "OUTPUT";
+})(ErrorPosition || (exports.ErrorPosition = ErrorPosition = {}));
+class CheckMacroError extends Error {
+    node;
+    position;
+    expectedArgs;
+    actualArgs;
+    constructor(node, position, expectedArgs, actualArgs) {
+        super(`宏参数错误：${node.name}的${expectedArgs == ErrorPosition.OUTPUT ? '输出' : '输入'}参数应为${expectedArgs}个，实为${actualArgs}个`);
+        this.node = node;
+        this.position = position;
+        this.expectedArgs = expectedArgs;
+        this.actualArgs = actualArgs;
+    }
+}
+exports.CheckMacroError = CheckMacroError;
+const checkMacro = (project) => {
+    for (const source of Object.values(project.sources)) {
+        const macroMap = new Map();
+        for (const macro of [...source.macros, ...source.internalMacros]) {
+            macroMap.set(macro.name, macro);
+        }
+        const checkExpressionChild = (child) => {
+            switch (child.type) {
+                case parser_1.NodeType.UNARY_OP_EXPRESSION:
+                    checkExpressionChild(child.child);
+                    break;
+                case parser_1.NodeType.BINARY_OP_EXPRESSION:
+                    checkExpressionChild(child.lChild);
+                    checkExpressionChild(child.rChild);
+                    break;
+                case parser_1.NodeType.FUNCTION_CALL_EXPRESSION:
+                    child.args.forEach(checkExpressionChild);
+                    break;
+                case parser_1.NodeType.MACRO_CALL_EXPRESSION: {
+                    const macroDef = macroMap.get(child.name);
+                    if (macroDef) {
+                        if (child.inputArgs.length !== macroDef.inputParams.length) {
+                            throw new CheckMacroError(child, ErrorPosition.INPUT, macroDef.inputParams.length, child.inputArgs.length);
+                        }
+                        if (child.outputArgs.length !== macroDef.outputParams.length) {
+                            throw new CheckMacroError(child, ErrorPosition.OUTPUT, macroDef.outputParams.length, child.outputArgs.length);
+                        }
+                    }
+                    child.inputArgs.forEach(checkExpressionChild);
+                    break;
+                }
+                case parser_1.NodeType.LITERAL_EXPRESSION:
+                case parser_1.NodeType.IDENTIFIER_EXPRESSION:
+                    break;
+                default:
+                    child;
+            }
+        };
+        const checkExpression = (expression) => {
+            checkExpressionChild(expression.child);
+        };
+        const checkStatement = (statement) => {
+            switch (statement.statementType) {
+                case parser_1.StatementType.EMPTY:
+                case parser_1.StatementType.LOOP_CONTROL:
+                case parser_1.StatementType.BIND:
+                    break;
+                case parser_1.StatementType.VARIABLE_DEFINE:
+                    checkExpression(statement.expression);
+                    break;
+                case parser_1.StatementType.ASSIGN:
+                    checkExpression(statement.expression);
+                    break;
+                case parser_1.StatementType.CONTROL:
+                    for (const value of Object.values(statement)) {
+                        if (value &&
+                            typeof value === 'object' &&
+                            'type' in value &&
+                            value.type === parser_1.NodeType.EXPRESSION) {
+                            checkExpression(value);
+                        }
+                    }
+                    break;
+                case parser_1.StatementType.MACRO_CALL: {
+                    const macroDef = macroMap.get(statement.name);
+                    if (macroDef) {
+                        if (statement.inputArgs.length !== macroDef.inputParams.length) {
+                            throw new CheckMacroError(statement, ErrorPosition.INPUT, macroDef.inputParams.length, statement.inputArgs.length);
+                        }
+                        if (statement.outputArgs.length !== macroDef.outputParams.length) {
+                            throw new CheckMacroError(statement, ErrorPosition.OUTPUT, macroDef.outputParams.length, statement.outputArgs.length);
+                        }
+                    }
+                    statement.inputArgs.forEach(checkExpression);
+                    break;
+                }
+                case parser_1.StatementType.MACRO_DEFINE:
+                    statement.body.forEach(checkStatement);
+                    break;
+                case parser_1.StatementType.IF:
+                    checkExpression(statement.condition);
+                    statement.ifBody.forEach(checkStatement);
+                    break;
+                case parser_1.StatementType.IF_ELSE:
+                    checkExpression(statement.condition);
+                    statement.ifBody.forEach(checkStatement);
+                    statement.elseBody.forEach(checkStatement);
+                    break;
+                case parser_1.StatementType.FOR:
+                    checkStatement(statement.init);
+                    checkExpression(statement.condition);
+                    if (statement.increment)
+                        checkStatement(statement.increment);
+                    statement.body.forEach(checkStatement);
+                    break;
+                case parser_1.StatementType.WHILE:
+                    checkExpression(statement.condition);
+                    statement.body.forEach(checkStatement);
+                    break;
+                case parser_1.StatementType.RETURN:
+                    checkExpression(statement.expression);
+                    break;
+                default:
+                    statement;
+            }
+        };
+        for (const statement of source.ast.statementList) {
+            checkStatement(statement);
+        }
+    }
+};
+exports.checkMacro = checkMacro;
+//# sourceMappingURL=check-macro.js.map

package/dist/macro/expand-macros.d.ts

@@ -0,0 +1,6 @@
+import { IRProgram, type IRNode } from '../ir/ir';
+export type SimplifiedIRProgram = {
+    body: IRNode[];
+    boundVariables: Set<string>;
+};
+export declare const expandMacros: (program: IRProgram) => SimplifiedIRProgram;