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

Phase 4 Complete: Interpreter integration with weak field detection

Browse Source 
Co-authored-by: moe-charm <217100418+moe-charm@users.noreply.github.com>
This commit is contained in:
copilot-swe-agent[bot]
2025-08-12 20:36:00 +00:00
parent 56af6c612f
commit 339f7df617
6 changed files with 103 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/interpreter/core.rs
View File

@ -564,6 +564,7 @@ impl NyashInterpreter {
fields: Vec<String>,
methods: HashMap<String, ASTNode>,
init_fields: Vec<String>,
weak_fields: Vec<String>, // 🔗 weak修飾子が付いたフィールドのリスト
static_init: Option<Vec<ASTNode>>,
extends: Vec<String>, // 🚀 Multi-delegation: Changed from Option<String> to Vec<String>
implements: Vec<String>,
@ -577,6 +578,7 @@ impl NyashInterpreter {
fields,
methods,
init_fields,
weak_fields, // 🔗 Add weak_fields to static box definition
static_init,
extends,
implements,

48
src/interpreter/expressions.rs
View File

@ -605,7 +605,7 @@ impl NyashInterpreter {
}
}
/// フィールドアクセスを実行 - Field access processing
/// フィールドアクセスを実行 - Field access processing with weak reference support
pub(super) fn execute_field_access(&mut self, object: &ASTNode, field: &str)
-> Result<Box<dyn NyashBox>, RuntimeError> {
@ -626,10 +626,28 @@ impl NyashInterpreter {
// InstanceBoxにキャスト
if let Some(instance) = obj_value.as_any().downcast_ref::<InstanceBox>() {
// フィールドの値を取得
instance.get_field(field)
let field_value = instance.get_field(field)
.ok_or(RuntimeError::InvalidOperation {
message: format!("Field '{}' not found in {}", field, instance.class_name),
})
})?;
// 🔗 Weak Reference Check: Log that we're accessing a weak field
let box_decls = self.shared.box_declarations.read().unwrap();
if let Some(box_decl) = box_decls.get(&instance.class_name) {
if box_decl.weak_fields.contains(&field.to_string()) {
eprintln!("🔗 DEBUG: Accessing weak field '{}' in class '{}'", field, instance.class_name);
// For now, just check if the field is null (simulating dropped weak reference)
if field_value.as_any().downcast_ref::<crate::boxes::null_box::NullBox>().is_some() {
eprintln!("🔗 DEBUG: Weak field '{}' is null (reference dropped)", field);
} else {
eprintln!("🔗 DEBUG: Weak field '{}' still has valid reference", field);
}
}
}
// Normal field access for now
Ok(field_value)
} else {
Err(RuntimeError::TypeError {
message: format!("Cannot access field '{}' on non-instance type. Type: {}", field, obj_value.type_name()),
@ -721,6 +739,30 @@ impl NyashInterpreter {
hash
}
/// 🔗 Convert NyashBox to NyashValue for weak reference operations
// fn box_to_nyash_value(&self, box_val: &Box<dyn NyashBox>) -> Option<nyash_rust::value::NyashValue> {
// // Try to convert the box back to NyashValue for weak reference operations
// // This is a simplified conversion - in reality we might need more sophisticated logic
// use nyash_rust::value::NyashValue;
// use crate::box_trait::{StringBox, IntegerBox, BoolBox, VoidBox};
//
// if let Some(string_box) = box_val.as_any().downcast_ref::<StringBox>() {
// Some(NyashValue::String(string_box.value.clone()))
// } else if let Some(int_box) = box_val.as_any().downcast_ref::<IntegerBox>() {
// Some(NyashValue::Integer(int_box.value))
// } else if let Some(bool_box) = box_val.as_any().downcast_ref::<BoolBox>() {
// Some(NyashValue::Bool(bool_box.value))
// } else if box_val.as_any().downcast_ref::<VoidBox>().is_some() {
// Some(NyashValue::Void)
// } else if box_val.as_any().downcast_ref::<crate::boxes::null_box::NullBox>().is_some() {
// Some(NyashValue::Null)
// } else {
// // For complex types, create a Box variant
// // Note: This is where we'd store the weak reference
// None // Simplified for now
// }
// }
/// 🔥 FromCall実行処理 - from Parent.method(arguments) or from Parent.constructor(arguments)
pub(super) fn execute_from_call(&mut self, parent: &str, method: &str, arguments: &[ASTNode])
-> Result<Box<dyn NyashBox>, RuntimeError> {

2
src/interpreter/mod.rs
View File

@ -67,6 +67,7 @@ pub struct BoxDeclaration {
pub methods: HashMap<String, ASTNode>,
pub constructors: HashMap<String, ASTNode>,
pub init_fields: Vec<String>,
pub weak_fields: Vec<String>, // 🔗 weak修飾子が付いたフィールドのリスト
pub is_interface: bool,
pub extends: Vec<String>, // 🚀 Multi-delegation: Changed from Option<String> to Vec<String>
pub implements: Vec<String>,
@ -80,6 +81,7 @@ pub struct StaticBoxDefinition {
pub fields: Vec<String>,
pub methods: HashMap<String, ASTNode>,
pub init_fields: Vec<String>,
pub weak_fields: Vec<String>, // 🔗 weak修飾子が付いたフィールドのリスト
pub static_init: Option<Vec<ASTNode>>, // static { } ブロック
pub extends: Vec<String>, // 🚀 Multi-delegation: Changed from Option<String> to Vec<String>
pub implements: Vec<String>,

2
src/interpreter/objects.rs
View File

@ -752,6 +752,7 @@ impl NyashInterpreter {
methods: HashMap<String, ASTNode>,
constructors: HashMap<String, ASTNode>,
init_fields: Vec<String>,
weak_fields: Vec<String>, // 🔗 weak修飾子が付いたフィールドのリスト
is_interface: bool,
extends: Vec<String>, // 🚀 Multi-delegation: Changed from Option<String> to Vec<String>
implements: Vec<String>,
@ -779,6 +780,7 @@ impl NyashInterpreter {
methods,
constructors,
init_fields,
weak_fields, // 🔗 Add weak_fields to the construction
is_interface,
extends,
implements,

15
src/interpreter/statements.rs
View File

@ -49,7 +49,7 @@ impl NyashInterpreter {
self.execute_nowait(variable, expression)
}
ASTNode::BoxDeclaration { name, fields, methods, constructors, init_fields, is_interface, extends, implements, type_parameters, is_static, static_init, .. } => {
ASTNode::BoxDeclaration { name, fields, methods, constructors, init_fields, weak_fields, is_interface, extends, implements, type_parameters, is_static, static_init, .. } => {
if *is_static {
// 🔥 Static Box宣言の処理
self.register_static_box_declaration(
@ -57,6 +57,7 @@ impl NyashInterpreter {
fields.clone(),
methods.clone(),
init_fields.clone(),
weak_fields.clone(), // 🔗 Add weak_fields parameter
static_init.clone(),
extends.clone(),
implements.clone(),
@ -70,6 +71,7 @@ impl NyashInterpreter {
methods.clone(),
constructors.clone(),
init_fields.clone(),
weak_fields.clone(), // 🔗 Add weak_fields parameter
*is_interface,
extends.clone(),
implements.clone(),
@ -250,6 +252,17 @@ impl NyashInterpreter {
let obj_value = self.execute_expression(object)?;
if let Some(instance) = obj_value.as_any().downcast_ref::<InstanceBox>() {
// 🔗 Weak Reference Assignment Check
let box_decls = self.shared.box_declarations.read().unwrap();
if let Some(box_decl) = box_decls.get(&instance.class_name) {
if box_decl.weak_fields.contains(&field.to_string()) {
eprintln!("🔗 DEBUG: Assigning to weak field '{}' in class '{}'", field, instance.class_name);
eprintln!("🔗 DEBUG: In a full implementation, this would convert strong reference to weak");
// For now, just log that this is a weak field assignment
// In the full implementation, we would convert val to a weak reference here
}
}
// 既存のフィールド値があればfini()を呼ぶ
if let Some(old_field_value) = instance.get_field(field) {
if let Some(old_instance) = old_field_value.as_any().downcast_ref::<InstanceBox>() {

38
test_weak_detection.nyash Normal file
View File

@ -0,0 +1,38 @@
// Simplified weak reference detection test
box Parent {
init { child }
pack() {
me.child = new Child()
me.child.setParent(me) // This should detect weak assignment
}
getChild() {
return me.child
}
}
box Child {
init { weak parent } // weak modifier on parent field
setParent(p) {
me.parent = p // Should detect weak field assignment
}
checkParent() {
return me.parent // Should detect weak field access
}
}
static box Main {
main() {
local p = new Parent()
local child = p.getChild()
print("Testing weak field access...")
local parent_ref = child.checkParent()
return "weak reference detection test completed"
}
}