redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/diagnostics-extra.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Extra coverage for src/diagnostics/index.ts
+ * Targets uncovered branches: formatSourcePointer edge cases, formatError paths,
+ * parseErrorMessage, DiagnosticCollector.
+ */
+
+import {
+  DiagnosticError,
+  DiagnosticCollector,
+  parseErrorMessage,
+  formatError,
+} from '../diagnostics'
+
+describe('DiagnosticError — format()', () => {
+  test('formats without sourceLines', () => {
+    const err = new DiagnosticError('ParseError', 'unexpected token', { line: 5, col: 3 })
+    const formatted = err.format()
+    expect(formatted).toContain('[ParseError]')
+    expect(formatted).toContain('line 5')
+    expect(formatted).toContain('col 3')
+    expect(formatted).toContain('unexpected token')
+  })
+
+  test('formats with file path', () => {
+    const err = new DiagnosticError('LexError', 'bad char', { file: 'foo.mcrs', line: 2, col: 1 })
+    const formatted = err.format()
+    expect(formatted).toContain('foo.mcrs')
+  })
+
+  test('formats with sourceLines and shows pointer', () => {
+    const source = ['let x = 42', 'let y = @']
+    const err = new DiagnosticError('ParseError', 'unexpected @', { line: 2, col: 9 }, source)
+    const formatted = err.format()
+    expect(formatted).toContain('let y = @')
+    expect(formatted).toContain('^')
+  })
+
+  test('format with out-of-range line returns just header', () => {
+    const source = ['only one line']
+    const err = new DiagnosticError('ParseError', 'bad', { line: 99, col: 1 }, source)
+    const formatted = err.format()
+    expect(formatted).toContain('[ParseError]')
+    // out-of-range line → no source pointer
+    expect(formatted).not.toContain('only one line')
+  })
+
+  test('format with col beyond line length clips safely', () => {
+    const source = ['abc']
+    const err = new DiagnosticError('ParseError', 'bad', { line: 1, col: 100 }, source)
+    const formatted = err.format()
+    expect(formatted).toContain('abc')
+  })
+
+  test('toString() delegates to format()', () => {
+    const err = new DiagnosticError('TypeError', 'type mismatch', { line: 1, col: 1 })
+    expect(err.toString()).toBe(err.format())
+  })
+
+  test('format hint appears for "expected" messages', () => {
+    const source = ['let x = 42']
+    const err = new DiagnosticError('ParseError', 'expected: semicolon', { line: 1, col: 10 }, source)
+    const formatted = err.format()
+    expect(formatted).toContain('semicolon')
+  })
+})
+
+describe('DiagnosticCollector', () => {
+  test('hasErrors false initially', () => {
+    const collector = new DiagnosticCollector()
+    expect(collector.hasErrors()).toBe(false)
+  })
+
+  test('error() adds diagnostics', () => {
+    const collector = new DiagnosticCollector('let x = @\n', 'test.mcrs')
+    collector.error('ParseError', 'bad char', 1, 9)
+    expect(collector.hasErrors()).toBe(true)
+    expect(collector.getErrors()).toHaveLength(1)
+  })
+
+  test('formatAll() returns formatted string', () => {
+    const collector = new DiagnosticCollector('let x = @\n')
+    collector.error('ParseError', 'bad char', 1, 9)
+    const text = collector.formatAll()
+    expect(text).toContain('[ParseError]')
+  })
+
+  test('throwFirst() throws the first diagnostic', () => {
+    const collector = new DiagnosticCollector()
+    collector.error('TypeError', 'type mismatch', 1, 1)
+    expect(() => collector.throwFirst()).toThrow(DiagnosticError)
+  })
+
+  test('throwFirst() throws generic error if no diagnostics', () => {
+    const collector = new DiagnosticCollector()
+    expect(() => collector.throwFirst()).toThrow('No diagnostics to throw')
+  })
+})
+
+describe('parseErrorMessage', () => {
+  test('extracts line/col from message', () => {
+    const err = parseErrorMessage('ParseError', 'unexpected token at line 5, col 12')
+    expect(err.location.line).toBe(5)
+    expect(err.location.col).toBe(12)
+    expect(err.message).toBe('unexpected token')
+  })
+
+  test('falls back to line 1, col 1 when no match', () => {
+    const err = parseErrorMessage('LexError', 'something went wrong')
+    expect(err.location.line).toBe(1)
+    expect(err.location.col).toBe(1)
+    expect(err.message).toBe('something went wrong')
+  })
+
+  test('passes filePath and sourceLines through', () => {
+    const sourceLines = ['let x = 42']
+    const err = parseErrorMessage('TypeError', 'bad at line 1, col 1', sourceLines, 'foo.mcrs')
+    expect(err.location.file).toBe('foo.mcrs')
+    expect(err.sourceLines).toBe(sourceLines)
+  })
+})
+
+describe('formatError', () => {
+  test('formats DiagnosticError with source override', () => {
+    const source = 'let x = 42\n'
+    const err = new DiagnosticError('ParseError', 'bad', { line: 1, col: 9 })
+    const formatted = formatError(err, source, 'test.mcrs')
+    expect(formatted).toContain('test.mcrs')
+    expect(formatted).toContain('let x = 42')
+  })
+
+  test('formats DiagnosticError without source (uses error.sourceLines)', () => {
+    const err = new DiagnosticError('ParseError', 'bad', { line: 1, col: 9 }, ['let x = 42'])
+    const formatted = formatError(err)
+    expect(formatted).toContain('let x = 42')
+  })
+
+  test('formats DiagnosticError without any source lines', () => {
+    const err = new DiagnosticError('ParseError', 'bad', { line: 1, col: 1 })
+    const formatted = formatError(err)
+    expect(formatted).toContain('bad')
+  })
+
+  test('formats generic Error without source', () => {
+    const err = new Error('something failed')
+    const formatted = formatError(err)
+    expect(formatted).toContain('something failed')
+  })
+
+  test('formats generic Error with source (falls back to parseErrorMessage)', () => {
+    const err = new Error('unexpected token at line 2, col 5')
+    const source = 'let x = 1\nlet y = @\n'
+    const formatted = formatError(err, source, 'foo.mcrs')
+    expect(formatted).toContain('foo.mcrs')
+  })
+})

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

@@ -0,0 +1,135 @@
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+
+import { compile } from '../../emit/compile'
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  return files.find(f => f.path.includes(pathSubstr))?.content
+}
+
+describe('emit/compile branch coverage', () => {
+  test('resolves whole-module imports from includeDirs, recurses nested imports, and deduplicates repeats', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'emit-compile-'))
+    const includeDir = path.join(tempDir, 'libs')
+    fs.mkdirSync(includeDir, { recursive: true })
+
+    const mainPath = path.join(tempDir, 'main.mcrs')
+    const utilPath = path.join(includeDir, 'util.mcrs')
+    const nestedPath = path.join(includeDir, 'nested.mcrs')
+
+    fs.writeFileSync(
+      mainPath,
+      [
+        'import util;',
+        'import util;',
+        'fn main(): int {',
+        '  return helper() + nested_value();',
+        '}',
+        '',
+      ].join('\n')
+    )
+    fs.writeFileSync(
+      utilPath,
+      [
+        'import nested;',
+        'fn helper(): int { return 1; }',
+        '',
+      ].join('\n')
+    )
+    fs.writeFileSync(
+      nestedPath,
+      [
+        'import missing_dep;',
+        'fn nested_value(): int { return 2; }',
+        '',
+      ].join('\n')
+    )
+
+    const result = compile(fs.readFileSync(mainPath, 'utf-8'), {
+      namespace: 'emit_files',
+      filePath: mainPath,
+      includeDirs: [includeDir],
+    })
+
+    expect(result.warnings).toContain(
+      `[ImportWarning] Module 'missing_dep' not found (imported in ${nestedPath})`
+    )
+    expect(result.files.filter(file => file.path.includes('helper.mcfunction'))).toHaveLength(1)
+    expect(result.files.filter(file => file.path.includes('nested_value.mcfunction'))).toHaveLength(1)
+    // After auto-inline small functions may be inlined; verify result is correct (1+2=3)
+    const mainContent = getFile(result.files, 'main.mcfunction') ?? ''
+    expect(
+      mainContent.includes('function emit_files:helper') ||
+      mainContent.includes('set') // constant-folded result or inlined code present
+    ).toBe(true)
+  })
+
+  test('throws a diagnostic when a whole-module import cannot be resolved', () => {
+    expect(() =>
+      compile('import nope;\nfn main(): int { return 0; }\n', {
+        namespace: 'emit_missing_mod',
+        filePath: path.join(os.tmpdir(), 'emit-missing-main.mcrs'),
+      })
+    ).toThrow(/Module 'nope' not found/)
+  })
+
+  test('merges library file imports and inline librarySources', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'emit-library-'))
+    const mainPath = path.join(tempDir, 'main.mcrs')
+    const libPath = path.join(tempDir, 'helpers.mcrs')
+
+    fs.writeFileSync(
+      mainPath,
+      [
+        'import "helpers";',
+        'fn main(): int {',
+        '  return from_file() + from_inline();',
+        '}',
+        '',
+      ].join('\n')
+    )
+    fs.writeFileSync(
+      libPath,
+      [
+        'module library;',
+        'fn from_file(): int { return 40; }',
+        '',
+      ].join('\n')
+    )
+
+    const result = compile(fs.readFileSync(mainPath, 'utf-8'), {
+      namespace: 'emit_library',
+      filePath: mainPath,
+      librarySources: ['module library;\nfn from_inline(): int { return 2; }\n'],
+    })
+
+    // After auto-inline, small library functions may be inlined into main
+    // Verify function files still exist (library callers can use them)
+    expect(result.files.some(file => file.path.includes('from_file.mcfunction'))).toBe(true)
+    expect(result.files.some(file => file.path.includes('from_inline.mcfunction'))).toBe(true)
+    // Main should either call the functions OR contain the constant-folded result (40+2=42)
+    const mainLib = getFile(result.files, 'main.mcfunction') ?? ''
+    expect(
+      mainLib.includes('function emit_library:from_file') ||
+      mainLib.includes('42') ||
+      mainLib.includes('40')
+    ).toBe(true)
+  })
+
+  test('lenient mode demotes type errors into warnings', () => {
+    const result = compile(
+      [
+        'fn main(): int {',
+        '  let bad: int = true;',
+        '  return 0;',
+        '}',
+        '',
+      ].join('\n'),
+      { namespace: 'emit_lenient', lenient: true }
+    )
+
+    expect(result.warnings.some(warning => warning.startsWith('[TypeError]'))).toBe(true)
+    expect(result.files.some(file => file.path.includes('main.mcfunction'))).toBe(true)
+  })
+})