redscript-mc 1.2.30 → 2.1.0

package/src/cache/incremental.ts

@@ -0,0 +1,173 @@
+/**
+ * Incremental compilation — only recompile files whose content (or
+ * dependencies) has changed since the last build.
+ */
+
+import * as path from 'path'
+import { compile, type CompileOptions, type CompileResult } from '../emit/compile'
+import * as fs from 'fs'
+import { FileCache } from './index'
+import { DependencyGraph } from './deps'
+
+export interface IncrementalOptions {
+  namespace?: string
+  /** Output directory for compiled files. */
+  output: string
+}
+
+export interface IncrementalResult {
+  /** Number of files that were recompiled. */
+  recompiled: number
+  /** Number of files that used the cache (skipped). */
+  cached: number
+  /** Files that had errors (path → error message). */
+  errors: Map<string, string>
+  /** Per-file compile results (only for recompiled files). */
+  results: Map<string, CompileResult>
+}
+
+/** Cached compilation output per entry file. */
+interface CompileCacheEntry {
+  result: CompileResult
+  /** Content hashes of entry file + all its transitive deps at compile time. */
+  depHashes: Map<string, string>
+}
+
+const compiledCache = new Map<string, CompileCacheEntry>()
+
+/**
+ * Compile a set of entry files incrementally.
+ *
+ * For each file:
+ * - Compute content hash of the file and all its transitive imports
+ * - If all hashes match the previous build → skip (cache hit)
+ * - If any hash changed → recompile from scratch
+ */
+export function compileIncremental(
+  files: string[],
+  cache: FileCache,
+  depGraph: DependencyGraph,
+  options: IncrementalOptions,
+): IncrementalResult {
+  const result: IncrementalResult = {
+    recompiled: 0,
+    cached: 0,
+    errors: new Map(),
+    results: new Map(),
+  }
+
+  // Phase 1: Update dependency graph for all files
+  for (const file of files) {
+    const absFile = path.resolve(file)
+    try {
+      const source = fs.readFileSync(absFile, 'utf-8')
+      depGraph.addFile(absFile, source)
+    } catch {
+      // File might have been deleted
+      depGraph.removeFile(absFile)
+    }
+  }
+
+  // Phase 2: Detect all changed source files BEFORE recompiling anything.
+  // This prevents cache.update() during one file's recompile from hiding
+  // changes needed by another file that shares the same dependency.
+  const changedSourceFiles = new Set<string>()
+  const allSourceFiles = new Set<string>()
+
+  for (const file of files) {
+    const absFile = path.resolve(file)
+    const allDeps = depGraph.getTransitiveDeps(absFile)
+    allSourceFiles.add(absFile)
+    for (const dep of allDeps) allSourceFiles.add(dep)
+  }
+
+  for (const sourceFile of allSourceFiles) {
+    if (cache.hasChanged(sourceFile)) {
+      changedSourceFiles.add(sourceFile)
+    }
+  }
+
+  // Phase 3: For each entry file, check if it or any dep changed → recompile
+  for (const file of files) {
+    const absFile = path.resolve(file)
+
+    // Collect all files in this compilation unit (entry + transitive deps)
+    const allDeps = depGraph.getTransitiveDeps(absFile)
+    const unitFiles = [absFile, ...allDeps]
+
+    // Check if any file in the unit has changed
+    let needsRecompile = false
+    const prevEntry = compiledCache.get(absFile)
+
+    if (!prevEntry) {
+      needsRecompile = true
+    } else {
+      for (const unitFile of unitFiles) {
+        if (changedSourceFiles.has(unitFile)) {
+          needsRecompile = true
+          break
+        }
+      }
+      // Also check if the set of dependencies changed
+      if (!needsRecompile && prevEntry.depHashes.size !== unitFiles.length) {
+        needsRecompile = true
+      }
+    }
+
+    if (!needsRecompile) {
+      // Cache hit — write cached result to output
+      const cached = compiledCache.get(absFile)!
+      writeBuildOutput(cached.result, options.output)
+      result.cached++
+      continue
+    }
+
+    // Cache miss — recompile
+    try {
+      const source = fs.readFileSync(absFile, 'utf-8')
+      const ns = options.namespace ?? deriveNamespace(absFile)
+      const compileResult = compile(source, { namespace: ns, filePath: absFile })
+
+      // Update caches
+      const depHashes = new Map<string, string>()
+      for (const unitFile of unitFiles) {
+        cache.update(unitFile)
+        const entry = cache.get(unitFile)
+        if (entry) depHashes.set(unitFile, entry.hash)
+      }
+
+      compiledCache.set(absFile, { result: compileResult, depHashes })
+      writeBuildOutput(compileResult, options.output)
+
+      result.recompiled++
+      result.results.set(absFile, compileResult)
+    } catch (err) {
+      result.errors.set(absFile, (err as Error).message)
+    }
+  }
+
+  return result
+}
+
+/** Write compile output files to the output directory. */
+function writeBuildOutput(compileResult: CompileResult, output: string): void {
+  fs.mkdirSync(output, { recursive: true })
+  for (const dataFile of compileResult.files) {
+    const filePath = path.join(output, dataFile.path)
+    const dir = path.dirname(filePath)
+    fs.mkdirSync(dir, { recursive: true })
+    fs.writeFileSync(filePath, dataFile.content)
+  }
+}
+
+function deriveNamespace(filePath: string): string {
+  const basename = path.basename(filePath, path.extname(filePath))
+  return basename.toLowerCase().replace(/[^a-z0-9]/g, '_')
+}
+
+/**
+ * Reset the in-memory compile cache. Useful for testing.
+ */
+export function resetCompileCache(): void {
+  compiledCache.clear()
+}

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')
+}