redscript-mc 1.2.30 → 2.1.0

package/dist/src/__tests__/e2e/stdlib-e2e.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * End-to-end stdlib tests through the v2 pipeline.
+ *
+ * Tests pure-arithmetic stdlib functions (math.mcrs, vec.mcrs) by compiling
+ * with librarySources, loading into MCRuntime, and asserting return values.
+ *
+ * NOTE: sin_fixed/cos_fixed/atan2_fixed are skipped — they depend on
+ * storage_get_int/storage_set_array which are not available in MCRuntime.
+ */
+export {};

package/dist/src/__tests__/e2e/stdlib-e2e.test.js

@@ -0,0 +1,324 @@
+"use strict";
+/**
+ * End-to-end stdlib tests through the v2 pipeline.
+ *
+ * Tests pure-arithmetic stdlib functions (math.mcrs, vec.mcrs) by compiling
+ * with librarySources, loading into MCRuntime, and asserting return values.
+ *
+ * NOTE: sin_fixed/cos_fixed/atan2_fixed are skipped — they depend on
+ * storage_get_int/storage_set_array which are not available in MCRuntime.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const compile_1 = require("../../emit/compile");
+const runtime_1 = require("../../runtime");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const NS = 'test';
+const OBJ = `__${NS}`;
+const MATH_SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/math.mcrs'), 'utf-8');
+const VEC_SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/vec.mcrs'), 'utf-8');
+/** Compile source with math stdlib, load into MCRuntime, init objective */
+function makeRuntime(source, libs = [MATH_SRC]) {
+    const result = (0, compile_1.compile)(source, { namespace: NS, librarySources: libs });
+    const rt = new runtime_1.MCRuntime(NS);
+    for (const file of result.files) {
+        if (!file.path.endsWith('.mcfunction'))
+            continue;
+        const m = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/);
+        if (!m)
+            continue;
+        rt.loadFunction(`${m[1]}:${m[2]}`, file.content.split('\n'));
+    }
+    rt.execFunction(`${NS}:load`);
+    return rt;
+}
+/** Execute a function and return the $ret value */
+function callAndGetRet(rt, fnName) {
+    rt.execFunction(`${NS}:${fnName}`);
+    return rt.getScore('$ret', OBJ);
+}
+// ===========================================================================
+// math.mcrs — Phase 1: Basic integer helpers
+// ===========================================================================
+describe('stdlib e2e: abs', () => {
+    const rt = makeRuntime(`
+    fn test_abs_neg(): int { return abs(-5); }
+    fn test_abs_pos(): int { return abs(5); }
+    fn test_abs_zero(): int { return abs(0); }
+  `);
+    test('abs(-5) = 5', () => expect(callAndGetRet(rt, 'test_abs_neg')).toBe(5));
+    test('abs(5) = 5', () => expect(callAndGetRet(rt, 'test_abs_pos')).toBe(5));
+    test('abs(0) = 0', () => expect(callAndGetRet(rt, 'test_abs_zero')).toBe(0));
+});
+describe('stdlib e2e: sign', () => {
+    const rt = makeRuntime(`
+    fn test_sign_pos(): int { return sign(42); }
+    fn test_sign_neg(): int { return sign(-7); }
+    fn test_sign_zero(): int { return sign(0); }
+  `);
+    test('sign(42) = 1', () => expect(callAndGetRet(rt, 'test_sign_pos')).toBe(1));
+    test('sign(-7) = -1', () => expect(callAndGetRet(rt, 'test_sign_neg')).toBe(-1));
+    test('sign(0) = 0', () => expect(callAndGetRet(rt, 'test_sign_zero')).toBe(0));
+});
+describe('stdlib e2e: min/max', () => {
+    const rt = makeRuntime(`
+    fn test_min(): int { return min(3, 7); }
+    fn test_max(): int { return max(3, 7); }
+    fn test_min_eq(): int { return min(5, 5); }
+    fn test_max_neg(): int { return max(-10, -3); }
+  `);
+    test('min(3, 7) = 3', () => expect(callAndGetRet(rt, 'test_min')).toBe(3));
+    test('max(3, 7) = 7', () => expect(callAndGetRet(rt, 'test_max')).toBe(7));
+    test('min(5, 5) = 5', () => expect(callAndGetRet(rt, 'test_min_eq')).toBe(5));
+    test('max(-10, -3) = -3', () => expect(callAndGetRet(rt, 'test_max_neg')).toBe(-3));
+});
+describe('stdlib e2e: clamp', () => {
+    const rt = makeRuntime(`
+    fn test_clamp_above(): int { return clamp(10, 0, 5); }
+    fn test_clamp_below(): int { return clamp(-10, 0, 5); }
+    fn test_clamp_in(): int { return clamp(3, 0, 5); }
+    fn test_clamp_edge(): int { return clamp(0, 0, 5); }
+  `);
+    test('clamp(10, 0, 5) = 5', () => expect(callAndGetRet(rt, 'test_clamp_above')).toBe(5));
+    test('clamp(-10, 0, 5) = 0', () => expect(callAndGetRet(rt, 'test_clamp_below')).toBe(0));
+    test('clamp(3, 0, 5) = 3', () => expect(callAndGetRet(rt, 'test_clamp_in')).toBe(3));
+    test('clamp(0, 0, 5) = 0', () => expect(callAndGetRet(rt, 'test_clamp_edge')).toBe(0));
+});
+describe('stdlib e2e: lerp', () => {
+    const rt = makeRuntime(`
+    fn test_lerp_half(): int { return lerp(0, 1000, 500); }
+    fn test_lerp_quarter(): int { return lerp(100, 200, 750); }
+    fn test_lerp_zero(): int { return lerp(10, 20, 0); }
+    fn test_lerp_full(): int { return lerp(10, 20, 1000); }
+  `);
+    test('lerp(0, 1000, 500) = 500', () => expect(callAndGetRet(rt, 'test_lerp_half')).toBe(500));
+    test('lerp(100, 200, 750) = 175', () => expect(callAndGetRet(rt, 'test_lerp_quarter')).toBe(175));
+    test('lerp(10, 20, 0) = 10', () => expect(callAndGetRet(rt, 'test_lerp_zero')).toBe(10));
+    test('lerp(10, 20, 1000) = 20', () => expect(callAndGetRet(rt, 'test_lerp_full')).toBe(20));
+});
+// ===========================================================================
+// math.mcrs — Phase 2: Iterative algorithms
+// ===========================================================================
+describe('stdlib e2e: isqrt', () => {
+    const rt = makeRuntime(`
+    fn test_isqrt_9(): int { return isqrt(9); }
+    fn test_isqrt_10(): int { return isqrt(10); }
+    fn test_isqrt_0(): int { return isqrt(0); }
+    fn test_isqrt_1(): int { return isqrt(1); }
+    fn test_isqrt_100(): int { return isqrt(100); }
+  `);
+    test('isqrt(9) = 3', () => expect(callAndGetRet(rt, 'test_isqrt_9')).toBe(3));
+    test('isqrt(10) = 3', () => expect(callAndGetRet(rt, 'test_isqrt_10')).toBe(3));
+    test('isqrt(0) = 0', () => expect(callAndGetRet(rt, 'test_isqrt_0')).toBe(0));
+    test('isqrt(1) = 1', () => expect(callAndGetRet(rt, 'test_isqrt_1')).toBe(1));
+    test('isqrt(100) = 10', () => expect(callAndGetRet(rt, 'test_isqrt_100')).toBe(10));
+});
+describe('stdlib e2e: sqrt_fixed', () => {
+    const rt = makeRuntime(`
+    fn test_sqrt_1(): int { return sqrt_fixed(1000); }
+    fn test_sqrt_2(): int { return sqrt_fixed(2000); }
+    fn test_sqrt_4(): int { return sqrt_fixed(4000); }
+  `);
+    test('sqrt_fixed(1000) = 1000 (sqrt(1)*1000)', () => expect(callAndGetRet(rt, 'test_sqrt_1')).toBe(1000));
+    test('sqrt_fixed(2000) ≈ 1414', () => {
+        const val = callAndGetRet(rt, 'test_sqrt_2');
+        expect(val).toBeGreaterThanOrEqual(1413);
+        expect(val).toBeLessThanOrEqual(1415);
+    });
+    test('sqrt_fixed(4000) = 2000 (sqrt(4)*1000)', () => expect(callAndGetRet(rt, 'test_sqrt_4')).toBe(2000));
+});
+describe('stdlib e2e: pow_int', () => {
+    const rt = makeRuntime(`
+    fn test_pow_2_10(): int { return pow_int(2, 10); }
+    fn test_pow_3_0(): int { return pow_int(3, 0); }
+    fn test_pow_5_3(): int { return pow_int(5, 3); }
+  `);
+    test('pow_int(2, 10) = 1024', () => expect(callAndGetRet(rt, 'test_pow_2_10')).toBe(1024));
+    test('pow_int(3, 0) = 1', () => expect(callAndGetRet(rt, 'test_pow_3_0')).toBe(1));
+    test('pow_int(5, 3) = 125', () => expect(callAndGetRet(rt, 'test_pow_5_3')).toBe(125));
+});
+describe('stdlib e2e: gcd', () => {
+    const rt = makeRuntime(`
+    fn test_gcd_12_8(): int { return gcd(12, 8); }
+    fn test_gcd_0_5(): int { return gcd(0, 5); }
+    fn test_gcd_neg(): int { return gcd(-12, 8); }
+  `);
+    test('gcd(12, 8) = 4', () => expect(callAndGetRet(rt, 'test_gcd_12_8')).toBe(4));
+    test('gcd(0, 5) = 5', () => expect(callAndGetRet(rt, 'test_gcd_0_5')).toBe(5));
+    test('gcd(-12, 8) = 4', () => expect(callAndGetRet(rt, 'test_gcd_neg')).toBe(4));
+});
+// ===========================================================================
+// math.mcrs — Phase 4: Number theory & utilities
+// ===========================================================================
+describe('stdlib e2e: lcm', () => {
+    const rt = makeRuntime(`
+    fn test_lcm_4_6(): int { return lcm(4, 6); }
+    fn test_lcm_0_5(): int { return lcm(0, 5); }
+  `);
+    test('lcm(4, 6) = 12', () => expect(callAndGetRet(rt, 'test_lcm_4_6')).toBe(12));
+    test('lcm(0, 5) = 0', () => expect(callAndGetRet(rt, 'test_lcm_0_5')).toBe(0));
+});
+describe('stdlib e2e: map', () => {
+    const rt = makeRuntime(`
+    fn test_map_half(): int { return map(5, 0, 10, 0, 100); }
+    fn test_map_offset(): int { return map(1, 0, 10, 100, 200); }
+  `);
+    test('map(5, 0, 10, 0, 100) = 50', () => expect(callAndGetRet(rt, 'test_map_half')).toBe(50));
+    test('map(1, 0, 10, 100, 200) = 110', () => expect(callAndGetRet(rt, 'test_map_offset')).toBe(110));
+});
+describe('stdlib e2e: ceil_div', () => {
+    const rt = makeRuntime(`
+    fn test_ceil_7_3(): int { return ceil_div(7, 3); }
+    fn test_ceil_6_3(): int { return ceil_div(6, 3); }
+  `);
+    test('ceil_div(7, 3) = 3', () => expect(callAndGetRet(rt, 'test_ceil_7_3')).toBe(3));
+    test('ceil_div(6, 3) = 2', () => expect(callAndGetRet(rt, 'test_ceil_6_3')).toBe(2));
+});
+describe('stdlib e2e: log2_int', () => {
+    const rt = makeRuntime(`
+    fn test_log2_1(): int { return log2_int(1); }
+    fn test_log2_8(): int { return log2_int(8); }
+    fn test_log2_7(): int { return log2_int(7); }
+    fn test_log2_neg(): int { return log2_int(-1); }
+  `);
+    test('log2_int(1) = 0', () => expect(callAndGetRet(rt, 'test_log2_1')).toBe(0));
+    test('log2_int(8) = 3', () => expect(callAndGetRet(rt, 'test_log2_8')).toBe(3));
+    test('log2_int(7) = 2', () => expect(callAndGetRet(rt, 'test_log2_7')).toBe(2));
+    test('log2_int(-1) = -1', () => expect(callAndGetRet(rt, 'test_log2_neg')).toBe(-1));
+});
+// ===========================================================================
+// math.mcrs — Phase 5: Fixed-point arithmetic
+// ===========================================================================
+describe('stdlib e2e: mulfix/divfix', () => {
+    const rt = makeRuntime(`
+    fn test_mulfix(): int { return mulfix(500, 707); }
+    fn test_divfix(): int { return divfix(1, 3); }
+    fn test_divfix_zero(): int { return divfix(5, 0); }
+  `);
+    test('mulfix(500, 707) = 353', () => expect(callAndGetRet(rt, 'test_mulfix')).toBe(353));
+    test('divfix(1, 3) = 333', () => expect(callAndGetRet(rt, 'test_divfix')).toBe(333));
+    test('divfix(5, 0) = 0', () => expect(callAndGetRet(rt, 'test_divfix_zero')).toBe(0));
+});
+describe('stdlib e2e: smoothstep', () => {
+    const rt = makeRuntime(`
+    fn test_ss_zero(): int { return smoothstep(0, 100, 0); }
+    fn test_ss_half(): int { return smoothstep(0, 100, 50); }
+    fn test_ss_full(): int { return smoothstep(0, 100, 100); }
+  `);
+    test('smoothstep(0, 100, 0) = 0', () => expect(callAndGetRet(rt, 'test_ss_zero')).toBe(0));
+    test('smoothstep(0, 100, 50) = 500', () => expect(callAndGetRet(rt, 'test_ss_half')).toBe(500));
+    test('smoothstep(0, 100, 100) = 1000', () => expect(callAndGetRet(rt, 'test_ss_full')).toBe(1000));
+});
+// ===========================================================================
+// vec.mcrs — 2D geometry (pure arithmetic, no storage)
+// ===========================================================================
+describe('stdlib e2e: vec2d geometry', () => {
+    const rt = makeRuntime(`
+    fn test_dot2d(): int { return dot2d(3, 4, 3, 4); }
+    fn test_cross2d(): int { return cross2d(1, 0, 0, 1); }
+    fn test_manhattan(): int { return manhattan(0, 0, 3, 4); }
+    fn test_chebyshev(): int { return chebyshev(0, 0, 3, 4); }
+  `, [MATH_SRC, VEC_SRC]);
+    test('dot2d(3,4,3,4) = 25', () => expect(callAndGetRet(rt, 'test_dot2d')).toBe(25));
+    test('cross2d(1,0,0,1) = 1', () => expect(callAndGetRet(rt, 'test_cross2d')).toBe(1));
+    test('manhattan(0,0,3,4) = 7', () => expect(callAndGetRet(rt, 'test_manhattan')).toBe(7));
+    test('chebyshev(0,0,3,4) = 4', () => expect(callAndGetRet(rt, 'test_chebyshev')).toBe(4));
+});
+describe('stdlib e2e: vec2d length & distance', () => {
+    const rt = makeRuntime(`
+    fn test_length2d(): int { return length2d_fixed(3, 4); }
+    fn test_distance2d(): int { return distance2d_fixed(0, 0, 3, 4); }
+  `, [MATH_SRC, VEC_SRC]);
+    test('length2d_fixed(3, 4) = 5000', () => expect(callAndGetRet(rt, 'test_length2d')).toBe(5000));
+    test('distance2d_fixed(0,0,3,4) = 5000', () => expect(callAndGetRet(rt, 'test_distance2d')).toBe(5000));
+});
+describe('stdlib e2e: vec2d normalize', () => {
+    const rt = makeRuntime(`
+    fn test_norm_x(): int { return normalize2d_x(3, 4); }
+    fn test_norm_y(): int { return normalize2d_y(3, 4); }
+    fn test_norm_zero(): int { return normalize2d_x(0, 0); }
+  `, [MATH_SRC, VEC_SRC]);
+    test('normalize2d_x(3, 4) = 600', () => expect(callAndGetRet(rt, 'test_norm_x')).toBe(600));
+    test('normalize2d_y(3, 4) = 800', () => expect(callAndGetRet(rt, 'test_norm_y')).toBe(800));
+    test('normalize2d_x(0, 0) = 0', () => expect(callAndGetRet(rt, 'test_norm_zero')).toBe(0));
+});
+describe('stdlib e2e: vec2d lerp', () => {
+    const rt = makeRuntime(`
+    fn test_lerp2d_x(): int { return lerp2d_x(0, 0, 100, 200, 500); }
+    fn test_lerp2d_y(): int { return lerp2d_y(0, 0, 100, 200, 500); }
+  `, [MATH_SRC, VEC_SRC]);
+    test('lerp2d_x(0,0,100,200,500) = 50', () => expect(callAndGetRet(rt, 'test_lerp2d_x')).toBe(50));
+    test('lerp2d_y(0,0,100,200,500) = 100', () => expect(callAndGetRet(rt, 'test_lerp2d_y')).toBe(100));
+});
+// ===========================================================================
+// vec.mcrs — 3D geometry
+// ===========================================================================
+describe('stdlib e2e: vec3d geometry', () => {
+    const rt = makeRuntime(`
+    fn test_dot3d(): int { return dot3d(1, 2, 3, 4, 5, 6); }
+    fn test_cross3d_x(): int { return cross3d_x(1, 0, 0, 0, 1, 0); }
+    fn test_cross3d_y(): int { return cross3d_y(1, 0, 0, 0, 1, 0); }
+    fn test_cross3d_z(): int { return cross3d_z(1, 0, 0, 0, 1, 0); }
+    fn test_manhattan3d(): int { return manhattan3d(0, 0, 0, 1, 2, 3); }
+    fn test_chebyshev3d(): int { return chebyshev3d(0, 0, 0, 3, 1, 2); }
+  `, [MATH_SRC, VEC_SRC]);
+    test('dot3d(1,2,3,4,5,6) = 32', () => expect(callAndGetRet(rt, 'test_dot3d')).toBe(32));
+    test('cross3d_x(1,0,0, 0,1,0) = 0', () => expect(callAndGetRet(rt, 'test_cross3d_x')).toBe(0));
+    test('cross3d_y(1,0,0, 0,1,0) = 0', () => expect(callAndGetRet(rt, 'test_cross3d_y')).toBe(0));
+    test('cross3d_z(1,0,0, 0,1,0) = 1', () => expect(callAndGetRet(rt, 'test_cross3d_z')).toBe(1));
+    test('manhattan3d(0,0,0, 1,2,3) = 6', () => expect(callAndGetRet(rt, 'test_manhattan3d')).toBe(6));
+    test('chebyshev3d(0,0,0, 3,1,2) = 3', () => expect(callAndGetRet(rt, 'test_chebyshev3d')).toBe(3));
+});
+describe('stdlib e2e: vec3d length & distance', () => {
+    const rt = makeRuntime(`
+    fn test_length3d(): int { return length3d_fixed(1, 1, 1); }
+    fn test_distance3d(): int { return distance3d_fixed(0, 0, 0, 1, 1, 1); }
+  `, [MATH_SRC, VEC_SRC]);
+    test('length3d_fixed(1,1,1) ≈ 1732', () => {
+        const val = callAndGetRet(rt, 'test_length3d');
+        expect(val).toBeGreaterThanOrEqual(1731);
+        expect(val).toBeLessThanOrEqual(1733);
+    });
+    test('distance3d_fixed(0,0,0, 1,1,1) ≈ 1732', () => {
+        const val = callAndGetRet(rt, 'test_distance3d');
+        expect(val).toBeGreaterThanOrEqual(1731);
+        expect(val).toBeLessThanOrEqual(1733);
+    });
+});
+//# sourceMappingURL=stdlib-e2e.test.js.map

package/dist/src/__tests__/enum.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Enum + pattern matching tests for Phase 2a.
+ *
+ * Tests cover:
+ * - Lexer/Parser: enum declarations, :: path operator
+ * - TypeChecker: enum type checking, variant resolution
+ * - HIR/MIR/LIR: enum compilation to integer scoreboard slots
+ * - E2E: match on enum variants → execute if score ... matches N
+ */
+export {};