redscript-mc 2.3.0 → 2.4.1

package/dist/src/mir/lower.js

@@ -49,9 +49,16 @@ function lowerToMIR(hir, sourceFile) {
         }
     }
     const timerCounter = { count: 0, timerId: 0 };
+    // Build HIR function map for array-arg monomorphization
+    const hirFnMap = new Map();
+    for (const f of hir.functions) {
+        hirFnMap.set(f.name, f);
+    }
+    // Shared registry: specializedName → [mirFn, ...helpers]
+    const specializedFnsRegistry = new Map();
     const allFunctions = [];
     for (const f of hir.functions) {
-        const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter);
+        const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter, undefined, hirFnMap, specializedFnsRegistry);
         allFunctions.push(fn, ...helpers);
     }
     // Lower impl block methods
@@ -61,6 +68,10 @@ function lowerToMIR(hir, sourceFile) {
             allFunctions.push(fn, ...helpers);
         }
     }
+    // Add all specialized (array-monomorphized) functions
+    for (const fns of specializedFnsRegistry.values()) {
+        allFunctions.push(...fns);
+    }
     return {
         functions: allFunctions,
         namespace: hir.namespace,
@@ -91,6 +102,10 @@ class FnContext {
         this.sourceFile = undefined;
         /** Tracks temps whose values are known compile-time constants (for Timer static ID propagation) */
         this.constTemps = new Map();
+        /** HIR function definitions for array-arg monomorphization */
+        this.hirFunctions = new Map();
+        /** Shared registry of already-generated specialized (monomorphized) MIR functions */
+        this.specializedFnsRegistry = new Map();
         this.namespace = namespace;
         this.fnName = fnName;
         this.structDefs = structDefs;
@@ -156,19 +171,40 @@ class FnContext {
 // ---------------------------------------------------------------------------
 // Function lowering
 // ---------------------------------------------------------------------------
-function lowerFunction(fn, namespace, structDefs = new Map(), implMethods = new Map(), macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), sourceFile, timerCounter = { count: 0, timerId: 0 }) {
-    const ctx = new FnContext(namespace, fn.name, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter);
+function lowerFunction(fn, namespace, structDefs = new Map(), implMethods = new Map(), macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), sourceFile, timerCounter = { count: 0, timerId: 0 }, 
+/** Pre-bound array variable info for array-parameter monomorphization */
+arrayArgBindings, 
+/** HIR function map for generating specialized callees */
+hirFnMap, 
+/** Shared registry of already-generated specialized MIR functions */
+specializedFnsRegistry, 
+/** Override the MIR function name (used when generating specialized versions) */
+overrideName) {
+    const mirFnName = overrideName ?? fn.name;
+    const ctx = new FnContext(namespace, mirFnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter);
     ctx.sourceFile = sourceFile;
+    if (hirFnMap)
+        ctx.hirFunctions = hirFnMap;
+    if (specializedFnsRegistry)
+        ctx.specializedFnsRegistry = specializedFnsRegistry;
     const fnMacroInfo = macroInfo.get(fn.name);
-    // Create temps for parameters
-    const params = fn.params.map(p => {
-        const t = ctx.freshTemp();
-        return { name: t, isMacroParam: fnMacroInfo?.macroParams.has(p.name) ?? false };
-    });
-    // Map parameter names to their temps
+    // Pre-populate arrayVars from caller-provided array bindings
+    if (arrayArgBindings) {
+        for (const [paramName, arrInfo] of arrayArgBindings) {
+            ctx.arrayVars.set(paramName, arrInfo);
+        }
+    }
+    // Create temps for parameters, skipping array-type params that are pre-bound
+    const params = [];
     const scope = new Map();
-    fn.params.forEach((p, i) => {
-        scope.set(p.name, params[i].name);
+    fn.params.forEach((p) => {
+        if (p.type.kind === 'array' && arrayArgBindings?.has(p.name)) {
+            // Array param already bound via arrayVars; no scoreboard slot needed
+            return;
+        }
+        const t = ctx.freshTemp();
+        params.push({ name: t, isMacroParam: fnMacroInfo?.macroParams.has(p.name) ?? false });
+        scope.set(p.name, t);
     });
     lowerBlock(fn.body, ctx, scope);
     // If the current block doesn't have a real terminator, add void return
@@ -182,7 +218,7 @@ function lowerFunction(fn, namespace, structDefs = new Map(), implMethods = new
     // Fill predecessor lists
     computePreds(liveBlocks);
     const result = {
-        name: fn.name,
+        name: mirFnName,
         params,
         blocks: liveBlocks,
         entry: 'entry',
@@ -929,12 +965,20 @@ function lowerExpr(expr, ctx, scope) {
             return { kind: 'temp', name: t };
         }
         case 'index': {
-            // Check if obj is a tracked array variable with a constant index
+            // Check if obj is a tracked array variable
             if (expr.obj.kind === 'ident') {
                 const arrInfo = ctx.arrayVars.get(expr.obj.name);
-                if (arrInfo && expr.index.kind === 'int_lit') {
+                if (arrInfo) {
                     const t = ctx.freshTemp();
-                    ctx.emit({ kind: 'nbt_read', dst: t, ns: arrInfo.ns, path: `${arrInfo.pathPrefix}[${expr.index.value}]`, scale: 1 });
+                    if (expr.index.kind === 'int_lit') {
+                        // Constant index: direct NBT read
+                        ctx.emit({ kind: 'nbt_read', dst: t, ns: arrInfo.ns, path: `${arrInfo.pathPrefix}[${expr.index.value}]`, scale: 1 });
+                    }
+                    else {
+                        // Dynamic index: emit nbt_read_dynamic
+                        const idxOp = lowerExpr(expr.index, ctx, scope);
+                        ctx.emit({ kind: 'nbt_read_dynamic', dst: t, ns: arrInfo.ns, pathPrefix: arrInfo.pathPrefix, indexSrc: idxOp });
+                    }
                     return { kind: 'temp', name: t };
                 }
             }
@@ -944,6 +988,25 @@ function lowerExpr(expr, ctx, scope) {
             ctx.emit({ kind: 'copy', dst: t, src: obj });
             return { kind: 'temp', name: t };
         }
+        case 'index_assign': {
+            const valOp = lowerExpr(expr.value, ctx, scope);
+            if (expr.obj.kind === 'ident') {
+                const arrInfo = ctx.arrayVars.get(expr.obj.name);
+                if (arrInfo) {
+                    if (expr.index.kind === 'int_lit') {
+                        // constant index → direct nbt_write
+                        ctx.emit({ kind: 'nbt_write', ns: arrInfo.ns, path: `${arrInfo.pathPrefix}[${expr.index.value}]`, type: 'int', scale: 1, src: valOp });
+                    }
+                    else {
+                        // dynamic index → nbt_write_dynamic
+                        const idxOp = lowerExpr(expr.index, ctx, scope);
+                        ctx.emit({ kind: 'nbt_write_dynamic', ns: arrInfo.ns, pathPrefix: arrInfo.pathPrefix, indexSrc: idxOp, valueSrc: valOp });
+                    }
+                    return valOp;
+                }
+            }
+            return valOp;
+        }
         case 'call': {
             // Handle scoreboard_get / score — read from vanilla MC scoreboard
             if (expr.fn === 'scoreboard_get' || expr.fn === 'score') {
@@ -963,6 +1026,49 @@ function lowerExpr(expr, ctx, scope) {
                 ctx.emit({ kind: 'const', dst: t, value: 0 });
                 return { kind: 'temp', name: t };
             }
+            // Handle list_push(arr_name, val) — append an int to an NBT int array
+            // list_push("rs:lists", "mylist", val) or simpler: uses the array's storage path
+            if (expr.fn === 'list_push') {
+                // list_push(array_var, value)
+                // 1. Append a placeholder 0
+                // 2. Overwrite [-1] with the actual value
+                if (expr.args[0].kind === 'ident') {
+                    const arrInfo = ctx.arrayVars.get(expr.args[0].name);
+                    if (arrInfo) {
+                        const valOp = lowerExpr(expr.args[1], ctx, scope);
+                        // Step 1: append placeholder
+                        ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${arrInfo.ns} ${arrInfo.pathPrefix} append value 0`, args: [] });
+                        // Step 2: overwrite last element with actual value
+                        ctx.emit({ kind: 'nbt_write', ns: arrInfo.ns, path: `${arrInfo.pathPrefix}[-1]`, type: 'int', scale: 1, src: valOp });
+                        const t = ctx.freshTemp();
+                        ctx.emit({ kind: 'const', dst: t, value: 0 });
+                        return { kind: 'temp', name: t };
+                    }
+                }
+            }
+            // Handle list_pop(arr_var) — remove last element from NBT int array
+            if (expr.fn === 'list_pop') {
+                if (expr.args[0].kind === 'ident') {
+                    const arrInfo = ctx.arrayVars.get(expr.args[0].name);
+                    if (arrInfo) {
+                        ctx.emit({ kind: 'call', dst: null, fn: `__raw:data remove storage ${arrInfo.ns} ${arrInfo.pathPrefix}[-1]`, args: [] });
+                        const t = ctx.freshTemp();
+                        ctx.emit({ kind: 'const', dst: t, value: 0 });
+                        return { kind: 'temp', name: t };
+                    }
+                }
+            }
+            // Handle list_len(arr_var) — get length of NBT int array
+            if (expr.fn === 'list_len') {
+                if (expr.args[0].kind === 'ident') {
+                    const arrInfo = ctx.arrayVars.get(expr.args[0].name);
+                    if (arrInfo) {
+                        const t = ctx.freshTemp();
+                        ctx.emit({ kind: 'nbt_read', dst: t, ns: arrInfo.ns, path: `${arrInfo.pathPrefix}`, scale: 1 });
+                        return { kind: 'temp', name: t };
+                    }
+                }
+            }
             // Handle setTimeout/setInterval: lift lambda arg to a named helper function
             if ((expr.fn === 'setTimeout' || expr.fn === 'setInterval') && expr.args.length === 2) {
                 const ticksArg = expr.args[0];
@@ -1079,6 +1185,51 @@ function lowerExpr(expr, ctx, scope) {
                 ctx.emit({ kind: 'call_macro', dst: t, fn: expr.fn, args: macroArgs });
                 return { kind: 'temp', name: t };
             }
+            // --- Array-parameter monomorphization ---
+            // Detect if any argument is an array variable; if so, generate a
+            // specialized callee version with array info pre-bound (per call-site).
+            {
+                const targetHirFn = ctx.hirFunctions.get(expr.fn);
+                if (targetHirFn && ctx.specializedFnsRegistry) {
+                    const arrayArgBindings = new Map();
+                    for (let i = 0; i < expr.args.length; i++) {
+                        const arg = expr.args[i];
+                        if (arg.kind === 'ident' && ctx.arrayVars.has(arg.name)) {
+                            const paramName = targetHirFn.params[i]?.name;
+                            if (paramName) {
+                                arrayArgBindings.set(paramName, ctx.arrayVars.get(arg.name));
+                            }
+                        }
+                    }
+                    if (arrayArgBindings.size > 0) {
+                        // Build a deterministic specialized function name from the array bindings
+                        const bindingKey = [...arrayArgBindings.entries()]
+                            .sort(([a], [b]) => a.localeCompare(b))
+                            .map(([p, { ns, pathPrefix }]) => `${p}__${ns.replace(/[^a-zA-Z0-9]/g, '_')}__${pathPrefix.replace(/[^a-zA-Z0-9]/g, '_')}`)
+                            .join('__');
+                        const specializedName = `${expr.fn}__arr_${bindingKey}`;
+                        // Generate the specialized function if not already done
+                        if (!ctx.specializedFnsRegistry.has(specializedName)) {
+                            // Placeholder to prevent re-entry
+                            ctx.specializedFnsRegistry.set(specializedName, []);
+                            const { fn: specFn, helpers: specHelpers } = lowerFunction(targetHirFn, ctx.getNamespace(), ctx.structDefs, ctx.implMethods, ctx.macroInfo, ctx.fnParamInfo, ctx.enumDefs, ctx.sourceFile, ctx.timerCounter, arrayArgBindings, ctx.hirFunctions, ctx.specializedFnsRegistry, specializedName);
+                            ctx.specializedFnsRegistry.set(specializedName, [specFn, ...specHelpers]);
+                        }
+                        // Emit call to the specialized function, passing only non-array args
+                        const nonArrayArgs = [];
+                        for (let i = 0; i < expr.args.length; i++) {
+                            const param = targetHirFn.params[i];
+                            if (!param || param.type.kind !== 'array' || !arrayArgBindings.has(param.name)) {
+                                nonArrayArgs.push(lowerExpr(expr.args[i], ctx, scope));
+                            }
+                        }
+                        const t = ctx.freshTemp();
+                        ctx.emit({ kind: 'call', dst: t, fn: specializedName, args: nonArrayArgs });
+                        return { kind: 'temp', name: t };
+                    }
+                }
+            }
+            // --- end array monomorphization ---
             const args = expr.args.map(a => lowerExpr(a, ctx, scope));
             const t = ctx.freshTemp();
             ctx.emit({ kind: 'call', dst: t, fn: expr.fn, args });

package/dist/src/mir/macro.js

@@ -139,6 +139,11 @@ function scanExpr(expr, paramNames, macroParams) {
             scanExpr(expr.obj, paramNames, macroParams);
             scanExpr(expr.value, paramNames, macroParams);
             break;
+        case 'index_assign':
+            scanExpr(expr.obj, paramNames, macroParams);
+            scanExpr(expr.index, paramNames, macroParams);
+            scanExpr(expr.value, paramNames, macroParams);
+            break;
         case 'member':
             scanExpr(expr.obj, paramNames, macroParams);
             break;

package/dist/src/mir/types.d.ts

@@ -130,6 +130,12 @@ export type MIRInstr = MIRInstrBase & ({
     ns: string;
     path: string;
     scale: number;
+} | {
+    kind: 'nbt_read_dynamic';
+    dst: Temp;
+    ns: string;
+    pathPrefix: string;
+    indexSrc: Operand;
 } | {
     kind: 'nbt_write';
     ns: string;
@@ -137,6 +143,12 @@ export type MIRInstr = MIRInstrBase & ({
     type: NBTType;
     scale: number;
     src: Operand;
+} | {
+    kind: 'nbt_write_dynamic';
+    ns: string;
+    pathPrefix: string;
+    indexSrc: Operand;
+    valueSrc: Operand;
 } | {
     kind: 'score_read';
     dst: Temp;

package/dist/src/mir/verify.js

@@ -155,6 +155,7 @@ function getDst(instr) {
         case 'or':
         case 'not':
         case 'nbt_read':
+        case 'nbt_read_dynamic':
             return instr.dst;
         case 'call':
         case 'call_macro':
@@ -188,9 +189,15 @@ function getUsedTemps(instr) {
             break;
         case 'nbt_read':
             break;
+        case 'nbt_read_dynamic':
+            temps.push(...getOperandTemps(instr.indexSrc));
+            break;
         case 'nbt_write':
             temps.push(...getOperandTemps(instr.src));
             break;
+        case 'nbt_write_dynamic':
+            temps.push(...getOperandTemps(instr.indexSrc), ...getOperandTemps(instr.valueSrc));
+            break;
         case 'call':
             for (const arg of instr.args)
                 temps.push(...getOperandTemps(arg));

package/dist/src/optimizer/commands.d.ts

@@ -0,0 +1,38 @@
+import type { IRCommand } from '../ir/types';
+export interface OptimizationStats {
+    licmHoists: number;
+    licmLoopBodies: number;
+    cseRedundantReads: number;
+    cseArithmetic: number;
+    setblockMergedCommands: number;
+    setblockFillCommands: number;
+    setblockSavedCommands: number;
+    deadCodeRemoved: number;
+    constantFolds: number;
+    inlinedTrivialFunctions: number;
+    totalCommandsBefore: number;
+    totalCommandsAfter: number;
+}
+export interface CommandFunction {
+    name: string;
+    commands: IRCommand[];
+}
+export declare function setOptimizerObjective(obj: string): void;
+export declare function createEmptyOptimizationStats(): OptimizationStats;
+export declare function mergeOptimizationStats(base: OptimizationStats, delta: Partial<OptimizationStats>): void;
+export declare function applyLICM(functions: CommandFunction[]): {
+    functions: CommandFunction[];
+    stats: OptimizationStats;
+};
+export declare function applyCSE(functions: CommandFunction[]): {
+    functions: CommandFunction[];
+    stats: OptimizationStats;
+};
+export declare function batchSetblocks(functions: CommandFunction[]): {
+    functions: CommandFunction[];
+    stats: OptimizationStats;
+};
+export declare function optimizeCommandFunctions(functions: CommandFunction[]): {
+    functions: CommandFunction[];
+    stats: OptimizationStats;
+};