@minduscript/compiler 1.0.0

package/dist/macro/expand-macros.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandMacros = void 0;
+const counter_1 = require("../counter");
+const ir_1 = require("../ir/ir");
+const deepCopy = (obj) => {
+    return JSON.parse(JSON.stringify(obj));
+};
+const expandSingleMacro = (body, inputParams, outputParams, inputArgs, outputArgs, returnTarget) => {
+    const macroCallId = counter_1.counter.next();
+    const varNameMap = {};
+    const labelNameMap = {};
+    const inputArgVars = {};
+    const inputArgLiterals = {};
+    for (let i = 0; i < inputArgs.length; i++) {
+        const arg = inputArgs[i];
+        if (arg.isLiteral) {
+            inputArgLiterals[i] = arg;
+            continue;
+        }
+        inputArgVars[i] = arg;
+    }
+    const getVarName = (original) => {
+        if (!original.startsWith('$')) {
+            return original;
+        }
+        if (!varNameMap[original]) {
+            if (inputParams.includes(original)) {
+                const index = inputParams.indexOf(original);
+                varNameMap[original] = inputArgs[index].name;
+            }
+            else if (outputParams.includes(original)) {
+                const index = outputParams.indexOf(original);
+                varNameMap[original] = outputArgs[index];
+            }
+            else if (returnTarget && original === '$return') {
+                varNameMap[original] = returnTarget;
+            }
+            else {
+                varNameMap[original] = `$$${macroCallId}_${original}`;
+            }
+        }
+        return varNameMap[original];
+    };
+    const getLabelName = (original) => {
+        if (!labelNameMap[original]) {
+            labelNameMap[original] = `_${macroCallId}_${original}`;
+        }
+        return labelNameMap[original];
+    };
+    const transformValue = (original) => {
+        if (original.isLiteral || original.isMindustry) {
+            return original;
+        }
+        if (inputParams.includes(original.name)) {
+            const index = inputParams.indexOf(original.name);
+            if (inputArgVars[index]) {
+                return { ...inputArgVars[index] };
+            }
+            else {
+                return { ...inputArgLiterals[index] };
+            }
+        }
+        return {
+            ...original,
+            name: getVarName(original.name),
+        };
+    };
+    const outputBody = [];
+    for (const node of body) {
+        const newNode = deepCopy(node);
+        if (newNode.type == ir_1.IRNodeType.JUMP) {
+            newNode.label = getLabelName(newNode.label);
+        }
+        else if (newNode.type == ir_1.IRNodeType.CONDITIONAL_JUMP) {
+            newNode.left = transformValue(newNode.left);
+            newNode.right = transformValue(newNode.right);
+            newNode.label = getLabelName(newNode.label);
+        }
+        else if (newNode.type == ir_1.IRNodeType.LABEL) {
+            newNode.name = getLabelName(newNode.name);
+        }
+        else {
+            const temp = newNode;
+            for (const key in temp) {
+                if (typeof temp[key] == 'string') {
+                    temp[key] = getVarName(temp[key]);
+                }
+                else if (typeof temp[key] == 'object' && 'isLiteral' in temp[key]) {
+                    temp[key] = transformValue(temp[key]);
+                }
+            }
+        }
+        outputBody.push(newNode);
+    }
+    return outputBody;
+};
+const expandMacrosInBody = (body, macroDefinitions) => {
+    const output = [];
+    for (const node of body) {
+        if (node.type == ir_1.IRNodeType.MACRO_CALL) {
+            const macroDef = macroDefinitions[node.name];
+            output.push(...expandSingleMacro(macroDef.body, macroDef.inputParams, macroDef.outputParams, node.inputArgs, node.outputArgs));
+        }
+        else if (node.type == ir_1.IRNodeType.MACRO_CALL_ASSIGN) {
+            const macroDef = macroDefinitions[node.name];
+            const expanded = expandSingleMacro(macroDef.body, macroDef.inputParams, macroDef.outputParams, node.inputArgs, node.outputArgs, node.returnTarget);
+            output.push(...expanded);
+        }
+        else {
+            output.push(deepCopy(node));
+        }
+    }
+    return output;
+};
+const simplifyNames = (body, inputParams, outputParams) => {
+    counter_1.counter.reset();
+    const varNameMap = {};
+    const labelNameMap = {};
+    const getVarName = (original) => {
+        if (!original.startsWith('$') || original == '$return') {
+            return original;
+        }
+        if (!varNameMap[original]) {
+            if (inputParams.includes(original) || outputParams.includes(original)) {
+                varNameMap[original] = original;
+            }
+            else {
+                varNameMap[original] = `$${counter_1.counter.next()}`;
+            }
+        }
+        return varNameMap[original];
+    };
+    const getLabelName = (original) => {
+        if (!labelNameMap[original]) {
+            labelNameMap[original] = `${counter_1.counter.next()}`;
+        }
+        return labelNameMap[original];
+    };
+    const transformValue = (original) => {
+        if (original.isLiteral || original.isMindustry) {
+            return original;
+        }
+        return {
+            ...original,
+            name: getVarName(original.name),
+        };
+    };
+    for (const node of body) {
+        if (node.type == ir_1.IRNodeType.JUMP) {
+            node.label = getLabelName(node.label);
+        }
+        else if (node.type == ir_1.IRNodeType.CONDITIONAL_JUMP) {
+            node.left = transformValue(node.left);
+            node.right = transformValue(node.right);
+            node.label = getLabelName(node.label);
+        }
+        else if (node.type == ir_1.IRNodeType.LABEL) {
+            node.name = getLabelName(node.name);
+        }
+        else {
+            const temp = node;
+            for (const key in temp) {
+                if (typeof temp[key] == 'string') {
+                    temp[key] = getVarName(temp[key]);
+                }
+                else if (typeof temp[key] == 'object' && 'isLiteral' in temp[key]) {
+                    temp[key] = transformValue(temp[key]);
+                }
+            }
+        }
+    }
+};
+const expandAllMacros = (macroDefinitions) => {
+    const result = {};
+    const macroMap = {};
+    // 创建宏定义的映射表
+    for (const macro of macroDefinitions) {
+        macroMap[macro.name] = {
+            ...deepCopy(macro),
+            dependencies: new Set(macro.dependencies),
+        };
+    }
+    // 拓扑排序状态
+    const visited = new Set();
+    const order = [];
+    // DFS 拓扑排序
+    const dfs = (name) => {
+        if (visited.has(name)) {
+            return;
+        }
+        visited.add(name);
+        const macro = macroMap[name];
+        if (macro && macro.dependencies) {
+            for (const dep of macro.dependencies) {
+                dfs(dep);
+            }
+        }
+        order.push(name);
+    };
+    // 获取拓扑排序后的遍历顺序
+    for (const macro of macroDefinitions) {
+        dfs(macro.name);
+    }
+    // 按顺序展开宏
+    for (const macroName of order) {
+        const macro = macroMap[macroName];
+        // 展开宏体中的所有宏调用
+        const expandedBody = expandMacrosInBody(macro.body, result);
+        simplifyNames(expandedBody, macro.inputParams, macro.outputParams);
+        // 保存展开后的宏
+        result[macroName] = {
+            ...macro,
+            body: expandedBody,
+        };
+    }
+    return result;
+};
+const simplifyMainNames = (body, boundVariables) => {
+    counter_1.counter.reset();
+    const varNameMap = {};
+    const labelNameMap = {};
+    const shouldKeepVarName = (name) => {
+        return name.startsWith('@') || boundVariables.has(name);
+    };
+    const getVarName = (original) => {
+        if (shouldKeepVarName(original)) {
+            return original;
+        }
+        if (!varNameMap[original]) {
+            varNameMap[original] = `$${counter_1.counter.next()}`;
+        }
+        return varNameMap[original];
+    };
+    const getLabelName = (original) => {
+        if (!labelNameMap[original]) {
+            labelNameMap[original] = `${counter_1.counter.next()}`;
+        }
+        return labelNameMap[original];
+    };
+    const transformValue = (original) => {
+        if (original.isLiteral || original.isMindustry) {
+            return original;
+        }
+        return {
+            ...original,
+            name: getVarName(original.name),
+        };
+    };
+    for (const node of body) {
+        if (node.type == ir_1.IRNodeType.JUMP) {
+            node.label = getLabelName(node.label);
+        }
+        else if (node.type == ir_1.IRNodeType.CONDITIONAL_JUMP) {
+            node.left = transformValue(node.left);
+            node.right = transformValue(node.right);
+            node.label = getLabelName(node.label);
+        }
+        else if (node.type == ir_1.IRNodeType.LABEL) {
+            node.name = getLabelName(node.name);
+        }
+        else {
+            const temp = node;
+            for (const key in temp) {
+                if (typeof temp[key] == 'string') {
+                    temp[key] = getVarName(temp[key]);
+                }
+                else if (typeof temp[key] == 'object' && 'isLiteral' in temp[key]) {
+                    temp[key] = transformValue(temp[key]);
+                }
+            }
+        }
+    }
+    return {
+        body,
+        boundVariables,
+    };
+};
+const expandMacros = (program) => {
+    const expandedMacros = expandAllMacros(Object.values(program.macros));
+    const expandedBody = expandMacrosInBody(program.main, expandedMacros);
+    return simplifyMainNames(expandedBody, program.boundVariables);
+};
+exports.expandMacros = expandMacros;
+//# sourceMappingURL=expand-macros.js.map

package/dist/optimizer/default-passes.d.ts

@@ -0,0 +1,2 @@
+import type { OptimizerPass } from './types';
+export declare const DEFAULT_PASSES: OptimizerPass[];

package/dist/optimizer/default-passes.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PASSES = void 0;
+const control_flow_1 = require("./passes/control-flow");
+const copy_propagation_1 = require("./passes/copy-propagation");
+const constant_folding_1 = require("./passes/constant-folding");
+const dead_code_1 = require("./passes/dead-code");
+const merge_labels_pass_1 = require("./passes/merge-labels-pass");
+exports.DEFAULT_PASSES = [
+    merge_labels_pass_1.mergeLabelsPass,
+    control_flow_1.foldConstantConditionalJumps,
+    control_flow_1.removeJumpToNextLabel,
+    control_flow_1.removeUnreachableAfterJump,
+    copy_propagation_1.propagateAssignValues,
+    constant_folding_1.foldConstants,
+    dead_code_1.removeDeadCode,
+    merge_labels_pass_1.mergeLabelsPass,
+    control_flow_1.removeUnusedLabels,
+];
+//# sourceMappingURL=default-passes.js.map

package/dist/optimizer/merge-labels.d.ts

@@ -0,0 +1,2 @@
+import { SimplifiedIRProgram } from '../macro/expand-macros';
+export declare const mergeLabels: (ir: SimplifiedIRProgram) => SimplifiedIRProgram;

package/dist/optimizer/merge-labels.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeLabels = void 0;
+const ir_1 = require("../ir/ir");
+const mergeLabels = (ir) => {
+    const labelAlias = new Map();
+    const merged = [];
+    for (const node of ir.body) {
+        if (node.type === ir_1.IRNodeType.LABEL) {
+            const prev = merged[merged.length - 1];
+            if (prev && prev.type === ir_1.IRNodeType.LABEL) {
+                labelAlias.set(node.name, prev.name);
+                continue;
+            }
+        }
+        merged.push(node);
+    }
+    const resolveLabel = (name) => {
+        let resolved = name;
+        while (labelAlias.has(resolved)) {
+            resolved = labelAlias.get(resolved);
+        }
+        return resolved;
+    };
+    return {
+        body: merged.map((node) => {
+            if (node.type === ir_1.IRNodeType.JUMP) {
+                return {
+                    ...node,
+                    label: resolveLabel(node.label),
+                };
+            }
+            if (node.type === ir_1.IRNodeType.CONDITIONAL_JUMP) {
+                return {
+                    ...node,
+                    label: resolveLabel(node.label),
+                };
+            }
+            return node;
+        }),
+        boundVariables: ir.boundVariables,
+    };
+};
+exports.mergeLabels = mergeLabels;
+//# sourceMappingURL=merge-labels.js.map

package/dist/optimizer/optimizer.d.ts

@@ -0,0 +1,4 @@
+import { type SimplifiedIRProgram } from '../macro/expand-macros';
+import type { OptimizeOptions } from './types';
+export type { OptimizerPass, OptimizeOptions } from './types';
+export declare const optimizeIR: (program: SimplifiedIRProgram, options?: OptimizeOptions) => SimplifiedIRProgram;

package/dist/optimizer/optimizer.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimizeIR = void 0;
+const default_passes_1 = require("./default-passes");
+const optimizeIR = (program, options = {}) => {
+    const maxIterations = options.maxIterations ?? 5;
+    const passes = options.passes ?? default_passes_1.DEFAULT_PASSES;
+    let current = {
+        body: [...program.body],
+        boundVariables: program.boundVariables,
+    };
+    for (let i = 0; i < maxIterations; i++) {
+        let changedInIteration = false;
+        for (const pass of passes) {
+            const result = pass(current);
+            current = result.program;
+            changedInIteration = changedInIteration || result.changed;
+        }
+        if (!changedInIteration) {
+            break;
+        }
+    }
+    return current;
+};
+exports.optimizeIR = optimizeIR;
+//# sourceMappingURL=optimizer.js.map

package/dist/optimizer/passes/constant-folding.d.ts

@@ -0,0 +1,2 @@
+import type { OptimizerPass } from '../types';
+export declare const foldConstants: OptimizerPass;

package/dist/optimizer/passes/constant-folding.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.foldConstants = void 0;
+const ir_1 = require("../../ir/ir");
+const literal = (value) => ({
+    isLiteral: true,
+    value,
+});
+const asNumber = (value) => {
+    if (!value.isLiteral || typeof value.value !== 'number') {
+        return undefined;
+    }
+    return value.value;
+};
+const foldUnary = (node) => {
+    if (node.type === ir_1.IRNodeType.ASSIGN) {
+        if (node.value.isLiteral) {
+            return node;
+        }
+        return undefined;
+    }
+    if (node.type !== ir_1.IRNodeType.FLIP &&
+        node.type !== ir_1.IRNodeType.ABS &&
+        node.type !== ir_1.IRNodeType.LOG &&
+        node.type !== ir_1.IRNodeType.LOG10 &&
+        node.type !== ir_1.IRNodeType.FLOOR &&
+        node.type !== ir_1.IRNodeType.CEIL &&
+        node.type !== ir_1.IRNodeType.SQRT &&
+        node.type !== ir_1.IRNodeType.SIN &&
+        node.type !== ir_1.IRNodeType.COS &&
+        node.type !== ir_1.IRNodeType.TAN &&
+        node.type !== ir_1.IRNodeType.ASIN &&
+        node.type !== ir_1.IRNodeType.ACOS &&
+        node.type !== ir_1.IRNodeType.ATAN) {
+        return undefined;
+    }
+    const n = asNumber(node.value);
+    if (n === undefined) {
+        return undefined;
+    }
+    let output;
+    switch (node.type) {
+        case ir_1.IRNodeType.FLIP:
+            output = -n;
+            break;
+        case ir_1.IRNodeType.ABS:
+            output = Math.abs(n);
+            break;
+        case ir_1.IRNodeType.LOG:
+            output = Math.log(n);
+            break;
+        case ir_1.IRNodeType.LOG10:
+            output = Math.log10(n);
+            break;
+        case ir_1.IRNodeType.FLOOR:
+            output = Math.floor(n);
+            break;
+        case ir_1.IRNodeType.CEIL:
+            output = Math.ceil(n);
+            break;
+        case ir_1.IRNodeType.SQRT:
+            output = Math.sqrt(n);
+            break;
+        case ir_1.IRNodeType.SIN:
+            output = Math.sin(n);
+            break;
+        case ir_1.IRNodeType.COS:
+            output = Math.cos(n);
+            break;
+        case ir_1.IRNodeType.TAN:
+            output = Math.tan(n);
+            break;
+        case ir_1.IRNodeType.ASIN:
+            output = Math.asin(n);
+            break;
+        case ir_1.IRNodeType.ACOS:
+            output = Math.acos(n);
+            break;
+        default:
+            output = Math.atan(n);
+            break;
+    }
+    return {
+        type: ir_1.IRNodeType.ASSIGN,
+        target: node.target,
+        value: literal(output),
+    };
+};
+const foldBinary = (node) => {
+    if (node.type !== ir_1.IRNodeType.ADD &&
+        node.type !== ir_1.IRNodeType.SUB &&
+        node.type !== ir_1.IRNodeType.MUL &&
+        node.type !== ir_1.IRNodeType.DIV &&
+        node.type !== ir_1.IRNodeType.IDIV &&
+        node.type !== ir_1.IRNodeType.MOD &&
+        node.type !== ir_1.IRNodeType.POW) {
+        return undefined;
+    }
+    const left = asNumber(node.left);
+    const right = asNumber(node.right);
+    if (left === undefined || right === undefined) {
+        return undefined;
+    }
+    let output;
+    switch (node.type) {
+        case ir_1.IRNodeType.ADD:
+            output = left + right;
+            break;
+        case ir_1.IRNodeType.SUB:
+            output = left - right;
+            break;
+        case ir_1.IRNodeType.MUL:
+            output = left * right;
+            break;
+        case ir_1.IRNodeType.DIV:
+            output = left / right;
+            break;
+        case ir_1.IRNodeType.IDIV:
+            output = Math.trunc(left / right);
+            break;
+        case ir_1.IRNodeType.MOD:
+            output = left % right;
+            break;
+        default:
+            output = left ** right;
+            break;
+    }
+    return {
+        type: ir_1.IRNodeType.ASSIGN,
+        target: node.target,
+        value: literal(output),
+    };
+};
+const foldConstants = (program) => {
+    let changed = false;
+    const body = program.body.map((node) => {
+        const unaryFolded = foldUnary(node);
+        if (unaryFolded) {
+            if (unaryFolded !== node) {
+                changed = true;
+            }
+            return unaryFolded;
+        }
+        const binaryFolded = foldBinary(node);
+        if (binaryFolded) {
+            changed = true;
+            return binaryFolded;
+        }
+        return node;
+    });
+    return {
+        program: {
+            body,
+            boundVariables: program.boundVariables,
+        },
+        changed,
+    };
+};
+exports.foldConstants = foldConstants;
+//# sourceMappingURL=constant-folding.js.map

package/dist/optimizer/passes/control-flow.d.ts

@@ -0,0 +1,5 @@
+import type { OptimizerPass } from '../types';
+export declare const foldConstantConditionalJumps: OptimizerPass;
+export declare const removeJumpToNextLabel: OptimizerPass;
+export declare const removeUnreachableAfterJump: OptimizerPass;
+export declare const removeUnusedLabels: OptimizerPass;

package/dist/optimizer/passes/control-flow.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeUnusedLabels = exports.removeUnreachableAfterJump = exports.removeJumpToNextLabel = exports.foldConstantConditionalJumps = void 0;
+const ir_1 = require("../../ir/ir");
+const evaluateCondition = (node) => {
+    if (!node.left.isLiteral || !node.right.isLiteral) {
+        return undefined;
+    }
+    const left = node.left.value;
+    const right = node.right.value;
+    switch (node.condition) {
+        case ir_1.JumpCondition.EQ:
+            return left == right;
+        case ir_1.JumpCondition.NE:
+            return left != right;
+        case ir_1.JumpCondition.LESS:
+            return left < right;
+        case ir_1.JumpCondition.LE:
+            return left <= right;
+        case ir_1.JumpCondition.GREATER:
+            return left > right;
+        case ir_1.JumpCondition.GE:
+            return left >= right;
+        case ir_1.JumpCondition.STRICT_EQ:
+            return left === right;
+        default:
+            return undefined;
+    }
+};
+const foldConstantConditionalJumps = (program) => {
+    let changed = false;
+    const body = [];
+    for (const node of program.body) {
+        if (node.type !== ir_1.IRNodeType.CONDITIONAL_JUMP) {
+            body.push(node);
+            continue;
+        }
+        const result = evaluateCondition(node);
+        if (result === undefined) {
+            body.push(node);
+            continue;
+        }
+        changed = true;
+        if (result) {
+            body.push({
+                type: ir_1.IRNodeType.JUMP,
+                label: node.label,
+            });
+        }
+    }
+    return {
+        program: {
+            body,
+            boundVariables: program.boundVariables,
+        },
+        changed,
+    };
+};
+exports.foldConstantConditionalJumps = foldConstantConditionalJumps;
+const removeJumpToNextLabel = (program) => {
+    let changed = false;
+    const body = [];
+    for (let i = 0; i < program.body.length; i++) {
+        const node = program.body[i];
+        if (node.type === ir_1.IRNodeType.JUMP) {
+            const next = program.body[i + 1];
+            if (next && next.type === ir_1.IRNodeType.LABEL && next.name === node.label) {
+                changed = true;
+                continue;
+            }
+        }
+        body.push(node);
+    }
+    return {
+        program: {
+            body,
+            boundVariables: program.boundVariables,
+        },
+        changed,
+    };
+};
+exports.removeJumpToNextLabel = removeJumpToNextLabel;
+const removeUnreachableAfterJump = (program) => {
+    let changed = false;
+    const body = [];
+    let inUnreachableRegion = false;
+    for (const node of program.body) {
+        if (node.type === ir_1.IRNodeType.LABEL) {
+            inUnreachableRegion = false;
+            body.push(node);
+            continue;
+        }
+        if (inUnreachableRegion) {
+            changed = true;
+            continue;
+        }
+        body.push(node);
+        if (node.type === ir_1.IRNodeType.JUMP) {
+            inUnreachableRegion = true;
+        }
+    }
+    return {
+        program: {
+            body,
+            boundVariables: program.boundVariables,
+        },
+        changed,
+    };
+};
+exports.removeUnreachableAfterJump = removeUnreachableAfterJump;
+const removeUnusedLabels = (program) => {
+    const usedLabels = new Set();
+    for (const node of program.body) {
+        if (node.type === ir_1.IRNodeType.JUMP || node.type === ir_1.IRNodeType.CONDITIONAL_JUMP) {
+            usedLabels.add(node.label);
+        }
+    }
+    let changed = false;
+    const body = program.body.filter((node) => {
+        if (node.type !== ir_1.IRNodeType.LABEL) {
+            return true;
+        }
+        const keep = usedLabels.has(node.name);
+        if (!keep) {
+            changed = true;
+        }
+        return keep;
+    });
+    return {
+        program: {
+            body,
+            boundVariables: program.boundVariables,
+        },
+        changed,
+    };
+};
+exports.removeUnusedLabels = removeUnusedLabels;
+//# sourceMappingURL=control-flow.js.map