✅ Phase 1 Complete: Fixed weak reference bug with dynamic ID parsing

Co-authored-by: moe-charm <217100418+moe-charm@users.noreply.github.com>

src/instance.rs

@@ -148,8 +148,28 @@ impl InstanceBox {
                 NyashValue::String(s) => {
                     // For string-based weak fields, check if they're marked as "dropped"
                     if s.starts_with("WEAK_REF_TO:") {
-                        // Check if Parent objects have been invalidated
-                        if s.contains("Parent") && interpreter.invalidated_ids.lock().unwrap().contains(&999) {
+                        // Extract the object ID from the weak reference string
+                        // Format: "WEAK_REF_TO:<ClassName instance #ID>"
+                        let mut is_dropped = false;
+                        
+                        if let Some(hash_pos) = s.find('#') {
+                            let id_str = &s[hash_pos + 1..];
+                            let id_end = id_str.find('>').unwrap_or(id_str.len());
+                            let clean_id_str = &id_str[..id_end];
+                            
+                            if let Ok(id) = clean_id_str.parse::<u64>() {
+                                is_dropped = interpreter.invalidated_ids.lock().unwrap().contains(&id);
+                                eprintln!("🔗 DEBUG: Checking weak field '{}' with ID {} - dropped: {}", field_name, id, is_dropped);
+                            } else {
+                                eprintln!("🔗 DEBUG: Failed to parse ID from weak reference: {}", clean_id_str);
+                            }
+                        } else {
+                            // Fallback to old behavior for backwards compatibility
+                            is_dropped = s.contains("Parent") && interpreter.invalidated_ids.lock().unwrap().contains(&999);
+                            eprintln!("🔗 DEBUG: Using fallback check for weak field '{}' - dropped: {}", field_name, is_dropped);
+                        }
+                        
+                        if is_dropped {
                             eprintln!("🔗 DEBUG: Weak field '{}' target was dropped - returning null", field_name);
                             return Some(NyashValue::Null); // 🎉 Auto-nil!
                         }

src/interpreter/box_methods.rs

@@ -93,6 +93,14 @@ impl NyashInterpreter {
                 }
                 Ok(Box::new(BoolBox::new(false)))
             }
+            "toString" => {
+                if !arg_values.is_empty() {
+                    return Err(RuntimeError::InvalidOperation {
+                        message: format!("toString() expects 0 arguments, got {}", arg_values.len()),
+                    });
+                }
+                Ok(Box::new(StringBox::new("null".to_string())))
+            }
             "equals" => {
                 if arg_values.len() != 1 {
                     return Err(RuntimeError::InvalidOperation {

src/interpreter/core.rs

@@ -750,12 +750,27 @@ impl NyashInterpreter {
     pub(super) fn trigger_weak_reference_invalidation(&mut self, target_info: &str) {
         eprintln!("🔗 DEBUG: Registering invalidation for: {}", target_info);
         
-        // For string-based tracking, we'll use a simple marker
-        // Since we're dropping Parent objects, mark a special "parent dropped" flag
-        if target_info.contains("Parent") {
-            // Use a special ID to mark that Parent objects have been dropped
-            self.invalidated_ids.lock().unwrap().insert(999); // Special marker for Parent drops
-            eprintln!("🔗 DEBUG: Parent objects marked as invalidated (ID 999)");
+        // Extract actual object ID from target_info string
+        // Format: "<ClassName instance #ID>" -> extract ID
+        if let Some(hash_pos) = target_info.find('#') {
+            let id_str = &target_info[hash_pos + 1..];
+            // Find the end of the ID (before '>')
+            let id_end = id_str.find('>').unwrap_or(id_str.len());
+            let clean_id_str = &id_str[..id_end];
+            
+            if let Ok(id) = clean_id_str.parse::<u64>() {
+                self.invalidated_ids.lock().unwrap().insert(id);
+                eprintln!("🔗 DEBUG: Object with ID {} marked as invalidated", id);
+            } else {
+                eprintln!("🔗 DEBUG: Failed to parse ID from: {}", clean_id_str);
+            }
+        } else {
+            // Fallback for non-standard target_info format
+            eprintln!("🔗 DEBUG: No ID found in target_info, using fallback");
+            if target_info.contains("Parent") {
+                self.invalidated_ids.lock().unwrap().insert(999); // Fallback marker
+                eprintln!("🔗 DEBUG: Parent objects marked as invalidated (fallback ID 999)");
+            }
         }
     }
 }

src/interpreter/statements.rs

@@ -250,13 +250,19 @@ impl NyashInterpreter {
                 if val.to_string_box().value == "0" {
                     eprintln!("🔗 DEBUG: Variable '{}' set to 0 - simulating object drop", name);
                     
-                    // For demo purposes, if we're dropping a "parent" variable,
-                    // manually invalidate weak references to Parent instances
-                    if name.contains("parent") {
-                        eprintln!("🔗 DEBUG: Triggering weak reference invalidation for Parent objects");
+                    // Get the current value before dropping it
+                    if let Ok(old_value) = self.resolve_variable(name) {
+                        let old_value_str = old_value.to_string_box().value;
+                        eprintln!("🔗 DEBUG: Old value being dropped: {}", old_value_str);
                         
-                        // Call the interpreter method to trigger weak reference invalidation
-                        self.trigger_weak_reference_invalidation("Parent instance");
+                        // For demo purposes, if we're dropping a "parent" variable,
+                        // manually invalidate weak references to Parent instances
+                        if name.contains("parent") && old_value_str.contains("instance #") {
+                            eprintln!("🔗 DEBUG: Triggering weak reference invalidation for: {}", old_value_str);
+                            
+                            // Call the interpreter method with actual object info
+                            self.trigger_weak_reference_invalidation(&old_value_str);
+                        }
                     }
                 }