@minduscript/compiler 1.0.0

package/dist/optimizer/passes/copy-propagation.d.ts

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

package/dist/optimizer/passes/copy-propagation.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propagateAssignValues = void 0;
+const ir_1 = require("../../ir/ir");
+const cloneValue = (value) => {
+    if (value.isLiteral) {
+        return {
+            isLiteral: true,
+            value: value.value,
+        };
+    }
+    return {
+        isLiteral: false,
+        name: value.name,
+        isMindustry: value.isMindustry,
+    };
+};
+const resolveValue = (value, env) => {
+    if (value.isLiteral || value.isMindustry) {
+        return value;
+    }
+    let current = value;
+    const visited = new Set();
+    while (!current.isLiteral && !current.isMindustry) {
+        if (visited.has(current.name)) {
+            break;
+        }
+        visited.add(current.name);
+        const replacement = env.get(current.name);
+        if (!replacement) {
+            break;
+        }
+        current = replacement;
+    }
+    return cloneValue(current);
+};
+const invalidateDependentMappings = (env, changedName) => {
+    for (const [name, value] of [...env.entries()]) {
+        if (!value.isLiteral && !value.isMindustry && value.name === changedName) {
+            env.delete(name);
+        }
+    }
+};
+const DEF_KEYS = new Set(['target', 'output', 'result', 'outType', 'building', 'floor', 'returnTarget']);
+const mapValuesDeep = (input, env, changedRef) => {
+    if (!input || typeof input !== 'object') {
+        return input;
+    }
+    if (Array.isArray(input)) {
+        let arrayChanged = false;
+        const next = input.map((item) => {
+            const mapped = mapValuesDeep(item, env, changedRef);
+            if (mapped !== item) {
+                arrayChanged = true;
+            }
+            return mapped;
+        });
+        if (arrayChanged) {
+            changedRef.changed = true;
+            return next;
+        }
+        return input;
+    }
+    const maybeValue = input;
+    if (typeof maybeValue.isLiteral === 'boolean' && typeof maybeValue.name === 'string') {
+        const resolved = resolveValue(input, env);
+        const original = input;
+        if (resolved.isLiteral !== original.isLiteral ||
+            (resolved.isLiteral && original.isLiteral && resolved.value !== original.value) ||
+            (!resolved.isLiteral &&
+                !original.isLiteral &&
+                (resolved.name !== original.name || resolved.isMindustry !== original.isMindustry))) {
+            changedRef.changed = true;
+            return resolved;
+        }
+        return input;
+    }
+    const source = input;
+    let objectChanged = false;
+    const output = {};
+    for (const key in source) {
+        const mapped = mapValuesDeep(source[key], env, changedRef);
+        output[key] = mapped;
+        if (mapped !== source[key]) {
+            objectChanged = true;
+        }
+    }
+    return objectChanged ? output : input;
+};
+const removeDefsFromEnv = (node, env) => {
+    const temp = node;
+    for (const key in temp) {
+        if (!DEF_KEYS.has(key)) {
+            continue;
+        }
+        const value = temp[key];
+        if (typeof value === 'string') {
+            env.delete(value);
+            invalidateDependentMappings(env, value);
+        }
+    }
+};
+const propagateAssignValues = (program) => {
+    const env = new Map();
+    const changedRef = { changed: false };
+    const body = program.body.map((node) => {
+        const mappedNode = mapValuesDeep(node, env, changedRef);
+        removeDefsFromEnv(mappedNode, env);
+        if (mappedNode.type === ir_1.IRNodeType.ASSIGN) {
+            const resolved = mappedNode.value;
+            if (!resolved.isLiteral && !resolved.isMindustry && resolved.name === mappedNode.target) {
+                return mappedNode;
+            }
+            env.set(mappedNode.target, cloneValue(resolved));
+        }
+        return mappedNode;
+    });
+    return {
+        program: {
+            body,
+            boundVariables: program.boundVariables,
+        },
+        changed: changedRef.changed,
+    };
+};
+exports.propagateAssignValues = propagateAssignValues;
+//# sourceMappingURL=copy-propagation.js.map

package/dist/optimizer/passes/dead-code.d.ts

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

package/dist/optimizer/passes/dead-code.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDeadCode = void 0;
+const ir_1 = require("../../ir/ir");
+const DCE_REMOVABLE_TYPES = new Set([
+    ir_1.IRNodeType.ASSIGN,
+    ir_1.IRNodeType.FLIP,
+    ir_1.IRNodeType.AND,
+    ir_1.IRNodeType.EQ,
+    ir_1.IRNodeType.NE,
+    ir_1.IRNodeType.LESS,
+    ir_1.IRNodeType.LE,
+    ir_1.IRNodeType.GREATER,
+    ir_1.IRNodeType.GE,
+    ir_1.IRNodeType.STRICT_EQ,
+    ir_1.IRNodeType.BITOR,
+    ir_1.IRNodeType.XOR,
+    ir_1.IRNodeType.BITAND,
+    ir_1.IRNodeType.SHL,
+    ir_1.IRNodeType.SHR,
+    ir_1.IRNodeType.ADD,
+    ir_1.IRNodeType.SUB,
+    ir_1.IRNodeType.MUL,
+    ir_1.IRNodeType.DIV,
+    ir_1.IRNodeType.IDIV,
+    ir_1.IRNodeType.MOD,
+    ir_1.IRNodeType.POW,
+    ir_1.IRNodeType.MAX,
+    ir_1.IRNodeType.MIN,
+    ir_1.IRNodeType.ANGLE,
+    ir_1.IRNodeType.ANGLE_DIFF,
+    ir_1.IRNodeType.LEN,
+    ir_1.IRNodeType.PACK_COLOR,
+    ir_1.IRNodeType.ABS,
+    ir_1.IRNodeType.LOG,
+    ir_1.IRNodeType.LOG10,
+    ir_1.IRNodeType.FLOOR,
+    ir_1.IRNodeType.CEIL,
+    ir_1.IRNodeType.SQRT,
+    ir_1.IRNodeType.SIN,
+    ir_1.IRNodeType.COS,
+    ir_1.IRNodeType.TAN,
+    ir_1.IRNodeType.ASIN,
+    ir_1.IRNodeType.ACOS,
+    ir_1.IRNodeType.ATAN,
+]);
+const addValueUse = (value, used) => {
+    if (!value || typeof value !== 'object') {
+        return;
+    }
+    const temp = value;
+    if (typeof temp.isLiteral === 'boolean' && temp.isLiteral === false && typeof temp.name === 'string') {
+        used.add(temp.name);
+    }
+};
+const collectNodeUses = (node) => {
+    const used = new Set();
+    const visited = new Set();
+    const walk = (value) => {
+        if (!value || typeof value !== 'object') {
+            return;
+        }
+        if (visited.has(value)) {
+            return;
+        }
+        visited.add(value);
+        addValueUse(value, used);
+        if (Array.isArray(value)) {
+            for (const element of value) {
+                walk(element);
+            }
+            return;
+        }
+        const temp = value;
+        for (const key in temp) {
+            walk(temp[key]);
+        }
+    };
+    walk(node);
+    return used;
+};
+const getDefVariable = (node) => {
+    if (!DCE_REMOVABLE_TYPES.has(node.type)) {
+        return undefined;
+    }
+    const temp = node;
+    if (node.type === ir_1.IRNodeType.PACK_COLOR && typeof temp.result === 'string') {
+        return temp.result;
+    }
+    if (typeof temp.target !== 'string') {
+        return undefined;
+    }
+    return temp.target;
+};
+const buildLabelIndexMap = (body) => {
+    const labelIndex = new Map();
+    for (let i = 0; i < body.length; i++) {
+        const node = body[i];
+        if (node.type === ir_1.IRNodeType.LABEL) {
+            labelIndex.set(node.name, i);
+        }
+    }
+    return labelIndex;
+};
+const buildSuccessors = (body, labelIndex) => {
+    const successors = Array.from({ length: body.length }, () => []);
+    for (let i = 0; i < body.length; i++) {
+        const node = body[i];
+        const nextIndex = i + 1 < body.length ? i + 1 : undefined;
+        if (node.type === ir_1.IRNodeType.JUMP) {
+            const target = labelIndex.get(node.label);
+            if (target !== undefined) {
+                successors[i].push(target);
+            }
+            continue;
+        }
+        if (node.type === ir_1.IRNodeType.CONDITIONAL_JUMP) {
+            const target = labelIndex.get(node.label);
+            if (target !== undefined) {
+                successors[i].push(target);
+            }
+            if (nextIndex !== undefined) {
+                successors[i].push(nextIndex);
+            }
+            continue;
+        }
+        if (nextIndex !== undefined) {
+            successors[i].push(nextIndex);
+        }
+    }
+    return successors;
+};
+const removeDeadCode = (program) => {
+    const body = program.body;
+    if (body.length === 0) {
+        return {
+            program,
+            changed: false,
+        };
+    }
+    const labelIndex = buildLabelIndexMap(body);
+    const successors = buildSuccessors(body, labelIndex);
+    const useSets = body.map((node) => collectNodeUses(node));
+    const defVars = body.map((node) => getDefVariable(node));
+    const inSets = Array.from({ length: body.length }, () => new Set());
+    const outSets = Array.from({ length: body.length }, () => new Set());
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (let i = body.length - 1; i >= 0; i--) {
+            const nextOut = new Set();
+            for (const succ of successors[i]) {
+                for (const variable of inSets[succ]) {
+                    nextOut.add(variable);
+                }
+            }
+            const nextIn = new Set(useSets[i]);
+            const defVar = defVars[i];
+            for (const variable of nextOut) {
+                if (variable !== defVar) {
+                    nextIn.add(variable);
+                }
+            }
+            const outBefore = outSets[i];
+            const inBefore = inSets[i];
+            if (outBefore.size !== nextOut.size || [...outBefore].some((v) => !nextOut.has(v))) {
+                outSets[i] = nextOut;
+                changed = true;
+            }
+            if (inBefore.size !== nextIn.size || [...inBefore].some((v) => !nextIn.has(v))) {
+                inSets[i] = nextIn;
+                changed = true;
+            }
+        }
+    }
+    let removed = false;
+    const optimizedBody = body.filter((_, index) => {
+        const defVar = defVars[index];
+        if (!defVar) {
+            return true;
+        }
+        if (defVar.startsWith('@') || program.boundVariables.has(defVar)) {
+            return true;
+        }
+        if (outSets[index].has(defVar)) {
+            return true;
+        }
+        removed = true;
+        return false;
+    });
+    return {
+        program: {
+            body: optimizedBody,
+            boundVariables: program.boundVariables,
+        },
+        changed: removed,
+    };
+};
+exports.removeDeadCode = removeDeadCode;
+//# sourceMappingURL=dead-code.js.map

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

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

package/dist/optimizer/passes/merge-labels-pass.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeLabelsPass = void 0;
+const merge_labels_1 = require("../merge-labels");
+const mergeLabelsPass = (program) => {
+    const merged = (0, merge_labels_1.mergeLabels)(program);
+    const changed = merged.body.length !== program.body.length;
+    return {
+        program: merged,
+        changed,
+    };
+};
+exports.mergeLabelsPass = mergeLabelsPass;
+//# sourceMappingURL=merge-labels-pass.js.map

package/dist/optimizer/types.d.ts

@@ -0,0 +1,10 @@
+import type { SimplifiedIRProgram } from '../macro/expand-macros';
+export type OptimizerPassResult = {
+    program: SimplifiedIRProgram;
+    changed: boolean;
+};
+export type OptimizerPass = (program: SimplifiedIRProgram) => OptimizerPassResult;
+export type OptimizeOptions = {
+    maxIterations?: number;
+    passes?: OptimizerPass[];
+};

package/dist/optimizer/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/test.d.ts

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

package/dist/test.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const build_ir_1 = require("./ir/build-ir");
+const expand_macros_1 = require("./macro/expand-macros");
+const optimizer_1 = require("./optimizer/optimizer");
+const project_1 = require("./ir/project");
+const gen_asm_1 = require("./asm/gen-asm");
+const project = (0, project_1.parseProject)('test.minduscript');
+const ir = (0, build_ir_1.buildIR)(project);
+const expanded = (0, expand_macros_1.expandMacros)(ir);
+const optimized = (0, optimizer_1.optimizeIR)(expanded);
+const asm = (0, gen_asm_1.genASM)(optimized.body);
+console.log(asm);
+//# sourceMappingURL=test.js.map

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@minduscript/compiler",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    ".npmignore"
+  ],
+  "dependencies": {
+    "@minduscript/parser": "1.0.0",
+    "@minduscript/lexer": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "rimraf": "^6.1.3",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc"
+  }
+}