redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/emit/compile-extra-branches.test.ts

@@ -0,0 +1,228 @@
+/**
+ * Extra targeted tests to push compile.ts branch coverage above 85%.
+ *
+ * Targets remaining uncovered branches:
+ * - B9: default-arg (options = {} when called with no second arg)
+ * - B10: default-arg (namespace = 'redscript' when not provided)
+ * - B24/B25: mergeWholeModuleImport parse error (file import with bad syntax)
+ * - B32/B33: libraryImports parse error (library import with bad syntax)
+ * - B63: budget diagnostic level === 'error'
+ * - B69: stopAfterCheck + caught CheckFailedError → re-throw as-is
+ */
+
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import { compile } from '../../emit/compile'
+import { CheckFailedError } from '../../diagnostics'
+
+// ---------------------------------------------------------------------------
+// B9 + B10: call compile() with no second arg / without namespace
+// ---------------------------------------------------------------------------
+
+describe('compile.ts default arg branches', () => {
+  test('B9: compile called with no options arg uses default {} → succeeds', () => {
+    // Branch 9: the default `options = {}` is used (i.e. no second arg)
+    const result = compile('fn f(): int { return 1; }')
+    expect(result.success).toBe(true)
+    expect(result.files.length).toBeGreaterThan(0)
+    // default namespace is 'redscript'
+    expect(result.files.some(f => f.path.includes('redscript'))).toBe(true)
+  })
+
+  test('B10: compile called without namespace uses default "redscript"', () => {
+    // Branch 10: namespace defaults to 'redscript' when not provided
+    // We provide options but omit namespace
+    const result = compile('fn f(): int { return 2; }', { stopAfterCheck: false })
+    expect(result.success).toBe(true)
+    expect(result.files.some(f => f.path.includes('redscript'))).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// B24/B25: mergeWholeModuleImport parse error
+//   When a whole-module import file has invalid syntax, the parse error is thrown
+//   Branch 24: if (modParser.parseErrors.length > 0) → true
+//   Branch 25: throw stopAfterCheck ? DiagnosticBundleError : parseErrors[0]
+//     - B25 arm 0 (stopAfterCheck=true): throws DiagnosticBundleError → wrapped in CheckFailedError
+//     - B25 arm 1 (stopAfterCheck=false): throws parseErrors[0]
+// ---------------------------------------------------------------------------
+
+describe('compile.ts mergeWholeModuleImport parse error (B24/B25)', () => {
+  let tempDir: string
+  let mainPath: string
+  let badModPath: string
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-b24-'))
+    mainPath = path.join(tempDir, 'main.mcrs')
+    badModPath = path.join(tempDir, 'bad_mod.mcrs')
+
+    // Write a bad module (invalid syntax)
+    fs.writeFileSync(badModPath, 'fn broken_syntax( { return 1; }\n')
+
+    // Write main that imports the bad module with whole-module import
+    // `import bad_mod;` (no ::) → symbol=undefined → mergeWholeModuleImport
+    fs.writeFileSync(mainPath, 'import bad_mod;\nfn main(): int { return 0; }\n')
+  })
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  test('B24+B25 arm1: whole-module import parse error (no stopAfterCheck) → throws raw parse error', () => {
+    // Branch 24: true path (parse errors > 0)
+    // Branch 25: arm 1 (stopAfterCheck=false) → throws parseErrors[0]
+    expect(() =>
+      compile(fs.readFileSync(mainPath, 'utf-8'), {
+        namespace: 'b24_nosac',
+        filePath: mainPath,
+      })
+    ).toThrow()
+  })
+
+  test('B24+B25 arm0: whole-module import parse error (stopAfterCheck=true) → throws CheckFailedError', () => {
+    // Branch 24: true path (parse errors > 0)
+    // Branch 25: arm 0 (stopAfterCheck=true) → throws DiagnosticBundleError → wrapped in CheckFailedError
+    expect(() =>
+      compile(fs.readFileSync(mainPath, 'utf-8'), {
+        namespace: 'b24_sac',
+        filePath: mainPath,
+        stopAfterCheck: true,
+      })
+    ).toThrow(CheckFailedError)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// B32/B33: libraryImports parse error
+//   When a file referenced via file-system `import "file.mcrs";` has:
+//     `module library;` declaration → goes to libraryImports array
+//   Then if that library file has parse errors → Branch 32/33 fires
+//   Branch 32: if (libParser.parseErrors.length > 0)
+//   Branch 33: throw stopAfterCheck ? DiagnosticBundleError : parseErrors[0]
+// ---------------------------------------------------------------------------
+
+describe('compile.ts libraryImports parse error (B32/B33)', () => {
+  let tempDir: string
+  let mainPath: string
+  let badLibPath: string
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-b32-'))
+    mainPath = path.join(tempDir, 'main.mcrs')
+    badLibPath = path.join(tempDir, 'mylib.mcrs')
+
+    // Write a library file with module library; but broken syntax
+    fs.writeFileSync(badLibPath, 'module library;\nfn broken( { return 1; }\n')
+
+    // Write main that imports the library file (file-path import triggers libraryImports path)
+    // The preprocessor finds `module library;` in the imported file → puts it in libraryImports
+    fs.writeFileSync(mainPath, 'import "mylib";\nfn main(): int { return 0; }\n')
+  })
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  test('B32+B33 arm1: library import parse error (no stopAfterCheck) → throws raw parse error', () => {
+    expect(() =>
+      compile(fs.readFileSync(mainPath, 'utf-8'), {
+        namespace: 'b32_nosac',
+        filePath: mainPath,
+      })
+    ).toThrow()
+  })
+
+  test('B32+B33 arm0: library import parse error (stopAfterCheck=true) → throws CheckFailedError', () => {
+    expect(() =>
+      compile(fs.readFileSync(mainPath, 'utf-8'), {
+        namespace: 'b32_sac',
+        filePath: mainPath,
+        stopAfterCheck: true,
+      })
+    ).toThrow(CheckFailedError)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// B63: budget diagnostic with level 'error' → throws DiagnosticError
+// ---------------------------------------------------------------------------
+
+describe('compile.ts budget error level (B63) via mock', () => {
+  beforeEach(() => {
+    jest.resetModules()
+  })
+
+  afterEach(() => {
+    jest.resetModules()
+  })
+
+  test('B63: analyzeBudget returning error level throws DiagnosticError', () => {
+    jest.isolateModules(() => {
+      jest.doMock('../../lir/budget', () => ({
+        analyzeBudget: jest.fn(() => [
+          { level: 'error', message: 'tick budget exceeded' },
+        ]),
+      }))
+
+      const { compile: compileFresh } = require('../../emit/compile')
+      let thrown: unknown
+      try {
+        compileFresh('fn f(): int { return 0; }', { namespace: 'b63_budget' })
+      } catch (e) {
+        thrown = e
+      }
+      expect(thrown).toBeDefined()
+      expect((thrown as Error).name).toBe('DiagnosticError')
+    })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// B69: stopAfterCheck + CheckFailedError in catch → re-throw as-is
+//   This fires when err instanceof CheckFailedError in the catch block AND stopAfterCheck=true
+//   A CheckFailedError can only arrive here if something inside the try block throws it.
+//   lowerToHIR, lowerToMIR, etc. can throw one if mocked to do so.
+// ---------------------------------------------------------------------------
+
+describe('compile.ts catch block: B69 stopAfterCheck + CheckFailedError re-throw', () => {
+  beforeEach(() => {
+    jest.resetModules()
+  })
+
+  afterEach(() => {
+    jest.resetModules()
+  })
+
+  test('B69: stopAfterCheck + CheckFailedError thrown inside → re-throw unchanged', () => {
+    jest.isolateModules(() => {
+      jest.doMock('../../hir/lower', () => ({
+        lowerToHIR: jest.fn(() => {
+          const { CheckFailedError: CFE, DiagnosticError: DE } = require('../../diagnostics')
+          throw new CFE(
+            [new DE('LoweringError', 'injected check-failed error', { line: 1, col: 1 })],
+            ['prior warning'],
+          )
+        }),
+      }))
+
+      const { compile: compileFresh } = require('../../emit/compile')
+      let thrown: unknown
+      try {
+        compileFresh('fn f(): int { return 0; }', {
+          namespace: 'b69_cfe',
+          stopAfterCheck: true,
+        })
+      } catch (e) {
+        thrown = e
+      }
+      expect(thrown).toBeDefined()
+      expect((thrown as Error).name).toBe('CheckFailedError')
+      // The original CheckFailedError is re-thrown unchanged (B69 path)
+      // vs. a new CheckFailedError being created (B70/B71 paths)
+      // We can verify it has the original warnings
+      expect((thrown as CheckFailedError).warnings).toEqual(['prior warning'])
+    })
+  })
+})

package/src/__tests__/emit/compile-mocked-branches.test.ts

@@ -0,0 +1,249 @@
+describe('emit/compile mocked branch coverage', () => {
+  afterEach(() => {
+    jest.resetModules()
+    jest.clearAllMocks()
+    jest.unmock('../../compile')
+    jest.unmock('../../lexer')
+    jest.unmock('../../parser')
+    jest.unmock('../../typechecker')
+    jest.unmock('../../hir/lower')
+    jest.unmock('../../hir/monomorphize')
+    jest.unmock('../../hir/deprecated')
+    jest.unmock('../../mir/lower')
+    jest.unmock('../../optimizer/pipeline')
+    jest.unmock('../../optimizer/coroutine')
+    jest.unmock('../../lir/lower')
+    jest.unmock('../../optimizer/lir/pipeline')
+    jest.unmock('../../lir/budget')
+    jest.unmock('../../events/types')
+    jest.unmock('../../emit/index')
+    jest.unmock('fs')
+  })
+
+  test('whole-module import paths resolve, recurse, skip symbol imports, and warn on missing nested modules', () => {
+    jest.isolateModules(() => {
+      const parseQueue = [
+        {
+          imports: [
+            { moduleName: 'mod', symbol: undefined, span: { line: 1, col: 1 } },
+            { moduleName: 'sym', symbol: 'named', span: { line: 2, col: 1 } },
+          ],
+          declarations: [],
+          structs: [],
+          implBlocks: [],
+          enums: [],
+          consts: [],
+          globals: [],
+        },
+        {
+          imports: [
+            { moduleName: 'nested', symbol: undefined },
+            { moduleName: 'skip_nested', symbol: 'named' },
+            { moduleName: 'missing_nested', symbol: undefined },
+          ],
+          declarations: [{ name: 'helper', decorators: [] }],
+          structs: [],
+          implBlocks: [],
+          enums: [],
+          consts: [],
+          globals: [],
+        },
+        {
+          imports: [],
+          declarations: [{ name: 'nested_helper', decorators: [] }],
+          structs: [],
+          implBlocks: [],
+          enums: [],
+          consts: [],
+          globals: [],
+        },
+      ]
+
+      jest.doMock('../../compile', () => ({
+        preprocessSourceWithMetadata: jest.fn((source: string) => ({ source })),
+      }))
+      jest.doMock('fs', () => ({
+        existsSync: jest.fn((file: string) => (
+          file === '/root/mod.mcrs' ||
+          file === '/root/nested.mcrs'
+        )),
+        readFileSync: jest.fn((file: string) => {
+          if (file === '/root/mod.mcrs') return 'mod-source'
+          if (file === '/root/nested.mcrs') return 'nested-source'
+          return ''
+        }),
+      }))
+      jest.doMock('../../lexer', () => ({
+        Lexer: jest.fn().mockImplementation(() => ({
+          tokenize: () => [],
+        })),
+      }))
+      jest.doMock('../../parser', () => ({
+        Parser: jest.fn().mockImplementation(() => ({
+          warnings: [],
+          parseErrors: [],
+          parse: () => parseQueue.shift(),
+        })),
+      }))
+      jest.doMock('../../typechecker', () => ({
+        TypeChecker: jest.fn().mockImplementation(() => ({
+          check: () => [],
+          getWarnings: () => [],
+        })),
+      }))
+      jest.doMock('../../hir/lower', () => ({ lowerToHIR: jest.fn(() => ({ functions: [], structs: [] })) }))
+      jest.doMock('../../hir/monomorphize', () => ({ monomorphize: jest.fn(x => x) }))
+      jest.doMock('../../hir/deprecated', () => ({ checkDeprecatedCalls: jest.fn(() => []) }))
+      jest.doMock('../../mir/lower', () => ({ lowerToMIR: jest.fn(() => ({ functions: [] })) }))
+      jest.doMock('../../optimizer/pipeline', () => ({ optimizeModule: jest.fn(x => x) }))
+      jest.doMock('../../optimizer/coroutine', () => ({
+        coroutineTransform: jest.fn(module => ({ module, generatedTickFunctions: [], warnings: [] })),
+      }))
+      jest.doMock('../../lir/lower', () => ({ lowerToLIR: jest.fn(() => ({ functions: [] })) }))
+      jest.doMock('../../optimizer/lir/pipeline', () => ({ lirOptimizeModule: jest.fn(x => x) }))
+      jest.doMock('../../lir/budget', () => ({ analyzeBudget: jest.fn(() => []) }))
+      jest.doMock('../../events/types', () => ({ isEventTypeName: jest.fn(() => false) }))
+      jest.doMock('../../emit/index', () => ({ emit: jest.fn(() => []) }))
+
+      const { compile } = require('../../emit/compile')
+      const result = compile('source', { namespace: 'mocked', filePath: '/root/main.mcrs' })
+
+      expect(result.warnings).toContain(
+        "[ImportWarning] Module 'missing_nested' not found (imported in /root/mod.mcrs)"
+      )
+    })
+  })
+
+  test('library imports, librarySources, lenient type errors, and decorator extraction flow into emit options', () => {
+    jest.isolateModules(() => {
+      const emit = jest.fn(() => [])
+      const parseQueue = [
+        {
+          imports: [],
+          declarations: [],
+          structs: [],
+          implBlocks: [],
+          enums: [],
+          consts: [],
+          globals: [],
+        },
+        {
+          imports: [],
+          declarations: [{ name: 'lib_fn', decorators: [] }],
+          structs: [],
+          implBlocks: [],
+          enums: [],
+          consts: [],
+          globals: [],
+        },
+        {
+          declarations: [{ name: 'inline_fn', decorators: [] }],
+          structs: [],
+          implBlocks: [],
+          enums: [],
+          consts: [],
+          globals: [],
+        },
+      ]
+
+      jest.doMock('../../compile', () => ({
+        preprocessSourceWithMetadata: jest.fn((source: string, options?: { filePath?: string }) => {
+          if (options?.filePath === '/root/main.mcrs') {
+            return {
+              source,
+              libraryImports: [{ source: 'module library;\nfn lib_fn(): int { return 1; }', filePath: '/root/lib.mcrs' }],
+            }
+          }
+          return { source }
+        }),
+      }))
+      jest.doMock('fs', () => ({
+        existsSync: jest.fn(() => false),
+        readFileSync: jest.fn(() => ''),
+      }))
+      jest.doMock('../../lexer', () => ({
+        Lexer: jest.fn().mockImplementation(() => ({
+          tokenize: () => [],
+        })),
+      }))
+      jest.doMock('../../parser', () => ({
+        Parser: jest.fn().mockImplementation(() => ({
+          warnings: [],
+          parseErrors: [],
+          parse: () => parseQueue.shift(),
+        })),
+      }))
+      jest.doMock('../../typechecker', () => ({
+        TypeChecker: jest.fn().mockImplementation(() => ({
+          check: () => [{ location: { line: 3, col: 5 }, message: 'bad types' }],
+          getWarnings: () => ['lint warning'],
+        })),
+      }))
+      jest.doMock('../../hir/lower', () => ({
+        lowerToHIR: jest.fn(() => ({
+          functions: [
+            {
+              name: 'tick_fn',
+              decorators: [
+                { name: 'tick' },
+                { name: 'load' },
+                { name: 'coroutine', args: { batch: 4, onDone: 'after' } },
+                { name: 'schedule', args: { ticks: 5 } },
+                { name: 'on', args: { eventType: 'PlayerJoin' } },
+              ],
+            },
+            {
+              name: 'ignored_event',
+              decorators: [{ name: 'on', args: { eventType: 'NotReal' } }],
+            },
+          ],
+          structs: [],
+        })),
+      }))
+      jest.doMock('../../hir/monomorphize', () => ({ monomorphize: jest.fn(x => x) }))
+      jest.doMock('../../hir/deprecated', () => ({ checkDeprecatedCalls: jest.fn(() => ['deprecated warning']) }))
+      jest.doMock('../../mir/lower', () => ({ lowerToMIR: jest.fn(() => ({ functions: [] })) }))
+      jest.doMock('../../optimizer/pipeline', () => ({ optimizeModule: jest.fn(x => x) }))
+      jest.doMock('../../optimizer/coroutine', () => ({
+        coroutineTransform: jest.fn(module => ({
+          module,
+          generatedTickFunctions: ['generated_tick'],
+          warnings: ['coro warning'],
+        })),
+      }))
+      jest.doMock('../../lir/lower', () => ({ lowerToLIR: jest.fn(() => ({ functions: [] })) }))
+      jest.doMock('../../optimizer/lir/pipeline', () => ({ lirOptimizeModule: jest.fn(x => x) }))
+      jest.doMock('../../lir/budget', () => ({ analyzeBudget: jest.fn(() => [{ level: 'warning', message: 'budget warning' }]) }))
+      jest.doMock('../../events/types', () => ({
+        isEventTypeName: jest.fn((name: string) => name === 'PlayerJoin'),
+      }))
+      jest.doMock('../../emit/index', () => ({ emit }))
+
+      const { compile } = require('../../emit/compile')
+      const result = compile('source', {
+        namespace: 'mocked',
+        filePath: '/root/main.mcrs',
+        lenient: true,
+        librarySources: ['module library;\nfn inline_fn(): int { return 2; }'],
+      })
+
+      expect(result.warnings).toEqual(expect.arrayContaining([
+        'lint warning',
+        '[TypeError] line 3, col 5: bad types',
+        'deprecated warning',
+        'coro warning',
+        'budget warning',
+      ]))
+      expect(emit).toHaveBeenCalledWith(
+        { functions: [] },
+        expect.objectContaining({
+          namespace: 'mocked',
+          tickFunctions: ['tick_fn', 'generated_tick'],
+          loadFunctions: ['tick_fn'],
+          scheduleFunctions: [{ name: 'tick_fn', ticks: 5 }],
+          eventHandlers: new Map([['PlayerJoin', ['mocked:tick_fn']]]),
+        })
+      )
+    })
+  })
+})

package/src/__tests__/emit/compile.test.ts

@@ -72,7 +72,12 @@ describe('emit: compile coverage', () => {
 
     expect(empty).toBe('\n')
     expect(single).toContain('scoreboard players set')
-    expect(nested).toContain('function emit_edge:single')
+    // After auto-inline, single() may be inlined into nested — check either case
+    const allContent = result.files.map(f => f.content).join('\n')
+    expect(
+      (nested ?? '').includes('function emit_edge:single') ||
+      allContent.includes('scoreboard players set $__const_1')
+    ).toBe(true)
   })
 
   test('special builtins raw, scoreboard interop, tell, and setblock emit expected commands', () => {

package/src/__tests__/emit/execute-chain.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Tests for Execute Chain Optimization
+ *
+ * MC allows chaining execute conditions:
+ *   execute if A run execute if B run X
+ * →  execute if A if B run X
+ *
+ * This reduces command parsing overhead and improves TPS.
+ */
+
+import { flattenExecute } from '../../emit'
+import { emit } from '../../emit'
+import type { LIRModule, LIRFunction, LIRInstr } from '../../lir/types'
+import { McVersion } from '../../types/mc-version'
+
+// ---------------------------------------------------------------------------
+// Unit tests: flattenExecute()
+// ---------------------------------------------------------------------------
+
+describe('flattenExecute()', () => {
+  test('double-level if: merges nested execute if into single execute', () => {
+    const input = 'execute if score A rs.vars matches 1 run execute if score B rs.vars matches 1 run function rs:foo'
+    const expected = 'execute if score A rs.vars matches 1 if score B rs.vars matches 1 run function rs:foo'
+    expect(flattenExecute(input)).toBe(expected)
+  })
+
+  test('triple-level if: recursively merges three levels into one execute', () => {
+    const input =
+      'execute if score A rs.vars matches 1 run execute if score B rs.vars matches 1 run execute if score C rs.vars matches 1 run function rs:bar'
+    const expected =
+      'execute if score A rs.vars matches 1 if score B rs.vars matches 1 if score C rs.vars matches 1 run function rs:bar'
+    expect(flattenExecute(input)).toBe(expected)
+  })
+
+  test('if + unless mix: does NOT merge (semantics differ)', () => {
+    const input = 'execute if score A rs.vars matches 1 run execute unless score B rs.vars matches 1 run function rs:baz'
+    // Should remain unchanged — "unless" is not the same as another "if"
+    expect(flattenExecute(input)).toBe(input)
+  })
+
+  test('non-execute command is returned unchanged', () => {
+    const input = 'scoreboard players set $x rs.vars 42'
+    expect(flattenExecute(input)).toBe(input)
+  })
+
+  test('plain execute without nested run execute is returned unchanged', () => {
+    const input = 'execute if score A rs.vars matches 1 run function rs:simple'
+    expect(flattenExecute(input)).toBe(input)
+  })
+
+  test('execute run execute with "as" subcmd is NOT merged (not an if clause)', () => {
+    const input = 'execute if score A rs.vars matches 1 run execute as @a run function rs:ctx'
+    // Inner starts with "as", not "if" — should not be merged
+    expect(flattenExecute(input)).toBe(input)
+  })
+
+  test('execute if score using score comparison: merges correctly', () => {
+    const input = 'execute if score $a rs.vars = $b rs.vars run execute if score $c rs.vars = $d rs.vars run function rs:check'
+    const expected = 'execute if score $a rs.vars = $b rs.vars if score $c rs.vars = $d rs.vars run function rs:check'
+    expect(flattenExecute(input)).toBe(expected)
+  })
+
+  test('four-level nesting: recursively flattens all levels', () => {
+    const input =
+      'execute if score A o matches 1 run execute if score B o matches 2 run execute if score C o matches 3 run execute if score D o matches 4 run function ns:deep'
+    const expected =
+      'execute if score A o matches 1 if score B o matches 2 if score C o matches 3 if score D o matches 4 run function ns:deep'
+    expect(flattenExecute(input)).toBe(expected)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Integration tests: actual compilation output
+// ---------------------------------------------------------------------------
+
+describe('execute chain optimization: compilation output', () => {
+  function buildModule(instructions: LIRInstr[]): LIRModule {
+    const fn: LIRFunction = {
+      name: 'test_fn',
+      instructions,
+      isMacro: false,
+      macroParams: [],
+      params: [],
+      returnType: 'void',
+    }
+    return {
+      functions: [fn],
+      objective: 'rs.vars',
+      namespace: 'rs',
+    }
+  }
+
+  function getFile(files: { path: string; content: string }[], pathSubstr: string): string {
+    const f = files.find(f => f.path.includes(pathSubstr))
+    if (!f) throw new Error(`Missing file matching: ${pathSubstr}\nFiles: ${files.map(f => f.path).join(', ')}`)
+    return f.content
+  }
+
+  test('call_if_matches + nested raw execute if: flattened in emitted output', () => {
+    // Emit a raw execute that already contains a nested execute if to verify post-processing
+    const instructions: LIRInstr[] = [
+      {
+        kind: 'raw',
+        cmd: 'execute if score $cond rs.vars matches 1 run execute if score $cond2 rs.vars matches 2 run function rs:target',
+      },
+    ]
+    const files = emit(buildModule(instructions), { namespace: 'rs' })
+    const content = getFile(files, 'test_fn.mcfunction')
+    expect(content).toContain(
+      'execute if score $cond rs.vars matches 1 if score $cond2 rs.vars matches 2 run function rs:target',
+    )
+    expect(content).not.toContain('run execute if')
+  })
+})

package/src/__tests__/emit/index.test.ts

@@ -114,6 +114,7 @@ describe('emit: direct LIR emission', () => {
     expect(getFile(files, 'data/emitns/function/load.mcfunction')).toBe('scoreboard objectives add __emit dummy\n')
 
     const main = getFile(files, 'data/emitns/function/main/run.mcfunction')
+    expect(main).toContain('# src: src/test.mcrs:3')
     expect(main).toContain('scoreboard players set $a __emit 7')
     expect(main).toContain('scoreboard players operation $b __emit = $a __emit')
     expect(main).toContain('scoreboard players operation $a __emit += $b __emit')
@@ -150,7 +151,7 @@ describe('emit: direct LIR emission', () => {
     const map = JSON.parse(getFile(files, 'data/emitns/function/main/run.sourcemap.json'))
     expect(map.generatedFile).toBe('data/emitns/function/main/run.mcfunction')
     expect(map.sources).toEqual(['src/test.mcrs'])
-    expect(map.mappings[0]).toMatchObject({ line: 1, sourceLine: 3, sourceCol: 5 })
+    expect(map.mappings[0]).toMatchObject({ line: 2, sourceLine: 3, sourceCol: 5 })
     expect(files.find(f => f.path === 'data/emitns/function/empty.sourcemap.json')).toBeUndefined()
   })