redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/watch-decorator.test.ts

@@ -0,0 +1,59 @@
+import { compile } from '../emit/compile'
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { TypeChecker } from '../typechecker'
+import type { DiagnosticError } from '../diagnostics'
+
+function getFile(files: Array<{ path: string; content: string }>, path: string): string {
+  const file = files.find(entry => entry.path === path)
+  if (!file) {
+    throw new Error(`Missing file: ${path}\nFiles:\n${files.map(entry => entry.path).join('\n')}`)
+  }
+  return file.content
+}
+
+function typeCheck(source: string): DiagnosticError[] {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  return new TypeChecker(source).check(ast)
+}
+
+describe('@watch decorator', () => {
+  test('typechecker accepts parameterless handlers and rejects parameters', () => {
+    expect(typeCheck(`
+      @watch("rs.kills")
+      fn on_kill() {
+        say("kill");
+      }
+    `)).toHaveLength(0)
+
+    const errors = typeCheck(`
+      @watch("rs.kills")
+      fn on_kill(player: Player) {}
+    `)
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('cannot declare parameters')
+  })
+
+  test('emits watcher objective, dispatcher, and tick registration', () => {
+    const result = compile(`
+      @watch("rs.kills")
+      fn on_kill() {
+        let k: int = scoreboard_get("@s", "rs.kills");
+        if (k >= 10) {
+          title("@s", "Achievement Unlocked!");
+        }
+      }
+    `, { namespace: 'watch_test' })
+
+    const load = getFile(result.files, 'data/watch_test/function/load.mcfunction')
+    const tick = JSON.parse(getFile(result.files, 'data/minecraft/tags/function/tick.json'))
+    const watch = getFile(result.files, 'data/watch_test/function/__watch_on_kill.mcfunction')
+
+    expect(load).toContain('scoreboard objectives add __watch_on_kill_prev dummy')
+    expect(tick.values).toContain('watch_test:__watch_on_kill')
+    expect(watch).toContain('execute as @a unless score @s __watch_on_kill_prev = @s __watch_on_kill_prev run scoreboard players operation @s __watch_on_kill_prev = @s rs.kills')
+    expect(watch).toContain('execute as @a unless score @s rs.kills = @s __watch_on_kill_prev run function watch_test:on_kill')
+    expect(watch).toContain('execute as @a unless score @s rs.kills = @s __watch_on_kill_prev run scoreboard players operation @s __watch_on_kill_prev = @s rs.kills')
+  })
+})

package/src/ast/types.ts

@@ -175,10 +175,12 @@ export type Expr =
   | { kind: 'array_lit';  elements: Expr[]; span?: Span }
   | { kind: 'static_call'; type: string; method: string; args: Expr[]; span?: Span }
   | { kind: 'path_expr'; enumName: string; variant: string; span?: Span }
+  | { kind: 'enum_construct'; enumName: string; variant: string; args: { name: string; value: Expr }[]; span?: Span }
   | (LambdaExpr & { span?: Span })
   | { kind: 'tuple_lit'; elements: Expr[]; span?: Span }
   | { kind: 'some_lit'; value: Expr; span?: Span }  // Some(expr)
   | { kind: 'none_lit'; span?: Span }               // None
+  | { kind: 'unwrap_or'; opt: Expr; default_: Expr; span?: Span }  // opt.unwrap_or(default)
   | { kind: 'type_cast'; expr: Expr; targetType: TypeNode; span?: Span }  // expr as Type
 
 export type LiteralExpr =
@@ -233,16 +235,23 @@ export type MatchPattern =
   | { kind: 'PatInt'; value: number }      // 1, 2, 3
   | { kind: 'PatWild' }                    // _
   | { kind: 'PatExpr'; expr: Expr }        // legacy: range_lit or other expr
+  | { kind: 'PatEnum'; enumName: string; variant: string; bindings: string[] }  // Color::RGB(r, g, b)
 
 export type Stmt =
   | { kind: 'let';        name: string; type?: TypeNode; init: Expr; span?: Span }
   | { kind: 'let_destruct'; names: string[]; type?: TypeNode; init: Expr; span?: Span }
+  | { kind: 'const_decl'; name: string; type: TypeNode; value: Expr; span?: Span }
   | { kind: 'expr';       expr: Expr; span?: Span }
   | { kind: 'return';     value?: Expr; span?: Span }
   | { kind: 'break';      span?: Span }
   | { kind: 'continue';   span?: Span }
+  | { kind: 'break_label'; label: string; span?: Span }
+  | { kind: 'continue_label'; label: string; span?: Span }
+  | { kind: 'labeled_loop'; label: string; body: Stmt; span?: Span }
   | { kind: 'if';         cond: Expr; then: Block; else_?: Block; span?: Span }
   | { kind: 'while';      cond: Expr; body: Block; span?: Span }
+  | { kind: 'do_while';   cond: Expr; body: Block; span?: Span }
+  | { kind: 'repeat';     count: number; body: Block; span?: Span }
   | { kind: 'for';        init?: Stmt; cond: Expr; step: Expr; body: Block; span?: Span }
   | { kind: 'foreach';    binding: string; iterable: Expr; body: Block; executeContext?: string; span?: Span }
   | { kind: 'for_range';  varName: string; start: Expr; end: Expr; inclusive?: boolean; body: Block; span?: Span }
@@ -250,6 +259,7 @@ export type Stmt =
   | { kind: 'for_each';    binding: string; array: Expr; body: Block; span?: Span }
   | { kind: 'match';      expr: Expr; arms: { pattern: MatchPattern; body: Block }[]; span?: Span }
   | { kind: 'if_let_some'; binding: string; init: Expr; then: Block; else_?: Block; span?: Span }
+  | { kind: 'while_let_some'; binding: string; init: Expr; body: Block; span?: Span }
   | { kind: 'as_block';   selector: EntitySelector; body: Block; span?: Span }
   | { kind: 'at_block';   selector: EntitySelector; body: Block; span?: Span }
   | { kind: 'as_at';      as_sel: EntitySelector; at_sel: EntitySelector; body: Block; span?: Span }
@@ -263,9 +273,10 @@ export type Block = Stmt[]
 // ---------------------------------------------------------------------------
 
 export interface Decorator {
-  name: 'tick' | 'load' | 'on' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team' | 'keep' | 'require_on_load' | 'coroutine' | 'schedule'
+  name: 'tick' | 'load' | 'watch' | 'on' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team' | 'keep' | 'require_on_load' | 'coroutine' | 'schedule' | 'deprecated' | 'inline' | 'no-inline' | 'config' | 'singleton' | 'profile' | 'throttle' | 'retry' | 'memoize' | 'test'
   args?: {
     rate?: number
+    objective?: string
     eventType?: string
     trigger?: string
     advancement?: string
@@ -274,6 +285,16 @@ export interface Decorator {
     batch?: number
     onDone?: string
     ticks?: number
+    /** @deprecated decorator message */
+    message?: string
+    /** @config decorator: config key name */
+    configKey?: string
+    /** @config decorator: default value */
+    configDefault?: number
+    /** @retry decorator: max retry count */
+    max?: number
+    /** @test decorator: human-readable test label */
+    testLabel?: string
   }
   /** Raw positional arguments (used by @requires and future generic decorators). */
   rawArgs?: Array<{ kind: 'string'; value: string } | { kind: 'number'; value: number }>
@@ -296,6 +317,8 @@ export interface FnDecl {
   isLibraryFn?: boolean
   /** True when declared with `export fn` or `@keep fn` — survives DCE. */
   isExported?: boolean
+  /** Scoreboard objective watched by @watch("..."), if present. */
+  watchObjective?: string
   name: string
   /** Generic type parameter names, e.g. ['T'] for fn foo<T>(...) */
   typeParams?: string[]
@@ -304,6 +327,7 @@ export interface FnDecl {
   decorators: Decorator[]
   body: Block
   span?: Span
+  sourceFile?: string
 }
 
 // ---------------------------------------------------------------------------
@@ -317,20 +341,51 @@ export interface StructField {
 
 export interface StructDecl {
   name: string
+  extends?: string
   fields: StructField[]
+  /** True when the struct was declared with `@singleton` */
+  isSingleton?: boolean
   span?: Span
 }
 
 export interface ImplBlock {
   kind: 'impl_block'
   typeName: string
+  /** Trait name when declared as `impl TraitName for TypeName` (e.g. "Display") */
+  traitName?: string
   methods: FnDecl[]
   span?: Span
 }
 
+// ---------------------------------------------------------------------------
+// Interface / Trait Declarations
+// ---------------------------------------------------------------------------
+
+/** A method signature in an interface body (no body) */
+export interface InterfaceMethod {
+  name: string
+  params: Param[]
+  returnType?: TypeNode
+  span?: Span
+}
+
+/** `interface Drawable { fn draw(self, x: int, y: int) ... }` */
+export interface InterfaceDecl {
+  name: string
+  methods: InterfaceMethod[]
+  span?: Span
+}
+
+export interface EnumPayloadField {
+  name: string
+  type: TypeNode
+}
+
 export interface EnumVariant {
   name: string
   value?: number
+  /** Payload fields for tuple-like variants, e.g. RGB(r: int, g: int, b: int) */
+  fields?: EnumPayloadField[]
 }
 
 export interface EnumDecl {
@@ -352,6 +407,10 @@ export interface GlobalDecl {
   type: TypeNode
   init: Expr
   mutable: boolean  // let = true, const = false
+  /** Present when the global was declared with @config("key", default: value) */
+  configKey?: string
+  /** Default value for @config globals */
+  configDefault?: number
   span?: Span
 }
 
@@ -362,8 +421,9 @@ export interface GlobalDecl {
 export interface ImportDecl {
   /** The module being imported from, e.g. "math" in `import math::sin` */
   moduleName: string
-  /** The symbol being imported, or '*' for wildcard */
-  symbol: string   // '*' | identifier
+  /** The symbol being imported, or '*' for wildcard.
+   *  Undefined when this is a whole-module file import (`import player_utils`). */
+  symbol?: string   // '*' | identifier | undefined (whole-module import)
   span?: Span
 }
 
@@ -383,6 +443,8 @@ export interface Program {
   consts: ConstDecl[]
   /** Phase 5b: module imports (`import math::sin;`) */
   imports: ImportDecl[]
+  /** Interface / trait declarations */
+  interfaces: InterfaceDecl[]
   /** True when the source file declares `module library;`.
    *  Library-mode: all functions are DCE-eligible by default — none are treated
    *  as MC entry points unless they carry @tick / @load / @on / @keep etc. */

package/src/cache/incremental.ts

@@ -1,18 +1,23 @@
 /**
- * Incremental compilation — only recompile files whose content (or
- * dependencies) has changed since the last build.
+ * Incremental compilation — only recompile files whose content, imports,
+ * or reverse dependents changed since the last build.
  */
 
+import * as fs from 'fs'
 import * as path from 'path'
 import { compile, type CompileOptions, type CompileResult } from '../emit/compile'
-import * as fs from 'fs'
+import type { DatapackFile } from '../emit'
 import { FileCache } from './index'
-import { DependencyGraph } from './deps'
+import { DependencyGraph, parseImports } from './deps'
 
 export interface IncrementalOptions {
   namespace?: string
   /** Output directory for compiled files. */
   output: string
+  generateSourceMap?: boolean
+  mcVersion?: CompileOptions['mcVersion']
+  lenient?: boolean
+  includeDirs?: string[]
 }
 
 export interface IncrementalResult {
@@ -24,135 +29,149 @@ export interface IncrementalResult {
   errors: Map<string, string>
   /** Per-file compile results (only for recompiled files). */
   results: Map<string, CompileResult>
+  /** Files skipped due to cache hit. */
+  skippedFiles: string[]
+  /** Files rebuilt in this run. */
+  rebuiltFiles: string[]
+  /** Elapsed wall time for this run. */
+  elapsedMs: number
 }
 
-/** 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 start = Date.now()
+  const normalizedEntries = [...new Set(files.map(file => path.resolve(file)))]
   const result: IncrementalResult = {
     recompiled: 0,
     cached: 0,
     errors: new Map(),
     results: new Map(),
+    skippedFiles: [],
+    rebuiltFiles: [],
+    elapsedMs: 0,
   }
 
-  // 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)
-    }
+  if (normalizedEntries.length === 0) {
+    result.elapsedMs = Date.now() - start
+    return result
   }
 
-  // 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)
+  depGraph.clear()
+  const discoveredFiles = discoverDependencyGraph(normalizedEntries, depGraph)
+  const changedFiles = new Set<string>()
+
+  for (const file of discoveredFiles) {
+    if (cache.hasChanged(file)) changedFiles.add(file)
   }
 
-  for (const sourceFile of allSourceFiles) {
-    if (cache.hasChanged(sourceFile)) {
-      changedSourceFiles.add(sourceFile)
-    }
+  const dirtyFiles = depGraph.computeDirtySet(changedFiles)
+  for (const entry of normalizedEntries) {
+    if (!discoveredFiles.has(entry)) dirtyFiles.add(entry)
   }
 
-  // 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
-      }
-    }
+  for (const entryFile of normalizedEntries) {
+    const entryDeps = depGraph.getTransitiveDeps(entryFile)
+    const entryUnit = new Set([entryFile, ...entryDeps])
+    const cachedEntry = cache.get(entryFile)
+    const cachedDepList = new Set(cachedEntry?.dependencies ?? [])
 
-    if (!needsRecompile) {
-      // Cache hit — write cached result to output
-      const cached = compiledCache.get(absFile)!
-      writeBuildOutput(cached.result, options.output)
+    const hasDependencyDrift =
+      cachedDepList.size !== entryUnit.size ||
+      [...entryUnit].some(file => !cachedDepList.has(file))
+
+    const canUseCache =
+      !dirtyFiles.has(entryFile) &&
+      !hasDependencyDrift &&
+      !!cachedEntry?.outputFiles &&
+      cachedEntry.outputFiles.length > 0
+
+    if (canUseCache) {
+      writeBuildOutput(cachedEntry.outputFiles!, options.output)
       result.cached++
+      result.skippedFiles.push(entryFile)
       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)
+      const source = fs.readFileSync(entryFile, 'utf-8')
+      const ns = options.namespace ?? deriveNamespace(entryFile)
+      const compileResult = compile(source, {
+        namespace: ns,
+        filePath: entryFile,
+        generateSourceMap: options.generateSourceMap,
+        mcVersion: options.mcVersion,
+        lenient: options.lenient,
+        includeDirs: options.includeDirs,
+      })
+      const outputFiles = cloneFiles(compileResult.files)
+      const compiledFunctions = outputFiles
+        .filter(file => file.path.endsWith('.mcfunction'))
+        .map(file => file.path)
+
+      removeStaleOutputs(cachedEntry?.outputFiles ?? [], outputFiles, options.output)
+
+      for (const file of entryUnit) {
+        cache.update(file)
+      }
+
+      const entryRecord = cache.get(entryFile)
+      if (entryRecord) {
+        entryRecord.compiledFunctions = compiledFunctions
+        entryRecord.outputFiles = outputFiles
+        entryRecord.dependencies = [...entryUnit].sort()
       }
 
-      compiledCache.set(absFile, { result: compileResult, depHashes })
-      writeBuildOutput(compileResult, options.output)
+      writeBuildOutput(outputFiles, options.output)
 
       result.recompiled++
-      result.results.set(absFile, compileResult)
+      result.results.set(entryFile, compileResult)
+      result.rebuiltFiles.push(entryFile)
     } catch (err) {
-      result.errors.set(absFile, (err as Error).message)
+      result.errors.set(entryFile, (err as Error).message)
     }
   }
 
+  cache.save()
+  result.elapsedMs = Date.now() - start
   return result
 }
 
+function discoverDependencyGraph(entries: string[], depGraph: DependencyGraph): Set<string> {
+  const visited = new Set<string>()
+  const queue = [...entries]
+
+  while (queue.length > 0) {
+    const current = path.resolve(queue.shift()!)
+    if (visited.has(current)) continue
+    visited.add(current)
+
+    try {
+      const source = fs.readFileSync(current, 'utf-8')
+      depGraph.addFile(current, source)
+      const imports = parseImports(current, source)
+      for (const imported of imports) {
+        if (!visited.has(imported)) queue.push(imported)
+      }
+    } catch {
+      depGraph.removeFile(current)
+    }
+  }
+
+  return visited
+}
+
+function cloneFiles(files: DatapackFile[]): DatapackFile[] {
+  return files.map(file => ({ path: file.path, content: file.content }))
+}
+
 /** Write compile output files to the output directory. */
-function writeBuildOutput(compileResult: CompileResult, output: string): void {
+function writeBuildOutput(files: DatapackFile[], output: string): void {
   fs.mkdirSync(output, { recursive: true })
-  for (const dataFile of compileResult.files) {
+  for (const dataFile of files) {
     const filePath = path.join(output, dataFile.path)
     const dir = path.dirname(filePath)
     fs.mkdirSync(dir, { recursive: true })
@@ -160,14 +179,24 @@ function writeBuildOutput(compileResult: CompileResult, output: string): void {
   }
 }
 
+function removeStaleOutputs(
+  previousFiles: DatapackFile[],
+  nextFiles: DatapackFile[],
+  output: string,
+): void {
+  if (previousFiles.length === 0) return
+  const nextPaths = new Set(nextFiles.map(file => file.path))
+
+  for (const oldFile of previousFiles) {
+    if (nextPaths.has(oldFile.path)) continue
+    const targetPath = path.join(output, oldFile.path)
+    if (fs.existsSync(targetPath)) fs.rmSync(targetPath, { force: true })
+  }
+}
+
 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()
-}
+export function resetCompileCache(): void {}

package/src/cache/index.ts

@@ -1,24 +1,39 @@
 /**
  * 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.
+ * Stores per-file content hashes and optional cached output payloads.
+ * Persists to `.redscript-cache/cache.json`.
  */
 
 import * as fs from 'fs'
 import * as path from 'path'
 import * as crypto from 'crypto'
 import type { HIRModule } from '../hir/types'
+import type { DatapackFile } from '../emit'
+
+export interface CachedOutputFile extends DatapackFile {}
 
 export interface CacheEntry {
   hash: string
   mtime: number
   hir?: HIRModule
+  compiledFunctions?: string[]
+  outputFiles?: CachedOutputFile[]
+  dependencies?: string[]
 }
 
 interface SerializedCache {
-  version: 1
-  entries: Record<string, { hash: string; mtime: number }>
+  version: 2
+  entries: Record<
+    string,
+    {
+      hash: string
+      mtime: number
+      compiledFunctions?: string[]
+      outputFiles?: CachedOutputFile[]
+      dependencies?: string[]
+    }
+  >
 }
 
 export class FileCache {
@@ -102,12 +117,18 @@ export class FileCache {
   save(): void {
     fs.mkdirSync(this.cacheDir, { recursive: true })
     const serialized: SerializedCache = {
-      version: 1,
+      version: 2,
       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 }
+      serialized.entries[filePath] = {
+        hash: entry.hash,
+        mtime: entry.mtime,
+        compiledFunctions: entry.compiledFunctions,
+        outputFiles: entry.outputFiles,
+        dependencies: entry.dependencies,
+      }
     }
     const cachePath = path.join(this.cacheDir, 'cache.json')
     fs.writeFileSync(cachePath, JSON.stringify(serialized, null, 2))
@@ -118,9 +139,15 @@ export class FileCache {
     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
+      if (data.version !== 2) return
       for (const [filePath, entry] of Object.entries(data.entries)) {
-        this.entries.set(filePath, { hash: entry.hash, mtime: entry.mtime })
+        this.entries.set(filePath, {
+          hash: entry.hash,
+          mtime: entry.mtime,
+          compiledFunctions: entry.compiledFunctions,
+          outputFiles: entry.outputFiles,
+          dependencies: entry.dependencies,
+        })
       }
     } catch {
       // No cache or corrupt — start fresh