@minduscript/compiler 1.0.0

package/dist/ir/ir.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JumpCondition = exports.IRNodeType = void 0;
+var IRNodeType;
+(function (IRNodeType) {
+    // 控制指令
+    IRNodeType[IRNodeType["READ"] = 0] = "READ";
+    IRNodeType[IRNodeType["WRITE"] = 1] = "WRITE";
+    IRNodeType[IRNodeType["DRAW_CLEAR"] = 2] = "DRAW_CLEAR";
+    IRNodeType[IRNodeType["DRAW_COLOR"] = 3] = "DRAW_COLOR";
+    IRNodeType[IRNodeType["DRAW_COL"] = 4] = "DRAW_COL";
+    IRNodeType[IRNodeType["DRAW_STROKE"] = 5] = "DRAW_STROKE";
+    IRNodeType[IRNodeType["DRAW_LINE"] = 6] = "DRAW_LINE";
+    IRNodeType[IRNodeType["DRAW_RECT"] = 7] = "DRAW_RECT";
+    IRNodeType[IRNodeType["DRAW_LINE_RECT"] = 8] = "DRAW_LINE_RECT";
+    IRNodeType[IRNodeType["DRAW_POLY"] = 9] = "DRAW_POLY";
+    IRNodeType[IRNodeType["DRAW_LINE_POLY"] = 10] = "DRAW_LINE_POLY";
+    IRNodeType[IRNodeType["DRAW_TRIANGLE"] = 11] = "DRAW_TRIANGLE";
+    IRNodeType[IRNodeType["DRAW_IMAGE"] = 12] = "DRAW_IMAGE";
+    IRNodeType[IRNodeType["PRINT"] = 13] = "PRINT";
+    IRNodeType[IRNodeType["DRAW_FLUSH"] = 14] = "DRAW_FLUSH";
+    IRNodeType[IRNodeType["PRINT_FLUSH"] = 15] = "PRINT_FLUSH";
+    IRNodeType[IRNodeType["GET_LINK"] = 16] = "GET_LINK";
+    IRNodeType[IRNodeType["SET_ENABLED"] = 17] = "SET_ENABLED";
+    IRNodeType[IRNodeType["SET_SHOOT"] = 18] = "SET_SHOOT";
+    IRNodeType[IRNodeType["SET_SHOOT_P"] = 19] = "SET_SHOOT_P";
+    IRNodeType[IRNodeType["SET_CONFIG"] = 20] = "SET_CONFIG";
+    IRNodeType[IRNodeType["SET_COLOR"] = 21] = "SET_COLOR";
+    IRNodeType[IRNodeType["RADAR"] = 22] = "RADAR";
+    IRNodeType[IRNodeType["SENSOR"] = 23] = "SENSOR";
+    IRNodeType[IRNodeType["PACK_COLOR"] = 24] = "PACK_COLOR";
+    IRNodeType[IRNodeType["WAIT"] = 25] = "WAIT";
+    IRNodeType[IRNodeType["CPU_STOP"] = 26] = "CPU_STOP";
+    IRNodeType[IRNodeType["UNIT_BIND"] = 27] = "UNIT_BIND";
+    IRNodeType[IRNodeType["UNIT_RADAR"] = 28] = "UNIT_RADAR";
+    IRNodeType[IRNodeType["UNIT_LOCATE_ORE"] = 29] = "UNIT_LOCATE_ORE";
+    IRNodeType[IRNodeType["UNIT_LOCATE_BUILDING"] = 30] = "UNIT_LOCATE_BUILDING";
+    IRNodeType[IRNodeType["UNIT_LOCATE_SPAWN"] = 31] = "UNIT_LOCATE_SPAWN";
+    IRNodeType[IRNodeType["UNIT_LOCATE_DAMAGED"] = 32] = "UNIT_LOCATE_DAMAGED";
+    IRNodeType[IRNodeType["IDLE"] = 33] = "IDLE";
+    IRNodeType[IRNodeType["STOP"] = 34] = "STOP";
+    IRNodeType[IRNodeType["MOVE"] = 35] = "MOVE";
+    IRNodeType[IRNodeType["APPROACH"] = 36] = "APPROACH";
+    IRNodeType[IRNodeType["PATH_FIND"] = 37] = "PATH_FIND";
+    IRNodeType[IRNodeType["AUTO_PATH_FIND"] = 38] = "AUTO_PATH_FIND";
+    IRNodeType[IRNodeType["BOOST"] = 39] = "BOOST";
+    IRNodeType[IRNodeType["TARGET"] = 40] = "TARGET";
+    IRNodeType[IRNodeType["TARGET_P"] = 41] = "TARGET_P";
+    IRNodeType[IRNodeType["ITEM_DROP"] = 42] = "ITEM_DROP";
+    IRNodeType[IRNodeType["ITEM_TAKE"] = 43] = "ITEM_TAKE";
+    IRNodeType[IRNodeType["PAY_DROP"] = 44] = "PAY_DROP";
+    IRNodeType[IRNodeType["PAY_TAKE"] = 45] = "PAY_TAKE";
+    IRNodeType[IRNodeType["PAY_ENTER"] = 46] = "PAY_ENTER";
+    IRNodeType[IRNodeType["MINE"] = 47] = "MINE";
+    IRNodeType[IRNodeType["FLAG"] = 48] = "FLAG";
+    IRNodeType[IRNodeType["BUILD"] = 49] = "BUILD";
+    IRNodeType[IRNodeType["GET_BLOCK"] = 50] = "GET_BLOCK";
+    IRNodeType[IRNodeType["WITHIN"] = 51] = "WITHIN";
+    IRNodeType[IRNodeType["UNBIND"] = 52] = "UNBIND";
+    // 运算指令
+    IRNodeType[IRNodeType["ASSIGN"] = 53] = "ASSIGN";
+    IRNodeType[IRNodeType["FLIP"] = 54] = "FLIP";
+    IRNodeType[IRNodeType["AND"] = 55] = "AND";
+    IRNodeType[IRNodeType["EQ"] = 56] = "EQ";
+    IRNodeType[IRNodeType["NE"] = 57] = "NE";
+    IRNodeType[IRNodeType["LESS"] = 58] = "LESS";
+    IRNodeType[IRNodeType["LE"] = 59] = "LE";
+    IRNodeType[IRNodeType["GREATER"] = 60] = "GREATER";
+    IRNodeType[IRNodeType["GE"] = 61] = "GE";
+    IRNodeType[IRNodeType["STRICT_EQ"] = 62] = "STRICT_EQ";
+    IRNodeType[IRNodeType["BITOR"] = 63] = "BITOR";
+    IRNodeType[IRNodeType["XOR"] = 64] = "XOR";
+    IRNodeType[IRNodeType["BITAND"] = 65] = "BITAND";
+    IRNodeType[IRNodeType["SHL"] = 66] = "SHL";
+    IRNodeType[IRNodeType["SHR"] = 67] = "SHR";
+    IRNodeType[IRNodeType["ADD"] = 68] = "ADD";
+    IRNodeType[IRNodeType["SUB"] = 69] = "SUB";
+    IRNodeType[IRNodeType["MUL"] = 70] = "MUL";
+    IRNodeType[IRNodeType["DIV"] = 71] = "DIV";
+    IRNodeType[IRNodeType["IDIV"] = 72] = "IDIV";
+    IRNodeType[IRNodeType["MOD"] = 73] = "MOD";
+    IRNodeType[IRNodeType["POW"] = 74] = "POW";
+    IRNodeType[IRNodeType["MAX"] = 75] = "MAX";
+    IRNodeType[IRNodeType["MIN"] = 76] = "MIN";
+    IRNodeType[IRNodeType["ANGLE"] = 77] = "ANGLE";
+    IRNodeType[IRNodeType["ANGLE_DIFF"] = 78] = "ANGLE_DIFF";
+    IRNodeType[IRNodeType["LEN"] = 79] = "LEN";
+    IRNodeType[IRNodeType["NOISE"] = 80] = "NOISE";
+    IRNodeType[IRNodeType["ABS"] = 81] = "ABS";
+    IRNodeType[IRNodeType["LOG"] = 82] = "LOG";
+    IRNodeType[IRNodeType["LOG10"] = 83] = "LOG10";
+    IRNodeType[IRNodeType["FLOOR"] = 84] = "FLOOR";
+    IRNodeType[IRNodeType["CEIL"] = 85] = "CEIL";
+    IRNodeType[IRNodeType["SQRT"] = 86] = "SQRT";
+    IRNodeType[IRNodeType["RAND"] = 87] = "RAND";
+    IRNodeType[IRNodeType["SIN"] = 88] = "SIN";
+    IRNodeType[IRNodeType["COS"] = 89] = "COS";
+    IRNodeType[IRNodeType["TAN"] = 90] = "TAN";
+    IRNodeType[IRNodeType["ASIN"] = 91] = "ASIN";
+    IRNodeType[IRNodeType["ACOS"] = 92] = "ACOS";
+    IRNodeType[IRNodeType["ATAN"] = 93] = "ATAN";
+    // 其他指令
+    IRNodeType[IRNodeType["LABEL"] = 94] = "LABEL";
+    IRNodeType[IRNodeType["JUMP"] = 95] = "JUMP";
+    IRNodeType[IRNodeType["CONDITIONAL_JUMP"] = 96] = "CONDITIONAL_JUMP";
+    IRNodeType[IRNodeType["MACRO_CALL"] = 97] = "MACRO_CALL";
+    IRNodeType[IRNodeType["MACRO_CALL_ASSIGN"] = 98] = "MACRO_CALL_ASSIGN";
+    IRNodeType[IRNodeType["BIND"] = 99] = "BIND";
+})(IRNodeType || (exports.IRNodeType = IRNodeType = {}));
+var JumpCondition;
+(function (JumpCondition) {
+    JumpCondition[JumpCondition["EQ"] = 0] = "EQ";
+    JumpCondition[JumpCondition["NE"] = 1] = "NE";
+    JumpCondition[JumpCondition["LESS"] = 2] = "LESS";
+    JumpCondition[JumpCondition["LE"] = 3] = "LE";
+    JumpCondition[JumpCondition["GREATER"] = 4] = "GREATER";
+    JumpCondition[JumpCondition["GE"] = 5] = "GE";
+    JumpCondition[JumpCondition["STRICT_EQ"] = 6] = "STRICT_EQ";
+})(JumpCondition || (exports.JumpCondition = JumpCondition = {}));
+//# sourceMappingURL=ir.js.map

package/dist/ir/project.d.ts

@@ -0,0 +1,24 @@
+import type { DocumentNode, MacroDefineStatementNode } from '@minduscript/parser';
+import type { WithSymbolTable } from './symbol-table';
+export type Source = {
+    path: string;
+    ast: WithSymbolTable<DocumentNode>;
+    macros: MacroDefineStatementNode[];
+    internalMacros: MacroDefineStatementNode[];
+};
+export type Project = {
+    rootPath: string;
+    entryPath: string;
+    sources: Record<string, Source>;
+};
+export declare class MacroRecursionError extends Error {
+    readonly chain: {
+        macroName: string;
+        sourceFile: string;
+    }[];
+    constructor(chain: {
+        macroName: string;
+        sourceFile: string;
+    }[]);
+}
+export declare const parseProject: (entryPath: string, rootPath?: string) => Project;

package/dist/ir/project.js

@@ -0,0 +1,339 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProject = exports.MacroRecursionError = void 0;
+const lexer_1 = require("@minduscript/lexer");
+const lexer_2 = require("@minduscript/lexer");
+const parser_1 = require("@minduscript/parser");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const symbol_table_1 = require("./symbol-table");
+class MacroRecursionError extends Error {
+    chain;
+    constructor(chain) {
+        super(`发生宏递归调用：${chain.map((item) => item.macroName).join('->')}`);
+        this.chain = chain;
+    }
+}
+exports.MacroRecursionError = MacroRecursionError;
+const hasOwn = (record, name) => Object.prototype.hasOwnProperty.call(record, name);
+const tryResolveFile = (candidatePath) => {
+    const normalizedPath = path_1.default.normalize(candidatePath);
+    const candidates = path_1.default.extname(normalizedPath)
+        ? [normalizedPath]
+        : [normalizedPath, `${normalizedPath}.minduscript`];
+    for (const current of candidates) {
+        if (!fs_1.default.existsSync(current)) {
+            continue;
+        }
+        if (!fs_1.default.statSync(current).isFile()) {
+            continue;
+        }
+        return current;
+    }
+    return undefined;
+};
+const resolveImportPath = (importStatement, importerPath, rootPath) => {
+    const { from } = importStatement;
+    const basePath = path_1.default.dirname(importerPath);
+    const candidate = path_1.default.isAbsolute(from)
+        ? from
+        : from.startsWith('.')
+            ? path_1.default.resolve(basePath, from)
+            : rootPath
+                ? path_1.default.resolve(rootPath, from)
+                : undefined;
+    if (!candidate) {
+        throw new Error(`Import "${from}" in "${importerPath}" requires an explicit project root path`);
+    }
+    const resolvedPath = tryResolveFile(candidate);
+    if (!resolvedPath) {
+        throw new Error(`Cannot resolve import "${from}" in "${importerPath}"`);
+    }
+    return resolvedPath;
+};
+const getGlobalVariableNames = (ast) => {
+    return new Set([...Object.keys(ast.symbolTable.vars), ...Object.keys(ast.symbolTable.consts)]);
+};
+const isIdentifierUsingGlobalVariable = (identifier, globalVariableNames) => {
+    return (!identifier.isMindustry &&
+        identifier.identifierType === parser_1.IdentifierType.SIMPLE &&
+        globalVariableNames.has(identifier.value));
+};
+const expressionUsesGlobalVariable = (expression, globalVariableNames, macroCallUsesGlobalVariable) => {
+    const childUsesGlobalVariable = (child) => {
+        switch (child.type) {
+            case parser_1.NodeType.UNARY_OP_EXPRESSION:
+                return childUsesGlobalVariable(child.child);
+            case parser_1.NodeType.BINARY_OP_EXPRESSION:
+                return childUsesGlobalVariable(child.lChild) || childUsesGlobalVariable(child.rChild);
+            case parser_1.NodeType.FUNCTION_CALL_EXPRESSION:
+                return child.args.some(childUsesGlobalVariable);
+            case parser_1.NodeType.MACRO_CALL_EXPRESSION:
+                return (macroCallUsesGlobalVariable(child.name) ||
+                    child.inputArgs.some(childUsesGlobalVariable) ||
+                    child.outputArgs.some((identifier) => isIdentifierUsingGlobalVariable(identifier, globalVariableNames)));
+            case parser_1.NodeType.IDENTIFIER_EXPRESSION:
+                return isIdentifierUsingGlobalVariable(child, globalVariableNames);
+            case parser_1.NodeType.LITERAL_EXPRESSION:
+                return false;
+            default:
+                return child;
+        }
+    };
+    return childUsesGlobalVariable(expression.child);
+};
+const statementUsesGlobalVariable = (statement, globalVariableNames, macroCallUsesGlobalVariable) => {
+    switch (statement.statementType) {
+        case parser_1.StatementType.EMPTY:
+            return false;
+        case parser_1.StatementType.VARIABLE_DEFINE:
+            return expressionUsesGlobalVariable(statement.expression, globalVariableNames, macroCallUsesGlobalVariable);
+        case parser_1.StatementType.ASSIGN:
+            return (expressionUsesGlobalVariable(statement.expression, globalVariableNames, macroCallUsesGlobalVariable) ||
+                (statement.tokens[0]?.type !== lexer_2.TokenType.MINDUSTRY_IDENTIFIER &&
+                    globalVariableNames.has(statement.variableName)));
+        case parser_1.StatementType.CONTROL:
+            return Object.values(statement).some((value) => {
+                if (!value || typeof value !== 'object') {
+                    return false;
+                }
+                const maybeNode = value;
+                if (maybeNode.type === parser_1.NodeType.EXPRESSION) {
+                    return expressionUsesGlobalVariable(maybeNode, globalVariableNames, macroCallUsesGlobalVariable);
+                }
+                if (maybeNode.type === parser_1.NodeType.IDENTIFIER_EXPRESSION) {
+                    return isIdentifierUsingGlobalVariable(maybeNode, globalVariableNames);
+                }
+                return false;
+            });
+        case parser_1.StatementType.MACRO_CALL:
+            return (macroCallUsesGlobalVariable(statement.name) ||
+                statement.inputArgs.some((expression) => expressionUsesGlobalVariable(expression, globalVariableNames, macroCallUsesGlobalVariable)) ||
+                statement.outputArgs.some((identifier) => isIdentifierUsingGlobalVariable(identifier, globalVariableNames)));
+        case parser_1.StatementType.MACRO_DEFINE:
+            return statement.body.some((child) => statementUsesGlobalVariable(child, globalVariableNames, macroCallUsesGlobalVariable));
+        case parser_1.StatementType.IF:
+            return (expressionUsesGlobalVariable(statement.condition, globalVariableNames, macroCallUsesGlobalVariable) ||
+                statement.ifBody.some((child) => statementUsesGlobalVariable(child, globalVariableNames, macroCallUsesGlobalVariable)));
+        case parser_1.StatementType.IF_ELSE:
+            return (expressionUsesGlobalVariable(statement.condition, globalVariableNames, macroCallUsesGlobalVariable) ||
+                statement.ifBody.some((child) => statementUsesGlobalVariable(child, globalVariableNames, macroCallUsesGlobalVariable)) ||
+                statement.elseBody.some((child) => statementUsesGlobalVariable(child, globalVariableNames, macroCallUsesGlobalVariable)));
+        case parser_1.StatementType.FOR:
+            return (statementUsesGlobalVariable(statement.init, globalVariableNames, macroCallUsesGlobalVariable) ||
+                expressionUsesGlobalVariable(statement.condition, globalVariableNames, macroCallUsesGlobalVariable) ||
+                (statement.increment
+                    ? statementUsesGlobalVariable(statement.increment, globalVariableNames, macroCallUsesGlobalVariable)
+                    : false) ||
+                statement.body.some((child) => statementUsesGlobalVariable(child, globalVariableNames, macroCallUsesGlobalVariable)));
+        case parser_1.StatementType.WHILE:
+            return (expressionUsesGlobalVariable(statement.condition, globalVariableNames, macroCallUsesGlobalVariable) ||
+                statement.body.some((child) => statementUsesGlobalVariable(child, globalVariableNames, macroCallUsesGlobalVariable)));
+        case parser_1.StatementType.LOOP_CONTROL:
+            return false;
+        case parser_1.StatementType.RETURN:
+            return expressionUsesGlobalVariable(statement.expression, globalVariableNames, macroCallUsesGlobalVariable);
+        default:
+            return statement;
+    }
+};
+const collectLocalMacroMap = (ast) => {
+    const macroMap = {};
+    for (const statement of ast.statementList) {
+        if (statement.statementType !== parser_1.StatementType.MACRO_DEFINE) {
+            continue;
+        }
+        macroMap[statement.name] = statement;
+    }
+    return macroMap;
+};
+const createReExportedMacro = (macro, exportName) => {
+    if (macro.name === exportName) {
+        return macro;
+    }
+    return {
+        ...macro,
+        name: exportName,
+    };
+};
+const parseProject = (entryPath, rootPath) => {
+    const resolvedEntryPath = tryResolveFile(path_1.default.resolve(entryPath));
+    if (!resolvedEntryPath) {
+        throw new Error(`Entry file "${entryPath}" does not exist`);
+    }
+    const resolvedRootPath = rootPath ? path_1.default.resolve(rootPath) : path_1.default.dirname(resolvedEntryPath);
+    const sourceMap = {};
+    const visitingStack = [];
+    const loadSource = (filePath) => {
+        if (hasOwn(sourceMap, filePath)) {
+            return sourceMap[filePath];
+        }
+        const cycleStartIndex = visitingStack.indexOf(filePath);
+        if (cycleStartIndex >= 0) {
+            const cyclePath = [...visitingStack.slice(cycleStartIndex), filePath].join(' -> ');
+            throw new Error(`Circular dependency detected: ${cyclePath}`);
+        }
+        visitingStack.push(filePath);
+        try {
+            const tokens = lexer_1.lexer.lexFile(filePath);
+            const ast = (0, symbol_table_1.buildSymbolTable)(parser_1.parser.parse(tokens));
+            const source = {
+                path: filePath,
+                ast,
+                macros: [],
+                internalMacros: [],
+                exportMap: {},
+                localMacroMap: collectLocalMacroMap(ast),
+                importAliasMap: {},
+                resolvedImports: [],
+                globalVariableNames: getGlobalVariableNames(ast),
+            };
+            sourceMap[filePath] = source;
+            for (const importStatement of ast.importList) {
+                const importedPath = resolveImportPath(importStatement, filePath, rootPath ? resolvedRootPath : undefined);
+                loadSource(importedPath);
+                const resolvedImport = {
+                    sourcePath: importedPath,
+                    macroName: importStatement.name,
+                    asName: importStatement.asName,
+                };
+                source.resolvedImports.push(resolvedImport);
+                source.importAliasMap[importStatement.asName] = resolvedImport;
+            }
+            return source;
+        }
+        finally {
+            visitingStack.pop();
+        }
+    };
+    loadSource(resolvedEntryPath);
+    const resolveMacroDefinition = (sourcePath, macroName, aliasChain = []) => {
+        const source = sourceMap[sourcePath];
+        if (!source) {
+            return undefined;
+        }
+        const nextAliasChain = [...aliasChain, { sourcePath, macroName }];
+        const localMacro = source.localMacroMap[macroName];
+        if (localMacro) {
+            return {
+                sourcePath,
+                macroName,
+                macro: localMacro,
+                aliases: nextAliasChain,
+            };
+        }
+        const imported = source.importAliasMap[macroName];
+        if (!imported) {
+            return undefined;
+        }
+        return resolveMacroDefinition(imported.sourcePath, imported.macroName, nextAliasChain);
+    };
+    const toMacroKey = (sourcePath, macroName) => `${sourcePath}\u0000${macroName}`;
+    const parseMacroKey = (key) => {
+        const separator = key.indexOf('\u0000');
+        return {
+            sourcePath: key.slice(0, separator),
+            macroName: key.slice(separator + 1),
+        };
+    };
+    const macroState = new Map();
+    const macroUsesGlobalVariableMap = new Map();
+    const macroStack = [];
+    const analyzeMacroUsesGlobalVariable = (sourcePath, macroName) => {
+        const resolved = resolveMacroDefinition(sourcePath, macroName);
+        if (!resolved) {
+            return false;
+        }
+        const key = toMacroKey(resolved.sourcePath, resolved.macroName);
+        const currentState = macroState.get(key);
+        if (currentState === 'done') {
+            return macroUsesGlobalVariableMap.get(key) ?? false;
+        }
+        if (currentState === 'visiting') {
+            const cycleStart = macroStack.indexOf(key);
+            const cycleKeys = [...macroStack.slice(cycleStart), key];
+            throw new MacroRecursionError(cycleKeys.map((item) => {
+                const parsed = parseMacroKey(item);
+                return {
+                    macroName: parsed.macroName,
+                    sourceFile: parsed.sourcePath,
+                };
+            }));
+        }
+        const ownerSource = sourceMap[resolved.sourcePath];
+        macroState.set(key, 'visiting');
+        macroStack.push(key);
+        try {
+            const usesGlobalVariable = resolved.macro.body.some((statement) => statementUsesGlobalVariable(statement, ownerSource.globalVariableNames, (calledMacroName) => analyzeMacroUsesGlobalVariable(resolved.sourcePath, calledMacroName)));
+            macroUsesGlobalVariableMap.set(key, usesGlobalVariable);
+            macroState.set(key, 'done');
+            return usesGlobalVariable;
+        }
+        finally {
+            macroStack.pop();
+        }
+    };
+    const localExportMapBySource = {};
+    for (const source of Object.values(sourceMap)) {
+        const localExportMap = {};
+        const internalMacros = [];
+        for (const [macroName, macroNode] of Object.entries(source.localMacroMap)) {
+            if (analyzeMacroUsesGlobalVariable(source.path, macroName)) {
+                internalMacros.push(macroNode);
+                continue;
+            }
+            localExportMap[macroName] = macroNode;
+        }
+        localExportMapBySource[source.path] = localExportMap;
+        source.internalMacros = internalMacros;
+    }
+    const sourceExportState = new Map();
+    const buildSourceExportMap = (sourcePath) => {
+        const source = sourceMap[sourcePath];
+        const currentState = sourceExportState.get(sourcePath);
+        if (currentState === 'done') {
+            return source.exportMap;
+        }
+        if (currentState === 'visiting') {
+            throw new Error(`Unexpected import cycle while building exports: ${sourcePath}`);
+        }
+        sourceExportState.set(sourcePath, 'visiting');
+        const exportMap = {
+            ...localExportMapBySource[sourcePath],
+        };
+        for (const resolvedImport of source.resolvedImports) {
+            const importedExportMap = buildSourceExportMap(resolvedImport.sourcePath);
+            const importedMacro = importedExportMap[resolvedImport.macroName];
+            if (!importedMacro) {
+                throw new Error(`Macro "${resolvedImport.macroName}" imported by "${sourcePath}" was not exported from "${resolvedImport.sourcePath}"`);
+            }
+            exportMap[resolvedImport.asName] = createReExportedMacro(importedMacro, resolvedImport.asName);
+        }
+        source.exportMap = exportMap;
+        source.macros = Object.values(exportMap);
+        sourceExportState.set(sourcePath, 'done');
+        return exportMap;
+    };
+    for (const sourcePath of Object.keys(sourceMap)) {
+        buildSourceExportMap(sourcePath);
+    }
+    const sources = {};
+    for (const [filePath, source] of Object.entries(sourceMap)) {
+        sources[filePath] = {
+            path: source.path,
+            ast: source.ast,
+            macros: source.macros,
+            internalMacros: source.internalMacros,
+        };
+    }
+    return {
+        rootPath: resolvedRootPath,
+        entryPath: resolvedEntryPath,
+        sources,
+    };
+};
+exports.parseProject = parseProject;
+//# sourceMappingURL=project.js.map

package/dist/ir/symbol-table.d.ts

@@ -0,0 +1,19 @@
+import type { ASTNode, BindStatementNode, DocumentNode, ImportStatementNode, MacroDefineStatementNode, MinduscriptIdentifierExpressionNode, VariableDefineStatementNode } from '@minduscript/parser';
+export type VarSymbolSource = VariableDefineStatementNode | BindStatementNode | MinduscriptIdentifierExpressionNode;
+export type MacroSymbolSource = MacroDefineStatementNode | ImportStatementNode;
+export type SymbolTable = {
+    vars: Record<string, VarSymbolSource>;
+    consts: Record<string, VarSymbolSource>;
+    macros: Record<string, MacroSymbolSource>;
+};
+export type WithSymbolTable<T extends ASTNode> = T extends ASTNode ? {
+    [K in keyof T]: T[K] extends ASTNode ? WithSymbolTable<T[K]> : T[K] extends (infer N extends ASTNode)[] ? WithSymbolTable<N>[] : T[K];
+} & {
+    symbolTable: SymbolTable;
+} : never;
+export declare class BuildSymbolTableError extends Error {
+    readonly node: ASTNode;
+    constructor(node: ASTNode, message: string);
+}
+declare const buildSymbolTable: (document: DocumentNode) => WithSymbolTable<DocumentNode>;
+export { buildSymbolTable };