redscript-mc 1.2.26 → 1.2.27

package/dist/lowering/index.js

@@ -130,6 +130,7 @@ const BUILTINS = {
     clearInterval: () => null, // Special handling
     storage_get_int: () => null, // Special handling (dynamic NBT array read via macro)
     storage_set_array: () => null, // Special handling (write literal NBT array to storage)
+    storage_set_int: () => null, // Special handling (dynamic NBT array write via macro)
 };
 function getSpan(node) {
     return node?.span;
@@ -339,12 +340,30 @@ class Lowering {
     }
     preScanExpr(expr, paramNames, macroParams) {
         if (expr.kind === 'call' && BUILTINS[expr.fn] !== undefined) {
-            // All ident args to macro-aware builtins that are params → macro params
-            for (const arg of expr.args) {
-                if (arg.kind === 'ident' && paramNames.has(arg.name)) {
-                    macroParams.add(arg.name);
+            // Only trigger macro param detection for builtins that actually emit
+            // MC commands with $(param) inline in the current function body.
+            // Special-handled builtins (storage_get_int / storage_set_int / etc.) are
+            // declared as `() => null` — they create their own sub-functions for macro
+            // indirection and do NOT require the surrounding function to be a macro.
+            const handler = BUILTINS[expr.fn];
+            const isSpecialHandled = (() => {
+                try {
+                    return handler() === null;
+                }
+                catch {
+                    return false;
+                }
+            })();
+            if (!isSpecialHandled) {
+                for (const arg of expr.args) {
+                    if (arg.kind === 'ident' && paramNames.has(arg.name)) {
+                        macroParams.add(arg.name);
+                    }
                 }
             }
+            // Always recurse into args for nested calls/expressions
+            for (const arg of expr.args)
+                this.preScanExpr(arg, paramNames, macroParams);
             return;
         }
         // Recurse into sub-expressions for other call types
@@ -2289,6 +2308,54 @@ class Lowering {
             this.builder.emitRaw(`data modify storage ${storageNs} ${arrayKey} set value ${nbtLiteral}`);
             return { kind: 'const', value: 0 };
         }
+        // storage_set_int(storage_ns, array_key, index, value) -> void
+        // Writes one integer element into an NBT int-array stored in data storage.
+        //   storage_ns : e.g. "rs:bigint"
+        //   array_key  : e.g. "a"
+        //   index      : element index (const or runtime)
+        //   value      : integer value to write (const or runtime)
+        //
+        // Const index + const value:
+        //   execute store result storage <ns> <key>[N] int 1 run scoreboard players set $const_V rs V
+        // Runtime index or value: macro sub-function via rs:heap
+        if (name === 'storage_set_int') {
+            const storageNs = this.exprToString(args[0]);
+            const arrayKey = this.exprToString(args[1]);
+            const indexOperand = this.lowerExpr(args[2]);
+            const valueOperand = this.lowerExpr(args[3]);
+            if (indexOperand.kind === 'const') {
+                // Static index — use execute store result to write to the fixed slot
+                const valVar = valueOperand.kind === 'var'
+                    ? valueOperand.name
+                    : this.operandToVar(valueOperand);
+                this.builder.emitRaw(`execute store result storage ${storageNs} ${arrayKey}[${indexOperand.value}] int 1 run scoreboard players get ${valVar} rs`);
+            }
+            else {
+                // Runtime index: we need a macro sub-function.
+                // Store index + value into rs:heap, call macro that does:
+                //   $data modify storage <ns> <key>[$(idx_key)] set value $(val_key)
+                const macroIdxKey = `__ssi_i_${this.foreachCounter++}`;
+                const macroValKey = `__ssi_v_${this.foreachCounter++}`; // kept to pin valVar in optimizer
+                const subFnName = `${this.currentFn}/__ssi_${this.foreachCounter++}`;
+                const indexVar = indexOperand.kind === 'var'
+                    ? indexOperand.name
+                    : this.operandToVar(indexOperand);
+                const valVar = valueOperand.kind === 'var'
+                    ? valueOperand.name
+                    : this.operandToVar(valueOperand);
+                this.builder.emitRaw(`execute store result storage rs:heap ${macroIdxKey} int 1 run scoreboard players get ${indexVar} rs`);
+                // Pin valVar in the optimizer's read-set so the assignment is not dead-code-eliminated.
+                // The value is stored to rs:heap but NOT used by the macro (the macro reads the scoreboard
+                // slot directly to avoid the MC 'data modify set value $(n)' macro substitution bug).
+                this.builder.emitRaw(`execute store result storage rs:heap ${macroValKey} int 1 run scoreboard players get ${valVar} rs`);
+                this.builder.emitRaw(`function ${this.namespace}:${subFnName} with storage rs:heap`);
+                // Use execute store result (not 'data modify set value $(val)') to avoid MC macro
+                // substitution bugs with numeric values. The scoreboard slot ${valVar} is hardcoded
+                // into the macro sub-function at compile time — only the array index is macro-substituted.
+                this.emitRawSubFunction(subFnName, `\x01execute store result storage ${storageNs} ${arrayKey}[$(${macroIdxKey})] int 1 run scoreboard players get ${valVar} rs`);
+            }
+            return { kind: 'const', value: 0 };
+        }
         // data_merge(target, nbt) — merge NBT into entity/block/storage
         // data_merge(@s, { Invisible: 1b, Silent: 1b })
         if (name === 'data_merge') {

package/dist/mathtest.map.json

@@ -0,0 +1,6 @@
+{
+  "$b": "x",
+  "$a": "const:0",
+  "$c": "internal:p0",
+  "$f": "internal:ret"
+}

package/dist/mypack.map.json

@@ -0,0 +1,27 @@
+{
+  "$o": "x",
+  "$r": "execute",
+  "$u": "y",
+  "$aa": "ax",
+  "$ad": "ay",
+  "$ai": "swapped",
+  "$ak": "tmp",
+  "$al": "lo",
+  "$am": "hi",
+  "$ar": "mid",
+  "$as": "t",
+  "$ax": "theta",
+  "$a": "const:0",
+  "$b": "const:1",
+  "$c": "const:2",
+  "$d": "const:45",
+  "$e": "const:90",
+  "$f": "const:180",
+  "$g": "const:270",
+  "$h": "const:360",
+  "$i": "const:1000",
+  "$j": "const:46340",
+  "$k": "internal:ret",
+  "$n": "internal:p0",
+  "$t": "internal:p1"
+}

package/dist/pack.mcmeta

@@ -0,0 +1,6 @@
+{
+  "pack": {
+    "pack_format": 26,
+    "description": "mypack datapack — compiled by redscript"
+  }
+}

package/dist/reqtest.map.json

@@ -0,0 +1,4 @@
+{
+  "$a": "const:42",
+  "$b": "internal:ret"
+}

package/dist/reqtest2.map.json

@@ -0,0 +1,4 @@
+{
+  "$a": "const:42",
+  "$b": "internal:ret"
+}

package/dist/runtime/index.js

@@ -647,17 +647,27 @@ class MCRuntime {
                 condition = condition && entities.length === 0;
                 continue;
             }
-            // Handle 'store result storage <ns:path> <field> <type> <scale>'
+            // Handle 'store result storage <ns:path> <field>[<idx>] <type> <scale>'  (array element)
             if (rest.startsWith('store result storage ')) {
-                rest = rest.slice(21);
-                // format: <ns:path> <field> <type> <scale> <run-cmd>
-                const storageParts = rest.match(/^(\S+)\s+(\S+)\s+(\S+)\s+([\d.]+)\s+(.*)$/);
+                const sliced = rest.slice(21);
+                // Try array-index form first: <ns:path> <field>[<idx>] <type> <scale> <run-cmd>
+                // Use [^\[\s]+ for field (no brackets or spaces) so that \[ matches correctly.
+                const arrParts = sliced.match(/^(\S+)\s+([^\[\s]+)\[(\d+)\]\s+(\S+)\s+([\d.]+)\s+(.*)$/);
+                if (arrParts) {
+                    const [, storagePath, field, indexStr, , , remaining] = arrParts;
+                    storeTarget = { storagePath, field: `${field}[${indexStr}]`, type: 'result' };
+                    rest = remaining.trim();
+                    continue;
+                }
+                // Plain form: <ns:path> <field> <type> <scale> <run-cmd>
+                const storageParts = sliced.match(/^(\S+)\s+(\S+)\s+(\S+)\s+([\d.]+)\s+(.*)$/);
                 if (storageParts) {
                     const [, storagePath, field, , , remaining] = storageParts;
                     storeTarget = { storagePath, field, type: 'result' };
                     rest = remaining.trim();
                     continue;
                 }
+                rest = sliced;
             }
             // Handle 'store result score <player> <obj>'
             if (rest.startsWith('store result score ')) {
@@ -771,8 +781,19 @@ class MCRuntime {
             }
             return true;
         }
+        // data modify storage <ns:path> <field>[<index>] set value <val>  (array element write)
+        const setArrMatch = cmd.match(/^data modify storage (\S+) ([^\[\s]+)\[(\d+)\] set value (.+)$/);
+        if (setArrMatch) {
+            const [, storagePath, field, indexStr, valueStr] = setArrMatch;
+            const arr = this.getStorageField(storagePath, field);
+            const idx = parseInt(indexStr, 10);
+            if (Array.isArray(arr) && idx >= 0 && idx < arr.length) {
+                arr[idx] = this.parseDataValue(valueStr);
+            }
+            return true;
+        }
         // data get storage <ns:path> <field>[<index>] [scale]  (array element access)
-        const getArrMatch = cmd.match(/^data get storage (\S+) (\S+)\[(\d+)\](?:\s+[\d.]+)?$/);
+        const getArrMatch = cmd.match(/^data get storage (\S+) ([^\[\s]+)\[(\d+)\](?:\s+[\d.]+)?$/);
         if (getArrMatch) {
             const [, storagePath, field, indexStr] = getArrMatch;
             const arr = this.getStorageField(storagePath, field);

package/dist/runtime.map.json

@@ -0,0 +1,7 @@
+{
+  "$d": "ticks",
+  "$a": "const:0",
+  "$b": "const:1",
+  "$c": "const:100",
+  "$i": "internal:ret"
+}

package/dist/swap_test.map.json

@@ -0,0 +1,14 @@
+{
+  "$b": "a",
+  "$d": "b",
+  "$f": "p0",
+  "$g": "p1",
+  "$h": "x",
+  "$i": "y",
+  "$k": "tmp",
+  "$n": "m",
+  "$a": "const:0",
+  "$c": "internal:p0",
+  "$e": "internal:p1",
+  "$m": "internal:ret"
+}

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "1.0.28",
+  "version": "1.0.31",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "1.0.28",
+      "version": "1.0.31",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../"

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.0.28",
+  "version": "1.0.31",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",