redscript-mc 2.0.0 → 2.1.1

package/src/cache/index.ts

@@ -0,0 +1,135 @@
+/**
+ * FileCache — content-hash-based compilation cache for incremental builds.
+ *
+ * Stores per-file content hashes and optional cached HIR modules.
+ * Persists to `.redscript-cache/` as JSON.
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+import * as crypto from 'crypto'
+import type { HIRModule } from '../hir/types'
+
+export interface CacheEntry {
+  hash: string
+  mtime: number
+  hir?: HIRModule
+}
+
+interface SerializedCache {
+  version: 1
+  entries: Record<string, { hash: string; mtime: number }>
+}
+
+export class FileCache {
+  private entries = new Map<string, CacheEntry>()
+  private cacheDir: string
+
+  constructor(cacheDir: string) {
+    this.cacheDir = cacheDir
+  }
+
+  /** Get cached entry for a file (by absolute path). */
+  get(filePath: string): CacheEntry | undefined {
+    return this.entries.get(path.resolve(filePath))
+  }
+
+  /** Set cache entry for a file. */
+  set(filePath: string, entry: CacheEntry): void {
+    this.entries.set(path.resolve(filePath), entry)
+  }
+
+  /** Check if a file's content has changed since last cache. */
+  hasChanged(filePath: string): boolean {
+    const absPath = path.resolve(filePath)
+    const cached = this.entries.get(absPath)
+    if (!cached) return true
+
+    // Quick mtime check first
+    try {
+      const stat = fs.statSync(absPath)
+      if (stat.mtimeMs === cached.mtime) return false
+    } catch {
+      return true
+    }
+
+    // mtime changed — compare content hash
+    const currentHash = hashFile(absPath)
+    return currentHash !== cached.hash
+  }
+
+  /** Update the cache entry for a file from disk. Returns true if content changed. */
+  update(filePath: string, hir?: HIRModule): boolean {
+    const absPath = path.resolve(filePath)
+    const changed = this.hasChanged(absPath)
+
+    if (changed) {
+      try {
+        const stat = fs.statSync(absPath)
+        this.entries.set(absPath, {
+          hash: hashFile(absPath),
+          mtime: stat.mtimeMs,
+          hir,
+        })
+      } catch {
+        this.entries.delete(absPath)
+      }
+    } else if (hir) {
+      // Update HIR even if hash didn't change
+      const entry = this.entries.get(absPath)
+      if (entry) entry.hir = hir
+    }
+
+    return changed
+  }
+
+  /** Remove a file from the cache. */
+  delete(filePath: string): void {
+    this.entries.delete(path.resolve(filePath))
+  }
+
+  /** Clear all cache entries. */
+  clear(): void {
+    this.entries.clear()
+  }
+
+  /** Number of cached entries. */
+  get size(): number {
+    return this.entries.size
+  }
+
+  /** Persist cache to disk (`.redscript-cache/cache.json`). */
+  save(): void {
+    fs.mkdirSync(this.cacheDir, { recursive: true })
+    const serialized: SerializedCache = {
+      version: 1,
+      entries: {},
+    }
+    for (const [filePath, entry] of this.entries) {
+      // Don't persist HIR — it contains non-serializable references
+      serialized.entries[filePath] = { hash: entry.hash, mtime: entry.mtime }
+    }
+    const cachePath = path.join(this.cacheDir, 'cache.json')
+    fs.writeFileSync(cachePath, JSON.stringify(serialized, null, 2))
+  }
+
+  /** Load cache from disk. */
+  load(): void {
+    const cachePath = path.join(this.cacheDir, 'cache.json')
+    try {
+      const data = JSON.parse(fs.readFileSync(cachePath, 'utf-8')) as SerializedCache
+      if (data.version !== 1) return
+      for (const [filePath, entry] of Object.entries(data.entries)) {
+        this.entries.set(filePath, { hash: entry.hash, mtime: entry.mtime })
+      }
+    } catch {
+      // No cache or corrupt — start fresh
+    }
+  }
+}
+
+/** SHA-256 hash of a file's content. */
+export function hashFile(filePath: string): string {
+  const content = fs.readFileSync(filePath)
+  return crypto.createHash('sha256').update(content).digest('hex')
+}

package/src/cli.ts

@@ -9,10 +9,14 @@
  *   redscript version
  */
 
-import { compile, check } from './index'
+import { compile, checkWithWarnings } from './index'
 import { formatError } from './diagnostics'
+import { parseMcVersion, DEFAULT_MC_VERSION } from './types/mc-version'
 import { startRepl } from './repl'
 import { generateDts } from './builtins/metadata'
+import { FileCache } from './cache/index'
+import { DependencyGraph } from './cache/deps'
+import { compileIncremental } from './cache/incremental'
 import * as fs from 'fs'
 import * as path from 'path'
 import * as https from 'https'
@@ -49,6 +53,11 @@ Options:
   --namespace <ns>       Datapack namespace (default: derived from filename)
   --hot-reload <url>     After each successful compile, POST to <url>/reload
                          (use with redscript-testharness; e.g. http://localhost:25561)
+  --source-map           Generate .sourcemap.json files alongside .mcfunction output
+  --mc-version <ver>     Target Minecraft version (default: 1.21). Affects codegen features.
+                         e.g. --mc-version 1.20.2, --mc-version 1.19
+  --lenient              Treat type errors as warnings instead of blocking compilation
+  --include <dir>        Add a directory to the import search path (repeatable)
   -h, --help             Show this help message
 `)
 }
@@ -150,6 +159,10 @@ function parseArgs(args: string[]): {
   namespace?: string
   help?: boolean
   hotReload?: string
+  sourceMap?: boolean
+  mcVersionStr?: string
+  lenient?: boolean
+  includeDirs?: string[]
 } {
   const result: ReturnType<typeof parseArgs> = {}
   let i = 0
@@ -169,6 +182,19 @@ function parseArgs(args: string[]): {
     } else if (arg === '--hot-reload') {
       result.hotReload = args[++i]
       i++
+    } else if (arg === '--source-map') {
+      result.sourceMap = true
+      i++
+    } else if (arg === '--mc-version') {
+      result.mcVersionStr = args[++i]
+      i++
+    } else if (arg === '--lenient') {
+      result.lenient = true
+      i++
+    } else if (arg === '--include') {
+      if (!result.includeDirs) result.includeDirs = []
+      result.includeDirs.push(args[++i])
+      i++
     } else if (!result.command) {
       result.command = arg
       i++
@@ -193,6 +219,10 @@ function compileCommand(
   file: string,
   output: string,
   namespace: string,
+  sourceMap = false,
+  mcVersionStr?: string,
+  lenient = false,
+  includeDirs?: string[],
 ): void {
   // Read source file
   if (!fs.existsSync(file)) {
@@ -200,10 +230,20 @@ function compileCommand(
     process.exit(1)
   }
 
+  let mcVersion = DEFAULT_MC_VERSION
+  if (mcVersionStr) {
+    try {
+      mcVersion = parseMcVersion(mcVersionStr)
+    } catch (e) {
+      console.error(`Error: ${(e as Error).message}`)
+      process.exit(1)
+    }
+  }
+
   const source = fs.readFileSync(file, 'utf-8')
 
   try {
-    const result = compile(source, { namespace, filePath: file })
+    const result = compile(source, { namespace, filePath: file, generateSourceMap: sourceMap, mcVersion, lenient, includeDirs })
 
     for (const w of result.warnings) {
       console.error(`Warning: ${w}`)
@@ -224,12 +264,12 @@ function compileCommand(
     console.log(`  Namespace: ${namespace}`)
     console.log(`  Files: ${result.files.length}`)
   } catch (err) {
-    console.error(formatError(err as Error, source))
+    console.error(formatError(err as Error, source, file))
     process.exit(1)
   }
 }
 
-function checkCommand(file: string): void {
+function checkCommand(file: string, namespace?: string): void {
   // Read source file
   if (!fs.existsSync(file)) {
     console.error(`Error: File not found: ${file}`)
@@ -238,13 +278,19 @@ function checkCommand(file: string): void {
 
   const source = fs.readFileSync(file, 'utf-8')
 
-  const error = check(source, 'redscript', file)
-  if (error) {
-    console.error(formatError(error, source))
+  const ns = namespace ?? deriveNamespace(file)
+  const result = checkWithWarnings(source, ns, file)
+
+  for (const w of result.warnings) {
+    console.error(`Warning: ${w}`)
+  }
+
+  if (result.error) {
+    console.error(formatError(result.error, source, file))
     process.exit(1)
   }
 
-  console.log(`✓ ${file} is valid`)
+  console.log(`✓ No errors found`)
 }
 
 async function hotReload(url: string): Promise<void> {
@@ -276,54 +322,55 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
   console.log(`👁  Watching ${dir} for .mcrs file changes...`)
   console.log(`   Output: ${output}`)
   if (hotReloadUrl) console.log(`   Hot reload: ${hotReloadUrl}`)
+  console.log(`   Incremental compilation enabled`)
   console.log(`   Press Ctrl+C to stop\n`)
 
+  // Set up incremental compilation infrastructure
+  const cacheDir = path.join(dir, '.redscript-cache')
+  const cache = new FileCache(cacheDir)
+  cache.load()
+  const depGraph = new DependencyGraph()
+
   // Debounce timer
   let debounceTimer: NodeJS.Timeout | null = null
 
-  // Compile all .mcrs files in directory
-  async function compileAll(): Promise<void> {
+  // Compile all .mcrs files in directory (incrementally)
+  async function compileAllIncremental(): Promise<void> {
     const files = findRsFiles(dir)
     if (files.length === 0) {
       console.log(`⚠  No .mcrs files found in ${dir}`)
       return
     }
 
-    let hasErrors = false
-    for (const file of files) {
-      let source = ''
-      try {
-        source = fs.readFileSync(file, 'utf-8')
-        const ns = namespace ?? deriveNamespace(file)
-        const result = compile(source, { namespace: ns, filePath: file })
-        for (const w of result.warnings) {
-          console.error(`Warning: ${w}`)
-        }
-
-        // Create output directory
-        fs.mkdirSync(output, { recursive: true })
-
-        // Write all files
-        for (const dataFile of result.files) {
-          const filePath = path.join(output, dataFile.path)
-          const fileDir = path.dirname(filePath)
-          fs.mkdirSync(fileDir, { recursive: true })
-          fs.writeFileSync(filePath, dataFile.content)
-        }
-
-        const timestamp = new Date().toLocaleTimeString()
-        console.log(`✓ [${timestamp}] Compiled ${file} (${result.files.length} files)`)
-      } catch (err) {
-        hasErrors = true
-        const timestamp = new Date().toLocaleTimeString()
-        console.error(`✗ [${timestamp}] ${formatError(err as Error, source)}`)
+    const incResult = compileIncremental(files, cache, depGraph, {
+      namespace,
+      output,
+    })
+
+    const timestamp = new Date().toLocaleTimeString()
+
+    // Print warnings from recompiled files
+    for (const [file, compileResult] of incResult.results) {
+      for (const w of compileResult.warnings) {
+        console.error(`Warning: ${w}`)
       }
+      console.log(`✓ [${timestamp}] Compiled ${path.relative(dir, file)} (${compileResult.files.length} files)`)
     }
 
-    if (!hasErrors) {
-      if (hotReloadUrl) await hotReload(hotReloadUrl)
-      console.log('')
+    if (incResult.cached > 0) {
+      console.log(`  [${timestamp}] ${incResult.cached} file(s) unchanged (cached)`)
     }
+
+    // Print errors
+    for (const [file, errMsg] of incResult.errors) {
+      console.error(`✗ [${timestamp}] ${path.relative(dir, file)}: ${errMsg}`)
+    }
+
+    // Persist cache
+    cache.save()
+
+    if (incResult.errors.size === 0 && hotReloadUrl) await hotReload(hotReloadUrl)
+    console.log('')
   }
 
   // Find all .mcrs files recursively
@@ -333,7 +380,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
 
     for (const entry of entries) {
       const fullPath = path.join(directory, entry.name)
-      if (entry.isDirectory()) {
+      if (entry.isDirectory() && entry.name !== '.redscript-cache') {
         results.push(...findRsFiles(fullPath))
       } else if (entry.isFile() && entry.name.endsWith('.mcrs')) {
         results.push(fullPath)
@@ -344,7 +391,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
   }
 
   // Initial compile
-  void compileAll()
+  void compileAllIncremental()
 
   // Watch for changes
   fs.watch(dir, { recursive: true }, (eventType, filename) => {
@@ -355,7 +402,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
       }
       debounceTimer = setTimeout(() => {
         console.log(`📝 Change detected: ${filename}`)
-        void compileAll()
+        void compileAllIncremental()
       }, 100)
     }
   })
@@ -392,6 +439,10 @@ async function main(): Promise<void> {
         parsed.file,
         output,
         namespace,
+        parsed.sourceMap,
+        parsed.mcVersionStr,
+        parsed.lenient,
+        parsed.includeDirs,
       )
       }
       break
@@ -416,7 +467,7 @@ async function main(): Promise<void> {
         printUsage()
         process.exit(1)
       }
-      checkCommand(parsed.file)
+      checkCommand(parsed.file, parsed.namespace)
       break
 
     case 'fmt':

package/src/compile.ts

@@ -13,8 +13,8 @@ import { DiagnosticError } from './diagnostics'
 // Re-export v2 compile
 // ---------------------------------------------------------------------------
 
-export { compile, CompileOptions, CompileResult } from '../src2/emit/compile'
-export type { DatapackFile } from '../src2/emit/index'
+export { compile, CompileOptions, CompileResult } from './emit/compile'
+export type { DatapackFile } from './emit/index'
 
 // ---------------------------------------------------------------------------
 // Source Range / Preprocessing
@@ -69,6 +69,37 @@ function isLibrarySource(source: string): boolean {
 interface PreprocessOptions {
   filePath?: string
   seen?: Set<string>
+  includeDirs?: string[]
+}
+
+/** Resolve an import specifier to an absolute file path, trying multiple locations. */
+function resolveImportPath(
+  spec: string,
+  fromFile: string,
+  includeDirs: string[]
+): string | null {
+  const candidates = spec.endsWith('.mcrs') ? [spec] : [spec, spec + '.mcrs']
+
+  for (const candidate of candidates) {
+    // 1. Relative to the importing file
+    const rel = path.resolve(path.dirname(fromFile), candidate)
+    if (fs.existsSync(rel)) return rel
+
+    // 2. stdlib directory (package root / src / stdlib)
+    //    Strip leading 'stdlib/' prefix so `import "stdlib/math"` resolves to
+    //    <stdlibDir>/math.mcrs rather than <stdlibDir>/stdlib/math.mcrs.
+    const stdlibDir = path.resolve(__dirname, '..', 'src', 'stdlib')
+    const stdlibCandidate = candidate.replace(/^stdlib\//, '')
+    const stdlib = path.resolve(stdlibDir, stdlibCandidate)
+    if (fs.existsSync(stdlib)) return stdlib
+
+    // 3. Extra include dirs
+    for (const dir of includeDirs) {
+      const extra = path.resolve(dir, candidate)
+      if (fs.existsSync(extra)) return extra
+    }
+  }
+  return null
 }
 
 function countLines(source: string): number {
@@ -86,6 +117,7 @@ function offsetRanges(ranges: SourceRange[], lineOffset: number): SourceRange[]
 export function preprocessSourceWithMetadata(source: string, options: PreprocessOptions = {}): PreprocessedSource {
   const { filePath } = options
   const seen = options.seen ?? new Set<string>()
+  const includeDirs = options.includeDirs ?? []
 
   if (filePath) {
     seen.add(path.resolve(filePath))
@@ -113,31 +145,28 @@ export function preprocessSourceWithMetadata(source: string, options: Preprocess
         )
       }
 
-      const importPath = path.resolve(path.dirname(filePath), match[1])
+      const importPath = resolveImportPath(match[1], filePath, includeDirs)
+      if (!importPath) {
+        throw new DiagnosticError(
+          'ParseError',
+          `Cannot import '${match[1]}'`,
+          { file: filePath, line: i + 1, col: 1 },
+          lines
+        )
+      }
       if (!seen.has(importPath)) {
         seen.add(importPath)
-        let importedSource: string
-
-        try {
-          importedSource = fs.readFileSync(importPath, 'utf-8')
-        } catch {
-          throw new DiagnosticError(
-            'ParseError',
-            `Cannot import '${match[1]}'`,
-            { file: filePath, line: i + 1, col: 1 },
-            lines
-          )
-        }
+        const importedSource = fs.readFileSync(importPath, 'utf-8')
 
         if (isLibrarySource(importedSource)) {
           // Library file: parse separately so its functions are DCE-eligible.
           // Also collect any transitive library imports inside it.
-          const nested = preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen })
+          const nested = preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen, includeDirs })
           libraryImports.push({ source: importedSource, filePath: importPath })
           // Propagate transitive library imports (e.g. math.mcrs imports vec.mcrs)
           if (nested.libraryImports) libraryImports.push(...nested.libraryImports)
         } else {
-          imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen }))
+          imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen, includeDirs }))
         }
       }
       continue

package/src/diagnostics/index.ts

@@ -161,26 +161,23 @@ export function parseErrorMessage(
   return new DiagnosticError(kind, rawMessage, { file: filePath, line: 1, col: 1 }, sourceLines)
 }
 
-export function formatError(error: Error | DiagnosticError, source?: string): string {
+export function formatError(error: Error | DiagnosticError, source?: string, filePath?: string): string {
   if (error instanceof DiagnosticError) {
     const sourceLines = source?.split('\n') ?? error.sourceLines ?? []
     const { file, line, col } = error.location
-    const locationPart = file
-      ? ` in ${file} at line ${line}, col ${col}`
-      : ` at line ${line}, col ${col}`
-    const lines = [`Error${locationPart}:`]
+    const fileStr = file ?? filePath ?? '<input>'
+    const header = `${fileStr}:${line}:${col}: error: ${error.message}`
     const pointerLines = formatSourcePointer(sourceLines, line, col)
-    if (pointerLines.length > 0) {
-      lines.push(...pointerLines)
+    if (pointerLines.length === 0) {
+      return header
     }
-    lines.push(error.message)
-    return lines.join('\n')
+    return [header, ...pointerLines].join('\n')
   }
 
   if (!source) {
     return error.message
   }
 
-  const parsed = parseErrorMessage('ParseError', error.message, source.split('\n'))
-  return formatError(parsed, source)
+  const parsed = parseErrorMessage('ParseError', error.message, source.split('\n'), filePath)
+  return formatError(parsed, source, filePath)
 }