redscript-mc 1.0.0

package/src/codegen/structure/index.ts

@@ -0,0 +1,305 @@
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { Lowering } from '../../lowering'
+import { nbt, TagType, writeNbt, type CompoundTag, type NbtTag } from '../../nbt'
+import { createEmptyOptimizationStats, mergeOptimizationStats, type OptimizationStats } from '../../optimizer/commands'
+import { optimizeWithStats } from '../../optimizer/passes'
+import { optimizeForStructure, optimizeForStructureWithStats } from '../../optimizer/structure'
+import { preprocessSource } from '../../compile'
+import type { IRCommand, IRFunction, IRModule } from '../../ir/types'
+import type { DatapackFile } from '../mcfunction'
+
+const DATA_VERSION = 3953
+const MAX_WIDTH = 16
+const OBJ = 'rs'
+
+const PALETTE_IMPULSE = 0
+const PALETTE_CHAIN_UNCONDITIONAL = 1
+const PALETTE_CHAIN_CONDITIONAL = 2
+const PALETTE_REPEAT = 3
+
+const palette = [
+  { Name: 'minecraft:command_block', Properties: { conditional: 'false', facing: 'east' } },
+  { Name: 'minecraft:chain_command_block', Properties: { conditional: 'false', facing: 'east' } },
+  { Name: 'minecraft:chain_command_block', Properties: { conditional: 'true', facing: 'east' } },
+  { Name: 'minecraft:repeating_command_block', Properties: { conditional: 'false', facing: 'east' } },
+  { Name: 'minecraft:air', Properties: {} },
+]
+
+interface CommandEntry {
+  functionName: string
+  lineNumber: number
+  command: string
+  state: number
+  conditional: boolean
+  isRepeat: boolean
+}
+
+export interface StructureBlockInfo {
+  command: string
+  conditional: boolean
+  state: number
+  functionName: string
+  lineNumber: number
+}
+
+export interface StructureCompileResult {
+  buffer: Buffer
+  blockCount: number
+  blocks: StructureBlockInfo[]
+  stats?: OptimizationStats
+}
+
+function escapeJsonString(value: string): string {
+  return JSON.stringify(value).slice(1, -1)
+}
+
+function varRef(name: string): string {
+  return name.startsWith('$') ? name : `$${name}`
+}
+
+function collectConsts(fn: IRFunction): Set<number> {
+  const consts = new Set<number>()
+  for (const block of fn.blocks) {
+    for (const instr of block.instrs) {
+      if (instr.op === 'assign' && instr.src.kind === 'const') consts.add(instr.src.value)
+      if (instr.op === 'binop') {
+        if (instr.lhs.kind === 'const') consts.add(instr.lhs.value)
+        if (instr.rhs.kind === 'const') consts.add(instr.rhs.value)
+      }
+      if (instr.op === 'cmp') {
+        if (instr.lhs.kind === 'const') consts.add(instr.lhs.value)
+        if (instr.rhs.kind === 'const') consts.add(instr.rhs.value)
+      }
+    }
+    if (block.term.op === 'return' && block.term.value?.kind === 'const') {
+      consts.add(block.term.value.value)
+    }
+  }
+  return consts
+}
+
+function constSetup(value: number): string {
+  return `scoreboard players set $const_${value} ${OBJ} ${value}`
+}
+
+function collectCommandEntriesFromModule(module: IRModule): CommandEntry[] {
+  const entries: CommandEntry[] = []
+  const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName)
+  const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName!))
+  const loadCommands = [
+    `scoreboard objectives add ${OBJ} dummy`,
+    ...module.globals.map(globalName => `scoreboard players set ${varRef(globalName)} ${OBJ} 0`),
+    ...Array.from(triggerNames).flatMap(triggerName => [
+      `scoreboard objectives add ${triggerName} trigger`,
+      `scoreboard players enable @a ${triggerName}`,
+    ]),
+    ...Array.from(
+      new Set(module.functions.flatMap(fn => Array.from(collectConsts(fn))))
+    ).map(constSetup),
+  ]
+
+  const sections: Array<{ name: string; commands: IRCommand[]; repeat?: boolean }> = []
+
+  if (loadCommands.length > 0) {
+    sections.push({
+      name: '__load',
+      commands: loadCommands.map(cmd => ({ cmd })),
+    })
+  }
+
+  for (const triggerName of triggerNames) {
+    const handlers = triggerHandlers.filter(fn => fn.triggerName === triggerName)
+    sections.push({
+      name: `__trigger_${triggerName}_dispatch`,
+      commands: [
+        ...handlers.map(handler => ({ cmd: `function ${module.namespace}:${handler.name}` })),
+        { cmd: `scoreboard players set @s ${triggerName} 0` },
+        { cmd: `scoreboard players enable @s ${triggerName}` },
+      ],
+    })
+  }
+
+  for (const fn of module.functions) {
+    if (!fn.commands || fn.commands.length === 0) continue
+    sections.push({
+      name: fn.name,
+      commands: fn.commands,
+    })
+  }
+
+  const tickCommands: IRCommand[] = []
+  for (const fn of module.functions.filter(candidate => candidate.isTickLoop)) {
+    tickCommands.push({ cmd: `function ${module.namespace}:${fn.name}` })
+  }
+  if (triggerNames.size > 0) {
+    for (const triggerName of triggerNames) {
+      tickCommands.push({
+        cmd: `execute as @a[scores={${triggerName}=1..}] run function ${module.namespace}:__trigger_${triggerName}_dispatch`,
+      })
+    }
+  }
+  if (tickCommands.length > 0) {
+    sections.push({
+      name: '__tick',
+      commands: tickCommands,
+      repeat: true,
+    })
+  }
+
+  for (const section of sections) {
+    for (let i = 0; i < section.commands.length; i++) {
+      const command = section.commands[i]
+      const state =
+        i === 0
+          ? (section.repeat ? PALETTE_REPEAT : PALETTE_IMPULSE)
+          : (command.conditional ? PALETTE_CHAIN_CONDITIONAL : PALETTE_CHAIN_UNCONDITIONAL)
+
+      entries.push({
+        functionName: section.name,
+        lineNumber: i + 1,
+        command: command.cmd,
+        conditional: Boolean(command.conditional),
+        state,
+        isRepeat: Boolean(section.repeat && i === 0),
+      })
+    }
+  }
+
+  return entries
+}
+
+function toFunctionName(file: DatapackFile): string | null {
+  const match = file.path.match(/^data\/[^/]+\/function\/(.+)\.mcfunction$/)
+  return match?.[1] ?? null
+}
+
+function collectCommandEntriesFromFiles(files: DatapackFile[]): CommandEntry[] {
+  const entries: CommandEntry[] = []
+
+  for (const file of files) {
+    const functionName = toFunctionName(file)
+    if (!functionName) continue
+
+    const lines = file.content.split('\n')
+    let isFirstCommand = true
+    const isTickFunction = functionName === '__tick'
+
+    for (let i = 0; i < lines.length; i++) {
+      const command = lines[i].trim()
+      if (command === '' || command.startsWith('#')) continue
+
+      const state = isFirstCommand
+        ? (isTickFunction ? PALETTE_REPEAT : PALETTE_IMPULSE)
+        : PALETTE_CHAIN_UNCONDITIONAL
+
+      entries.push({
+        functionName,
+        lineNumber: i + 1,
+        command,
+        conditional: false,
+        state,
+        isRepeat: isTickFunction && isFirstCommand,
+      })
+
+      isFirstCommand = false
+    }
+  }
+
+  return entries
+}
+
+function createPaletteTag(): CompoundTag[] {
+  return palette.map(entry =>
+    nbt.compound({
+      Name: nbt.string(entry.Name),
+      Properties: nbt.compound(
+        Object.fromEntries(
+          Object.entries(entry.Properties).map(([key, value]) => [key, nbt.string(value)])
+        )
+      ),
+    })
+  )
+}
+
+function createBlockEntityTag(entry: CommandEntry): NbtTag {
+  return nbt.compound({
+    id: nbt.string('minecraft:command_block'),
+    Command: nbt.string(entry.command),
+    auto: nbt.byte(entry.isRepeat ? 1 : 0),
+    powered: nbt.byte(0),
+    conditionMet: nbt.byte(0),
+    UpdateLastExecution: nbt.byte(1),
+    LastExecution: nbt.long(0n),
+    TrackOutput: nbt.byte(1),
+    SuccessCount: nbt.int(0),
+    LastOutput: nbt.string(''),
+    CustomName: nbt.string(`{"text":"${escapeJsonString(`${entry.functionName}:${entry.lineNumber}`)}"}`),
+  })
+}
+
+function createBlockTag(entry: CommandEntry, index: number): CompoundTag {
+  const x = index % MAX_WIDTH
+  const z = Math.floor(index / MAX_WIDTH) % MAX_WIDTH
+  const y = Math.floor(index / (MAX_WIDTH * MAX_WIDTH))
+
+  return nbt.compound({
+    pos: nbt.list(TagType.Int, [nbt.int(x), nbt.int(y), nbt.int(z)]),
+    state: nbt.int(entry.state),
+    nbt: createBlockEntityTag(entry),
+  })
+}
+
+export function generateStructure(input: IRModule | DatapackFile[]): StructureCompileResult {
+  const entries = Array.isArray(input)
+    ? collectCommandEntriesFromFiles(input)
+    : collectCommandEntriesFromModule(input)
+
+  const blockTags = entries.map(createBlockTag)
+  const sizeX = Math.max(1, Math.min(MAX_WIDTH, entries.length || 1))
+  const sizeZ = Math.max(1, Math.min(MAX_WIDTH, Math.ceil(entries.length / MAX_WIDTH) || 1))
+  const sizeY = Math.max(1, Math.ceil(entries.length / (MAX_WIDTH * MAX_WIDTH)) || 1)
+
+  const root = nbt.compound({
+    DataVersion: nbt.int(DATA_VERSION),
+    size: nbt.list(TagType.Int, [nbt.int(sizeX), nbt.int(sizeY), nbt.int(sizeZ)]),
+    palette: nbt.list(TagType.Compound, createPaletteTag()),
+    blocks: nbt.list(TagType.Compound, blockTags),
+    entities: nbt.list(TagType.Compound, []),
+  })
+
+  return {
+    buffer: writeNbt(root, ''),
+    blockCount: entries.length,
+    blocks: entries.map(entry => ({
+      command: entry.command,
+      conditional: entry.conditional,
+      state: entry.state,
+      functionName: entry.functionName,
+      lineNumber: entry.lineNumber,
+    })),
+  }
+}
+
+export function compileToStructure(source: string, namespace: string, filePath?: string): StructureCompileResult {
+  const preprocessedSource = preprocessSource(source, { filePath })
+  const tokens = new Lexer(preprocessedSource, filePath).tokenize()
+  const ast = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+  const ir = new Lowering(namespace).lower(ast)
+  const stats = createEmptyOptimizationStats()
+  const optimizedIRFunctions = ir.functions.map(fn => {
+    const optimized = optimizeWithStats(fn)
+    mergeOptimizationStats(stats, optimized.stats)
+    return optimized.fn
+  })
+  const structureOptimized = optimizeForStructureWithStats(optimizedIRFunctions, namespace)
+  mergeOptimizationStats(stats, structureOptimized.stats)
+  const optimizedModule: IRModule = {
+    ...ir,
+    functions: structureOptimized.functions,
+  }
+  return {
+    ...generateStructure(optimizedModule),
+    stats,
+  }
+}

package/src/compile.ts

@@ -0,0 +1,188 @@
+/**
+ * RedScript Compile API
+ *
+ * Main compile function with proper error handling and diagnostics.
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+
+import { Lexer } from './lexer'
+import { Parser } from './parser'
+import { Lowering } from './lowering'
+import { optimize } from './optimizer/passes'
+import { generateDatapackWithStats, DatapackFile } from './codegen/mcfunction'
+import { DiagnosticError, formatError, parseErrorMessage } from './diagnostics'
+import type { IRModule } from './ir/types'
+import type { Program } from './ast/types'
+
+// ---------------------------------------------------------------------------
+// Compile Options
+// ---------------------------------------------------------------------------
+
+export interface CompileOptions {
+  namespace?: string
+  filePath?: string
+  optimize?: boolean
+}
+
+// ---------------------------------------------------------------------------
+// Compile Result
+// ---------------------------------------------------------------------------
+
+export interface CompileResult {
+  success: boolean
+  files?: DatapackFile[]
+  advancements?: DatapackFile[]
+  ast?: Program
+  ir?: IRModule
+  error?: DiagnosticError
+}
+
+const IMPORT_RE = /^\s*import\s+"([^"]+)"\s*;?\s*$/
+
+interface PreprocessOptions {
+  filePath?: string
+  seen?: Set<string>
+}
+
+export function preprocessSource(source: string, options: PreprocessOptions = {}): string {
+  const { filePath } = options
+  const seen = options.seen ?? new Set<string>()
+
+  if (filePath) {
+    seen.add(path.resolve(filePath))
+  }
+
+  const lines = source.split('\n')
+  const imports: string[] = []
+  const bodyLines: string[] = []
+  let parsingHeader = true
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const trimmed = line.trim()
+    const match = line.match(IMPORT_RE)
+
+    if (parsingHeader && match) {
+      if (!filePath) {
+        throw new DiagnosticError(
+          'ParseError',
+          'Import statements require a file path',
+          { line: i + 1, col: 1 },
+          lines
+        )
+      }
+
+      const importPath = path.resolve(path.dirname(filePath), match[1])
+      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
+          )
+        }
+
+        imports.push(preprocessSource(importedSource, { filePath: importPath, seen }))
+      }
+      continue
+    }
+
+    if (parsingHeader && (trimmed === '' || trimmed.startsWith('//'))) {
+      bodyLines.push(line)
+      continue
+    }
+
+    parsingHeader = false
+    bodyLines.push(line)
+  }
+
+  return [...imports, bodyLines.join('\n')].filter(Boolean).join('\n')
+}
+
+// ---------------------------------------------------------------------------
+// Main Compile Function
+// ---------------------------------------------------------------------------
+
+export function compile(source: string, options: CompileOptions = {}): CompileResult {
+  const { namespace = 'redscript', filePath, optimize: shouldOptimize = true } = options
+  let sourceLines = source.split('\n')
+
+  try {
+    const preprocessedSource = preprocessSource(source, { filePath })
+    sourceLines = preprocessedSource.split('\n')
+
+    // Lexing
+    const tokens = new Lexer(preprocessedSource, filePath).tokenize()
+
+    // Parsing
+    const ast = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+
+    // Lowering
+    const ir = new Lowering(namespace).lower(ast)
+
+    // Optimization
+    const optimized: IRModule = shouldOptimize
+      ? { ...ir, functions: ir.functions.map(fn => optimize(fn)) }
+      : ir
+
+    // Code generation
+    const generated = generateDatapackWithStats(optimized)
+
+    return {
+      success: true,
+      files: [...generated.files, ...generated.advancements],
+      advancements: generated.advancements,
+      ast,
+      ir: optimized,
+    }
+  } catch (err) {
+    // Already a DiagnosticError
+    if (err instanceof DiagnosticError) {
+      return { success: false, error: err }
+    }
+
+    // Try to parse the error message for line/col info
+    if (err instanceof Error) {
+      const diagnostic = parseErrorMessage(
+        'ParseError',
+        err.message,
+        sourceLines,
+        filePath
+      )
+      return { success: false, error: diagnostic }
+    }
+
+    // Unknown error
+    return {
+      success: false,
+      error: new DiagnosticError(
+        'ParseError',
+        String(err),
+        { file: filePath, line: 1, col: 1 },
+        sourceLines
+      )
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Format Compile Error
+// ---------------------------------------------------------------------------
+
+export function formatCompileError(result: CompileResult): string {
+  if (result.success) {
+    return 'Compilation successful'
+  }
+  if (result.error) {
+    return formatError(result.error, result.error.sourceLines?.join('\n'))
+  }
+  return 'Unknown error'
+}

package/src/diagnostics/index.ts

@@ -0,0 +1,186 @@
+/**
+ * RedScript Diagnostics
+ *
+ * Error reporting with file path, line, column, and formatted error messages.
+ */
+
+// ---------------------------------------------------------------------------
+// Error Types
+// ---------------------------------------------------------------------------
+
+export type DiagnosticKind = 'LexError' | 'ParseError' | 'LoweringError' | 'TypeError'
+
+export interface DiagnosticLocation {
+  file?: string
+  line: number
+  col: number
+}
+
+function formatSourcePointer(sourceLines: string[], line: number, col: number): string[] {
+  const lineIdx = line - 1
+  if (lineIdx < 0 || lineIdx >= sourceLines.length) {
+    return []
+  }
+
+  const sourceLine = sourceLines[lineIdx]
+  const safeCol = Math.max(1, Math.min(col, sourceLine.length + 1))
+  const pointer = `  ${' '.repeat(safeCol - 1)}^`
+  return [`  ${sourceLine}`, pointer]
+}
+
+export class DiagnosticError extends Error {
+  readonly kind: DiagnosticKind
+  readonly location: DiagnosticLocation
+  readonly sourceLines?: string[]
+
+  constructor(
+    kind: DiagnosticKind,
+    message: string,
+    location: DiagnosticLocation,
+    sourceLines?: string[]
+  ) {
+    super(message)
+    this.name = 'DiagnosticError'
+    this.kind = kind
+    this.location = location
+    this.sourceLines = sourceLines
+  }
+
+  /**
+   * Format the error for display:
+   * ```
+   * Error: [ParseError] line 5, col 12: Expected ';' after statement
+   *   5 |   let x = 42
+   *                   ^ expected ';'
+   * ```
+   */
+  format(): string {
+    const { kind, message, location, sourceLines } = this
+    const filePart = location.file ? `${location.file}:` : ''
+    const header = `Error: [${kind}] ${filePart}line ${location.line}, col ${location.col}: ${message}`
+
+    if (!sourceLines || sourceLines.length === 0) {
+      return header
+    }
+
+    const pointerLines = formatSourcePointer(sourceLines, location.line, location.col)
+    if (pointerLines.length === 0) {
+      return header
+    }
+    const lineNum = String(location.line).padStart(3)
+    const prefix = `${lineNum} | `
+    const sourceLine = sourceLines[location.line - 1]
+    const safeCol = Math.max(1, Math.min(location.col, sourceLine.length + 1))
+    const pointer = ' '.repeat(prefix.length + safeCol - 1) + '^'
+    const hint = message.toLowerCase().includes('expected')
+      ? message.split(':').pop()?.trim() || ''
+      : ''
+
+    return [
+      header,
+      `${prefix}${sourceLine}`,
+      `${pointer}${hint ? ` ${hint}` : ''}`,
+    ].join('\n')
+  }
+
+  toString(): string {
+    return this.format()
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Diagnostic Collection
+// ---------------------------------------------------------------------------
+
+export class DiagnosticCollector {
+  private diagnostics: DiagnosticError[] = []
+  private sourceLines: string[] = []
+  private filePath?: string
+
+  constructor(source?: string, filePath?: string) {
+    if (source) {
+      this.sourceLines = source.split('\n')
+    }
+    this.filePath = filePath
+  }
+
+  error(kind: DiagnosticKind, message: string, line: number, col: number): void {
+    const diagnostic = new DiagnosticError(
+      kind,
+      message,
+      { file: this.filePath, line, col },
+      this.sourceLines
+    )
+    this.diagnostics.push(diagnostic)
+  }
+
+  hasErrors(): boolean {
+    return this.diagnostics.length > 0
+  }
+
+  getErrors(): DiagnosticError[] {
+    return this.diagnostics
+  }
+
+  formatAll(): string {
+    return this.diagnostics.map(d => d.format()).join('\n\n')
+  }
+
+  throwFirst(): never {
+    if (this.diagnostics.length > 0) {
+      throw this.diagnostics[0]
+    }
+    throw new Error('No diagnostics to throw')
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helper Functions
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a DiagnosticError from a raw error message that includes line/col info
+ * e.g., "Expected ';' at line 5, col 12"
+ */
+export function parseErrorMessage(
+  kind: DiagnosticKind,
+  rawMessage: string,
+  sourceLines?: string[],
+  filePath?: string
+): DiagnosticError {
+  // Try to extract line and col from message
+  const match = rawMessage.match(/at line (\d+), col (\d+)/)
+  if (match) {
+    const line = parseInt(match[1], 10)
+    const col = parseInt(match[2], 10)
+    const message = rawMessage.replace(/ at line \d+, col \d+$/, '').trim()
+    return new DiagnosticError(kind, message, { file: filePath, line, col }, sourceLines)
+  }
+
+  // Fallback: line 1, col 1
+  return new DiagnosticError(kind, rawMessage, { file: filePath, line: 1, col: 1 }, sourceLines)
+}
+
+export function formatError(error: Error | DiagnosticError, source?: 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 pointerLines = formatSourcePointer(sourceLines, line, col)
+    if (pointerLines.length > 0) {
+      lines.push(...pointerLines)
+    }
+    lines.push(error.message)
+    return lines.join('\n')
+  }
+
+  if (!source) {
+    return error.message
+  }
+
+  const parsed = parseErrorMessage('ParseError', error.message, source.split('\n'))
+  return formatError(parsed, source)
+}