redscript-mc 2.2.1 → 2.4.0

package/dist/src/hir/lower.js

@@ -360,6 +360,35 @@ function lowerExpr(expr) {
             return { kind: 'member', obj: lowerExpr(expr.obj), field: expr.field, span: expr.span };
         case 'index':
             return { kind: 'index', obj: lowerExpr(expr.obj), index: lowerExpr(expr.index), span: expr.span };
+        // --- Desugaring: compound index_assign → plain index_assign ---
+        case 'index_assign':
+            if (expr.op !== '=') {
+                const binOp = COMPOUND_TO_BINOP[expr.op];
+                const obj = lowerExpr(expr.obj);
+                const index = lowerExpr(expr.index);
+                return {
+                    kind: 'index_assign',
+                    obj,
+                    index,
+                    op: '=',
+                    value: {
+                        kind: 'binary',
+                        op: binOp,
+                        left: { kind: 'index', obj, index },
+                        right: lowerExpr(expr.value),
+                        span: expr.span,
+                    },
+                    span: expr.span,
+                };
+            }
+            return {
+                kind: 'index_assign',
+                obj: lowerExpr(expr.obj),
+                index: lowerExpr(expr.index),
+                op: expr.op,
+                value: lowerExpr(expr.value),
+                span: expr.span,
+            };
         case 'call':
             return { kind: 'call', fn: expr.fn, args: expr.args.map(lowerExpr), typeArgs: expr.typeArgs, span: expr.span };
         case 'invoke':

package/dist/src/hir/monomorphize.js

@@ -278,6 +278,8 @@ class Monomorphizer {
                 return { ...expr, value: this.rewriteExpr(expr.value, ctx) };
             case 'member_assign':
                 return { ...expr, obj: this.rewriteExpr(expr.obj, ctx), value: this.rewriteExpr(expr.value, ctx) };
+            case 'index_assign':
+                return { ...expr, obj: this.rewriteExpr(expr.obj, ctx), index: this.rewriteExpr(expr.index, ctx), value: this.rewriteExpr(expr.value, ctx) };
             case 'member':
                 return { ...expr, obj: this.rewriteExpr(expr.obj, ctx) };
             case 'index':

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

@@ -12,8 +12,8 @@
  * All types and names are preserved from the AST.
  */
 import type { Span, TypeNode, EntitySelector, CoordComponent, Decorator, RangeExpr, FStringPart, SelectorFilter, EntityTypeName, LambdaParam } from '../ast/types';
-import type { BinOp, CmpOp } from '../ast/types';
-export type { Span, TypeNode, EntitySelector, CoordComponent, Decorator, RangeExpr, FStringPart, SelectorFilter, EntityTypeName, LambdaParam, BinOp, CmpOp, };
+import type { BinOp, CmpOp, AssignOp } from '../ast/types';
+export type { Span, TypeNode, EntitySelector, CoordComponent, Decorator, RangeExpr, FStringPart, SelectorFilter, EntityTypeName, LambdaParam, BinOp, CmpOp, AssignOp, };
 export type HIRExpr = {
     kind: 'int_lit';
     value: number;
@@ -124,6 +124,13 @@ export type HIRExpr = {
     field: string;
     value: HIRExpr;
     span?: Span;
+} | {
+    kind: 'index_assign';
+    obj: HIRExpr;
+    index: HIRExpr;
+    op: AssignOp;
+    value: HIRExpr;
+    span?: Span;
 } | {
     kind: 'member';
     obj: HIRExpr;

package/dist/src/lir/lower.js

@@ -41,6 +41,10 @@ class LoweringContext {
         this.currentMIRFn = null;
         /** Block map for quick lookup */
         this.blockMap = new Map();
+        /** Track generated dynamic array macro helper functions to avoid duplicates: key → fn name */
+        this.dynIdxHelpers = new Map();
+        /** Track generated dynamic array write helper functions: key → fn name */
+        this.dynWrtHelpers = new Map();
         this.namespace = namespace;
         this.objective = objective;
     }
@@ -62,6 +66,68 @@ class LoweringContext {
     addFunction(fn) {
         this.functions.push(fn);
     }
+    /**
+     * Get or create a macro helper function for dynamic array index reads.
+     * The helper function is: $return run data get storage <ns> <pathPrefix>[$(arr_idx)] 1
+     * Returns the qualified MC function name (namespace:fnName).
+     */
+    getDynIdxHelper(ns, pathPrefix) {
+        const key = `${ns}\0${pathPrefix}`;
+        const existing = this.dynIdxHelpers.get(key);
+        if (existing)
+            return existing;
+        // Generate deterministic name from ns and pathPrefix
+        const sanitize = (s) => s.replace(/[^a-z0-9_]/gi, '_').toLowerCase();
+        // Extract just the storage name part from ns (e.g. "myns:arrays" → "myns_arrays")
+        const nsStr = sanitize(ns);
+        const prefixStr = sanitize(pathPrefix);
+        const helperName = `__dyn_idx_${nsStr}_${prefixStr}`;
+        // The helper is placed in the current namespace
+        const qualifiedName = `${this.namespace}:${helperName}`;
+        // Generate the macro function content:
+        // $return run data get storage <ns> <pathPrefix>[$(arr_idx)] 1
+        const macroLine = {
+            kind: 'macro_line',
+            template: `return run data get storage ${ns} ${pathPrefix}[$(arr_idx)] 1`,
+        };
+        this.addFunction({
+            name: helperName,
+            instructions: [macroLine],
+            isMacro: true,
+            macroParams: ['arr_idx'],
+        });
+        this.dynIdxHelpers.set(key, qualifiedName);
+        return qualifiedName;
+    }
+    /**
+     * Get or create a macro helper function for dynamic array index writes.
+     * The helper function: $data modify storage <ns> <pathPrefix>[$(arr_idx)] set value $(arr_val)
+     * Returns the qualified MC function name.
+     */
+    getDynWrtHelper(ns, pathPrefix) {
+        const key = `${ns}\0${pathPrefix}`;
+        const existing = this.dynWrtHelpers.get(key);
+        if (existing)
+            return existing;
+        const sanitize = (s) => s.replace(/[^a-z0-9_]/gi, '_').toLowerCase();
+        const nsStr = sanitize(ns);
+        const prefixStr = sanitize(pathPrefix);
+        const helperName = `__dyn_wrt_${nsStr}_${prefixStr}`;
+        const qualifiedName = `${this.namespace}:${helperName}`;
+        // Macro line: $data modify storage <ns> <pathPrefix>[$(arr_idx)] set value $(arr_val)
+        const macroLine = {
+            kind: 'macro_line',
+            template: `data modify storage ${ns} ${pathPrefix}[$(arr_idx)] set value $(arr_val)`,
+        };
+        this.addFunction({
+            name: helperName,
+            instructions: [macroLine],
+            isMacro: true,
+            macroParams: ['arr_idx', 'arr_val'],
+        });
+        this.dynWrtHelpers.set(key, qualifiedName);
+        return qualifiedName;
+    }
     /** Attach sourceLoc to newly added instructions (from the given start index onward) */
     tagSourceLoc(instrs, fromIndex, sourceLoc) {
         if (!sourceLoc)
@@ -263,6 +329,41 @@ function lowerInstrInner(instr, fn, ctx, instrs) {
             });
             break;
         }
+        case 'nbt_read_dynamic': {
+            // Strategy:
+            // 1. Store the index value into rs:macro_args __arr_idx (int)
+            // 2. Call the per-array macro helper function with 'with storage rs:macro_args'
+            // 3. Result comes back via $ret scoreboard slot (the macro uses $return)
+            const dst = ctx.slot(instr.dst);
+            const idxSlot = operandToSlot(instr.indexSrc, ctx, instrs);
+            // Step 1: store index score → rs:macro_args arr_idx (int, scale 1)
+            instrs.push({
+                kind: 'store_score_to_nbt',
+                ns: 'rs:macro_args',
+                path: 'arr_idx',
+                type: 'int',
+                scale: 1,
+                src: idxSlot,
+            });
+            // Step 2: get or create the macro helper function, then call it
+            const helperFn = ctx.getDynIdxHelper(instr.ns, instr.pathPrefix);
+            instrs.push({ kind: 'call_macro', fn: helperFn, storage: 'rs:macro_args' });
+            // Step 3: the macro uses $return which sets the MC return value.
+            // We need to capture that. In MC, $return run ... returns the result
+            // to the caller via the execute store mechanism.
+            // Use store_cmd_to_score to capture the return value of the macro call.
+            // Actually, the call_macro instruction above already ran the function.
+            // The $return run data get ... sets the scoreboard return value for the
+            // *calling* function context. We need to use execute store result score.
+            // Rewrite: use raw command instead:
+            instrs.pop(); // remove the call_macro we just added
+            instrs.push({
+                kind: 'store_cmd_to_score',
+                dst,
+                cmd: { kind: 'call_macro', fn: helperFn, storage: 'rs:macro_args' },
+            });
+            break;
+        }
         case 'nbt_write': {
             const srcSlot = operandToSlot(instr.src, ctx, instrs);
             instrs.push({
@@ -275,6 +376,36 @@ function lowerInstrInner(instr, fn, ctx, instrs) {
             });
             break;
         }
+        case 'nbt_write_dynamic': {
+            // Strategy:
+            // 1. Store index score → rs:macro_args arr_idx (int)
+            // 2. Store value score → rs:macro_args arr_val (int)
+            // 3. Call macro helper: $data modify storage <ns> <pathPrefix>[$(arr_idx)] set value $(arr_val)
+            const idxSlot = operandToSlot(instr.indexSrc, ctx, instrs);
+            const valSlot = operandToSlot(instr.valueSrc, ctx, instrs);
+            // Store index
+            instrs.push({
+                kind: 'store_score_to_nbt',
+                ns: 'rs:macro_args',
+                path: 'arr_idx',
+                type: 'int',
+                scale: 1,
+                src: idxSlot,
+            });
+            // Store value
+            instrs.push({
+                kind: 'store_score_to_nbt',
+                ns: 'rs:macro_args',
+                path: 'arr_val',
+                type: 'int',
+                scale: 1,
+                src: valSlot,
+            });
+            // Call macro helper function
+            const helperFn = ctx.getDynWrtHelper(instr.ns, instr.pathPrefix);
+            instrs.push({ kind: 'call_macro', fn: helperFn, storage: 'rs:macro_args' });
+            break;
+        }
         case 'score_read': {
             // execute store result score $dst __obj run scoreboard players get <player> <obj>
             const dst = ctx.slot(instr.dst);

package/dist/src/mir/lower.js

@@ -929,12 +929,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 +952,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 +990,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];

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/copy_prop.js

@@ -75,6 +75,10 @@ function rewriteUses(instr, copies) {
             return { ...instr, a: resolve(instr.a, copies), b: resolve(instr.b, copies) };
         case 'nbt_write':
             return { ...instr, src: resolve(instr.src, copies) };
+        case 'nbt_write_dynamic':
+            return { ...instr, indexSrc: resolve(instr.indexSrc, copies), valueSrc: resolve(instr.valueSrc, copies) };
+        case 'nbt_read_dynamic':
+            return { ...instr, indexSrc: resolve(instr.indexSrc, copies) };
         case 'call':
             return { ...instr, args: instr.args.map(a => resolve(a, copies)) };
         case 'call_macro':
@@ -104,6 +108,7 @@ function getDst(instr) {
         case 'or':
         case 'not':
         case 'nbt_read':
+        case 'nbt_read_dynamic':
             return instr.dst;
         case 'call':
         case 'call_macro':

package/dist/src/optimizer/coroutine.js

@@ -713,8 +713,12 @@ function rewriteInstr(instr, promoted) {
             return { ...instr, dst: rTemp(instr.dst), src: rOp(instr.src) };
         case 'nbt_read':
             return { ...instr, dst: rTemp(instr.dst) };
+        case 'nbt_read_dynamic':
+            return { ...instr, dst: rTemp(instr.dst), indexSrc: rOp(instr.indexSrc) };
         case 'nbt_write':
             return { ...instr, src: rOp(instr.src) };
+        case 'nbt_write_dynamic':
+            return { ...instr, indexSrc: rOp(instr.indexSrc), valueSrc: rOp(instr.valueSrc) };
         case 'call':
             return { ...instr, dst: instr.dst ? rTemp(instr.dst) : null, args: instr.args.map(rOp) };
         case 'call_macro':
@@ -770,6 +774,7 @@ function getDst(instr) {
         case 'or':
         case 'not':
         case 'nbt_read':
+        case 'nbt_read_dynamic':
             return instr.dst;
         case 'call':
         case 'call_macro':
@@ -802,6 +807,13 @@ function getUsedTemps(instr) {
         case 'nbt_write':
             addOp(instr.src);
             break;
+        case 'nbt_write_dynamic':
+            addOp(instr.indexSrc);
+            addOp(instr.valueSrc);
+            break;
+        case 'nbt_read_dynamic':
+            addOp(instr.indexSrc);
+            break;
         case 'call':
             instr.args.forEach(addOp);
             break;

package/dist/src/optimizer/dce.js

@@ -75,6 +75,7 @@ function recomputePreds(blocks) {
 function hasSideEffects(instr) {
     if (instr.kind === 'call' || instr.kind === 'call_macro' ||
         instr.kind === 'call_context' || instr.kind === 'nbt_write' ||
+        instr.kind === 'nbt_write_dynamic' ||
         instr.kind === 'score_write')
         return true;
     // Return field temps (__rf_) write to global return slots — not dead even if unused locally
@@ -106,6 +107,7 @@ function getDst(instr) {
         case 'or':
         case 'not':
         case 'nbt_read':
+        case 'nbt_read_dynamic':
             return instr.dst;
         case 'call':
         case 'call_macro':
@@ -140,6 +142,13 @@ function getUsedTemps(instr) {
         case 'nbt_write':
             addOp(instr.src);
             break;
+        case 'nbt_write_dynamic':
+            addOp(instr.indexSrc);
+            addOp(instr.valueSrc);
+            break;
+        case 'nbt_read_dynamic':
+            addOp(instr.indexSrc);
+            break;
         case 'call':
             instr.args.forEach(addOp);
             break;

package/dist/src/optimizer/unroll.js

@@ -287,6 +287,8 @@ function substituteInstr(instr, sub) {
             return { ...instr, a: substituteOp(instr.a, sub), b: substituteOp(instr.b, sub) };
         case 'nbt_write':
             return { ...instr, src: substituteOp(instr.src, sub) };
+        case 'nbt_write_dynamic':
+            return { ...instr, indexSrc: substituteOp(instr.indexSrc, sub), valueSrc: substituteOp(instr.valueSrc, sub) };
         case 'call':
             return { ...instr, args: instr.args.map(a => substituteOp(a, sub)) };
         case 'call_macro':
@@ -317,6 +319,7 @@ function getInstrDst(instr) {
         case 'or':
         case 'not':
         case 'nbt_read':
+        case 'nbt_read_dynamic':
             return instr.dst;
         case 'call':
         case 'call_macro':

package/dist/src/parser/index.js

@@ -1048,6 +1048,11 @@ class Parser {
                 const value = this.parseAssignment();
                 return this.withLoc({ kind: 'member_assign', obj: left.obj, field: left.field, op, value }, this.getLocToken(left) ?? token);
             }
+            // Index assignment: arr[0] = val, arr[i] = val
+            if (left.kind === 'index') {
+                const value = this.parseAssignment();
+                return this.withLoc({ kind: 'index_assign', obj: left.obj, index: left.index, op, value }, this.getLocToken(left) ?? token);
+            }
         }
         return left;
     }

package/dist/src/tuner/adapters/ln-polynomial.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ln(x) polynomial approximation adapter — atanh series form.
+ *
+ * Algorithm:
+ *   Input x: fixed-point integer (×10000), e.g. 10000 = 1.0
+ *   1. Range reduction: find k s.t. xr ∈ [10000, 20000)
+ *   2. s = (xr - 10000) * 10000 / (xr + 10000)   →  s ∈ [0, 3333]
+ *   3. ln(xr/10000) ≈ A1*s/SCALE + A3*s³/SCALE² + A5*s⁵/SCALE³
+ *      (coefficients absorb the factor of 2; theoretical: A1=20000, A3=6667, A5=4000)
+ *   4. ln(x/10000) = k * LN2 + ln(xr/10000)
+ *
+ * Intermediate overflow analysis (s ≤ 3333, SCALE = 10000):
+ *   s²    = s*s    ≤ 11M   — fits int32 (max ~2.1B)
+ *   s2    = s²/SCALE ≤ 1111
+ *   s3    = s*s2   ≤ 3.7M  — fits int32
+ *   s5    = s3*s2  ≤ 4.1M  — fits int32
+ *   A1*s  ≤ 22000*3333 ≤ 73M — fits int32
+ *   A3*s3 ≤ 7000*3703  ≤ 26M — fits int32
+ *   A5*s5 ≤ 5000*4115  ≤ 21M — fits int32
+ */
+import { TunerAdapter } from '../types';
+export declare const defaultParams: Record<string, number>;
+export declare const lnPolynomialAdapter: TunerAdapter;