redscript-mc 2.4.1 → 2.6.0

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)
+  })
+})

package/src/__tests__/float.test.ts

@@ -0,0 +1,158 @@
+/**
+ * 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.
+ */
+
+import { compile } from '../emit/compile'
+
+function getAllMcContent(files: { path: string; content: string }[]): string {
+  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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = compile(source, { namespace: 'floattest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('2500')
+  })
+})

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

@@ -0,0 +1,149 @@
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { lowerToHIR } from '../hir/lower'
+import type { HIRStmt, HIRExpr } from '../hir/types'
+import { compile } from '../emit/compile'
+
+function parseHIR(source: string) {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  return lowerToHIR(ast)
+}
+
+function getBody(source: string): HIRStmt[] {
+  return parseHIR(source).functions[0].body
+}
+
+describe('for-range: lexer', () => {
+  test('lexes 0..10 as range_lit', () => {
+    const tokens = new 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('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('..=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('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(new 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 as any).value).toBe(0)
+      expect((stmt.end as any).value).toBe(10)
+    }
+  })
+
+  test('for i in 0..=9 parses to for_range with inclusive=true', () => {
+    const program = new Parser(new 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 as any).value).toBe(0)
+      expect((stmt.end as any).value).toBe(9)
+    }
+  })
+
+  test('for i in 0..n parses to for_range with dynamic end', () => {
+    const program = new Parser(new 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 as any).value).toBe(0)
+      expect((stmt.end as any).kind).toBe('ident')
+      expect((stmt.end as any).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] as Extract<HIRStmt, { kind: 'while' }>
+    const cond = w.cond as Extract<HIRExpr, { kind: 'binary' }>
+    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] as Extract<HIRStmt, { kind: 'while' }>
+    const cond = w.cond as Extract<HIRExpr, { kind: 'binary' }>
+    expect(cond.op).toBe('<=')
+    expect((cond.right as any).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] as Extract<HIRStmt, { kind: 'while' }>
+    const cond = w.cond as Extract<HIRExpr, { kind: 'binary' }>
+    expect(cond.op).toBe('<')
+    expect((cond.right as any).kind).toBe('ident')
+    expect((cond.right as any).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(() => 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(() => 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(() => compile(src, { namespace: 'test' })).not.toThrow()
+  })
+})

package/src/__tests__/generics.test.ts

@@ -127,13 +127,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 = 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)', () => {
@@ -258,11 +258,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 = 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', () => {

package/src/__tests__/impl.test.ts

@@ -0,0 +1,207 @@
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { lowerToHIR } from '../hir/lower'
+import { compile } from '../emit/compile'
+
+function parse(source: string) {
+  const tokens = new Lexer(source).tokenize()
+  return new 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 = 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(() => 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(() => 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(() => 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(() => 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(() => 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 = 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)
+  })
+})