redscript-mc 2.0.0 → 2.1.1

package/{src2 → src}/mir/lower.ts

@@ -11,7 +11,7 @@ import type {
 } from '../hir/types'
 import type {
   MIRModule, MIRFunction, MIRBlock, MIRInstr, BlockId,
-  Operand, Temp, CmpOp, ExecuteSubcmd, NBTType,
+  Operand, Temp, CmpOp, ExecuteSubcmd, NBTType, SourceLoc,
 } from './types'
 import { detectMacroFunctions, BUILTIN_SET, type MacroFunctionInfo } from './macro'
 
@@ -19,13 +19,23 @@ import { detectMacroFunctions, BUILTIN_SET, type MacroFunctionInfo } from './mac
 // Public API
 // ---------------------------------------------------------------------------
 
-export function lowerToMIR(hir: HIRModule): MIRModule {
+export function lowerToMIR(hir: HIRModule, sourceFile?: string): MIRModule {
   // Build struct definitions: name → field names
   const structDefs = new Map<string, string[]>()
   for (const s of hir.structs) {
     structDefs.set(s.name, s.fields.map(f => f.name))
   }
 
+  // Build enum definitions: enumName → variantName → integer value
+  const enumDefs = new Map<string, Map<string, number>>()
+  for (const e of hir.enums) {
+    const variants = new Map<string, number>()
+    for (const v of e.variants) {
+      variants.set(v.name, v.value ?? 0)
+    }
+    enumDefs.set(e.name, variants)
+  }
+
   // Build impl method info: typeName → methodName → { hasSelf }
   const implMethods = new Map<string, Map<string, { hasSelf: boolean }>>()
   for (const ib of hir.implBlocks) {
@@ -53,14 +63,14 @@ export function lowerToMIR(hir: HIRModule): MIRModule {
 
   const allFunctions: MIRFunction[] = []
   for (const f of hir.functions) {
-    const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo)
+    const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile)
     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)
+      const { fn, helpers } = lowerImplMethod(m, ib.typeName, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile)
       allFunctions.push(fn, ...helpers)
     }
   }
@@ -93,12 +103,20 @@ class FnContext {
   readonly implMethods: Map<string, Map<string, { hasSelf: boolean }>>
   /** Struct variable tracking: varName → { typeName, fields: fieldName → temp } */
   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[]>()
   /** Macro function info for all functions in the module */
   readonly macroInfo: Map<string, MacroFunctionInfo>
   /** Function parameter info for call_macro generation */
   readonly fnParamInfo: Map<string, HIRParam[]>
   /** Macro params for the current function being lowered */
   readonly currentMacroParams: Set<string>
+  /** Enum definitions: enumName → variantName → integer value */
+  readonly enumDefs: Map<string, Map<string, number>>
+  /** Current source location (set during statement lowering) */
+  currentSourceLoc: SourceLoc | undefined = undefined
+  /** Source file path for the module being compiled */
+  sourceFile: string | undefined = undefined
 
   constructor(
     namespace: string,
@@ -107,6 +125,7 @@ class FnContext {
     implMethods: Map<string, Map<string, { hasSelf: boolean }>> = new Map(),
     macroInfo: Map<string, MacroFunctionInfo> = new Map(),
     fnParamInfo: Map<string, HIRParam[]> = new Map(),
+    enumDefs: Map<string, Map<string, number>> = new Map(),
   ) {
     this.namespace = namespace
     this.fnName = fnName
@@ -115,6 +134,7 @@ class FnContext {
     this.macroInfo = macroInfo
     this.fnParamInfo = fnParamInfo
     this.currentMacroParams = macroInfo.get(fnName)?.macroParams ?? new Set()
+    this.enumDefs = enumDefs
     const entry = this.makeBlock('entry')
     this.currentBlock = entry
   }
@@ -139,10 +159,16 @@ class FnContext {
   }
 
   emit(instr: MIRInstr): void {
+    if (this.currentSourceLoc && !instr.sourceLoc) {
+      instr.sourceLoc = this.currentSourceLoc
+    }
     this.currentBlock.instrs.push(instr)
   }
 
   terminate(term: MIRInstr): void {
+    if (this.currentSourceLoc && !term.sourceLoc) {
+      term.sourceLoc = this.currentSourceLoc
+    }
     this.currentBlock.term = term
   }
 
@@ -186,8 +212,11 @@ function lowerFunction(
   implMethods: Map<string, Map<string, { hasSelf: boolean }>> = new Map(),
   macroInfo: Map<string, MacroFunctionInfo> = new Map(),
   fnParamInfo: Map<string, HIRParam[]> = new Map(),
+  enumDefs: Map<string, Map<string, number>> = new Map(),
+  sourceFile?: string,
 ): { fn: MIRFunction; helpers: MIRFunction[] } {
-  const ctx = new FnContext(namespace, fn.name, structDefs, implMethods, macroInfo, fnParamInfo)
+  const ctx = new FnContext(namespace, fn.name, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs)
+  ctx.sourceFile = sourceFile
   const fnMacroInfo = macroInfo.get(fn.name)
 
   // Create temps for parameters
@@ -236,9 +265,12 @@ function lowerImplMethod(
   implMethods: Map<string, Map<string, { hasSelf: boolean }>>,
   macroInfo: Map<string, MacroFunctionInfo> = new Map(),
   fnParamInfo: Map<string, HIRParam[]> = new Map(),
+  enumDefs: Map<string, Map<string, number>> = new Map(),
+  sourceFile?: string,
 ): { fn: MIRFunction; helpers: MIRFunction[] } {
   const fnName = `${typeName}::${method.name}`
-  const ctx = new FnContext(namespace, fnName, structDefs, implMethods, macroInfo, fnParamInfo)
+  const ctx = new FnContext(namespace, fnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs)
+  ctx.sourceFile = sourceFile
   const fields = structDefs.get(typeName) ?? []
   const hasSelf = method.params.length > 0 && method.params[0].name === 'self'
 
@@ -356,9 +388,32 @@ function lowerStmt(
   ctx: FnContext,
   scope: Map<string, Temp>,
 ): void {
+  // Propagate source location from HIR statement span
+  if (stmt.span && ctx.sourceFile) {
+    ctx.currentSourceLoc = { file: ctx.sourceFile, line: stmt.span.line, col: stmt.span.col }
+  }
+
   switch (stmt.kind) {
     case 'let': {
-      if (stmt.init.kind === 'struct_lit') {
+      if (stmt.init.kind === 'some_lit') {
+        // Some(expr) — create option struct vars: has=1, val=expr
+        // Use __opt_ prefix so DCE treats these as side-effectful scoreboard writes
+        const hasTemp: Temp = `__opt_${stmt.name}_has`
+        const valTemp: Temp = `__opt_${stmt.name}_val`
+        ctx.emit({ kind: 'const', dst: hasTemp, value: 1 })
+        const valOp = lowerExpr(stmt.init.value, ctx, scope)
+        ctx.emit({ kind: 'copy', dst: valTemp, src: valOp })
+        const fieldTemps = new Map<string, Temp>([['has', hasTemp], ['val', valTemp]])
+        ctx.structVars.set(stmt.name, { typeName: '__option', fields: fieldTemps })
+      } else if (stmt.init.kind === 'none_lit') {
+        // None — create option struct vars: has=0, val=0
+        const hasTemp: Temp = `__opt_${stmt.name}_has`
+        const valTemp: Temp = `__opt_${stmt.name}_val`
+        ctx.emit({ kind: 'const', dst: hasTemp, value: 0 })
+        ctx.emit({ kind: 'const', dst: valTemp, value: 0 })
+        const fieldTemps = new Map<string, Temp>([['has', hasTemp], ['val', valTemp]])
+        ctx.structVars.set(stmt.name, { typeName: '__option', fields: fieldTemps })
+      } else if (stmt.init.kind === 'struct_lit') {
         // Struct literal: create per-field temps
         const typeName = (stmt.type?.kind === 'struct') ? stmt.type.name : '__anon'
         const fieldTemps = new Map<string, Temp>()
@@ -369,6 +424,15 @@ function lowerStmt(
           fieldTemps.set(field.name, t)
         }
         ctx.structVars.set(stmt.name, { typeName, fields: fieldTemps })
+      } else if (stmt.type?.kind === 'option') {
+        // Option<T>-typed let with function call result — use __rf_has/__rf_val convention
+        lowerExpr(stmt.init, ctx, scope)
+        const hasTemp: Temp = `__opt_${stmt.name}_has`
+        const valTemp: Temp = `__opt_${stmt.name}_val`
+        ctx.emit({ kind: 'copy', dst: hasTemp, src: { kind: 'temp', name: '__rf_has' } })
+        ctx.emit({ kind: 'copy', dst: valTemp, src: { kind: 'temp', name: '__rf_val' } })
+        const fieldTemps = new Map<string, Temp>([['has', hasTemp], ['val', valTemp]])
+        ctx.structVars.set(stmt.name, { typeName: '__option', fields: fieldTemps })
       } else if (stmt.type?.kind === 'struct') {
         // Struct-typed let with non-literal init (e.g., call returning struct)
         const fields = ctx.structDefs.get(stmt.type.name)
@@ -397,19 +461,98 @@ function lowerStmt(
       break
     }
 
+    case 'let_destruct': {
+      // Tuple destructuring: let (a, b, c) = expr
+      const n = stmt.names.length
+      if (stmt.init.kind === 'tuple_lit') {
+        // Direct tuple literal: evaluate each element into its own temp
+        const elemTemps: Temp[] = []
+        for (let i = 0; i < stmt.init.elements.length && i < n; i++) {
+          const val = lowerExpr(stmt.init.elements[i], ctx, scope)
+          const t = ctx.freshTemp()
+          ctx.emit({ kind: 'copy', dst: t, src: val })
+          elemTemps.push(t)
+          scope.set(stmt.names[i], t)
+        }
+      } else if (stmt.init.kind === 'ident') {
+        // Could be referencing a known tuple var
+        const tv = ctx.tupleVars.get(stmt.init.name)
+        if (tv) {
+          for (let i = 0; i < n && i < tv.length; i++) {
+            scope.set(stmt.names[i], tv[i])
+          }
+          break
+        }
+        // Otherwise treat as a call result stored in __rf_ slots
+        lowerExpr(stmt.init, ctx, scope)
+        const elemTemps: Temp[] = []
+        for (let i = 0; i < n; i++) {
+          const t = ctx.freshTemp()
+          ctx.emit({ kind: 'copy', dst: t, src: { kind: 'temp', name: `__rf_${i}` } })
+          elemTemps.push(t)
+          scope.set(stmt.names[i], t)
+        }
+        // Register as tuple var so it can be passed around
+        const varName = stmt.names.join('_') + '_tup'
+        ctx.tupleVars.set(varName, elemTemps)
+      } else {
+        // General expression (e.g. function call) — evaluate, read __rf_ slots
+        lowerExpr(stmt.init, ctx, scope)
+        const elemTemps: Temp[] = []
+        for (let i = 0; i < n; i++) {
+          const t = ctx.freshTemp()
+          ctx.emit({ kind: 'copy', dst: t, src: { kind: 'temp', name: `__rf_${i}` } })
+          elemTemps.push(t)
+          scope.set(stmt.names[i], t)
+        }
+      }
+      break
+    }
+
     case 'expr': {
       lowerExpr(stmt.expr, ctx, scope)
       break
     }
 
     case 'return': {
-      if (stmt.value?.kind === 'struct_lit') {
+      if (stmt.value?.kind === 'some_lit') {
+        // Option return: Some(expr) → set __rf_has=1, __rf_val=expr
+        const valOp = lowerExpr(stmt.value.value, ctx, scope)
+        ctx.emit({ kind: 'copy', dst: '__rf_has', src: { kind: 'const', value: 1 } })
+        ctx.emit({ kind: 'copy', dst: '__rf_val', src: valOp })
+        ctx.terminate({ kind: 'return', value: null })
+      } else if (stmt.value?.kind === 'none_lit') {
+        // Option return: None → set __rf_has=0, __rf_val=0
+        ctx.emit({ kind: 'copy', dst: '__rf_has', src: { kind: 'const', value: 0 } })
+        ctx.emit({ kind: 'copy', dst: '__rf_val', src: { kind: 'const', value: 0 } })
+        ctx.terminate({ kind: 'return', value: null })
+      } else if (stmt.value?.kind === 'struct_lit') {
         // Struct return — copy each field to return field slots
         for (const field of stmt.value.fields) {
           const val = lowerExpr(field.value, ctx, scope)
           ctx.emit({ kind: 'copy', dst: `__rf_${field.name}`, src: val })
         }
         ctx.terminate({ kind: 'return', value: null })
+      } else if (stmt.value?.kind === 'tuple_lit') {
+        // Tuple return — copy each element to __rf_0, __rf_1, ...
+        for (let i = 0; i < stmt.value.elements.length; i++) {
+          const val = lowerExpr(stmt.value.elements[i], ctx, scope)
+          ctx.emit({ kind: 'copy', dst: `__rf_${i}`, src: val })
+        }
+        ctx.terminate({ kind: 'return', value: null })
+      } else if (stmt.value?.kind === 'ident') {
+        // Check if returning an option struct var
+        const sv = ctx.structVars.get(stmt.value.name)
+        if (sv && sv.typeName === '__option') {
+          const hasT = sv.fields.get('has')!
+          const valT = sv.fields.get('val')!
+          ctx.emit({ kind: 'copy', dst: '__rf_has', src: { kind: 'temp', name: hasT } })
+          ctx.emit({ kind: 'copy', dst: '__rf_val', src: { kind: 'temp', name: valT } })
+          ctx.terminate({ kind: 'return', value: null })
+        } else {
+          const val = lowerExpr(stmt.value, ctx, scope)
+          ctx.terminate({ kind: 'return', value: val })
+        }
       } else {
         const val = stmt.value ? lowerExpr(stmt.value, ctx, scope) : null
         ctx.terminate({ kind: 'return', value: val })
@@ -622,6 +765,61 @@ function lowerStmt(
       break
     }
 
+    case 'if_let_some': {
+      // if let Some(x) = opt { ... }
+      // Lower: check opt.has, if 1 then bind x = opt.val and run then-block
+      const sv = (() => {
+        if (stmt.init.kind === 'ident') return ctx.structVars.get(stmt.init.name)
+        return undefined
+      })()
+
+      let hasOp: Operand
+      let valTemp: Temp | undefined
+
+      if (sv && sv.typeName === '__option') {
+        const hasT = sv.fields.get('has')!
+        const valT = sv.fields.get('val')!
+        hasOp = { kind: 'temp', name: hasT }
+        valTemp = valT
+      } else {
+        // General: evaluate init (e.g. function call returning option via __rf_has/__rf_val)
+        lowerExpr(stmt.init, ctx, scope)
+        const hasT = ctx.freshTemp()
+        const valT = ctx.freshTemp()
+        ctx.emit({ kind: 'copy', dst: hasT, src: { kind: 'temp', name: '__rf_has' } })
+        ctx.emit({ kind: 'copy', dst: valT, src: { kind: 'temp', name: '__rf_val' } })
+        hasOp = { kind: 'temp', name: hasT }
+        valTemp = valT
+      }
+
+      const thenBlock = ctx.newBlock('ifl_then')
+      const mergeBlock = ctx.newBlock('ifl_merge')
+      const elseBlock = stmt.else_ ? ctx.newBlock('ifl_else') : mergeBlock
+
+      ctx.terminate({ kind: 'branch', cond: hasOp, then: thenBlock.id, else: elseBlock.id })
+
+      // Then branch: bind x = val temp
+      ctx.switchTo(thenBlock)
+      const thenScope = new Map(scope)
+      if (valTemp) thenScope.set(stmt.binding, valTemp)
+      lowerBlock(stmt.then, ctx, thenScope)
+      if (isPlaceholderTerm(ctx.current().term)) {
+        ctx.terminate({ kind: 'jump', target: mergeBlock.id })
+      }
+
+      // Else branch
+      if (stmt.else_) {
+        ctx.switchTo(elseBlock)
+        lowerBlock(stmt.else_, ctx, new Map(scope))
+        if (isPlaceholderTerm(ctx.current().term)) {
+          ctx.terminate({ kind: 'jump', target: mergeBlock.id })
+        }
+      }
+
+      ctx.switchTo(mergeBlock)
+      break
+    }
+
     default: {
       const _exhaustive: never = stmt
       throw new Error(`Unknown HIR statement kind: ${(_exhaustive as any).kind}`)
@@ -767,7 +965,21 @@ function lowerExpr(
       return val
     }
 
+    case 'path_expr': {
+      // Enum variant access: Phase::Idle → integer constant
+      const variants = ctx.enumDefs.get(expr.enumName)
+      const value = variants?.get(expr.variant) ?? 0
+      return { kind: 'const', value }
+    }
+
     case 'member': {
+      // Enum variant access via dot syntax: Phase.Idle → integer constant
+      if (expr.obj.kind === 'ident') {
+        const enumVariants = ctx.enumDefs.get(expr.obj.name)
+        if (enumVariants && enumVariants.has(expr.field)) {
+          return { kind: 'const', value: enumVariants.get(expr.field)! }
+        }
+      }
       // Struct field access: v.x → return v's x temp
       if (expr.obj.kind === 'ident') {
         const sv = ctx.structVars.get(expr.obj.name)
@@ -888,6 +1100,37 @@ function lowerExpr(
       return { kind: 'temp', name: t }
     }
 
+    case 'tuple_lit': {
+      // Inline tuple literal as expression: store elements into __rf_ slots and return a dummy temp
+      // This happens when a tuple literal appears as an expression (e.g., passed to a function)
+      for (let i = 0; i < expr.elements.length; i++) {
+        const val = lowerExpr(expr.elements[i], ctx, scope)
+        ctx.emit({ kind: 'copy', dst: `__rf_${i}`, src: val })
+      }
+      const t = ctx.freshTemp()
+      ctx.emit({ kind: 'const', dst: t, value: 0 })
+      return { kind: 'temp', name: t }
+    }
+
+    case 'some_lit': {
+      // Some(expr) in expression context: store has=1,val into __rf_has/__rf_val slots
+      const valOp = lowerExpr(expr.value, ctx, scope)
+      ctx.emit({ kind: 'copy', dst: '__rf_has', src: { kind: 'const', value: 1 } })
+      ctx.emit({ kind: 'copy', dst: '__rf_val', src: valOp })
+      const t = ctx.freshTemp()
+      ctx.emit({ kind: 'const', dst: t, value: 1 })
+      return { kind: 'temp', name: t }
+    }
+
+    case 'none_lit': {
+      // None in expression context: store has=0,val=0 into __rf_has/__rf_val slots
+      ctx.emit({ kind: 'copy', dst: '__rf_has', src: { kind: 'const', value: 0 } })
+      ctx.emit({ kind: 'copy', dst: '__rf_val', src: { kind: 'const', value: 0 } })
+      const t = ctx.freshTemp()
+      ctx.emit({ kind: 'const', dst: t, value: 0 })
+      return { kind: 'temp', name: t }
+    }
+
     default: {
       const _exhaustive: never = expr
       throw new Error(`Unknown HIR expression kind: ${(_exhaustive as any).kind}`)

package/{src2 → src}/mir/types.ts

@@ -10,6 +10,13 @@
 // A temporary variable — unique within a function, named t0, t1, t2...
 export type Temp = string
 
+// Source location from the original .mcrs file
+export interface SourceLoc {
+  file: string
+  line: number
+  col: number
+}
+
 // An operand: either a temp or an inline constant
 export type Operand =
   | { kind: 'temp'; name: Temp }
@@ -45,7 +52,10 @@ export type ExecuteSubcmd =
 // MIR Instructions
 // ---------------------------------------------------------------------------
 
-export type MIRInstr =
+// Base type for all MIR instructions — carries optional source location
+export type MIRInstrBase = { sourceLoc?: SourceLoc }
+
+export type MIRInstr = MIRInstrBase & (
   // ── Constants & copies ──────────────────────────────────────────────────
   | { kind: 'const'; dst: Temp; value: number }
   | { kind: 'copy'; dst: Temp; src: Operand }
@@ -79,6 +89,7 @@ export type MIRInstr =
   | { kind: 'jump'; target: BlockId }
   | { kind: 'branch'; cond: Operand; then: BlockId; else: BlockId }
   | { kind: 'return'; value: Operand | null }
+)
 
 // ---------------------------------------------------------------------------
 // Basic block and function structure