redscript-mc 1.0.0

package/src/examples/turret.rs

@@ -0,0 +1,27 @@
+// Automated turret using a spawned armor stand object and a struct value.
+
+struct TurretState { health: int }
+
+@on_trigger("deploy_turret")
+fn deploy_turret() {
+    let turret = spawn_object(0, 64, 0);
+    turret.health = 40;
+    turret.tag("turret");
+
+    let state: TurretState = { health: 40 };
+    let hp = state.health;
+    scoreboard_set("turret", #health, hp);
+
+    say("Turret deployed.");
+}
+
+@tick(rate=20)
+fn turret_tick() {
+    foreach (turret in @e[type=armor_stand, tag=turret]) {
+        at @s {
+            foreach (z in @e[type=zombie, distance=..8]) {
+                kill(z);
+            }
+        }
+    }
+}

package/src/examples/world_manager.rs

@@ -0,0 +1,23 @@
+// World management helpers for a lobby or event setup.
+// Demonstrates block editing, global rules, and weather/time control.
+
+fn reset_lobby_platform() {
+    fill((0, 64, 0), (8, 64, 8), "minecraft:smooth_stone");
+    fill((1, 65, 1), (7, 68, 7), "minecraft:air");
+    setblock((4, 65, 4), "minecraft:gold_block");
+}
+
+fn configure_world() {
+    weather("clear");
+    time_set("day");
+    gamerule(#doWeatherCycle, "false");
+    gamerule(#doDaylightCycle, "false");
+    announce("World manager refreshed the lobby.");
+}
+
+@on_trigger("world_reset")
+fn handle_world_reset() {
+    reset_lobby_platform();
+    configure_world();
+    actionbar(@a, "Lobby reset complete");
+}

package/src/formatter/index.ts

@@ -0,0 +1,22 @@
+export function format(source: string): string {
+  const lines = source.split("\n")
+  let indent = 0
+  const result: string[] = []
+
+  for (let line of lines) {
+    line = line.trim()
+    if (!line) { result.push(""); continue }
+
+    // Decrease indent before }
+    if (line.startsWith("}")) indent = Math.max(0, indent - 1)
+
+    // Add indentation
+    result.push("    ".repeat(indent) + line)
+
+    // Increase indent after {
+    if (line.endsWith("{")) indent++
+  }
+
+  // Ensure single newline at end
+  return result.join("\n").trimEnd() + "\n"
+}

package/src/index.ts

@@ -0,0 +1,161 @@
+/**
+ * RedScript Compiler
+ * 
+ * Main entry point for programmatic usage.
+ */
+
+import { Lexer } from './lexer'
+import { Parser } from './parser'
+import { TypeChecker } from './typechecker'
+import { Lowering } from './lowering'
+import type { Warning } from './lowering'
+import {
+  constantFoldingWithStats,
+  copyPropagation,
+  deadCodeEliminationWithStats,
+} from './optimizer/passes'
+import {
+  countMcfunctionCommands,
+  generateDatapackWithStats,
+  DatapackFile,
+} from './codegen/mcfunction'
+import { preprocessSource } 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'
+
+export interface CompileOptions {
+  namespace?: string
+  optimize?: boolean
+  typeCheck?: boolean
+  filePath?: string
+}
+
+export interface CompileResult {
+  files: DatapackFile[]
+  advancements: DatapackFile[]
+  ast: Program
+  ir: IRModule
+  typeErrors?: DiagnosticError[]
+  warnings?: Warning[]
+  stats?: OptimizationStats
+}
+
+/**
+ * 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 filePath = options.filePath
+  const preprocessedSource = preprocessSource(source, { filePath })
+
+  // Lexing
+  const tokens = new Lexer(preprocessedSource, filePath).tokenize()
+
+  // Parsing
+  const ast = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+
+  // 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)
+  }
+
+  // Lowering to IR
+  const lowering = new Lowering(namespace)
+  const ir = lowering.lower(ast)
+
+  let optimizedIR: IRModule = ir
+  let generated = generateDatapackWithStats(ir, { optimizeCommands: shouldOptimize })
+  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
+
+      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 })
+    const beforeDceGenerated = generateDatapackWithStats(copyPropagatedIR, { optimizeCommands: false })
+    const afterDceGenerated = generateDatapackWithStats(optimizedIR, { optimizeCommands: false })
+    generated = generateDatapackWithStats(optimizedIR, { optimizeCommands: true })
+
+    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 })
+  }
+
+  return {
+    files: [...generated.files, ...generated.advancements],
+    advancements: generated.advancements,
+    ast,
+    ir: optimizedIR,
+    typeErrors,
+    warnings: lowering.warnings,
+    stats: optimizationStats,
+  }
+}
+
+/**
+ * Check RedScript source code for errors without generating output.
+ * 
+ * @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 {
+  try {
+    const preprocessedSource = preprocessSource(source, { filePath })
+    const tokens = new Lexer(preprocessedSource, filePath).tokenize()
+    new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+    return null
+  } catch (err) {
+    return err as Error
+  }
+}
+
+// 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/ir/builder.ts

@@ -0,0 +1,114 @@
+/**
+ * IRBuilder — helper for constructing IR programmatically.
+ * AST → IR lowering uses this.
+ */
+
+import type { IRBlock, IRFunction, IRInstr, IRModule, Operand, Terminator } from './types'
+
+export class IRBuilder {
+  private tempCount = 0
+  private labelCount = 0
+  private currentBlock: IRBlock | null = null
+  private blocks: IRBlock[] = []
+  private locals = new Set<string>()
+
+  // -------------------------------------------------------------------------
+  // Names
+  // -------------------------------------------------------------------------
+
+  freshTemp(): string {
+    const name = `$t${this.tempCount++}`
+    this.locals.add(name)
+    return name
+  }
+
+  freshLabel(hint = 'L'): string {
+    return `${hint}_${this.labelCount++}`
+  }
+
+  // -------------------------------------------------------------------------
+  // Block management
+  // -------------------------------------------------------------------------
+
+  startBlock(label: string): void {
+    this.currentBlock = { label, instrs: [], term: { op: 'return' } }
+  }
+
+  private get block(): IRBlock {
+    if (!this.currentBlock) throw new Error('No active block')
+    return this.currentBlock
+  }
+
+  private sealBlock(term: Terminator): void {
+    this.block.term = term
+    this.blocks.push(this.block)
+    this.currentBlock = null
+  }
+
+  // -------------------------------------------------------------------------
+  // Emit instructions
+  // -------------------------------------------------------------------------
+
+  emitAssign(dst: string, src: Operand): void {
+    this.locals.add(dst)
+    this.block.instrs.push({ op: 'assign', dst, src })
+  }
+
+  emitBinop(dst: string, lhs: Operand, bop: IRInstr & { op: 'binop' } extends { bop: infer B } ? B : never, rhs: Operand): void
+  emitBinop(dst: string, lhs: Operand, bop: '+' | '-' | '*' | '/' | '%', rhs: Operand): void {
+    this.locals.add(dst)
+    this.block.instrs.push({ op: 'binop', dst, lhs, bop, rhs })
+  }
+
+  emitCmp(dst: string, lhs: Operand, cop: '==' | '!=' | '<' | '<=' | '>' | '>=', rhs: Operand): void {
+    this.locals.add(dst)
+    this.block.instrs.push({ op: 'cmp', dst, lhs, cop, rhs })
+  }
+
+  emitCall(fn: string, args: Operand[], dst?: string): void {
+    if (dst) this.locals.add(dst)
+    this.block.instrs.push({ op: 'call', fn, args, dst })
+  }
+
+  emitRaw(cmd: string): void {
+    this.block.instrs.push({ op: 'raw', cmd })
+  }
+
+  // -------------------------------------------------------------------------
+  // Terminators
+  // -------------------------------------------------------------------------
+
+  emitJump(target: string): void {
+    this.sealBlock({ op: 'jump', target })
+  }
+
+  emitJumpIf(cond: string, then: string, else_: string): void {
+    this.sealBlock({ op: 'jump_if', cond, then, else_ })
+  }
+
+  emitReturn(value?: Operand): void {
+    this.sealBlock({ op: 'return', value })
+  }
+
+  emitTickYield(continuation: string): void {
+    this.sealBlock({ op: 'tick_yield', continuation })
+  }
+
+  // -------------------------------------------------------------------------
+  // Build
+  // -------------------------------------------------------------------------
+
+  build(name: string, params: string[], isTickLoop = false): IRFunction {
+    return {
+      name,
+      params,
+      locals: Array.from(this.locals),
+      blocks: this.blocks,
+      isTickLoop,
+    }
+  }
+}
+
+export function buildModule(namespace: string, fns: IRFunction[], globals: string[] = []): IRModule {
+  return { namespace, functions: fns, globals }
+}

package/src/ir/types.ts

@@ -0,0 +1,119 @@
+/**
+ * RedScript IR — Three-Address Code (TAC)
+ *
+ * Compilation pipeline:
+ *   Source → AST → IR → (optimize) → CodeGen → mcfunction / cmdblock
+ *
+ * Variable storage in MC Java Edition:
+ *   - Integer vars  → scoreboard fake player  ($name on objective "rs_vars")
+ *   - Complex data  → NBT storage             (redscript:stack / redscript:heap)
+ *   - Return value  → fake player $ret
+ *   - Temporaries   → $t0, $t1, ...
+ */
+
+// ---------------------------------------------------------------------------
+// Operands
+// ---------------------------------------------------------------------------
+
+export type Operand =
+  | { kind: 'var';     name: string }        // scoreboard fake player
+  | { kind: 'const';   value: number }       // integer literal
+  | { kind: 'storage'; path: string }        // NBT storage path (e.g. "redscript:heap data.x")
+
+// ---------------------------------------------------------------------------
+// Binary operators (all map to `scoreboard players operation`)
+// ---------------------------------------------------------------------------
+
+export type BinOp = '+' | '-' | '*' | '/' | '%'
+export type CmpOp = '==' | '!=' | '<' | '<=' | '>' | '>='
+
+// ---------------------------------------------------------------------------
+// IR Instructions
+// ---------------------------------------------------------------------------
+
+export type IRInstr =
+  // x = src
+  | { op: 'assign';    dst: string; src: Operand }
+
+  // dst = lhs bop rhs
+  | { op: 'binop';     dst: string; lhs: Operand; bop: BinOp; rhs: Operand }
+
+  // dst = (lhs cop rhs) ? 1 : 0
+  | { op: 'cmp';       dst: string; lhs: Operand; cop: CmpOp; rhs: Operand }
+
+  // goto label
+  | { op: 'jump';      target: string }
+
+  // if cond != 0 goto target
+  | { op: 'jump_if';   cond: string; target: string }
+
+  // if cond == 0 goto target
+  | { op: 'jump_unless'; cond: string; target: string }
+
+  // dst = fn(args)
+  | { op: 'call';      fn: string; args: Operand[]; dst?: string }
+
+  // return value (optional)
+  | { op: 'return';    value?: Operand }
+
+  // label declaration (block entry point)
+  | { op: 'label';     id: string }
+
+  // raw MC command passthrough (escape hatch)
+  | { op: 'raw';       cmd: string }
+
+  // wait one game tick (command block target only)
+  // maps to: schedule function <continuation> 1t replace
+  | { op: 'tick_yield' }
+
+// ---------------------------------------------------------------------------
+// Basic Block — straight-line code, ends with a terminator
+// ---------------------------------------------------------------------------
+
+export type Terminator =
+  | { op: 'jump';        target: string }
+  | { op: 'jump_if';     cond: string; then: string; else_: string }
+  | { op: 'jump_unless'; cond: string; then: string; else_: string }
+  | { op: 'return';      value?: Operand }
+  | { op: 'tick_yield';  continuation: string }
+
+export interface IRBlock {
+  label: string
+  instrs: IRInstr[]       // non-terminator instructions
+  term: Terminator
+}
+
+export interface IRCommand {
+  cmd: string
+  conditional?: boolean
+  label?: string
+}
+
+// ---------------------------------------------------------------------------
+// Function
+// ---------------------------------------------------------------------------
+
+export interface IRFunction {
+  name: string
+  params: string[]         // parameter names (passed via fake players)
+  locals: string[]         // all local variable names
+  blocks: IRBlock[]        // blocks[0] = entry block
+  commands?: IRCommand[]   // structure target command stream
+  isTickLoop?: boolean     // true → Repeat command block (runs every tick)
+  isTriggerHandler?: boolean  // true → handles a trigger event
+  triggerName?: string        // the trigger objective name
+  eventTrigger?: {
+    kind: 'advancement' | 'craft' | 'death' | 'login' | 'join_team'
+    value?: string
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Module — top-level compilation unit
+// ---------------------------------------------------------------------------
+
+export interface IRModule {
+  namespace: string        // datapack namespace (e.g. "mypack")
+  functions: IRFunction[]
+  globals: string[]        // global variable names
+}