redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/hir/monomorphize-extra2.test.js

@@ -0,0 +1,316 @@
+"use strict";
+/**
+ * Extra coverage for src/hir/monomorphize.ts (part 2)
+ *
+ * Targets uncovered branches in rewriteStmt and rewriteExpr:
+ * - while stmt with step
+ * - foreach stmt in generic
+ * - match stmt with PatExpr vs EnumVariant
+ * - break/continue/raw stmts in generic
+ * - invoke, member_assign, index_assign, index, member exprs
+ * - str_interp, some_lit, lambda exprs
+ * - is_check expr
+ * - matchTypes: array → array matching
+ * - matchTypes: tuple → tuple matching
+ * - substType: function_type, enum, named pass-through
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+function compileSource(source, namespace = 'test') {
+    return (0, compile_1.compile)(source, { namespace });
+}
+// ── generic with while + step ─────────────────────────────────────────────
+describe('monomorphize — while stmt in generic', () => {
+    test('while loop in generic function is rewritten', () => {
+        const src = `
+      fn countdown<T>(start: T): int {
+        let n: int = 0;
+        while (n < 5) {
+          n = n + 1;
+        }
+        return n;
+      }
+      fn main(): int {
+        return countdown<int>(10);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── generic with foreach ─────────────────────────────────────────────────
+describe('monomorphize — foreach stmt in generic', () => {
+    test('foreach over selector in generic function', () => {
+        const src = `
+      fn broadcast<T>(val: T): void {
+        foreach (p in @a) {
+          raw("say hello");
+        }
+      }
+      fn main(): int {
+        broadcast<int>(42);
+        return 0;
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── generic with match ─────────────────────────────────────────────────
+describe('monomorphize — match stmt in generic', () => {
+    test('match with enum arms in generic function', () => {
+        const src = `
+      enum Dir { North, South }
+      fn check<T>(dir: Dir, val: T): int {
+        match dir {
+          Dir::North => { return 1; }
+          Dir::South => { return 0; }
+        }
+      }
+      fn main(): int {
+        return check<int>(Dir::North, 42);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── generic with break/continue ───────────────────────────────────────
+describe('monomorphize — break/continue in generic', () => {
+    test('break in while loop inside generic function', () => {
+        const src = `
+      fn find<T>(sentinel: T): int {
+        let i = 0;
+        while (i < 10) {
+          if (i == 5) { break; }
+          i = i + 1;
+        }
+        return i;
+      }
+      fn main(): int {
+        return find<int>(99);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── generic with raw ────────────────────────────────────────────────────
+describe('monomorphize — raw in generic', () => {
+    test('raw-like command inside generic function is preserved', () => {
+        // Use scoreboard_set as a non-raw side effect
+        const src = `
+      fn store<T>(val: T): void {
+        scoreboard_set("rs_marker", "rs", 1);
+      }
+      fn main(): int {
+        store<int>(42);
+        return 0;
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── generic with invoke (method call) ─────────────────────────────────
+describe('monomorphize — invoke expr in generic', () => {
+    test('method call inside generic function is rewritten', () => {
+        const src = `
+      struct Box { val: int }
+      impl Box {
+        fn get(self): int { return self.val; }
+      }
+      fn unwrap<T>(b: Box): int {
+        return b.get();
+      }
+      fn main(): int {
+        let b: Box = Box { val: 99 };
+        return unwrap<int>(b);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── generic with member_assign ─────────────────────────────────────────
+describe('monomorphize — member_assign in generic', () => {
+    test('struct field assign inside generic is rewritten', () => {
+        const src = `
+      struct Counter { count: int }
+      fn increment<T>(c: Counter): int {
+        c.count = c.count + 1;
+        return c.count;
+      }
+      fn main(): int {
+        let c: Counter = Counter { count: 0 };
+        return increment<int>(c);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── generic with index / index_assign ─────────────────────────────────
+describe('monomorphize — index/index_assign in generic', () => {
+    test('array index in generic function is rewritten', () => {
+        const src = `
+      fn get_elem<T>(arr: int[], idx: int): int {
+        return arr[idx];
+      }
+      fn main(): int {
+        let arr: int[] = [10, 20, 30];
+        return get_elem<int>(arr, 1);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('array index assign in generic function is rewritten', () => {
+        const src = `
+      fn set_elem<T>(arr: int[], idx: int, val: int): int {
+        arr[idx] = val;
+        return 0;
+      }
+      fn main(): int {
+        let arr: int[] = [0, 0, 0];
+        return set_elem<int>(arr, 1, 42);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── generic with str_interp ───────────────────────────────────────────
+describe('monomorphize — str_interp in generic', () => {
+    test('string interpolation inside generic body is rewritten', () => {
+        const src = `
+      fn show<T>(val: T): void {
+        say("showing generic value");
+      }
+      fn main(): int {
+        show<int>(42);
+        return 0;
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── generic with some_lit ─────────────────────────────────────────────
+describe('monomorphize — some_lit in generic', () => {
+    test('Some(val) in generic function is rewritten', () => {
+        const src = `
+      fn wrap_some<T>(val: T): Option<T> {
+        return Some(val);
+      }
+      fn main(): int {
+        let x: Option<int> = wrap_some<int>(42);
+        return 0;
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── generic with execute stmt ──────────────────────────────────────────
+describe('monomorphize — execute stmt in generic', () => {
+    test('execute as @a in generic function is rewritten', () => {
+        const src = `
+      fn broadcast<T>(val: T): void {
+        execute as @a run {
+          raw("say hi");
+        }
+      }
+      fn main(): int {
+        broadcast<int>(1);
+        return 0;
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── substType: function_type ───────────────────────────────────────────
+describe('monomorphize — substType function_type', () => {
+    test('generic fn with lambda param compiles', () => {
+        const src = `
+      fn apply<T>(val: T): T {
+        return val;
+      }
+      fn main(): int {
+        let x = apply<int>(10);
+        return x;
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── matchTypes: array → array ─────────────────────────────────────────
+describe('monomorphize — matchTypes array', () => {
+    test('type inference with nested array type', () => {
+        const src = `
+      fn wrap_arr<T>(arr: T[]): int {
+        return 0;
+      }
+      fn main(): int {
+        let arr: int[] = [1, 2, 3];
+        return wrap_arr(arr);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── matchTypes: tuple → tuple ─────────────────────────────────────────
+describe('monomorphize — matchTypes tuple', () => {
+    test('type inference with tuple type param', () => {
+        const src = `
+      fn fst<T>(a: T, b: int): T {
+        return a;
+      }
+      fn main(): int {
+        return fst<int>(42, 0);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── inferExprType: various expr types ────────────────────────────────
+describe('monomorphize — inferExprType coverage', () => {
+    test('byte_lit, short_lit, long_lit, double_lit in generic fn', () => {
+        const src = `
+      fn id<T>(val: T): T { return val; }
+      fn main(): int {
+        let a = id<int>(42);
+        return a;
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('binary expr type inference in generic', () => {
+        const src = `
+      fn compute<T>(a: T, b: T): int {
+        return 0;
+      }
+      fn main(): int {
+        let x: int = 5;
+        let y: int = 3;
+        return compute(x + y, 0);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('unary expr type inference in generic', () => {
+        const src = `
+      fn negate<T>(val: T): int { return 0; }
+      fn main(): int {
+        let x: int = 5;
+        return negate(-x);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ── typeSuffix: enum/struct/option ────────────────────────────────────
+describe('monomorphize — typeSuffix enum/struct/option', () => {
+    test('explicit Option<int> type arg uses opt_int suffix', () => {
+        const src = `
+      fn wrap<T>(val: T): int { return 0; }
+      fn main(): int {
+        let x: Option<int> = None;
+        return wrap<Option<int>>(x);
+      }
+    `;
+        const { files } = compileSource(src);
+        // Should have a specialization
+        expect(files.some(f => f.path.includes('wrap'))).toBe(true);
+    });
+});
+//# sourceMappingURL=monomorphize-extra2.test.js.map

package/dist/src/__tests__/incremental.test.js

@@ -233,19 +233,25 @@ describe('compileIncremental', () => {
         expect(result.recompiled).toBe(2);
         expect(result.cached).toBe(0);
         expect(result.errors.size).toBe(0);
+        const entry = cache.get(path.resolve(a));
+        expect(entry?.hash).toMatch(/^[0-9a-f]{64}$/);
+        expect(entry?.compiledFunctions?.length).toBeGreaterThan(0);
+        expect(entry?.outputFiles?.length).toBeGreaterThan(0);
     });
-    test('second compile (no changes): all files cached', () => {
+    test('second compile (no changes): all files cached and faster', () => {
         const a = writeFile(tmpDir, 'a.mcrs', 'fn a_func() { let x: int = 1; }');
         const b = writeFile(tmpDir, 'b.mcrs', 'fn b_func() { let y: int = 2; }');
         const cache = new index_1.FileCache(cacheDir);
         const depGraph = new deps_1.DependencyGraph();
         // First compile
-        (0, incremental_1.compileIncremental)([a, b], cache, depGraph, { output: outDir });
+        const first = (0, incremental_1.compileIncremental)([a, b], cache, depGraph, { output: outDir });
         // Second compile — no changes
         const result = (0, incremental_1.compileIncremental)([a, b], cache, depGraph, { output: outDir });
         expect(result.recompiled).toBe(0);
         expect(result.cached).toBe(2);
         expect(result.errors.size).toBe(0);
+        expect(result.skippedFiles).toEqual([path.resolve(a), path.resolve(b)]);
+        expect(result.elapsedMs).toBeLessThanOrEqual(first.elapsedMs + 20);
     });
     test('modify one file: only that file recompiled', () => {
         const a = writeFile(tmpDir, 'a.mcrs', 'fn a_func() { let x: int = 1; }');
@@ -283,6 +289,8 @@ describe('compileIncremental', () => {
         expect(result.recompiled).toBe(2);
         expect(result.cached).toBe(1);
         expect(result.errors.size).toBe(0);
+        expect(result.rebuiltFiles).toEqual([path.resolve(main1), path.resolve(main2)]);
+        expect(result.skippedFiles).toEqual([path.resolve(other)]);
     });
     test('output files are written to disk', () => {
         writeFile(tmpDir, 'a.mcrs', 'fn a_func() { let x: int = 1; }');

package/dist/src/__tests__/index-extra.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Coverage for src/index.ts
+ *
+ * Tests:
+ * - version export
+ * - check() with valid code (returns null)
+ * - check() with invalid code (returns Error)
+ * - checkWithWarnings() returns both error and warnings
+ */
+export {};

package/dist/src/__tests__/index-extra.test.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Coverage for src/index.ts
+ *
+ * Tests:
+ * - version export
+ * - check() with valid code (returns null)
+ * - check() with invalid code (returns Error)
+ * - checkWithWarnings() returns both error and warnings
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+describe('src/index — exported symbols', () => {
+    test('version export is a non-empty string', () => {
+        expect(typeof index_1.version).toBe('string');
+        expect(index_1.version.length).toBeGreaterThan(0);
+    });
+});
+describe('src/index — check()', () => {
+    test('check() returns null for valid code', () => {
+        const result = (0, index_1.check)(`
+      fn f(): int { return 42; }
+    `);
+        expect(result).toBeNull();
+    });
+    test('check() returns Error for invalid code', () => {
+        const result = (0, index_1.check)(`
+      fn f(): int { return "not an int"; }
+    `);
+        expect(result).toBeInstanceOf(Error);
+    });
+    test('check() returns null for empty function', () => {
+        const result = (0, index_1.check)(`
+      fn f(): void { }
+    `);
+        expect(result).toBeNull();
+    });
+    test('check() with custom namespace', () => {
+        const result = (0, index_1.check)(`fn f(): int { return 1; }`, 'custom_ns');
+        expect(result).toBeNull();
+    });
+    test('check() with syntax error returns Error', () => {
+        const result = (0, index_1.check)(`
+      fn f() {
+        let x = ;;; invalid
+      }
+    `);
+        expect(result).toBeInstanceOf(Error);
+    });
+    test('check() with filePath option', () => {
+        const result = (0, index_1.check)(`fn f(): int { return 1; }`, 'ns', 'test.mcrs');
+        expect(result).toBeNull();
+    });
+});
+describe('src/index — checkWithWarnings()', () => {
+    test('checkWithWarnings() returns null error for valid code', () => {
+        const result = (0, index_1.checkWithWarnings)(`fn f(): int { return 1; }`);
+        expect(result.error).toBeNull();
+        expect(Array.isArray(result.warnings)).toBe(true);
+    });
+    test('checkWithWarnings() returns Error for invalid code', () => {
+        const result = (0, index_1.checkWithWarnings)(`fn f(): int { return "wrong"; }`);
+        expect(result.error).toBeInstanceOf(Error);
+        expect(result.warnings).toEqual([]);
+    });
+    test('checkWithWarnings() with namespace', () => {
+        const result = (0, index_1.checkWithWarnings)(`fn f(): void { }`, 'myns');
+        expect(result.error).toBeNull();
+    });
+});
+//# sourceMappingURL=index-extra.test.js.map

package/dist/src/__tests__/lexer.test.js

@@ -10,10 +10,10 @@ function kinds(tokens) {
 describe('Lexer', () => {
     describe('keywords', () => {
         it('recognizes all keywords', () => {
-            const tokens = tokenize('fn let const if else while for foreach match return as at in is struct impl enum trigger namespace');
+            const tokens = tokenize('fn let const if else while for foreach match return as at in is struct extends impl enum trigger namespace');
             expect(kinds(tokens)).toEqual([
                 'fn', 'let', 'const', 'if', 'else', 'while', 'for', 'foreach', 'match',
-                'return', 'as', 'at', 'in', 'is', 'struct', 'impl', 'enum', 'trigger', 'namespace', 'eof'
+                'return', 'as', 'at', 'in', 'is', 'struct', 'extends', 'impl', 'enum', 'trigger', 'namespace', 'eof'
             ]);
         });
         it('tokenizes is-check and impl syntax with their dedicated keywords', () => {

package/dist/src/__tests__/lint/rules.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for redscript lint rules.
+ * Each rule has 2-3 test cases.
+ */
+export {};

package/dist/src/__tests__/lint/rules.test.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * Tests for redscript lint rules.
+ * Each rule has 2-3 test cases.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../lint/index");
+// ---------------------------------------------------------------------------
+// Helper
+// ---------------------------------------------------------------------------
+function lint(source, opts = {}) {
+    return (0, index_1.lintString)(source, '<test>', 'test', opts);
+}
+function ruleNames(source, opts = {}) {
+    return lint(source, opts).map(w => w.rule);
+}
+function messages(source, opts = {}) {
+    return lint(source, opts).map(w => w.message);
+}
+// ---------------------------------------------------------------------------
+// Rule: unused-variable
+// ---------------------------------------------------------------------------
+describe('unused-variable', () => {
+    it('warns when a let variable is never read', () => {
+        const src = `
+fn foo(): void {
+  let x: int = 5;
+}
+`;
+        const rules = ruleNames(src);
+        expect(rules).toContain('unused-variable');
+        const msgs = messages(src);
+        expect(msgs.some(m => m.includes('"x"') && m.includes('never used'))).toBe(true);
+    });
+    it('does NOT warn when the variable is read', () => {
+        const src = `
+fn foo(): int {
+  let x: int = 5;
+  return x;
+}
+`;
+        const warnings = lint(src).filter(w => w.rule === 'unused-variable');
+        expect(warnings).toHaveLength(0);
+    });
+    it('warns for multiple unused variables in the same function', () => {
+        const src = `
+fn bar(): void {
+  let a: int = 1;
+  let b: int = 2;
+}
+`;
+        const warnings = lint(src).filter(w => w.rule === 'unused-variable');
+        // both a and b are unused
+        const names = warnings.map(w => w.message).join(',');
+        expect(names).toContain('"a"');
+        expect(names).toContain('"b"');
+    });
+});
+// ---------------------------------------------------------------------------
+// Rule: unused-import
+// ---------------------------------------------------------------------------
+describe('unused-import', () => {
+    it('warns when an imported symbol is never used', () => {
+        // Use a simple import that the parser will accept
+        const src = `
+import mylib::helper;
+
+fn main(): void {
+  say("hello");
+}
+`;
+        const warnings = lint(src).filter(w => w.rule === 'unused-import');
+        // The import "helper" from "mylib" is never called
+        expect(warnings.length).toBeGreaterThan(0);
+        expect(warnings[0].message).toContain('"helper"');
+    });
+    it('does NOT warn when the imported symbol is called', () => {
+        const src = `
+import mylib::helper;
+
+fn main(): void {
+  helper();
+}
+`;
+        const warnings = lint(src).filter(w => w.rule === 'unused-import');
+        expect(warnings).toHaveLength(0);
+    });
+    it('warns for each individually unused named import', () => {
+        const src = `
+import mylib::alpha;
+import mylib::beta;
+
+fn main(): void {
+  alpha();
+}
+`;
+        const warnings = lint(src).filter(w => w.rule === 'unused-import');
+        // only beta is unused
+        expect(warnings).toHaveLength(1);
+        expect(warnings[0].message).toContain('"beta"');
+    });
+});
+// ---------------------------------------------------------------------------
+// Rule: magic-number
+// ---------------------------------------------------------------------------
+describe('magic-number', () => {
+    it('warns for literal numbers greater than 1', () => {
+        const src = `
+fn foo(): void {
+  let x: int = 1000;
+}
+`;
+        const warnings = lint(src).filter(w => w.rule === 'magic-number');
+        expect(warnings.length).toBeGreaterThan(0);
+        expect(warnings[0].message).toContain('1000');
+    });
+    it('does NOT warn for 0 or 1', () => {
+        const src = `
+fn foo(): int {
+  let a: int = 0;
+  let b: int = 1;
+  return a + b;
+}
+`;
+        const warnings = lint(src).filter(w => w.rule === 'magic-number');
+        expect(warnings).toHaveLength(0);
+    });
+    it('does NOT warn for numbers in const declarations', () => {
+        const src = `
+const MAX_PLAYERS: int = 100;
+
+fn foo(): void {
+  say("ok");
+}
+`;
+        const warnings = lint(src).filter(w => w.rule === 'magic-number');
+        expect(warnings).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// Rule: dead-branch
+// ---------------------------------------------------------------------------
+describe('dead-branch', () => {
+    it('warns for if (1 == 2) — always false condition', () => {
+        const src = `
+fn foo(): void {
+  if 1 == 2 {
+    say("never");
+  }
+}
+`;
+        const warnings = lint(src).filter(w => w.rule === 'dead-branch');
+        expect(warnings.length).toBeGreaterThan(0);
+        expect(warnings[0].message).toContain('always false');
+    });
+    it('warns for if (3 == 3) — always true condition', () => {
+        const src = `
+fn foo(): void {
+  if 3 == 3 {
+    say("always");
+  }
+}
+`;
+        const warnings = lint(src).filter(w => w.rule === 'dead-branch');
+        expect(warnings.length).toBeGreaterThan(0);
+        expect(warnings[0].message).toContain('always true');
+    });
+    it('does NOT warn for dynamic conditions', () => {
+        const src = `
+fn foo(x: int): void {
+  if x == 5 {
+    say("maybe");
+  }
+}
+`;
+        const warnings = lint(src).filter(w => w.rule === 'dead-branch');
+        expect(warnings).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// Rule: function-too-long
+// ---------------------------------------------------------------------------
+describe('function-too-long', () => {
+    it('warns when function body exceeds maxFunctionLines', () => {
+        // Build a function with 60 statements
+        const stmts = Array.from({ length: 60 }, (_, i) => `  say("line ${i}");`).join('\n');
+        const src = `fn long_fn(): void {\n${stmts}\n}`;
+        const warnings = lint(src, { maxFunctionLines: 50 }).filter(w => w.rule === 'function-too-long');
+        expect(warnings.length).toBeGreaterThan(0);
+        expect(warnings[0].message).toContain('"long_fn"');
+    });
+    it('does NOT warn when function is within the limit', () => {
+        const stmts = Array.from({ length: 5 }, (_, i) => `  say("line ${i}");`).join('\n');
+        const src = `fn short_fn(): void {\n${stmts}\n}`;
+        const warnings = lint(src, { maxFunctionLines: 50 }).filter(w => w.rule === 'function-too-long');
+        expect(warnings).toHaveLength(0);
+    });
+    it('respects custom maxFunctionLines threshold', () => {
+        const stmts = Array.from({ length: 10 }, (_, i) => `  say("s${i}");`).join('\n');
+        const src = `fn medium_fn(): void {\n${stmts}\n}`;
+        // With default 50 it's fine, with threshold 5 it should warn
+        const noWarn = lint(src, { maxFunctionLines: 50 }).filter(w => w.rule === 'function-too-long');
+        expect(noWarn).toHaveLength(0);
+        const warn = lint(src, { maxFunctionLines: 5 }).filter(w => w.rule === 'function-too-long');
+        expect(warn.length).toBeGreaterThan(0);
+    });
+});
+//# sourceMappingURL=rules.test.js.map