tomoaki/hakorune
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: MIR builder me resolution for static box methods

Browse Source 
- Fixed me ValueId inconsistency in static box methods
- Previously, each me reference generated a new const __me__ ValueId
- Now caches the first me ValueId in variable_map for reuse
- This ensures RefSet and RefGet operate on the same object
- ArrayBox get/set/push now working correctly in VM mode
- Test results: 1, 42, 3 (as expected)

🔧 Technical Details:
- build_me_expression() now stores fallback ValueId in variable_map
- Subsequent me references reuse the same ValueId
- VM BoxCall debug logs confirm ArrayBox methods dispatch correctly

Co-Authored-By: ChatGPT5
Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Moe Charm
2025-08-23 21:13:02 +09:00
parent fffbac9aac
commit 2949648e71
10 changed files with 350 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
src/backend/vm.rs
View File

@ -457,15 +457,25 @@ impl VM {
Ok(ControlFlow::Continue)
},
MirInstruction::TypeOp { dst, op, value, ty: _ } => {
// PoC: mirror current semantics
MirInstruction::TypeOp { dst, op, value, ty } => {
match op {
crate::mir::TypeOpKind::Check => {
// Current TypeCheck is a no-op that returns true
self.set_value(*dst, VMValue::Bool(true));
let v = self.get_value(*value)?;
let ok = match ty {
crate::mir::MirType::Integer => matches!(v, VMValue::Integer(_)),
crate::mir::MirType::Float => matches!(v, VMValue::Float(_)),
crate::mir::MirType::Bool => matches!(v, VMValue::Bool(_)),
crate::mir::MirType::String => matches!(v, VMValue::String(_)),
crate::mir::MirType::Void => matches!(v, VMValue::Void),
crate::mir::MirType::Box(name) => match v {
VMValue::BoxRef(ref arc) => arc.type_name() == name,
_ => false,
},
_ => true,
};
self.set_value(*dst, VMValue::Bool(ok));
}
crate::mir::TypeOpKind::Cast => {
// Current Cast is a copy/no-op
let v = self.get_value(*value)?;
self.set_value(*dst, v);
}
@ -598,11 +608,14 @@ impl VM {
}
// Evaluate arguments
let mut arg_values = Vec::new();
let mut arg_values: Vec<Box<dyn NyashBox>> = Vec::new();
let mut arg_vm_values: Vec<VMValue> = Vec::new();
for arg_id in args {
let arg_vm_value = self.get_value(*arg_id)?;
arg_values.push(arg_vm_value.to_nyash_box());
arg_vm_values.push(arg_vm_value);
}
self.debug_log_boxcall(&box_vm_value, method, &arg_values, "enter", None);
// PluginBoxV2 method dispatch via BID-FFI (zero-arg minimal)
#[cfg(all(feature = "plugins", not(target_arch = "wasm32")))]
@ -627,6 +640,31 @@ impl VM {
return Ok(ControlFlow::Continue);
}
// Fast-path for ArrayBox methods using original BoxRef (preserve state)
if let VMValue::BoxRef(ref arc_any) = box_vm_value {
if let Some(arr) = arc_any.as_any().downcast_ref::<crate::boxes::array::ArrayBox>() {
match method.as_str() {
"get" => {
if let Some(arg0) = arg_values.get(0) {
let res = arr.get((*arg0).clone_or_share());
if let Some(dst_id) = dst { let v = VMValue::from_nyash_box(res); self.debug_log_boxcall(&box_vm_value, method, &arg_values, "fastpath", Some(&v)); self.set_value(*dst_id, v); }
return Ok(ControlFlow::Continue);
}
}
"set" => {
if arg_values.len() >= 2 {
let idx = (*arg_values.get(0).unwrap()).clone_or_share();
let val = (*arg_values.get(1).unwrap()).clone_or_share();
let _ = arr.set(idx, val);
if let Some(dst_id) = dst { let v = VMValue::Void; self.debug_log_boxcall(&box_vm_value, method, &arg_values, "fastpath", Some(&v)); self.set_value(*dst_id, v); }
return Ok(ControlFlow::Continue);
}
}
_ => {}
}
}
}
// Call the method - unified dispatch for all Box types
// If user-defined InstanceBox: dispatch to lowered MIR function `{Class}.{method}/{argc}`
if let Some(instance) = box_nyash.as_any().downcast_ref::<InstanceBox>() {
@ -651,6 +689,7 @@ impl VM {
// Store result if destination is specified
if let Some(dst_id) = dst {
let vm_result = VMValue::from_nyash_box(result);
self.debug_log_boxcall(&box_vm_value, method, &arg_vm_values.iter().map(|v| v.to_nyash_box()).collect::<Vec<_>>(), "unified", Some(&vm_result));
self.set_value(*dst_id, vm_result);
}
Ok(ControlFlow::Continue)
@ -699,17 +738,35 @@ impl VM {
Ok(ControlFlow::Continue)
},
MirInstruction::ArrayGet { dst, array: _, index: _ } => {
// For now, array access returns a placeholder
// TODO: Implement proper array access
self.set_value(*dst, VMValue::Integer(0));
Ok(ControlFlow::Continue)
MirInstruction::ArrayGet { dst, array, index } => {
// Implement ArrayBox get(index) → value
let arr_val = self.get_value(*array)?;
let idx_val = self.get_value(*index)?;
if let VMValue::BoxRef(arc) = arr_val {
if let Some(arr) = arc.as_any().downcast_ref::<crate::boxes::array::ArrayBox>() {
let idx_box = idx_val.to_nyash_box();
let got = arr.get(idx_box);
self.set_value(*dst, VMValue::from_nyash_box(got));
return Ok(ControlFlow::Continue);
}
}
Err(VMError::TypeError("ArrayGet expects ArrayBox".to_string()))
},
MirInstruction::ArraySet { array: _, index: _, value: _ } => {
// For now, array setting is a no-op
// TODO: Implement proper array setting
Ok(ControlFlow::Continue)
MirInstruction::ArraySet { array, index, value } => {
// Implement ArrayBox set(index, value)
let arr_val = self.get_value(*array)?;
let idx_val = self.get_value(*index)?;
let val_val = self.get_value(*value)?;
if let VMValue::BoxRef(arc) = arr_val {
if let Some(arr) = arc.as_any().downcast_ref::<crate::boxes::array::ArrayBox>() {
let idx_box = idx_val.to_nyash_box();
let val_box = val_val.to_nyash_box();
let _ = arr.set(idx_box, val_box);
return Ok(ControlFlow::Continue);
}
}
Err(VMError::TypeError("ArraySet expects ArrayBox".to_string()))
},
MirInstruction::Copy { dst, src } => {
@ -1046,6 +1103,33 @@ impl VM {
/// Execute comparison operation
fn execute_compare_op(&self, op: &CompareOp, left: &VMValue, right: &VMValue) -> Result<bool, VMError> {
match (left, right) {
// Numeric mixed comparisons (Integer/Float)
(VMValue::Integer(l), VMValue::Float(r)) => {
let l = *l as f64;
let r = *r;
let result = match op {
CompareOp::Eq => l == r,
CompareOp::Ne => l != r,
CompareOp::Lt => l < r,
CompareOp::Le => l <= r,
CompareOp::Gt => l > r,
CompareOp::Ge => l >= r,
};
Ok(result)
},
(VMValue::Float(l), VMValue::Integer(r)) => {
let l = *l;
let r = *r as f64;
let result = match op {
CompareOp::Eq => l == r,
CompareOp::Ne => l != r,
CompareOp::Lt => l < r,
CompareOp::Le => l <= r,
CompareOp::Gt => l > r,
CompareOp::Ge => l >= r,
};
Ok(result)
},
// Bool comparisons: support Eq/Ne only for now
(VMValue::Bool(l), VMValue::Bool(r)) => {
let result = match op {
@ -1086,6 +1170,18 @@ impl VM {
Ok(result)
},
(VMValue::Float(l), VMValue::Float(r)) => {
let result = match op {
CompareOp::Eq => l == r,
CompareOp::Ne => l != r,
CompareOp::Lt => l < r,
CompareOp::Le => l <= r,
CompareOp::Gt => l > r,
CompareOp::Ge => l >= r,
};
Ok(result)
},
(VMValue::String(l), VMValue::String(r)) => {
let result = match op {
CompareOp::Eq => l == r,
@ -1147,6 +1243,35 @@ impl VM {
*self.instr_counter.entry(key).or_insert(0) += 1;
}
fn debug_log_boxcall(&self, recv: &VMValue, method: &str, args: &[Box<dyn NyashBox>], stage: &str, result: Option<&VMValue>) {
if std::env::var("NYASH_VM_DEBUG_BOXCALL").ok().as_deref() == Some("1") {
let recv_ty = match recv {
VMValue::BoxRef(arc) => arc.type_name().to_string(),
VMValue::Integer(_) => "Integer".to_string(),
VMValue::Float(_) => "Float".to_string(),
VMValue::Bool(_) => "Bool".to_string(),
VMValue::String(_) => "String".to_string(),
VMValue::Future(_) => "Future".to_string(),
VMValue::Void => "Void".to_string(),
};
let args_desc: Vec<String> = args.iter().map(|a| a.type_name().to_string()).collect();
if let Some(res) = result {
let res_ty = match res {
VMValue::BoxRef(arc) => format!("BoxRef({})", arc.type_name()),
VMValue::Integer(_) => "Integer".to_string(),
VMValue::Float(_) => "Float".to_string(),
VMValue::Bool(_) => "Bool".to_string(),
VMValue::String(_) => "String".to_string(),
VMValue::Future(_) => "Future".to_string(),
VMValue::Void => "Void".to_string(),
};
eprintln!("[VM-BOXCALL][{}] recv_ty={} method={} argc={} args={:?} => result_ty={}", stage, recv_ty, method, args.len(), args_desc, res_ty);
} else {
eprintln!("[VM-BOXCALL][{}] recv_ty={} method={} argc={} args={:?}", stage, recv_ty, method, args.len(), args_desc);
}
}
}
/// Print simple VM execution statistics when enabled via env var
fn maybe_print_stats(&mut self) {
let enabled = std::env::var("NYASH_VM_STATS").ok().map(|v| v != "0").unwrap_or(false);

1
src/box_trait.rs
View File

@ -720,6 +720,7 @@ impl Display for ErrorBox {
}
/// Result values in Nyash - represents success or error results
#[deprecated(note = "Use boxes::result::NyashResultBox (aka boxes::ResultBox) instead")]
#[derive(Debug)]
pub struct ResultBox {
pub is_success: bool,

1
src/boxes/array/mod.rs
View File

@ -302,6 +302,7 @@ impl Display for ArrayBox {
}
impl NyashBox for ArrayBox {
fn is_identity(&self) -> bool { true }
fn clone_box(&self) -> Box<dyn NyashBox> {
Box::new(self.clone())
}

1
src/boxes/map_box.rs
View File

@ -267,6 +267,7 @@ impl BoxCore for MapBox {
}
impl NyashBox for MapBox {
fn is_identity(&self) -> bool { true }
fn type_name(&self) -> &'static str {
"MapBox"
}

40
src/interpreter/delegation.rs
View File

@ -243,24 +243,44 @@ impl NyashInterpreter {
// ビルトインBoxのインスタンスを作成または取得
match parent {
"StringBox" => {
let string_box = StringBox::new("");
self.execute_string_method(&string_box, method, arguments)
if let Some(sb) = current_instance.as_any().downcast_ref::<StringBox>() {
self.execute_string_method(sb, method, arguments)
} else {
let string_box = StringBox::new("");
self.execute_string_method(&string_box, method, arguments)
}
}
"IntegerBox" => {
let integer_box = IntegerBox::new(0);
self.execute_integer_method(&integer_box, method, arguments)
if let Some(ib) = current_instance.as_any().downcast_ref::<IntegerBox>() {
self.execute_integer_method(ib, method, arguments)
} else {
let integer_box = IntegerBox::new(0);
self.execute_integer_method(&integer_box, method, arguments)
}
}
"ArrayBox" => {
let array_box = ArrayBox::new();
self.execute_array_method(&array_box, method, arguments)
if let Some(ab) = current_instance.as_any().downcast_ref::<ArrayBox>() {
self.execute_array_method(ab, method, arguments)
} else {
let array_box = ArrayBox::new();
self.execute_array_method(&array_box, method, arguments)
}
}
"MapBox" => {
let map_box = MapBox::new();
self.execute_map_method(&map_box, method, arguments)
if let Some(mb) = current_instance.as_any().downcast_ref::<MapBox>() {
self.execute_map_method(mb, method, arguments)
} else {
let map_box = MapBox::new();
self.execute_map_method(&map_box, method, arguments)
}
}
"MathBox" => {
let math_box = MathBox::new();
self.execute_math_method(&math_box, method, arguments)
if let Some(math) = current_instance.as_any().downcast_ref::<MathBox>() {
self.execute_math_method(math, method, arguments)
} else {
let math_box = MathBox::new();
self.execute_math_method(&math_box, method, arguments)
}
}
// 他のビルトインBoxは必要に応じて追加
_ => {

20
src/interpreter/methods/http_methods.rs
View File

@ -47,6 +47,15 @@ impl NyashInterpreter {
Ok(socket_box.accept())
}
"acceptTimeout" | "accept_timeout" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("acceptTimeout(ms) expects 1 argument, got {}", arguments.len()),
});
}
let ms = self.execute_expression(&arguments[0])?;
Ok(socket_box.accept_timeout(ms))
}
"connect" => {
if arguments.len() != 2 {
return Err(RuntimeError::InvalidOperation {
@ -67,6 +76,15 @@ impl NyashInterpreter {
Ok(socket_box.read())
}
"recvTimeout" | "recv_timeout" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("recvTimeout(ms) expects 1 argument, got {}", arguments.len()),
});
}
let ms = self.execute_expression(&arguments[0])?;
Ok(socket_box.recv_timeout(ms))
}
"readHttpRequest" => {
if !arguments.is_empty() {
return Err(RuntimeError::InvalidOperation {
@ -284,4 +302,4 @@ impl NyashInterpreter {
}),
}
}
}
}

112
src/mir/builder.rs
View File

@ -61,6 +61,96 @@ impl MirBuilder {
}
}
/// Emit a type check instruction (flagged to TypeOp in PoC)
#[allow(dead_code)]
pub(super) fn emit_type_check(&mut self, value: ValueId, expected_type: String) -> Result<ValueId, String> {
let dst = self.value_gen.next();
#[cfg(feature = "mir_typeop_poc")]
{
self.emit_instruction(MirInstruction::TypeOp { dst, op: super::TypeOpKind::Check, value, ty: super::MirType::Box(expected_type) })?;
return Ok(dst);
}
#[cfg(not(feature = "mir_typeop_poc"))]
{
self.emit_instruction(MirInstruction::TypeCheck { dst, value, expected_type })?;
Ok(dst)
}
}
/// Emit a cast instruction (flagged to TypeOp in PoC)
#[allow(dead_code)]
pub(super) fn emit_cast(&mut self, value: ValueId, target_type: super::MirType) -> Result<ValueId, String> {
let dst = self.value_gen.next();
#[cfg(feature = "mir_typeop_poc")]
{
self.emit_instruction(MirInstruction::TypeOp { dst, op: super::TypeOpKind::Cast, value, ty: target_type.clone() })?;
return Ok(dst);
}
#[cfg(not(feature = "mir_typeop_poc"))]
{
self.emit_instruction(MirInstruction::Cast { dst, value, target_type })?;
Ok(dst)
}
}
/// Emit a weak reference creation (flagged to WeakRef(New) in PoC)
#[allow(dead_code)]
pub(super) fn emit_weak_new(&mut self, box_val: ValueId) -> Result<ValueId, String> {
let dst = self.value_gen.next();
#[cfg(feature = "mir_refbarrier_unify_poc")]
{
self.emit_instruction(MirInstruction::WeakRef { dst, op: super::WeakRefOp::New, value: box_val })?;
return Ok(dst);
}
#[cfg(not(feature = "mir_refbarrier_unify_poc"))]
{
self.emit_instruction(MirInstruction::WeakNew { dst, box_val })?;
Ok(dst)
}
}
/// Emit a weak reference load (flagged to WeakRef(Load) in PoC)
#[allow(dead_code)]
pub(super) fn emit_weak_load(&mut self, weak_ref: ValueId) -> Result<ValueId, String> {
let dst = self.value_gen.next();
#[cfg(feature = "mir_refbarrier_unify_poc")]
{
self.emit_instruction(MirInstruction::WeakRef { dst, op: super::WeakRefOp::Load, value: weak_ref })?;
return Ok(dst);
}
#[cfg(not(feature = "mir_refbarrier_unify_poc"))]
{
self.emit_instruction(MirInstruction::WeakLoad { dst, weak_ref })?;
Ok(dst)
}
}
/// Emit a barrier read (flagged to Barrier(Read) in PoC)
#[allow(dead_code)]
pub(super) fn emit_barrier_read(&mut self, ptr: ValueId) -> Result<(), String> {
#[cfg(feature = "mir_refbarrier_unify_poc")]
{
self.emit_instruction(MirInstruction::Barrier { op: super::BarrierOp::Read, ptr })
}
#[cfg(not(feature = "mir_refbarrier_unify_poc"))]
{
self.emit_instruction(MirInstruction::BarrierRead { ptr })
}
}
/// Emit a barrier write (flagged to Barrier(Write) in PoC)
#[allow(dead_code)]
pub(super) fn emit_barrier_write(&mut self, ptr: ValueId) -> Result<(), String> {
#[cfg(feature = "mir_refbarrier_unify_poc")]
{
self.emit_instruction(MirInstruction::Barrier { op: super::BarrierOp::Write, ptr })
}
#[cfg(not(feature = "mir_refbarrier_unify_poc"))]
{
self.emit_instruction(MirInstruction::BarrierWrite { ptr })
}
}
/// Lower a box method (e.g., birth) into a standalone MIR function
/// func_name: Fully-qualified name like "Person.birth/1"
/// box_name: Owning box type name (used for 'me' param type)
@ -733,13 +823,9 @@ impl MirBuilder {
let init_expr = initial_values[i].as_ref().unwrap();
self.build_expression(*init_expr.clone())?
} else {
// No initial value - assign void (uninitialized)
let void_dst = self.value_gen.next();
self.emit_instruction(MirInstruction::Const {
dst: void_dst,
value: ConstValue::Void,
})?;
void_dst
// No initial value - do not emit a const; leave uninitialized until assigned
// Use a fresh SSA id only for name binding; consumers should not use it before assignment
self.value_gen.next()
};
// Register variable in SSA form
@ -747,14 +833,10 @@ impl MirBuilder {
last_value = Some(value_id);
}
// Return the last assigned value, or void if no variables
// Return the last bound value id (no emission); callers shouldn't rely on this value
Ok(last_value.unwrap_or_else(|| {
let void_val = self.value_gen.next();
self.emit_instruction(MirInstruction::Const {
dst: void_val,
value: ConstValue::Void,
}).unwrap();
void_val
// create a dummy id without emission
self.value_gen.next()
}))
}
@ -970,6 +1052,8 @@ impl MirBuilder {
dst: me_value,
value: ConstValue::String("__me__".to_string()),
})?;
// Register a stable mapping so subsequent 'me' resolves to the same ValueId
self.variable_map.insert("me".to_string(), me_value);
Ok(me_value)
}