redscript-mc 2.5.0 → 2.6.2

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

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * Tests for float (×1000 fixed-point) support in the RedScript compiler.
+ *
+ * RedScript floats are stored as ×1000 fixed-point integers on MC scoreboards.
+ * 1.5f → 1500, 3.14f → 3140, etc.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../emit/compile");
+function getAllMcContent(files) {
+    return files.filter(f => f.path.endsWith('.mcfunction')).map(f => f.content).join('\n');
+}
+describe('float literals (×1000 fixed-point)', () => {
+    test('1.5 literal compiles to scoreboard value 1500', () => {
+        const source = `fn t(): float { return 1.5; }`;
+        const result = (0, compile_1.compile)(source, { namespace: 'floattest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('1500');
+    });
+    test('3.14 literal compiles to scoreboard value 3140', () => {
+        const source = `fn t(): float { return 3.14; }`;
+        const result = (0, compile_1.compile)(source, { namespace: 'floattest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('3140');
+    });
+    test('2.0 literal compiles to 2000', () => {
+        const source = `fn t(): float { return 2.0; }`;
+        const result = (0, compile_1.compile)(source, { namespace: 'floattest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('2000');
+    });
+    test('0.5 literal compiles to 500', () => {
+        const source = `fn t(): float { return 0.5; }`;
+        const result = (0, compile_1.compile)(source, { namespace: 'floattest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('500');
+    });
+});
+describe('float addition', () => {
+    test('1.5 + 2.5 = 4.0 → result 4000 in output', () => {
+        // 1500 + 2500 = 4000 — addition needs no scale correction
+        const source = `
+      fn t(): float {
+        let a: float = 1.5;
+        let b: float = 2.5;
+        return a + b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'floattest' });
+        const all = getAllMcContent(result.files);
+        // Constant folder folds 1500+2500=4000 — result must appear
+        expect(all).toContain('4000');
+    });
+    test('2.0 + 3.0 = 5.0 → result 5000', () => {
+        const source = `
+      fn t(): float {
+        let a: float = 2.0;
+        let b: float = 3.0;
+        return a + b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'floattest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('5000');
+    });
+});
+describe('float multiplication (scale correction ÷1000)', () => {
+    test('2.0 * 3.0 = 6.0 → result 6000 (not 6000000)', () => {
+        // Without correction: 2000 * 3000 = 6000000 (wrong)
+        // With correction: 2000 * 3000 / 1000 = 6000 ✓
+        const source = `
+      fn t(): float {
+        let a: float = 2.0;
+        let b: float = 3.0;
+        return a * b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'floattest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('6000');
+        // Must NOT contain the uncorrected result
+        expect(all).not.toContain('6000000');
+    });
+    test('1.5 * 2.0 = 3.0 → result 3000 (not 3000000)', () => {
+        // Without correction: 1500 * 2000 = 3000000 (wrong)
+        // With correction: 1500 * 2000 / 1000 = 3000 ✓
+        const source = `
+      fn t(): float {
+        let a: float = 1.5;
+        let b: float = 2.0;
+        return a * b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'floattest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('3000');
+        expect(all).not.toContain('3000000');
+    });
+    test('0.5 * 0.5 = 0.25 → result 250 (not 250000)', () => {
+        // Without correction: 500 * 500 = 250000 (wrong)
+        // With correction: 500 * 500 / 1000 = 250 ✓
+        const source = `
+      fn t(): float {
+        let a: float = 0.5;
+        let b: float = 0.5;
+        return a * b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'floattest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('250');
+        expect(all).not.toContain('250000');
+    });
+});
+describe('float division (scale correction ×1000)', () => {
+    test('6.0 / 2.0 = 3.0 → result 3000 (not 3)', () => {
+        // Without correction: 6000 / 2000 = 3 (wrong)
+        // With correction: 6000 * 1000 / 2000 = 3000 ✓
+        const source = `
+      fn t(): float {
+        let a: float = 6.0;
+        let b: float = 2.0;
+        return a / b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'floattest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('3000');
+        // The uncorrected result would be 3 (without the trailing 000)
+        // Check we get 3000 not just 3
+        expect(all).toMatch(/3000/);
+    });
+    test('10.0 / 4.0 = 2.5 → result 2500 (not 2)', () => {
+        // Without correction: 10000 / 4000 = 2 (wrong, loses precision)
+        // With correction: 10000 * 1000 / 4000 = 2500 ✓
+        const source = `
+      fn t(): float {
+        let a: float = 10.0;
+        let b: float = 4.0;
+        return a / b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'floattest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('2500');
+    });
+});
+//# sourceMappingURL=float.test.js.map

package/dist/src/__tests__/for-each.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/__tests__/for-each.test.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const lower_1 = require("../hir/lower");
+const compile_1 = require("../emit/compile");
+function parseHIR(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) {
+    return parseHIR(source).functions[0].body;
+}
+describe('for-each: parser', () => {
+    test('for item in arr parses to for_each', () => {
+        const program = new parser_1.Parser(new lexer_1.Lexer('fn f(arr: int[]) { for item in arr { } }').tokenize()).parse('test');
+        const stmt = program.declarations[0].body[0];
+        expect(stmt.kind).toBe('for_each');
+        if (stmt.kind === 'for_each') {
+            expect(stmt.binding).toBe('item');
+            expect(stmt.array.kind).toBe('ident');
+            expect(stmt.array.name).toBe('arr');
+        }
+    });
+    test('for n in nums parses to for_each', () => {
+        const program = new parser_1.Parser(new lexer_1.Lexer('fn f(nums: int[]) { for n in nums { } }').tokenize()).parse('test');
+        const stmt = program.declarations[0].body[0];
+        expect(stmt.kind).toBe('for_each');
+        if (stmt.kind === 'for_each') {
+            expect(stmt.binding).toBe('n');
+        }
+    });
+});
+describe('for-each: HIR lowering', () => {
+    test('for item in arr → [let __foreach_len, let __foreach_i, while]', () => {
+        const body = getBody('fn f(arr: int[]) { for item in arr { } }');
+        // Expect: let __foreach_len, let __foreach_i, while
+        expect(body).toHaveLength(3);
+        expect(body[0].kind).toBe('let');
+        expect(body[1].kind).toBe('let');
+        expect(body[2].kind).toBe('while');
+    });
+    test('while condition uses idx < len', () => {
+        const body = getBody('fn f(arr: int[]) { for item in arr { } }');
+        const w = body[2];
+        const cond = w.cond;
+        expect(cond.op).toBe('<');
+        expect(cond.left.kind).toBe('ident');
+        expect(cond.right.kind).toBe('ident');
+    });
+    test('while body starts with let item = arr[idx]', () => {
+        const body = getBody('fn f(arr: int[]) { for item in arr { } }');
+        const w = body[2];
+        const firstBodyStmt = w.body[0];
+        expect(firstBodyStmt.kind).toBe('let');
+        expect(firstBodyStmt.name).toBe('item');
+        expect(firstBodyStmt.init.kind).toBe('index');
+    });
+    test('nested for-each generates unique variable names', () => {
+        const body = getBody('fn f(arr: int[], brr: int[]) { for x in arr { for y in brr { } } }');
+        // outer: let len_N, let i_N, while
+        expect(body).toHaveLength(3);
+        const outerLen = body[0].name;
+        const outerIdx = body[1].name;
+        const w = body[2];
+        // inner while is nested inside outer while body
+        const innerBody = w.body;
+        // Find inner let len and idx
+        const innerLenStmt = innerBody.find((s) => s.kind === 'let' && s.name.startsWith('__foreach_len_'));
+        const innerIdxStmt = innerBody.find((s) => s.kind === 'let' && s.name.startsWith('__foreach_i_'));
+        expect(innerLenStmt).toBeDefined();
+        expect(innerIdxStmt).toBeDefined();
+        // Names must differ from outer
+        expect(innerLenStmt.name).not.toBe(outerLen);
+        expect(innerIdxStmt.name).not.toBe(outerIdx);
+    });
+});
+describe('for-each: compile', () => {
+    test('basic element iteration compiles end-to-end', () => {
+        const src = `
+      @keep fn test(arr: int[]): void {
+        for item in arr {
+          let x: int = item
+        }
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+    test('accumulate sum compiles end-to-end', () => {
+        const src = `
+      @keep fn sum_all(items: int[]): int {
+        let total: int = 0
+        for x in items {
+          total = total + x
+        }
+        return total
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+    test('nested for-each compiles end-to-end', () => {
+        const src = `
+      @keep fn nested(arr: int[], brr: int[]): void {
+        for x in arr {
+          for y in brr {
+            let z: int = x + y
+          }
+        }
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+    test('for-each with function parameter compiles end-to-end', () => {
+        const src = `
+      @keep fn process(items: int[]): void {
+        for n in items {
+          let doubled: int = n + n
+        }
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+});
+//# sourceMappingURL=for-each.test.js.map

package/dist/src/__tests__/for-range.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/__tests__/for-range.test.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const lower_1 = require("../hir/lower");
+const compile_1 = require("../emit/compile");
+function parseHIR(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) {
+    return parseHIR(source).functions[0].body;
+}
+describe('for-range: lexer', () => {
+    test('lexes 0..10 as range_lit', () => {
+        const tokens = new lexer_1.Lexer('0..10').tokenize();
+        expect(tokens[0].kind).toBe('range_lit');
+        expect(tokens[0].value).toBe('0..10');
+    });
+    test('lexes 0..=9 as range_lit', () => {
+        const tokens = new lexer_1.Lexer('0..=9').tokenize();
+        expect(tokens[0].kind).toBe('range_lit');
+        expect(tokens[0].value).toBe('0..=9');
+    });
+    test('lexes ..=5 as range_lit', () => {
+        const tokens = new lexer_1.Lexer('..=5').tokenize();
+        expect(tokens[0].kind).toBe('range_lit');
+        expect(tokens[0].value).toBe('..=5');
+    });
+    test('lexes 0.. as range_lit (open-ended)', () => {
+        const tokens = new lexer_1.Lexer('0..').tokenize();
+        expect(tokens[0].kind).toBe('range_lit');
+        expect(tokens[0].value).toBe('0..');
+    });
+});
+describe('for-range: parser', () => {
+    test('for i in 0..10 parses to for_range', () => {
+        const program = new parser_1.Parser(new lexer_1.Lexer('fn f() { for i in 0..10 { } }').tokenize()).parse('test');
+        const stmt = program.declarations[0].body[0];
+        expect(stmt.kind).toBe('for_range');
+        if (stmt.kind === 'for_range') {
+            expect(stmt.varName).toBe('i');
+            expect(stmt.inclusive).toBeFalsy();
+            expect(stmt.start.value).toBe(0);
+            expect(stmt.end.value).toBe(10);
+        }
+    });
+    test('for i in 0..=9 parses to for_range with inclusive=true', () => {
+        const program = new parser_1.Parser(new lexer_1.Lexer('fn f() { for i in 0..=9 { } }').tokenize()).parse('test');
+        const stmt = program.declarations[0].body[0];
+        expect(stmt.kind).toBe('for_range');
+        if (stmt.kind === 'for_range') {
+            expect(stmt.varName).toBe('i');
+            expect(stmt.inclusive).toBe(true);
+            expect(stmt.start.value).toBe(0);
+            expect(stmt.end.value).toBe(9);
+        }
+    });
+    test('for i in 0..n parses to for_range with dynamic end', () => {
+        const program = new parser_1.Parser(new lexer_1.Lexer('fn f(n: int) { for i in 0..n { } }').tokenize()).parse('test');
+        const stmt = program.declarations[0].body[0];
+        expect(stmt.kind).toBe('for_range');
+        if (stmt.kind === 'for_range') {
+            expect(stmt.varName).toBe('i');
+            expect(stmt.inclusive).toBeFalsy();
+            expect(stmt.start.value).toBe(0);
+            expect(stmt.end.kind).toBe('ident');
+            expect(stmt.end.name).toBe('n');
+        }
+    });
+});
+describe('for-range: HIR lowering', () => {
+    test('for i in 0..10 → let i=0; while(i<10){body;i=i+1}', () => {
+        const body = getBody('fn f() { for i in 0..10 { } }');
+        expect(body).toHaveLength(2);
+        expect(body[0].kind).toBe('let');
+        expect(body[1].kind).toBe('while');
+        const w = body[1];
+        const cond = w.cond;
+        expect(cond.op).toBe('<');
+    });
+    test('for i in 0..=9 uses <= in while condition', () => {
+        const body = getBody('fn f() { for i in 0..=9 { } }');
+        expect(body).toHaveLength(2);
+        const w = body[1];
+        const cond = w.cond;
+        expect(cond.op).toBe('<=');
+        expect(cond.right.value).toBe(9);
+    });
+    test('for i in 0..n uses ident as end expr', () => {
+        const body = getBody('fn f(n: int) { for i in 0..n { } }');
+        expect(body).toHaveLength(2);
+        const w = body[1];
+        const cond = w.cond;
+        expect(cond.op).toBe('<');
+        expect(cond.right.kind).toBe('ident');
+        expect(cond.right.name).toBe('n');
+    });
+});
+describe('for-range: compile', () => {
+    test('for i in 0..n compiles end-to-end', () => {
+        const src = `
+      @keep fn test(n: int): void {
+        let sum: int = 0
+        for i in 0..n {
+          sum = sum + i
+        }
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+    test('for i in 0..=9 compiles end-to-end', () => {
+        const src = `
+      @keep fn test(): void {
+        let sum: int = 0
+        for i in 0..=9 {
+          sum = sum + i
+        }
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+    test('for i in 0..5 compiles end-to-end (literal)', () => {
+        const src = `
+      @keep fn test(): void {
+        let sum: int = 0
+        for i in 0..5 {
+          sum = sum + i
+        }
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+});
+//# sourceMappingURL=for-range.test.js.map

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

@@ -117,13 +117,13 @@ describe('Generics: Monomorphization', () => {
         return b;
       }
       fn use_int(): int { return max<int>(3, 5); }
-      fn use_float(): float { return max<float>(1.0, 2.0); }
+      fn use_fixed(): fixed { return max<fixed>(1.0, 2.0); }
     `;
         const hir2 = hirOf(source2);
         const mono2 = (0, monomorphize_1.monomorphize)(hir2);
         const names2 = mono2.functions.map(f => f.name);
         expect(names2).toContain('max_int');
-        expect(names2).toContain('max_float');
+        expect(names2).toContain('max_fixed');
     });
     it('does not duplicate specializations (caching works)', () => {
         const source = `
@@ -241,11 +241,11 @@ describe('Generics: E2E compilation', () => {
         return b;
       }
       fn use_int(): int { return max<int>(3, 5); }
-      fn use_float(): float { return max<float>(1.0, 2.0); }
+      fn use_fixed(): fixed { return max<fixed>(1.0, 2.0); }
     `;
         const result = (0, compile_1.compile)(source, { namespace: 'test' });
         expect(getFile(result.files, 'max_int.mcfunction')).toBeDefined();
-        expect(getFile(result.files, 'max_float.mcfunction')).toBeDefined();
+        expect(getFile(result.files, 'max_fixed.mcfunction')).toBeDefined();
     });
     test('type inference: max(3, 5) infers T=int and generates max_int', () => {
         const source = `

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const lower_1 = require("../hir/lower");
+const compile_1 = require("../emit/compile");
+function parse(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens).parse('test');
+}
+describe('impl: parser', () => {
+    test('parses impl block with self methods', () => {
+        const program = parse(`
+      struct Counter { value: int }
+      impl Counter {
+        fn increment(self): Counter {
+          return { value: self.value + 1 }
+        }
+        fn get(self): int {
+          return self.value
+        }
+      }
+    `);
+        expect(program.implBlocks).toHaveLength(1);
+        expect(program.implBlocks[0].typeName).toBe('Counter');
+        expect(program.implBlocks[0].methods).toHaveLength(2);
+        expect(program.implBlocks[0].methods[0].name).toBe('increment');
+        expect(program.implBlocks[0].methods[0].params[0].name).toBe('self');
+        expect(program.implBlocks[0].methods[0].params[0].type).toEqual({ kind: 'struct', name: 'Counter' });
+        expect(program.implBlocks[0].methods[1].name).toBe('get');
+    });
+    test('parses impl block with static method (no self)', () => {
+        const program = parse(`
+      struct Counter { value: int }
+      impl Counter {
+        fn new(n: int): Counter {
+          return { value: n }
+        }
+      }
+    `);
+        expect(program.implBlocks[0].methods[0].name).toBe('new');
+        expect(program.implBlocks[0].methods[0].params[0].name).toBe('n');
+    });
+    test('parses named struct literal TypeName { field: value }', () => {
+        const program = parse(`
+      struct Counter { value: int }
+      impl Counter {
+        fn increment(self): Counter {
+          return Counter { value: self.value + 1 }
+        }
+      }
+    `);
+        const body = program.implBlocks[0].methods[0].body;
+        const ret = body[0];
+        expect(ret.kind).toBe('return');
+        if (ret.kind === 'return' && ret.value) {
+            expect(ret.value.kind).toBe('struct_lit');
+        }
+    });
+});
+describe('impl: HIR lowering', () => {
+    test('impl methods appear in HIR implBlocks', () => {
+        const program = parse(`
+      struct Counter { value: int }
+      impl Counter {
+        fn increment(self): Counter {
+          return { value: self.value + 1 }
+        }
+        fn add(self, n: int): Counter {
+          return { value: self.value + n }
+        }
+      }
+    `);
+        const hir = (0, lower_1.lowerToHIR)(program);
+        expect(hir.implBlocks).toHaveLength(1);
+        expect(hir.implBlocks[0].typeName).toBe('Counter');
+        expect(hir.implBlocks[0].methods).toHaveLength(2);
+    });
+});
+describe('impl: compile', () => {
+    test('impl with self methods compiles end-to-end', () => {
+        const src = `
+      struct Counter { value: int }
+      impl Counter {
+        fn increment(self): Counter {
+          return { value: self.value + 1 }
+        }
+        fn add(self, n: int): Counter {
+          return { value: self.value + n }
+        }
+        fn get(self): int {
+          return self.value
+        }
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+    test('named struct literal Counter { ... } compiles end-to-end', () => {
+        const src = `
+      struct Counter { value: int }
+      impl Counter {
+        fn increment(self): Counter {
+          return Counter { value: self.value + 1 }
+        }
+        fn get(self): int {
+          return self.value
+        }
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+    test('method calls on struct instances compile', () => {
+        const src = `
+      struct Counter { value: int }
+      impl Counter {
+        fn increment(self): Counter {
+          return { value: self.value + 1 }
+        }
+        fn get(self): int {
+          return self.value
+        }
+      }
+      @keep fn main(): void {
+        let c: Counter = { value: 0 }
+        let c2: Counter = c.increment()
+        let v: int = c2.get()
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+    test('static method Counter::new compiles', () => {
+        const src = `
+      struct Counter { value: int }
+      impl Counter {
+        fn new(n: int): Counter {
+          return { value: n }
+        }
+      }
+      @keep fn main(): void {
+        let c: Counter = Counter::new(5)
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+    test('impl fixture compiles', () => {
+        const src = `
+      namespace impl_test
+      struct Counter {
+        value: int
+      }
+      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
+        }
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'impl_test' })).not.toThrow();
+    });
+});
+describe('impl: struct param method (bug fix)', () => {
+    test('method receiving another struct instance as param compiles and produces correct ops', () => {
+        // Regression: dot(self: Vec2, other: Vec2) was broken because struct args
+        // were not flattened field-by-field at call sites and in lowerImplMethod.
+        const src = `
+      struct Vec2 { x: int, y: int }
+      impl Vec2 {
+        fn dot(self, other: Vec2): int {
+          return self.x * other.x + self.y * other.y
+        }
+        fn length_sq(self): int {
+          return self.x * self.x + self.y * self.y
+        }
+      }
+      @keep fn test(): void {
+        let a: Vec2 = { x: 3, y: 4 }
+        let b: Vec2 = { x: 1, y: 2 }
+        let d: int = a.dot(b)
+        let l: int = a.length_sq()
+      }
+    `;
+        const result = (0, compile_1.compile)(src, { namespace: 'test' });
+        // dot(a={3,4}, b={1,2}) = 3*1 + 4*2 = 11, length_sq(a) = 9+16 = 25
+        // Compiler constant-folds into a specialized function dot__const_3_4_1_2
+        const allContent = result.files.map(f => f.content).join('\n');
+        // The specialized dot function should compute 3*1=3 and 4*2=8 and add them = 11
+        expect(allContent).toMatch(/set.*3\b/);
+        expect(allContent).toMatch(/set.*8\b/);
+        // Ensure no helper files for __entity_tag or nonexistent functions are emitted
+        const fnPaths = result.files.map(f => f.path);
+        expect(fnPaths.some(p => p.includes('dot'))).toBe(true);
+    });
+});
+//# sourceMappingURL=impl.test.js.map

package/dist/src/__tests__/lsp-logic.test.d.ts

@@ -0,0 +1 @@
+export {};