redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/compiler/labeled-loops.test.ts

@@ -0,0 +1,279 @@
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { lowerToHIR } from '../../hir/lower'
+import { lowerToMIR } from '../../mir/lower'
+import { verifyMIR } from '../../mir/verify'
+import type { MIRFunction, MIRInstr } from '../../mir/types'
+import { compile } from '../../emit/compile'
+
+function parse(source: string) {
+  const tokens = new Lexer(source).tokenize()
+  return new Parser(tokens, source).parse('test')
+}
+
+function lowerFn(source: string, fnName = 'test_fn'): MIRFunction {
+  const ast = parse(source)
+  const hir = lowerToHIR(ast)
+  const mir = lowerToMIR(hir)
+  expect(verifyMIR(mir)).toEqual([])
+  const fn = mir.functions.find(f => f.name === fnName)
+  if (!fn) throw new Error(`function '${fnName}' not found in MIR`)
+  return fn
+}
+
+// ---------------------------------------------------------------------------
+// Parser tests
+// ---------------------------------------------------------------------------
+
+describe('labeled loops — parser', () => {
+  test('parses labeled while loop', () => {
+    const src = `
+      fn test_fn() {
+        outer: while true {
+          break outer
+        }
+      }
+    `
+    const ast = parse(src)
+    const fnBody = ast.declarations[0].body
+    const labeled = fnBody[0]
+    expect(labeled.kind).toBe('labeled_loop')
+    if (labeled.kind !== 'labeled_loop') throw new Error()
+    expect(labeled.label).toBe('outer')
+    expect(labeled.body.kind).toBe('while')
+  })
+
+  test('parses labeled for_each loop', () => {
+    const src = `
+      fn test_fn() {
+        outer: for i in [0, 1, 2] {
+          continue outer
+        }
+      }
+    `
+    const ast = parse(src)
+    const fnBody = ast.declarations[0].body
+    const labeled = fnBody[0]
+    expect(labeled.kind).toBe('labeled_loop')
+    if (labeled.kind !== 'labeled_loop') throw new Error()
+    expect(labeled.label).toBe('outer')
+  })
+
+  test('parses break with label', () => {
+    const src = `
+      fn test_fn() {
+        outer: while true {
+          break outer
+        }
+      }
+    `
+    const ast = parse(src)
+    const labeled = ast.declarations[0].body[0]
+    if (labeled.kind !== 'labeled_loop') throw new Error()
+    const whileBody = (labeled.body as Extract<typeof labeled.body, { kind: 'while' }>).body
+    expect(whileBody[0]).toMatchObject({ kind: 'break_label', label: 'outer' })
+  })
+
+  test('parses continue with label', () => {
+    const src = `
+      fn test_fn() {
+        outer: while true {
+          inner: while true {
+            continue outer
+          }
+        }
+      }
+    `
+    const ast = parse(src)
+    const outer = ast.declarations[0].body[0]
+    if (outer.kind !== 'labeled_loop') throw new Error()
+    const outerWhile = outer.body as Extract<typeof outer.body, { kind: 'while' }>
+    const inner = outerWhile.body[0]
+    if (inner.kind !== 'labeled_loop') throw new Error()
+    const innerWhile = inner.body as Extract<typeof inner.body, { kind: 'while' }>
+    expect(innerWhile.body[0]).toMatchObject({ kind: 'continue_label', label: 'outer' })
+  })
+
+  test('label not on loop produces parse error', () => {
+    const src = `
+      fn test_fn() {
+        outer: let x: int = 0
+      }
+    `
+    const tokens = new Lexer(src).tokenize()
+    const parser = new Parser(tokens, src)
+    parser.parse('test')
+    // Error is collected in parseErrors (error recovery mode), not thrown
+    expect(parser.parseErrors.length).toBeGreaterThan(0)
+    expect(parser.parseErrors[0].message).toMatch(/outer/)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// MIR lowering tests
+// ---------------------------------------------------------------------------
+
+describe('labeled loops — MIR lowering', () => {
+  test('break label generates jump to outer loop exit', () => {
+    const src = `
+      fn test_fn() {
+        let result: int = 0
+        outer: while result < 100 {
+          let j: int = 0
+          inner: while j < 10 {
+            if j == 3 {
+              break outer
+            }
+            j = j + 1
+          }
+          result = result + 1
+        }
+      }
+    `
+    const fn = lowerFn(src)
+    // Should have multiple loop_exit blocks (outer and inner)
+    const exitBlocks = fn.blocks.filter(b => b.id.startsWith('loop_exit'))
+    expect(exitBlocks.length).toBeGreaterThanOrEqual(2)
+
+    // There should be a block that has a 'break_label' path (jumps to outer exit)
+    const outerExit = exitBlocks[0] // first is outer
+    const breakToOuter = fn.blocks.find(b =>
+      b.term.kind === 'jump' &&
+      (b.term as Extract<MIRInstr, { kind: 'jump' }>).target === outerExit.id &&
+      b.id !== outerExit.id &&
+      !b.id.startsWith('loop_latch')
+    )
+    expect(breakToOuter).toBeDefined()
+  })
+
+  test('continue label generates jump to outer loop header/latch', () => {
+    const src = `
+      fn test_fn() {
+        let result: int = 0
+        outer: for i in [0, 1, 2, 3, 4] {
+          inner: for j in [0, 1, 2, 3] {
+            if j == 1 {
+              continue outer
+            }
+          }
+          result = result + 1
+        }
+      }
+    `
+    const fn = lowerFn(src)
+    // Should compile without errors
+    expect(fn.blocks.length).toBeGreaterThan(0)
+
+    // There should be jump(s) going to a loop header or latch
+    const loopHeaders = fn.blocks.filter(b =>
+      b.id.startsWith('loop_header') || b.id.startsWith('loop_latch')
+    )
+    expect(loopHeaders.length).toBeGreaterThan(0)
+  })
+
+  test('three levels of nesting with break on outermost', () => {
+    const src = `
+      fn test_fn() {
+        let found: int = 0
+        outermost: while found == 0 {
+          let i: int = 0
+          middle: while i < 5 {
+            let j: int = 0
+            inner: while j < 5 {
+              if i == 2 && j == 2 {
+                break outermost
+              }
+              j = j + 1
+            }
+            i = i + 1
+          }
+        }
+      }
+    `
+    const fn = lowerFn(src)
+    expect(fn.blocks.length).toBeGreaterThan(0)
+  })
+
+  test('break unlabeled still works inside labeled loop', () => {
+    const src = `
+      fn test_fn() {
+        outer: while true {
+          let i: int = 0
+          while i < 10 {
+            if i == 5 { break }
+            i = i + 1
+          }
+          break outer
+        }
+      }
+    `
+    const fn = lowerFn(src)
+    expect(fn.blocks.length).toBeGreaterThan(0)
+  })
+
+  test('end-to-end compile with labeled break', () => {
+    const src = `
+      fn test_fn() {
+        let i: int = 0
+        outer: while i < 10 {
+          let j: int = 0
+          inner: while j < 10 {
+            if i == 3 && j == 3 {
+              break outer
+            }
+            j = j + 1
+          }
+          i = i + 1
+        }
+      }
+    `
+    expect(() => compile(src, { namespace: 'test' })).not.toThrow()
+  })
+
+  test('end-to-end compile with labeled continue', () => {
+    const src = `
+      fn test_fn() {
+        let i: int = 0
+        outer: while i < 5 {
+          let j: int = 0
+          inner: while j < 5 {
+            if j == 1 {
+              continue outer
+            }
+            j = j + 1
+          }
+          i = i + 1
+        }
+      }
+    `
+    expect(() => compile(src, { namespace: 'test' })).not.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Error cases
+// ---------------------------------------------------------------------------
+
+describe('labeled loops — error handling', () => {
+  test('break with unknown label throws error', () => {
+    const src = `
+      fn test_fn() {
+        while true {
+          break nonexistent
+        }
+      }
+    `
+    expect(() => compile(src, { namespace: 'test' })).toThrow(/nonexistent/)
+  })
+
+  test('continue with unknown label throws error', () => {
+    const src = `
+      fn test_fn() {
+        while true {
+          continue nonexistent
+        }
+      }
+    `
+    expect(() => compile(src, { namespace: 'test' })).toThrow(/nonexistent/)
+  })
+})

package/src/__tests__/compiler/match-string.test.ts

@@ -0,0 +1,45 @@
+import { compile } from '../../emit/compile'
+
+function allContent(result: ReturnType<typeof compile>): string {
+  return result.files.map(f => f.content).join('\n')
+}
+
+describe('compiler: string match', () => {
+  test('compiles string literal match arms via rs:strings storage checks', () => {
+    const result = compile(`
+      fn handle_cmd(cmd: string): void {
+        match cmd {
+          "help" => { say("help") }
+          "quit" => { say("quit") }
+          _ => { say("other") }
+        }
+      }
+    `, { namespace: 'test' })
+
+    const content = allContent(result)
+    expect(content).toContain('execute store success score $handle_cmd_t0 __test if data storage rs:strings __sp0 matches "help"')
+    expect(content).toContain('execute store success score $handle_cmd_t2 __test if data storage rs:strings __sp0 matches "quit"')
+    expect(content).toContain('say help')
+    expect(content).toContain('say quit')
+    expect(content).toContain('say other')
+  })
+
+  test('copies string call arguments into string parameter slots before matching', () => {
+    const result = compile(`
+      fn handle_cmd(cmd: string): void {
+        match cmd {
+          "help" => { say("help") }
+          _ => { say("other") }
+        }
+      }
+
+      fn main(): void {
+        handle_cmd("help")
+      }
+    `, { namespace: 'test' })
+
+    const content = allContent(result)
+    expect(content).toContain('data modify storage rs:strings __sp0 set from storage rs:strings')
+    expect(content).toContain('set value "help"')
+  })
+})

package/src/__tests__/compiler/memoize.test.ts

@@ -0,0 +1,126 @@
+import { compile } from '../../emit/compile'
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { TypeChecker } from '../../typechecker'
+import type { DiagnosticError } from '../../diagnostics'
+
+function getFile(files: Array<{ path: string; content: string }>, path: string): string {
+  const file = files.find(entry => entry.path === path)
+  if (!file) {
+    throw new Error(`Missing file: ${path}\nFiles:\n${files.map(entry => entry.path).join('\n')}`)
+  }
+  return file.content
+}
+
+function parseDecorators(source: string): Array<{ name: string; args?: Record<string, unknown> }> {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  return ast.declarations[0]?.decorators ?? []
+}
+
+function typeCheck(source: string): DiagnosticError[] {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  return new TypeChecker(source).check(ast)
+}
+
+// ---------------------------------------------------------------------------
+// @memoize tests
+// ---------------------------------------------------------------------------
+
+describe('@memoize decorator', () => {
+  test('parser records @memoize decorator with no args', () => {
+    const decorators = parseDecorators(`
+      @memoize
+      fn fib(n: int): int { 0 }
+    `)
+    expect(decorators).toHaveLength(1)
+    expect(decorators[0].name).toBe('memoize')
+  })
+
+  test('typechecker accepts valid @memoize on single int param function', () => {
+    const errors = typeCheck(`
+      @memoize
+      fn fib(n: int): int { 0 }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('typechecker rejects @memoize on function with no parameters', () => {
+    const errors = typeCheck(`
+      @memoize
+      fn get_value(): int { 0 }
+    `)
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('@memoize')
+    expect(errors[0].message).toContain('exactly one parameter')
+  })
+
+  test('typechecker rejects @memoize on function with non-int parameter', () => {
+    const errors = typeCheck(`
+      @memoize
+      fn compute(x: fixed): int { 0 }
+    `)
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('@memoize')
+    expect(errors[0].message).toContain('int')
+  })
+
+  test('typechecker rejects duplicate @memoize decorators', () => {
+    const errors = typeCheck(`
+      @memoize
+      @memoize
+      fn fib(n: int): int { 0 }
+    `)
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('multiple @memoize')
+  })
+
+  test('emits __memo scoreboard objective in load.mcfunction', () => {
+    const result = compile(`
+      @memoize
+      fn fib(n: int): int {
+        if n <= 1 { return n; }
+        return fib(n - 1) + fib(n - 2);
+      }
+    `, { namespace: 'memo_test' })
+
+    const load = getFile(result.files, 'data/memo_test/function/load.mcfunction')
+    expect(load).toContain('scoreboard objectives add __memo dummy')
+  })
+
+  test('emits memoize wrapper mcfunction with cache-check and cache-store logic', () => {
+    const result = compile(`
+      @memoize
+      fn fib(n: int): int {
+        if n <= 1 { return n; }
+        return fib(n - 1) + fib(n - 2);
+      }
+    `, { namespace: 'memo_test' })
+
+    const wrapper = getFile(result.files, 'data/memo_test/function/fib.mcfunction')
+    // Cache hit branch: check valid flag and key match, copy cached value, return early
+    expect(wrapper).toContain('__memo_fib_hit')
+    expect(wrapper).toContain('__memo_fib_key')
+    expect(wrapper).toContain('__memo_fib_val')
+    expect(wrapper).toContain('return 0')
+    // Cache miss branch: call implementation
+    expect(wrapper).toContain('function memo_test:fib_impl')
+    // Store result
+    expect(wrapper).toContain('scoreboard players set __memo_fib_hit __memo 1')
+  })
+
+  test('emits fib_impl function (renamed original body)', () => {
+    const result = compile(`
+      @memoize
+      fn fib(n: int): int {
+        if n <= 1 { return n; }
+        return fib(n - 1) + fib(n - 2);
+      }
+    `, { namespace: 'memo_test' })
+
+    // The original compiled body should be available as fib_impl
+    const implExists = result.files.some(f => f.path === 'data/memo_test/function/fib_impl.mcfunction')
+    expect(implExists).toBe(true)
+  })
+})

package/src/__tests__/compiler/method-chain.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Tests for struct method chaining (method chaining pattern).
+ * Verifies that impl method calls can be chained: v.scale(2).add(other).len_sq()
+ */
+
+import { compile } from '../../emit/compile'
+
+const VEC2_SRC = `
+  struct Vec2 { x: int, y: int }
+
+  impl Vec2 {
+    fn scale(self, factor: int): Vec2 {
+      return Vec2 { x: self.x * factor, y: self.y * factor }
+    }
+    fn add(self, other: Vec2): Vec2 {
+      return Vec2 { x: self.x + other.x, y: self.y + other.y }
+    }
+    fn len_sq(self): int {
+      return self.x * self.x + self.y * self.y
+    }
+  }
+`
+
+describe('method chaining: compile', () => {
+  test('simple two-step chain compiles without error', () => {
+    const src = `
+      ${VEC2_SRC}
+      @keep fn test(): void {
+        let v: Vec2 = Vec2 { x: 3, y: 4 }
+        let v2: Vec2 = v.scale(2)
+        let result: Vec2 = v2.add(Vec2 { x: 1, y: 0 })
+      }
+    `
+    expect(() => compile(src, { namespace: 'test' })).not.toThrow()
+  })
+
+  test('two-method chain v.scale(2).add(...) compiles without error', () => {
+    const src = `
+      ${VEC2_SRC}
+      @keep fn test(): void {
+        let v: Vec2 = Vec2 { x: 3, y: 4 }
+        let result: Vec2 = v.scale(2).add(Vec2 { x: 1, y: 0 })
+      }
+    `
+    expect(() => compile(src, { namespace: 'test' })).not.toThrow()
+  })
+
+  test('three-method chain v.scale(2).add(...).len_sq() compiles without error', () => {
+    const src = `
+      ${VEC2_SRC}
+      @keep fn test(): void {
+        let v: Vec2 = Vec2 { x: 3, y: 4 }
+        let result: int = v.scale(2).add(Vec2 { x: 1, y: 0 }).len_sq()
+      }
+    `
+    expect(() => compile(src, { namespace: 'test' })).not.toThrow()
+  })
+
+  test('two-method chain emits call to scale and add functions', () => {
+    const src = `
+      ${VEC2_SRC}
+      @keep fn test(): void {
+        let v: Vec2 = Vec2 { x: 3, y: 4 }
+        let result: Vec2 = v.scale(2).add(Vec2 { x: 1, y: 0 })
+      }
+    `
+    const result = compile(src, { namespace: 'test' })
+    const allContent = result.files.map(f => f.content).join('\n')
+    // scale and add should be emitted as functions
+    const allPaths = result.files.map(f => f.path).join('\n')
+    expect(allPaths).toMatch(/scale/)
+    expect(allPaths).toMatch(/add/)
+  })
+
+  test('three-method chain emits scale, add, and len_sq functions', () => {
+    const src = `
+      ${VEC2_SRC}
+      @keep fn test(): void {
+        let v: Vec2 = Vec2 { x: 3, y: 4 }
+        let result: int = v.scale(2).add(Vec2 { x: 1, y: 0 }).len_sq()
+      }
+    `
+    const result = compile(src, { namespace: 'test' })
+    const allPaths = result.files.map(f => f.path).join('\n')
+    expect(allPaths).toMatch(/scale/)
+    expect(allPaths).toMatch(/add/)
+    expect(allPaths).toMatch(/len_sq/)
+  })
+
+  test('chained method result as function argument compiles', () => {
+    const src = `
+      ${VEC2_SRC}
+      @keep fn use_len(n: int): void {}
+      @keep fn test(): void {
+        let v: Vec2 = Vec2 { x: 1, y: 2 }
+        use_len(v.scale(3).len_sq())
+      }
+    `
+    expect(() => compile(src, { namespace: 'test' })).not.toThrow()
+  })
+
+  test('Counter increment chain: c.increment().increment() compiles', () => {
+    const src = `
+      struct Counter { value: int }
+      impl Counter {
+        fn increment(self): Counter {
+          return Counter { value: self.value + 1 }
+        }
+        fn get(self): int {
+          return self.value
+        }
+      }
+      @keep fn test(): void {
+        let c: Counter = Counter { value: 0 }
+        let c3: Counter = c.increment().increment()
+        let v: int = c3.get()
+      }
+    `
+    expect(() => compile(src, { namespace: 'test' })).not.toThrow()
+  })
+})