redscript-mc 2.5.0 → 2.6.2

package/src/__tests__/fixtures/heap-sort-mc-test.mcrs

@@ -0,0 +1,87 @@
+// heap-sort-mc-test.mcrs — MC integration tests for heap and sort stdlib
+// heap.mcrs and sort.mcrs are injected as librarySources by writeFixtureWithLibs
+namespace heap_sort_mc_test
+
+@load fn load_fn() {
+  raw("scoreboard objectives add hsmc dummy")
+}
+
+// ── Test 1: MinHeap push/pop order ───────────────────────────────────────────
+// push 5,1,3,2,4 → pop order must be 1,2,3,4,5
+@keep fn test_min_heap() {
+  let h: int[] = heap_new()
+  h = heap_push(h, 5)
+  h = heap_push(h, 1)
+  h = heap_push(h, 3)
+  h = heap_push(h, 2)
+  h = heap_push(h, 4)
+
+  let v1: int = heap_peek(h)
+  h = heap_pop(h)
+  let v2: int = heap_peek(h)
+  h = heap_pop(h)
+  let v3: int = heap_peek(h)
+
+  // v1=1, v2=2, v3=3 → encode as 100*v1 + 10*v2 + v3
+  let encoded: int = v1 * 100 + v2 * 10 + v3
+  scoreboard_set("#heap_min_top3", "hsmc", encoded)
+
+  let final_size: int = heap_size(h)
+  scoreboard_set("#heap_size_after_pop3", "hsmc", final_size)
+}
+
+// ── Test 2: MaxHeap push/pop order ───────────────────────────────────────────
+// push 3,1,4,1,5 → first pop = 5
+@keep fn test_max_heap() {
+  let h: int[] = heap_new()
+  h = max_heap_push(h, 3)
+  h = max_heap_push(h, 1)
+  h = max_heap_push(h, 4)
+  h = max_heap_push(h, 1)
+  h = max_heap_push(h, 5)
+
+  let top: int = heap_peek(h)
+  scoreboard_set("#max_heap_top", "hsmc", top)
+
+  h = max_heap_pop(h)
+  let second: int = heap_peek(h)
+  scoreboard_set("#max_heap_second", "hsmc", second)
+}
+
+// ── Test 3: insertion_sort ascending ─────────────────────────────────────────
+@keep fn test_sort_asc() {
+  let arr: int[] = [30, 10, 50, 20, 40]
+  insertion_sort(arr, 5)
+  // expect [10, 20, 30, 40, 50]
+  let ok: int = 1
+  if (arr[0] != 10) { ok = 0 }
+  if (arr[1] != 20) { ok = 0 }
+  if (arr[2] != 30) { ok = 0 }
+  if (arr[3] != 40) { ok = 0 }
+  if (arr[4] != 50) { ok = 0 }
+  scoreboard_set("#sort_asc_ok", "hsmc", ok)
+  scoreboard_set("#sort_asc_first", "hsmc", arr[0])
+  scoreboard_set("#sort_asc_last", "hsmc", arr[4])
+}
+
+// ── Test 4: insertion_sort descending ────────────────────────────────────────
+@keep fn test_sort_desc() {
+  let arr: int[] = [30, 10, 50, 20, 40]
+  insertion_sort_desc(arr, 5)
+  // expect [50, 40, 30, 20, 10]
+  let ok: int = 1
+  if (arr[0] != 50) { ok = 0 }
+  if (arr[4] != 10) { ok = 0 }
+  scoreboard_set("#sort_desc_ok", "hsmc", ok)
+}
+
+// ── Test 5: sort_merge ────────────────────────────────────────────────────────
+// sort_merge is verified via the NBT /nbt endpoint: result = [1,2,3,4,5,6]
+// We trigger the merge and check via TestHarness /nbt rather than scoreboard.
+@keep fn test_sort_merge() {
+  let a: int[] = [1, 3, 5]
+  let b: int[] = [2, 4, 6]
+  let merged: int[] = sort_merge(a, 3, b, 3)
+  // Signal that function ran (merged array is in heap_sort_mc_test:arrays result)
+  scoreboard_set("#sort_merge_ran", "hsmc", 1)
+}

package/src/__tests__/fixtures/impl-test.mcrs

@@ -1,46 +1,15 @@
-struct timer {
-    _id: int,
-    _duration: int
+namespace impl_test
+struct Counter {
+  value: int
 }
-
-impl timer {
-    fn new(duration: int) -> timer {
-        scoreboard_set("timer_ticks", #rs, 0);
-        scoreboard_set("timer_active", #rs, 0);
-        return { _id: 0, _duration: duration };
-    }
-
-    fn start(self) {
-        scoreboard_set("timer_active", #rs, 1);
-    }
-
-    fn tick(self) {
-        let active: int = scoreboard_get("timer_active", #rs);
-        let ticks: int = scoreboard_get("timer_ticks", #rs);
-
-        if (active == 1) {
-            if (ticks < self._duration) {
-                scoreboard_set("timer_ticks", #rs, ticks + 1);
-            }
-        }
-    }
-
-    fn done(self) -> bool {
-        let ticks: int = scoreboard_get("timer_ticks", #rs);
-        return ticks >= 3;
-    }
-}
-
-fn test() {
-    let timer_value: timer = timer::new(3);
-    timer_value.start();
-    timer_value.tick();
-    timer_value.tick();
-    timer_value.tick();
-    let finished: bool = timer_value.done();
-    if (finished) {
-        scoreboard_set("#impl", #done, 1);
-        return;
-    }
-    scoreboard_set("#impl", #done, 1);
+impl Counter {
+  fn increment(self): Counter {
+    return Counter { value: self.value + 1 }
+  }
+  fn add(self, n: int): Counter {
+    return Counter { value: self.value + n }
+  }
+  fn get(self): int {
+    return self.value
+  }
 }

package/src/__tests__/fixtures/stdlib-extra-test.mcrs

@@ -0,0 +1,226 @@
+// stdlib-extra-test.mcrs — MC integration tests for random, bits, list_sort, bigint, math_hp
+
+@load fn __load() {
+    raw("scoreboard objectives add rsex dummy");
+    raw("scoreboard objectives add rshp dummy");
+}
+
+// ─── random.mcrs ─────────────────────────────────────────────────────────────
+
+@keep fn test_random() {
+    // LCG: next_lcg(12345) should produce deterministic result
+    scoreboard_set("#lcg_12345", "rsex", next_lcg(12345));
+
+    // Two consecutive calls should differ
+    let s1: int = next_lcg(99999);
+    let s2: int = next_lcg(s1);
+    // s1 != s2 → set 1 if different
+    let diff: int = s1 - s2;
+    if (diff < 0) { diff = 0 - diff; }
+    if (diff > 0) {
+        scoreboard_set("#lcg_different", "rsex", 1);
+    }
+
+    // random_range should stay in [0, 10)
+    let seed: int = next_lcg(42);
+    let r: int = random_range(seed, 0, 10);
+    if (r >= 0) {
+        if (r < 10) {
+            scoreboard_set("#rand_in_range", "rsex", 1);
+        }
+    }
+
+    // random_bool returns 0 or 1
+    let b: int = random_bool(seed);
+    if (b >= 0) {
+        if (b <= 1) {
+            scoreboard_set("#rand_bool_valid", "rsex", 1);
+        }
+    }
+}
+
+// ─── bits.mcrs ───────────────────────────────────────────────────────────────
+
+@keep fn test_bits() {
+    // bit_get(5, 0) = 1  (5 = 101 binary, bit 0 = 1)
+    scoreboard_set("#bit_get_5_0", "rsex", bit_get(5, 0));
+
+    // bit_get(5, 1) = 0  (bit 1 = 0)
+    scoreboard_set("#bit_get_5_1", "rsex", bit_get(5, 1));
+
+    // bit_get(5, 2) = 1  (bit 2 = 1)
+    scoreboard_set("#bit_get_5_2", "rsex", bit_get(5, 2));
+
+    // bit_shl(1, 3) = 8  (1 << 3)
+    scoreboard_set("#bit_shl_1_3", "rsex", bit_shl(1, 3));
+
+    // bit_shr(8, 2) = 2  (8 >> 2)
+    scoreboard_set("#bit_shr_8_2", "rsex", bit_shr(8, 2));
+
+    // popcount(7) = 3  (7 = 111, 3 bits set)
+    scoreboard_set("#popcount_7", "rsex", popcount(7));
+
+    // popcount(0) = 0
+    scoreboard_set("#popcount_0", "rsex", popcount(0));
+}
+
+// ─── list.mcrs (sort) ────────────────────────────────────────────────────────
+
+@keep fn test_list_sort() {
+    // sort3(30, 10, 20) → min=10, mid=20, max=30
+    scoreboard_set("#sort3_min", "rsex", sort3(30, 10, 20, 0));
+    scoreboard_set("#sort3_mid", "rsex", sort3(30, 10, 20, 1));
+    scoreboard_set("#sort3_max", "rsex", sort3(30, 10, 20, 2));
+
+    // sort4(40, 10, 30, 20) → sorted: 10, 20, 30, 40
+    scoreboard_set("#sort4_min", "rsex", sort4(40, 10, 30, 20, 0));
+    scoreboard_set("#sort4_max", "rsex", sort4(40, 10, 30, 20, 3));
+
+    // list_min3(5, 3, 8) = 3
+    scoreboard_set("#list_min3", "rsex", list_min3(5, 3, 8));
+
+    // list_max3(5, 3, 8) = 8
+    scoreboard_set("#list_max3", "rsex", list_max3(5, 3, 8));
+
+    // avg3(10, 20, 30) = 20
+    scoreboard_set("#avg3", "rsex", avg3(10, 20, 30));
+}
+
+// ─── bigint.mcrs ─────────────────────────────────────────────────────────────
+
+@keep fn test_bigint() {
+    // bigint3_add: chunks [9999, 9999] + [0, 1] = carry=1, result=[0, 0]
+    scoreboard_set("#bi3_add_lo", "rsex",    bigint3_add_lo(9999, 1));     // (9999+1) % 10000 = 0
+    scoreboard_set("#bi3_carry_lo", "rsex",  bigint3_carry_lo(9999, 1));   // (9999+1) / 10000 = 1
+    scoreboard_set("#bi3_add_mid", "rsex",   bigint3_add_mid(9999, 0, 1)); // (9999+0+1) % 10000 = 0
+    scoreboard_set("#bi3_carry_mid", "rsex", bigint3_carry_mid(9999, 0, 1)); // (9999+0+1) / 10000 = 1
+
+    // bigint3_cmp: [1,0,0] vs [0,9999,9999] → 1 (greater)
+    scoreboard_set("#bi3_cmp_gt", "rsex", bigint3_cmp(1, 0, 0, 0, 9999, 9999));
+
+    // bigint3_cmp: [0,9999,9999] vs [1,0,0] → -1 (less)
+    scoreboard_set("#bi3_cmp_lt", "rsex", bigint3_cmp(0, 9999, 9999, 1, 0, 0));
+
+    // int32_to_bigint3 decomposition: 1023456789
+    // = 1*100000000 + 234*10000 + 5678... wait let me calc:
+    // 1023456789 / 100000000 = 10 (hi) → but int32 max is 2.1B so 10_2345_6789
+    // hi = 10, mid = 2345, lo = 6789
+    scoreboard_set("#bi3_hi", "rsex",  int32_to_bigint3_hi(1023456789));   // 10
+    scoreboard_set("#bi3_mid", "rsex", int32_to_bigint3_mid(1023456789));  // 2345
+    scoreboard_set("#bi3_lo", "rsex",  int32_to_bigint3_lo(1023456789));   // 6789
+}
+
+// ─── math_hp.mcrs: ln_hp ─────────────────────────────────────────────────────
+
+@keep fn test_ln_hp() {
+    // ln_hp(10000) == 0  (ln(1) = 0, input ×10000 so 10000 = 1.0)
+    scoreboard_set("#ln_1", "rshp", ln_hp(10000));
+
+    // ln_hp(27183) ≈ 10000  (ln(e) ≈ 1.0, e≈2.71828 → 27183 in ×10000)
+    scoreboard_set("#ln_e", "rshp", ln_hp(27183));
+
+    // ln_hp(20000) ≈ 6931  (ln(2) ≈ 0.6931, 2.0 = 20000)
+    scoreboard_set("#ln_2", "rshp", ln_hp(20000));
+
+    // ln_hp(100000) ≈ 23026  (ln(10) ≈ 2.3026, 10.0 = 100000)
+    scoreboard_set("#ln_10", "rshp", ln_hp(100000));
+}
+
+// ─── math_hp.mcrs: double_mul_fixed ──────────────────────────────────────────
+
+@keep fn test_double_mul_fixed() {
+    // double_mul_fixed(2.0d, 15000) ≈ 3.0  (2.0 × 1.5 = 3.0)
+    // After call, __dp0 holds d×(f/10000); read it back as ×10000 fixed directly.
+    let d: double = 2.0d;
+    let f: int = scoreboard_get("#dmul_f_in", "rshp");
+    double_mul_fixed(d, f);
+    // Read __dp0 directly to avoid 'as fixed' temp var rename bug
+    raw("execute store result score #dmul_result rshp run data get storage rs:d __dp0 10000.0");
+}
+
+// ─── list.mcrs: dynamic aggregates ──────────────────────────────────────────
+
+@keep fn test_list_aggregates() {
+    let arr: int[] = [10, 30, 20, 50, 40];
+    let len: int = 5;
+
+    // list_sum([10,30,20,50,40]) = 150
+    scoreboard_set("#list_sum", "rsex", list_sum(arr, len));
+
+    // list_avg([10,30,20,50,40]) = 30 * 10000 = 300000 (×10000 fixed)
+    scoreboard_set("#list_avg", "rsex", list_avg(arr, len));
+
+    // list_min([10,30,20,50,40]) = 10
+    scoreboard_set("#list_min", "rsex", list_min(arr, len));
+
+    // list_max([10,30,20,50,40]) = 50
+    scoreboard_set("#list_max", "rsex", list_max(arr, len));
+
+    // list_contains: 20 is in array → 1
+    scoreboard_set("#list_contains_1", "rsex", list_contains(arr, len, 20));
+
+    // list_contains: 99 is NOT in array → 0
+    scoreboard_set("#list_contains_0", "rsex", list_contains(arr, len, 99));
+
+    // list_index_of: 20 is at index 2
+    scoreboard_set("#list_idx_20", "rsex", list_index_of(arr, len, 20));
+
+    // list_index_of: 99 not found → -1
+    scoreboard_set("#list_idx_miss", "rsex", list_index_of(arr, len, 99));
+}
+
+@keep fn test_list_dedup() {
+    // [1, 2, 1, 3, 2] has 3 unique values
+    let arr: int[] = [1, 2, 1, 3, 2];
+    scoreboard_set("#list_dedup", "rsex", list_dedup_count(arr, 5));
+}
+
+// ─── random.mcrs: statistical distributions ──────────────────────────────────
+
+@keep fn test_binomial() {
+    // binomial_sample(10, 10000, 42): p=1.0 → all 10 should succeed
+    scoreboard_set("#binom_p1", "rsex", binomial_sample(10, 10000, 42));
+
+    // binomial_sample(10, 0, 42): p=0.0 → 0 successes
+    scoreboard_set("#binom_p0", "rsex", binomial_sample(10, 0, 42));
+
+    // binomial_sample with p=5000 (50%): result in [0, 10]
+    let b: int = binomial_sample(10, 5000, 12345);
+    if (b >= 0) {
+        if (b <= 10) {
+            scoreboard_set("#binom_valid", "rsex", 1);
+        }
+    }
+}
+
+@keep fn test_hypergeometric() {
+    // Pop=10, success=10, draws=3 → always 3 successes
+    scoreboard_set("#hyper_all", "rsex", hypergeometric_sample(10, 10, 3, 99));
+
+    // Pop=10, success=0, draws=3 → always 0 successes
+    scoreboard_set("#hyper_none", "rsex", hypergeometric_sample(10, 0, 3, 99));
+
+    // Pop=10, success=5, draws=4: result in [0, 4]
+    let h: int = hypergeometric_sample(10, 5, 4, 42);
+    if (h >= 0) {
+        if (h <= 4) {
+            scoreboard_set("#hyper_valid", "rsex", 1);
+        }
+    }
+}
+
+// ─── color.mcrs: rgb_to_hex ──────────────────────────────────────────────────
+
+@keep fn test_rgb_to_hex() {
+    // rgb_to_hex(255, 0, 0) = 0xFF0000 = 16711680
+    scoreboard_set("#hex_red", "rsex", rgb_to_hex(255, 0, 0));
+
+    // rgb_to_hex(0, 255, 0) = 0x00FF00 = 65280
+    scoreboard_set("#hex_green", "rsex", rgb_to_hex(0, 255, 0));
+
+    // rgb_to_hex(0, 0, 255) = 0x0000FF = 255
+    scoreboard_set("#hex_blue", "rsex", rgb_to_hex(0, 0, 255));
+
+    // rgb_to_hex(255, 255, 255) = 0xFFFFFF = 16777215
+    scoreboard_set("#hex_white", "rsex", rgb_to_hex(255, 255, 255));
+}

package/src/__tests__/fixtures/stdlib-math-integration.mcrs

@@ -0,0 +1,28 @@
+// stdlib math integration test
+// Uses librarySources so no import needed
+
+@load fn __load() {
+    scoreboard_add("rs");
+}
+
+@keep fn test_math_basic() {
+    scoreboard_set("#factorial_5", "rs", factorial(5));
+    scoreboard_set("#combinations_5_2", "rs", combinations(5, 2));
+    scoreboard_set("#gcd_12_8", "rs", gcd(12, 8));
+    scoreboard_set("#isqrt_144", "rs", isqrt(144));
+    scoreboard_set("#log2_1024", "rs", log2_int(1024));
+    scoreboard_set("#pow_2_10", "rs", pow_int(2, 10));
+    scoreboard_set("#abs_neg42", "rs", abs(-42));
+    scoreboard_set("#clamp_hi", "rs", clamp(15, 0, 10));
+}
+
+@keep fn test_math_sqrt() {
+    scoreboard_set("#sqrt_fx_40000", "rs", sqrt_fx(40000));
+    scoreboard_set("#cbrt_27", "rs", cbrt_fx(27));
+    scoreboard_set("#cbrt_1000", "rs", cbrt_fx(1000));
+}
+
+@keep fn test_math_approx() {
+    scoreboard_set("#apeq_yes", "rs", approx_eq(100, 103, 5));
+    scoreboard_set("#apeq_no", "rs", approx_eq(100, 110, 5));
+}

package/src/__tests__/fixtures/stdlib-math-test.mcrs

@@ -0,0 +1,53 @@
+// stdlib-math-test.mcrs — MC integration test for math stdlib functions
+// Tests actual in-game execution of math.mcrs functions
+
+import "../../../src/stdlib/math.mcrs"
+
+@load fn __load() {
+    scoreboard_add("rs");
+}
+
+// Run all stdlib math tests, store results to scoreboards
+@keep fn test_stdlib_math() {
+    // ln(2.0) ≈ 6931  (input 20000 = 2.0 ×10000)
+    scoreboard_set("#ln_2", "rs", ln(20000));
+
+    // sqrt_fx(4.0) = 20000  (input 40000 = 4.0 ×10000)
+    scoreboard_set("#sqrt_4", "rs", sqrt_fx(40000));
+
+    // exp_fx(1.0) ≈ 27183  (input 10000 = 1.0 ×10000)
+    scoreboard_set("#exp_1", "rs", exp_fx(10000));
+
+    // cbrt(27) = 3
+    scoreboard_set("#cbrt_27", "rs", cbrt_fx(27));
+
+    // factorial(5) = 120
+    scoreboard_set("#fac5", "rs", factorial(5));
+
+    // combinations(5,2) = 10
+    scoreboard_set("#c52", "rs", combinations(5, 2));
+
+    // gcd(12, 8) = 4
+    scoreboard_set("#gcd128", "rs", gcd(12, 8));
+
+    // isqrt(144) = 12
+    scoreboard_set("#isqrt144", "rs", isqrt(144));
+
+    // log2_int(1024) = 10
+    scoreboard_set("#log2_1024", "rs", log2_int(1024));
+
+    // pow_int(2, 10) = 1024
+    scoreboard_set("#pow2_10", "rs", pow_int(2, 10));
+
+    // abs(-42) = 42
+    scoreboard_set("#abs_neg42", "rs", abs(-42));
+
+    // clamp(15, 0, 10) = 10
+    scoreboard_set("#clamp_15", "rs", clamp(15, 0, 10));
+
+    // approx_eq(100, 103, 5) = 1
+    scoreboard_set("#apeq_1", "rs", approx_eq(100, 103, 5));
+
+    // approx_eq(100, 110, 5) = 0
+    scoreboard_set("#apeq_0", "rs", approx_eq(100, 110, 5));
+}

package/src/__tests__/float-lint.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Tests for [FloatArithmetic] lint warning.
+ *
+ * 'float' is a MC NBT system boundary type (used for volume/pitch parameters).
+ * It should NOT be used for arithmetic — use 'fixed' (×10000) instead.
+ */
+
+import { compile } from '../emit/compile'
+
+function compileAndGetWarnings(source: string): string[] {
+  const result = compile(source, { namespace: 'floatlinttest' })
+  return result.warnings
+}
+
+describe('[FloatArithmetic] lint warnings', () => {
+  test('float arithmetic emits [FloatArithmetic] warning', () => {
+    const source = `
+fn test(): void {
+  let a: float = 1.5f;
+  let b: float = 2.5f;
+  let c: float = a + b;
+}
+`
+    const warnings = compileAndGetWarnings(source)
+    const floatArithWarnings = warnings.filter(w => w.includes('[FloatArithmetic]'))
+    expect(floatArithWarnings.length).toBeGreaterThan(0)
+    expect(floatArithWarnings[0]).toContain("'float' is a system boundary type")
+    expect(floatArithWarnings[0]).toContain("use 'fixed' for arithmetic")
+  })
+
+  test('float used as function parameter type — no [FloatArithmetic] warning', () => {
+    const source = `
+fn foo(volume: float): void {
+}
+`
+    const warnings = compileAndGetWarnings(source)
+    const floatArithWarnings = warnings.filter(w => w.includes('[FloatArithmetic]'))
+    expect(floatArithWarnings).toHaveLength(0)
+  })
+
+  test('fixed arithmetic — no [FloatArithmetic] warning', () => {
+    const source = `
+fn test(): void {
+  let x: fixed = 15000 as fixed;
+  let y: fixed = x + 5000;
+}
+`
+    const warnings = compileAndGetWarnings(source)
+    const floatArithWarnings = warnings.filter(w => w.includes('[FloatArithmetic]'))
+    expect(floatArithWarnings).toHaveLength(0)
+  })
+
+  test('float literal assigned directly — no [FloatArithmetic] warning (only [DeprecatedType])', () => {
+    const source = `
+fn test(): void {
+  let v: float = 1.5f;
+}
+`
+    const warnings = compileAndGetWarnings(source)
+    const floatArithWarnings = warnings.filter(w => w.includes('[FloatArithmetic]'))
+    expect(floatArithWarnings).toHaveLength(0)
+    // But [DeprecatedType] should still fire
+    const deprecatedWarnings = warnings.filter(w => w.includes('[DeprecatedType]'))
+    expect(deprecatedWarnings.length).toBeGreaterThan(0)
+  })
+
+  test('compilation still succeeds when float arithmetic is used (warning only, no error)', () => {
+    const source = `
+fn test(): void {
+  let a: float = 1.5f;
+  let b: float = 2.5f;
+  let c: float = a + b;
+}
+`
+    // Should not throw
+    expect(() => compile(source, { namespace: 'floatlinttest' })).not.toThrow()
+  })
+
+  test('float return type with arithmetic binary expression — emits [FloatArithmetic] warning', () => {
+    const source = `
+fn compute(a: float, b: float): float {
+  return a + b;
+}
+`
+    const warnings = compileAndGetWarnings(source)
+    const floatArithWarnings = warnings.filter(w => w.includes('[FloatArithmetic]'))
+    expect(floatArithWarnings.length).toBeGreaterThan(0)
+  })
+
+  test('float return type with literal — no extra [FloatArithmetic] warning beyond operand check', () => {
+    const source = `
+fn get_volume(): float {
+  return 1.5f;
+}
+`
+    const warnings = compileAndGetWarnings(source)
+    // The literal itself is not arithmetic, so no FloatArithmetic warning from return check
+    // (There may be a [DeprecatedType] warning but not [FloatArithmetic])
+    const floatArithWarnings = warnings.filter(w => w.includes('[FloatArithmetic]'))
+    expect(floatArithWarnings).toHaveLength(0)
+  })
+})