redscript-mc 1.2.30 → 2.1.0

package/src/__tests__/generics.test.ts

@@ -0,0 +1,390 @@
+/**
+ * Tests for Phase 2c: Generic functions (monomorphization)
+ *
+ * Covers:
+ * - Parsing fn<T> declarations and typeParams
+ * - Parsing explicit call<int>() type args
+ * - Type inference from arguments (max(3, 5) → max_int)
+ * - Monomorphization: unique specialized copies per type
+ * - Mangled names: max_int, max_float
+ * - Generic calling generic (clamp<T> calls min<T> and max<T>)
+ * - Interaction with enum + tuple
+ * - Correct scoreboard output
+ */
+
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { compile } from '../emit/compile'
+import { monomorphize } from '../hir/monomorphize'
+import { lowerToHIR } from '../hir/lower'
+import type { Program } from '../ast/types'
+
+function parse(source: string, namespace = 'test'): Program {
+  const tokens = new Lexer(source).tokenize()
+  return new Parser(tokens).parse(namespace)
+}
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  const f = files.find(f => f.path.includes(pathSubstr))
+  return f?.content
+}
+
+// ---------------------------------------------------------------------------
+// Parser tests
+// ---------------------------------------------------------------------------
+
+describe('Generics: Parser', () => {
+  it('parses fn max<T>(a: T, b: T): T with typeParams', () => {
+    const program = parse('fn max<T>(a: T, b: T): T {}')
+    const fn = program.declarations[0]
+    expect(fn.name).toBe('max')
+    expect(fn.typeParams).toEqual(['T'])
+    expect(fn.params[0].type).toEqual({ kind: 'struct', name: 'T' })
+    expect(fn.params[1].type).toEqual({ kind: 'struct', name: 'T' })
+    expect(fn.returnType).toEqual({ kind: 'struct', name: 'T' })
+  })
+
+  it('parses fn with two type params <A, B>', () => {
+    const program = parse('fn swap<A, B>(a: A, b: B): A {}')
+    const fn = program.declarations[0]
+    expect(fn.typeParams).toEqual(['A', 'B'])
+  })
+
+  it('parses explicit type args max<int>(3, 5)', () => {
+    const program = parse('fn _test(): int { return max<int>(3, 5); }')
+    const ret = program.declarations[0].body[0]
+    if (ret.kind === 'return' && ret.value && ret.value.kind === 'call') {
+      expect(ret.value.fn).toBe('max')
+      expect(ret.value.typeArgs).toBeDefined()
+      expect(ret.value.typeArgs![0]).toEqual({ kind: 'named', name: 'int' })
+    } else {
+      throw new Error('Expected return with call node')
+    }
+  })
+
+  it('parses call without type args (type inference)', () => {
+    const program = parse('fn _test(): int { return max(3, 5); }')
+    const ret = program.declarations[0].body[0]
+    if (ret.kind === 'return' && ret.value && ret.value.kind === 'call') {
+      expect(ret.value.fn).toBe('max')
+      expect(ret.value.typeArgs).toBeUndefined()
+    } else {
+      throw new Error('Expected return with call node')
+    }
+  })
+
+  it('does not break non-generic functions', () => {
+    const program = parse('fn add(a: int, b: int): int { return a + b; }')
+    const fn = program.declarations[0]
+    expect(fn.typeParams).toBeUndefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Monomorphization unit tests
+// ---------------------------------------------------------------------------
+
+describe('Generics: Monomorphization', () => {
+  function hirOf(source: string) {
+    const tokens = new Lexer(source).tokenize()
+    const ast = new Parser(tokens).parse('test')
+    return lowerToHIR(ast)
+  }
+
+  it('removes generic template and adds max_int specialization', () => {
+    const source = `
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn use_max(): int {
+        return max(3, 5);
+      }
+    `
+    const hir = hirOf(source)
+    const mono = monomorphize(hir)
+    const names = mono.functions.map(f => f.name)
+    expect(names).not.toContain('max')        // template removed
+    expect(names).toContain('max_int')        // specialization added
+    expect(names).toContain('use_max')        // regular fn preserved
+  })
+
+  it('generates both max_int and max_float for two call sites', () => {
+    const source = `
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn use_both(): int {
+        let a: int = max(3, 5);
+        return a;
+      }
+    `
+    // Only int can be inferred from literals here, but let's check explicit type args too
+    const source2 = `
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn use_int(): int { return max<int>(3, 5); }
+      fn use_float(): float { return max<float>(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')
+  })
+
+  it('does not duplicate specializations (caching works)', () => {
+    const source = `
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn a(): int { return max(1, 2); }
+      fn b(): int { return max(3, 4); }
+      fn c(): int { return max(5, 6); }
+    `
+    const hir = hirOf(source)
+    const mono = monomorphize(hir)
+    const maxIntCount = mono.functions.filter(f => f.name === 'max_int').length
+    expect(maxIntCount).toBe(1)  // only one copy
+  })
+
+  it('rewrites call sites to use mangled names', () => {
+    const source = `
+      fn min<T>(a: T, b: T): T {
+        if (a < b) { return a; }
+        return b;
+      }
+      fn use_min(): int {
+        return min(10, 20);
+      }
+    `
+    const hir = hirOf(source)
+    const mono = monomorphize(hir)
+    const useMin = mono.functions.find(f => f.name === 'use_min')!
+    const ret = useMin.body[0]
+    if (ret.kind === 'return' && ret.value && ret.value.kind === 'call') {
+      expect(ret.value.fn).toBe('min_int')
+    } else {
+      throw new Error('Expected return with call')
+    }
+  })
+
+  it('handles generic calling generic (clamp<T> → min<T>, max<T>)', () => {
+    const source = `
+      fn min<T>(a: T, b: T): T {
+        if (a < b) { return a; }
+        return b;
+      }
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn clamp<T>(val: T, lo: T, hi: T): T {
+        return max(min(val, hi), lo);
+      }
+      fn use_clamp(): int {
+        return clamp(5, 0, 10);
+      }
+    `
+    const hir = hirOf(source)
+    const mono = monomorphize(hir)
+    const names = mono.functions.map(f => f.name)
+    expect(names).toContain('clamp_int')
+    expect(names).toContain('min_int')
+    expect(names).toContain('max_int')
+    expect(names).not.toContain('clamp')
+    expect(names).not.toContain('min')
+    expect(names).not.toContain('max')
+  })
+
+  it('preserves non-generic functions unchanged', () => {
+    const source = `
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn helper(x: int): int { return x + 1; }
+    `
+    const hir = hirOf(source)
+    const mono = monomorphize(hir)
+    expect(mono.functions.find(f => f.name === 'helper')).toBeDefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// E2E compilation tests
+// ---------------------------------------------------------------------------
+
+describe('Generics: E2E compilation', () => {
+  test('basic generic max<T> compiles to max_int.mcfunction', () => {
+    const source = `
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn use_max(): int {
+        return max(3, 5);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    // Should generate max_int, not max
+    expect(getFile(result.files, 'max_int.mcfunction')).toBeDefined()
+    expect(getFile(result.files, '/max.mcfunction')).toBeUndefined()
+    expect(getFile(result.files, 'use_max.mcfunction')).toBeDefined()
+  })
+
+  test('explicit type args max<int>(3, 5) compiles correctly', () => {
+    const source = `
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn use_max(): int {
+        return max<int>(3, 5);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(getFile(result.files, 'max_int.mcfunction')).toBeDefined()
+  })
+
+  test('two specializations: max_int and max_float', () => {
+    const source = `
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn use_int(): int { return max<int>(3, 5); }
+      fn use_float(): float { return max<float>(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()
+  })
+
+  test('type inference: max(3, 5) infers T=int and generates max_int', () => {
+    const source = `
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn main(): int { return max(3, 5); }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(getFile(result.files, 'max_int.mcfunction')).toBeDefined()
+    // The main function should call max_int
+    const mainFn = getFile(result.files, 'main.mcfunction')
+    expect(mainFn).toBeDefined()
+    expect(mainFn).toContain('max_int')
+  })
+
+  test('clamp<T> using min<T> and max<T>: all three get specialized', () => {
+    const source = `
+      fn min<T>(a: T, b: T): T {
+        if (a < b) { return a; }
+        return b;
+      }
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn clamp<T>(val: T, lo: T, hi: T): T {
+        return max(min(val, hi), lo);
+      }
+      fn main(): int {
+        return clamp(5, 0, 10);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(getFile(result.files, 'clamp_int.mcfunction')).toBeDefined()
+    expect(getFile(result.files, 'min_int.mcfunction')).toBeDefined()
+    expect(getFile(result.files, 'max_int.mcfunction')).toBeDefined()
+    // clamp_int should call min_int and max_int
+    const clampFn = getFile(result.files, 'clamp_int.mcfunction')!
+    expect(clampFn).toContain('min_int')
+    expect(clampFn).toContain('max_int')
+  })
+
+  test('generated max_int uses scoreboard operations', () => {
+    const source = `
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn use_max(): int {
+        return max(1, 2);
+      }
+    `
+    const result = compile(source, { namespace: 'ns' })
+    const fn = getFile(result.files, 'max_int.mcfunction')!
+    expect(fn).toBeDefined()
+    expect(fn).toContain('__ns')
+    expect(fn).toContain('scoreboard')
+  })
+
+  test('generics work with enum types (max<Phase>)', () => {
+    const source = `
+      enum Phase { Idle, Running, Done }
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn main(): int {
+        return max<int>(Phase::Running, Phase::Done);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(getFile(result.files, 'max_int.mcfunction')).toBeDefined()
+  })
+
+  test('generics work alongside tuple return values', () => {
+    const source = `
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn minmax(a: int, b: int): (int, int) {
+        return (max(a, b), max(b, a));
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(getFile(result.files, 'max_int.mcfunction')).toBeDefined()
+    expect(getFile(result.files, 'minmax.mcfunction')).toBeDefined()
+    const minmaxFn = getFile(result.files, 'minmax.mcfunction')!
+    expect(minmaxFn).toContain('max_int')
+  })
+
+  test('abs<T> generic: abs(negative) returns positive', () => {
+    const source = `
+      fn abs<T>(x: T): T {
+        if (x < 0) { return 0 - x; }
+        return x;
+      }
+      fn main(): int {
+        return abs(-5);
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    expect(getFile(result.files, 'abs_int.mcfunction')).toBeDefined()
+    const mainFn = getFile(result.files, 'main.mcfunction')
+    expect(mainFn).toContain('abs_int')
+  })
+
+  test('unused generic produces no specialization files', () => {
+    const source = `
+      fn max<T>(a: T, b: T): T {
+        if (a > b) { return a; }
+        return b;
+      }
+      fn helper(): int { return 42; }
+    `
+    const result = compile(source, { namespace: 'test' })
+    // max<T> is never called, so max_int should NOT exist
+    expect(getFile(result.files, 'max_int.mcfunction')).toBeUndefined()
+    expect(getFile(result.files, '/max.mcfunction')).toBeUndefined()
+    expect(getFile(result.files, 'helper.mcfunction')).toBeDefined()
+  })
+})

package/src/__tests__/hir/desugar.test.ts

@@ -0,0 +1,263 @@
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { lowerToHIR } from '../../hir/lower'
+import type { HIRStmt, HIRExpr, HIRModule } from '../../hir/types'
+
+function parse(source: string): HIRModule {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  return lowerToHIR(ast)
+}
+
+function getBody(source: string): HIRStmt[] {
+  const mod = parse(source)
+  return mod.functions[0].body
+}
+
+describe('HIR lowering — for loop desugaring', () => {
+  test('for(init;cond;step) → let + while with step in separate block', () => {
+    const body = getBody('fn f() { for (let i: int = 0; i < 10; i = i + 1) { let x: int = i; } }')
+    // Should produce: let i = 0; while(i < 10) { body } step { i = i + 1 }
+    expect(body).toHaveLength(2)
+    expect(body[0].kind).toBe('let')
+    const letStmt = body[0] as Extract<HIRStmt, { kind: 'let' }>
+    expect(letStmt.name).toBe('i')
+
+    expect(body[1].kind).toBe('while')
+    const whileStmt = body[1] as Extract<HIRStmt, { kind: 'while' }>
+    expect(whileStmt.cond.kind).toBe('binary')
+
+    // while body: only the original body (step is separate)
+    expect(whileStmt.body).toHaveLength(1)
+    expect(whileStmt.body[0].kind).toBe('let') // let x = i
+
+    // step block: i = i + 1 (separate so continue still increments)
+    expect(whileStmt.step).toBeDefined()
+    expect(whileStmt.step).toHaveLength(1)
+    expect(whileStmt.step![0].kind).toBe('expr') // i = i + 1
+  })
+
+  test('for loop without init', () => {
+    const body = getBody('fn f() { let i: int = 0; for (; i < 5; i = i + 1) {} }')
+    // let i = 0; while(i < 5) { i = i + 1 }
+    expect(body).toHaveLength(2)
+    expect(body[0].kind).toBe('let')
+    expect(body[1].kind).toBe('while')
+  })
+})
+
+describe('HIR lowering — for_range desugaring', () => {
+  test('for i in 0..10 → let + while with step block', () => {
+    const body = getBody('fn f() { for i in 0..10 { let x: int = i; } }')
+    expect(body).toHaveLength(2)
+
+    const letStmt = body[0] as Extract<HIRStmt, { kind: 'let' }>
+    expect(letStmt.kind).toBe('let')
+    expect(letStmt.name).toBe('i')
+    expect(letStmt.init.kind).toBe('int_lit')
+
+    const whileStmt = body[1] as Extract<HIRStmt, { kind: 'while' }>
+    expect(whileStmt.kind).toBe('while')
+    // cond: i < 10
+    expect(whileStmt.cond.kind).toBe('binary')
+    const cond = whileStmt.cond as Extract<HIRExpr, { kind: 'binary' }>
+    expect(cond.op).toBe('<')
+    // body: only user body (step is separate)
+    expect(whileStmt.body).toHaveLength(1)
+    expect(whileStmt.body[0].kind).toBe('let')
+    // step: i = i + 1 (in separate block so continue still increments)
+    expect(whileStmt.step).toBeDefined()
+    expect(whileStmt.step).toHaveLength(1)
+    expect(whileStmt.step![0].kind).toBe('expr')
+  })
+})
+
+describe('HIR lowering — compound assignment desugaring', () => {
+  test('x += 1 → x = x + 1', () => {
+    const body = getBody('fn f() { let x: int = 0; x += 1; }')
+    const exprStmt = body[1] as Extract<HIRStmt, { kind: 'expr' }>
+    expect(exprStmt.kind).toBe('expr')
+    const assign = exprStmt.expr as Extract<HIRExpr, { kind: 'assign' }>
+    expect(assign.kind).toBe('assign')
+    expect(assign.target).toBe('x')
+    // value should be x + 1
+    const binExpr = assign.value as Extract<HIRExpr, { kind: 'binary' }>
+    expect(binExpr.kind).toBe('binary')
+    expect(binExpr.op).toBe('+')
+    expect((binExpr.left as any).name).toBe('x')
+    expect((binExpr.right as any).value).toBe(1)
+  })
+
+  test('x -= 5 → x = x - 5', () => {
+    const body = getBody('fn f() { let x: int = 10; x -= 5; }')
+    const exprStmt = body[1] as Extract<HIRStmt, { kind: 'expr' }>
+    const assign = exprStmt.expr as Extract<HIRExpr, { kind: 'assign' }>
+    expect(assign.kind).toBe('assign')
+    const bin = assign.value as Extract<HIRExpr, { kind: 'binary' }>
+    expect(bin.op).toBe('-')
+  })
+
+  test('x *= 2 → x = x * 2', () => {
+    const body = getBody('fn f() { let x: int = 1; x *= 2; }')
+    const exprStmt = body[1] as Extract<HIRStmt, { kind: 'expr' }>
+    const assign = exprStmt.expr as Extract<HIRExpr, { kind: 'assign' }>
+    const bin = assign.value as Extract<HIRExpr, { kind: 'binary' }>
+    expect(bin.op).toBe('*')
+  })
+
+  test('x /= 3 → x = x / 3', () => {
+    const body = getBody('fn f() { let x: int = 9; x /= 3; }')
+    const exprStmt = body[1] as Extract<HIRStmt, { kind: 'expr' }>
+    const assign = exprStmt.expr as Extract<HIRExpr, { kind: 'assign' }>
+    const bin = assign.value as Extract<HIRExpr, { kind: 'binary' }>
+    expect(bin.op).toBe('/')
+  })
+
+  test('x %= 3 → x = x % 3', () => {
+    const body = getBody('fn f() { let x: int = 10; x %= 3; }')
+    const exprStmt = body[1] as Extract<HIRStmt, { kind: 'expr' }>
+    const assign = exprStmt.expr as Extract<HIRExpr, { kind: 'assign' }>
+    const bin = assign.value as Extract<HIRExpr, { kind: 'binary' }>
+    expect(bin.op).toBe('%')
+  })
+})
+
+describe('HIR lowering — execute block unification', () => {
+  test('as_block → execute [as]', () => {
+    const body = getBody('fn f() { as @e[tag=foo] { } }')
+    expect(body).toHaveLength(1)
+    const exec = body[0] as Extract<HIRStmt, { kind: 'execute' }>
+    expect(exec.kind).toBe('execute')
+    expect(exec.subcommands).toHaveLength(1)
+    expect(exec.subcommands[0].kind).toBe('as')
+  })
+
+  test('foreach with at context preserved', () => {
+    const body = getBody('fn f() { foreach (p in @a) at @s { } }')
+    expect(body).toHaveLength(1)
+    expect(body[0].kind).toBe('foreach')
+    const fe = body[0] as Extract<HIRStmt, { kind: 'foreach' }>
+    expect(fe.executeContext).toBe('at @s')
+  })
+})
+
+describe('HIR lowering — && and || preservation', () => {
+  test('&& preserved as binary op', () => {
+    const body = getBody('fn f() { let x: bool = true && false; }')
+    const letStmt = body[0] as Extract<HIRStmt, { kind: 'let' }>
+    const bin = letStmt.init as Extract<HIRExpr, { kind: 'binary' }>
+    expect(bin.kind).toBe('binary')
+    expect(bin.op).toBe('&&')
+  })
+
+  test('|| preserved as binary op', () => {
+    const body = getBody('fn f() { let x: bool = true || false; }')
+    const letStmt = body[0] as Extract<HIRStmt, { kind: 'let' }>
+    const bin = letStmt.init as Extract<HIRExpr, { kind: 'binary' }>
+    expect(bin.kind).toBe('binary')
+    expect(bin.op).toBe('||')
+  })
+})
+
+describe('HIR lowering — pass-through constructs', () => {
+  test('while loop passes through', () => {
+    const body = getBody('fn f() { while (true) { } }')
+    expect(body).toHaveLength(1)
+    expect(body[0].kind).toBe('while')
+  })
+
+  test('if/else passes through', () => {
+    const body = getBody('fn f() { if (true) { } else { } }')
+    expect(body).toHaveLength(1)
+    expect(body[0].kind).toBe('if')
+    const ifStmt = body[0] as Extract<HIRStmt, { kind: 'if' }>
+    expect(ifStmt.then).toBeDefined()
+    expect(ifStmt.else_).toBeDefined()
+  })
+
+  test('return passes through', () => {
+    const body = getBody('fn f(): int { return 42; }')
+    expect(body).toHaveLength(1)
+    expect(body[0].kind).toBe('return')
+    const ret = body[0] as Extract<HIRStmt, { kind: 'return' }>
+    expect(ret.value).toBeDefined()
+    expect((ret.value as any).value).toBe(42)
+  })
+
+  test('function call passes through', () => {
+    const body = getBody('fn f() { foo(1, 2); }')
+    expect(body).toHaveLength(1)
+    const exprStmt = body[0] as Extract<HIRStmt, { kind: 'expr' }>
+    const call = exprStmt.expr as Extract<HIRExpr, { kind: 'call' }>
+    expect(call.kind).toBe('call')
+    expect(call.fn).toBe('foo')
+    expect(call.args).toHaveLength(2)
+  })
+
+  test('break and continue pass through', () => {
+    const body = getBody('fn f() { while (true) { break; continue; } }')
+    const whileStmt = body[0] as Extract<HIRStmt, { kind: 'while' }>
+    expect(whileStmt.body[0].kind).toBe('break')
+    expect(whileStmt.body[1].kind).toBe('continue')
+  })
+
+  test('raw command passes through', () => {
+    const body = getBody('fn f() { raw("say hello"); }')
+    expect(body).toHaveLength(1)
+    expect(body[0].kind).toBe('raw')
+  })
+})
+
+describe('HIR lowering — module structure', () => {
+  test('struct declarations preserved', () => {
+    const mod = parse('struct Vec2 { x: int, y: int }')
+    expect(mod.structs).toHaveLength(1)
+    expect(mod.structs[0].name).toBe('Vec2')
+    expect(mod.structs[0].fields).toHaveLength(2)
+  })
+
+  test('const declarations preserved', () => {
+    const mod = parse('const MAX: int = 100;')
+    expect(mod.consts).toHaveLength(1)
+    expect(mod.consts[0].name).toBe('MAX')
+  })
+
+  test('namespace preserved', () => {
+    const mod = parse('fn f() {}')
+    expect(mod.namespace).toBe('test')
+  })
+
+  test('decorators preserved on functions', () => {
+    const mod = parse('@tick fn tick_fn() {}')
+    expect(mod.functions).toHaveLength(1)
+    expect(mod.functions[0].decorators).toHaveLength(1)
+    expect(mod.functions[0].decorators[0].name).toBe('tick')
+  })
+})
+
+describe('HIR lowering — member compound assignment', () => {
+  test('obj.field += 1 → obj.field = obj.field + 1', () => {
+    const mod = parse('struct S { x: int } fn f() { let s: S = { x: 0 }; s.x += 1; }')
+    const body = mod.functions[0].body
+    const exprStmt = body[1] as Extract<HIRStmt, { kind: 'expr' }>
+    const assign = exprStmt.expr as Extract<HIRExpr, { kind: 'member_assign' }>
+    expect(assign.kind).toBe('member_assign')
+    expect(assign.field).toBe('x')
+    const bin = assign.value as Extract<HIRExpr, { kind: 'binary' }>
+    expect(bin.kind).toBe('binary')
+    expect(bin.op).toBe('+')
+    expect((bin.left as any).kind).toBe('member')
+    expect((bin.left as any).field).toBe('x')
+  })
+})
+
+describe('HIR lowering — plain assignment passes through', () => {
+  test('x = 5 stays as x = 5', () => {
+    const body = getBody('fn f() { let x: int = 0; x = 5; }')
+    const exprStmt = body[1] as Extract<HIRStmt, { kind: 'expr' }>
+    const assign = exprStmt.expr as Extract<HIRExpr, { kind: 'assign' }>
+    expect(assign.kind).toBe('assign')
+    expect(assign.target).toBe('x')
+    expect((assign.value as any).value).toBe(5)
+  })
+})