redscript-mc 2.1.0 → 2.2.1

package/src/lsp/server.ts

@@ -34,6 +34,7 @@ import { Parser } from '../parser'
 import { TypeChecker } from '../typechecker'
 import { DiagnosticError } from '../diagnostics'
 import type { Program, FnDecl, Span, TypeNode } from '../ast/types'
+import { BUILTIN_METADATA } from '../builtins/metadata'
 
 // ---------------------------------------------------------------------------
 // Connection and document manager
@@ -123,6 +124,25 @@ function toDiagnostic(err: DiagnosticError): Diagnostic {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Decorator hover docs
+// ---------------------------------------------------------------------------
+
+const DECORATOR_DOCS: Record<string, string> = {
+  tick:         'Runs every MC game tick (~20 Hz). No arguments.',
+  load:         'Runs on `/reload`. Use for initialization logic.',
+  coroutine:    'Splits loops into tick-spread continuations. Arg: `batch=N` (steps per tick, default 1).',
+  schedule:     'Schedules the function to run after N ticks. Arg: `ticks=N`.',
+  on_trigger:   'Runs when a trigger scoreboard objective is set by a player. Arg: trigger name.',
+  keep:         'Prevents the compiler from dead-code-eliminating this function.',
+  on:           'Generic event handler decorator.',
+  on_advancement: 'Runs when a player earns an advancement. Arg: advancement id.',
+  on_craft:     'Runs when a player crafts an item. Arg: item id.',
+  on_death:     'Runs when a player dies.',
+  on_join_team: 'Runs when a player joins a team. Arg: team name.',
+  on_login:     'Runs when a player logs in.',
+}
+
 // ---------------------------------------------------------------------------
 // Hover helpers
 // ---------------------------------------------------------------------------
@@ -290,9 +310,44 @@ connection.onHover((params: TextDocumentPositionParams): Hover | null => {
   const program = cached?.program ?? null
   if (!program) return null
 
+  // Check if cursor is on a decorator (@tick, @load, etc.)
+  const lines = source.split('\n')
+  const lineText = lines[params.position.line] ?? ''
+  const decoratorMatch = lineText.match(/@([a-zA-Z_][a-zA-Z0-9_]*)/)
+  if (decoratorMatch) {
+    const ch = params.position.character
+    const atIdx = lineText.indexOf('@')
+    const decoratorEnd = atIdx + 1 + decoratorMatch[1].length
+    if (ch >= atIdx && ch <= decoratorEnd) {
+      const decoratorName = decoratorMatch[1]
+      const decoratorDoc = DECORATOR_DOCS[decoratorName]
+      if (decoratorDoc) {
+        const content: MarkupContent = {
+          kind: MarkupKind.Markdown,
+          value: `**@${decoratorName}** — ${decoratorDoc}`,
+        }
+        return { contents: content }
+      }
+    }
+  }
+
   const word = wordAt(source, params.position)
   if (!word) return null
 
+  // Check builtins
+  const builtin = BUILTIN_METADATA[word]
+  if (builtin) {
+    const paramStr = builtin.params
+      .map(p => `${p.name}: ${p.type}${p.required ? '' : '?'}`)
+      .join(', ')
+    const sig = `fn ${builtin.name}(${paramStr}): ${builtin.returns}`
+    const content: MarkupContent = {
+      kind: MarkupKind.Markdown,
+      value: `\`\`\`redscript\n${sig}\n\`\`\`\n${builtin.doc}`,
+    }
+    return { contents: content }
+  }
+
   // Check if it's a known function
   const fn = findFunction(program, word)
   if (fn) {

package/src/mir/lower.ts

@@ -61,16 +61,18 @@ export function lowerToMIR(hir: HIRModule, sourceFile?: string): MIRModule {
     }
   }
 
+  const timerCounter = { count: 0, timerId: 0 }
+
   const allFunctions: MIRFunction[] = []
   for (const f of hir.functions) {
-    const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile)
+    const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter)
     allFunctions.push(fn, ...helpers)
   }
 
   // Lower impl block methods
   for (const ib of hir.implBlocks) {
     for (const m of ib.methods) {
-      const { fn, helpers } = lowerImplMethod(m, ib.typeName, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile)
+      const { fn, helpers } = lowerImplMethod(m, ib.typeName, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter)
       allFunctions.push(fn, ...helpers)
     }
   }
@@ -105,6 +107,8 @@ class FnContext {
   readonly structVars = new Map<string, { typeName: string; fields: Map<string, Temp> }>()
   /** Tuple variable tracking: varName → array of element temps (index = slot) */
   readonly tupleVars = new Map<string, Temp[]>()
+  /** Array variable tracking: varName → { ns, pathPrefix } for NBT-backed int[] */
+  readonly arrayVars = new Map<string, { ns: string; pathPrefix: string }>()
   /** Macro function info for all functions in the module */
   readonly macroInfo: Map<string, MacroFunctionInfo>
   /** Function parameter info for call_macro generation */
@@ -117,6 +121,10 @@ class FnContext {
   currentSourceLoc: SourceLoc | undefined = undefined
   /** Source file path for the module being compiled */
   sourceFile: string | undefined = undefined
+  /** Shared counter for setTimeout/setInterval callback naming and Timer static IDs (module-wide) */
+  readonly timerCounter: { count: number; timerId: number }
+  /** Tracks temps whose values are known compile-time constants (for Timer static ID propagation) */
+  readonly constTemps = new Map<Temp, number>()
 
   constructor(
     namespace: string,
@@ -126,6 +134,7 @@ class FnContext {
     macroInfo: Map<string, MacroFunctionInfo> = new Map(),
     fnParamInfo: Map<string, HIRParam[]> = new Map(),
     enumDefs: Map<string, Map<string, number>> = new Map(),
+    timerCounter: { count: number; timerId: number } = { count: 0, timerId: 0 },
   ) {
     this.namespace = namespace
     this.fnName = fnName
@@ -135,6 +144,7 @@ class FnContext {
     this.fnParamInfo = fnParamInfo
     this.currentMacroParams = macroInfo.get(fnName)?.macroParams ?? new Set()
     this.enumDefs = enumDefs
+    this.timerCounter = timerCounter
     const entry = this.makeBlock('entry')
     this.currentBlock = entry
   }
@@ -214,8 +224,9 @@ function lowerFunction(
   fnParamInfo: Map<string, HIRParam[]> = new Map(),
   enumDefs: Map<string, Map<string, number>> = new Map(),
   sourceFile?: string,
+  timerCounter: { count: number; timerId: number } = { count: 0, timerId: 0 },
 ): { fn: MIRFunction; helpers: MIRFunction[] } {
-  const ctx = new FnContext(namespace, fn.name, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs)
+  const ctx = new FnContext(namespace, fn.name, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter)
   ctx.sourceFile = sourceFile
   const fnMacroInfo = macroInfo.get(fn.name)
 
@@ -267,9 +278,10 @@ function lowerImplMethod(
   fnParamInfo: Map<string, HIRParam[]> = new Map(),
   enumDefs: Map<string, Map<string, number>> = new Map(),
   sourceFile?: string,
+  timerCounter: { count: number; timerId: number } = { count: 0, timerId: 0 },
 ): { fn: MIRFunction; helpers: MIRFunction[] } {
   const fnName = `${typeName}::${method.name}`
-  const ctx = new FnContext(namespace, fnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs)
+  const ctx = new FnContext(namespace, fnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter)
   ctx.sourceFile = sourceFile
   const fields = structDefs.get(typeName) ?? []
   const hasSelf = method.params.length > 0 && method.params[0].name === 'self'
@@ -444,6 +456,12 @@ function lowerStmt(
             const t = ctx.freshTemp()
             ctx.emit({ kind: 'copy', dst: t, src: { kind: 'temp', name: `__rf_${fieldName}` } })
             fieldTemps.set(fieldName, t)
+            // Propagate compile-time constants from return slots (e.g. Timer._id from Timer::new)
+            const rfSlot = `__rf_${fieldName}`
+            const constVal = ctx.constTemps.get(rfSlot)
+            if (constVal !== undefined) {
+              ctx.constTemps.set(t, constVal)
+            }
           }
           ctx.structVars.set(stmt.name, { typeName: stmt.type.name, fields: fieldTemps })
         } else {
@@ -452,6 +470,33 @@ function lowerStmt(
           ctx.emit({ kind: 'copy', dst: t, src: valOp })
           scope.set(stmt.name, t)
         }
+      } else if (stmt.init.kind === 'array_lit') {
+        // Array literal: write to NBT storage, track the var for index access
+        const ns = `${ctx.getNamespace()}:arrays`
+        const pathPrefix = stmt.name
+        ctx.arrayVars.set(stmt.name, { ns, pathPrefix })
+        const elems = stmt.init.elements
+        // Check if all elements are pure integer literals (no side-effects)
+        const allConst = elems.every(e => e.kind === 'int_lit')
+        if (allConst) {
+          // Emit a single raw 'data modify ... set value [...]' to initialize the whole list
+          const vals = elems.map(e => (e as { kind: 'int_lit'; value: number }).value).join(', ')
+          ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${vals}]`, args: [] })
+        } else {
+          // Initialize with zeros, then overwrite dynamic elements
+          const zeros = elems.map(() => '0').join(', ')
+          ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${zeros}]`, args: [] })
+          for (let i = 0; i < elems.length; i++) {
+            const elemOp = lowerExpr(elems[i], ctx, scope)
+            if (elemOp.kind !== 'const' || (elems[i].kind !== 'int_lit')) {
+              ctx.emit({ kind: 'nbt_write', ns, path: `${pathPrefix}[${i}]`, type: 'int', scale: 1, src: elemOp })
+            }
+          }
+        }
+        // Store array length as a temp in scope (for .len access)
+        const lenTemp = ctx.freshTemp()
+        ctx.emit({ kind: 'const', dst: lenTemp, value: elems.length })
+        scope.set(stmt.name, lenTemp)
       } else {
         const valOp = lowerExpr(stmt.init, ctx, scope)
         const t = ctx.freshTemp()
@@ -730,6 +775,40 @@ function lowerStmt(
           if (isPlaceholderTerm(ctx.current().term)) {
             ctx.terminate({ kind: 'jump', target: mergeBlock.id })
           }
+        } else if (arm.pattern.kind === 'range_lit') {
+          // Range pattern: e.g. 0..59 => emit ge/le comparisons
+          const range = arm.pattern.range
+          const armBody = ctx.newBlock('match_arm')
+          const nextArm = ctx.newBlock('match_next')
+
+          // Chain checks: if min defined, check matchVal >= min; if max defined, check matchVal <= max
+          // Each failed check jumps to nextArm
+          const checks: Array<{ op: 'ge' | 'le'; bound: number }> = []
+          if (range.min !== undefined) checks.push({ op: 'ge', bound: range.min })
+          if (range.max !== undefined) checks.push({ op: 'le', bound: range.max })
+
+          if (checks.length === 0) {
+            // Open range — always matches
+            ctx.terminate({ kind: 'jump', target: armBody.id })
+          } else {
+            // Emit checks sequentially; each check passes → continue to next or armBody
+            for (let ci = 0; ci < checks.length; ci++) {
+              const { op, bound } = checks[ci]
+              const cmpTemp = ctx.freshTemp()
+              ctx.emit({ kind: 'cmp', dst: cmpTemp, op, a: matchVal, b: { kind: 'const', value: bound } })
+              const passBlock = ci === checks.length - 1 ? armBody : ctx.newBlock('match_range_check')
+              ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: passBlock.id, else: nextArm.id })
+              if (ci < checks.length - 1) ctx.switchTo(passBlock)
+            }
+          }
+
+          ctx.switchTo(armBody)
+          lowerBlock(arm.body, ctx, new Map(scope))
+          if (isPlaceholderTerm(ctx.current().term)) {
+            ctx.terminate({ kind: 'jump', target: mergeBlock.id })
+          }
+
+          ctx.switchTo(nextArm)
         } else {
           const patOp = lowerExpr(arm.pattern, ctx, scope)
           const cmpTemp = ctx.freshTemp()
@@ -996,14 +1075,116 @@ function lowerExpr(
     }
 
     case 'index': {
+      // Check if obj is a tracked array variable with a constant index
+      if (expr.obj.kind === 'ident') {
+        const arrInfo = ctx.arrayVars.get(expr.obj.name)
+        if (arrInfo && expr.index.kind === 'int_lit') {
+          const t = ctx.freshTemp()
+          ctx.emit({ kind: 'nbt_read', dst: t, ns: arrInfo.ns, path: `${arrInfo.pathPrefix}[${expr.index.value}]`, scale: 1 })
+          return { kind: 'temp', name: t }
+        }
+      }
       const obj = lowerExpr(expr.obj, ctx, scope)
-      const idx = lowerExpr(expr.index, ctx, scope)
+      lowerExpr(expr.index, ctx, scope)
       const t = ctx.freshTemp()
       ctx.emit({ kind: 'copy', dst: t, src: obj })
       return { kind: 'temp', name: t }
     }
 
     case 'call': {
+      // Handle scoreboard_get / score — read from vanilla MC scoreboard
+      if (expr.fn === 'scoreboard_get' || expr.fn === 'score') {
+        const player = hirExprToStringLiteral(expr.args[0])
+        const obj = hirExprToStringLiteral(expr.args[1])
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'score_read', dst: t, player, obj })
+        return { kind: 'temp', name: t }
+      }
+
+      // Handle scoreboard_set — write to vanilla MC scoreboard
+      if (expr.fn === 'scoreboard_set') {
+        const player = hirExprToStringLiteral(expr.args[0])
+        const obj = hirExprToStringLiteral(expr.args[1])
+        const src = lowerExpr(expr.args[2], ctx, scope)
+        ctx.emit({ kind: 'score_write', player, obj, src })
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'const', dst: t, value: 0 })
+        return { kind: 'temp', name: t }
+      }
+
+      // Handle setTimeout/setInterval: lift lambda arg to a named helper function
+      if ((expr.fn === 'setTimeout' || expr.fn === 'setInterval') && expr.args.length === 2) {
+        const ticksArg = expr.args[0]
+        const callbackArg = expr.args[1]
+        const ns = ctx.getNamespace()
+        const id = ctx.timerCounter.count++
+        const callbackName = `__timeout_callback_${id}`
+
+        // Extract ticks value for the schedule command
+        let ticksLiteral: number | null = null
+        if (ticksArg.kind === 'int_lit') {
+          ticksLiteral = ticksArg.value
+        }
+
+        // Build the callback MIRFunction from the lambda body
+        if (callbackArg.kind === 'lambda') {
+          const cbCtx = new FnContext(
+            ns,
+            callbackName,
+            ctx.structDefs,
+            ctx.implMethods,
+            ctx.macroInfo,
+            ctx.fnParamInfo,
+            ctx.enumDefs,
+            ctx.timerCounter,
+          )
+          cbCtx.sourceFile = ctx.sourceFile
+
+          const cbBody = Array.isArray(callbackArg.body) ? callbackArg.body : [{ kind: 'expr' as const, expr: callbackArg.body }]
+
+          // For setInterval: reschedule at end of body
+          const bodyStmts: typeof cbBody = [...cbBody]
+          if (expr.fn === 'setInterval' && ticksLiteral !== null) {
+            // Append: raw `schedule function ns:callbackName ticksT`
+            bodyStmts.push({
+              kind: 'raw' as const,
+              cmd: `schedule function ${ns}:${callbackName} ${ticksLiteral}t`,
+            } as any)
+          }
+
+          lowerBlock(bodyStmts, cbCtx, new Map())
+          const cbCur = cbCtx.current()
+          if (isPlaceholderTerm(cbCur.term)) {
+            cbCtx.terminate({ kind: 'return', value: null })
+          }
+          const cbReachable = computeReachable(cbCtx.blocks, 'entry')
+          const cbLiveBlocks = cbCtx.blocks.filter(b => cbReachable.has(b.id))
+          computePreds(cbLiveBlocks)
+          const cbFn: MIRFunction = {
+            name: callbackName,
+            params: [],
+            blocks: cbLiveBlocks,
+            entry: 'entry',
+            isMacro: false,
+          }
+          ctx.helperFunctions.push(cbFn, ...cbCtx.helperFunctions)
+        }
+
+        // Emit: schedule function ns:callbackName ticksT
+        if (ticksLiteral !== null) {
+          ctx.emit({ kind: 'call', dst: null, fn: `__raw:schedule function ${ns}:${callbackName} ${ticksLiteral}t`, args: [] })
+        } else {
+          // Dynamic ticks: lower ticks operand and emit a raw schedule (best-effort)
+          const ticksOp = lowerExpr(ticksArg, ctx, scope)
+          ctx.emit({ kind: 'call', dst: null, fn: `__raw:schedule function ${ns}:${callbackName} 1t`, args: [ticksOp] })
+        }
+
+        // setTimeout returns void (0), setInterval returns an int ID (0 for now)
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'const', dst: t, value: 0 })
+        return { kind: 'temp', name: t }
+      }
+
       // Handle builtin calls → raw MC commands
       if (BUILTIN_SET.has(expr.fn)) {
         const cmd = formatBuiltinCall(expr.fn, expr.args, ctx.currentMacroParams)
@@ -1017,6 +1198,14 @@ function lowerExpr(
       if (expr.args.length > 0 && expr.args[0].kind === 'ident') {
         const sv = ctx.structVars.get(expr.args[0].name)
         if (sv) {
+          // Intercept Timer method calls when _id is a known compile-time constant
+          if (sv.typeName === 'Timer') {
+            const idTemp = sv.fields.get('_id')
+            const timerId = idTemp !== undefined ? ctx.constTemps.get(idTemp) : undefined
+            if (timerId !== undefined) {
+              return lowerTimerMethod(expr.fn, timerId, sv, ctx, scope, expr.args.slice(1))
+            }
+          }
           const methodInfo = ctx.implMethods.get(sv.typeName)?.get(expr.fn)
           if (methodInfo?.hasSelf) {
             // Build args: self fields first, then remaining explicit args
@@ -1069,6 +1258,14 @@ function lowerExpr(
       if (expr.callee.kind === 'member' && expr.callee.obj.kind === 'ident') {
         const sv = ctx.structVars.get(expr.callee.obj.name)
         if (sv) {
+          // Intercept Timer method calls when _id is a known compile-time constant
+          if (sv.typeName === 'Timer') {
+            const idTemp = sv.fields.get('_id')
+            const timerId = idTemp !== undefined ? ctx.constTemps.get(idTemp) : undefined
+            if (timerId !== undefined) {
+              return lowerTimerMethod(expr.callee.field, timerId, sv, ctx, scope, expr.args)
+            }
+          }
           const methodInfo = ctx.implMethods.get(sv.typeName)?.get(expr.callee.field)
           if (methodInfo?.hasSelf) {
             // Build args: self fields first, then explicit args
@@ -1094,6 +1291,24 @@ function lowerExpr(
     }
 
     case 'static_call': {
+      // Intercept Timer::new() to statically allocate a unique ID
+      if (expr.type === 'Timer' && expr.method === 'new' && expr.args.length === 1) {
+        const id = ctx.timerCounter.timerId++
+        const ns = ctx.getNamespace()
+        const playerName = `__timer_${id}`
+        // Emit scoreboard initialization: ticks=0, active=0
+        ctx.emit({ kind: 'score_write', player: `${playerName}_ticks`, obj: ns, src: { kind: 'const', value: 0 } })
+        ctx.emit({ kind: 'score_write', player: `${playerName}_active`, obj: ns, src: { kind: 'const', value: 0 } })
+        // Lower the duration argument
+        const durationOp = lowerExpr(expr.args[0], ctx, scope)
+        // Return fields via __rf_ slots (Timer has fields: _id, _duration)
+        ctx.emit({ kind: 'const', dst: '__rf__id', value: id })
+        ctx.constTemps.set('__rf__id', id)
+        ctx.emit({ kind: 'copy', dst: '__rf__duration', src: durationOp })
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'const', dst: t, value: 0 })
+        return { kind: 'temp', name: t }
+      }
       const args = expr.args.map(a => lowerExpr(a, ctx, scope))
       const t = ctx.freshTemp()
       ctx.emit({ kind: 'call', dst: t, fn: `${expr.type}::${expr.method}`, args })
@@ -1198,6 +1413,98 @@ function lowerShortCircuitOr(
   return { kind: 'temp', name: result }
 }
 
+// ---------------------------------------------------------------------------
+// Timer method inlining
+// ---------------------------------------------------------------------------
+
+/**
+ * Inline a Timer instance method call using the statically-assigned timer ID.
+ * Emits scoreboard operations directly, bypassing the Timer::* function calls.
+ */
+function lowerTimerMethod(
+  method: string,
+  timerId: number,
+  sv: { typeName: string; fields: Map<string, Temp> },
+  ctx: FnContext,
+  scope: Map<string, Temp>,
+  extraArgs: HIRExpr[],
+): Operand {
+  const ns = ctx.getNamespace()
+  const player = `__timer_${timerId}`
+  const t = ctx.freshTemp()
+
+  if (method === 'start') {
+    ctx.emit({ kind: 'score_write', player: `${player}_active`, obj: ns, src: { kind: 'const', value: 1 } })
+    ctx.emit({ kind: 'const', dst: t, value: 0 })
+  } else if (method === 'pause') {
+    ctx.emit({ kind: 'score_write', player: `${player}_active`, obj: ns, src: { kind: 'const', value: 0 } })
+    ctx.emit({ kind: 'const', dst: t, value: 0 })
+  } else if (method === 'reset') {
+    ctx.emit({ kind: 'score_write', player: `${player}_ticks`, obj: ns, src: { kind: 'const', value: 0 } })
+    ctx.emit({ kind: 'const', dst: t, value: 0 })
+  } else if (method === 'tick') {
+    const durationTemp = sv.fields.get('_duration')
+    const activeTemp = ctx.freshTemp()
+    const ticksTemp = ctx.freshTemp()
+    ctx.emit({ kind: 'score_read', dst: activeTemp, player: `${player}_active`, obj: ns })
+    ctx.emit({ kind: 'score_read', dst: ticksTemp, player: `${player}_ticks`, obj: ns })
+    const innerThen = ctx.newBlock('timer_tick_inner')
+    const innerMerge = ctx.newBlock('timer_tick_after_lt')
+    const outerMerge = ctx.newBlock('timer_tick_done')
+    const activeCheck = ctx.freshTemp()
+    ctx.emit({ kind: 'cmp', op: 'eq', dst: activeCheck, a: { kind: 'temp', name: activeTemp }, b: { kind: 'const', value: 1 } })
+    ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: activeCheck }, then: innerThen.id, else: outerMerge.id })
+    ctx.switchTo(innerThen)
+    const lessCheck = ctx.freshTemp()
+    if (durationTemp) {
+      ctx.emit({ kind: 'cmp', op: 'lt', dst: lessCheck, a: { kind: 'temp', name: ticksTemp }, b: { kind: 'temp', name: durationTemp } })
+    } else {
+      ctx.emit({ kind: 'const', dst: lessCheck, value: 0 })
+    }
+    const doIncBlock = ctx.newBlock('timer_tick_inc')
+    ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: lessCheck }, then: doIncBlock.id, else: innerMerge.id })
+    ctx.switchTo(doIncBlock)
+    const newTicks = ctx.freshTemp()
+    ctx.emit({ kind: 'add', dst: newTicks, a: { kind: 'temp', name: ticksTemp }, b: { kind: 'const', value: 1 } })
+    ctx.emit({ kind: 'score_write', player: `${player}_ticks`, obj: ns, src: { kind: 'temp', name: newTicks } })
+    ctx.terminate({ kind: 'jump', target: innerMerge.id })
+    ctx.switchTo(innerMerge)
+    ctx.terminate({ kind: 'jump', target: outerMerge.id })
+    ctx.switchTo(outerMerge)
+    ctx.emit({ kind: 'const', dst: t, value: 0 })
+  } else if (method === 'done') {
+    const durationTemp = sv.fields.get('_duration')
+    const ticksTemp = ctx.freshTemp()
+    ctx.emit({ kind: 'score_read', dst: ticksTemp, player: `${player}_ticks`, obj: ns })
+    if (durationTemp) {
+      ctx.emit({ kind: 'cmp', op: 'ge', dst: t, a: { kind: 'temp', name: ticksTemp }, b: { kind: 'temp', name: durationTemp } })
+    } else {
+      ctx.emit({ kind: 'const', dst: t, value: 0 })
+    }
+  } else if (method === 'elapsed') {
+    ctx.emit({ kind: 'score_read', dst: t, player: `${player}_ticks`, obj: ns })
+  } else if (method === 'remaining') {
+    const durationTemp = sv.fields.get('_duration')
+    const ticksTemp = ctx.freshTemp()
+    ctx.emit({ kind: 'score_read', dst: ticksTemp, player: `${player}_ticks`, obj: ns })
+    if (durationTemp) {
+      ctx.emit({ kind: 'sub', dst: t, a: { kind: 'temp', name: durationTemp }, b: { kind: 'temp', name: ticksTemp } })
+    } else {
+      ctx.emit({ kind: 'const', dst: t, value: 0 })
+    }
+  } else {
+    // Unknown Timer method — emit regular call
+    const fields = ['_id', '_duration']
+    const selfArgs: Operand[] = fields.map(f => {
+      const temp = sv.fields.get(f)
+      return temp ? { kind: 'temp' as const, name: temp } : { kind: 'const' as const, value: 0 }
+    })
+    const explicitArgs = extraArgs.map(a => lowerExpr(a, ctx, scope))
+    ctx.emit({ kind: 'call', dst: t, fn: `Timer::${method}`, args: [...selfArgs, ...explicitArgs] })
+  }
+  return { kind: 'temp', name: t }
+}
+
 // ---------------------------------------------------------------------------
 // Execute subcommand lowering
 // ---------------------------------------------------------------------------
@@ -1310,13 +1617,32 @@ function formatBuiltinCall(
       break
     }
     case 'setblock': {
-      const [x, y, z, block] = strs
-      cmd = `setblock ${x} ${y} ${z} ${block}`
+      // args: blockpos, block — expand blockpos to x y z
+      const [posOrX, blockOrY] = args
+      if (posOrX?.kind === 'blockpos') {
+        const px = coordStr(posOrX.x)
+        const py = coordStr(posOrX.y)
+        const pz = coordStr(posOrX.z)
+        const blk = exprToCommandArg(blockOrY, macroParams).str
+        cmd = `setblock ${px} ${py} ${pz} ${blk}`
+      } else {
+        const [x, y, z, block] = strs
+        cmd = `setblock ${x} ${y} ${z} ${block}`
+      }
       break
     }
     case 'fill': {
-      const [x1, y1, z1, x2, y2, z2, block] = strs
-      cmd = `fill ${x1} ${y1} ${z1} ${x2} ${y2} ${z2} ${block}`
+      // args: blockpos1, blockpos2, block — expand both blockpos
+      const [p1, p2, blkArg] = args
+      if (p1?.kind === 'blockpos' && p2?.kind === 'blockpos') {
+        const x1 = coordStr(p1.x); const y1 = coordStr(p1.y); const z1 = coordStr(p1.z)
+        const x2 = coordStr(p2.x); const y2 = coordStr(p2.y); const z2 = coordStr(p2.z)
+        const blk = exprToCommandArg(blkArg, macroParams).str
+        cmd = `fill ${x1} ${y1} ${z1} ${x2} ${y2} ${z2} ${blk}`
+      } else {
+        const [x1, y1, z1, x2, y2, z2, block] = strs
+        cmd = `fill ${x1} ${y1} ${z1} ${x2} ${y2} ${z2} ${block}`
+      }
       break
     }
     case 'say': cmd = `say ${strs[0] ?? ''}`; break
@@ -1355,6 +1681,15 @@ function formatBuiltinCall(
 }
 
 /** Convert an HIR expression to its MC command string representation */
+/** Convert a CoordComponent to a MC coordinate string */
+function coordStr(c: import('../ast/types').CoordComponent): string {
+  switch (c.kind) {
+    case 'absolute': return String(c.value)
+    case 'relative': return c.offset === 0 ? '~' : `~${c.offset}`
+    case 'local':    return c.offset === 0 ? '^' : `^${c.offset}`
+  }
+}
+
 function exprToCommandArg(
   expr: HIRExpr,
   macroParams: Set<string>,
@@ -1401,3 +1736,14 @@ function exprToCommandArg(
       return { str: '~', isMacro: false }
   }
 }
+
+/** Extract a string literal from a HIR expression for use in MC commands */
+function hirExprToStringLiteral(expr: HIRExpr): string {
+  switch (expr.kind) {
+    case 'str_lit': return expr.value
+    case 'mc_name': return expr.value
+    case 'selector': return expr.raw
+    case 'int_lit': return String(expr.value)
+    default: return ''
+  }
+}

package/src/mir/types.ts

@@ -80,6 +80,10 @@ export type MIRInstr = MIRInstrBase & (
   | { kind: 'nbt_read'; dst: Temp; ns: string; path: string; scale: number }
   | { kind: 'nbt_write'; ns: string; path: string; type: NBTType; scale: number; src: Operand }
 
+  // ── Vanilla scoreboard interop ────────────────────────────────────────────
+  | { kind: 'score_read'; dst: Temp; player: string; obj: string }
+  | { kind: 'score_write'; player: string; obj: string; src: Operand }
+
   // ── Function calls ────────────────────────────────────────────────────────
   | { kind: 'call'; dst: Temp | null; fn: string; args: Operand[] }
   | { kind: 'call_macro'; dst: Temp | null; fn: string; args: { name: string; value: Operand; type: NBTType; scale: number }[] }

package/src/optimizer/copy_prop.ts

@@ -85,6 +85,8 @@ function rewriteUses(instr: MIRInstr, copies: Map<Temp, Operand>): MIRInstr {
       return { ...instr, cond: resolve(instr.cond, copies) }
     case 'return':
       return { ...instr, value: instr.value ? resolve(instr.value, copies) : null }
+    case 'score_write':
+      return { ...instr, src: resolve(instr.src, copies) }
     default:
       return instr
   }
@@ -100,6 +102,8 @@ function getDst(instr: MIRInstr): Temp | null {
       return instr.dst
     case 'call': case 'call_macro':
       return instr.dst
+    case 'score_read':
+      return instr.dst
     default:
       return null
   }