redscript-mc 2.0.0 → 2.1.1

package/examples/scheduler-demo.mcrs

@@ -0,0 +1,59 @@
+// scheduler-demo.mcrs — Delayed event triggering with @schedule
+//
+// @schedule(ticks=N) generates a _schedule_xxx wrapper that emits
+// `schedule function ns:xxx Nt`, deferring execution by N ticks.
+//
+// 20 ticks = 1 second in Minecraft.
+//
+// Usage:
+//   /function demo:begin_countdown   trigger the 1-second delayed reward
+//   /function demo:announce_morning  schedule a sunrise announcement
+
+// ── 1-second delayed reward ───────────────────────────────────────────────
+
+fn begin_countdown() {
+    title(@a, "Get ready...");
+    raw("function demo:_schedule_reward_players");
+}
+
+// Called automatically 1 second (20t) after _schedule_reward_players fires
+@schedule(ticks=20)
+fn reward_players(): void {
+    title(@a, "Go!");
+    raw("effect give @a minecraft:speed 5 1 true");
+    raw("effect give @a minecraft:jump_boost 5 1 true");
+    tell(@a, "Speed and Jump Boost applied for 5 seconds.");
+}
+
+// ── 5-second delayed announcement ────────────────────────────────────────
+
+fn announce_morning() {
+    tell(@a, "Sunrise in 5 seconds...");
+    raw("function demo:_schedule_sunrise_event");
+}
+
+@schedule(ticks=100)
+fn sunrise_event(): void {
+    raw("time set day");
+    raw("weather clear");
+    title(@a, "Good morning!");
+    subtitle(@a, "A new day begins");
+}
+
+// ── Chain: schedule a follow-up from inside a scheduled function ──────────
+
+fn start_chain() {
+    tell(@a, "Chain started — phase 1 runs in 1s, phase 2 in 3s total.");
+    raw("function demo:_schedule_chain_phase1");
+}
+
+@schedule(ticks=20)
+fn chain_phase1(): void {
+    actionbar(@a, "Phase 1 complete");
+    raw("function demo:_schedule_chain_phase2");
+}
+
+@schedule(ticks=40)
+fn chain_phase2(): void {
+    actionbar(@a, "Phase 2 complete — chain done!");
+}

package/examples/showcase.mcrs

@@ -293,9 +293,9 @@ fn _dump_advanced_phase() {
     say("§eHash (splitmix32) & 1D Noise:");
     say(f"  hash_int(0)   = {hash_int(0)}");
     say(f"  hash_int(1)   = {hash_int(1)}");
-    say(f"  noise1d(0,42) = {noise1d(0, 42)}");
-    say(f"  noise1d(1,42) = {noise1d(1, 42)}");
-    say(f"  noise1d(2,42) = {noise1d(2, 42)}");
+    say(f"  noise1d(0,42) = {noise1d(0)}");
+    say(f"  noise1d(1,42) = {noise1d(1)}");
+    say(f"  noise1d(2,42) = {noise1d(2)}");
 
     // Modular exponentiation
     say("§eModular Exponentiation:");

package/jest.config.js

@@ -1,5 +1,5 @@
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
-  roots: ['<rootDir>/src', '<rootDir>/src2'],
+  roots: ['<rootDir>/src'],
 };

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "redscript-mc",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/src/index.js",
   "bin": {
     "redscript": "dist/src/cli.js",
-    "rsc": "dist/src/cli.js"
+    "rsc": "dist/src/cli.js",
+    "redscript-lsp": "dist/src/lsp/main.js"
   },
   "scripts": {
     "build": "tsc",
     "dev": "tsc -w",
     "test": "jest",
     "cli": "ts-node src/cli.ts",
+    "lsp": "node dist/src/lsp/main.js",
     "validate-mc": "jest src/__tests__/mc-syntax.test.ts --verbose",
     "postbuild": "node scripts/postbuild.js"
   },
@@ -35,5 +37,9 @@
     "type": "git",
     "url": "https://github.com/bkmashiro/redscript.git"
   },
-  "author": "bkmashiro"
+  "author": "bkmashiro",
+  "dependencies": {
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12"
+  }
 }

package/src/__tests__/budget.test.ts

@@ -0,0 +1,297 @@
+import {
+  estimateCommandCount,
+  analyzeBudget,
+  BUDGET_WARN_THRESHOLD,
+  BUDGET_ERROR_THRESHOLD,
+} from '../lir/budget'
+import type { LIRModule, LIRFunction, LIRInstr, Slot } from '../lir/types'
+import { compile } from '../emit/compile'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const NS = 'test'
+const OBJ = '__test'
+
+function slot(name: string): Slot {
+  return { player: name, obj: OBJ }
+}
+
+function mkFn(name: string, instructions: LIRInstr[]): LIRFunction {
+  return { name, instructions, isMacro: false, macroParams: [] }
+}
+
+function mkModule(functions: LIRFunction[]): LIRModule {
+  return { functions, namespace: NS, objective: OBJ }
+}
+
+// ---------------------------------------------------------------------------
+// Unit tests: estimateCommandCount
+// ---------------------------------------------------------------------------
+
+describe('estimateCommandCount', () => {
+  test('flat function — counts each instruction as 1', () => {
+    const fn = mkFn('simple', [
+      { kind: 'score_set', dst: slot('$x'), value: 0 },
+      { kind: 'score_set', dst: slot('$y'), value: 1 },
+      { kind: 'score_add', dst: slot('$x'), src: slot('$y') },
+    ])
+    const mod = mkModule([fn])
+    expect(estimateCommandCount('simple', mod)).toBe(3)
+  })
+
+  test('function calling another — sums callee cost', () => {
+    const callee = mkFn('helper', [
+      { kind: 'score_set', dst: slot('$a'), value: 42 },
+      { kind: 'score_set', dst: slot('$b'), value: 43 },
+    ])
+    const caller = mkFn('main', [
+      { kind: 'score_set', dst: slot('$x'), value: 0 },
+      { kind: 'call', fn: `${NS}:helper` },
+    ])
+    const mod = mkModule([caller, callee])
+    // caller: 2 instrs + callee: 2 instrs = 4
+    expect(estimateCommandCount('main', mod)).toBe(4)
+  })
+
+  test('self-recursive function (loop) — multiplies by estimated iterations', () => {
+    // Simulate a loop: header checks condition, calls body, body calls header
+    const header = mkFn('loop__header', [
+      { kind: 'call_if_matches', fn: `${NS}:loop__body`, slot: slot('$i'), range: '..99' },
+    ])
+    const body = mkFn('loop__body', [
+      { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+      { kind: 'score_set', dst: slot('$tmp'), value: 1 },
+      { kind: 'call', fn: `${NS}:loop__header` },
+    ])
+    const mod = mkModule([header, body])
+    // Cycle: header(1) + body(3) = 4 cmds/iteration
+    // Range ..99 → 100 iterations
+    // Total: 4 × 100 = 400
+    expect(estimateCommandCount('loop__header', mod)).toBe(400)
+  })
+
+  test('unknown loop bound defaults to 100 iterations', () => {
+    const header = mkFn('loop__header', [
+      { kind: 'call_if_score', fn: `${NS}:loop__body`, a: slot('$i'), op: 'lt', b: slot('$limit') },
+    ])
+    const body = mkFn('loop__body', [
+      { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+      { kind: 'call', fn: `${NS}:loop__header` },
+    ])
+    const mod = mkModule([header, body])
+    // Cycle: 1 + 2 = 3 cmds/iteration, 100 default iterations = 300
+    expect(estimateCommandCount('loop__header', mod)).toBe(300)
+  })
+
+  test('nested loops — outer × inner', () => {
+    // Inner loop: inner_header ↔ inner_body (5 cmds/iter, 10 iters)
+    const innerHeader = mkFn('inner__header', [
+      { kind: 'call_if_matches', fn: `${NS}:inner__body`, slot: slot('$j'), range: '..9' },
+    ])
+    const innerBody = mkFn('inner__body', [
+      { kind: 'score_set', dst: slot('$a'), value: 1 },
+      { kind: 'score_set', dst: slot('$b'), value: 2 },
+      { kind: 'score_add', dst: slot('$j'), src: slot('$one') },
+      { kind: 'call', fn: `${NS}:inner__header` },
+    ])
+
+    // Outer loop: outer_header ↔ outer_body (calls inner loop + own work)
+    const outerHeader = mkFn('outer__header', [
+      { kind: 'call_if_matches', fn: `${NS}:outer__body`, slot: slot('$i'), range: '..19' },
+    ])
+    const outerBody = mkFn('outer__body', [
+      { kind: 'score_set', dst: slot('$j'), value: 0 },
+      { kind: 'call', fn: `${NS}:inner__header` },
+      { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+      { kind: 'call', fn: `${NS}:outer__header` },
+    ])
+
+    const mod = mkModule([innerHeader, innerBody, outerHeader, outerBody])
+
+    // Inner cycle: header(1) + body(4) = 5 cmds × 10 iters = 50
+    // Outer cycle local: header(1) + body(4) = 5 cmds
+    // Outer cycle external callee: inner = 50
+    // Outer total: (5 + 50) × 20 = 1100
+    expect(estimateCommandCount('outer__header', mod)).toBe(1100)
+  })
+
+  test('external call (not in module) contributes 0', () => {
+    const fn = mkFn('main', [
+      { kind: 'score_set', dst: slot('$x'), value: 0 },
+      { kind: 'call', fn: 'other_ns:external_fn' },
+    ])
+    const mod = mkModule([fn])
+    expect(estimateCommandCount('main', mod)).toBe(2)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Unit tests: analyzeBudget
+// ---------------------------------------------------------------------------
+
+describe('analyzeBudget', () => {
+  test('small loop (100 iters × 5 cmds = 500) → no diagnostic', () => {
+    const header = mkFn('process', [
+      { kind: 'call_if_matches', fn: `${NS}:process__body`, slot: slot('$i'), range: '..99' },
+    ])
+    const body = mkFn('process__body', [
+      { kind: 'score_set', dst: slot('$a'), value: 1 },
+      { kind: 'score_set', dst: slot('$b'), value: 2 },
+      { kind: 'score_add', dst: slot('$c'), src: slot('$a') },
+      { kind: 'call', fn: `${NS}:process` },
+    ])
+    const mod = mkModule([header, body])
+    const diags = analyzeBudget(mod)
+    expect(diags).toEqual([])
+  })
+
+  test('medium loop (1000 iters × 50 cmds = 50000) → warning', () => {
+    // Build a body with 48 instructions + 1 call back + header 1 = 50 per iter
+    const bodyInstrs: LIRInstr[] = []
+    for (let i = 0; i < 48; i++) {
+      bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i })
+    }
+    bodyInstrs.push({ kind: 'call', fn: `${NS}:bigloop` })
+
+    const header = mkFn('bigloop', [
+      { kind: 'call_if_matches', fn: `${NS}:bigloop__body`, slot: slot('$i'), range: '..999' },
+    ])
+    const body = mkFn('bigloop__body', bodyInstrs)
+    const mod = mkModule([header, body])
+    const diags = analyzeBudget(mod)
+    expect(diags).toHaveLength(1)
+    expect(diags[0].level).toBe('warning')
+    expect(diags[0].fnName).toBe('bigloop')
+    expect(diags[0].estimatedCommands).toBe(50000)
+    expect(diags[0].message).toContain('consider @coroutine')
+  })
+
+  test('large loop (1000 iters × 100 cmds = 100000) → error', () => {
+    const bodyInstrs: LIRInstr[] = []
+    for (let i = 0; i < 98; i++) {
+      bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i })
+    }
+    bodyInstrs.push({ kind: 'call', fn: `${NS}:hugeloop` })
+
+    const header = mkFn('hugeloop', [
+      { kind: 'call_if_matches', fn: `${NS}:hugeloop__body`, slot: slot('$i'), range: '..999' },
+    ])
+    const body = mkFn('hugeloop__body', bodyInstrs)
+    const mod = mkModule([header, body])
+    const diags = analyzeBudget(mod)
+    expect(diags).toHaveLength(1)
+    expect(diags[0].level).toBe('error')
+    expect(diags[0].fnName).toBe('hugeloop')
+    expect(diags[0].estimatedCommands).toBe(100000)
+  })
+
+  test('@coroutine function is skipped', () => {
+    const bodyInstrs: LIRInstr[] = []
+    for (let i = 0; i < 98; i++) {
+      bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i })
+    }
+    bodyInstrs.push({ kind: 'call', fn: `${NS}:bigfn` })
+
+    const header = mkFn('bigfn', [
+      { kind: 'call_if_matches', fn: `${NS}:bigfn__body`, slot: slot('$i'), range: '..999' },
+    ])
+    const body = mkFn('bigfn__body', bodyInstrs)
+    const mod = mkModule([header, body])
+
+    const diags = analyzeBudget(mod, new Set(['bigfn']))
+    expect(diags).toEqual([])
+  })
+
+  test('compiler-generated __helper functions are skipped', () => {
+    // Only top-level user functions are analyzed; __body etc are internal
+    const bodyInstrs: LIRInstr[] = []
+    for (let i = 0; i < 98; i++) {
+      bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i })
+    }
+    bodyInstrs.push({ kind: 'call', fn: `${NS}:fn__header` })
+
+    // Only fn__header and fn__body exist — both have __ so both skipped
+    const header = mkFn('fn__header', [
+      { kind: 'call_if_matches', fn: `${NS}:fn__body`, slot: slot('$i'), range: '..999' },
+    ])
+    const body = mkFn('fn__body', bodyInstrs)
+    const mod = mkModule([header, body])
+    const diags = analyzeBudget(mod)
+    expect(diags).toEqual([])
+  })
+
+  test('nested loop estimation is correct', () => {
+    // Inner: 5 cmds × 10 iters = 50
+    const innerHeader = mkFn('run__inner_header', [
+      { kind: 'call_if_matches', fn: `${NS}:run__inner_body`, slot: slot('$j'), range: '..9' },
+    ])
+    const innerBody = mkFn('run__inner_body', [
+      { kind: 'score_set', dst: slot('$a'), value: 1 },
+      { kind: 'score_set', dst: slot('$b'), value: 2 },
+      { kind: 'score_add', dst: slot('$c'), src: slot('$a') },
+      { kind: 'call', fn: `${NS}:run__inner_header` },
+    ])
+
+    // Outer: (5 + inner=50) × 20 = 1100
+    const outerHeader = mkFn('run__outer_header', [
+      { kind: 'call_if_matches', fn: `${NS}:run__outer_body`, slot: slot('$i'), range: '..19' },
+    ])
+    const outerBody = mkFn('run__outer_body', [
+      { kind: 'score_set', dst: slot('$j'), value: 0 },
+      { kind: 'call', fn: `${NS}:run__inner_header` },
+      { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+      { kind: 'call', fn: `${NS}:run__outer_header` },
+    ])
+
+    // The "root" user function that sets up the outer loop
+    const run = mkFn('run', [
+      { kind: 'score_set', dst: slot('$i'), value: 0 },
+      { kind: 'call', fn: `${NS}:run__outer_header` },
+    ])
+
+    const mod = mkModule([run, innerHeader, innerBody, outerHeader, outerBody])
+    const estimate = estimateCommandCount('run', mod)
+    // run: 2 local + outer(1100) = 1102
+    expect(estimate).toBe(1102)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// E2E: compile pipeline integration
+// ---------------------------------------------------------------------------
+
+describe('budget analysis — compile pipeline integration', () => {
+  test('small loop produces no warning', () => {
+    const source = `
+      fn process(): void {
+        let i: int = 0;
+        while (i < 10) {
+          let x: int = i * 2;
+          i = i + 1;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'budgettest' })
+    expect(result.warnings).toEqual([])
+  })
+
+  test('@coroutine function skips budget check', () => {
+    const source = `
+      @coroutine(batch=5)
+      fn process_all(): void {
+        let i: int = 0;
+        while (i < 10000) {
+          let x: int = i * 2;
+          i = i + 1;
+        }
+      }
+    `
+    // Should not throw even with huge loop — @coroutine exempts it
+    const result = compile(source, { namespace: 'budgettest' })
+    // No budget error/warning for coroutine functions
+    const budgetWarnings = result.warnings.filter(w => w.includes('tick budget'))
+    expect(budgetWarnings).toEqual([])
+  })
+})

package/src/__tests__/diagnostics.test.ts

@@ -21,10 +21,9 @@ describe('DiagnosticError', () => {
       )
 
       expect(formatError(error, source)).toBe([
-        'Error at line 2, col 11:',
+        '<input>:2:11: error: Unknown function: foo',
         '    let x = foo(',
         '            ^',
-        'Unknown function: foo',
       ].join('\n'))
     })
 
@@ -37,7 +36,7 @@ describe('DiagnosticError', () => {
         source.split('\n')
       )
 
-      expect(formatError(error, source)).toContain('Error in test.mcrs at line 1, col 9:')
+      expect(formatError(error, source)).toContain('test.mcrs:1:9: error: Unknown function: foo')
     })
   })
 

package/src/__tests__/e2e/coroutine.test.ts

@@ -0,0 +1,142 @@
+/**
+ * End-to-end tests for @coroutine decorator.
+ *
+ * Compiles RedScript with @coroutine through the full pipeline and
+ * verifies generated .mcfunction output and tick.json registration.
+ */
+
+import { compile } from '../../emit/compile'
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  const f = files.find(f => f.path.includes(pathSubstr))
+  return f?.content
+}
+
+function getFileNames(files: { path: string; content: string }[]): string[] {
+  return files.map(f => f.path)
+}
+
+describe('e2e: @coroutine', () => {
+  test('@coroutine loop function generates dispatcher in tick.json', () => {
+    const source = `
+      @coroutine(batch=10)
+      fn process_all(): void {
+        let i: int = 0;
+        while (i < 100) {
+          let x: int = i * 2;
+          i = i + 1;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'corotest' })
+    const tickJson = getFile(result.files, 'tick.json')
+    expect(tickJson).toBeDefined()
+    const parsed = JSON.parse(tickJson!)
+    // The generated tick dispatcher should be registered
+    const hasCoroTick = parsed.values.some((v: string) => v.includes('_coro_'))
+    expect(hasCoroTick).toBe(true)
+  })
+
+  test('@coroutine generates continuation mcfunction files', () => {
+    const source = `
+      @coroutine(batch=5)
+      fn heavy_loop(): void {
+        let i: int = 0;
+        while (i < 1000) {
+          let x: int = i + 1;
+          i = i + 1;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'corotest' })
+    const paths = getFileNames(result.files)
+
+    // Should have at least one continuation function file
+    const contFiles = paths.filter(p => p.includes('_coro_') && p.includes('_cont_'))
+    expect(contFiles.length).toBeGreaterThanOrEqual(1)
+
+    // Should have a dispatcher tick function file (may include sub-function files)
+    const tickFiles = paths.filter(p => p.includes('_coro_') && p.includes('_tick'))
+    expect(tickFiles.length).toBeGreaterThanOrEqual(1)
+  })
+
+  test('@coroutine with onDone generates call to callback', () => {
+    const source = `
+      fn after_done(): void {
+        let x: int = 42;
+      }
+
+      @coroutine(batch=10, onDone=after_done)
+      fn process(): void {
+        let i: int = 0;
+        while (i < 100) {
+          let x: int = i;
+          i = i + 1;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'corotest' })
+
+    // The continuation files should reference after_done somewhere
+    const contFiles = result.files.filter(f => f.path.includes('_coro_') && f.path.includes('_cont_'))
+    const allContent = contFiles.map(f => f.content).join('\n')
+    expect(allContent).toContain('after_done')
+  })
+
+  test('@coroutine function without loops still compiles', () => {
+    const source = `
+      @coroutine(batch=10)
+      fn no_loop(): void {
+        let x: int = 1;
+        let y: int = x + 2;
+      }
+    `
+    const result = compile(source, { namespace: 'corotest' })
+    expect(result.files.length).toBeGreaterThan(0)
+
+    // Should still produce continuation + dispatcher
+    const paths = getFileNames(result.files)
+    const contFiles = paths.filter(p => p.includes('_coro_'))
+    expect(contFiles.length).toBeGreaterThanOrEqual(2) // at least cont + tick
+  })
+
+  test('@coroutine preserves non-coroutine functions', () => {
+    const source = `
+      fn helper(): int {
+        return 42;
+      }
+
+      @coroutine(batch=10)
+      fn process(): void {
+        let i: int = 0;
+        while (i < 100) {
+          let x: int = i;
+          i = i + 1;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'corotest' })
+    const helperFn = getFile(result.files, 'helper.mcfunction')
+    expect(helperFn).toBeDefined()
+  })
+
+  test('default batch value is 10 when not specified', () => {
+    // @coroutine without batch should default to batch=10
+    // We test by ensuring compilation succeeds
+    const source = `
+      @coroutine
+      fn process(): void {
+        let i: int = 0;
+        while (i < 100) {
+          let x: int = i;
+          i = i + 1;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'corotest' })
+    expect(result.files.length).toBeGreaterThan(0)
+    const paths = getFileNames(result.files)
+    const contFiles = paths.filter(p => p.includes('_coro_'))
+    expect(contFiles.length).toBeGreaterThanOrEqual(2)
+  })
+})

package/{src2 → src}/__tests__/e2e/macros.test.ts

@@ -152,7 +152,7 @@ describe('e2e: float macro params with local coords', () => {
       }
 
       fn caller() {
-        draw_pt(100, 200);
+        draw_pt(100.0, 200.0);
       }
     `
     const result = compile(source, { namespace: 'test' })

package/{src2 → src}/__tests__/e2e/migrate.test.ts

@@ -12,7 +12,7 @@
  */
 
 import { compile } from '../../emit/compile'
-import { MCRuntime } from '../../../src/runtime'
+import { MCRuntime } from '../../runtime'
 
 // ---------------------------------------------------------------------------
 // Helpers