redscript-mc 2.3.0 → 2.4.0

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/typechecker/index.js

@@ -535,6 +535,11 @@ class TypeChecker {
                 this.checkExpr(expr.obj);
                 this.checkExpr(expr.value);
                 break;
+            case 'index_assign':
+                this.checkExpr(expr.obj);
+                this.checkExpr(expr.index);
+                this.checkExpr(expr.value);
+                break;
             case 'index':
                 this.checkExpr(expr.obj);
                 this.checkExpr(expr.index);

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "1.2.26",
+  "version": "1.2.34",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "1.2.26",
+      "version": "1.2.34",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../",
@@ -24,7 +24,7 @@
     },
     "../..": {
       "name": "redscript-mc",
-      "version": "2.3.0",
+      "version": "2.4.0",
       "license": "MIT",
       "dependencies": {
         "vscode-languageserver": "^9.0.1",

package/editors/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "redscript-vscode",
   "displayName": "RedScript for Minecraft",
   "description": "Syntax highlighting, error diagnostics, and language support for RedScript — a compiler targeting Minecraft Java Edition",
-  "version": "1.2.26",
+  "version": "1.2.34",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/src/index.js",
   "bin": {

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/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