redscript-mc 1.2.30 → 2.1.0

package/src/index.ts

@@ -1,205 +1,60 @@
 /**
  * RedScript Compiler
- * 
+ *
  * Main entry point for programmatic usage.
  */
 
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-export const version = '1.2.11'
+export const version = '2.0.0'
 
-import { Lexer } from './lexer'
-import { Parser } from './parser'
-import { TypeChecker } from './typechecker'
-import { Lowering, setScoreboardObjective } from './lowering'
-import type { Warning } from './lowering'
-import {
-  constantFoldingWithStats,
-  copyPropagation,
-  deadCodeEliminationWithStats,
-} from './optimizer/passes'
-import { eliminateDeadCode } from './optimizer/dce'
-import {
-  countMcfunctionCommands,
-  generateDatapackWithStats,
-  DatapackFile,
-} from './codegen/mcfunction'
-import { preprocessSource, preprocessSourceWithMetadata } from './compile'
-import type { IRModule } from './ir/types'
-import type { Program } from './ast/types'
-import type { DiagnosticError } from './diagnostics'
-import { createEmptyOptimizationStats, type OptimizationStats } from './optimizer/commands'
+import { compile } from './emit/compile'
 
-export interface CompileOptions {
-  namespace?: string
-  optimize?: boolean
-  typeCheck?: boolean
-  filePath?: string
-  dce?: boolean
-  mangle?: boolean
-  /** Scoreboard objective used for all variable slots.
-   *  Defaults to '__<namespace>' (e.g. '__mathshow') to avoid collisions when
-   *  multiple RedScript datapacks are loaded simultaneously, without occupying
-   *  the user's own namespace. Override only if you need a specific name. */
-  scoreboardObjective?: string
-}
-
-export interface CompileResult {
-  files: DatapackFile[]
-  advancements: DatapackFile[]
-  ast: Program
-  ir: IRModule
-  typeErrors?: DiagnosticError[]
-  warnings?: Warning[]
-  stats?: OptimizationStats
-  sourceMap?: Record<string, string>
-}
-
-/**
- * Compile RedScript source code to a Minecraft datapack.
- * 
- * @param source - The RedScript source code
- * @param options - Compilation options
- * @returns Compiled datapack files
- */
-export function compile(source: string, options: CompileOptions = {}): CompileResult {
-  const namespace = options.namespace ?? 'redscript'
-  const shouldOptimize = options.optimize ?? true
-  const shouldTypeCheck = options.typeCheck ?? true
-  const shouldRunDce = options.dce ?? shouldOptimize
-  const mangle = options.mangle ?? false
-  const filePath = options.filePath
-  const preprocessed = preprocessSourceWithMetadata(source, { filePath })
-  const preprocessedSource = preprocessed.source
-
-  // Lexing
-  const tokens = new Lexer(preprocessedSource, filePath).tokenize()
-
-  // Parsing — user source
-  const parsedAst = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
-
-  // Library imports: files that declared `module library;` are parsed independently
-  // (fresh Parser per file) so their functions are DCE-eligible but never bleed into user code.
-  const allLibrarySources: Array<{ src: string; fp?: string }> = []
-  for (const li of preprocessed.libraryImports ?? []) {
-    allLibrarySources.push({ src: li.source, fp: li.filePath })
-  }
-  for (const { src, fp } of allLibrarySources) {
-    const libPreprocessed = preprocessSourceWithMetadata(src, fp ? { filePath: fp } : {})
-    const libTokens = new Lexer(libPreprocessed.source, fp).tokenize()
-    const libAst = new Parser(libTokens, libPreprocessed.source, fp).parse(namespace)
-    for (const fn of libAst.declarations) fn.isLibraryFn = true
-    parsedAst.declarations.push(...libAst.declarations)
-    parsedAst.structs.push(...libAst.structs)
-    parsedAst.implBlocks.push(...libAst.implBlocks)
-    parsedAst.enums.push(...libAst.enums)
-    parsedAst.consts.push(...libAst.consts)
-    parsedAst.globals.push(...libAst.globals)
-  }
-
-  const dceResult = shouldRunDce ? eliminateDeadCode(parsedAst, preprocessed.ranges) : { program: parsedAst, warnings: [] }
-  const ast = dceResult.program
-
-  // Type checking (warn mode - collect errors but don't block)
-  let typeErrors: DiagnosticError[] | undefined
-  if (shouldTypeCheck) {
-    const checker = new TypeChecker(preprocessedSource, filePath)
-    typeErrors = checker.check(ast)
-  }
-
-  // Configure scoreboard objective for this compilation.
-  // Default: use the datapack namespace so each datapack gets its own objective
-  // automatically, preventing variable collisions when multiple datapacks coexist.
-  const scoreboardObj = options.scoreboardObjective ?? `__${namespace}`
-  setScoreboardObjective(scoreboardObj)
-
-  // Lowering to IR
-  const lowering = new Lowering(namespace, preprocessed.ranges)
-  const ir = lowering.lower(ast)
-
-  let optimizedIR: IRModule = ir
-  let generated = generateDatapackWithStats(ir, { optimizeCommands: shouldOptimize, mangle, scoreboardObjective: scoreboardObj })
-  let optimizationStats: OptimizationStats | undefined
-
-  if (shouldOptimize) {
-    const stats = createEmptyOptimizationStats()
-    const copyPropagatedFunctions = []
-    const deadCodeEliminatedFunctions = []
-
-    for (const fn of ir.functions) {
-      const folded = constantFoldingWithStats(fn)
-      stats.constantFolds += folded.stats.constantFolds ?? 0
+// Re-export v2 compile API
+export { compile, CompileOptions, CompileResult } from './emit/compile'
+export { compileModules } from './emit/modules'
+export type { ModuleInput, CompileModulesOptions, CompileModulesResult } from './emit/modules'
+export { McVersion, parseMcVersion, compareMcVersion, DEFAULT_MC_VERSION } from './types/mc-version'
+export type { DatapackFile } from './emit/index'
 
-      const propagated = copyPropagation(folded.fn)
-      copyPropagatedFunctions.push(propagated)
-
-      const dce = deadCodeEliminationWithStats(propagated)
-      deadCodeEliminatedFunctions.push(dce.fn)
-    }
-
-    const copyPropagatedIR: IRModule = { ...ir, functions: copyPropagatedFunctions }
-    optimizedIR = { ...ir, functions: deadCodeEliminatedFunctions }
-
-    const baselineGenerated = generateDatapackWithStats(ir, { optimizeCommands: false, mangle, scoreboardObjective: scoreboardObj })
-    const beforeDceGenerated = generateDatapackWithStats(copyPropagatedIR, { optimizeCommands: false, mangle, scoreboardObjective: scoreboardObj })
-    const afterDceGenerated = generateDatapackWithStats(optimizedIR, { optimizeCommands: false, mangle, scoreboardObjective: scoreboardObj })
-    generated = generateDatapackWithStats(optimizedIR, { optimizeCommands: true, mangle, scoreboardObjective: scoreboardObj })
+// Re-export utilities
+export { Lexer } from './lexer'
+export { Parser } from './parser'
+export { preprocessSource, preprocessSourceWithMetadata } from './compile'
+export { MCCommandValidator } from './mc-validator'
+export type { Program, FnDecl, Expr, Stmt, Span } from './ast/types'
+export type { DiagnosticError } from './diagnostics'
 
-    stats.deadCodeRemoved =
-      countMcfunctionCommands(beforeDceGenerated.files) - countMcfunctionCommands(afterDceGenerated.files)
-    stats.licmHoists = generated.stats.licmHoists
-    stats.licmLoopBodies = generated.stats.licmLoopBodies
-    stats.cseRedundantReads = generated.stats.cseRedundantReads
-    stats.cseArithmetic = generated.stats.cseArithmetic
-    stats.setblockMergedCommands = generated.stats.setblockMergedCommands
-    stats.setblockFillCommands = generated.stats.setblockFillCommands
-    stats.setblockSavedCommands = generated.stats.setblockSavedCommands
-    stats.totalCommandsBefore = countMcfunctionCommands(baselineGenerated.files)
-    stats.totalCommandsAfter = countMcfunctionCommands(generated.files)
-    optimizationStats = stats
-  } else {
-    optimizedIR = ir
-    generated = generateDatapackWithStats(ir, { optimizeCommands: false, mangle, scoreboardObjective: scoreboardObj })
-  }
+// Incremental compilation
+export { FileCache, hashFile } from './cache/index'
+export { DependencyGraph, parseImports } from './cache/deps'
+export { compileIncremental, resetCompileCache } from './cache/incremental'
+export type { IncrementalOptions, IncrementalResult } from './cache/incremental'
 
-  return {
-    files: [...generated.files, ...generated.advancements],
-    advancements: generated.advancements,
-    ast,
-    ir: optimizedIR,
-    typeErrors,
-    warnings: [...dceResult.warnings, ...lowering.warnings],
-    stats: optimizationStats,
-    sourceMap: generated.sourceMap,
-  }
+export interface CheckResult {
+  error: Error | null
+  warnings: string[]
 }
 
 /**
  * Check RedScript source code for errors without generating output.
- * 
+ * Runs the full compile pipeline (lex → parse → HIR → MIR → LIR → emit)
+ * to catch type-level and lowering errors, not just parse errors.
+ *
  * @param source - The RedScript source code
  * @param namespace - Optional namespace
  * @returns null if no errors, or an error object
  */
 export function check(source: string, namespace = 'redscript', filePath?: string): Error | null {
+  return checkWithWarnings(source, namespace, filePath).error
+}
+
+/**
+ * Like check(), but also returns warnings (e.g., tick budget analysis).
+ */
+export function checkWithWarnings(source: string, namespace = 'redscript', filePath?: string): CheckResult {
   try {
-    const preprocessedSource = preprocessSource(source, { filePath })
-    const tokens = new Lexer(preprocessedSource, filePath).tokenize()
-    new Parser(tokens, preprocessedSource, filePath).parse(namespace)
-    return null
+    const result = compile(source, { namespace, filePath })
+    return { error: null, warnings: result.warnings }
   } catch (err) {
-    return err as Error
+    return { error: err as Error, warnings: [] }
   }
 }
-
-// Re-export types and classes for advanced usage
-export { Lexer } from './lexer'
-export { Parser } from './parser'
-export { TypeChecker } from './typechecker'
-export { Lowering } from './lowering'
-export { optimize } from './optimizer/passes'
-export { generateDatapack } from './codegen/mcfunction'
-export { MCCommandValidator } from './mc-validator'
-export type { DatapackFile } from './codegen/mcfunction'
-export type { IRModule, IRFunction } from './ir/types'
-export type { Program, FnDecl, Expr, Stmt, Span } from './ast/types'
-export type { DiagnosticError } from './diagnostics'

package/src/lexer/index.ts

@@ -16,7 +16,7 @@ export type TokenKind =
   // Keywords
   | 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match'
   | 'return' | 'break' | 'continue' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace' | 'module'
-  | 'execute' | 'run' | 'unless' | 'declare'
+  | 'execute' | 'run' | 'unless' | 'declare' | 'export'
   // Types
   | 'int' | 'bool' | 'float' | 'string' | 'void'
   | 'BlockPos'
@@ -91,6 +91,7 @@ const KEYWORDS: Record<string, TokenKind> = {
   run: 'run',
   unless: 'unless',
   declare: 'declare',
+  export: 'export',
   int: 'int',
   bool: 'bool',
   float: 'float',

package/src/lir/budget.ts

@@ -0,0 +1,321 @@
+/**
+ * Static Tick Budget Analysis — Phase 1a
+ *
+ * Estimates the number of MC commands a function will execute at runtime.
+ * Used to warn when loops may exceed Minecraft's maxCommandChainLength (65536).
+ *
+ * In LIR, loops are represented as mutually-recursive function calls
+ * (e.g., fn__header ↔ fn__body). This module detects call-graph cycles
+ * and multiplies the loop body cost by an estimated iteration count.
+ */
+
+import type { LIRModule, LIRFunction, LIRInstr } from './types'
+
+/** Default estimated iteration count when the upper bound is unknown */
+const DEFAULT_LOOP_ITERATIONS = 100
+
+/** Warning threshold: suggest @coroutine */
+export const BUDGET_WARN_THRESHOLD = 32768
+
+/** Error threshold: likely exceeds maxCommandChainLength */
+export const BUDGET_ERROR_THRESHOLD = 65536
+
+export interface BudgetDiagnostic {
+  level: 'warning' | 'error'
+  fnName: string
+  estimatedCommands: number
+  message: string
+}
+
+// ---------------------------------------------------------------------------
+// Call graph utilities
+// ---------------------------------------------------------------------------
+
+/** Extract all function names called by an instruction */
+function getCalledFunctions(instr: LIRInstr): string[] {
+  switch (instr.kind) {
+    case 'call':
+    case 'call_macro':
+      return [instr.fn]
+    case 'call_if_matches':
+    case 'call_unless_matches':
+    case 'call_if_score':
+    case 'call_unless_score':
+    case 'call_context':
+      return [instr.fn]
+    case 'store_cmd_to_score':
+      // The nested cmd may also be a call
+      return getCalledFunctions(instr.cmd)
+    default:
+      return []
+  }
+}
+
+/** Build adjacency list: fnName → set of called function names (module-local only) */
+function buildCallGraph(mod: LIRModule): Map<string, Set<string>> {
+  const fnNames = new Set(mod.functions.map(f => f.name))
+  const graph = new Map<string, Set<string>>()
+
+  for (const fn of mod.functions) {
+    const callees = new Set<string>()
+    for (const instr of fn.instructions) {
+      for (const callee of getCalledFunctions(instr)) {
+        // Strip namespace prefix to match local function names
+        const local = stripNamespace(callee, mod.namespace)
+        if (fnNames.has(local)) {
+          callees.add(local)
+        }
+      }
+    }
+    graph.set(fn.name, callees)
+  }
+
+  return graph
+}
+
+/** Strip "namespace:" prefix from a qualified function name */
+function stripNamespace(qualifiedName: string, namespace: string): string {
+  const prefix = `${namespace}:`
+  if (qualifiedName.startsWith(prefix)) {
+    return qualifiedName.slice(prefix.length)
+  }
+  return qualifiedName
+}
+
+/** Find all strongly connected components (Tarjan's algorithm) */
+function findSCCs(graph: Map<string, Set<string>>): string[][] {
+  let index = 0
+  const stack: string[] = []
+  const onStack = new Set<string>()
+  const indices = new Map<string, number>()
+  const lowlinks = new Map<string, number>()
+  const sccs: string[][] = []
+
+  function strongconnect(v: string): void {
+    indices.set(v, index)
+    lowlinks.set(v, index)
+    index++
+    stack.push(v)
+    onStack.add(v)
+
+    for (const w of graph.get(v) ?? []) {
+      if (!indices.has(w)) {
+        strongconnect(w)
+        lowlinks.set(v, Math.min(lowlinks.get(v)!, lowlinks.get(w)!))
+      } else if (onStack.has(w)) {
+        lowlinks.set(v, Math.min(lowlinks.get(v)!, indices.get(w)!))
+      }
+    }
+
+    if (lowlinks.get(v) === indices.get(v)) {
+      const scc: string[] = []
+      let w: string
+      do {
+        w = stack.pop()!
+        onStack.delete(w)
+        scc.push(w)
+      } while (w !== v)
+      sccs.push(scc)
+    }
+  }
+
+  for (const v of graph.keys()) {
+    if (!indices.has(v)) {
+      strongconnect(v)
+    }
+  }
+
+  return sccs
+}
+
+// ---------------------------------------------------------------------------
+// Command count estimation
+// ---------------------------------------------------------------------------
+
+/** Count the number of MC commands an instruction generates (non-recursive) */
+function instrCommandCount(instr: LIRInstr): number {
+  switch (instr.kind) {
+    case 'store_cmd_to_score':
+      // The execute store wrapper + the inner command
+      return 1
+    default:
+      // Each LIR instruction maps to ~1 MC command
+      return 1
+  }
+}
+
+/** Count raw (non-call) commands in a function */
+function localCommandCount(fn: LIRFunction): number {
+  let count = 0
+  for (const instr of fn.instructions) {
+    count += instrCommandCount(instr)
+  }
+  return count
+}
+
+/**
+ * Try to extract a constant loop bound from a loop's LIR functions.
+ *
+ * Looks for patterns like:
+ *   score_set <limit_slot> <N>
+ * in the cycle's functions, where N is used as a comparison bound.
+ *
+ * Returns the bound if found, otherwise DEFAULT_LOOP_ITERATIONS.
+ */
+function estimateLoopIterations(cycleFns: LIRFunction[]): number {
+  // Look for score_set instructions that might be loop bounds
+  // Heuristic: find the largest constant set in the cycle's callers
+  // that looks like a loop limit (typically set before the loop)
+  for (const fn of cycleFns) {
+    for (const instr of fn.instructions) {
+      if (instr.kind === 'call_if_matches' || instr.kind === 'call_unless_matches') {
+        // Parse range like "..999" or "0..999" to extract upper bound
+        const range = instr.range
+        const match = range.match(/\.\.(\d+)/)
+        if (match) {
+          return parseInt(match[1], 10) + 1
+        }
+      }
+    }
+  }
+
+  return DEFAULT_LOOP_ITERATIONS
+}
+
+/**
+ * Estimate the total command count for a function, including callees.
+ *
+ * @param fnName - Name of the function to estimate
+ * @param mod - The LIR module
+ * @returns Estimated number of MC commands
+ */
+export function estimateCommandCount(fnName: string, mod: LIRModule): number {
+  const fnMap = new Map<string, LIRFunction>()
+  for (const fn of mod.functions) {
+    fnMap.set(fn.name, fn)
+  }
+
+  const callGraph = buildCallGraph(mod)
+  const sccs = findSCCs(callGraph)
+
+  // Map each function to its SCC
+  const fnToSCC = new Map<string, string[]>()
+  for (const scc of sccs) {
+    for (const name of scc) {
+      fnToSCC.set(name, scc)
+    }
+  }
+
+  // Memoize estimated counts
+  const memo = new Map<string, number>()
+
+  function estimate(name: string, visiting: Set<string>): number {
+    if (memo.has(name)) return memo.get(name)!
+
+    const fn = fnMap.get(name)
+    if (!fn) return 0
+
+    // Detect cycle: if we're already visiting this function, return 0
+    // (cycle cost is handled at the SCC level)
+    if (visiting.has(name)) return 0
+
+    visiting.add(name)
+
+    const scc = fnToSCC.get(name)!
+    const isCyclic = scc.length > 1 || (scc.length === 1 && callGraph.get(name)?.has(name))
+
+    if (isCyclic) {
+      // Sum local commands across all functions in the cycle
+      let cycleLocalCost = 0
+      for (const member of scc) {
+        const memberFn = fnMap.get(member)
+        if (memberFn) cycleLocalCost += localCommandCount(memberFn)
+      }
+
+      // Estimate iterations
+      const cycleFns = scc.map(n => fnMap.get(n)!).filter(Boolean)
+      const iterations = estimateLoopIterations(cycleFns)
+
+      // Also add cost of non-cycle callees
+      let externalCalleeCost = 0
+      for (const member of scc) {
+        for (const callee of callGraph.get(member) ?? []) {
+          if (!scc.includes(callee)) {
+            externalCalleeCost += estimate(callee, new Set(visiting))
+          }
+        }
+      }
+
+      const total = (cycleLocalCost + externalCalleeCost) * iterations
+      // Memoize for all members of this SCC
+      for (const member of scc) {
+        memo.set(member, total)
+      }
+      visiting.delete(name)
+      return total
+    }
+
+    // Non-cyclic: local cost + callee costs
+    let total = localCommandCount(fn)
+    for (const callee of callGraph.get(name) ?? []) {
+      total += estimate(callee, visiting)
+    }
+
+    memo.set(name, total)
+    visiting.delete(name)
+    return total
+  }
+
+  return estimate(fnName, new Set())
+}
+
+// ---------------------------------------------------------------------------
+// Budget analysis for a full module
+// ---------------------------------------------------------------------------
+
+/**
+ * Analyze all "top-level" functions in the module for tick budget violations.
+ *
+ * @param mod - The LIR module to analyze
+ * @param coroutineFunctions - Set of function names marked @coroutine (skip these)
+ * @returns Array of budget diagnostics (warnings and errors)
+ */
+export function analyzeBudget(
+  mod: LIRModule,
+  coroutineFunctions: Set<string> = new Set(),
+): BudgetDiagnostic[] {
+  const diagnostics: BudgetDiagnostic[] = []
+
+  // Only analyze user-defined "root" functions, not compiler-generated helper blocks
+  // Helper blocks have names like "fnname__blockid"
+  for (const fn of mod.functions) {
+    // Skip coroutine-annotated functions
+    if (coroutineFunctions.has(fn.name)) continue
+
+    // Skip compiler-generated helper functions (contain __)
+    if (fn.name.includes('__')) continue
+
+    // Skip coroutine-generated functions
+    if (fn.name.startsWith('_coro_')) continue
+
+    const estimated = estimateCommandCount(fn.name, mod)
+
+    if (estimated > BUDGET_ERROR_THRESHOLD) {
+      diagnostics.push({
+        level: 'error',
+        fnName: fn.name,
+        estimatedCommands: estimated,
+        message: `function '${fn.name}' may exceed tick budget (~${estimated} commands), this will likely crash. Consider @coroutine or reducing loop iterations`,
+      })
+    } else if (estimated > BUDGET_WARN_THRESHOLD) {
+      diagnostics.push({
+        level: 'warning',
+        fnName: fn.name,
+        estimatedCommands: estimated,
+        message: `loop may exceed tick budget (~${estimated} commands), consider @coroutine`,
+      })
+    }
+  }
+
+  return diagnostics
+}