redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/stdlib/random.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Tests for stdlib/random.mcrs — LCG / PCG RNG helpers.
+ */
+
+import { compile } from '../../emit/compile'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/random.mcrs'), 'utf-8')
+
+function compileWith(extra: string) {
+  return compile(SRC + '\n' + extra, { namespace: 'test' })
+}
+
+describe('stdlib/random.mcrs', () => {
+  test('compiles without errors', () => {
+    const r = compileWith('')
+    expect(r.files.length).toBeGreaterThan(0)
+  })
+
+  test('next_lcg is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return next_lcg(12345); }`)
+    expect(r.files.some(f => f.path.includes('next_lcg'))).toBe(true)
+  })
+
+  test('random_range is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return random_range(999, 0, 100); }`)
+    expect(r.files.some(f => f.path.includes('random_range'))).toBe(true)
+  })
+
+  test('random_bool is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return random_bool(42); }`)
+    expect(r.files.some(f => f.path.includes('random_bool'))).toBe(true)
+  })
+
+  test('pcg_next_lo is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return pcg_next_lo(123); }`)
+    expect(r.files.some(f => f.path.includes('pcg_next_lo'))).toBe(true)
+  })
+
+  test('binomial_sample is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return binomial_sample(10, 5000, 777); }`)
+    expect(r.files.some(f => f.path.includes('binomial_sample'))).toBe(true)
+  })
+
+  test('hypergeometric_sample is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return hypergeometric_sample(20, 5, 10, 999); }`)
+    expect(r.files.some(f => f.path.includes('hypergeometric_sample'))).toBe(true)
+  })
+})

package/src/__tests__/stdlib/result.test.ts

@@ -0,0 +1,326 @@
+/**
+ * Tests for stdlib/result.mcrs — Result<T> error handling type.
+ *
+ * Covers:
+ * - Compilation succeeds for the full stdlib file
+ * - Result::Ok and Result::Err construction emit correct scoreboard/NBT commands
+ * - result_is_ok / result_is_err helper functions compile and are emitted
+ * - result_value / result_code extraction helpers compile and are emitted
+ * - result_divide safe division example compiles correctly
+ * - match on Result arms emits correct tag comparison and NBT reads
+ */
+
+import { compile } from '../../emit/compile'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const RESULT_STDLIB = path.join(__dirname, '../../stdlib/result.mcrs')
+const resultSrc = fs.readFileSync(RESULT_STDLIB, 'utf-8')
+
+function getCommands(source: string, namespace = 'test'): string[] {
+  const result = compile(source, { namespace })
+  if (!result.success) {
+    const errors = (result as any).errors ?? []
+    throw new Error(`Compilation failed:\n${errors.map((e: any) => e.message ?? e).join('\n')}`)
+  }
+  return (result.files ?? [])
+    .filter(f => f.path.endsWith('.mcfunction'))
+    .flatMap(f => f.content.split('\n'))
+    .filter(line => line.trim().length > 0)
+}
+
+function compileWithResult(extra: string): { path: string; content: string }[] {
+  const result = compile(resultSrc + '\n' + extra, { namespace: 'test' })
+  if (!result.success) {
+    const errors = (result as any).errors ?? []
+    throw new Error(`Compilation failed:\n${errors.map((e: any) => e.message ?? e).join('\n')}`)
+  }
+  return result.files ?? []
+}
+
+function getFn(files: { path: string; content: string }[], fnName: string): string {
+  const f = files.find(f => f.path.endsWith(`/${fnName}.mcfunction`))
+  if (!f) {
+    const paths = files.map(f => f.path).join('\n')
+    throw new Error(`Function '${fnName}' not found in:\n${paths}`)
+  }
+  return f.content
+}
+
+// ===========================================================================
+// Basic compilation
+// ===========================================================================
+
+describe('stdlib/result.mcrs: compilation', () => {
+  test('compiles the full stdlib file without errors', () => {
+    const result = compile(resultSrc, { namespace: 'test' })
+    // Library modules may emit no files if nothing is referenced — just check no crash
+    expect(result.success).toBe(true)
+  })
+
+  test('Result enum is recognized by type checker', () => {
+    const source = resultSrc + `
+      @keep fn test_ok(): Result {
+        return Result::Ok(value: 42);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.success).toBe(true)
+  })
+
+  test('Result::Err construction compiles', () => {
+    const source = resultSrc + `
+      @keep fn test_err(): Result {
+        return Result::Err(code: -1);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.success).toBe(true)
+  })
+})
+
+// ===========================================================================
+// Constructor helpers
+// ===========================================================================
+
+describe('stdlib/result.mcrs: constructors', () => {
+  test('result_ok helper is emitted', () => {
+    const files = compileWithResult(`@keep fn t() { let r: Result = result_ok(100); }`)
+    expect(files.some(f => f.path.includes('result_ok'))).toBe(true)
+  })
+
+  test('result_err helper is emitted', () => {
+    const files = compileWithResult(`@keep fn t() { let r: Result = result_err(-1); }`)
+    expect(files.some(f => f.path.includes('result_err'))).toBe(true)
+  })
+
+  test('Result::Ok emits tag=0 (Ok is first variant)', () => {
+    const source = resultSrc + `
+      @keep fn t(): Result {
+        return Result::Ok(value: 42);
+      }
+    `
+    const cmds = getCommands(source)
+    // Ok is variant index 0
+    const tagSets = cmds.filter(c => c.includes('scoreboard players set') && c.includes(' 0'))
+    expect(tagSets.length).toBeGreaterThan(0)
+  })
+
+  test('Result::Ok emits NBT write for payload value', () => {
+    const source = resultSrc + `
+      @keep fn t(): Result {
+        return Result::Ok(value: 99);
+      }
+    `
+    const cmds = getCommands(source)
+    const allCmds = cmds.join('\n')
+    expect(allCmds).toContain('storage rs:enums')
+    expect(allCmds).toContain('Result_value')
+  })
+
+  test('Result::Err emits tag=1 (Err is second variant)', () => {
+    const source = resultSrc + `
+      @keep fn t(): Result {
+        return Result::Err(code: -2);
+      }
+    `
+    const cmds = getCommands(source)
+    // Err is variant index 1
+    const tagSets = cmds.filter(c => c.includes('scoreboard players set') && c.includes(' 1'))
+    expect(tagSets.length).toBeGreaterThan(0)
+  })
+
+  test('Result::Err emits NBT write for payload code', () => {
+    const source = resultSrc + `
+      @keep fn t(): Result {
+        return Result::Err(code: -1);
+      }
+    `
+    const cmds = getCommands(source)
+    const allCmds = cmds.join('\n')
+    expect(allCmds).toContain('storage rs:enums')
+    expect(allCmds).toContain('Result_code')
+  })
+})
+
+// ===========================================================================
+// Query helpers
+// ===========================================================================
+
+describe('stdlib/result.mcrs: query helpers', () => {
+  test('result_is_ok is emitted when called', () => {
+    const files = compileWithResult(`
+      @keep fn t(r: Result): int {
+        return result_is_ok(r);
+      }
+    `)
+    expect(files.some(f => f.path.includes('result_is_ok'))).toBe(true)
+  })
+
+  test('result_is_err is emitted when called', () => {
+    const files = compileWithResult(`
+      @keep fn t(r: Result): int {
+        return result_is_err(r);
+      }
+    `)
+    expect(files.some(f => f.path.includes('result_is_err'))).toBe(true)
+  })
+
+  test('result_is_ok match emits tag comparison', () => {
+    const source = resultSrc + `
+      @keep fn t(r: Result): int {
+        return result_is_ok(r);
+      }
+    `
+    const cmds = getCommands(source)
+    const allCmds = cmds.join('\n')
+    expect(allCmds).toContain('execute if score')
+  })
+})
+
+// ===========================================================================
+// Extraction helpers
+// ===========================================================================
+
+describe('stdlib/result.mcrs: extraction helpers', () => {
+  test('result_value is emitted when called', () => {
+    const files = compileWithResult(`
+      @keep fn t(r: Result): int {
+        return result_value(r);
+      }
+    `)
+    expect(files.some(f => f.path.includes('result_value'))).toBe(true)
+  })
+
+  test('result_code is emitted when called', () => {
+    const files = compileWithResult(`
+      @keep fn t(r: Result): int {
+        return result_code(r);
+      }
+    `)
+    expect(files.some(f => f.path.includes('result_code'))).toBe(true)
+  })
+
+  test('result_value reads NBT payload field', () => {
+    const source = resultSrc + `
+      @keep fn t(r: Result): int {
+        return result_value(r);
+      }
+    `
+    const cmds = getCommands(source)
+    const allCmds = cmds.join('\n')
+    expect(allCmds).toContain('Result_value')
+  })
+
+  test('result_code reads NBT payload field', () => {
+    const source = resultSrc + `
+      @keep fn t(r: Result): int {
+        return result_code(r);
+      }
+    `
+    const cmds = getCommands(source)
+    const allCmds = cmds.join('\n')
+    expect(allCmds).toContain('Result_code')
+  })
+})
+
+// ===========================================================================
+// Safe division example
+// ===========================================================================
+
+describe('stdlib/result.mcrs: result_divide', () => {
+  test('result_divide compiles and is emitted', () => {
+    const files = compileWithResult(`
+      @keep fn t(): Result {
+        return result_divide(10, 2);
+      }
+    `)
+    expect(files.some(f => f.path.includes('result_divide'))).toBe(true)
+  })
+
+  test('result_divide emits conditional branch guard', () => {
+    const source = resultSrc + `
+      @keep fn t(): Result {
+        return result_divide(10, 2);
+      }
+    `
+    const cmds = getCommands(source)
+    // The if (b == 0) check compiles to: execute store success score ... if score ... = ... then execute if score matches 1 run return
+    expect(cmds.some(c => c.includes('execute if score') || c.includes('execute store success'))).toBe(true)
+  })
+})
+
+// ===========================================================================
+// Match on Result
+// ===========================================================================
+
+describe('stdlib/result.mcrs: match', () => {
+  test('match on Result::Ok arm emits tag=0 check', () => {
+    const source = resultSrc + `
+      @keep fn t(r: Result): int {
+        match r {
+          Result::Ok(value) => { return value; }
+          Result::Err(code) => { return code; }
+        }
+        return -1;
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.success).toBe(true)
+    const cmds = (result.files ?? [])
+      .filter(f => f.path.endsWith('.mcfunction'))
+      .flatMap(f => f.content.split('\n'))
+      .filter(l => l.trim())
+    const allCmds = cmds.join('\n')
+    expect(allCmds).toContain('execute if score')
+    expect(allCmds).toContain('storage rs:enums')
+  })
+
+  test('match on Result extracts Ok value binding', () => {
+    const source = resultSrc + `
+      @keep fn t(r: Result): int {
+        match r {
+          Result::Ok(value) => { return value; }
+          Result::Err(code) => { return 0; }
+        }
+        return -1;
+      }
+    `
+    const cmds = getCommands(source)
+    const allCmds = cmds.join('\n')
+    expect(allCmds).toContain('Result_value')
+  })
+
+  test('match on Result extracts Err code binding', () => {
+    const source = resultSrc + `
+      @keep fn t(r: Result): int {
+        match r {
+          Result::Ok(value) => { return 0; }
+          Result::Err(code) => { return code; }
+        }
+        return -1;
+      }
+    `
+    const cmds = getCommands(source)
+    const allCmds = cmds.join('\n')
+    expect(allCmds).toContain('Result_code')
+  })
+
+  test('full divide-and-use pattern compiles end-to-end', () => {
+    const source = resultSrc + `
+      @keep fn use_divide() {
+        let r: Result = result_divide(10, 2);
+        match r {
+          Result::Ok(value) => {
+            let dummy: int = value;
+          }
+          Result::Err(code) => {
+            let dummy: int = code;
+          }
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(result.success).toBe(true)
+  })
+})

package/src/__tests__/stdlib/scheduler.test.ts

@@ -17,7 +17,12 @@ function compileWith(extra: string): { path: string; content: string }[] {
 }
 
 function getFn(files: { path: string; content: string }[], fnName: string): string {
+  // Match exact name or specialized variants (e.g. fn__const_0_0)
   const f = files.find(f => f.path.endsWith(`/${fnName}.mcfunction`))
+    ?? files.find(f => {
+      const base = f.path.split('/').pop()!
+      return base.startsWith(`${fnName}__`)
+    })
   if (!f) {
     const paths = files.map(f => f.path).join('\n')
     throw new Error(`Function '${fnName}' not found. Files:\n${paths}`)
@@ -113,22 +118,28 @@ describe('stdlib/scheduler.mcrs', () => {
   // ── scheduler_tick ─────────────────────────────────────────────────────────
 
   test('scheduler_tick is emitted', () => {
+    // scheduler_tick may be inlined (no branches → no separate file); check all content
     const files = compileWith(`@keep fn t() { scheduler_tick(); }`)
-    expect(files.some(f => f.path.includes('scheduler_tick'))).toBe(true)
+    const allContent = files.map(f => f.content).join('\n')
+    const hasFile = files.some(f => f.path.includes('scheduler_tick'))
+    const hasContent = allContent.includes('rs.t0') || allContent.includes('rs.g0')
+    expect(hasFile || hasContent).toBe(true)
   })
 
   test('scheduler_tick decrements per-player slots', () => {
     const files = compileWith(`@keep fn t() { scheduler_tick(); }`)
-    const body = getFn(files, 'scheduler_tick')
-    expect(body).toContain('rs.t0')
-    expect(body).toContain('scoreboard')
+    // May be inlined — check all generated file content
+    const allContent = files.map(f => f.content).join('\n')
+    expect(allContent).toContain('rs.t0')
+    expect(allContent).toContain('scoreboard')
   })
 
   test('scheduler_tick decrements global slots', () => {
     const files = compileWith(`@keep fn t() { scheduler_tick(); }`)
-    const body = getFn(files, 'scheduler_tick')
-    expect(body).toContain('rs.g0')
-    expect(body).toContain('#rs')
+    // May be inlined — check all generated file content
+    const allContent = files.map(f => f.content).join('\n')
+    expect(allContent).toContain('rs.g0')
+    expect(allContent).toContain('#rs')
   })
 
   // ── Combined usage ─────────────────────────────────────────────────────────

package/src/__tests__/stdlib/set_int.test.ts

@@ -0,0 +1,62 @@
+import { compile } from '../../emit/compile'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/set_int.mcrs'), 'utf-8')
+
+function compileWith(extra: string) {
+  return compile(SRC + '\n' + extra, { namespace: 'test' })
+}
+
+describe('stdlib/set_int.mcrs', () => {
+  test('compiles without errors', () => {
+    const r = compileWith('')
+    expect(r.files.length).toBeGreaterThan(0)
+  })
+
+  test('set_add loads named storage, deduplicates, and stores back', () => {
+    const r = compileWith(`@keep fn t() { set_add("Visited", 42); }`)
+    const all = r.files.map(f => f.content).join('\n')
+    expect(all).toContain('data modify storage rs:macro_args set_name set from storage rs:strings __sp0')
+    expect(all).toContain('function test:__set_int_load_items_apply with storage rs:macro_args')
+    expect(all).toContain('$data modify storage test:arrays items set from storage rs:set_int $(set_name)')
+    expect(all).toContain('function test:__set_int_store_items_apply with storage rs:macro_args')
+  })
+
+  test('set_has emits array scan helper usage', () => {
+    const r = compileWith(`@keep fn t(): int { return set_has("Visited", 42); }`)
+    const all = r.files.map(f => f.content).join('\n')
+    expect(all).toContain('function test:__set_int_load_items_apply with storage rs:macro_args')
+    expect(all).toContain('function test:_set_int_array_has')
+  })
+
+  test('set_remove filters elements and writes rebuilt set', () => {
+    const r = compileWith(`@keep fn t() { set_remove("Visited", 42); }`)
+    const all = r.files.map(f => f.content).join('\n')
+    expect(all).toContain('function test:__set_int_store_kept_apply with storage rs:macro_args')
+    expect(all).toContain('$data modify storage rs:set_int $(set_name) set from storage test:arrays kept')
+  })
+
+  test('set_size initializes zero default and reads list length from storage', () => {
+    const r = compileWith(`@keep fn t(): int { return set_size("Visited"); }`)
+    expect(r.files.length).toBeGreaterThan(0)
+  })
+
+  test('set_clear resets named set to an empty list', () => {
+    const r = compileWith(`@keep fn t() { set_clear("Visited"); }`)
+    expect(r.files.length).toBeGreaterThan(0)
+  })
+
+  test('set_union merges both sets into the result storage', () => {
+    const r = compileWith(`@keep fn t() { set_union("A", "B", "Out"); }`)
+    const all = r.files.map(f => f.content).join('\n')
+    expect(all).toContain('$data modify storage rs:set_int $(result) set from storage test:arrays merged')
+  })
+
+  test('set_intersect scans both sources and writes the shared result', () => {
+    const r = compileWith(`@keep fn t() { set_intersect("A", "B", "Both"); }`)
+    const all = r.files.map(f => f.content).join('\n')
+    expect(all).toContain('$data modify storage rs:set_int $(result) set from storage test:arrays shared')
+    expect(all).toContain('function test:_set_int_array_has')
+  })
+})

package/src/__tests__/stdlib/sets.test.ts

@@ -0,0 +1,28 @@
+/**
+ * Tests for stdlib/sets.mcrs — runtime set documentation (builtins).
+ * The actual set_new/set_add/set_contains are compiler builtins; sets.mcrs
+ * only contains documentation comments.
+ */
+
+import { compile } from '../../emit/compile'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/sets.mcrs'), 'utf-8')
+
+describe('stdlib/sets.mcrs', () => {
+  test('file loads without parse errors', () => {
+    // sets.mcrs is documentation-only; just ensure it doesn't throw on compile
+    expect(() => {
+      compile(SRC + '\nfn _noop(): int { return 0; }', { namespace: 'test' })
+    }).not.toThrow()
+  })
+
+  test('set builtin functions compile when called', () => {
+    // set_new, set_add, set_contains, set_remove, set_clear are compiler builtins
+    const r = compile(`
+      fn _noop(): int { return 0; }
+    `, { namespace: 'test' })
+    expect(r.files.length).toBeGreaterThan(0)
+  })
+})

package/src/__tests__/stdlib/signal.test.ts

@@ -0,0 +1,60 @@
+/**
+ * Tests for stdlib/signal.mcrs — statistical distributions and probability.
+ */
+
+import { compile } from '../../emit/compile'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/signal.mcrs'), 'utf-8')
+
+function compileWith(extra: string) {
+  return compile(SRC + '\n' + extra, { namespace: 'test' })
+}
+
+describe('stdlib/signal.mcrs', () => {
+  test('compiles without errors', () => {
+    const r = compileWith('')
+    expect(r.files.length).toBeGreaterThan(0)
+  })
+
+  test('uniform_int is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return uniform_int(42, 0, 100); }`)
+    expect(r.files.some(f => f.path.includes('uniform_int'))).toBe(true)
+  })
+
+  test('uniform_frac is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return uniform_frac(999); }`)
+    expect(r.files.some(f => f.path.includes('uniform_frac'))).toBe(true)
+  })
+
+  test('bernoulli is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return bernoulli(77, 5000); }`)
+    expect(r.files.some(f => f.path.includes('bernoulli'))).toBe(true)
+  })
+
+  test('weighted2 is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return weighted2(55, 3, 7); }`)
+    expect(r.files.some(f => f.path.includes('weighted2'))).toBe(true)
+  })
+
+  test('weighted3 is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return weighted3(55, 2, 5, 3); }`)
+    expect(r.files.some(f => f.path.includes('weighted3'))).toBe(true)
+  })
+
+  test('poisson_sample is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return poisson_sample(30000, 123); }`)
+    expect(r.files.some(f => f.path.includes('poisson_sample'))).toBe(true)
+  })
+
+  test('geometric_sample is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return geometric_sample(3000, 456); }`)
+    expect(r.files.some(f => f.path.includes('geometric_sample'))).toBe(true)
+  })
+
+  test('dft_magnitude is emitted', () => {
+    const r = compileWith(`@keep fn t(): int { return dft_magnitude(10000, 0, -10000, 0, 0, 0, 0, 0, 4, 0); }`)
+    expect(r.files.some(f => f.path.includes('dft_magnitude'))).toBe(true)
+  })
+})

package/src/__tests__/stdlib/spawn.test.ts

@@ -0,0 +1,40 @@
+/**
+ * Tests for stdlib/spawn.mcrs — spawn / teleportation utilities.
+ */
+
+import { compile } from '../../emit/compile'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/spawn.mcrs'), 'utf-8')
+
+function compileWith(extra: string) {
+  return compile(SRC + '\n' + extra, { namespace: 'test' })
+}
+
+describe('stdlib/spawn.mcrs', () => {
+  test('compiles without errors', () => {
+    const r = compileWith('')
+    expect(r.files.length).toBeGreaterThan(0)
+  })
+
+  test('teleport_to is emitted', () => {
+    const r = compileWith(`@keep fn t() { teleport_to(@s, 0, 64, 0); }`)
+    expect(r.files.some(f => f.path.includes('teleport_to'))).toBe(true)
+  })
+
+  test('spread_players is emitted', () => {
+    const r = compileWith(`@keep fn t() { spread_players(0, 0, 50); }`)
+    expect(r.files.some(f => f.path.includes('spread_players'))).toBe(true)
+  })
+
+  test('gather_all is emitted', () => {
+    const r = compileWith(`@keep fn t() { gather_all(0, 64, 0); }`)
+    expect(r.files.some(f => f.path.includes('gather_all'))).toBe(true)
+  })
+
+  test('launch_up is emitted', () => {
+    const r = compileWith(`@keep fn t() { launch_up(@s, 10); }`)
+    expect(r.files.some(f => f.path.includes('launch_up'))).toBe(true)
+  })
+})