redscript-mc 2.1.1 → 2.2.1

package/src/__tests__/schedule.test.ts

@@ -103,3 +103,115 @@ describe('@schedule decorator', () => {
     expect(startFn).toContain('function test:_schedule_after_one_second')
   })
 })
+
+describe('setTimeout / setInterval codegen', () => {
+  test('setTimeout lifts lambda to __timeout_callback_0 and schedules it', () => {
+    const source = `
+      fn start() {
+        setTimeout(20, () => {
+          say("later");
+        });
+      }
+    `
+    const result = compile(source, { namespace: 'ns' })
+    const startFn = getFile(result.files, 'start.mcfunction')
+    const cbFn = getFile(result.files, '__timeout_callback_0.mcfunction')
+    expect(startFn).toContain('schedule function ns:__timeout_callback_0 20t')
+    expect(cbFn).toBeDefined()
+    expect(cbFn).toContain('say later')
+  })
+
+  test('setInterval lambda reschedules itself at the end', () => {
+    const source = `
+      fn start() {
+        setInterval(10, () => {
+          say("tick");
+        });
+      }
+    `
+    const result = compile(source, { namespace: 'ns' })
+    const cbFn = getFile(result.files, '__timeout_callback_0.mcfunction')
+    expect(cbFn).toBeDefined()
+    expect(cbFn).toContain('schedule function ns:__timeout_callback_0 10t')
+  })
+
+  test('multiple setTimeout calls get unique callback names', () => {
+    const source = `
+      fn start() {
+        setTimeout(10, () => { say("a"); });
+        setTimeout(20, () => { say("b"); });
+      }
+    `
+    const result = compile(source, { namespace: 'ns' })
+    const cb0 = getFile(result.files, '__timeout_callback_0.mcfunction')
+    const cb1 = getFile(result.files, '__timeout_callback_1.mcfunction')
+    expect(cb0).toBeDefined()
+    expect(cb1).toBeDefined()
+    expect(cb0).toContain('say a')
+    expect(cb1).toContain('say b')
+  })
+})
+
+const TIMER_STRUCT = `
+struct Timer {
+    _id: int,
+    _duration: int
+}
+impl Timer {
+    fn new(duration: int) -> Timer {
+        return { _id: 0, _duration: duration };
+    }
+    fn start(self) {}
+    fn pause(self) {}
+    fn reset(self) {}
+    fn tick(self) {}
+    fn done(self) -> bool { return false; }
+    fn elapsed(self) -> int { return 0; }
+}
+`
+
+describe('Timer static allocation codegen', () => {
+  test('Timer::new() initializes unique scoreboard slots', () => {
+    const source = TIMER_STRUCT + `
+fn init() {
+    let t: Timer = Timer::new(20);
+}
+`
+    const result = compile(source, { namespace: 'ns' })
+    const initFn = getFile(result.files, 'init.mcfunction')
+    expect(initFn).toContain('scoreboard players set __timer_0_ticks ns 0')
+    expect(initFn).toContain('scoreboard players set __timer_0_active ns 0')
+  })
+
+  test('Timer.start() inlines to scoreboard set active=1', () => {
+    const source = TIMER_STRUCT + `
+fn init() {
+    let t: Timer = Timer::new(20);
+    t.start();
+}
+`
+    const result = compile(source, { namespace: 'ns' })
+    const initFn = getFile(result.files, 'init.mcfunction')
+    expect(initFn).toContain('scoreboard players set __timer_0_active ns 1')
+    expect(initFn).not.toContain('function ns:timer/start')
+  })
+
+  test('two Timer::new() calls get distinct IDs', () => {
+    const source = TIMER_STRUCT + `
+fn init() {
+    let t0: Timer = Timer::new(10);
+    let t1: Timer = Timer::new(20);
+    t0.start();
+    t1.start();
+}
+`
+    const result = compile(source, { namespace: 'ns' })
+    const initFn = getFile(result.files, 'init.mcfunction')
+    // Both timers initialized
+    expect(initFn).toContain('__timer_0_ticks')
+    expect(initFn).toContain('__timer_1_ticks')
+    // Both started with unique slot names
+    expect(initFn).toContain('scoreboard players set __timer_0_active ns 1')
+    expect(initFn).toContain('scoreboard players set __timer_1_active ns 1')
+  })
+})

package/src/__tests__/typechecker.test.ts

@@ -270,6 +270,74 @@ fn test() {
       expect(errors[0].message).toContain('Return type mismatch: expected void, got int')
     })
 
+    it('rejects setTimeout inside a loop', () => {
+      const errors = typeCheck(`
+fn test() {
+    while (true) {
+        setTimeout(20, () => { say("x"); });
+    }
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('cannot be called inside a loop')
+    })
+
+    it('rejects setTimeout inside an if body', () => {
+      const errors = typeCheck(`
+fn test() {
+    if (true) {
+        setTimeout(20, () => { say("x"); });
+    }
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('cannot be called inside an if/else body')
+    })
+
+    it('rejects setInterval inside a loop', () => {
+      const errors = typeCheck(`
+fn test() {
+    while (true) {
+        setInterval(20, () => { say("x"); });
+    }
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('cannot be called inside a loop')
+    })
+
+    it('rejects Timer::new() inside a loop', () => {
+      const errors = typeCheck(`
+struct Timer { _id: int, _duration: int }
+impl Timer {
+    fn new(duration: int) -> Timer { return { _id: 0, _duration: duration }; }
+}
+fn test() {
+    while (true) {
+        let t: Timer = Timer::new(10);
+    }
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('Timer::new() cannot be called inside a loop')
+    })
+
+    it('rejects Timer::new() inside an if body', () => {
+      const errors = typeCheck(`
+struct Timer { _id: int, _duration: int }
+impl Timer {
+    fn new(duration: int) -> Timer { return { _id: 0, _duration: duration }; }
+}
+fn test() {
+    if (true) {
+        let t: Timer = Timer::new(10);
+    }
+}
+`)
+      expect(errors.length).toBeGreaterThan(0)
+      expect(errors[0].message).toContain('Timer::new() cannot be called inside an if/else body')
+    })
+
     it('allows impl instance methods with inferred self type', () => {
       const errors = typeCheck(`
 struct Timer { duration: int }

package/src/emit/compile.ts

@@ -146,6 +146,7 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
     const coroResult = coroutineTransform(mirOpt, coroutineInfos)
     const mirFinal = coroResult.module
     tickFunctions.push(...coroResult.generatedTickFunctions)
+    warnings.push(...coroResult.warnings)
 
     // Stage 5: MIR → LIR
     const lir = lowerToLIR(mirFinal)

package/src/emit/index.ts

@@ -208,7 +208,9 @@ function emitInstr(instr: LIRInstr, ns: string, obj: string, mcVersion: McVersio
 
     case 'call_context': {
       const subcmds = instr.subcommands.map(emitSubcmd).join(' ')
-      return `execute ${subcmds} run function ${instr.fn}`
+      return subcmds
+        ? `execute ${subcmds} run function ${instr.fn}`
+        : `function ${instr.fn}`
     }
 
     case 'return_value':

package/src/lir/lower.ts

@@ -334,6 +334,33 @@ function lowerInstrInner(
       break
     }
 
+    case 'score_read': {
+      // execute store result score $dst __obj run scoreboard players get <player> <obj>
+      const dst = ctx.slot(instr.dst)
+      instrs.push({
+        kind: 'store_cmd_to_score',
+        dst,
+        cmd: { kind: 'raw', cmd: `scoreboard players get ${instr.player} ${instr.obj}` },
+      })
+      break
+    }
+
+    case 'score_write': {
+      // Write a value to a vanilla MC scoreboard objective
+      if (instr.src.kind === 'const') {
+        instrs.push({ kind: 'raw', cmd: `scoreboard players set ${instr.player} ${instr.obj} ${instr.src.value}` })
+      } else {
+        // execute store result score <player> <obj> run scoreboard players get $src __ns
+        const srcSlot = operandToSlot(instr.src, ctx, instrs)
+        instrs.push({
+          kind: 'store_cmd_to_score',
+          dst: { player: instr.player, obj: instr.obj },
+          cmd: { kind: 'raw', cmd: `scoreboard players get ${srcSlot.player} ${srcSlot.obj}` },
+        })
+      }
+      break
+    }
+
     case 'call': {
       // Set parameter slots $p0, $p1, ...
       for (let i = 0; i < instr.args.length; i++) {