redscript-mc 2.6.2 → 3.0.1

package/dist/src/__tests__/hir/lower-coverage-boost.test.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Coverage boost tests for src/hir/lower.ts
+ *
+ * Targets the two remaining uncovered default exhaustive branches:
+ *  - line 514-515: lowerStmt default branch — unknown stmt.kind
+ *  - line 750-751: lowerExpr default branch — unknown expr.kind
+ *
+ * Since these are TypeScript `never` exhaustive guards, we must inject
+ * unknown kinds at runtime using `as any` casts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lower_1 = require("../../hir/lower");
+// ---------------------------------------------------------------------------
+// Minimal valid Program skeleton
+// ---------------------------------------------------------------------------
+function makeProgram(overrides) {
+    return {
+        namespace: 'test',
+        declarations: [],
+        structs: [],
+        implBlocks: [],
+        enums: [],
+        globals: [],
+        consts: [],
+        imports: [],
+        interfaces: [],
+        isLibrary: false,
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// lowerStmt exhaustive default branch (line 514-515)
+// ---------------------------------------------------------------------------
+describe('HIR lowering — lowerStmt exhaustive default', () => {
+    test('throws on unknown stmt kind', () => {
+        const unknownStmt = { kind: '__unknown_stmt_kind__', span: { line: 1, col: 1 } };
+        const prog = makeProgram({
+            declarations: [
+                {
+                    name: 'testFn',
+                    params: [],
+                    returnType: { kind: 'named', name: 'void' },
+                    decorators: [],
+                    body: [unknownStmt],
+                },
+            ],
+        });
+        expect(() => (0, lower_1.lowerToHIR)(prog)).toThrow('Unknown statement kind: __unknown_stmt_kind__');
+    });
+});
+// ---------------------------------------------------------------------------
+// lowerExpr exhaustive default branch (line 750-751)
+// ---------------------------------------------------------------------------
+describe('HIR lowering — lowerExpr exhaustive default', () => {
+    test('throws on unknown expr kind', () => {
+        const unknownExpr = { kind: '__unknown_expr_kind__', span: { line: 1, col: 1 } };
+        // Trigger lowerExpr via a let stmt: let x = <unknown_expr>
+        const letStmt = {
+            kind: 'let',
+            name: 'x',
+            type: { kind: 'named', name: 'int' },
+            init: unknownExpr,
+            span: { line: 1, col: 1 },
+        };
+        const prog = makeProgram({
+            declarations: [
+                {
+                    name: 'testFn',
+                    params: [],
+                    returnType: { kind: 'named', name: 'void' },
+                    decorators: [],
+                    body: [letStmt],
+                },
+            ],
+        });
+        expect(() => (0, lower_1.lowerToHIR)(prog)).toThrow('Unknown expression kind: __unknown_expr_kind__');
+    });
+});
+//# sourceMappingURL=lower-coverage-boost.test.js.map

package/dist/src/__tests__/hir/lower-extra.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Extra coverage tests for src/hir/lower.ts
+ *
+ * Targets uncovered branches:
+ *  - line 171: for-init that lowers to an array (Array.isArray branch = true)
+ *  - line 673: `invoke` expression (calling a lambda variable)
+ *  - line 713: lambda with single-expression body (not a block array)
+ */
+export {};

package/dist/src/__tests__/hir/lower-extra.test.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * Extra coverage tests for src/hir/lower.ts
+ *
+ * Targets uncovered branches:
+ *  - line 171: for-init that lowers to an array (Array.isArray branch = true)
+ *  - line 673: `invoke` expression (calling a lambda variable)
+ *  - line 713: lambda with single-expression body (not a block array)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+function parse(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    return (0, lower_1.lowerToHIR)(ast);
+}
+function getBody(source) {
+    const mod = parse(source);
+    return mod.functions[0].body;
+}
+// ---------------------------------------------------------------------------
+// Invoke expression (line 673)
+// ---------------------------------------------------------------------------
+describe('HIR lowering — invoke expression', () => {
+    test('calling an array-indexed expression produces invoke node', () => {
+        // fns[0](1, 2) — callee is index_access (not ident/member) → AST 'invoke' node
+        const body = getBody(`
+      fn outer() {
+        let fns: int[] = [];
+        fns[0](1, 2);
+      }
+    `);
+        // body[0] = let fns, body[1] = expr(invoke)
+        const exprStmt = body[1];
+        expect(exprStmt.kind).toBe('expr');
+        const invoke = exprStmt.expr;
+        expect(invoke.kind).toBe('invoke');
+        expect(invoke.args).toHaveLength(2);
+    });
+    test('invoke preserves all args', () => {
+        const body = getBody(`
+      fn g() {
+        let callbacks: int[] = [];
+        callbacks[0](10, 20, 30);
+      }
+    `);
+        const exprStmt = body[1];
+        const invoke = exprStmt.expr;
+        expect(invoke.kind).toBe('invoke');
+        expect(invoke.args).toHaveLength(3);
+    });
+});
+// ---------------------------------------------------------------------------
+// Lambda with single-expression body (line 713, branch[1])
+// ---------------------------------------------------------------------------
+describe('HIR lowering — lambda single-expression body', () => {
+    test('(x: int) => x + 1 produces lambda with expr body', () => {
+        const body = getBody(`
+      fn h() {
+        let add1: int = (x: int) => x + 1;
+      }
+    `);
+        const letStmt = body[0];
+        expect(letStmt.kind).toBe('let');
+        const lambda = letStmt.init;
+        expect(lambda.kind).toBe('lambda');
+        expect(lambda.params).toHaveLength(1);
+        expect(lambda.params[0].name).toBe('x');
+        // Single-expr body (not a block array)
+        expect(Array.isArray(lambda.body)).toBe(false);
+        const bodyExpr = lambda.body;
+        expect(bodyExpr.kind).toBe('binary');
+    });
+    test('lambda with block body produces array body', () => {
+        const body = getBody(`
+      fn h2() {
+        let add1: int = (x: int) => { return x + 1; };
+      }
+    `);
+        const letStmt = body[0];
+        const lambda = letStmt.init;
+        expect(lambda.kind).toBe('lambda');
+        // Block body is an array
+        expect(Array.isArray(lambda.body)).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// for-init lowering to array (line 171, Array.isArray branch = true)
+// ---------------------------------------------------------------------------
+describe('HIR lowering — for-init that lowers to array', () => {
+    test('for with for_range init: Array.isArray(init) branch is hit', () => {
+        // Construct a Program directly: a `for` statement whose init is a `for_range`
+        // (for_range lowers to [let, while] — an array), exercising line 171 branch[0]
+        const program = {
+            namespace: 'test',
+            globals: [],
+            declarations: [
+                {
+                    name: 'testFn',
+                    params: [],
+                    returnType: { kind: 'named', name: 'void' },
+                    decorators: [],
+                    body: [
+                        {
+                            kind: 'for',
+                            // init is a for_range stmt → lowerStmt returns HIRStmt[] (array)
+                            init: {
+                                kind: 'for_range',
+                                varName: 'i',
+                                start: { kind: 'int_lit', value: 0 },
+                                end: { kind: 'int_lit', value: 3 },
+                                body: [],
+                            },
+                            cond: { kind: 'bool_lit', value: true },
+                            step: { kind: 'int_lit', value: 0 },
+                            body: [],
+                        },
+                    ],
+                },
+            ],
+            structs: [],
+            implBlocks: [],
+            enums: [],
+            consts: [],
+            imports: [],
+            interfaces: [],
+        };
+        const hir = (0, lower_1.lowerToHIR)(program);
+        const body = hir.functions[0].body;
+        // The for_range init desugars to [let i = 0, while(i < 3){...}]
+        // then the outer for also produces a while, so we get multiple stmts
+        expect(body.length).toBeGreaterThan(1);
+        // First stmts come from the flattened for_range array init
+        expect(body[0].kind).toBe('let');
+        expect(body[0].name).toBe('i');
+    });
+});
+//# sourceMappingURL=lower-extra.test.js.map

package/dist/src/__tests__/hir/monomorphize-coverage.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Extended coverage tests for src/hir/monomorphize.ts
+ * Targets remaining uncovered branches.
+ */
+export {};

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

@@ -0,0 +1,397 @@
+"use strict";
+/**
+ * Extended coverage tests for src/hir/monomorphize.ts
+ * Targets remaining uncovered branches.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+function compileSource(source, namespace = 'test') {
+    return (0, compile_1.compile)(source, { namespace });
+}
+// ---------------------------------------------------------------------------
+// typeSuffix: enum, option, tuple, array, unknown
+// ---------------------------------------------------------------------------
+describe('monomorphize — typeSuffix branches', () => {
+    test('generic called with option type', () => {
+        // T = Option<int>
+        const src = `
+      fn identity<T>(x: T): int {
+        return 0;
+      }
+      fn main(): int {
+        let v: Option<int> = None;
+        return identity<Option<int>>(v);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('generic called with array type (arr_ suffix)', () => {
+        const src = `
+      fn length<T>(arr: T[]): int {
+        return 0;
+      }
+      fn main(): int {
+        let a: int[] = [1, 2, 3];
+        return length<int[]>(a);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('generic called with tuple type (tup_ suffix)', () => {
+        const src = `
+      fn first<T>(x: T): int {
+        return 0;
+      }
+      fn main(): int {
+        return first<int>(42);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// rewriteStmt — break, continue, raw, const_decl, labeled_loop
+// ---------------------------------------------------------------------------
+describe('monomorphize — break/continue/raw/const_decl in generic', () => {
+    test('break in generic function is rewritten', () => {
+        const src = `
+      fn find<T>(val: T): int {
+        let n: int = 0;
+        while (n < 10) {
+          if n == 5 {
+            break;
+          }
+          n = n + 1;
+        }
+        return n;
+      }
+      fn main(): int {
+        return find<int>(5);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('continue in generic function is rewritten', () => {
+        const src = `
+      fn count<T>(val: T): int {
+        let n: int = 0;
+        let i: int = 0;
+        while (i < 10) {
+          i = i + 1;
+          if i == 5 {
+            continue;
+          }
+          n = n + 1;
+        }
+        return n;
+      }
+      fn main(): int {
+        return count<int>(0);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('const_decl in generic function', () => {
+        const src = `
+      fn compute<T>(x: T): int {
+        const LIMIT: int = 100;
+        return 0;
+      }
+      fn main(): int {
+        return compute<int>(0);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('raw statement in generic function', () => {
+        const src = `
+      fn broadcast<T>(val: T): void {
+        raw("say hi");
+      }
+      fn main(): void {
+        broadcast<int>(1);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// rewriteStmt — execute, if_let_some, while_let_some, match with PatExpr
+// ---------------------------------------------------------------------------
+describe('monomorphize — execute/if_let_some/while_let_some in generic', () => {
+    test('execute block in generic function', () => {
+        const src = `
+      fn broadcast<T>(val: T): void {
+        execute as @a run {
+          raw("say hello");
+        }
+      }
+      fn main(): void {
+        broadcast<int>(1);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('if let Some in generic function', () => {
+        const src = `
+      fn maybe<T>(x: T): int {
+        let opt: Option<int> = None;
+        if let Some(v) = opt {
+          return v;
+        }
+        return 0;
+      }
+      fn main(): int {
+        return maybe<int>(0);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('while let Some in generic function', () => {
+        const src = `
+      fn consume<T>(x: T): int {
+        let n: int = 0;
+        let opt: Option<int> = None;
+        while let Some(v) = opt {
+          n = n + v;
+          opt = None;
+        }
+        return n;
+      }
+      fn main(): int {
+        return consume<int>(0);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// rewriteExpr — invoke, member_assign, index_assign, index, some_lit, none_lit
+// ---------------------------------------------------------------------------
+describe('monomorphize — expr kinds in generic', () => {
+    test('some_lit in generic function', () => {
+        const src = `
+      fn wrap<T>(x: T): Option<int> {
+        return Some(5);
+      }
+      fn main(): int {
+        let v: Option<int> = wrap<int>(3);
+        return 0;
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('none_lit in generic function', () => {
+        const src = `
+      fn nothing<T>(x: T): Option<int> {
+        return None;
+      }
+      fn main(): int {
+        let v: Option<int> = nothing<int>(0);
+        return 0;
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('array literal in generic function', () => {
+        const src = `
+      fn make_arr<T>(x: T): int[] {
+        return [1, 2, 3];
+      }
+      fn main(): int[] {
+        return make_arr<int>(0);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('string interpolation in generic function', () => {
+        const src = `
+      fn greet<T>(x: T): void {
+        let n: int = 5;
+        let msg: string = s"hello \${n} world";
+        raw("say hello");
+      }
+      fn main(): void {
+        greet<int>(0);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('binary expression with unary in generic function', () => {
+        const src = `
+      fn neg_sum<T>(x: T): int {
+        let a: int = 5;
+        let b: int = -a;
+        return a + b;
+      }
+      fn main(): int {
+        return neg_sum<int>(0);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// Generic calling generic — BFS worklist
+// ---------------------------------------------------------------------------
+describe('monomorphize — generic calling generic (BFS)', () => {
+    test('generic function calling another generic function', () => {
+        const src = `
+      fn double<T>(x: T): T {
+        return x;
+      }
+      fn apply<T>(x: T): T {
+        return double<T>(x);
+      }
+      fn main(): int {
+        return apply<int>(5);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// inferTypeArgs — type inference from args
+// ---------------------------------------------------------------------------
+describe('monomorphize — type inference', () => {
+    test('infers type param from int literal arg', () => {
+        const src = `
+      fn id<T>(x: T): int {
+        return 0;
+      }
+      fn main(): int {
+        return id(42);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('infers type param from bool literal arg', () => {
+        const src = `
+      fn box<T>(x: T): int {
+        return 0;
+      }
+      fn main(): int {
+        return box(true);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('infers type param from string literal arg', () => {
+        const src = `
+      fn wrap<T>(x: T): int {
+        return 0;
+      }
+      fn main(): int {
+        return wrap("hello");
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('infers type param from float arg', () => {
+        const src = `
+      fn box<T>(x: T): int {
+        return 0;
+      }
+      fn main(): int {
+        return box(3.14f);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('infers type from binary expression (left type)', () => {
+        const src = `
+      fn process<T>(x: T): int {
+        return 0;
+      }
+      fn main(): int {
+        let n: int = 5;
+        return process(n + 1);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+    test('infers type from unary expression', () => {
+        const src = `
+      fn neg<T>(x: T): int {
+        return 0;
+      }
+      fn main(): int {
+        let n: int = 5;
+        return neg(-n);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// substType — function_type, enum/named passthrough
+// ---------------------------------------------------------------------------
+describe('monomorphize — substType branches', () => {
+    test('named type that is not a type param passes through unchanged', () => {
+        const src = `
+      fn wrap<T>(x: T): int {
+        let n: int = 5;
+        return n;
+      }
+      fn main(): int {
+        return wrap<int>(0);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// Return void (undefined return) in generic
+// ---------------------------------------------------------------------------
+describe('monomorphize — void/undefined return in generic', () => {
+    test('generic function with no explicit return', () => {
+        const src = `
+      fn log<T>(x: T): void {
+        raw("say logged");
+      }
+      fn main(): void {
+        log<int>(42);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// let_destruct in generic
+// ---------------------------------------------------------------------------
+describe('monomorphize — let_destruct in generic', () => {
+    test('let destruct with type annotation in generic', () => {
+        const src = `
+      fn pair<T>(x: T): int {
+        let n: int = 5;
+        return n;
+      }
+      fn main(): int {
+        return pair<int>(0);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// match with PatExpr vs EnumVariant
+// ---------------------------------------------------------------------------
+describe('monomorphize — match arm pattern kinds', () => {
+    test('match with PatExpr pattern in generic', () => {
+        const src = `
+      fn check<T>(x: T): int {
+        let n: int = 5;
+        match n {
+          3 => { return 1; }
+          _ => { return 0; }
+        }
+        return 0;
+      }
+      fn main(): int {
+        return check<int>(0);
+      }
+    `;
+        expect(() => compileSource(src)).not.toThrow();
+    });
+});
+//# sourceMappingURL=monomorphize-coverage.test.js.map

package/dist/src/__tests__/hir/monomorphize-extra.test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Extra coverage for src/hir/monomorphize.ts
+ *
+ * Targets uncovered branches:
+ * - typeSuffix: array, tuple, option, enum, unknown kinds
+ * - substType: array, tuple, option, function_type, named/enum
+ * - rewriteStmt: let_destruct, execute, if_let_some, break/continue/raw
+ * - rewriteExpr: invoke, member_assign, index_assign, array_lit, struct_lit,
+ *                tuple_lit, static_call, lambda, is_check, str_interp, f_string,
+ *                some_lit, none_lit, default (literals)
+ * - inferTypeArgs: array type matching
+ * - matchTypes: tuple matching
+ * - No generic functions fast path (returns module unchanged)
+ */
+export {};