redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/compile-preprocess.test.ts

@@ -0,0 +1,366 @@
+/**
+ * Branch coverage tests for src/compile.ts
+ *
+ * Targets uncovered branches in:
+ * - preprocessSourceWithMetadata: import without filePath, unresolvable import,
+ *   isLibrarySource detection, library vs non-library imports, resolveSourceLine,
+ *   offsetRanges, countLines
+ * - resolveImportPath: .mcrs extension, relative path, stdlib path, includeDirs
+ * - preprocessSource (wrapper)
+ */
+
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import {
+  preprocessSourceWithMetadata,
+  preprocessSource,
+  resolveSourceLine,
+} from '../compile'
+
+// ---------------------------------------------------------------------------
+// resolveSourceLine
+// ---------------------------------------------------------------------------
+
+describe('resolveSourceLine', () => {
+  const ranges = [
+    { startLine: 1, endLine: 10, filePath: 'a.mcrs' },
+    { startLine: 11, endLine: 20, filePath: 'b.mcrs' },
+  ]
+
+  test('maps line in first range to first file', () => {
+    const result = resolveSourceLine(5, ranges)
+    expect(result.filePath).toBe('a.mcrs')
+    expect(result.line).toBe(5)
+  })
+
+  test('maps line in second range to second file', () => {
+    const result = resolveSourceLine(15, ranges)
+    expect(result.filePath).toBe('b.mcrs')
+    expect(result.line).toBe(5)
+  })
+
+  test('line outside ranges uses fallback file', () => {
+    const result = resolveSourceLine(99, ranges, 'fallback.mcrs')
+    expect(result.filePath).toBe('fallback.mcrs')
+    expect(result.line).toBe(99)
+  })
+
+  test('line outside ranges with no fallback', () => {
+    const result = resolveSourceLine(99, ranges)
+    expect(result.filePath).toBeUndefined()
+    expect(result.line).toBe(99)
+  })
+
+  test('empty ranges uses fallback', () => {
+    const result = resolveSourceLine(5, [], 'default.mcrs')
+    expect(result.filePath).toBe('default.mcrs')
+    expect(result.line).toBe(5)
+  })
+
+  test('boundary line (startLine) maps correctly', () => {
+    const result = resolveSourceLine(1, ranges)
+    expect(result.filePath).toBe('a.mcrs')
+    expect(result.line).toBe(1)
+  })
+
+  test('boundary line (endLine) maps correctly', () => {
+    const result = resolveSourceLine(10, ranges)
+    expect(result.filePath).toBe('a.mcrs')
+    expect(result.line).toBe(10)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — basic (no imports)
+// ---------------------------------------------------------------------------
+
+describe('preprocessSourceWithMetadata — no imports', () => {
+  test('simple source returns unchanged source', () => {
+    const result = preprocessSourceWithMetadata('fn f() { }')
+    expect(result.source).toContain('fn f()')
+  })
+
+  test('empty source returns empty', () => {
+    const result = preprocessSourceWithMetadata('')
+    expect(result.source).toBe('')
+    expect(result.ranges).toEqual([])
+  })
+
+  test('returns no libraryImports when none present', () => {
+    const result = preprocessSourceWithMetadata('fn f() { }')
+    expect(result.libraryImports).toBeUndefined()
+  })
+
+  test('includes filePath in ranges when provided', () => {
+    const result = preprocessSourceWithMetadata('fn f() { }', { filePath: 'test.mcrs' })
+    expect(result.ranges.length).toBeGreaterThan(0)
+    expect(result.ranges[0].filePath).toContain('test.mcrs')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — import without filePath throws
+// ---------------------------------------------------------------------------
+
+describe('preprocessSourceWithMetadata — import without filePath', () => {
+  test('throws ParseError when import used without filePath', () => {
+    const source = `import "stdlib/math";
+fn f(): int { return 1; }
+`
+    expect(() => preprocessSourceWithMetadata(source)).toThrow(/ParseError|Import statements require/)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — unresolvable import
+// ---------------------------------------------------------------------------
+
+describe('preprocessSourceWithMetadata — unresolvable import', () => {
+  test('throws ParseError when import path cannot be resolved', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-test-'))
+    const mainFile = path.join(tmpDir, 'main.mcrs')
+    fs.writeFileSync(mainFile, `import "nonexistent_module_xyz";\nfn f(): int { return 1; }\n`)
+
+    try {
+      expect(() =>
+        preprocessSourceWithMetadata(fs.readFileSync(mainFile, 'utf-8'), { filePath: mainFile })
+      ).toThrow(/Cannot import|nonexistent_module_xyz/)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true })
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — library source detection
+// ---------------------------------------------------------------------------
+
+describe('preprocessSourceWithMetadata — library source', () => {
+  test('isLibrarySource: module library at top is recognized as library', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-lib-'))
+    const libFile = path.join(tmpDir, 'mylib.mcrs')
+    const mainFile = path.join(tmpDir, 'main.mcrs')
+
+    fs.writeFileSync(libFile, `module library;\nfn lib_fn(): int { return 42; }\n`)
+    fs.writeFileSync(mainFile, `import "mylib";\nfn main(): int { return lib_fn(); }\n`)
+
+    try {
+      const result = preprocessSourceWithMetadata(
+        fs.readFileSync(mainFile, 'utf-8'),
+        { filePath: mainFile }
+      )
+      // Library imports should be collected separately
+      expect(result.libraryImports).toBeDefined()
+      expect(result.libraryImports!.length).toBeGreaterThan(0)
+      expect(result.libraryImports![0].source).toContain('module library')
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true })
+    }
+  })
+
+  test('isLibrarySource: source with only comments before module library', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-lib2-'))
+    const libFile = path.join(tmpDir, 'commented_lib.mcrs')
+    const mainFile = path.join(tmpDir, 'main.mcrs')
+
+    // Comments before module declaration
+    fs.writeFileSync(libFile, `// This is a library\n// Usage: import this\n\nmodule library;\nfn helper(): int { return 1; }\n`)
+    fs.writeFileSync(mainFile, `import "commented_lib";\nfn main(): int { return helper(); }\n`)
+
+    try {
+      const result = preprocessSourceWithMetadata(
+        fs.readFileSync(mainFile, 'utf-8'),
+        { filePath: mainFile }
+      )
+      expect(result.libraryImports).toBeDefined()
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true })
+    }
+  })
+
+  test('non-library import is concatenated into source', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-nolib-'))
+    const modFile = path.join(tmpDir, 'helpers.mcrs')
+    const mainFile = path.join(tmpDir, 'main.mcrs')
+
+    // No "module library" declaration
+    fs.writeFileSync(modFile, `fn helper(): int { return 99; }\n`)
+    fs.writeFileSync(mainFile, `import "helpers";\nfn main(): int { return helper(); }\n`)
+
+    try {
+      const result = preprocessSourceWithMetadata(
+        fs.readFileSync(mainFile, 'utf-8'),
+        { filePath: mainFile }
+      )
+      // Should be concatenated (no libraryImports)
+      expect(result.libraryImports).toBeUndefined()
+      expect(result.source).toContain('fn helper()')
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true })
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — stdlib import
+// ---------------------------------------------------------------------------
+
+describe('preprocessSourceWithMetadata — stdlib imports', () => {
+  test('stdlib/math import resolves correctly', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-stdlib-'))
+    const mainFile = path.join(tmpDir, 'main.mcrs')
+    fs.writeFileSync(mainFile, `import "stdlib/math";\nfn f(): int { return abs(-5); }\n`)
+
+    try {
+      const result = preprocessSourceWithMetadata(
+        fs.readFileSync(mainFile, 'utf-8'),
+        { filePath: mainFile }
+      )
+      // math.mcrs is a library, so it goes to libraryImports
+      expect(result.libraryImports).toBeDefined()
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true })
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — includeDirs
+// ---------------------------------------------------------------------------
+
+describe('preprocessSourceWithMetadata — includeDirs', () => {
+  test('includeDirs resolves imports from extra directories', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-extra-'))
+    const extraDir = path.join(tmpDir, 'extra')
+    fs.mkdirSync(extraDir)
+    const mainFile = path.join(tmpDir, 'main.mcrs')
+    const libFile = path.join(extraDir, 'custom_lib.mcrs')
+
+    fs.writeFileSync(libFile, `fn custom(): int { return 77; }\n`)
+    fs.writeFileSync(mainFile, `import "custom_lib";\nfn f(): int { return custom(); }\n`)
+
+    try {
+      const result = preprocessSourceWithMetadata(
+        fs.readFileSync(mainFile, 'utf-8'),
+        { filePath: mainFile, includeDirs: [extraDir] }
+      )
+      expect(result.source).toContain('fn custom()')
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true })
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — duplicate import deduplication
+// ---------------------------------------------------------------------------
+
+describe('preprocessSourceWithMetadata — deduplication', () => {
+  test('same file imported twice is only included once', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-dup-'))
+    const libFile = path.join(tmpDir, 'dup.mcrs')
+    const mod1File = path.join(tmpDir, 'mod1.mcrs')
+    const mainFile = path.join(tmpDir, 'main.mcrs')
+
+    fs.writeFileSync(libFile, `fn shared(): int { return 1; }\n`)
+    fs.writeFileSync(mod1File, `import "dup";\nfn from_mod1(): int { return shared(); }\n`)
+    fs.writeFileSync(mainFile, `import "dup";\nimport "mod1";\nfn main(): int { return from_mod1(); }\n`)
+
+    try {
+      const result = preprocessSourceWithMetadata(
+        fs.readFileSync(mainFile, 'utf-8'),
+        { filePath: mainFile }
+      )
+      // dup.mcrs should only appear once in source
+      const dupCount = (result.source.match(/fn shared\(\)/g) ?? []).length
+      expect(dupCount).toBe(1)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true })
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — .mcrs extension handling
+// ---------------------------------------------------------------------------
+
+describe('preprocessSourceWithMetadata — extension handling', () => {
+  test('import with explicit .mcrs extension resolves', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-ext-'))
+    const libFile = path.join(tmpDir, 'withext.mcrs')
+    const mainFile = path.join(tmpDir, 'main.mcrs')
+
+    fs.writeFileSync(libFile, `fn ext_fn(): int { return 5; }\n`)
+    fs.writeFileSync(mainFile, `import "withext.mcrs";\nfn f(): int { return ext_fn(); }\n`)
+
+    try {
+      const result = preprocessSourceWithMetadata(
+        fs.readFileSync(mainFile, 'utf-8'),
+        { filePath: mainFile }
+      )
+      expect(result.source).toContain('fn ext_fn()')
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true })
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// preprocessSourceWithMetadata — ranges include library transitive imports
+// ---------------------------------------------------------------------------
+
+describe('preprocessSourceWithMetadata — transitive library imports', () => {
+  test('transitive library imports are collected', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-trans-'))
+    const innerLib = path.join(tmpDir, 'inner.mcrs')
+    const outerLib = path.join(tmpDir, 'outer.mcrs')
+    const mainFile = path.join(tmpDir, 'main.mcrs')
+
+    fs.writeFileSync(innerLib, `module library;\nfn inner(): int { return 1; }\n`)
+    fs.writeFileSync(outerLib, `module library;\nimport "inner";\nfn outer(): int { return inner(); }\n`)
+    fs.writeFileSync(mainFile, `import "outer";\nfn main(): int { return outer(); }\n`)
+
+    try {
+      const result = preprocessSourceWithMetadata(
+        fs.readFileSync(mainFile, 'utf-8'),
+        { filePath: mainFile }
+      )
+      // Both library files should be collected
+      expect(result.libraryImports).toBeDefined()
+      expect(result.libraryImports!.length).toBeGreaterThanOrEqual(1)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true })
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// preprocessSource (wrapper)
+// ---------------------------------------------------------------------------
+
+describe('preprocessSource', () => {
+  test('returns source string same as preprocessSourceWithMetadata.source', () => {
+    const source = 'fn f(): int { return 0; }'
+    const result = preprocessSource(source)
+    const meta = preprocessSourceWithMetadata(source)
+    expect(result).toBe(meta.source)
+  })
+
+  test('accepts options', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rscript-wrap-'))
+    const libFile = path.join(tmpDir, 'wraplib.mcrs')
+    const mainFile = path.join(tmpDir, 'main.mcrs')
+
+    fs.writeFileSync(libFile, `fn wrap(): int { return 7; }\n`)
+    fs.writeFileSync(mainFile, `import "wraplib";\nfn f(): int { return wrap(); }\n`)
+
+    try {
+      const source = fs.readFileSync(mainFile, 'utf-8')
+      const result = preprocessSource(source, { filePath: mainFile })
+      expect(result).toContain('fn wrap()')
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true })
+    }
+  })
+})

package/src/__tests__/compiler/break-stmt.test.ts

@@ -0,0 +1,66 @@
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { lowerToHIR } from '../../hir/lower'
+import { lowerToMIR } from '../../mir/lower'
+import { verifyMIR } from '../../mir/verify'
+import type { MIRFunction, MIRInstr } from '../../mir/types'
+import { compile } from '../../emit/compile'
+
+const SOURCE = `
+  fn test_break() {
+    let i: int = 0
+    while i < 10 {
+      if i == 5 { break }
+      i = i + 1
+    }
+    // i should be 5
+  }
+`
+
+function parse(source: string) {
+  const tokens = new Lexer(source).tokenize()
+  return new Parser(tokens, source).parse('test')
+}
+
+function lowerFn(source: string): MIRFunction {
+  const ast = parse(source)
+  const hir = lowerToHIR(ast)
+  const mir = lowerToMIR(hir)
+  expect(verifyMIR(mir)).toEqual([])
+  return mir.functions.find(fn => fn.name === 'test_break')!
+}
+
+describe('break statement', () => {
+  test('parser recognizes break inside while', () => {
+    const ast = parse(SOURCE)
+    const whileStmt = ast.declarations[0].body[1]
+    expect(whileStmt.kind).toBe('while')
+    if (whileStmt.kind !== 'while') throw new Error('expected while statement')
+
+    const ifStmt = whileStmt.body[0]
+    expect(ifStmt.kind).toBe('if')
+    if (ifStmt.kind !== 'if') throw new Error('expected if statement')
+
+    expect(ifStmt.then[0]).toMatchObject({ kind: 'break' })
+  })
+
+  test('MIR lowering turns break into jump to loop exit block', () => {
+    const fn = lowerFn(SOURCE)
+    const exitBlock = fn.blocks.find(block => block.id.startsWith('loop_exit'))
+    expect(exitBlock).toBeDefined()
+
+    const breakJump = fn.blocks.find(block =>
+      block.term.kind === 'jump' &&
+      (block.term as Extract<MIRInstr, { kind: 'jump' }>).target === exitBlock!.id &&
+      !block.id.startsWith('loop_header') &&
+      !block.id.startsWith('loop_exit') &&
+      !block.id.startsWith('entry')
+    )
+
+    expect(breakJump).toBeDefined()
+  })
+
+  test('end-to-end compile accepts while break program', () => {
+    expect(() => compile(SOURCE, { namespace: 'test' })).not.toThrow()
+  })
+})

package/src/__tests__/compiler/const-decl.test.ts

@@ -0,0 +1,141 @@
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { lowerToHIR } from '../../hir/lower'
+import { lowerToMIR } from '../../mir/lower'
+import { verifyMIR } from '../../mir/verify'
+import { compile } from '../../emit/compile'
+
+function parse(source: string) {
+  const tokens = new Lexer(source).tokenize()
+  return new Parser(tokens, source).parse('test')
+}
+
+// ---------------------------------------------------------------------------
+// Top-level const declarations
+// ---------------------------------------------------------------------------
+
+const TOP_LEVEL_CONST_SOURCE = `
+  const MAX_HEALTH: int = 20
+  const PI_APPROX: int = 31416
+
+  fn test() {
+    let h = MAX_HEALTH
+    let pi = PI_APPROX
+  }
+`
+
+describe('top-level const declarations', () => {
+  test('parser collects consts into program.consts', () => {
+    const ast = parse(TOP_LEVEL_CONST_SOURCE)
+    expect(ast.consts).toHaveLength(2)
+    expect(ast.consts[0].name).toBe('MAX_HEALTH')
+    expect(ast.consts[0].value).toMatchObject({ kind: 'int_lit', value: 20 })
+    expect(ast.consts[1].name).toBe('PI_APPROX')
+    expect(ast.consts[1].value).toMatchObject({ kind: 'int_lit', value: 31416 })
+  })
+
+  test('HIR preserves consts array', () => {
+    const ast = parse(TOP_LEVEL_CONST_SOURCE)
+    const hir = lowerToHIR(ast)
+    expect(hir.consts).toHaveLength(2)
+    expect(hir.consts[0].name).toBe('MAX_HEALTH')
+  })
+
+  test('MIR inlines constants at use sites — copy src is a const operand', () => {
+    const ast = parse(TOP_LEVEL_CONST_SOURCE)
+    const hir = lowerToHIR(ast)
+    const mir = lowerToMIR(hir)
+    expect(verifyMIR(mir)).toEqual([])
+
+    const fn = mir.functions.find(f => f.name === 'test')!
+    expect(fn).toBeDefined()
+
+    const allInstrs = fn.blocks.flatMap(b => b.instrs)
+    // When MAX_HEALTH / PI_APPROX are referenced, a copy instr is emitted with a const operand src
+    const copyConstSrcs = allInstrs
+      .filter(i => i.kind === 'copy' && (i as any).src.kind === 'const')
+      .map(i => (i as any).src.value as number)
+    expect(copyConstSrcs).toContain(20)
+    expect(copyConstSrcs).toContain(31416)
+  })
+
+  test('end-to-end compile accepts const declarations', () => {
+    expect(() => compile(TOP_LEVEL_CONST_SOURCE, { namespace: 'test' })).not.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Local (function-body) const declarations
+// ---------------------------------------------------------------------------
+
+const LOCAL_CONST_SOURCE = `
+  fn compute() {
+    const FACTOR: int = 100
+    let result = FACTOR
+  }
+`
+
+describe('local const declarations (inside function)', () => {
+  test('parser produces const_decl stmt in function body', () => {
+    const ast = parse(LOCAL_CONST_SOURCE)
+    const fn = ast.declarations[0]
+    expect(fn.body[0]).toMatchObject({ kind: 'const_decl', name: 'FACTOR' })
+  })
+
+  test('HIR preserves const_decl stmt', () => {
+    const ast = parse(LOCAL_CONST_SOURCE)
+    const hir = lowerToHIR(ast)
+    const fn = hir.functions[0]
+    expect(fn.body[0]).toMatchObject({ kind: 'const_decl', name: 'FACTOR' })
+  })
+
+  test('MIR inlines local constant at use sites', () => {
+    const ast = parse(LOCAL_CONST_SOURCE)
+    const hir = lowerToHIR(ast)
+    const mir = lowerToMIR(hir)
+    expect(verifyMIR(mir)).toEqual([])
+
+    const fn = mir.functions.find(f => f.name === 'compute')!
+    expect(fn).toBeDefined()
+
+    const allInstrs = fn.blocks.flatMap(b => b.instrs)
+    // FACTOR=100 is inlined at the use site as a const operand in a copy instruction
+    const copyConstSrcs = allInstrs
+      .filter(i => i.kind === 'copy' && (i as any).src.kind === 'const')
+      .map(i => (i as any).src.value as number)
+    expect(copyConstSrcs).toContain(100)
+  })
+
+  test('end-to-end compile accepts local const', () => {
+    expect(() => compile(LOCAL_CONST_SOURCE, { namespace: 'test' })).not.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Bool const
+// ---------------------------------------------------------------------------
+
+const BOOL_CONST_SOURCE = `
+  const FLAG: bool = true
+
+  fn check() {
+    let f = FLAG
+  }
+`
+
+describe('bool const declarations', () => {
+  test('bool const is inlined as 1', () => {
+    const ast = parse(BOOL_CONST_SOURCE)
+    const hir = lowerToHIR(ast)
+    const mir = lowerToMIR(hir)
+    expect(verifyMIR(mir)).toEqual([])
+
+    const fn = mir.functions.find(f => f.name === 'check')!
+    expect(fn).toBeDefined()
+    const allInstrs = fn.blocks.flatMap(b => b.instrs)
+    const copyConstSrcs = allInstrs
+      .filter(i => i.kind === 'copy' && (i as any).src.kind === 'const')
+      .map(i => (i as any).src.value as number)
+    expect(copyConstSrcs).toContain(1)
+  })
+})

package/src/__tests__/compiler/continue-stmt.test.ts

@@ -0,0 +1,81 @@
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import type { Program } from '../../ast/types'
+import { lowerToHIR } from '../../hir/lower'
+import { lowerToMIR } from '../../mir/lower'
+import { verifyMIR } from '../../mir/verify'
+import type { MIRFunction, MIRInstr, MIRModule } from '../../mir/types'
+import { compile } from '../../emit/compile'
+
+const SOURCE = `
+  fn test_continue() {
+    let sum: int = 0
+    let i: int = 0
+    while (i < 10) {
+      i = i + 1
+      if (i % 2 == 0) { continue }
+      sum = sum + i
+    }
+  }
+`
+
+function parse(source: string, namespace = 'test'): Program {
+  const tokens = new Lexer(source).tokenize()
+  return new Parser(tokens).parse(namespace)
+}
+
+function compileMIR(source: string): MIRModule {
+  const ast = parse(source)
+  const hir = lowerToHIR(ast)
+  return lowerToMIR(hir)
+}
+
+function getFn(mod: MIRModule, name?: string): MIRFunction {
+  if (name) return mod.functions.find(f => f.name === name)!
+  return mod.functions[0]
+}
+
+describe('continue statement', () => {
+  test('parser builds continue AST node inside while body', () => {
+    const program = parse(SOURCE)
+    const whileStmt = program.declarations[0].body[2]
+
+    expect(whileStmt.kind).toBe('while')
+    if (whileStmt.kind !== 'while') {
+      throw new Error('expected while statement')
+    }
+
+    const ifStmt = whileStmt.body[1]
+    expect(ifStmt.kind).toBe('if')
+    if (ifStmt.kind !== 'if') {
+      throw new Error('expected if statement')
+    }
+
+    expect(ifStmt.then[0]).toMatchObject({ kind: 'continue' })
+  })
+
+  test('MIR lowers continue to a jump back to loop header', () => {
+    const mod = compileMIR(SOURCE)
+    expect(verifyMIR(mod)).toEqual([])
+
+    const fn = getFn(mod, 'test_continue')
+    const headerBlock = fn.blocks.find(b => b.id.startsWith('loop_header'))
+    expect(headerBlock).toBeDefined()
+
+    const continueBlock = fn.blocks.find(b =>
+      b.term.kind === 'jump' &&
+      (b.term as Extract<MIRInstr, { kind: 'jump' }>).target === headerBlock!.id &&
+      !b.id.startsWith('loop_header') &&
+      !b.id.startsWith('entry')
+    )
+
+    expect(continueBlock).toBeDefined()
+  })
+
+  test('full compiler pipeline accepts while + continue program', () => {
+    const result = compile(SOURCE, { namespace: 'test' })
+
+    expect(result.files.length).toBeGreaterThan(0)
+    expect(result.files.some(f => f.path.endsWith('function/test_continue.mcfunction'))).toBe(true)
+  })
+})