redscript-mc 2.2.1 → 2.4.0

package/src/__tests__/array-dynamic.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Tests for dynamic array index read: arr[i] where i is a variable.
+ *
+ * Covers:
+ * - MIR: nbt_read_dynamic instruction is emitted instead of falling back to
+ *   copy(obj) (which returned the array length, not the value)
+ * - LIR/Emit: generates a macro helper function and calls it with
+ *   `function ns:__dyn_idx_... with storage rs:macro_args`
+ * - The generated .mcfunction contains 'with storage' (function macro call)
+ * - The helper function contains the $return macro line
+ */
+
+import { compile } from '../emit/compile'
+
+// Helper: find file in compiled output by path substring
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  const f = files.find(f => f.path.includes(pathSubstr))
+  return f?.content
+}
+
+// Helper: get the content of the function file for `fnName` in namespace
+function getFunctionBody(files: { path: string; content: string }[], fnName: string, ns = 'test'): string {
+  const content = getFile(files, `${fnName}.mcfunction`)
+  if (!content) {
+    // list files for debug
+    const paths = files.map(f => f.path).join('\n')
+    throw new Error(`Function '${fnName}' not found in output. Files:\n${paths}`)
+  }
+  return content
+}
+
+describe('Dynamic array index read: arr[i]', () => {
+  const src = `
+    fn test() {
+      let nums: int[] = [10, 20, 30, 40, 50];
+      let i: int = 2;
+      i = i + 1;
+      let v: int = nums[i];
+      scoreboard_set("#out", "test", v);
+    }
+  `
+
+  let files: { path: string; content: string }[]
+  beforeAll(() => {
+    const result = compile(src, { namespace: 'test' })
+    files = result.files
+  })
+
+  test('compiles without error', () => {
+    // beforeAll would have thrown if compilation failed
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('test function contains "with storage" (macro call)', () => {
+    const body = getFunctionBody(files, 'test')
+    expect(body).toContain('with storage')
+  })
+
+  test('test function does NOT contain fallback "scoreboard players set #out test 5"', () => {
+    // Old fallback would copy the array length (5 elements) as the result
+    const body = getFunctionBody(files, 'test')
+    expect(body).not.toContain('scoreboard players set #out test 5')
+  })
+
+  test('a macro helper function is generated for the array', () => {
+    // Should have a function file matching __dyn_idx_
+    const helperFile = files.find(f => f.path.includes('__dyn_idx_'))
+    expect(helperFile).toBeDefined()
+  })
+
+  test('macro helper function contains $return run data get', () => {
+    const helperFile = files.find(f => f.path.includes('__dyn_idx_'))
+    expect(helperFile).toBeDefined()
+    expect(helperFile!.content).toContain('$return run data get')
+    expect(helperFile!.content).toContain('$(arr_idx)')
+  })
+
+  test('macro helper function references the correct array path (nums)', () => {
+    const helperFile = files.find(f => f.path.includes('__dyn_idx_'))
+    expect(helperFile).toBeDefined()
+    expect(helperFile!.content).toContain('nums[$(arr_idx)]')
+  })
+
+  test('test function stores index to rs:macro_args', () => {
+    const body = getFunctionBody(files, 'test')
+    // Should store the index value into rs:macro_args arr_idx
+    expect(body).toContain('rs:macro_args')
+  })
+})
+
+describe('Dynamic array index: constant index still uses direct nbt_read', () => {
+  const src = `
+    fn test_const() {
+      let nums: int[] = [10, 20, 30];
+      let v: int = nums[1];
+      scoreboard_set("#out", "test", v);
+    }
+  `
+
+  let files: { path: string; content: string }[]
+  beforeAll(() => {
+    const result = compile(src, { namespace: 'test' })
+    files = result.files
+  })
+
+  test('constant index does NOT generate macro call (uses direct data get)', () => {
+    const body = getFunctionBody(files, 'test_const')
+    // Direct nbt_read emits store_nbt_to_score → execute store result score ... run data get ...
+    // without 'with storage'
+    expect(body).not.toContain('with storage')
+    expect(body).toContain('data get storage')
+    expect(body).toContain('nums[1]')
+  })
+})
+
+describe('Dynamic array index: multiple arrays, separate helpers', () => {
+  const src = `
+    fn test_multi() {
+      let a: int[] = [1, 2, 3];
+      let b: int[] = [10, 20, 30];
+      let i: int = 1;
+      i = i + 0;
+      let va: int = a[i];
+      let vb: int = b[i];
+      scoreboard_set("#va", "test", va);
+      scoreboard_set("#vb", "test", vb);
+    }
+  `
+
+  let files: { path: string; content: string }[]
+  beforeAll(() => {
+    const result = compile(src, { namespace: 'test' })
+    files = result.files
+  })
+
+  test('two separate macro helpers are generated for arrays a and b', () => {
+    const helperFiles = files.filter(f => f.path.includes('__dyn_idx_'))
+    expect(helperFiles.length).toBe(2)
+  })
+
+  test('each helper references its respective array path', () => {
+    const helperFiles = files.filter(f => f.path.includes('__dyn_idx_'))
+    const contents = helperFiles.map(f => f.content).join('\n')
+    expect(contents).toContain('a[$(arr_idx)]')
+    expect(contents).toContain('b[$(arr_idx)]')
+  })
+})

package/src/__tests__/array-write.test.ts

@@ -0,0 +1,169 @@
+/**
+ * Tests for array index write: arr[i] = val (constant and dynamic index).
+ *
+ * Covers:
+ * - Parser: arr[i] = val parses as index_assign (no "Expected ';'" error)
+ * - MIR: constant index → nbt_write, dynamic index → nbt_write_dynamic
+ * - LIR/Emit: constant index uses store_score_to_nbt to path[N]
+ *             dynamic index generates a macro helper function for write
+ * - Compound assignments: arr[i] += 5 desugars to read + write
+ */
+
+import { compile } from '../emit/compile'
+
+// Helper: find file in compiled output by path substring
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  const f = files.find(f => f.path.includes(pathSubstr))
+  return f?.content
+}
+
+// Helper: get the content of the function file for `fnName` in namespace
+function getFunctionBody(files: { path: string; content: string }[], fnName: string, ns = 'test'): string {
+  const content = getFile(files, `${fnName}.mcfunction`)
+  if (!content) {
+    const paths = files.map(f => f.path).join('\n')
+    throw new Error(`Function '${fnName}' not found in output. Files:\n${paths}`)
+  }
+  return content
+}
+
+// ---------------------------------------------------------------------------
+// Constant index write: arr[1] = 99
+// ---------------------------------------------------------------------------
+describe('Constant index write: arr[1] = 99', () => {
+  const src = `
+    fn test() {
+      let nums: int[] = [10, 20, 30];
+      nums[1] = 99;
+      scoreboard_set("#out", "test", nums[1]);
+    }
+  `
+
+  let files: { path: string; content: string }[]
+  beforeAll(() => {
+    const result = compile(src, { namespace: 'test' })
+    files = result.files
+  })
+
+  test('compiles without error', () => {
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('test function contains nbt store to array path [1] (constant write)', () => {
+    const body = getFunctionBody(files, 'test')
+    // Should write to path like "nums[1]" via execute store result storage
+    expect(body).toMatch(/nums\[1\]/)
+  })
+
+  test('test function reads back from nums[1] after writing', () => {
+    const body = getFunctionBody(files, 'test')
+    // Should also read nums[1] for scoreboard_set
+    expect(body).toMatch(/nums\[1\]/)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Dynamic index write: arr[i] = 99
+// ---------------------------------------------------------------------------
+describe('Dynamic index write: arr[i] = 99', () => {
+  const src = `
+    fn test() {
+      let nums: int[] = [10, 20, 30];
+      let i: int = 1;
+      nums[i] = 99;
+      scoreboard_set("#out", "test", nums[i]);
+    }
+  `
+
+  let files: { path: string; content: string }[]
+  beforeAll(() => {
+    const result = compile(src, { namespace: 'test' })
+    files = result.files
+  })
+
+  test('compiles without error', () => {
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('test function contains "with storage" (macro call for write)', () => {
+    const body = getFunctionBody(files, 'test')
+    expect(body).toContain('with storage')
+  })
+
+  test('a __dyn_wrt_ helper function is generated', () => {
+    const helperFile = files.find(f => f.path.includes('__dyn_wrt_'))
+    expect(helperFile).toBeDefined()
+  })
+
+  test('the write helper contains a macro line with arr_idx and arr_val', () => {
+    const helperFile = files.find(f => f.path.includes('__dyn_wrt_'))
+    expect(helperFile).toBeDefined()
+    expect(helperFile!.content).toContain('$(arr_idx)')
+    expect(helperFile!.content).toContain('$(arr_val)')
+  })
+
+  test('the write helper uses data modify set value', () => {
+    const helperFile = files.find(f => f.path.includes('__dyn_wrt_'))
+    expect(helperFile!.content).toContain('data modify storage')
+    expect(helperFile!.content).toContain('set value')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Compound assignment: arr[i] += 5
+// ---------------------------------------------------------------------------
+describe('Compound index assignment: arr[i] += 5', () => {
+  const src = `
+    fn test() {
+      let nums: int[] = [10, 20, 30];
+      let i: int = 0;
+      nums[i] += 5;
+      scoreboard_set("#out", "test", nums[i]);
+    }
+  `
+
+  let files: { path: string; content: string }[]
+  beforeAll(() => {
+    const result = compile(src, { namespace: 'test' })
+    files = result.files
+  })
+
+  test('compiles without error', () => {
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('compound assignment generates both read and write macro calls', () => {
+    const body = getFunctionBody(files, 'test')
+    // Should call with storage at least twice (read for += and write + scoreboard_set read)
+    const matches = (body.match(/with storage/g) || []).length
+    expect(matches).toBeGreaterThanOrEqual(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Constant compound assignment: arr[0] += 5
+// ---------------------------------------------------------------------------
+describe('Constant compound index assignment: arr[0] += 5', () => {
+  const src = `
+    fn test() {
+      let nums: int[] = [10, 20, 30];
+      nums[0] += 5;
+      scoreboard_set("#out", "test", nums[0]);
+    }
+  `
+
+  let files: { path: string; content: string }[]
+  beforeAll(() => {
+    const result = compile(src, { namespace: 'test' })
+    files = result.files
+  })
+
+  test('compiles without error', () => {
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('test function contains array path [0] for read and write', () => {
+    const body = getFunctionBody(files, 'test')
+    expect(body).toMatch(/nums\[0\]/)
+  })
+})

package/src/__tests__/tuner/engine.test.ts

@@ -0,0 +1,260 @@
+/**
+ * Tests for the redscript tuner engine, simulator, and ln-polynomial adapter.
+ */
+
+import { search, searchSA } from '../../tuner/engine';
+import { i32, fixedMul, isOverflow } from '../../tuner/simulator';
+import { evaluate } from '../../tuner/metrics';
+import { lnPolynomialAdapter, defaultParams as lnDefaultParams } from '../../tuner/adapters/ln-polynomial';
+import { sqrtNewtonAdapter, defaultParams as sqrtDefaultParams } from '../../tuner/adapters/sqrt-newton';
+import { TunerAdapter, ParamSpec } from '../../tuner/types';
+
+// ─── simulator tests ──────────────────────────────────────────────────────────
+
+describe('simulator', () => {
+  test('i32 truncates to int32', () => {
+    expect(i32(3.7)).toBe(3);
+    expect(i32(-3.7)).toBe(-3);
+    expect(i32(2147483648)).toBe(-2147483648); // overflow wraps
+    expect(i32(0)).toBe(0);
+  });
+
+  test('fixedMul basic', () => {
+    // 10000 * 10000 / 10000 = 10000
+    expect(fixedMul(10000, 10000, 10000)).toBe(10000);
+    // 5000 * 2 / 10000 = 1
+    expect(fixedMul(5000, 2, 10000)).toBe(1);
+  });
+
+  test('fixedMul returns Infinity on overflow', () => {
+    expect(fixedMul(2147483647, 2147483647, 1)).toBe(Infinity);
+  });
+
+  test('isOverflow detects out-of-range', () => {
+    expect(isOverflow(2147483648)).toBe(true);
+    expect(isOverflow(-2147483649)).toBe(true);
+    expect(isOverflow(Infinity)).toBe(true);
+    expect(isOverflow(NaN)).toBe(true);
+    expect(isOverflow(0)).toBe(false);
+    expect(isOverflow(2147483647)).toBe(false);
+  });
+});
+
+// ─── Nelder-Mead convergence test ────────────────────────────────────────────
+
+describe('Nelder-Mead engine', () => {
+  test('converges to minimum of (x-3)^2', () => {
+    // Simple 1D minimization: minimize (x-3)^2
+    const mockAdapter: TunerAdapter = {
+      name: 'test-quadratic',
+      description: 'Minimize (x-3)^2',
+      params: [
+        { name: 'x', range: [-10, 10], integer: false } as ParamSpec,
+      ],
+      simulate(input: number, params: Record<string, number>): number {
+        // Return the residual as a scaled integer
+        const x = params['x'];
+        return Math.round(x * 10000);
+      },
+      reference(_input: number): number {
+        // Target: x = 3 → value 30000
+        return 30000;
+      },
+      sampleInputs(): number[] {
+        return [1]; // single input, target value is 3.0 (×10000 = 30000)
+      },
+      generateCode(params: Record<string, number>): string {
+        return `// x = ${params['x']}`;
+      },
+    };
+
+    const result = search(mockAdapter, 5000);
+    // Should converge close to x=3
+    expect(result.params['x']).toBeCloseTo(3.0, 1);
+    expect(result.maxError).toBeLessThan(0.1);
+  });
+
+  test('handles integer constraints', () => {
+    const mockAdapter: TunerAdapter = {
+      name: 'test-integer',
+      description: 'Integer parameter test',
+      params: [
+        { name: 'n', range: [0, 10], integer: true } as ParamSpec,
+      ],
+      simulate(input: number, params: Record<string, number>): number {
+        // Should snap to integer 7
+        return Math.round(params['n'] * 10000);
+      },
+      reference(_input: number): number {
+        return 70000; // 7.0 × 10000
+      },
+      sampleInputs(): number[] {
+        return [1];
+      },
+      generateCode(): string {
+        return '';
+      },
+    };
+
+    const result = search(mockAdapter, 2000);
+    // Should find n close to 7
+    expect(Math.round(result.params['n'])).toBe(7);
+  });
+
+  test('i32 overflow penalization', () => {
+    const mockAdapter: TunerAdapter = {
+      name: 'test-overflow',
+      description: 'Test overflow penalization',
+      params: [
+        { name: 'scale', range: [1, 1000], integer: true } as ParamSpec,
+      ],
+      simulate(_input: number, params: Record<string, number>): number {
+        // Always overflow for any scale >= 500
+        if (params['scale'] >= 500) return Infinity;
+        return params['scale'] * 10000;
+      },
+      reference(_input: number): number {
+        return 2000000; // target: scale=200 → 2000000
+      },
+      sampleInputs(): number[] {
+        return [1];
+      },
+      generateCode(): string {
+        return '';
+      },
+    };
+
+    const { maxError, mae, rmse } = evaluate(mockAdapter, { scale: 2147483647 });
+    expect(maxError).toBe(Infinity);
+    expect(mae).toBe(Infinity);
+    expect(rmse).toBe(Infinity);
+  });
+});
+
+// ─── ln-polynomial adapter tests ─────────────────────────────────────────────
+
+describe('ln-polynomial adapter', () => {
+  const defaultParams = lnDefaultParams; // { A1: 20000, A3: 6667, A5: 4000 }
+
+  test('sample inputs cover the valid range', () => {
+    const inputs = lnPolynomialAdapter.sampleInputs();
+    expect(inputs.length).toBeGreaterThan(50);
+    // All inputs should be positive
+    expect(inputs.every(x => x > 0)).toBe(true);
+  });
+
+  test('reference matches Math.log', () => {
+    const SCALE = 10000;
+    // ln(1.0) = 0
+    expect(lnPolynomialAdapter.reference(SCALE)).toBeCloseTo(0, 5);
+    // ln(2.0) ≈ 0.6931 → 6931
+    expect(lnPolynomialAdapter.reference(2 * SCALE)).toBeCloseTo(6931.47, 0);
+    // ln(0.5) ≈ -0.6931 → -6931
+    expect(lnPolynomialAdapter.reference(5000)).toBeCloseTo(-6931.47, 0);
+  });
+
+  test('simulate produces reasonable output for x=1 (no error)', () => {
+    const result = lnPolynomialAdapter.simulate(10000, defaultParams);
+    // ln(1.0) = 0; allow some approximation error
+    expect(Math.abs(result)).toBeLessThan(500); // within 0.05
+  });
+
+  test('simulate returns Infinity for invalid input', () => {
+    const result = lnPolynomialAdapter.simulate(0, defaultParams);
+    expect(result).toBeLessThan(0); // negative sentinel or -MAX_INT
+  });
+
+  test('max_error < 0.001 with default atanh coefficients', () => {
+    const metrics = evaluate(lnPolynomialAdapter, defaultParams);
+    expect(metrics.maxError).toBeLessThan(0.001);
+  }, 10000);
+
+  test('search improves over default params', () => {
+    // Run a short search and confirm it doesn't get worse
+    const baseMetrics = evaluate(lnPolynomialAdapter, defaultParams);
+    const result = search(lnPolynomialAdapter, 500); // short budget for test speed
+    // Either same or better
+    expect(result.maxError).toBeLessThanOrEqual(baseMetrics.maxError * 2);
+    expect(result.maxError).toBeLessThan(0.01);
+  }, 30000);
+
+  test('generateCode produces valid output', () => {
+    const meta = {
+      maxError: 0.00003,
+      mae: 0.000012,
+      rmse: 0.000015,
+      estimatedCmds: 38,
+      tuneDate: '2026-03-17',
+      budgetUsed: 5000,
+    };
+    const code = lnPolynomialAdapter.generateCode(defaultParams, meta);
+    expect(code).toContain('AUTO-GENERATED');
+    expect(code).toContain('ln-polynomial');
+    expect(code).toContain('fn ln');
+    expect(code).toContain('A1');
+    expect(code).toContain('A3');
+    expect(code).toContain('A5');
+    expect(code).toContain('2026-03-17');
+  });
+
+  test('searchSA achieves max_error < 0.001 on ln-polynomial', () => {
+    const result = searchSA(lnPolynomialAdapter, 3000);
+    expect(result.maxError).toBeLessThan(0.001);
+  }, 30000);
+});
+
+// ─── sqrt-newton adapter tests ────────────────────────────────────────────────
+
+describe('sqrt-newton adapter', () => {
+  test('simulate(10000, defaultParams) ≈ 10000 (sqrt(1.0)=1.0)', () => {
+    const result = sqrtNewtonAdapter.simulate(10000, sqrtDefaultParams);
+    // sqrt(1.0) * 10000 = 10000
+    expect(Math.abs(result - 10000)).toBeLessThan(10);
+  });
+
+  test('simulate(40000, defaultParams) ≈ 20000 (sqrt(4.0)=2.0)', () => {
+    const result = sqrtNewtonAdapter.simulate(40000, sqrtDefaultParams);
+    // sqrt(4.0) * 10000 = 20000
+    expect(Math.abs(result - 20000)).toBeLessThan(10);
+  });
+
+  test('simulate(0) returns 0', () => {
+    expect(sqrtNewtonAdapter.simulate(0, sqrtDefaultParams)).toBe(0);
+    expect(sqrtNewtonAdapter.simulate(-1, sqrtDefaultParams)).toBe(0);
+  });
+
+  test('simulate(250000, defaultParams) ≈ 50000 (sqrt(25.0)=5.0)', () => {
+    const result = sqrtNewtonAdapter.simulate(250000, sqrtDefaultParams);
+    expect(Math.abs(result - 50000)).toBeLessThan(10);
+  });
+
+  test('sample inputs are all positive', () => {
+    const inputs = sqrtNewtonAdapter.sampleInputs();
+    expect(inputs.length).toBeGreaterThan(50);
+    expect(inputs.every(x => x > 0)).toBe(true);
+  });
+
+  test('reference matches Math.sqrt', () => {
+    const SCALE = 10000;
+    expect(sqrtNewtonAdapter.reference(SCALE)).toBe(SCALE);          // sqrt(1.0)
+    expect(sqrtNewtonAdapter.reference(4 * SCALE)).toBe(2 * SCALE);  // sqrt(4.0)
+    expect(sqrtNewtonAdapter.reference(9 * SCALE)).toBe(3 * SCALE);  // sqrt(9.0)
+    expect(sqrtNewtonAdapter.reference(0)).toBe(0);
+  });
+
+  test('generateCode contains fn sqrt_fx', () => {
+    const meta = {
+      maxError: 1.5,
+      mae: 0.5,
+      rmse: 0.8,
+      estimatedCmds: 30,
+      tuneDate: '2026-03-17',
+      budgetUsed: 3000,
+    };
+    const code = sqrtNewtonAdapter.generateCode(sqrtDefaultParams, meta);
+    expect(code).toContain('AUTO-GENERATED');
+    expect(code).toContain('sqrt-newton');
+    expect(code).toContain('fn sqrt_fx');
+    expect(code).toContain('2026-03-17');
+  });
+});

package/src/ast/types.ts

@@ -171,6 +171,7 @@ export type Expr =
   | { kind: 'struct_lit'; fields: { name: string; value: Expr }[]; span?: Span }
   | { kind: 'member_assign'; obj: Expr; field: string; op: AssignOp; value: Expr; span?: Span }
   | { kind: 'index';      obj: Expr; index: Expr; span?: Span }
+  | { kind: 'index_assign'; obj: Expr; index: Expr; op: AssignOp; value: Expr; span?: Span }
   | { kind: 'array_lit';  elements: Expr[]; span?: Span }
   | { kind: 'static_call'; type: string; method: string; args: Expr[]; span?: Span }
   | { kind: 'path_expr'; enumName: string; variant: string; span?: Span }

package/src/emit/modules.ts

@@ -560,6 +560,11 @@ function rewriteExpr(expr: Expr, symbolMap: Map<string, string>): void {
       rewriteExpr(expr.obj, symbolMap)
       rewriteExpr(expr.index, symbolMap)
       break
+    case 'index_assign':
+      rewriteExpr(expr.obj, symbolMap)
+      rewriteExpr(expr.index, symbolMap)
+      rewriteExpr(expr.value, symbolMap)
+      break
     case 'array_lit':
       for (const el of expr.elements) rewriteExpr(el, symbolMap)
       break

package/src/hir/lower.ts

@@ -409,6 +409,36 @@ function lowerExpr(expr: Expr): HIRExpr {
     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: '=' as const,
+          value: {
+            kind: 'binary',
+            op: binOp as any,
+            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 }
 

package/src/hir/monomorphize.ts

@@ -312,6 +312,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/src/hir/types.ts

@@ -24,7 +24,7 @@ import type {
   EntityTypeName,
   LambdaParam,
 } from '../ast/types'
-import type { BinOp, CmpOp } from '../ast/types'
+import type { BinOp, CmpOp, AssignOp } from '../ast/types'
 
 // Re-export types that HIR shares with AST unchanged
 export type {
@@ -40,6 +40,7 @@ export type {
   LambdaParam,
   BinOp,
   CmpOp,
+  AssignOp,
 }
 
 // ---------------------------------------------------------------------------
@@ -77,6 +78,7 @@ export type HIRExpr =
   // Assignment — only plain '=' (compound ops desugared)
   | { kind: 'assign'; target: string; value: HIRExpr; span?: Span }
   | { kind: 'member_assign'; obj: HIRExpr; field: string; value: HIRExpr; span?: Span }
+  | { kind: 'index_assign'; obj: HIRExpr; index: HIRExpr; op: AssignOp; value: HIRExpr; span?: Span }
   // Access
   | { kind: 'member'; obj: HIRExpr; field: string; span?: Span }
   | { kind: 'index'; obj: HIRExpr; index: HIRExpr; span?: Span }