redscript-mc 2.4.1 → 2.6.0

package/dist/src/optimizer/constant_fold.js

@@ -9,6 +9,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.constantFold = constantFold;
+/** Wrap a JS number to Java signed int32 (MC scoreboard semantics). */
+function int32(n) {
+    return (n | 0);
+}
 function constantFold(fn) {
     return {
         ...fn,
@@ -30,27 +34,27 @@ function tryFold(instr) {
     switch (instr.kind) {
         case 'add':
             if (isConst(instr.a) && isConst(instr.b))
-                return { kind: 'const', dst: instr.dst, value: instr.a.value + instr.b.value };
+                return { kind: 'const', dst: instr.dst, value: int32(instr.a.value + instr.b.value) };
             break;
         case 'sub':
             if (isConst(instr.a) && isConst(instr.b))
-                return { kind: 'const', dst: instr.dst, value: instr.a.value - instr.b.value };
+                return { kind: 'const', dst: instr.dst, value: int32(instr.a.value - instr.b.value) };
             break;
         case 'mul':
             if (isConst(instr.a) && isConst(instr.b))
-                return { kind: 'const', dst: instr.dst, value: instr.a.value * instr.b.value };
+                return { kind: 'const', dst: instr.dst, value: int32(instr.a.value * instr.b.value) };
             break;
         case 'div':
             if (isConst(instr.a) && isConst(instr.b) && instr.b.value !== 0)
-                return { kind: 'const', dst: instr.dst, value: Math.trunc(instr.a.value / instr.b.value) };
+                return { kind: 'const', dst: instr.dst, value: int32(Math.trunc(instr.a.value / instr.b.value)) };
             break;
         case 'mod':
             if (isConst(instr.a) && isConst(instr.b) && instr.b.value !== 0)
-                return { kind: 'const', dst: instr.dst, value: instr.a.value % instr.b.value };
+                return { kind: 'const', dst: instr.dst, value: int32(instr.a.value % instr.b.value) };
             break;
         case 'neg':
             if (isConst(instr.src))
-                return { kind: 'const', dst: instr.dst, value: -instr.src.value };
+                return { kind: 'const', dst: instr.dst, value: int32(-instr.src.value) };
             break;
         case 'not':
             if (isConst(instr.src))

package/dist/src/optimizer/coroutine.js

@@ -112,18 +112,26 @@ function transformCoroutine(fn, info, objective) {
     // Continuation 1: entry block → until first yield
     // Continuation N: from loop header → until next yield or exit
     const continuations = partitionIntoContinuations(fn, loopHeaders, backEdges);
+    // Compute the dispatcher name and the exact scoreboard player for the PC slot.
+    // The LIR lowerer prefixes each temp with the function name, so the PC slot
+    // used by the dispatcher (function = `${prefix}_tick`) is:
+    //   player = `$${prefix}_tick_${pcTemp}`, obj = objective
+    // We pass this pre-computed player string into builders so they can emit
+    // side-effectful `score_write` instructions that survive DCE.
+    const dispatcherName = `${prefix}_tick`;
+    const pcPlayer = `$${dispatcherName}_${pcTemp}`;
     // Step 4: Build continuation functions with batch counting and variable promotion
     const contFunctions = [];
     for (let i = 0; i < continuations.length; i++) {
         const contId = i + 1;
         const cont = continuations[i];
-        const contFn = buildContinuationFunction(`${prefix}_cont_${contId}`, cont, info.batch, contId, continuations.length, promoted, pcTemp, batchCountTemp, objective, info.onDone, fn.name);
+        const contFn = buildContinuationFunction(`${prefix}_cont_${contId}`, cont, info.batch, contId, continuations.length, promoted, pcTemp, batchCountTemp, objective, info.onDone, fn.name, pcPlayer);
         contFunctions.push(contFn);
     }
     // Step 5: Build the init function (replaces original)
-    const initFn = buildInitFunction(fn, promoted, pcTemp, prefix, objective);
+    const initFn = buildInitFunction(fn, promoted, pcTemp, prefix, objective, pcPlayer);
     // Step 6: Build the @tick dispatcher
-    const dispatcher = buildDispatcher(`${prefix}_tick`, contFunctions, pcTemp, objective, fn.name);
+    const dispatcher = buildDispatcher(dispatcherName, contFunctions, pcTemp, objective, fn.name);
     return { initFn, continuations: contFunctions, dispatcher };
 }
 // ---------------------------------------------------------------------------
@@ -368,15 +376,15 @@ function partitionIntoContinuations(fn, loopHeaders, backEdges) {
 // ---------------------------------------------------------------------------
 // Step 4: Build continuation functions
 // ---------------------------------------------------------------------------
-function buildContinuationFunction(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone, originalFnName) {
+function buildContinuationFunction(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone, originalFnName, pcPlayer) {
     if (cont.isLoopBody) {
-        return buildLoopContinuation(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone);
+        return buildLoopContinuation(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone, pcPlayer);
     }
     else {
-        return buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objective, onDone);
+        return buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objective, onDone, pcPlayer);
     }
 }
-function buildLoopContinuation(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone) {
+function buildLoopContinuation(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone, pcPlayer) {
     // Build a new function that:
     // 1. Initializes batch_count = 0
     // 2. Runs the loop body up to `batch` iterations
@@ -451,11 +459,15 @@ function buildLoopContinuation(name, cont, batch, contId, totalConts, promoted,
             // Check if this block exits the loop
             const exitSuccs = succs.filter(s => !cont.blocks.some(b => b.id === s));
             if (exitSuccs.length > 0) {
-                // Redirect exit branch to an exit block that returns
+                // Redirect exit branch to an exit block that advances PC and returns.
+                // Setting PC to contId+1 tells the dispatcher to run the next continuation
+                // on the following tick (post-loop code / onDone).
                 const exitBlockId = `${block.id}_exit`;
                 const exitBlock = {
                     id: exitBlockId,
-                    instrs: [],
+                    instrs: [
+                        { kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: contId + 1 } },
+                    ],
                     term: { kind: 'return', value: null },
                     preds: [block.id],
                 };
@@ -506,7 +518,7 @@ function buildLoopContinuation(name, cont, batch, contId, totalConts, promoted,
         isMacro: false,
     };
 }
-function buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objective, onDone) {
+function buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objective, onDone, pcPlayer) {
     const blocks = [];
     // Rewrite blocks with promoted variables
     for (const block of cont.blocks) {
@@ -514,19 +526,20 @@ function buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objecti
     }
     // The entry is the first block in the continuation
     const entry = cont.blocks[0]?.id ?? 'entry';
-    // Add onDone call if this is the last continuation
-    if (onDone) {
-        // Find blocks with return terminators and add onDone call before them
-        for (let i = 0; i < blocks.length; i++) {
-            if (blocks[i].term.kind === 'return') {
-                blocks[i] = {
-                    ...blocks[i],
-                    instrs: [
-                        ...blocks[i].instrs,
-                        { kind: 'call', dst: null, fn: onDone, args: [] },
-                    ],
-                };
+    // Add onDone call and PC reset on completion (this is the last continuation).
+    // Setting PC=0 marks the coroutine as done so the dispatcher stops running.
+    for (let i = 0; i < blocks.length; i++) {
+        if (blocks[i].term.kind === 'return') {
+            const extraInstrs = [];
+            if (onDone) {
+                extraInstrs.push({ kind: 'call', dst: null, fn: onDone, args: [] });
             }
+            // Reset PC to 0 → dispatcher will find no matching continuation → coroutine done
+            extraInstrs.push({ kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: 0 } });
+            blocks[i] = {
+                ...blocks[i],
+                instrs: [...blocks[i].instrs, ...extraInstrs],
+            };
         }
     }
     return {
@@ -540,22 +553,55 @@ function buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objecti
 // ---------------------------------------------------------------------------
 // Step 5: Build init function (replaces original)
 // ---------------------------------------------------------------------------
-function buildInitFunction(originalFn, promoted, pcTemp, prefix, objective) {
+function buildInitFunction(originalFn, promoted, pcTemp, prefix, objective, pcPlayer) {
     // The init function:
     // 1. Sets pc = 1 (start from continuation 1)
     // 2. Initializes promoted variables from the entry block's pre-loop code
+    //
+    // NOTE: We use `score_write` (side-effectful, not removed by DCE) to write
+    // directly to the dispatcher's PC scoreboard slot.  Using `const` would
+    // write to a function-local temp (prefixed with the init-function name) which
+    // is a *different* slot from the one the dispatcher reads.
     const instrs = [];
-    // Set pc = 1
-    instrs.push({ kind: 'const', dst: pcTemp, value: 1 });
-    // Initialize promoted variables from entry block instructions
-    // Walk the entry block and copy any const/copy instructions for promoted vars
+    // Set pc = 1 via score_write so DCE cannot eliminate it
+    instrs.push({ kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: 1 } });
+    // Initialize promoted variables from entry block instructions.
+    // We must use score_write (side-effectful) rather than const/copy so that DCE
+    // does not eliminate these instructions (the dst is never read in the init fn).
+    // Continuations read promoted vars from `$${contName}_${promotedTemp}`, where
+    // contName = `${prefix}_cont_1` (the first continuation).
+    // We write to EACH continuation's slot so all continuations see the initial values.
+    // (In practice there is usually only one continuation with a loop.)
+    const dispatcherName = `${prefix}_cont_1`;
     const entryBlock = originalFn.blocks.find(b => b.id === originalFn.entry);
     if (entryBlock) {
         for (const instr of entryBlock.instrs) {
             const dst = getDst(instr);
             if (dst && promoted.has(dst)) {
-                // Rewrite to use promoted name
-                instrs.push(rewriteInstr(instr, promoted));
+                const promotedTemp = promoted.get(dst);
+                const player = `$${dispatcherName}_${promotedTemp}`;
+                if (instr.kind === 'const') {
+                    instrs.push({ kind: 'score_write', player, obj: objective, src: { kind: 'const', value: instr.value } });
+                }
+                else if (instr.kind === 'copy') {
+                    // src is an Operand; if it's a temp, resolve through promoted map
+                    let src;
+                    if (instr.src.kind === 'temp') {
+                        const srcTemp = promoted.get(instr.src.name) ?? instr.src.name;
+                        src = { kind: 'temp', name: srcTemp };
+                    }
+                    else {
+                        src = instr.src;
+                    }
+                    instrs.push({ kind: 'score_write', player, obj: objective, src });
+                }
+                else {
+                    // Fallback for other instruction types: rewrite and emit as-is.
+                    // These will have the init-function prefix, which may be wrong, but they
+                    // are uncommon — the promoted variable set only contains loop-carried vars
+                    // that are initialised with const/copy in the entry block.
+                    instrs.push(rewriteInstr(instr, promoted));
+                }
             }
         }
     }
@@ -640,13 +686,17 @@ function buildSingleContinuation(fn, info, prefix, pcTemp, objective) {
     // If there are no loops, the entire function body runs in one tick.
     // We still wrap it in the coroutine pattern for consistency (init → cont_1 → done).
     const contName = `${prefix}_cont_1`;
-    // Continuation = entire original function body, plus set pc=-1 at the end
+    const dispatcherName = `${prefix}_tick`;
+    const pcPlayer = `$${dispatcherName}_${pcTemp}`;
+    // Continuation = entire original function body, plus onDone call and PC reset at the end
     const contBlocks = fn.blocks.map(block => {
         if (block.term.kind === 'return') {
             const instrs = [...block.instrs];
             if (info.onDone) {
                 instrs.push({ kind: 'call', dst: null, fn: info.onDone, args: [] });
             }
+            // Reset PC to 0 so dispatcher stops after one run
+            instrs.push({ kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: 0 } });
             return { ...block, instrs };
         }
         return block;
@@ -658,11 +708,11 @@ function buildSingleContinuation(fn, info, prefix, pcTemp, objective) {
         entry: fn.entry,
         isMacro: false,
     };
-    // Init: set pc = 1
+    // Init: set pc = 1 via score_write (side-effectful, not removed by DCE)
     const initBlock = {
         id: 'entry',
         instrs: [
-            { kind: 'const', dst: pcTemp, value: 1 },
+            { kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: 1 } },
         ],
         term: { kind: 'return', value: null },
         preds: [],
@@ -674,7 +724,7 @@ function buildSingleContinuation(fn, info, prefix, pcTemp, objective) {
         entry: 'entry',
         isMacro: fn.isMacro,
     };
-    const dispatcher = buildDispatcher(`${prefix}_tick`, [contFn], pcTemp, objective, fn.name);
+    const dispatcher = buildDispatcher(dispatcherName, [contFn], pcTemp, objective, fn.name);
     return { initFn, continuations: [contFn], dispatcher };
 }
 // ---------------------------------------------------------------------------
@@ -719,6 +769,10 @@ function rewriteInstr(instr, promoted) {
             return { ...instr, src: rOp(instr.src) };
         case 'nbt_write_dynamic':
             return { ...instr, indexSrc: rOp(instr.indexSrc), valueSrc: rOp(instr.valueSrc) };
+        case 'score_read':
+            return { ...instr, dst: rTemp(instr.dst) };
+        case 'score_write':
+            return { ...instr, src: rOp(instr.src) };
         case 'call':
             return { ...instr, dst: instr.dst ? rTemp(instr.dst) : null, args: instr.args.map(rOp) };
         case 'call_macro':
@@ -814,6 +868,9 @@ function getUsedTemps(instr) {
         case 'nbt_read_dynamic':
             addOp(instr.indexSrc);
             break;
+        case 'score_write':
+            addOp(instr.src);
+            break;
         case 'call':
             instr.args.forEach(addOp);
             break;

package/dist/src/optimizer/lir/peephole.d.ts

@@ -1,7 +1,7 @@
 /**
  * Execute-Store Peephole Pass — LIR optimization pass.
  *
- * Merges a `call_context` immediately followed by `score_set(dst, value)`
+ * Pattern 1: Merges a `call_context` immediately followed by `score_set(dst, value)`
  * into a single `store_cmd_to_score` instruction:
  *
  *   execute [subcommands] run function ns:fn      ← call_context
@@ -11,11 +11,20 @@
  *
  *   execute store result score $result __ns [subcommands] run function ns:fn
  *
- * This saves one command when the caller only needs to know whether the
- * execute chain ran (success = 1) or to capture the function's return value.
+ * Pattern 2: Merges a `score_set(dst, 0)` immediately followed by a `raw` command
+ * of the form `execute <cond> run scoreboard players set $dst __ns 1`:
+ *
+ *   scoreboard players set $dst __ns 0            ← score_set(dst, 0)
+ *   execute <cond> run scoreboard players set $dst __ns 1  ← raw
+ *
+ * becomes:
+ *
+ *   execute store success score $dst __ns <cond>
+ *
+ * This saves one command per boolean comparison (cmp instruction lowering).
  *
  * Safety: only merges when the two instructions are immediately adjacent
- * (no instructions between them).
+ * (no instructions between them) and the destination slot is identical.
  */
 import type { LIRFunction } from '../../lir/types';
 export declare function execStorePeephole(fn: LIRFunction): LIRFunction;

package/dist/src/optimizer/lir/peephole.js

@@ -2,7 +2,7 @@
 /**
  * Execute-Store Peephole Pass — LIR optimization pass.
  *
- * Merges a `call_context` immediately followed by `score_set(dst, value)`
+ * Pattern 1: Merges a `call_context` immediately followed by `score_set(dst, value)`
  * into a single `store_cmd_to_score` instruction:
  *
  *   execute [subcommands] run function ns:fn      ← call_context
@@ -12,14 +12,33 @@
  *
  *   execute store result score $result __ns [subcommands] run function ns:fn
  *
- * This saves one command when the caller only needs to know whether the
- * execute chain ran (success = 1) or to capture the function's return value.
+ * Pattern 2: Merges a `score_set(dst, 0)` immediately followed by a `raw` command
+ * of the form `execute <cond> run scoreboard players set $dst __ns 1`:
+ *
+ *   scoreboard players set $dst __ns 0            ← score_set(dst, 0)
+ *   execute <cond> run scoreboard players set $dst __ns 1  ← raw
+ *
+ * becomes:
+ *
+ *   execute store success score $dst __ns <cond>
+ *
+ * This saves one command per boolean comparison (cmp instruction lowering).
  *
  * Safety: only merges when the two instructions are immediately adjacent
- * (no instructions between them).
+ * (no instructions between them) and the destination slot is identical.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.execStorePeephole = execStorePeephole;
+/**
+ * Regex for Pattern 2's second instruction:
+ * execute (if|unless) score ... run scoreboard players set $X OBJ 1
+ *
+ * Captures:
+ *   [1] the full condition part (everything before " run scoreboard ...")
+ *   [2] the destination player  ($X)
+ *   [3] the destination objective
+ */
+const SET_ZERO_SET_ONE_RE = /^execute (.+) run scoreboard players set (\S+) (\S+) 1$/;
 function execStorePeephole(fn) {
     const instrs = fn.instructions;
     if (instrs.length < 2)
@@ -30,7 +49,7 @@ function execStorePeephole(fn) {
     while (i < instrs.length) {
         const curr = instrs[i];
         const next = instrs[i + 1];
-        // Pattern: call_context immediately followed by score_set
+        // Pattern 1: call_context immediately followed by score_set
         if (next &&
             curr.kind === 'call_context' &&
             next.kind === 'score_set') {
@@ -44,6 +63,26 @@ function execStorePeephole(fn) {
             i += 2;
             continue;
         }
+        // Pattern 2: score_set(dst, 0) + raw("execute <cond> run scoreboard players set $dst OBJ 1")
+        // → raw("execute store success score $dst OBJ <cond>")
+        if (next &&
+            curr.kind === 'score_set' &&
+            curr.value === 0 &&
+            next.kind === 'raw') {
+            const m = SET_ZERO_SET_ONE_RE.exec(next.cmd);
+            if (m &&
+                m[2] === curr.dst.player &&
+                m[3] === curr.dst.obj) {
+                const cond = m[1];
+                result.push({
+                    kind: 'raw',
+                    cmd: `execute store success score ${curr.dst.player} ${curr.dst.obj} ${cond}`,
+                });
+                changed = true;
+                i += 2;
+                continue;
+            }
+        }
         result.push(curr);
         i++;
     }

package/dist/src/parser/index.d.ts

@@ -16,6 +16,8 @@ export declare class Parser {
      *  `librarySources` compile option, each source is parsed by its own fresh
      *  Parser instance, so this flag never bleeds into user code. */
     private inLibraryMode;
+    /** Warnings accumulated during parsing (e.g. deprecated keyword usage). */
+    readonly warnings: string[];
     constructor(tokens: Token[], source?: string, filePath?: string);
     private peek;
     private advance;
@@ -72,6 +74,8 @@ export declare class Parser {
      */
     private tryParseTypeArgs;
     private parsePostfixExpr;
+    /** Returns true if the current 'as' token is a type cast (not a context block) */
+    private isTypeCastAs;
     private parseArgs;
     private parsePrimaryExpr;
     private parseLiteralExpr;