redscript-mc 1.2.30 → 2.1.0

package/src/__tests__/diagnostics.test.ts

@@ -3,7 +3,7 @@
  */
 
 import { DiagnosticError, DiagnosticCollector, formatError, parseErrorMessage } from '../diagnostics'
-import { compile, formatCompileError } from '../compile'
+import { compile } from '../compile'
 
 describe('DiagnosticError', () => {
   describe('formatError', () => {
@@ -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')
     })
   })
 
@@ -126,70 +125,91 @@ describe('parseErrorMessage', () => {
 
 describe('compile function', () => {
   it('returns success for valid code', () => {
-    const result = compile('fn main() { let x = 1; }')
+    const result = compile('fn main() { let x = 1; }', { namespace: 'test' })
     expect(result.success).toBe(true)
     expect(result.files).toBeDefined()
   })
 
-  it('returns DiagnosticError for lex errors', () => {
-    const result = compile('fn main() { let x = $ }')
-    expect(result.success).toBe(false)
-    expect(result.error).toBeInstanceOf(DiagnosticError)
-    expect(result.error?.kind).toBe('LexError')
+  it('throws DiagnosticError for lex errors', () => {
+    expect(() => compile('fn main() { let x = $ }', { namespace: 'test' }))
+      .toThrow()
+    try {
+      compile('fn main() { let x = $ }', { namespace: 'test' })
+    } catch (e) {
+      expect(e).toBeInstanceOf(DiagnosticError)
+      expect((e as DiagnosticError).kind).toBe('LexError')
+    }
   })
 
-  it('returns DiagnosticError for parse errors', () => {
-    const result = compile('fn main() { let x = }')
-    expect(result.success).toBe(false)
-    expect(result.error).toBeInstanceOf(DiagnosticError)
-    expect(result.error?.kind).toBe('ParseError')
+  it('throws DiagnosticError for parse errors', () => {
+    expect(() => compile('fn main() { let x = }', { namespace: 'test' }))
+      .toThrow()
+    try {
+      compile('fn main() { let x = }', { namespace: 'test' })
+    } catch (e) {
+      expect(e).toBeInstanceOf(DiagnosticError)
+      expect((e as DiagnosticError).kind).toBe('ParseError')
+    }
   })
 
-  it('returns DiagnosticError for missing semicolon', () => {
-    const result = compile('fn main() { let x = 42 }')
-    expect(result.success).toBe(false)
-    expect(result.error?.kind).toBe('ParseError')
-    expect(result.error?.message).toContain("Expected ';'")
+  it('throws DiagnosticError for missing semicolon', () => {
+    try {
+      compile('fn main() { let x = 42 }', { namespace: 'test' })
+      fail('Expected compile to throw')
+    } catch (e) {
+      expect((e as DiagnosticError).kind).toBe('ParseError')
+      expect((e as DiagnosticError).message).toContain("Expected ';'")
+    }
   })
 
   it('includes file path in error', () => {
-    const result = compile('fn main() { }', { filePath: 'test.mcrs' })
-    // This is valid, but test that filePath is passed through
+    const result = compile('fn main() { }', { filePath: 'test.mcrs', namespace: 'test' })
     expect(result.success).toBe(true)
   })
 
   it('formats error nicely', () => {
-    const result = compile('fn main() {\n  let x = 42\n}')
-    expect(result.success).toBe(false)
-    const formatted = formatCompileError(result)
-    expect(formatted).toContain('Error at line')
-    expect(formatted).toContain('^')
-    // Error points to } on line 3, which is where semicolon was expected
-    expect(formatted).toContain('}')
+    try {
+      compile('fn main() {\n  let x = 42\n}', { namespace: 'test' })
+      fail('Expected compile to throw')
+    } catch (e) {
+      expect(e).toBeInstanceOf(DiagnosticError)
+      const formatted = (e as DiagnosticError).format()
+      expect(formatted).toContain('line')
+      expect(formatted).toContain('^')
+    }
   })
 })
 
 describe('Lexer DiagnosticError', () => {
   it('throws DiagnosticError for unexpected character', () => {
-    const result = compile('fn main() { let x = $ }')
-    expect(result.success).toBe(false)
-    expect(result.error?.kind).toBe('LexError')
-    expect(result.error?.message).toContain('Unexpected character')
+    try {
+      compile('fn main() { let x = $ }', { namespace: 'test' })
+      fail('Expected compile to throw')
+    } catch (e) {
+      expect((e as DiagnosticError).kind).toBe('LexError')
+      expect((e as DiagnosticError).message).toContain('Unexpected character')
+    }
   })
 
   it('throws DiagnosticError for unterminated string', () => {
-    const result = compile('fn main() { let x = "hello }')
-    expect(result.success).toBe(false)
-    expect(result.error?.kind).toBe('LexError')
-    expect(result.error?.message).toContain('Unterminated string')
+    try {
+      compile('fn main() { let x = "hello }', { namespace: 'test' })
+      fail('Expected compile to throw')
+    } catch (e) {
+      expect((e as DiagnosticError).kind).toBe('LexError')
+      expect((e as DiagnosticError).message).toContain('Unterminated string')
+    }
   })
 })
 
 describe('Parser DiagnosticError', () => {
   it('includes line and column info', () => {
-    const result = compile('fn main() { return }')
-    expect(result.success).toBe(false)
-    expect(result.error?.location.line).toBeGreaterThan(0)
-    expect(result.error?.location.col).toBeGreaterThan(0)
+    try {
+      compile('fn main() { return }', { namespace: 'test' })
+      fail('Expected compile to throw')
+    } catch (e) {
+      expect((e as DiagnosticError).location.line).toBeGreaterThan(0)
+      expect((e as DiagnosticError).location.col).toBeGreaterThan(0)
+    }
   })
 })

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

@@ -0,0 +1,154 @@
+/**
+ * End-to-end tests for the v2 compiler pipeline.
+ *
+ * These tests compile RedScript source through the full pipeline
+ * (Lexer → Parser → HIR → MIR → optimize → LIR → emit) and verify
+ * the generated .mcfunction output contains expected MC commands.
+ */
+
+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
+}
+
+describe('e2e: basic compilation', () => {
+  test('simple arithmetic function produces scoreboard commands', () => {
+    const source = `
+      fn add(a: int, b: int): int {
+        return a + b;
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.files.length).toBeGreaterThan(0)
+
+    const addFn = getFile(result.files, 'add.mcfunction')
+    expect(addFn).toBeDefined()
+    expect(addFn).toContain('scoreboard players operation')
+    expect(addFn).toContain('__test')
+  })
+
+  test('pack.mcmeta is generated with pack_format 26', () => {
+    const source = `fn noop(): void {}`
+    const result = compile(source, { namespace: 'demo' })
+    const meta = getFile(result.files, 'pack.mcmeta')
+    expect(meta).toBeDefined()
+    const parsed = JSON.parse(meta!)
+    expect(parsed.pack.pack_format).toBe(26)
+  })
+
+  test('load.mcfunction creates scoreboard objective', () => {
+    const source = `fn noop(): void {}`
+    const result = compile(source, { namespace: 'mypack' })
+    const load = getFile(result.files, 'load.mcfunction')
+    expect(load).toBeDefined()
+    expect(load).toContain('scoreboard objectives add __mypack dummy')
+  })
+
+  test('@tick function appears in tick.json', () => {
+    const source = `
+      @tick fn game_tick(): void {
+        let x: int = 1;
+      }
+    `
+    const result = compile(source, { namespace: 'ticktest' })
+    const tickJson = getFile(result.files, 'tick.json')
+    expect(tickJson).toBeDefined()
+    const parsed = JSON.parse(tickJson!)
+    expect(parsed.values).toContain('ticktest:game_tick')
+  })
+
+  test('@load function appears in load.json', () => {
+    const source = `
+      @load fn setup(): void {
+        let x: int = 42;
+      }
+    `
+    const result = compile(source, { namespace: 'loadtest' })
+    const loadJson = getFile(result.files, 'load.json')
+    expect(loadJson).toBeDefined()
+    const parsed = JSON.parse(loadJson!)
+    expect(parsed.values).toContain('loadtest:setup')
+    // load.json should also reference the objective-init load function
+    expect(parsed.values).toContain('loadtest:load')
+  })
+
+  test('if/else produces conditional call pattern', () => {
+    const source = `
+      fn check(x: int): int {
+        if (x > 0) {
+          return 1;
+        } else {
+          return 0;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'cond' })
+
+    // The main function should contain call_if_matches / call_unless_matches
+    const checkFn = getFile(result.files, 'check.mcfunction')
+    expect(checkFn).toBeDefined()
+    expect(checkFn).toContain('execute if score')
+    expect(checkFn).toContain('matches')
+    expect(checkFn).toContain('run function')
+  })
+
+  test('while loop produces loop structure with recursive call', () => {
+    const source = `
+      fn count(): void {
+        let i: int = 0;
+        while (i < 10) {
+          i = i + 1;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'loop' })
+
+    // There should be a loop body function that calls itself (or a header)
+    const fnFiles = result.files.filter(f => f.path.endsWith('.mcfunction'))
+    expect(fnFiles.length).toBeGreaterThan(1) // main + at least one extracted block
+
+    // At least one file should have a conditional call pattern for the loop
+    const allContent = fnFiles.map(f => f.content).join('\n')
+    expect(allContent).toContain('execute if score')
+    expect(allContent).toContain('run function')
+  })
+
+  test('function names are lowercased in output paths', () => {
+    const source = `fn MyFunc(): void {}`
+    const result = compile(source, { namespace: 'ns' })
+    const fn = result.files.find(f => f.path.includes('myfunc.mcfunction'))
+    expect(fn).toBeDefined()
+  })
+
+  test('constant assignment produces score_set', () => {
+    const source = `
+      fn init(): int {
+        let x: int = 42;
+        return x;
+      }
+    `
+    const result = compile(source, { namespace: 'cst' })
+    const fn = getFile(result.files, 'init.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('scoreboard players set')
+    expect(fn).toContain('42')
+  })
+
+  test('load.json always includes namespace:load', () => {
+    const source = `fn noop(): void {}`
+    const result = compile(source, { namespace: 'abc' })
+    const loadJson = getFile(result.files, 'load.json')
+    expect(loadJson).toBeDefined()
+    const parsed = JSON.parse(loadJson!)
+    expect(parsed.values).toContain('abc:load')
+  })
+
+  test('no tick.json when no @tick functions', () => {
+    const source = `fn noop(): void {}`
+    const result = compile(source, { namespace: 'notick' })
+    const tickJson = getFile(result.files, 'tick.json')
+    expect(tickJson).toBeUndefined()
+  })
+})

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/src/__tests__/e2e/macros.test.ts

@@ -0,0 +1,199 @@
+/**
+ * End-to-end tests for MC 1.20.2+ macro function support in the v2 pipeline.
+ *
+ * When a function uses runtime parameters in positions that require literal
+ * values in MC commands (coordinates, entity types, etc.), the compiler should
+ * automatically compile it as a macro function using $-prefixed syntax and
+ * call it via `function ns:fn with storage rs:macro_args`.
+ */
+
+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
+}
+
+// ---------------------------------------------------------------------------
+// Macro function detection
+// ---------------------------------------------------------------------------
+
+describe('e2e: macro function detection', () => {
+  test('function with int params in summon coords emits $-prefixed command', () => {
+    const source = `
+      fn spawn_zombie(x: int, y: int, z: int) {
+        summon("minecraft:zombie", x, y, z);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'spawn_zombie.mcfunction')
+    expect(fn).toBeDefined()
+    // The function body should have a $summon macro line
+    expect(fn).toContain('$summon minecraft:zombie $(x) $(y) $(z)')
+  })
+
+  test('function with all constant args does NOT produce macro line', () => {
+    const source = `
+      fn spawn_fixed() {
+        summon("minecraft:zombie", 100, 64, 200);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'spawn_fixed.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('summon minecraft:zombie 100 64 200')
+    // No $ prefix
+    expect(fn).not.toMatch(/^\$summon/m)
+  })
+
+  test('function with int params in particle coords emits $-prefixed command', () => {
+    const source = `
+      fn show_particle(x: int, y: int, z: int) {
+        particle("minecraft:flame", x, y, z);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'show_particle.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('$particle minecraft:flame $(x) $(y) $(z)')
+  })
+
+  test('function with int params in setblock coords emits $-prefixed command', () => {
+    const source = `
+      fn place_block(x: int, y: int, z: int) {
+        setblock(x, y, z, "minecraft:stone");
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'place_block.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('$setblock $(x) $(y) $(z) minecraft:stone')
+  })
+
+  test('mixed literal and variable args: only variable args get $()', () => {
+    const source = `
+      fn teleport_y(y: int) {
+        summon("minecraft:zombie", 100, y, 200);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'teleport_y.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('$summon minecraft:zombie 100 $(y) 200')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Macro call site generation
+// ---------------------------------------------------------------------------
+
+describe('e2e: macro call site generation', () => {
+  test('call site emits store_score_to_nbt + function with storage', () => {
+    const source = `
+      fn spawn_zombie(x: int, y: int, z: int) {
+        summon("minecraft:zombie", x, y, z);
+      }
+
+      fn caller(px: int, pz: int) {
+        spawn_zombie(px, 64, pz);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const callerFn = getFile(result.files, 'caller.mcfunction')
+    expect(callerFn).toBeDefined()
+
+    // Should have 'function test:spawn_zombie with storage rs:macro_args'
+    expect(callerFn).toContain('with storage rs:macro_args')
+    expect(callerFn).toContain('spawn_zombie')
+  })
+
+  test('call site stores args to rs:macro_args NBT', () => {
+    const source = `
+      fn spawn_zombie(x: int, y: int, z: int) {
+        summon("minecraft:zombie", x, y, z);
+      }
+
+      fn caller(my_x: int) {
+        spawn_zombie(my_x, 64, 0);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const callerFn = getFile(result.files, 'caller.mcfunction')
+    expect(callerFn).toBeDefined()
+
+    // Should have NBT storage setup for macro args
+    expect(callerFn).toContain('rs:macro_args')
+    expect(callerFn).toContain('with storage')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Float macro params (local coords)
+// ---------------------------------------------------------------------------
+
+describe('e2e: float macro params with local coords', () => {
+  test('float params in ^coord positions produce macro function', () => {
+    const source = `
+      fn draw_pt(px: float, py: float) {
+        particle("minecraft:end_rod", ^px, ^py, ^5, 0.02, 0.02, 0.02, 0.0, 10);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'draw_pt.mcfunction')
+    expect(fn).toBeDefined()
+    // Should have $particle with ^$(px) and ^$(py)
+    expect(fn).toContain('$particle minecraft:end_rod ^$(px) ^$(py) ^5')
+  })
+
+  test('float macro call site uses double 0.01 scale for NBT storage', () => {
+    const source = `
+      fn draw_pt(px: float, py: float) {
+        particle("minecraft:end_rod", ^px, ^py, ^5, 0.02, 0.02, 0.02, 0.0, 10);
+      }
+
+      fn caller() {
+        draw_pt(100.0, 200.0);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const callerFn = getFile(result.files, 'caller.mcfunction')
+    expect(callerFn).toBeDefined()
+
+    // Should store to NBT with double type and 0.01 scale
+    expect(callerFn).toContain('rs:macro_args')
+    expect(callerFn).toContain('double 0.01')
+    expect(callerFn).toContain('with storage rs:macro_args')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Non-macro functions still work
+// ---------------------------------------------------------------------------
+
+describe('e2e: non-macro functions', () => {
+  test('say builtin emits normal (non-macro) command', () => {
+    const source = `
+      fn greet() {
+        say("hello world");
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'greet.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('say hello world')
+    // No $ prefix
+    expect(fn).not.toMatch(/^\$/m)
+  })
+
+  test('kill builtin emits normal command', () => {
+    const source = `
+      fn cleanup() {
+        kill(@e[tag=temp]);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'cleanup.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('kill @e[tag=temp]')
+  })
+})