redscript-mc 1.2.30 → 2.0.0

package/src2/emit/index.ts

@@ -0,0 +1,222 @@
+/**
+ * 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'
+
+export interface DatapackFile {
+  path: string
+  content: string
+}
+
+export interface EmitOptions {
+  namespace: string
+  tickFunctions?: string[]
+  loadFunctions?: string[]
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export function emit(module: LIRModule, options: EmitOptions): DatapackFile[] {
+  const { namespace } = options
+  const tickFns = options.tickFunctions ?? []
+  const loadFns = options.loadFunctions ?? []
+  const objective = module.objective
+  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 lines = emitFunction(fn, namespace, objective)
+    const fnPath = fnNameToPath(fn.name, namespace)
+    files.push({ path: fnPath, content: lines.join('\n') + '\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): string[] {
+  const lines: string[] = []
+  for (const instr of fn.instructions) {
+    lines.push(emitInstr(instr, namespace, objective))
+  }
+  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): 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)}`
+
+    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':
+      return `function ${instr.fn} with storage ${instr.storage}`
+
+    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':
+      return `$${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 '>='
+  }
+}
+
+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}`
+  }
+}

package/src2/hir/lower.ts

@@ -0,0 +1,428 @@
+/**
+ * AST → HIR Lowering — Stage 2 of the RedScript compiler pipeline.
+ *
+ * Desugaring transforms:
+ * - for(init;cond;step) → block { init; while(cond) { body; step } }
+ * - for_range(v,start,end) → block { let v = start; while(v < end) { body; v = v + 1 } }
+ * - a += b / -= / *= / /= / %= → a = a OP b
+ * - a && b → if(a) { b } else { false }
+ * - a || b → if(a) { true } else { b }
+ * - as_block / at_block / as_at → unified execute with subcommands
+ * - All other nodes pass through with field-wise recursion
+ */
+
+import type {
+  Program, Expr, Stmt, Block, FnDecl, Param,
+  AssignOp, ExecuteSubcommand,
+} from '../../src/ast/types'
+import type {
+  HIRModule, HIRFunction, HIRParam, HIRExpr, HIRStmt, HIRBlock,
+  HIRExecuteSubcommand, HIRStruct, HIRImplBlock, HIREnum, HIRConst, HIRGlobal,
+} from './types'
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export function lowerToHIR(program: Program): HIRModule {
+  return {
+    namespace: program.namespace,
+    globals: program.globals.map(lowerGlobal),
+    functions: program.declarations.map(lowerFunction),
+    structs: program.structs.map((s): HIRStruct => ({
+      name: s.name,
+      fields: s.fields.map(f => ({ name: f.name, type: f.type })),
+      span: s.span,
+    })),
+    implBlocks: program.implBlocks.map((ib): HIRImplBlock => ({
+      typeName: ib.typeName,
+      methods: ib.methods.map(lowerFunction),
+      span: ib.span,
+    })),
+    enums: program.enums.map((e): HIREnum => ({
+      name: e.name,
+      variants: e.variants.map(v => ({ name: v.name, value: v.value })),
+      span: e.span,
+    })),
+    consts: program.consts.map((c): HIRConst => ({
+      name: c.name,
+      type: c.type,
+      value: lowerExpr(c.value),
+      span: c.span,
+    })),
+    isLibrary: program.isLibrary,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Functions & globals
+// ---------------------------------------------------------------------------
+
+function lowerGlobal(g: Program['globals'][0]): HIRGlobal {
+  return {
+    name: g.name,
+    type: g.type,
+    init: lowerExpr(g.init),
+    mutable: g.mutable,
+    span: g.span,
+  }
+}
+
+function lowerFunction(fn: FnDecl): HIRFunction {
+  return {
+    name: fn.name,
+    params: fn.params.map(lowerParam),
+    returnType: fn.returnType,
+    decorators: fn.decorators,
+    body: lowerBlock(fn.body),
+    isLibraryFn: fn.isLibraryFn,
+    span: fn.span,
+  }
+}
+
+function lowerParam(p: Param): HIRParam {
+  return {
+    name: p.name,
+    type: p.type,
+    default: p.default ? lowerExpr(p.default) : undefined,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Blocks & statements
+// ---------------------------------------------------------------------------
+
+function lowerBlock(block: Block): HIRBlock {
+  const result: HIRBlock = []
+  for (const stmt of block) {
+    const lowered = lowerStmt(stmt)
+    // lowerStmt may return an array (e.g. for → [init, while])
+    if (Array.isArray(lowered)) {
+      result.push(...lowered)
+    } else {
+      result.push(lowered)
+    }
+  }
+  return result
+}
+
+function lowerStmt(stmt: Stmt): HIRStmt | HIRStmt[] {
+  switch (stmt.kind) {
+    case 'let':
+      return { kind: 'let', name: stmt.name, type: stmt.type, init: lowerExpr(stmt.init), span: stmt.span }
+
+    case 'expr':
+      return { kind: 'expr', expr: lowerExpr(stmt.expr), span: stmt.span }
+
+    case 'return':
+      return { kind: 'return', value: stmt.value ? lowerExpr(stmt.value) : undefined, span: stmt.span }
+
+    case 'break':
+      return { kind: 'break', span: stmt.span }
+
+    case 'continue':
+      return { kind: 'continue', span: stmt.span }
+
+    case 'if':
+      return {
+        kind: 'if',
+        cond: lowerExpr(stmt.cond),
+        then: lowerBlock(stmt.then),
+        else_: stmt.else_ ? lowerBlock(stmt.else_) : undefined,
+        span: stmt.span,
+      }
+
+    case 'while':
+      return { kind: 'while', cond: lowerExpr(stmt.cond), body: lowerBlock(stmt.body), span: stmt.span }
+
+    // --- Desugaring: for → while ---
+    case 'for': {
+      const stmts: HIRStmt[] = []
+      // Init
+      if (stmt.init) {
+        const init = lowerStmt(stmt.init)
+        if (Array.isArray(init)) stmts.push(...init)
+        else stmts.push(init)
+      }
+      // while(cond) { body } step { step_expr }
+      const body = lowerBlock(stmt.body)
+      const step: HIRStmt[] = [{ kind: 'expr', expr: lowerExpr(stmt.step), span: stmt.span }]
+      stmts.push({ kind: 'while', cond: lowerExpr(stmt.cond), body, step, span: stmt.span })
+      return stmts
+    }
+
+    // --- Desugaring: for_range → let + while(cond) { body } step { v++ } ---
+    case 'for_range': {
+      const varName = stmt.varName
+      const initStmt: HIRStmt = {
+        kind: 'let',
+        name: varName,
+        type: { kind: 'named', name: 'int' },
+        init: lowerExpr(stmt.start),
+        span: stmt.span,
+      }
+      const body = lowerBlock(stmt.body)
+      // step: v = v + 1 (in separate step block so continue still increments)
+      const step: HIRStmt[] = [{
+        kind: 'expr',
+        expr: {
+          kind: 'assign',
+          target: varName,
+          value: {
+            kind: 'binary',
+            op: '+',
+            left: { kind: 'ident', name: varName },
+            right: { kind: 'int_lit', value: 1 },
+          },
+        },
+      }]
+      const whileStmt: HIRStmt = {
+        kind: 'while',
+        cond: {
+          kind: 'binary',
+          op: '<',
+          left: { kind: 'ident', name: varName },
+          right: lowerExpr(stmt.end),
+        },
+        body,
+        step,
+        span: stmt.span,
+      }
+      return [initStmt, whileStmt]
+    }
+
+    case 'foreach':
+      return {
+        kind: 'foreach',
+        binding: stmt.binding,
+        iterable: lowerExpr(stmt.iterable),
+        body: lowerBlock(stmt.body),
+        executeContext: stmt.executeContext,
+        span: stmt.span,
+      }
+
+    case 'match':
+      return {
+        kind: 'match',
+        expr: lowerExpr(stmt.expr),
+        arms: stmt.arms.map(arm => ({
+          pattern: arm.pattern ? lowerExpr(arm.pattern) : null,
+          body: lowerBlock(arm.body),
+        })),
+        span: stmt.span,
+      }
+
+    // --- Desugaring: as_block → execute [as] ---
+    case 'as_block':
+      return {
+        kind: 'execute',
+        subcommands: [{ kind: 'as', selector: stmt.selector }],
+        body: lowerBlock(stmt.body),
+        span: stmt.span,
+      }
+
+    // --- Desugaring: at_block → execute [at] ---
+    case 'at_block':
+      return {
+        kind: 'execute',
+        subcommands: [{ kind: 'at', selector: stmt.selector }],
+        body: lowerBlock(stmt.body),
+        span: stmt.span,
+      }
+
+    // --- Desugaring: as_at → execute [as, at] ---
+    case 'as_at':
+      return {
+        kind: 'execute',
+        subcommands: [
+          { kind: 'as', selector: stmt.as_sel },
+          { kind: 'at', selector: stmt.at_sel },
+        ],
+        body: lowerBlock(stmt.body),
+        span: stmt.span,
+      }
+
+    case 'execute':
+      return {
+        kind: 'execute',
+        subcommands: stmt.subcommands.map(lowerExecuteSubcommand),
+        body: lowerBlock(stmt.body),
+        span: stmt.span,
+      }
+
+    case 'raw':
+      return { kind: 'raw', cmd: stmt.cmd, span: stmt.span }
+
+    default: {
+      const _exhaustive: never = stmt
+      throw new Error(`Unknown statement kind: ${(_exhaustive as any).kind}`)
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Execute subcommands (pass-through — same shape)
+// ---------------------------------------------------------------------------
+
+function lowerExecuteSubcommand(sub: ExecuteSubcommand): HIRExecuteSubcommand {
+  // All subcommand types share the same shape between AST and HIR
+  return sub as HIRExecuteSubcommand
+}
+
+// ---------------------------------------------------------------------------
+// Expressions
+// ---------------------------------------------------------------------------
+
+/** Map compound assignment operator to its base binary op */
+const COMPOUND_TO_BINOP: Record<string, string> = {
+  '+=': '+',
+  '-=': '-',
+  '*=': '*',
+  '/=': '/',
+  '%=': '%',
+}
+
+function lowerExpr(expr: Expr): HIRExpr {
+  switch (expr.kind) {
+    // --- Pass-through literals ---
+    case 'int_lit':
+    case 'float_lit':
+    case 'byte_lit':
+    case 'short_lit':
+    case 'long_lit':
+    case 'double_lit':
+    case 'bool_lit':
+    case 'str_lit':
+    case 'range_lit':
+    case 'rel_coord':
+    case 'local_coord':
+    case 'mc_name':
+    case 'blockpos':
+      return expr as HIRExpr
+
+    case 'ident':
+      return { kind: 'ident', name: expr.name, span: expr.span }
+
+    case 'selector':
+      return { kind: 'selector', raw: expr.raw, isSingle: expr.isSingle, sel: expr.sel, span: expr.span }
+
+    case 'array_lit':
+      return { kind: 'array_lit', elements: expr.elements.map(lowerExpr), span: expr.span }
+
+    case 'struct_lit':
+      return {
+        kind: 'struct_lit',
+        fields: expr.fields.map(f => ({ name: f.name, value: lowerExpr(f.value) })),
+        span: expr.span,
+      }
+
+    case 'str_interp':
+      return {
+        kind: 'str_interp',
+        parts: expr.parts.map(p => typeof p === 'string' ? p : lowerExpr(p)),
+        span: expr.span,
+      }
+
+    case 'f_string':
+      return { kind: 'f_string', parts: expr.parts, span: expr.span }
+
+    // Binary ops — && and || preserved as-is (short-circuit → control flow in MIR)
+    case 'binary':
+      return {
+        kind: 'binary',
+        op: expr.op,
+        left: lowerExpr(expr.left),
+        right: lowerExpr(expr.right),
+        span: expr.span,
+      }
+
+    case 'unary':
+      return { kind: 'unary', op: expr.op, operand: lowerExpr(expr.operand), span: expr.span }
+
+    case 'is_check':
+      return { kind: 'is_check', expr: lowerExpr(expr.expr), entityType: expr.entityType, span: expr.span }
+
+    // --- Desugaring: compound assignment → plain assign ---
+    case 'assign':
+      if (expr.op !== '=') {
+        const binOp = COMPOUND_TO_BINOP[expr.op]
+        return {
+          kind: 'assign',
+          target: expr.target,
+          value: {
+            kind: 'binary',
+            op: binOp as any,
+            left: { kind: 'ident', name: expr.target },
+            right: lowerExpr(expr.value),
+            span: expr.span,
+          },
+          span: expr.span,
+        }
+      }
+      return { kind: 'assign', target: expr.target, value: lowerExpr(expr.value), span: expr.span }
+
+    // --- Desugaring: compound member_assign → plain member_assign ---
+    case 'member_assign':
+      if (expr.op !== '=') {
+        const binOp = COMPOUND_TO_BINOP[expr.op]
+        const obj = lowerExpr(expr.obj)
+        return {
+          kind: 'member_assign',
+          obj,
+          field: expr.field,
+          value: {
+            kind: 'binary',
+            op: binOp as any,
+            left: { kind: 'member', obj, field: expr.field },
+            right: lowerExpr(expr.value),
+            span: expr.span,
+          },
+          span: expr.span,
+        }
+      }
+      return {
+        kind: 'member_assign',
+        obj: lowerExpr(expr.obj),
+        field: expr.field,
+        value: lowerExpr(expr.value),
+        span: expr.span,
+      }
+
+    case 'member':
+      return { kind: 'member', obj: lowerExpr(expr.obj), field: expr.field, span: expr.span }
+
+    case 'index':
+      return { kind: 'index', obj: lowerExpr(expr.obj), index: lowerExpr(expr.index), span: expr.span }
+
+    case 'call':
+      return { kind: 'call', fn: expr.fn, args: expr.args.map(lowerExpr), span: expr.span }
+
+    case 'invoke':
+      return { kind: 'invoke', callee: lowerExpr(expr.callee), args: expr.args.map(lowerExpr), span: expr.span }
+
+    case 'static_call':
+      return {
+        kind: 'static_call',
+        type: expr.type,
+        method: expr.method,
+        args: expr.args.map(lowerExpr),
+        span: expr.span,
+      }
+
+    case 'lambda': {
+      const body = Array.isArray(expr.body) ? lowerBlock(expr.body) : lowerExpr(expr.body)
+      return {
+        kind: 'lambda',
+        params: expr.params,
+        returnType: expr.returnType,
+        body,
+        span: expr.span,
+      }
+    }
+
+    default: {
+      const _exhaustive: never = expr
+      throw new Error(`Unknown expression kind: ${(_exhaustive as any).kind}`)
+    }
+  }
+}