redscript-mc 2.5.0 → 2.6.2

package/src/__tests__/emit/compile.test.ts

@@ -0,0 +1,102 @@
+import { compile } from '../../emit/compile'
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  return files.find(f => f.path.includes(pathSubstr))?.content
+}
+
+describe('emit: compile coverage', () => {
+  test('control-flow statements generate emit-time branching artifacts', () => {
+    const source = `
+      fn flow(): void {
+        let total: int = 0;
+        let arr: int[] = [1, 2, 3];
+
+        if (total == 0) {
+          total = 1;
+        } else {
+          total = 2;
+        }
+
+        while (total < 3) {
+          total = total + 1;
+        }
+
+        for i in 0..=2 {
+          total = total + i;
+        }
+
+        for x in arr {
+          total = total + x;
+        }
+
+        match total {
+          0 => { total = 10; }
+          _ => { total = 11; }
+        }
+
+        scoreboard_set("#out", "emit_cf", total);
+      }
+    `
+
+    const result = compile(source, { namespace: 'emit_cf' })
+    const main = getFile(result.files, 'flow.mcfunction')
+    const allPaths = result.files.map(f => f.path)
+    const allContent = result.files.map(f => f.content).join('\n')
+
+    expect(main).toBeDefined()
+    expect(allPaths.some(path => path.includes('__loop_header_'))).toBe(true)
+    expect(allPaths.some(path => path.includes('__loop_body_'))).toBe(true)
+    expect(allPaths.some(path => path.includes('__loop_exit_'))).toBe(true)
+    expect(allPaths.some(path => path.includes('__match_arm_'))).toBe(true)
+    expect(allPaths.some(path => path.includes('__match_merge_'))).toBe(true)
+    expect(allPaths.some(path => path.includes('__dyn_idx_emit_cf_arrays_arr'))).toBe(true)
+    expect(allContent).toContain('execute if score')
+    expect(allContent).toContain('with storage')
+  })
+
+  test('edge cases for empty, single-line, and nested-call functions compile cleanly', () => {
+    const source = `
+      fn empty(): void {}
+
+      fn single(): int { return 1; }
+
+      fn nested(): int {
+        return single() + single();
+      }
+    `
+
+    const result = compile(source, { namespace: 'emit_edge' })
+    const empty = getFile(result.files, 'empty.mcfunction')
+    const single = getFile(result.files, 'single.mcfunction')
+    const nested = getFile(result.files, 'nested.mcfunction')
+
+    expect(empty).toBe('\n')
+    expect(single).toContain('scoreboard players set')
+    expect(nested).toContain('function emit_edge:single')
+  })
+
+  test('special builtins raw, scoreboard interop, tell, and setblock emit expected commands', () => {
+    const source = `
+      fn builtins(): void {
+        raw("say hi");
+        tell(@s, "ok");
+        setblock((1, 2, 3), "minecraft:stone");
+        let current: int = scoreboard_get("#p", "obj");
+        scoreboard_set("#p", "obj", current);
+        scoreboard_add("#p", "obj", 1);
+      }
+    `
+
+    const result = compile(source, { namespace: 'emit_builtin' })
+    const fn = getFile(result.files, 'builtins.mcfunction')
+
+    expect(fn).toBeDefined()
+    expect(fn).toContain('say hi')
+    expect(fn).toContain('tellraw @s {"text":"ok"}')
+    expect(fn).toContain('setblock 1 2 3 minecraft:stone')
+    expect(fn).toContain('execute store result score $')
+    expect(fn).toContain('run scoreboard players get #p obj')
+    expect(fn).toContain('execute store result score #p obj run scoreboard players get')
+    expect(fn).toContain('function emit_builtin:scoreboard_add')
+  })
+})

package/src/__tests__/emit/index.test.ts

@@ -0,0 +1,189 @@
+import { emit } from '../../emit'
+import type { LIRModule, LIRFunction, LIRInstr } from '../../lir/types'
+import { McVersion } from '../../types/mc-version'
+
+function getFile(files: { path: string; content: string }[], path: string): string {
+  const file = files.find(f => f.path === path)
+  if (!file) {
+    throw new Error(`Missing file: ${path}\nFiles:\n${files.map(f => f.path).join('\n')}`)
+  }
+  return file.content
+}
+
+describe('emit: direct LIR emission', () => {
+  test('emits datapack files, source maps, tags, schedule wrappers, and modern instruction variants', () => {
+    const sourceLoc = { file: 'src/test.mcrs', line: 3, col: 5 }
+    const instructions: LIRInstr[] = [
+      { kind: 'score_set', dst: { player: '$a', obj: '__emit' }, value: 7, sourceLoc },
+      { kind: 'score_copy', dst: { player: '$b', obj: '__emit' }, src: { player: '$a', obj: '__emit' }, sourceLoc },
+      { kind: 'score_add', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+      { kind: 'score_sub', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+      { kind: 'score_mul', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+      { kind: 'score_div', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+      { kind: 'score_mod', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+      { kind: 'score_min', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+      { kind: 'score_max', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+      { kind: 'score_swap', a: { player: '$a', obj: '__emit' }, b: { player: '$b', obj: '__emit' }, sourceLoc },
+      {
+        kind: 'store_cmd_to_score',
+        dst: { player: '$stored', obj: '__emit' },
+        cmd: { kind: 'raw', cmd: 'say nested-store' },
+        sourceLoc,
+      },
+      {
+        kind: 'store_score_to_nbt',
+        ns: 'rs:data',
+        path: 'value.path',
+        type: 'int',
+        scale: 2,
+        src: { player: '$a', obj: '__emit' },
+        sourceLoc,
+      },
+      {
+        kind: 'store_nbt_to_score',
+        dst: { player: '$from_nbt', obj: '__emit' },
+        ns: 'rs:data',
+        path: 'value.path',
+        scale: 2.5,
+        sourceLoc,
+      },
+      { kind: 'nbt_set_literal', ns: 'rs:data', path: 'literal.path', value: '{foo:1b}', sourceLoc },
+      { kind: 'nbt_copy', srcNs: 'rs:src', srcPath: 'foo', dstNs: 'rs:dst', dstPath: 'bar', sourceLoc },
+      { kind: 'call', fn: 'emitns:helper', sourceLoc },
+      { kind: 'call_macro', fn: 'emitns:macro_helper', storage: 'rs:macro_args', sourceLoc },
+      { kind: 'call_if_matches', fn: 'emitns:matches', slot: { player: '$a', obj: '__emit' }, range: '1..5', sourceLoc },
+      { kind: 'call_unless_matches', fn: 'emitns:unless_matches', slot: { player: '$a', obj: '__emit' }, range: '0', sourceLoc },
+      { kind: 'call_if_score', fn: 'emitns:if_score', a: { player: '$a', obj: '__emit' }, op: 'eq', b: { player: '$b', obj: '__emit' }, sourceLoc },
+      { kind: 'call_unless_score', fn: 'emitns:unless_score', a: { player: '$a', obj: '__emit' }, op: 'ne', b: { player: '$b', obj: '__emit' }, sourceLoc },
+      {
+        kind: 'call_context',
+        fn: 'emitns:ctx',
+        subcommands: [
+          { kind: 'as', selector: '@a' },
+          { kind: 'at', selector: '@e[type=marker]' },
+          { kind: 'at_self' },
+          { kind: 'positioned', x: '~1', y: '~2', z: '~3' },
+          { kind: 'rotated', yaw: '~', pitch: '~10' },
+          { kind: 'in', dimension: 'minecraft:the_nether' },
+          { kind: 'anchored', anchor: 'eyes' },
+          { kind: 'if_score', a: '$a __emit', op: 'lt', b: '$b __emit' },
+          { kind: 'unless_score', a: '$a __emit', op: 'ge', b: '$b __emit' },
+          { kind: 'if_matches', score: '$a __emit', range: '1..' },
+          { kind: 'unless_matches', score: '$b __emit', range: '..0' },
+        ],
+        sourceLoc,
+      },
+      { kind: 'return_value', slot: { player: '$a', obj: '__emit' }, sourceLoc },
+      { kind: 'macro_line', template: 'tp @s $(x) $(y) $(z)', sourceLoc },
+      { kind: 'raw', cmd: 'say raw tail', sourceLoc },
+    ]
+
+    const mainFn: LIRFunction = {
+      name: 'Main::Run',
+      instructions,
+      isMacro: false,
+      macroParams: [],
+    }
+    const emptyFn: LIRFunction = {
+      name: 'Empty',
+      instructions: [],
+      isMacro: false,
+      macroParams: [],
+    }
+    const module: LIRModule = {
+      functions: [mainFn, emptyFn],
+      namespace: 'emitns',
+      objective: '__emit',
+    }
+
+    const files = emit(module, {
+      namespace: 'emitns',
+      tickFunctions: ['tick_fn'],
+      loadFunctions: ['bootstrap'],
+      scheduleFunctions: [{ name: 'later', ticks: 5 }],
+      generateSourceMap: true,
+      mcVersion: McVersion.v1_21,
+      eventHandlers: new Map([
+        ['PlayerJoin', ['emitns:on_join']],
+        ['BlockBreak', []],
+        ['UnknownEvent', ['emitns:ignored']],
+      ]),
+    })
+
+    expect(JSON.parse(getFile(files, 'pack.mcmeta')).pack.description).toContain('emitns')
+    expect(getFile(files, 'data/emitns/function/load.mcfunction')).toBe('scoreboard objectives add __emit dummy\n')
+
+    const main = getFile(files, 'data/emitns/function/main/run.mcfunction')
+    expect(main).toContain('scoreboard players set $a __emit 7')
+    expect(main).toContain('scoreboard players operation $b __emit = $a __emit')
+    expect(main).toContain('scoreboard players operation $a __emit += $b __emit')
+    expect(main).toContain('scoreboard players operation $a __emit -= $b __emit')
+    expect(main).toContain('scoreboard players operation $a __emit *= $b __emit')
+    expect(main).toContain('scoreboard players operation $a __emit /= $b __emit')
+    expect(main).toContain('scoreboard players operation $a __emit %= $b __emit')
+    expect(main).toContain('scoreboard players operation $a __emit < $b __emit')
+    expect(main).toContain('scoreboard players operation $a __emit > $b __emit')
+    expect(main).toContain('scoreboard players operation $a __emit >< $b __emit')
+    expect(main).toContain('execute store result score $stored __emit run say nested-store')
+    expect(main).toContain('execute store result storage rs:data value.path int 2 run scoreboard players get $a __emit')
+    expect(main).toContain('execute store result score $from_nbt __emit run data get storage rs:data value.path 2.5')
+    expect(main).toContain('data modify storage rs:data literal.path set value {foo:1b}')
+    expect(main).toContain('data modify storage rs:dst bar set from storage rs:src foo')
+    expect(main).toContain('function emitns:helper')
+    expect(main).toContain('function emitns:macro_helper with storage rs:macro_args')
+    expect(main).toContain('execute if score $a __emit matches 1..5 run function emitns:matches')
+    expect(main).toContain('execute unless score $a __emit matches 0 run function emitns:unless_matches')
+    expect(main).toContain('execute if score $a __emit = $b __emit run function emitns:if_score')
+    expect(main).toContain('execute unless score $a __emit = $b __emit run function emitns:unless_score')
+    expect(main).toContain('execute as @a at @e[type=marker] at @s positioned ~1 ~2 ~3 rotated ~ ~10 in minecraft:the_nether anchored eyes if score $a __emit < $b __emit unless score $a __emit >= $b __emit if score $a __emit matches 1.. unless score $b __emit matches ..0 run function emitns:ctx')
+    expect(main).toContain('scoreboard players operation $ret __emit = $a __emit')
+    expect(main).toContain('$tp @s $(x) $(y) $(z)')
+    expect(main).toContain('say raw tail')
+
+    expect(getFile(files, 'data/emitns/function/empty.mcfunction')).toBe('\n')
+    expect(getFile(files, 'data/emitns/function/_schedule_later.mcfunction')).toBe('schedule function emitns:later 5t\n')
+    expect(JSON.parse(getFile(files, 'data/minecraft/tags/function/load.json')).values).toEqual(['emitns:load', 'emitns:bootstrap'])
+    expect(JSON.parse(getFile(files, 'data/minecraft/tags/function/tick.json')).values).toEqual(['emitns:tick_fn'])
+    expect(JSON.parse(getFile(files, 'data/rs/tags/function/on_player_join.json')).values).toEqual(['emitns:on_join'])
+    expect(files.find(f => f.path === 'data/rs/tags/function/on_block_break.json')).toBeUndefined()
+
+    const map = JSON.parse(getFile(files, 'data/emitns/function/main/run.sourcemap.json'))
+    expect(map.generatedFile).toBe('data/emitns/function/main/run.mcfunction')
+    expect(map.sources).toEqual(['src/test.mcrs'])
+    expect(map.mappings[0]).toMatchObject({ line: 1, sourceLine: 3, sourceCol: 5 })
+    expect(files.find(f => f.path === 'data/emitns/function/empty.sourcemap.json')).toBeUndefined()
+  })
+
+  test('falls back to legacy macro emission for pre-1.20.2 and handles empty execute context', () => {
+    const module: LIRModule = {
+      namespace: 'legacy',
+      objective: '__legacy',
+      functions: [
+        {
+          name: 'Legacy',
+          isMacro: false,
+          macroParams: [],
+          instructions: [
+            { kind: 'call_macro', fn: 'legacy:macro_target', storage: 'rs:macro_args' },
+            { kind: 'macro_line', template: 'setblock $(x) $(y) $(z) minecraft:stone' },
+            { kind: 'call_context', fn: 'legacy:plain', subcommands: [] },
+            { kind: 'store_nbt_to_score', dst: { player: '$x', obj: '__legacy' }, ns: 'legacy:data', path: 'p', scale: 2 },
+          ],
+        },
+      ],
+    }
+
+    const files = emit(module, {
+      namespace: 'legacy',
+      mcVersion: McVersion.v1_20,
+    })
+
+    const main = getFile(files, 'data/legacy/function/legacy.mcfunction')
+    expect(main).toContain('function legacy:macro_target')
+    expect(main).not.toContain('with storage')
+    expect(main).toContain('setblock {storage:rs:macro_args,path:x} {storage:rs:macro_args,path:y} {storage:rs:macro_args,path:z} minecraft:stone')
+    expect(main).toContain('function legacy:plain')
+    expect(main).toContain('execute store result score $x __legacy run data get storage legacy:data p 2.0')
+    expect(files.find(f => f.path === 'data/minecraft/tags/function/tick.json')).toBeUndefined()
+  })
+})

package/src/__tests__/emit/modules-extra.test.ts

@@ -0,0 +1,80 @@
+import { compileModules } from '../../emit/modules'
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  return files.find(f => f.path.includes(pathSubstr))?.content
+}
+
+describe('emit/modules: extra branch coverage', () => {
+  test('rewrites imported calls inside impl methods', () => {
+    const result = compileModules([
+      {
+        name: 'util',
+        source: `
+          module util;
+          export fn add_one(n: int): int { return n + 1; }
+          export fn nonzero(n: int): bool { return n != 0; }
+        `,
+      },
+      {
+        name: 'main',
+        source: `
+          import util::add_one;
+          import util::nonzero;
+
+          struct Counter { value: int }
+
+          impl Counter {
+            fn bump(self): Counter {
+              let next: int = add_one(self.value);
+              if (nonzero(next)) {
+                return Counter { value: next };
+              } else {
+                return Counter { value: 0 };
+              }
+            }
+          }
+
+          fn main_fn(): int {
+            let c: Counter = Counter { value: 1 };
+            let d: Counter = c.bump();
+            return d.value;
+          }
+        `,
+      },
+    ], { namespace: 'mods' })
+
+    const bump = getFile(result.files, 'counter/bump.mcfunction')
+    expect(bump).toBeDefined()
+    expect(bump).toContain('function mods:util/add_one')
+    expect(bump).toContain('function mods:util/nonzero')
+  })
+
+  test('module-local coroutine and schedule decorators use default arguments', () => {
+    const result = compileModules([
+      {
+        name: 'jobs',
+        source: `
+          module jobs;
+
+          @coroutine
+          fn worker() {
+            let i: int = 0;
+            while (i < 2) {
+              i = i + 1;
+            }
+          }
+
+          @schedule
+          fn later() {}
+        `,
+      },
+    ], { namespace: 'mods' })
+
+    const tickJson = getFile(result.files, 'tick.json')
+    const scheduleWrapper = getFile(result.files, '_schedule_jobs/later.mcfunction')
+
+    expect(tickJson).toBeDefined()
+    expect(JSON.parse(tickJson!).values).toContain('mods:_coro_jobs/worker_tick')
+    expect(scheduleWrapper).toBe('schedule function mods:jobs/later 1t\n')
+  })
+})

package/src/__tests__/enum.test.ts

@@ -126,14 +126,12 @@ describe('enum: parser', () => {
     if (matchStmt.kind === 'match') {
       expect(matchStmt.arms).toHaveLength(2)
       expect(matchStmt.arms[0].pattern).toMatchObject({
-        kind: 'path_expr',
-        enumName: 'Phase',
-        variant: 'Idle',
+        kind: 'PatExpr',
+        expr: { kind: 'path_expr', enumName: 'Phase', variant: 'Idle' },
       })
       expect(matchStmt.arms[1].pattern).toMatchObject({
-        kind: 'path_expr',
-        enumName: 'Phase',
-        variant: 'Moving',
+        kind: 'PatExpr',
+        expr: { kind: 'path_expr', enumName: 'Phase', variant: 'Moving' },
       })
     }
   })

package/src/__tests__/fixed.test.ts

@@ -0,0 +1,159 @@
+/**
+ * Tests for fixed (×10000 fixed-point) support in the RedScript compiler.
+ *
+ * RedScript fixed-point values are stored as ×10000 integers on MC scoreboards.
+ * 1.5 → 15000, 3.14 → 31400, etc.
+ */
+
+import { compile } from '../emit/compile'
+
+function getAllMcContent(files: { path: string; content: string }[]): string {
+  return files.filter(f => f.path.endsWith('.mcfunction')).map(f => f.content).join('\n')
+}
+
+describe('fixed literals (×10000 fixed-point)', () => {
+  test('1.5 literal compiles to scoreboard value 15000', () => {
+    const source = `fn t(): fixed { return 1.5; }`
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('15000')
+  })
+
+  test('3.14 literal compiles to scoreboard value 31400', () => {
+    const source = `fn t(): fixed { return 3.14; }`
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('31400')
+  })
+
+  test('2.0 literal compiles to 20000', () => {
+    const source = `fn t(): fixed { return 2.0; }`
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('20000')
+  })
+
+  test('0.5 literal compiles to 5000', () => {
+    const source = `fn t(): fixed { return 0.5; }`
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('5000')
+  })
+})
+
+describe('fixed addition', () => {
+  test('1.5 + 2.5 = 4.0 → result 40000 in output', () => {
+    // 15000 + 25000 = 40000 — addition needs no scale correction
+    const source = `
+      fn t(): fixed {
+        let a: fixed = 1.5;
+        let b: fixed = 2.5;
+        return a + b;
+      }
+    `
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    // Constant folder folds 15000+25000=40000 — result must appear
+    expect(all).toContain('40000')
+  })
+
+  test('2.0 + 3.0 = 5.0 → result 50000', () => {
+    const source = `
+      fn t(): fixed {
+        let a: fixed = 2.0;
+        let b: fixed = 3.0;
+        return a + b;
+      }
+    `
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('50000')
+  })
+})
+
+describe('fixed multiplication (scale correction ÷10000)', () => {
+  test('2.0 * 3.0 = 6.0 → result 60000 (not 600000000)', () => {
+    // Without correction: 20000 * 30000 = 600000000 (wrong)
+    // With correction: 20000 * 30000 / 10000 = 60000 ✓
+    const source = `
+      fn t(): fixed {
+        let a: fixed = 2.0;
+        let b: fixed = 3.0;
+        return a * b;
+      }
+    `
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('60000')
+    // Must NOT contain the uncorrected result
+    expect(all).not.toContain('600000000')
+  })
+
+  test('1.5 * 2.0 = 3.0 → result 30000 (not 300000000)', () => {
+    // Without correction: 15000 * 20000 = 300000000 (wrong)
+    // With correction: 15000 * 20000 / 10000 = 30000 ✓
+    const source = `
+      fn t(): fixed {
+        let a: fixed = 1.5;
+        let b: fixed = 2.0;
+        return a * b;
+      }
+    `
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('30000')
+    expect(all).not.toContain('300000000')
+  })
+})
+
+describe('fixed division (scale correction ×10000)', () => {
+  test('6.0 / 2.0 = 3.0 → result 30000 (not 3)', () => {
+    // Without correction: 60000 / 20000 = 3 (wrong)
+    // With correction: 60000 * 10000 / 20000 = 30000 ✓
+    const source = `
+      fn t(): fixed {
+        let a: fixed = 6.0;
+        let b: fixed = 2.0;
+        return a / b;
+      }
+    `
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('30000')
+    // The uncorrected result would be 3 (without the trailing 0000)
+    expect(all).toMatch(/30000/)
+  })
+
+  test('10.0 / 4.0 = 2.5 → result 25000 (not 2)', () => {
+    // Without correction: 100000 / 40000 = 2 (wrong, loses precision)
+    // With correction: 100000 * 10000 / 40000 = 25000 ✓
+    const source = `
+      fn t(): fixed {
+        let a: fixed = 10.0;
+        let b: fixed = 4.0;
+        return a / b;
+      }
+    `
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('25000')
+  })
+})
+
+describe("'float' keyword deprecation", () => {
+  test("using 'float' as type emits a deprecation warning", () => {
+    const source = `fn t(): float { return 1.5; }`
+    const result = compile(source, { namespace: 'fixedtest' })
+    expect(result.warnings.some(w => w.includes('[DeprecatedType]'))).toBe(true)
+    expect(result.warnings.some(w => w.includes("'float' is deprecated"))).toBe(true)
+    expect(result.warnings.some(w => w.includes("use 'fixed' instead"))).toBe(true)
+  })
+
+  test("'float' still compiles correctly (acts as 'fixed')", () => {
+    const source = `fn t(): float { return 1.5; }`
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    // 1.5 × 10000 = 15000
+    expect(all).toContain('15000')
+  })
+})

package/src/__tests__/fixtures/coroutine-mc-test.mcrs

@@ -0,0 +1,58 @@
+namespace coro_mc_test
+
+// ── Test 1: basic sum ──────────────────────────────────────────────────────
+// batch=10, 100 iterations → needs 10 ticks minimum
+// sum(0..99) = 4950
+//
+// Variables stored in __coro_mc_test objective (auto-created by load fn):
+//   player $coro_sum_acc   — running accumulator
+//   player $coro_done_count — how many times onDone fired
+
+@coroutine(batch=10, onDone="on_sum_done")
+fn coro_sum_100() {
+  let i: int = 0
+  while (i < 100) {
+    let cur: int = scoreboard_get("$coro_sum_acc", "__coro_mc_test")
+    scoreboard_set("$coro_sum_acc", "__coro_mc_test", cur + i)
+    i = i + 1
+  }
+}
+
+fn on_sum_done() {
+  let done: int = scoreboard_get("$coro_done_count", "__coro_mc_test")
+  scoreboard_set("$coro_done_count", "__coro_mc_test", done + 1)
+}
+
+fn trigger_coro_sum() {
+  scoreboard_set("$coro_sum_acc", "__coro_mc_test", 0)
+  scoreboard_set("$coro_done_count", "__coro_mc_test", 0)
+  coro_sum_100()
+}
+
+// ── Test 2: partial result check ──────────────────────────────────────────
+// batch=5, sum 0..49 = 1225 (50 iters / batch=5 = 10 ticks)
+// After 3 ticks only 15 iters done — onDone not yet fired
+//
+// Variables:
+//   player $partial_acc  — running accumulator
+//   player $partial_done — 1 when onDone fires
+
+@coroutine(batch=5, onDone="on_partial_done")
+fn coro_partial() {
+  let i: int = 0
+  while (i < 50) {
+    let cur: int = scoreboard_get("$partial_acc", "__coro_mc_test")
+    scoreboard_set("$partial_acc", "__coro_mc_test", cur + i)
+    i = i + 1
+  }
+}
+
+fn on_partial_done() {
+  scoreboard_set("$partial_done", "__coro_mc_test", 1)
+}
+
+fn trigger_partial() {
+  scoreboard_set("$partial_acc", "__coro_mc_test", 0)
+  scoreboard_set("$partial_done", "__coro_mc_test", 0)
+  coro_partial()
+}

package/src/__tests__/fixtures/for-range.mcrs

@@ -0,0 +1,15 @@
+namespace for_range_test
+fn sum_range(): int {
+  let total: int = 0
+  for i in 0..10 {
+    total = total + i
+  }
+  return total
+}
+fn sum_inclusive(): int {
+  let total: int = 0
+  for i in 1..=5 {
+    total = total + i
+  }
+  return total
+}