redscript-mc 1.2.30 → 2.1.0

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

package/src/emit/compile.ts

@@ -0,0 +1,177 @@
+/**
+ * Top-level compile function for the v2 pipeline.
+ *
+ * Pipeline: source → Lexer → Parser → TypeCheck → HIR → MIR → optimize → LIR → emit
+ */
+
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { preprocessSourceWithMetadata } from '../compile'
+import { DiagnosticError, parseErrorMessage } from '../diagnostics'
+import { lowerToHIR } from '../hir/lower'
+import { monomorphize } from '../hir/monomorphize'
+import { lowerToMIR } from '../mir/lower'
+import { optimizeModule } from '../optimizer/pipeline'
+import { lowerToLIR } from '../lir/lower'
+import { lirOptimizeModule } from '../optimizer/lir/pipeline'
+import { emit, type DatapackFile } from './index'
+import { coroutineTransform, type CoroutineInfo } from '../optimizer/coroutine'
+import { analyzeBudget } from '../lir/budget'
+import { McVersion, DEFAULT_MC_VERSION } from '../types/mc-version'
+import { TypeChecker } from '../typechecker'
+
+export interface CompileOptions {
+  namespace?: string
+  filePath?: string
+  /** v1 compat: inline library sources (treated as `module library;` imports) */
+  librarySources?: string[]
+  /** When true, generate .sourcemap.json files alongside .mcfunction output */
+  generateSourceMap?: boolean
+  /** Target Minecraft version (default: 1.21). Affects which MC features are used. */
+  mcVersion?: McVersion
+  /**
+   * When true, type errors are reported as warnings instead of blocking compilation.
+   * Use for gradual migration or testing with existing codebases that have type errors.
+   */
+  lenient?: boolean
+}
+
+export interface CompileResult {
+  files: DatapackFile[]
+  warnings: string[]
+  /** Always true — v1 compat shim (compile() throws on error) */
+  readonly success: true
+}
+
+export function compile(source: string, options: CompileOptions = {}): CompileResult {
+  const { namespace = 'redscript', filePath, generateSourceMap = false, mcVersion = DEFAULT_MC_VERSION, lenient = false } = options
+  const warnings: string[] = []
+
+  // Preprocess: resolve import directives, merge imported sources
+  const preprocessed = preprocessSourceWithMetadata(source, { filePath })
+  const processedSource = preprocessed.source
+
+  // Stage 1: Lex + Parse → AST
+  const lexer = new Lexer(processedSource)
+  const tokens = lexer.tokenize()
+  const parser = new Parser(tokens, processedSource, filePath)
+  const ast = parser.parse(namespace)
+
+  // Merge library imports (files with `module library;`) into AST
+  for (const li of preprocessed.libraryImports ?? []) {
+    const libPreprocessed = preprocessSourceWithMetadata(li.source, { filePath: li.filePath })
+    const libTokens = new Lexer(libPreprocessed.source, li.filePath).tokenize()
+    const libAst = new Parser(libTokens, libPreprocessed.source, li.filePath).parse(namespace)
+    for (const fn of libAst.declarations) fn.isLibraryFn = true
+    ast.declarations.push(...libAst.declarations)
+    ast.structs.push(...libAst.structs)
+    ast.implBlocks.push(...libAst.implBlocks)
+    ast.enums.push(...libAst.enums)
+    ast.consts.push(...libAst.consts)
+    ast.globals.push(...libAst.globals)
+  }
+
+  // Merge librarySources (v1 compat: inline library strings) before HIR
+  if (options.librarySources) {
+    for (const libSrc of options.librarySources) {
+      const libTokens = new Lexer(libSrc).tokenize()
+      const libAst = new Parser(libTokens, libSrc).parse(namespace)
+      for (const fn of libAst.declarations) fn.isLibraryFn = true
+      ast.declarations.push(...libAst.declarations)
+      ast.structs.push(...libAst.structs)
+      ast.implBlocks.push(...libAst.implBlocks)
+      ast.enums.push(...libAst.enums)
+      ast.consts.push(...libAst.consts)
+      ast.globals.push(...libAst.globals)
+    }
+  }
+
+  // Stage 1b: Type checking
+  // Run TypeChecker on the merged AST. In error-mode (default), throw on first type error.
+  // In lenient mode, demote type errors to warnings.
+  {
+    const checker = new TypeChecker(processedSource, filePath)
+    const typeErrors = checker.check(ast)
+    if (typeErrors.length > 0) {
+      if (lenient) {
+        for (const e of typeErrors) {
+          warnings.push(`[TypeError] line ${e.location.line}, col ${e.location.col}: ${e.message}`)
+        }
+      } else {
+        throw typeErrors[0]
+      }
+    }
+  }
+
+  // Stage 2–7: lower, optimize, emit
+  // Wrap non-DiagnosticError from later stages so CLI always gets structured errors.
+  try {
+    // Stage 2: AST → HIR
+    const hirRaw = lowerToHIR(ast)
+
+    // Stage 2b: Monomorphize generic functions
+    const hir = monomorphize(hirRaw)
+
+    // Extract @tick, @load, @coroutine, and @schedule functions from HIR (before decorator info is lost)
+    const tickFunctions: string[] = []
+    const loadFunctions: string[] = []
+    const coroutineInfos: CoroutineInfo[] = []
+    const scheduleFunctions: Array<{ name: string; ticks: number }> = []
+    for (const fn of hir.functions) {
+      for (const dec of fn.decorators) {
+        if (dec.name === 'tick') tickFunctions.push(fn.name)
+        if (dec.name === 'load') loadFunctions.push(fn.name)
+        if (dec.name === 'coroutine') {
+          coroutineInfos.push({
+            fnName: fn.name,
+            batch: dec.args?.batch ?? 10,
+            onDone: dec.args?.onDone,
+          })
+        }
+        if (dec.name === 'schedule') {
+          scheduleFunctions.push({ name: fn.name, ticks: dec.args?.ticks ?? 1 })
+        }
+      }
+    }
+
+    // Stage 3: HIR → MIR
+    const mir = lowerToMIR(hir, filePath)
+
+    // Stage 4: MIR optimization
+    const mirOpt = optimizeModule(mir)
+
+    // Stage 4b: Coroutine transform (opt-in, only for @coroutine functions)
+    const coroResult = coroutineTransform(mirOpt, coroutineInfos)
+    const mirFinal = coroResult.module
+    tickFunctions.push(...coroResult.generatedTickFunctions)
+
+    // Stage 5: MIR → LIR
+    const lir = lowerToLIR(mirFinal)
+
+    // Stage 6: LIR optimization
+    const lirOpt = lirOptimizeModule(lir)
+
+    // Static tick budget analysis
+    const coroutineNames = new Set(coroutineInfos.map(c => c.fnName))
+    const budgetDiags = analyzeBudget(lirOpt, coroutineNames)
+    for (const diag of budgetDiags) {
+      if (diag.level === 'error') {
+        throw new DiagnosticError(
+          'LoweringError',
+          diag.message,
+          { line: 1, col: 1, file: filePath },
+        )
+      }
+      warnings.push(diag.message)
+    }
+
+    // Stage 7: LIR → .mcfunction
+    const files = emit(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions, generateSourceMap, mcVersion })
+
+    return { files, warnings, success: true as const }
+  } catch (err) {
+    if (err instanceof DiagnosticError) throw err
+    const sourceLines = processedSource.split('\n')
+    throw parseErrorMessage('LoweringError', (err as Error).message, sourceLines, filePath)
+  }
+}

package/src/emit/index.ts

@@ -0,0 +1,286 @@
+/**
+ * Stage 7 — LIR → .mcfunction Emission
+ *
+ * Converts a LIRModule into DatapackFile[] representing a Minecraft datapack.
+ * Each LIRFunction becomes a .mcfunction file under data/<ns>/function/.
+ */
+
+import type { LIRModule, LIRFunction, LIRInstr, Slot, CmpOp, ExecuteSubcmd } from '../lir/types'
+import { SourceMapBuilder, serializeSourceMap, sourceMapPath } from './sourcemap'
+import { McVersion, DEFAULT_MC_VERSION } from '../types/mc-version'
+
+export interface DatapackFile {
+  path: string
+  content: string
+}
+
+export interface EmitOptions {
+  namespace: string
+  tickFunctions?: string[]
+  loadFunctions?: string[]
+  scheduleFunctions?: Array<{ name: string; ticks: number }>
+  /** When true, generate a .sourcemap.json sidecar file for each .mcfunction */
+  generateSourceMap?: boolean
+  /** Target Minecraft version; controls which MC features are used in codegen */
+  mcVersion?: McVersion
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export function emit(module: LIRModule, options: EmitOptions): DatapackFile[] {
+  const { namespace } = options
+  const tickFns = options.tickFunctions ?? []
+  const loadFns = options.loadFunctions ?? []
+  const scheduleFns = options.scheduleFunctions ?? []
+  const objective = module.objective
+  const genSourceMap = options.generateSourceMap ?? false
+  const mcVersion = options.mcVersion ?? DEFAULT_MC_VERSION
+  const files: DatapackFile[] = []
+
+  // pack.mcmeta
+  files.push({
+    path: 'pack.mcmeta',
+    content: JSON.stringify({
+      pack: { pack_format: 26, description: `RedScript datapack: ${namespace}` },
+    }, null, 2) + '\n',
+  })
+
+  // load.mcfunction — creates the scoreboard objective
+  const loadCmds = [`scoreboard objectives add ${objective} dummy`]
+  files.push({
+    path: `data/${namespace}/function/load.mcfunction`,
+    content: loadCmds.join('\n') + '\n',
+  })
+
+  // Each LIR function → .mcfunction file
+  for (const fn of module.functions) {
+    const fnPath = fnNameToPath(fn.name, namespace)
+    if (genSourceMap) {
+      const builder = new SourceMapBuilder(fnPath)
+      const lines = emitFunctionWithSourceMap(fn, namespace, objective, builder, mcVersion)
+      files.push({ path: fnPath, content: lines.join('\n') + '\n' })
+      const map = builder.build()
+      if (map) {
+        files.push({ path: sourceMapPath(fnPath), content: serializeSourceMap(map) })
+      }
+    } else {
+      const lines = emitFunction(fn, namespace, objective, mcVersion)
+      files.push({ path: fnPath, content: lines.join('\n') + '\n' })
+    }
+  }
+
+  // @schedule wrapper functions: _schedule_xxx → schedule function ns:xxx Nt
+  for (const { name, ticks } of scheduleFns) {
+    files.push({
+      path: `data/${namespace}/function/_schedule_${name}.mcfunction`,
+      content: `schedule function ${namespace}:${name} ${ticks}t\n`,
+    })
+  }
+
+  // Tag files for tick/load
+  if (loadFns.length > 0 || true) {
+    // Always include load.json — it must reference the load.mcfunction
+    const loadValues = [`${namespace}:load`, ...loadFns.map(fn => `${namespace}:${fn}`)]
+    files.push({
+      path: 'data/minecraft/tags/function/load.json',
+      content: JSON.stringify({ values: loadValues }, null, 2) + '\n',
+    })
+  }
+
+  if (tickFns.length > 0) {
+    const tickValues = tickFns.map(fn => `${namespace}:${fn}`)
+    files.push({
+      path: 'data/minecraft/tags/function/tick.json',
+      content: JSON.stringify({ values: tickValues }, null, 2) + '\n',
+    })
+  }
+
+  return files
+}
+
+// ---------------------------------------------------------------------------
+// Function emission
+// ---------------------------------------------------------------------------
+
+function emitFunction(fn: LIRFunction, namespace: string, objective: string, mcVersion: McVersion): string[] {
+  const lines: string[] = []
+  for (const instr of fn.instructions) {
+    lines.push(emitInstr(instr, namespace, objective, mcVersion))
+  }
+  return lines
+}
+
+function emitFunctionWithSourceMap(
+  fn: LIRFunction,
+  namespace: string,
+  objective: string,
+  builder: SourceMapBuilder,
+  mcVersion: McVersion,
+): string[] {
+  const lines: string[] = []
+  for (const instr of fn.instructions) {
+    lines.push(emitInstr(instr, namespace, objective, mcVersion))
+    builder.addLine(instr.sourceLoc)
+  }
+  return lines
+}
+
+function fnNameToPath(name: string, namespace: string): string {
+  // LIR function names may contain :: for methods — convert to /
+  const mcName = name.replace(/::/g, '/').toLowerCase()
+  return `data/${namespace}/function/${mcName}.mcfunction`
+}
+
+// ---------------------------------------------------------------------------
+// Instruction emission
+// ---------------------------------------------------------------------------
+
+function emitInstr(instr: LIRInstr, ns: string, obj: string, mcVersion: McVersion): string {
+  switch (instr.kind) {
+    case 'score_set':
+      return `scoreboard players set ${slot(instr.dst)} ${instr.value}`
+
+    case 'score_copy':
+      return `scoreboard players operation ${slot(instr.dst)} = ${slot(instr.src)}`
+
+    case 'score_add':
+      return `scoreboard players operation ${slot(instr.dst)} += ${slot(instr.src)}`
+
+    case 'score_sub':
+      return `scoreboard players operation ${slot(instr.dst)} -= ${slot(instr.src)}`
+
+    case 'score_mul':
+      return `scoreboard players operation ${slot(instr.dst)} *= ${slot(instr.src)}`
+
+    case 'score_div':
+      return `scoreboard players operation ${slot(instr.dst)} /= ${slot(instr.src)}`
+
+    case 'score_mod':
+      return `scoreboard players operation ${slot(instr.dst)} %= ${slot(instr.src)}`
+
+    case 'score_min':
+      return `scoreboard players operation ${slot(instr.dst)} < ${slot(instr.src)}`
+
+    case 'score_max':
+      return `scoreboard players operation ${slot(instr.dst)} > ${slot(instr.src)}`
+
+    case 'score_swap':
+      return `scoreboard players operation ${slot(instr.a)} >< ${slot(instr.b)}`
+
+    case 'store_cmd_to_score':
+      return `execute store result score ${slot(instr.dst)} run ${emitInstr(instr.cmd, ns, obj, mcVersion)}`
+
+    case 'store_score_to_nbt':
+      return `execute store result storage ${instr.ns} ${instr.path} ${instr.type} ${instr.scale} run scoreboard players get ${slot(instr.src)}`
+
+    case 'store_nbt_to_score':
+      return `execute store result score ${slot(instr.dst)} run data get storage ${instr.ns} ${instr.path} ${instr.scale}`
+
+    case 'nbt_set_literal':
+      return `data modify storage ${instr.ns} ${instr.path} set value ${instr.value}`
+
+    case 'nbt_copy':
+      return `data modify storage ${instr.dstNs} ${instr.dstPath} set from storage ${instr.srcNs} ${instr.srcPath}`
+
+    case 'call':
+      return `function ${instr.fn}`
+
+    case 'call_macro':
+      if (mcVersion >= McVersion.v1_20_2) {
+        return `function ${instr.fn} with storage ${instr.storage}`
+      }
+      // Pre-1.20.2: macros not supported; call function directly (args in storage are ignored)
+      return `function ${instr.fn}`
+
+    case 'call_if_matches':
+      return `execute if score ${slot(instr.slot)} matches ${instr.range} run function ${instr.fn}`
+
+    case 'call_unless_matches':
+      return `execute unless score ${slot(instr.slot)} matches ${instr.range} run function ${instr.fn}`
+
+    case 'call_if_score':
+      return `execute if score ${slot(instr.a)} ${cmpToMC(instr.op)} ${slot(instr.b)} run function ${instr.fn}`
+
+    case 'call_unless_score':
+      return `execute unless score ${slot(instr.a)} ${cmpToMC(instr.op)} ${slot(instr.b)} run function ${instr.fn}`
+
+    case 'call_context': {
+      const subcmds = instr.subcommands.map(emitSubcmd).join(' ')
+      return `execute ${subcmds} run function ${instr.fn}`
+    }
+
+    case 'return_value':
+      return `scoreboard players operation $ret ${instr.slot.obj} = ${slot(instr.slot)}`
+
+    case 'macro_line':
+      if (mcVersion >= McVersion.v1_20_2) {
+        return `$${instr.template}`
+      }
+      // Pre-1.20.2: function macros not available. Emit as a plain command with
+      // $(param) placeholders replaced by storage reads via data get (best-effort
+      // compat for string/id params; numeric coords will not be dynamic).
+      return macroLineCompat(instr.template)
+
+    case 'raw':
+      return instr.cmd
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function slot(s: Slot): string {
+  return `${s.player} ${s.obj}`
+}
+
+function cmpToMC(op: CmpOp): string {
+  switch (op) {
+    case 'eq': return '='
+    case 'ne': return '='  // ne uses "unless" form, but when used in if score context
+    case 'lt': return '<'
+    case 'le': return '<='
+    case 'gt': return '>'
+    case 'ge': return '>='
+  }
+}
+
+/**
+ * Pre-1.20.2 compat: emit a macro template as a plain command.
+ * $(param) placeholders are replaced with `storage rs:macro_args <param>` data-get
+ * expressions for string/id values, or left as literal "0" for coordinates.
+ * This is best-effort — dynamic numeric positions cannot be truly emulated.
+ */
+function macroLineCompat(template: string): string {
+  // Replace $(param) with data-get-style substitution marker
+  return template.replace(/\$\((\w+)\)/g, (_m, p) => `{storage:rs:macro_args,path:${p}}`)
+}
+
+function emitSubcmd(sub: ExecuteSubcmd): string {
+  switch (sub.kind) {
+    case 'as':
+      return `as ${sub.selector}`
+    case 'at':
+      return `at ${sub.selector}`
+    case 'at_self':
+      return 'at @s'
+    case 'positioned':
+      return `positioned ${sub.x} ${sub.y} ${sub.z}`
+    case 'rotated':
+      return `rotated ${sub.yaw} ${sub.pitch}`
+    case 'in':
+      return `in ${sub.dimension}`
+    case 'anchored':
+      return `anchored ${sub.anchor}`
+    case 'if_score':
+      return `if score ${sub.a} ${cmpToMC(sub.op)} ${sub.b}`
+    case 'unless_score':
+      return `unless score ${sub.a} ${cmpToMC(sub.op)} ${sub.b}`
+    case 'if_matches':
+      return `if score ${sub.score} matches ${sub.range}`
+    case 'unless_matches':
+      return `unless score ${sub.score} matches ${sub.range}`
+  }
+}