/*! * MIR Instruction Set - 20 Core Instructions per ChatGPT5 Design * * SSA-form instructions with effect tracking for optimization */ use super::{Effect, EffectMask, ValueId}; use crate::mir::definitions::Callee; // Import Callee from unified definitions use crate::mir::types::{ BarrierOp, BinaryOp, CompareOp, ConstValue, MirType, TypeOpKind, UnaryOp, WeakRefOp, }; // use crate::value::NyashValue; // Commented out to avoid circular dependency use std::fmt; // Kind-specific metadata (non-functional refactor scaffolding) use crate::mir::instruction_kinds as inst_meta; /// MIR instruction types - limited to 20 core instructions #[derive(Debug, Clone, PartialEq)] pub enum MirInstruction { // === Constants and Values === /// Load a constant value /// `%dst = const value` Const { dst: ValueId, value: ConstValue }, // === Arithmetic Operations === /// Binary arithmetic operation /// `%dst = %lhs op %rhs` BinOp { dst: ValueId, op: BinaryOp, lhs: ValueId, rhs: ValueId, }, /// Unary operation /// `%dst = op %operand` UnaryOp { dst: ValueId, op: UnaryOp, operand: ValueId, }, // === Comparison Operations === /// Compare two values /// `%dst = %lhs cmp %rhs` Compare { dst: ValueId, op: CompareOp, lhs: ValueId, rhs: ValueId, }, // === Memory Operations === /// Load from memory/variable /// `%dst = load %ptr` Load { dst: ValueId, ptr: ValueId }, /// Store to memory/variable /// `store %value -> %ptr` Store { value: ValueId, ptr: ValueId }, // === Function Calls === /// Call a function with type-safe target resolution /// `%dst = call %func(%args...)` (legacy) /// `%dst = call Global("print")(%args...)` (new) /// /// Phase 1 Migration: Both func and callee fields present /// - callee: Some(_) -> Use new type-safe resolution (preferred) /// - callee: None -> Fall back to legacy string-based resolution Call { dst: Option, func: ValueId, // Legacy: string-based resolution (deprecated) callee: Option, // New: type-safe resolution (preferred) args: Vec, effects: EffectMask, }, /// Create a function value (FunctionBox) from params/body and optional captures /// `%dst = new_closure [params] {body} [captures...]` /// Minimal lowering support: captures may be empty; 'me' is optional. NewClosure { dst: ValueId, params: Vec, body: Vec, /// Pairs of (name, value) to capture by value captures: Vec<(String, ValueId)>, /// Optional 'me' value to capture weakly if it is a BoxRef at runtime me: Option, }, /// Box method invocation /// `%dst = invoke %box.method(%args...)` /// method_id: Optional numeric slot id when resolved at build time BoxCall { dst: Option, box_val: ValueId, method: String, /// Optional numeric method slot id (Unified Registry). None = late bind. method_id: Option, args: Vec, effects: EffectMask, }, /// Plugin invocation (forces plugin path; no builtin fallback) /// `%dst = plugin_invoke %box.method(%args...)` PluginInvoke { dst: Option, box_val: ValueId, method: String, args: Vec, effects: EffectMask, }, // === Control Flow === /// Conditional branch /// `br %condition -> %then_bb, %else_bb` Branch { condition: ValueId, then_bb: super::BasicBlockId, else_bb: super::BasicBlockId, }, /// Unconditional jump /// `jmp %target_bb` Jump { target: super::BasicBlockId }, /// Return from function /// `ret %value` or `ret void` Return { value: Option }, // === SSA Phi Function === /// SSA phi function for merging values from different paths /// `%dst = phi [%val1 from %bb1, %val2 from %bb2, ...]` Phi { dst: ValueId, inputs: Vec<(super::BasicBlockId, ValueId)>, }, // === Box Operations === /// Create a new Box instance /// `%dst = new_box "BoxType"(%args...)` NewBox { dst: ValueId, box_type: String, args: Vec, }, /// Check Box type /// `%dst = type_check %box "BoxType"` TypeCheck { dst: ValueId, value: ValueId, expected_type: String, }, // === Type Conversion === /// Convert between types /// `%dst = cast %value as Type` Cast { dst: ValueId, value: ValueId, target_type: MirType, }, // === Type Operations (Unified PoC) === /// Unified type operation (PoC): Check or Cast /// `%dst = typeop(check|cast, %value, Type)` TypeOp { dst: ValueId, op: TypeOpKind, value: ValueId, ty: MirType, }, // === Array Operations === /// Get array element /// `%dst = %array[%index]` ArrayGet { dst: ValueId, array: ValueId, index: ValueId, }, /// Set array element /// `%array[%index] = %value` ArraySet { array: ValueId, index: ValueId, value: ValueId, }, // === Special Operations === /// Copy a value (for optimization passes) /// `%dst = copy %src` Copy { dst: ValueId, src: ValueId }, /// Debug/introspection instruction /// `debug %value "message"` Debug { value: ValueId, message: String }, /// Print instruction for console output /// `print %value` Print { value: ValueId, effects: EffectMask }, /// No-op instruction (for optimization placeholders) Nop, // === Control Flow & Exception Handling (Phase 5) === /// Throw an exception /// `throw %exception_value` Throw { exception: ValueId, effects: EffectMask, }, /// Catch handler setup (landing pad for exceptions) /// `catch %exception_type -> %handler_bb` Catch { exception_type: Option, // None = catch-all exception_value: ValueId, // Where to store caught exception handler_bb: super::BasicBlockId, }, /// Safepoint instruction (no-op for now, can be used for GC/debugging) /// `safepoint` Safepoint, // === Phase 6: Box Reference Operations === /// Create a new reference to a Box /// `%dst = ref_new %box` RefNew { dst: ValueId, box_val: ValueId }, /// Get/dereference a Box field through reference /// `%dst = ref_get %ref.field` RefGet { dst: ValueId, reference: ValueId, field: String, }, /// Set/assign Box field through reference /// `ref_set %ref.field = %value` RefSet { reference: ValueId, field: String, value: ValueId, }, /// Create a weak reference to a Box /// `%dst = weak_new %box` WeakNew { dst: ValueId, box_val: ValueId }, /// Load from weak reference (if still alive) /// `%dst = weak_load %weak_ref` WeakLoad { dst: ValueId, weak_ref: ValueId }, /// Memory barrier read (no-op for now, proper effect annotation) /// `barrier_read %ptr` BarrierRead { ptr: ValueId }, /// Memory barrier write (no-op for now, proper effect annotation) /// `barrier_write %ptr` BarrierWrite { ptr: ValueId }, // === Unified PoC: WeakRef/Barrier (flags-only scaffolding) === /// Unified weak reference op (PoC) /// `%dst = weakref new %box` or `%dst = weakref load %weak` WeakRef { dst: ValueId, op: WeakRefOp, value: ValueId, }, /// Unified barrier op (PoC) /// `barrier read %ptr` or `barrier write %ptr` Barrier { op: BarrierOp, ptr: ValueId }, // === Phase 7: Async/Future Operations === /// Create a new Future with initial value /// `%dst = future_new %value` FutureNew { dst: ValueId, value: ValueId }, /// Set Future value and mark as ready /// `future_set %future = %value` FutureSet { future: ValueId, value: ValueId }, /// Wait for Future completion and get value /// `%dst = await %future` Await { dst: ValueId, future: ValueId }, // === Phase 9.7: External Function Calls (Box FFI/ABI) === /// External function call through Box FFI/ABI /// `%dst = extern_call interface.method(%args...)` ExternCall { dst: Option, iface_name: String, // e.g., "env.console" method_name: String, // e.g., "log" args: Vec, effects: EffectMask, }, } // types moved to crate::mir::types impl MirInstruction { /// Get the effect mask for this instruction pub fn effects(&self) -> EffectMask { if let Some(eff) = inst_meta::effects_via_meta(self) { return eff; } match self { // Pure operations MirInstruction::Const { .. } | MirInstruction::BinOp { .. } | MirInstruction::UnaryOp { .. } | MirInstruction::Compare { .. } | MirInstruction::Cast { .. } | MirInstruction::TypeOp { .. } | MirInstruction::Copy { .. } | MirInstruction::Phi { .. } | MirInstruction::TypeCheck { .. } | MirInstruction::Nop => EffectMask::PURE, // Memory operations MirInstruction::Load { .. } => EffectMask::READ, MirInstruction::Store { .. } | MirInstruction::ArraySet { .. } => EffectMask::WRITE, MirInstruction::ArrayGet { .. } => EffectMask::READ, // Function calls use provided effect mask MirInstruction::Call { effects, .. } | MirInstruction::BoxCall { effects, .. } | MirInstruction::PluginInvoke { effects, .. } => *effects, // Control flow (pure but affects execution) MirInstruction::Branch { .. } | MirInstruction::Jump { .. } | MirInstruction::Return { .. } => EffectMask::PURE, // Box creation may allocate MirInstruction::NewBox { .. } => EffectMask::PURE.add(Effect::Alloc), // Debug has debug effect MirInstruction::Debug { .. } => EffectMask::PURE.add(Effect::Debug), // Print has external write effect MirInstruction::Print { effects, .. } => *effects, // Phase 5: Control flow & exception handling MirInstruction::Throw { effects, .. } => *effects, MirInstruction::Catch { .. } => EffectMask::CONTROL, // Handler setup affects control handling MirInstruction::Safepoint => EffectMask::PURE, // No-op for now // Phase 6: Box reference operations MirInstruction::RefNew { .. } => EffectMask::PURE, // Creating reference is pure MirInstruction::RefGet { .. } => EffectMask::READ, // Reading field has read effects MirInstruction::RefSet { .. } => EffectMask::WRITE, // Writing field has write effects MirInstruction::WeakNew { .. } => EffectMask::PURE, // Creating weak ref is pure MirInstruction::WeakLoad { .. } => EffectMask::READ, // Loading weak ref has read effects MirInstruction::BarrierRead { .. } => EffectMask::READ.add(Effect::Barrier), // Memory barrier with read MirInstruction::BarrierWrite { .. } => EffectMask::WRITE.add(Effect::Barrier), // Memory barrier with write // PoC unified ops mirror legacy effects MirInstruction::WeakRef { op, .. } => match op { WeakRefOp::New => EffectMask::PURE, WeakRefOp::Load => EffectMask::READ, }, MirInstruction::Barrier { op, .. } => match op { BarrierOp::Read => EffectMask::READ.add(Effect::Barrier), BarrierOp::Write => EffectMask::WRITE.add(Effect::Barrier), }, // Phase 7: Async/Future Operations MirInstruction::FutureNew { .. } => EffectMask::PURE.add(Effect::Alloc), // Creating future may allocate MirInstruction::FutureSet { .. } => EffectMask::WRITE, // Setting future has write effects MirInstruction::Await { .. } => EffectMask::READ.add(Effect::Async), // Await blocks and reads // Phase 9.7: External Function Calls MirInstruction::ExternCall { effects, .. } => *effects, // Use provided effect mask // Function value construction: treat as pure with allocation MirInstruction::NewClosure { .. } => EffectMask::PURE.add(Effect::Alloc), } } /// Get the destination ValueId if this instruction produces a value pub fn dst_value(&self) -> Option { if let Some(dst) = inst_meta::dst_via_meta(self) { return Some(dst); } match self { MirInstruction::Const { dst, .. } | MirInstruction::BinOp { dst, .. } | MirInstruction::UnaryOp { dst, .. } | MirInstruction::Compare { dst, .. } | MirInstruction::Load { dst, .. } | MirInstruction::Phi { dst, .. } | MirInstruction::NewBox { dst, .. } | MirInstruction::TypeCheck { dst, .. } | MirInstruction::Cast { dst, .. } | MirInstruction::TypeOp { dst, .. } | MirInstruction::ArrayGet { dst, .. } | MirInstruction::Copy { dst, .. } | MirInstruction::RefNew { dst, .. } | MirInstruction::RefGet { dst, .. } | MirInstruction::WeakNew { dst, .. } | MirInstruction::WeakLoad { dst, .. } | MirInstruction::WeakRef { dst, .. } | MirInstruction::FutureNew { dst, .. } | MirInstruction::Await { dst, .. } => Some(*dst), MirInstruction::NewClosure { dst, .. } => Some(*dst), MirInstruction::Call { dst, .. } | MirInstruction::BoxCall { dst, .. } | MirInstruction::PluginInvoke { dst, .. } | MirInstruction::ExternCall { dst, .. } => *dst, MirInstruction::Store { .. } | MirInstruction::Branch { .. } | MirInstruction::Jump { .. } | MirInstruction::Return { .. } | MirInstruction::ArraySet { .. } | MirInstruction::Debug { .. } | MirInstruction::Print { .. } | MirInstruction::Throw { .. } | MirInstruction::RefSet { .. } | MirInstruction::BarrierRead { .. } | MirInstruction::BarrierWrite { .. } | MirInstruction::Barrier { .. } | MirInstruction::FutureSet { .. } | MirInstruction::Safepoint | MirInstruction::Nop => None, MirInstruction::Catch { exception_value, .. } => Some(*exception_value), } } /// Get all ValueIds used by this instruction pub fn used_values(&self) -> Vec { if let Some(used) = inst_meta::used_via_meta(self) { return used; } match self { MirInstruction::Const { .. } | MirInstruction::Jump { .. } | MirInstruction::Nop => { Vec::new() } MirInstruction::UnaryOp { operand, .. } | MirInstruction::Load { ptr: operand, .. } | MirInstruction::TypeCheck { value: operand, .. } | MirInstruction::Cast { value: operand, .. } | MirInstruction::TypeOp { value: operand, .. } | MirInstruction::Copy { src: operand, .. } | MirInstruction::Debug { value: operand, .. } | MirInstruction::Print { value: operand, .. } => vec![*operand], MirInstruction::BinOp { lhs, rhs, .. } | MirInstruction::Compare { lhs, rhs, .. } | MirInstruction::Store { value: lhs, ptr: rhs, .. } => vec![*lhs, *rhs], MirInstruction::ArrayGet { array, index, .. } => vec![*array, *index], MirInstruction::ArraySet { array, index, value, } => vec![*array, *index, *value], MirInstruction::Branch { condition, .. } => vec![*condition], MirInstruction::Return { value } => value.map(|v| vec![v]).unwrap_or_default(), MirInstruction::Call { func, args, .. } => { let mut used = vec![*func]; used.extend(args); used } MirInstruction::NewClosure { captures, me, .. } => { let mut used: Vec = Vec::new(); used.extend(captures.iter().map(|(_, v)| *v)); if let Some(m) = me { used.push(*m); } used } MirInstruction::BoxCall { box_val, args, .. } | MirInstruction::PluginInvoke { box_val, args, .. } => { let mut used = vec![*box_val]; used.extend(args); used } MirInstruction::NewBox { args, .. } => args.clone(), MirInstruction::Phi { inputs, .. } => inputs.iter().map(|(_, value)| *value).collect(), // Phase 5: Control flow & exception handling MirInstruction::Throw { exception, .. } => vec![*exception], MirInstruction::Catch { .. } => Vec::new(), // Handler setup doesn't use values MirInstruction::Safepoint => Vec::new(), // Phase 6: Box reference operations MirInstruction::RefNew { box_val, .. } => vec![*box_val], MirInstruction::RefGet { reference, .. } => vec![*reference], MirInstruction::RefSet { reference, value, .. } => vec![*reference, *value], MirInstruction::WeakNew { box_val, .. } => vec![*box_val], MirInstruction::WeakLoad { weak_ref, .. } => vec![*weak_ref], MirInstruction::BarrierRead { ptr } => vec![*ptr], MirInstruction::BarrierWrite { ptr } => vec![*ptr], MirInstruction::WeakRef { value, .. } => vec![*value], MirInstruction::Barrier { ptr, .. } => vec![*ptr], // Phase 7: Async/Future Operations MirInstruction::FutureNew { value, .. } => vec![*value], MirInstruction::FutureSet { future, value } => vec![*future, *value], MirInstruction::Await { future, .. } => vec![*future], // Phase 9.7: External Function Calls MirInstruction::ExternCall { args, .. } => args.clone(), } } } // enums TypeOpKind/WeakRefOp/BarrierOp moved to crate::mir::types impl ConstValue { /* /// Convert to NyashValue pub fn to_nyash_value(&self) -> NyashValue { match self { ConstValue::Integer(n) => NyashValue::new_integer(*n), ConstValue::Float(f) => NyashValue::new_float(*f), ConstValue::Bool(b) => NyashValue::new_bool(*b), ConstValue::String(s) => NyashValue::new_string(s.clone()), ConstValue::Null => NyashValue::new_null(), ConstValue::Void => NyashValue::new_void(), } } /// Create from NyashValue pub fn from_nyash_value(value: &NyashValue) -> Option { match value { NyashValue::Integer(n) => Some(ConstValue::Integer(*n)), NyashValue::Float(f) => Some(ConstValue::Float(*f)), NyashValue::Bool(b) => Some(ConstValue::Bool(*b)), NyashValue::String(s) => Some(ConstValue::String(s.clone())), NyashValue::Null => Some(ConstValue::Null), NyashValue::Void => Some(ConstValue::Void), _ => None, // Collections and Boxes can't be constants } } */ } impl fmt::Display for MirInstruction { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { MirInstruction::Const { dst, value } => { write!(f, "{} = const {}", dst, value) } MirInstruction::BinOp { dst, op, lhs, rhs } => { write!(f, "{} = {} {:?} {}", dst, lhs, op, rhs) } MirInstruction::UnaryOp { dst, op, operand } => { write!(f, "{} = {:?} {}", dst, op, operand) } MirInstruction::Compare { dst, op, lhs, rhs } => { write!(f, "{} = {} {:?} {}", dst, lhs, op, rhs) } MirInstruction::Load { dst, ptr } => { write!(f, "{} = load {}", dst, ptr) } MirInstruction::Store { value, ptr } => { write!(f, "store {} -> {}", value, ptr) } MirInstruction::Call { dst, func, callee: _, // TODO: Use callee for type-safe resolution display args, effects, } => { if let Some(dst) = dst { write!( f, "{} = call {}({}); effects: {}", dst, func, args.iter() .map(|v| format!("{}", v)) .collect::>() .join(", "), effects ) } else { write!( f, "call {}({}); effects: {}", func, args.iter() .map(|v| format!("{}", v)) .collect::>() .join(", "), effects ) } } MirInstruction::PluginInvoke { dst, box_val, method, args, effects: _, } => { if let Some(dst) = dst { write!( f, "{} = plugin_invoke {}.{}({})", dst, box_val, method, args.iter() .map(|v| format!("{}", v)) .collect::>() .join(", ") ) } else { write!( f, "plugin_invoke {}.{}({})", box_val, method, args.iter() .map(|v| format!("{}", v)) .collect::>() .join(", ") ) } } MirInstruction::Return { value } => { if let Some(value) = value { write!(f, "ret {}", value) } else { write!(f, "ret void") } } MirInstruction::ExternCall { dst, iface_name, method_name, args, effects, } => { if let Some(dst) = dst { write!( f, "{} = extern_call {}.{}({}); effects: {}", dst, iface_name, method_name, args.iter() .map(|v| format!("{}", v)) .collect::>() .join(", "), effects ) } else { write!( f, "extern_call {}.{}({}); effects: {}", iface_name, method_name, args.iter() .map(|v| format!("{}", v)) .collect::>() .join(", "), effects ) } } _ => write!(f, "{:?}", self), // Fallback for other instructions } } } // Display for ConstValue moved to crate::mir::types #[cfg(test)] mod tests { use super::*; #[test] fn test_const_instruction() { let dst = ValueId::new(0); let inst = MirInstruction::Const { dst, value: ConstValue::Integer(42), }; assert_eq!(inst.dst_value(), Some(dst)); assert!(inst.used_values().is_empty()); assert!(inst.effects().is_pure()); } #[test] fn test_binop_instruction() { let dst = ValueId::new(0); let lhs = ValueId::new(1); let rhs = ValueId::new(2); let inst = MirInstruction::BinOp { dst, op: BinaryOp::Add, lhs, rhs, }; assert_eq!(inst.dst_value(), Some(dst)); assert_eq!(inst.used_values(), vec![lhs, rhs]); assert!(inst.effects().is_pure()); } #[test] fn test_call_instruction() { let dst = ValueId::new(0); let func = ValueId::new(1); let arg1 = ValueId::new(2); let arg2 = ValueId::new(3); let inst = MirInstruction::Call { dst: Some(dst), func, args: vec![arg1, arg2], effects: EffectMask::IO, }; assert_eq!(inst.dst_value(), Some(dst)); assert_eq!(inst.used_values(), vec![func, arg1, arg2]); assert_eq!(inst.effects(), EffectMask::IO); } /* #[test] fn test_const_value_conversion() { let const_val = ConstValue::Integer(42); let nyash_val = const_val.to_nyash_value(); assert_eq!(nyash_val, NyashValue::new_integer(42)); let back = ConstValue::from_nyash_value(&nyash_val).unwrap(); assert_eq!(back, const_val); } */ #[test] fn test_ref_new_instruction() { let dst = ValueId::new(0); let box_val = ValueId::new(1); let inst = MirInstruction::RefNew { dst, box_val }; assert_eq!(inst.dst_value(), Some(dst)); assert_eq!(inst.used_values(), vec![box_val]); assert!(inst.effects().is_pure()); } #[test] fn test_ref_get_instruction() { let dst = ValueId::new(0); let reference = ValueId::new(1); let field = "name".to_string(); let inst = MirInstruction::RefGet { dst, reference, field, }; assert_eq!(inst.dst_value(), Some(dst)); assert_eq!(inst.used_values(), vec![reference]); assert!(!inst.effects().is_pure()); assert!(inst .effects() .contains(super::super::effect::Effect::ReadHeap)); } #[test] fn test_ref_set_instruction() { let reference = ValueId::new(0); let field = "value".to_string(); let value = ValueId::new(1); let inst = MirInstruction::RefSet { reference, field, value, }; assert_eq!(inst.dst_value(), None); assert_eq!(inst.used_values(), vec![reference, value]); assert!(!inst.effects().is_pure()); assert!(inst .effects() .contains(super::super::effect::Effect::WriteHeap)); } #[test] fn test_weak_new_instruction() { let dst = ValueId::new(0); let box_val = ValueId::new(1); let inst = MirInstruction::WeakNew { dst, box_val }; assert_eq!(inst.dst_value(), Some(dst)); assert_eq!(inst.used_values(), vec![box_val]); assert!(inst.effects().is_pure()); } #[test] fn test_weak_load_instruction() { let dst = ValueId::new(0); let weak_ref = ValueId::new(1); let inst = MirInstruction::WeakLoad { dst, weak_ref }; assert_eq!(inst.dst_value(), Some(dst)); assert_eq!(inst.used_values(), vec![weak_ref]); assert!(!inst.effects().is_pure()); assert!(inst .effects() .contains(super::super::effect::Effect::ReadHeap)); } #[test] fn test_barrier_instructions() { let ptr = ValueId::new(0); let read_barrier = MirInstruction::BarrierRead { ptr }; assert_eq!(read_barrier.dst_value(), None); assert_eq!(read_barrier.used_values(), vec![ptr]); assert!(read_barrier .effects() .contains(super::super::effect::Effect::Barrier)); assert!(read_barrier .effects() .contains(super::super::effect::Effect::ReadHeap)); let write_barrier = MirInstruction::BarrierWrite { ptr }; assert_eq!(write_barrier.dst_value(), None); assert_eq!(write_barrier.used_values(), vec![ptr]); assert!(write_barrier .effects() .contains(super::super::effect::Effect::Barrier)); assert!(write_barrier .effects() .contains(super::super::effect::Effect::WriteHeap)); } #[test] fn test_extern_call_instruction() { let dst = ValueId::new(0); let arg1 = ValueId::new(1); let arg2 = ValueId::new(2); let inst = MirInstruction::ExternCall { dst: Some(dst), iface_name: "env.console".to_string(), method_name: "log".to_string(), args: vec![arg1, arg2], effects: super::super::effect::EffectMask::IO, }; assert_eq!(inst.dst_value(), Some(dst)); assert_eq!(inst.used_values(), vec![arg1, arg2]); assert_eq!(inst.effects(), super::super::effect::EffectMask::IO); // Test void extern call let void_inst = MirInstruction::ExternCall { dst: None, iface_name: "env.canvas".to_string(), method_name: "fillRect".to_string(), args: vec![arg1], effects: super::super::effect::EffectMask::IO, }; assert_eq!(void_inst.dst_value(), None); assert_eq!(void_inst.used_values(), vec![arg1]); } }