redscript-mc 2.6.2 → 3.0.0

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

@@ -0,0 +1,310 @@
+/**
+ * Tests for enhanced string features:
+ * - Enhanced f-string interpolation (expressions, function calls, array indexing)
+ * - Multi-line triple-quoted strings
+ * - int_to_str / bool_to_str builtin functions
+ */
+
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { lowerToHIR } from '../../hir/lower'
+import { lowerToMIR } from '../../mir/lower'
+import { verifyMIR } from '../../mir/verify'
+import { compile } from '../../emit/compile'
+import { TypeChecker } from '../../typechecker'
+
+function parse(source: string) {
+  const tokens = new Lexer(source).tokenize()
+  return new Parser(tokens, source).parse('test')
+}
+
+function compileSource(source: string, namespace = 'test') {
+  return compile(source, { namespace })
+}
+
+function typeCheck(source: string) {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens, source).parse('test')
+  const tc = new TypeChecker(source, 'test')
+  return tc.check(ast)
+}
+
+// ---------------------------------------------------------------------------
+// Multi-line strings
+// ---------------------------------------------------------------------------
+
+describe('multi-line triple-quoted strings', () => {
+  test('lexer tokenizes triple-quoted string as string_lit', () => {
+    const tokens = new Lexer('"""Hello\nWorld"""').tokenize()
+    expect(tokens[0].kind).toBe('string_lit')
+    expect(tokens[0].value).toBe('Hello\nWorld')
+  })
+
+  test('triple-quoted string with leading/trailing newlines is trimmed', () => {
+    const tokens = new Lexer('"""\nHello\nWorld\n"""').tokenize()
+    expect(tokens[0].kind).toBe('string_lit')
+    expect(tokens[0].value).toBe('Hello\nWorld')
+  })
+
+  test('triple-quoted string compiles in let binding', () => {
+    expect(() => compileSource(`
+      fn test() {
+        let msg: string = """
+Hello
+World
+"""
+        say(msg)
+      }
+    `)).not.toThrow()
+  })
+
+  test('typechecker accepts triple-quoted string as string type', () => {
+    const errors = typeCheck(`
+fn test() {
+  let msg: string = """
+  Hello
+  World
+  """
+}
+`)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('triple-quoted string with interpolation content parses correctly', () => {
+    const ast = parse(`
+fn test() {
+  let s: string = """Line 1
+Line 2"""
+}
+`)
+    expect(ast.declarations).toHaveLength(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Enhanced f-string interpolation
+// ---------------------------------------------------------------------------
+
+describe('enhanced f-string interpolation', () => {
+  test('f-string with simple variable compiles', () => {
+    expect(() => compileSource(`
+      fn test() {
+        let x: int = 5
+        tellraw(@a, f"Value: {x}")
+      }
+    `)).not.toThrow()
+  })
+
+  test('f-string with binary expression compiles', () => {
+    expect(() => compileSource(`
+      fn test() {
+        let x: int = 5
+        tellraw(@a, f"Result: {x + 1}")
+      }
+    `)).not.toThrow()
+  })
+
+  test('f-string with arithmetic expression compiles', () => {
+    expect(() => compileSource(`
+      fn test() {
+        let a: int = 3
+        let b: int = 4
+        tellraw(@a, f"Product: {a * b}")
+      }
+    `)).not.toThrow()
+  })
+
+  test('f-string with function call expression compiles', () => {
+    expect(() => compileSource(`
+      fn double(n: int): int {
+        return n * 2
+      }
+      fn test() {
+        let x: int = 5
+        tellraw(@a, f"Doubled: {double(x)}")
+      }
+    `)).not.toThrow()
+  })
+
+  test('f-string passes MIR verification with expression interpolation', () => {
+    const source = `
+      fn test() {
+        let x: int = 5
+        tellraw(@a, f"Result: {x + 1}")
+      }
+    `
+    const ast = parse(source)
+    const hir = lowerToHIR(ast)
+    const mir = lowerToMIR(hir)
+    expect(verifyMIR(mir)).toEqual([])
+  })
+
+  test('f-string with multiple complex parts compiles', () => {
+    expect(() => compileSource(`
+      fn test() {
+        let a: int = 3
+        let b: int = 4
+        tellraw(@a, f"Sum: {a + b}, Product: {a * b}")
+      }
+    `)).not.toThrow()
+  })
+
+  test('f-string with text-only parts still works', () => {
+    expect(() => compileSource(`
+      fn test() {
+        tellraw(@a, f"Hello World")
+      }
+    `)).not.toThrow()
+  })
+
+  test('f-string generates JSON text component with score reference for ident', () => {
+    const source = `
+      fn test() {
+        let score: int = 10
+        tellraw(@a, f"Score: {score}")
+      }
+    `
+    const result = compileSource(source, 'myns')
+    // result is CompileResult with .files array of { path, content }
+    const allContent = result.files.map(f => f.content).join('\n')
+    expect(allContent).toContain('tellraw')
+    // Should contain a JSON text component with 'text' or 'score'
+    expect(allContent.includes('score') || allContent.includes('text')).toBe(true)
+  })
+
+  test('f-string with expression generates precomputed temp in MIR', () => {
+    const source = `
+      fn test() {
+        let x: int = 5
+        tellraw(@a, f"Val: {x + 1}")
+      }
+    `
+    const ast = parse(source)
+    const hir = lowerToHIR(ast)
+    const mir = lowerToMIR(hir)
+    const fn = mir.functions.find(f => f.name === 'test')
+    expect(fn).toBeDefined()
+    // Should have emitted arithmetic instructions for x + 1
+    const allInstrs = fn!.blocks.flatMap(b => b.instrs)
+    // MIR arithmetic uses 'add', 'sub', 'mul', etc. (not 'arith')
+    const arithInstrs = allInstrs.filter(i => ['add', 'sub', 'mul', 'div'].includes(i.kind))
+    expect(arithInstrs.length).toBeGreaterThan(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// int_to_str and bool_to_str
+// ---------------------------------------------------------------------------
+
+describe('int_to_str builtin', () => {
+  test('int_to_str is accepted by typechecker', () => {
+    const errors = typeCheck(`
+fn test() {
+  let n: int = 42
+  let s: string = int_to_str(n)
+}
+`)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('int_to_str in f-string compiles', () => {
+    expect(() => compileSource(`
+      fn test() {
+        let n: int = 42
+        tellraw(@a, f"Value: {int_to_str(n)}")
+      }
+    `)).not.toThrow()
+  })
+
+  test('int_to_str standalone compiles', () => {
+    expect(() => compileSource(`
+      fn test() {
+        let n: int = 42
+        let s: string = int_to_str(n)
+      }
+    `)).not.toThrow()
+  })
+
+  test('int_to_str passes MIR verification', () => {
+    const source = `
+      fn test() {
+        let n: int = 42
+        let s: string = int_to_str(n)
+      }
+    `
+    const ast = parse(source)
+    const hir = lowerToHIR(ast)
+    const mir = lowerToMIR(hir)
+    expect(verifyMIR(mir)).toEqual([])
+  })
+})
+
+describe('bool_to_str builtin', () => {
+  test('bool_to_str is accepted by typechecker', () => {
+    const errors = typeCheck(`
+fn test() {
+  let b: bool = true
+  let s: string = bool_to_str(b)
+}
+`)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('bool_to_str in f-string compiles', () => {
+    expect(() => compileSource(`
+      fn test() {
+        let b: bool = true
+        tellraw(@a, f"Active: {bool_to_str(b)}")
+      }
+    `)).not.toThrow()
+  })
+
+  test('bool_to_str passes MIR verification', () => {
+    const source = `
+      fn test() {
+        let b: bool = false
+        let s: string = bool_to_str(b)
+      }
+    `
+    const ast = parse(source)
+    const hir = lowerToHIR(ast)
+    const mir = lowerToMIR(hir)
+    expect(verifyMIR(mir)).toEqual([])
+  })
+
+  test('bool_to_str in title builtin compiles', () => {
+    expect(() => compileSource(`
+      fn test() {
+        let active: bool = true
+        title(@a, f"Active: {bool_to_str(active)}")
+      }
+    `)).not.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Integration: combined features
+// ---------------------------------------------------------------------------
+
+describe('combined string features', () => {
+  test('multi-line string with f-string expression compiles', () => {
+    expect(() => compileSource(`
+      fn test() {
+        let x: int = 10
+        let msg: string = """Hello World"""
+        tellraw(@a, f"Score: {x + 5}")
+      }
+    `)).not.toThrow()
+  })
+
+  test('int_to_str and f-string with arithmetic in same function', () => {
+    expect(() => compileSource(`
+      fn test() {
+        let n: int = 5
+        let doubled: int = n * 2
+        let s: string = int_to_str(doubled)
+        tellraw(@a, f"Value: {n + 1}, Doubled str: {int_to_str(n * 2)}")
+      }
+    `)).not.toThrow()
+  })
+})

package/src/__tests__/compiler/struct-extends.test.ts

@@ -0,0 +1,109 @@
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { lowerToHIR } from '../../hir/lower'
+import { compile } from '../../emit/compile'
+import { TypeChecker } from '../../typechecker'
+
+function parse(source: string) {
+  const tokens = new Lexer(source).tokenize()
+  return new Parser(tokens, source).parse('test')
+}
+
+function typeCheck(source: string) {
+  const program = parse(source)
+  return new TypeChecker(source).check(program)
+}
+
+describe('struct-extends: parser', () => {
+  test('parses extends clause on struct declarations', () => {
+    const program = parse(`
+      struct Animal { name: string, hp: int }
+      struct Dog extends Animal { breed: string }
+    `)
+
+    expect(program.structs).toHaveLength(2)
+    expect(program.structs[1].name).toBe('Dog')
+    expect(program.structs[1].extends).toBe('Animal')
+    expect(program.structs[1].fields.map(field => field.name)).toEqual(['breed'])
+  })
+})
+
+describe('struct-extends: HIR lowering', () => {
+  test('expands inherited fields before child fields', () => {
+    const hir = lowerToHIR(parse(`
+      struct Animal { name: string, hp: int }
+      struct Dog extends Animal { breed: string }
+    `))
+
+    expect(hir.structs[1].fields.map(field => field.name)).toEqual(['name', 'hp', 'breed'])
+  })
+
+  test('expands multi-level inheritance transitively', () => {
+    const hir = lowerToHIR(parse(`
+      struct Base { id: int }
+      struct Animal extends Base { hp: int }
+      struct Dog extends Animal { breed: string }
+    `))
+
+    expect(hir.structs[2].fields.map(field => field.name)).toEqual(['id', 'hp', 'breed'])
+  })
+})
+
+describe('struct-extends: typechecker', () => {
+  test('accepts inherited fields in struct literals', () => {
+    const errors = typeCheck(`
+      struct Animal { name: string, hp: int }
+      struct Dog extends Animal { breed: string }
+      fn make(): Dog {
+        return Dog { name: "Rex", hp: 10, breed: "Corgi" }
+      }
+    `)
+
+    expect(errors).toHaveLength(0)
+  })
+
+  test('accepts multi-level inherited field access', () => {
+    const errors = typeCheck(`
+      struct Base { id: int }
+      struct Animal extends Base { hp: int }
+      struct Dog extends Animal { breed: string }
+      fn id_of(d: Dog): int {
+        return d.id
+      }
+    `)
+
+    expect(errors).toHaveLength(0)
+  })
+
+  test('reports overriding an inherited field', () => {
+    const errors = typeCheck(`
+      struct Animal { name: string, hp: int }
+      struct Dog extends Animal { hp: int, breed: string }
+    `)
+
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain("Struct 'Dog' cannot override inherited field 'hp'")
+  })
+
+  test('reports unknown parent struct', () => {
+    const errors = typeCheck(`
+      struct Dog extends Animal { breed: string }
+    `)
+
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain("Struct 'Dog' extends unknown struct 'Animal'")
+  })
+})
+
+describe('struct-extends: compile', () => {
+  test('compiles inherited structs as flattened plain structs', () => {
+    expect(() => compile(`
+      struct Animal { name: string, hp: int }
+      struct Dog extends Animal { breed: string }
+      @keep fn main(): void {
+        let dog: Dog = Dog { name: "Rex", hp: 10, breed: "Corgi" }
+        let hp: int = dog.hp
+      }
+    `, { namespace: 'test' })).not.toThrow()
+  })
+})

package/src/__tests__/compiler/throttle-retry.test.ts

@@ -0,0 +1,191 @@
+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)
+}
+
+// ---------------------------------------------------------------------------
+// @throttle tests
+// ---------------------------------------------------------------------------
+
+describe('@throttle decorator', () => {
+  test('parser records @throttle with ticks argument', () => {
+    const decorators = parseDecorators(`
+      @throttle(ticks=20)
+      fn on_player_move() {}
+    `)
+    expect(decorators).toHaveLength(1)
+    expect(decorators[0].name).toBe('throttle')
+    expect(decorators[0].args?.ticks).toBe(20)
+  })
+
+  test('typechecker rejects @throttle without ticks argument', () => {
+    const errors = typeCheck(`
+      @throttle(ticks=0)
+      fn on_player_move() {}
+    `)
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('@throttle')
+  })
+
+  test('typechecker rejects duplicate @throttle decorators', () => {
+    const errors = typeCheck(`
+      @throttle(ticks=10)
+      @throttle(ticks=20)
+      fn on_player_move() {}
+    `)
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('multiple @throttle')
+  })
+
+  test('typechecker accepts valid @throttle decorator', () => {
+    const errors = typeCheck(`
+      @throttle(ticks=20)
+      fn on_player_move() {}
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('emits throttle objective in load.mcfunction', () => {
+    const result = compile(`
+      @throttle(ticks=20)
+      fn on_player_move() {
+        say("moved");
+      }
+    `, { namespace: 'throttle_test' })
+
+    const load = getFile(result.files, 'data/throttle_test/function/load.mcfunction')
+    expect(load).toContain('scoreboard objectives add __throttle dummy')
+  })
+
+  test('emits throttle dispatcher mcfunction with correct scoreboard commands', () => {
+    const result = compile(`
+      @throttle(ticks=20)
+      fn on_player_move() {
+        say("moved");
+      }
+    `, { namespace: 'throttle_test' })
+
+    const dispatcher = getFile(result.files, 'data/throttle_test/function/__throttle_on_player_move.mcfunction')
+    expect(dispatcher).toContain('scoreboard players add __throttle_on_player_move __throttle 1')
+    expect(dispatcher).toContain('execute if score __throttle_on_player_move __throttle matches 20.. run function throttle_test:on_player_move_inner')
+    expect(dispatcher).toContain('execute if score __throttle_on_player_move __throttle matches 20.. run scoreboard players set __throttle_on_player_move __throttle 0')
+  })
+
+  test('registers throttle dispatcher in tick.json', () => {
+    const result = compile(`
+      @throttle(ticks=20)
+      fn on_player_move() {
+        say("moved");
+      }
+    `, { namespace: 'throttle_test' })
+
+    const tick = JSON.parse(getFile(result.files, 'data/minecraft/tags/function/tick.json'))
+    expect(tick.values).toContain('throttle_test:__throttle_on_player_move')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// @retry tests
+// ---------------------------------------------------------------------------
+
+describe('@retry decorator', () => {
+  test('parser records @retry with max argument', () => {
+    const decorators = parseDecorators(`
+      @retry(max=3)
+      fn try_spawn_mob(): int { 0 }
+    `)
+    expect(decorators).toHaveLength(1)
+    expect(decorators[0].name).toBe('retry')
+    expect(decorators[0].args?.max).toBe(3)
+  })
+
+  test('typechecker rejects @retry without max argument', () => {
+    const errors = typeCheck(`
+      @retry(max=0)
+      fn try_spawn_mob(): int { 0 }
+    `)
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('@retry')
+  })
+
+  test('typechecker rejects duplicate @retry decorators', () => {
+    const errors = typeCheck(`
+      @retry(max=3)
+      @retry(max=5)
+      fn try_spawn_mob(): int { 0 }
+    `)
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('multiple @retry')
+  })
+
+  test('typechecker accepts valid @retry decorator', () => {
+    const errors = typeCheck(`
+      @retry(max=3)
+      fn try_spawn_mob(): int { 0 }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('emits retry objective in load.mcfunction', () => {
+    const result = compile(`
+      @retry(max=3)
+      fn try_spawn_mob(): int { 0 }
+    `, { namespace: 'retry_test' })
+
+    const load = getFile(result.files, 'data/retry_test/function/load.mcfunction')
+    expect(load).toContain('scoreboard objectives add __retry dummy')
+  })
+
+  test('emits retry dispatcher mcfunction with correct scoreboard commands', () => {
+    const result = compile(`
+      @retry(max=3)
+      fn try_spawn_mob(): int { 0 }
+    `, { namespace: 'retry_test' })
+
+    const dispatcher = getFile(result.files, 'data/retry_test/function/__retry_try_spawn_mob.mcfunction')
+    expect(dispatcher).toContain('execute if score __retry_try_spawn_mob __retry matches 1.. run function retry_test:try_spawn_mob')
+    expect(dispatcher).toContain('execute if score __retry_try_spawn_mob __retry matches 1.. if score $ret __retry matches 0 run scoreboard players remove __retry_try_spawn_mob __retry 1')
+    expect(dispatcher).toContain('execute if score __retry_try_spawn_mob __retry matches 1.. unless score $ret __retry matches 0 run scoreboard players set __retry_try_spawn_mob __retry 0')
+  })
+
+  test('emits retry start helper function with max count', () => {
+    const result = compile(`
+      @retry(max=3)
+      fn try_spawn_mob(): int { 0 }
+    `, { namespace: 'retry_test' })
+
+    const start = getFile(result.files, 'data/retry_test/function/try_spawn_mob_start.mcfunction')
+    expect(start).toContain('scoreboard players set __retry_try_spawn_mob __retry 3')
+  })
+
+  test('registers retry dispatcher in tick.json', () => {
+    const result = compile(`
+      @retry(max=3)
+      fn try_spawn_mob(): int { 0 }
+    `, { namespace: 'retry_test' })
+
+    const tick = JSON.parse(getFile(result.files, 'data/minecraft/tags/function/tick.json'))
+    expect(tick.values).toContain('retry_test:__retry_try_spawn_mob')
+  })
+})