redscript-mc 3.0.1 → 3.0.2

package/src/__tests__/mc-integration/say-fstring.test.ts

@@ -0,0 +1,211 @@
+/**
+ * RedScript MC Integration Tests — say() with f-string
+ *
+ * Verifies that say(f"...{var}...") correctly compiles to a MC macro function
+ * ($say template with $(var) placeholders) and that variable interpolation
+ * works correctly at runtime via `function <helper> with storage rs:macro_args`.
+ *
+ * Run: npx jest say-fstring --forceExit
+ * With server: MC_SERVER_DIR=~/mc-test-server MC_PORT=25561 npx jest say-fstring --forceExit
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+import { compile } from '../../compile'
+import { MCTestClient } from '../../mc-test/client'
+
+const MC_HOST = process.env.MC_HOST ?? 'localhost'
+const MC_PORT = parseInt(process.env.MC_PORT ?? '25561')
+const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME!, 'mc-test-server')
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test')
+
+const NS = 'rs_say_fstr'
+
+let serverOnline = false
+let mc: MCTestClient
+
+function writeFixture(source: string, namespace: string): void {
+  fs.mkdirSync(DATAPACK_DIR, { recursive: true })
+  if (!fs.existsSync(path.join(DATAPACK_DIR, 'pack.mcmeta'))) {
+    fs.writeFileSync(
+      path.join(DATAPACK_DIR, 'pack.mcmeta'),
+      JSON.stringify({ pack: { pack_format: 48, description: 'RedScript integration tests' } })
+    )
+  }
+  const result = compile(source, { namespace })
+  for (const file of result.files ?? []) {
+    if (file.path === 'pack.mcmeta') continue
+    const filePath = path.join(DATAPACK_DIR, file.path)
+    fs.mkdirSync(path.dirname(filePath), { recursive: true })
+    if (file.path.includes('data/minecraft/tags/') && fs.existsSync(filePath)) {
+      const existing = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+      const incoming = JSON.parse(file.content)
+      const merged = { values: [...new Set([...(existing.values ?? []), ...(incoming.values ?? [])])] }
+      fs.writeFileSync(filePath, JSON.stringify(merged, null, 2))
+    } else {
+      fs.writeFileSync(filePath, file.content)
+    }
+  }
+}
+
+beforeAll(async () => {
+  if (process.env.MC_OFFLINE === 'true') {
+    console.warn('⚠ MC_OFFLINE=true — skipping say-fstring integration tests')
+    return
+  }
+
+  mc = new MCTestClient(MC_HOST, MC_PORT)
+
+  try {
+    const deadline = Date.now() + 10_000
+    while (Date.now() < deadline) {
+      if (await mc.isOnline()) { serverOnline = true; break }
+      await new Promise(r => setTimeout(r, 1000))
+    }
+  } catch {
+    serverOnline = false
+  }
+
+  if (!serverOnline) {
+    console.warn('⚠ MC server not running — say-fstring runtime tests will be skipped')
+    return
+  }
+
+  await mc.command('/scoreboard objectives add sf_out dummy').catch(() => {})
+  await mc.ticks(2)
+
+  writeFixture(`
+    module ${NS}
+
+    let counter: int = 0;
+
+    @keep fn say_plain() {
+      say(f"Hello world");
+    }
+
+    @keep fn say_with_var() {
+      counter = 42;
+      say(f"Counter is {counter}");
+    }
+
+    @keep fn say_multivar() {
+      let a: int = 10;
+      let b: int = 20;
+      say(f"a={a} b={b}");
+    }
+
+    @keep fn say_expr() {
+      let x: int = 5;
+      let y: int = x + 3;
+      say(f"result={y}");
+    }
+
+    // Side-effect: sets sf_out scoreboard so we can detect the function ran
+    @keep fn say_and_score() {
+      counter = 99;
+      say(f"Score is {counter}");
+      scoreboard_set("#sf_ran", "sf_out", 1);
+    }
+  `, NS)
+
+  await mc.reload()
+  await mc.ticks(5)
+  console.log('  say-fstring setup complete.')
+}, 30_000)
+
+// ---------------------------------------------------------------------------
+// Compile-time tests (no server needed)
+// ---------------------------------------------------------------------------
+
+describe('say() f-string: compile output', () => {
+  test('say(f"plain text") compiles without error', () => {
+    expect(() =>
+      compile(`@keep fn f() { say(f"Hello world"); }`, { namespace: 'tmp' })
+    ).not.toThrow()
+  })
+
+  test('say(f"...{var}...") emits macro helper function', () => {
+    const result = compile(`
+      let counter: int = 0;
+      @keep fn f() { say(f"Count: {counter}"); }
+    `, { namespace: 'tmp' })
+
+    const helperFile = result.files?.find(f => f.path.includes('__say_macro'))
+    expect(helperFile).toBeDefined()
+    expect(helperFile?.content).toContain('$say Count: $(counter)')
+  })
+
+  test('say(f"...{var}...") emits storage copy + function with storage call', () => {
+    const result = compile(`
+      let counter: int = 0;
+      @keep fn f() { say(f"Count: {counter}"); }
+    `, { namespace: 'tmp' })
+
+    const mainFn = result.files?.find(f => f.path.endsWith('f.mcfunction'))
+    expect(mainFn?.content).toContain('execute store result storage rs:macro_args counter int 1')
+    expect(mainFn?.content).toContain('with storage rs:macro_args')
+  })
+
+  test('say(f"no vars") still uses function macro (safe fallback)', () => {
+    const result = compile(`
+      @keep fn f() { say(f"Hello world"); }
+    `, { namespace: 'tmp' })
+
+    // No storage copy needed (no vars), but still goes through macro helper
+    const helperFile = result.files?.find(f => f.path.includes('__say_macro'))
+    expect(helperFile).toBeDefined()
+    expect(helperFile?.content).toContain('$say Hello world')
+  })
+
+  test('say("plain string") still uses inline say command (not macro)', () => {
+    const result = compile(`
+      @keep fn f() { say("Hello world"); }
+    `, { namespace: 'tmp' })
+
+    const mainFn = result.files?.find(f => f.path.endsWith('f.mcfunction'))
+    expect(mainFn?.content).toContain('say Hello world')
+    expect(mainFn?.content).not.toContain('with storage')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Runtime tests (server required)
+// ---------------------------------------------------------------------------
+
+describe('say() f-string: runtime', () => {
+  test('say(f"...{var}...") function runs without error', async () => {
+    if (!serverOnline) return
+
+    // If this throws, the macro function failed to load or execute
+    await expect(mc.command(`/function ${NS}:say_with_var`)).resolves.not.toThrow()
+    await mc.ticks(5)
+  }, 20_000)
+
+  test('say(f"Score is {counter}") sets scoreboard correctly', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/scoreboard players set #sf_ran sf_out 0')
+    await mc.ticks(2)
+    await mc.command(`/function ${NS}:say_and_score`)
+    await mc.ticks(5)
+
+    // If scoreboard was set, the function ran fully (macro didn't crash)
+    const score = await mc.scoreboard('#sf_ran', 'sf_out')
+    expect(score).toBe(1)
+    console.log('  say_and_score ran successfully ✓')
+  }, 20_000)
+
+  test('say(f"plain text") runs without error', async () => {
+    if (!serverOnline) return
+
+    await expect(mc.command(`/function ${NS}:say_plain`)).resolves.not.toThrow()
+    await mc.ticks(3)
+  }, 20_000)
+
+  test('say(f"a={a} b={b}") multi-variable runs without error', async () => {
+    if (!serverOnline) return
+
+    await expect(mc.command(`/function ${NS}:say_multivar`)).resolves.not.toThrow()
+    await mc.ticks(3)
+  }, 20_000)
+})

package/src/__tests__/mc-integration/stdlib-coverage-2.test.ts

@@ -19,7 +19,7 @@ import { MCTestClient } from '../../mc-test/client'
 const MC_HOST = process.env.MC_HOST ?? 'localhost'
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561')
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME!, 'mc-test-server')
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test2')
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test')
 
 const STDLIB_DIR = path.join(__dirname, '../../stdlib')
 

package/src/__tests__/mc-integration/stdlib-coverage-3.test.ts

@@ -19,7 +19,7 @@ import { MCTestClient } from '../../mc-test/client'
 const MC_HOST = process.env.MC_HOST ?? 'localhost'
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561')
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME!, 'mc-test-server')
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test3')
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test')
 
 const STDLIB_DIR = path.join(__dirname, '../../stdlib')
 

package/src/__tests__/mc-integration/stdlib-coverage-4.test.ts

@@ -19,7 +19,7 @@ import { MCTestClient } from '../../mc-test/client'
 const MC_HOST = process.env.MC_HOST ?? 'localhost'
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561')
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME!, 'mc-test-server')
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test4')
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test')
 
 const STDLIB_DIR = path.join(__dirname, '../../stdlib')
 

package/src/__tests__/mc-integration/stdlib-coverage-5.test.ts

@@ -20,7 +20,7 @@ import { MCTestClient } from '../../mc-test/client'
 const MC_HOST = process.env.MC_HOST ?? 'localhost'
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561')
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME!, 'mc-test-server')
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test5')
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test')
 
 const STDLIB_DIR = path.join(__dirname, '../../stdlib')
 

package/src/__tests__/mc-integration/stdlib-coverage-6.test.ts

@@ -16,7 +16,7 @@ import { MCTestClient } from '../../mc-test/client'
 const MC_HOST = process.env.MC_HOST ?? 'localhost'
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561')
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME!, 'mc-test-server')
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test6')
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test')
 const STDLIB_DIR = path.join(__dirname, '../../stdlib')
 
 const BOT_URL = 'http://localhost:25562'

package/src/__tests__/mc-integration/stdlib-coverage-7.test.ts

@@ -19,7 +19,7 @@ import { MCTestClient } from '../../mc-test/client'
 const MC_HOST = process.env.MC_HOST ?? 'localhost'
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561')
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME!, 'mc-test-server')
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test7')
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test')
 
 const STDLIB_DIR = path.join(__dirname, '../../stdlib')
 

package/src/__tests__/mc-integration/stdlib-coverage-8.test.ts

@@ -15,7 +15,7 @@ import { MCTestClient } from '../../mc-test/client'
 const MC_HOST = process.env.MC_HOST ?? 'localhost'
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561')
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME!, 'mc-test-server')
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test8')
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test')
 const STDLIB_DIR = path.join(__dirname, '../../stdlib')
 
 let serverOnline = false

package/src/__tests__/mc-syntax.test.ts

@@ -16,6 +16,9 @@ function getCommands(source: string, namespace = 'test'): string[] {
     .filter(file => file.path.endsWith('.mcfunction'))
     .flatMap(file => file.content.split('\n'))
     .filter(line => line.trim().length > 0)
+    .filter(line => !line.startsWith('#'))                     // skip comments
+    .filter(line => !line.startsWith('$'))                     // skip MC macro lines ($say, $data, etc.)
+    .filter(line => !/ with storage /.test(line))              // skip macro function calls
 }
 
 function validateSource(

package/src/__tests__/monomorphize-coverage.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Additional coverage for src/hir/monomorphize.ts
+ *
+ * Targets uncovered branches: typeSuffix edge cases, substType for
+ * function_type and option, rewriteStmt for labeled_loop/break_label/
+ * continue_label, rewriteExpr for is_check/some_lit/none_lit/unwrap_or,
+ * and type inference from literals.
+ */
+
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { monomorphize } from '../hir/monomorphize'
+import { lowerToHIR } from '../hir/lower'
+import type { Program } from '../ast/types'
+
+function parse(source: string): Program {
+  const tokens = new Lexer(source).tokenize()
+  return new Parser(tokens, source).parse('test')
+}
+
+function monoFromSource(source: string) {
+  const program = parse(source)
+  const hir = lowerToHIR(program)
+  return monomorphize(hir)
+}
+
+describe('monomorphize — basic specialization', () => {
+  it('creates specialized copy for fn identity<T>(x: T): T', () => {
+    const result = monoFromSource(`
+      fn identity<T>(x: T): T { return x; }
+      fn main(): int { return identity<int>(42); }
+    `)
+    const names = result.functions.map(f => f.name)
+    expect(names).toContain('identity_int')
+    expect(names).not.toContain('identity') // template removed
+  })
+
+  it('creates multiple specializations for different type args', () => {
+    const result = monoFromSource(`
+      fn identity<T>(x: T): T { return x; }
+      fn main(): int {
+        let a: int = identity<int>(1);
+        let b: bool = identity<bool>(true);
+        return a;
+      }
+    `)
+    const names = result.functions.map(f => f.name)
+    expect(names).toContain('identity_int')
+    expect(names).toContain('identity_bool')
+  })
+
+  it('deduplicates same specialization called multiple times', () => {
+    const result = monoFromSource(`
+      fn double<T>(x: T): T { return x; }
+      fn main(): int {
+        let a: int = double<int>(1);
+        let b: int = double<int>(2);
+        return a + b;
+      }
+    `)
+    const intCopies = result.functions.filter(f => f.name === 'double_int')
+    expect(intCopies.length).toBe(1)
+  })
+})
+
+describe('monomorphize — type inference from arguments', () => {
+  it('infers type arg from int literal', () => {
+    const result = monoFromSource(`
+      fn max<T>(a: T, b: T): T {
+        if a > b { return a; }
+        return b;
+      }
+      fn main(): int { return max(3, 5); }
+    `)
+    const names = result.functions.map(f => f.name)
+    expect(names).toContain('max_int')
+  })
+
+  it('infers type arg from bool literal', () => {
+    const result = monoFromSource(`
+      fn identity<T>(x: T): T { return x; }
+      fn main(): bool { return identity(true); }
+    `)
+    const names = result.functions.map(f => f.name)
+    expect(names).toContain('identity_bool')
+  })
+
+  it('infers type arg from string literal', () => {
+    const result = monoFromSource(`
+      fn identity<T>(x: T): T { return x; }
+      fn main(): string { return identity("hello"); }
+    `)
+    const names = result.functions.map(f => f.name)
+    expect(names).toContain('identity_string')
+  })
+
+  it('infers type arg from variable type', () => {
+    const result = monoFromSource(`
+      fn identity<T>(x: T): T { return x; }
+      fn main(): int {
+        let n: int = 42;
+        return identity(n);
+      }
+    `)
+    const names = result.functions.map(f => f.name)
+    expect(names).toContain('identity_int')
+  })
+})
+
+describe('monomorphize — no generics fast path', () => {
+  it('returns module unchanged when no generic functions exist', () => {
+    const result = monoFromSource(`
+      fn add(a: int, b: int): int { return a + b; }
+      fn main(): int { return add(1, 2); }
+    `)
+    const names = result.functions.map(f => f.name)
+    expect(names).toContain('add')
+    expect(names).toContain('main')
+  })
+})
+
+describe('monomorphize — generic calling generic', () => {
+  it('handles generic function calling another generic', () => {
+    const result = monoFromSource(`
+      fn min<T>(a: T, b: T): T {
+        if a < b { return a; }
+        return b;
+      }
+      fn max<T>(a: T, b: T): T {
+        if a > b { return a; }
+        return b;
+      }
+      fn clamp<T>(x: T, lo: T, hi: T): T {
+        return min<T>(max<T>(x, lo), hi);
+      }
+      fn main(): int { return clamp<int>(5, 0, 10); }
+    `)
+    const names = result.functions.map(f => f.name)
+    expect(names).toContain('clamp_int')
+    expect(names).toContain('min_int')
+    expect(names).toContain('max_int')
+  })
+})
+
+describe('monomorphize — statement rewriting', () => {
+  it('rewrites let statements inside generic functions', () => {
+    const result = monoFromSource(`
+      fn wrap<T>(x: T): T {
+        let temp: T = x;
+        return temp;
+      }
+      fn main(): int { return wrap<int>(42); }
+    `)
+    const wrapInt = result.functions.find(f => f.name === 'wrap_int')
+    expect(wrapInt).toBeDefined()
+    // The let statement's type should be substituted
+    const letStmt = wrapInt!.body[0]
+    if (letStmt.kind === 'let' && letStmt.type) {
+      expect(letStmt.type.kind).toBe('named')
+    }
+  })
+
+  it('rewrites if statements inside generic functions', () => {
+    const result = monoFromSource(`
+      fn abs<T>(x: T): T {
+        if x < 0 { return 0 - x; }
+        return x;
+      }
+      fn main(): int { return abs<int>(-5); }
+    `)
+    const absInt = result.functions.find(f => f.name === 'abs_int')
+    expect(absInt).toBeDefined()
+  })
+
+  it('rewrites return statements', () => {
+    const result = monoFromSource(`
+      fn first<T>(a: T, b: T): T {
+        return a;
+      }
+      fn main(): int { return first<int>(1, 2); }
+    `)
+    const fn = result.functions.find(f => f.name === 'first_int')
+    expect(fn).toBeDefined()
+    expect(fn!.returnType).toEqual({ kind: 'named', name: 'int' })
+  })
+})
+
+describe('monomorphize — expression rewriting', () => {
+  it('rewrites binary expressions inside generic body', () => {
+    const result = monoFromSource(`
+      fn add<T>(a: T, b: T): T { return a + b; }
+      fn main(): int { return add<int>(1, 2); }
+    `)
+    const fn = result.functions.find(f => f.name === 'add_int')
+    expect(fn).toBeDefined()
+  })
+
+  it('rewrites array literal expressions', () => {
+    const result = monoFromSource(`
+      fn first<T>(a: T): T { return a; }
+      fn main(): int {
+        let arr: int[] = [1, 2, 3];
+        return first<int>(arr[0]);
+      }
+    `)
+    const fn = result.functions.find(f => f.name === 'first_int')
+    expect(fn).toBeDefined()
+  })
+})
+
+describe('monomorphize — type suffix', () => {
+  it('produces correct suffix for named types', () => {
+    const result = monoFromSource(`
+      fn id<T>(x: T): T { return x; }
+      fn main(): float { return id<float>(1.0); }
+    `)
+    const names = result.functions.map(f => f.name)
+    expect(names).toContain('id_float')
+  })
+})