method-ray 0.1.9 → 0.1.10

data/core/src/graph/box.rs

@@ -54,6 +54,8 @@ pub struct MethodCallBox {
     arg_vtxs: Vec<VertexId>,
     kwarg_vtxs: Option<HashMap<String, VertexId>>,
     location: Option<SourceLocation>, // Source code location
+    /// Whether this is a safe navigation call (`&.`)
+    safe_navigation: bool,
     /// Number of times this box has been rescheduled
     reschedule_count: u8,
 }
@@ -62,6 +64,7 @@ pub struct MethodCallBox {
 const MAX_RESCHEDULE_COUNT: u8 = 3;
 
 impl MethodCallBox {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         id: BoxId,
         recv: VertexId,
@@ -70,6 +73,7 @@ impl MethodCallBox {
         arg_vtxs: Vec<VertexId>,
         kwarg_vtxs: Option<HashMap<String, VertexId>>,
         location: Option<SourceLocation>,
+        safe_navigation: bool,
     ) -> Self {
         Self {
             id,
@@ -79,6 +83,7 @@ impl MethodCallBox {
             arg_vtxs,
             kwarg_vtxs,
             location,
+            safe_navigation,
             reschedule_count: 0,
         }
     }
@@ -100,6 +105,13 @@ impl MethodCallBox {
         genv: &mut GlobalEnv,
         changes: &mut ChangeSet,
     ) {
+        // Safe navigation (`&.`): skip nil receiver entirely.
+        // Ruby's &. short-circuits: no method resolution, no argument evaluation, no error.
+        // The nil return type is added in run() after processing all receiver types.
+        if self.safe_navigation && matches!(recv_ty, Type::Nil) {
+            return;
+        }
+
         if let Some(method_info) = genv.resolve_method(recv_ty, &self.method_name) {
             if let Some(return_vtx) = method_info.return_vertex {
                 // User-defined method: connect body's return vertex to call site
@@ -186,8 +198,14 @@ impl BoxTrait for MethodCallBox {
             return;
         }
 
-        for recv_ty in recv_types {
-            self.process_recv_type(&recv_ty, genv, changes);
+        for recv_ty in &recv_types {
+            self.process_recv_type(recv_ty, genv, changes);
+        }
+
+        // Safe navigation (`&.`): if receiver can be nil, return type includes nil
+        if self.safe_navigation && recv_types.iter().any(|t| matches!(t, Type::Nil)) {
+            let nil_src = genv.new_source(Type::Nil);
+            changes.add_edge(nil_src, self.ret);
         }
     }
 }
@@ -327,440 +345,3 @@ impl BoxTrait for BlockParameterTypeBox {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::env::GlobalEnv;
-    use crate::types::Type;
-
-    #[test]
-    fn test_method_call_box() {
-        let mut genv = GlobalEnv::new();
-
-        // Register String#upcase
-        genv.register_builtin_method(Type::string(), "upcase", Type::string());
-
-        // x = "hello" (Source<String> -> Vertex)
-        let x_vtx = genv.new_vertex();
-        let str_src = genv.new_source(Type::string());
-        genv.add_edge(str_src, x_vtx);
-
-        // x.upcase
-        let ret_vtx = genv.new_vertex();
-        let box_id = BoxId(0);
-        let mut call_box = MethodCallBox::new(
-            box_id,
-            x_vtx,
-            "upcase".to_string(),
-            ret_vtx,
-            vec![],
-            None,
-            None, // No location in test
-        );
-
-        // Execute Box
-        let mut changes = ChangeSet::new();
-        call_box.run(&mut genv, &mut changes);
-        genv.apply_changes(changes);
-
-        // Check return type
-        let ret_vertex = genv.get_vertex(ret_vtx).unwrap();
-        assert_eq!(ret_vertex.show(), "String");
-    }
-
-    #[test]
-    fn test_method_call_box_undefined() {
-        let mut genv = GlobalEnv::new();
-
-        // Don't register method
-
-        let x_vtx = genv.new_vertex();
-        let str_src = genv.new_source(Type::string());
-        genv.add_edge(str_src, x_vtx);
-
-        // x.unknown_method (undefined)
-        let ret_vtx = genv.new_vertex();
-        let box_id = BoxId(0);
-        let mut call_box = MethodCallBox::new(
-            box_id,
-            x_vtx,
-            "unknown_method".to_string(),
-            ret_vtx,
-            vec![],
-            None,
-            None, // No location in test
-        );
-
-        let mut changes = ChangeSet::new();
-        call_box.run(&mut genv, &mut changes);
-        genv.apply_changes(changes);
-
-        // Return value is untyped
-        let ret_vertex = genv.get_vertex(ret_vtx).unwrap();
-        assert_eq!(ret_vertex.show(), "untyped");
-    }
-
-    #[test]
-    fn test_block_param_type_box_simple() {
-        let mut genv = GlobalEnv::new();
-
-        // Register String#each_char with block param type String
-        genv.register_builtin_method_with_block(
-            Type::string(),
-            "each_char",
-            Type::string(),
-            Some(vec![Type::string()]),
-        );
-
-        // Create receiver vertex with String type
-        let recv_vtx = genv.new_vertex();
-        let str_src = genv.new_source(Type::string());
-        genv.add_edge(str_src, recv_vtx);
-
-        // Create block parameter vertex
-        let param_vtx = genv.new_vertex();
-
-        // Create and run BlockParameterTypeBox
-        let box_id = genv.alloc_box_id();
-        let block_box = BlockParameterTypeBox::new(
-            box_id,
-            recv_vtx,
-            "each_char".to_string(),
-            vec![param_vtx],
-        );
-        genv.register_box(box_id, Box::new(block_box));
-
-        // Run all boxes
-        genv.run_all();
-
-        // Block parameter should now have String type
-        assert_eq!(genv.get_vertex(param_vtx).unwrap().show(), "String");
-    }
-
-    #[test]
-    fn test_block_param_type_variable_skipped() {
-        let mut genv = GlobalEnv::new();
-
-        // Register Array#each with block param type Elem (type variable)
-        genv.register_builtin_method_with_block(
-            Type::array(),
-            "each",
-            Type::array(),
-            Some(vec![Type::instance("Elem")]),
-        );
-
-        let recv_vtx = genv.new_vertex();
-        let arr_src = genv.new_source(Type::array());
-        genv.add_edge(arr_src, recv_vtx);
-
-        let param_vtx = genv.new_vertex();
-
-        let box_id = genv.alloc_box_id();
-        let block_box = BlockParameterTypeBox::new(
-            box_id,
-            recv_vtx,
-            "each".to_string(),
-            vec![param_vtx],
-        );
-        genv.register_box(box_id, Box::new(block_box));
-
-        genv.run_all();
-
-        // Block parameter should remain untyped (type variable skipped)
-        assert_eq!(genv.get_vertex(param_vtx).unwrap().show(), "untyped");
-    }
-
-    #[test]
-    fn test_block_param_multiple_params() {
-        let mut genv = GlobalEnv::new();
-
-        // Register a method with multiple block params
-        genv.register_builtin_method_with_block(
-            Type::string(),
-            "each_with_index",
-            Type::string(),
-            Some(vec![Type::string(), Type::integer()]),
-        );
-
-        let recv_vtx = genv.new_vertex();
-        let str_src = genv.new_source(Type::string());
-        genv.add_edge(str_src, recv_vtx);
-
-        let param1_vtx = genv.new_vertex();
-        let param2_vtx = genv.new_vertex();
-
-        let box_id = genv.alloc_box_id();
-        let block_box = BlockParameterTypeBox::new(
-            box_id,
-            recv_vtx,
-            "each_with_index".to_string(),
-            vec![param1_vtx, param2_vtx],
-        );
-        genv.register_box(box_id, Box::new(block_box));
-
-        genv.run_all();
-
-        // Both params should have their types
-        assert_eq!(genv.get_vertex(param1_vtx).unwrap().show(), "String");
-        assert_eq!(genv.get_vertex(param2_vtx).unwrap().show(), "Integer");
-    }
-
-    #[test]
-    fn test_block_param_type_variable_resolved() {
-        let mut genv = GlobalEnv::new();
-
-        // Register Array#each with block param type Elem (type variable)
-        genv.register_builtin_method_with_block(
-            Type::array(),
-            "each",
-            Type::array(),
-            Some(vec![Type::instance("Elem")]),
-        );
-
-        // Create receiver vertex with Array[Integer] type
-        let recv_vtx = genv.new_vertex();
-        let arr_src = genv.new_source(Type::array_of(Type::integer()));
-        genv.add_edge(arr_src, recv_vtx);
-
-        let param_vtx = genv.new_vertex();
-
-        let box_id = genv.alloc_box_id();
-        let block_box = BlockParameterTypeBox::new(
-            box_id,
-            recv_vtx,
-            "each".to_string(),
-            vec![param_vtx],
-        );
-        genv.register_box(box_id, Box::new(block_box));
-
-        genv.run_all();
-
-        // Block parameter should be Integer (resolved from Array[Integer])
-        assert_eq!(genv.get_vertex(param_vtx).unwrap().show(), "Integer");
-    }
-
-    #[test]
-    fn test_hash_type_variable_resolved() {
-        let mut genv = GlobalEnv::new();
-
-        // Register Hash#each with block param types K, V
-        genv.register_builtin_method_with_block(
-            Type::hash(),
-            "each",
-            Type::hash(),
-            Some(vec![Type::instance("K"), Type::instance("V")]),
-        );
-
-        // Create receiver vertex with Hash[String, Integer] type
-        let recv_vtx = genv.new_vertex();
-        let hash_src = genv.new_source(Type::hash_of(Type::string(), Type::integer()));
-        genv.add_edge(hash_src, recv_vtx);
-
-        let key_vtx = genv.new_vertex();
-        let value_vtx = genv.new_vertex();
-
-        let box_id = genv.alloc_box_id();
-        let block_box = BlockParameterTypeBox::new(
-            box_id,
-            recv_vtx,
-            "each".to_string(),
-            vec![key_vtx, value_vtx],
-        );
-        genv.register_box(box_id, Box::new(block_box));
-
-        genv.run_all();
-
-        // Block parameters should be resolved from Hash[String, Integer]
-        assert_eq!(genv.get_vertex(key_vtx).unwrap().show(), "String");
-        assert_eq!(genv.get_vertex(value_vtx).unwrap().show(), "Integer");
-    }
-
-    #[test]
-    fn test_method_call_box_user_defined_method() {
-        let mut genv = GlobalEnv::new();
-
-        // Simulate: def name; "Alice"; end
-        let body_src = genv.new_source(Type::string());
-
-        // Register user-defined method User#name with return_vertex
-        genv.register_user_method(Type::instance("User"), "name", body_src, vec![], None);
-
-        // Simulate: user.name (receiver has type User)
-        let recv_vtx = genv.new_vertex();
-        let recv_src = genv.new_source(Type::instance("User"));
-        genv.add_edge(recv_src, recv_vtx);
-
-        let ret_vtx = genv.new_vertex();
-        let box_id = genv.alloc_box_id();
-        let call_box = MethodCallBox::new(
-            box_id,
-            recv_vtx,
-            "name".to_string(),
-            ret_vtx,
-            vec![],
-            None,
-            None,
-        );
-        genv.register_box(box_id, Box::new(call_box));
-
-        genv.run_all();
-
-        // Return type should be String (propagated from body's last expression)
-        assert_eq!(genv.get_vertex(ret_vtx).unwrap().show(), "String");
-    }
-
-    #[test]
-    fn test_method_call_box_param_type_propagation() {
-        let mut genv = GlobalEnv::new();
-
-        // Simulate: def format(value); value.to_s; end
-        // 1. Create parameter vertex for 'value'
-        let param_vtx = genv.new_vertex();
-
-        // 2. Register Integer#to_s -> String (builtin)
-        genv.register_builtin_method(Type::integer(), "to_s", Type::string());
-
-        // 3. Create MethodCallBox for value.to_s (inside method body)
-        let inner_ret_vtx = genv.new_vertex();
-        let inner_box_id = genv.alloc_box_id();
-        let inner_call = MethodCallBox::new(
-            inner_box_id,
-            param_vtx,
-            "to_s".to_string(),
-            inner_ret_vtx,
-            vec![],
-            None,
-            None,
-        );
-        genv.register_box(inner_box_id, Box::new(inner_call));
-
-        // 4. Register user-defined method Formatter#format with return_vertex and param_vertices
-        genv.register_user_method(
-            Type::instance("Formatter"),
-            "format",
-            inner_ret_vtx,
-            vec![param_vtx],
-            None,
-        );
-
-        // 5. Simulate call: Formatter.new.format(42)
-        let recv_vtx = genv.new_vertex();
-        let recv_src = genv.new_source(Type::instance("Formatter"));
-        genv.add_edge(recv_src, recv_vtx);
-
-        let arg_vtx = genv.new_source(Type::integer()); // argument: 42
-
-        let call_ret_vtx = genv.new_vertex();
-        let call_box_id = genv.alloc_box_id();
-        let call_box = MethodCallBox::new(
-            call_box_id,
-            recv_vtx,
-            "format".to_string(),
-            call_ret_vtx,
-            vec![arg_vtx],
-            None,
-            None,
-        );
-        genv.register_box(call_box_id, Box::new(call_box));
-
-        // Run all boxes
-        genv.run_all();
-
-        // param_vtx should have Integer type (propagated from argument)
-        assert_eq!(genv.get_vertex(param_vtx).unwrap().show(), "Integer");
-
-        // Return type should be String (Integer#to_s -> String)
-        assert_eq!(genv.get_vertex(call_ret_vtx).unwrap().show(), "String");
-    }
-
-    #[test]
-    fn test_keyword_arg_propagation() {
-        let mut genv = GlobalEnv::new();
-
-        // Simulate: def greet(name:); name; end
-        let param_vtx = genv.new_vertex();
-        let mut kw_params = HashMap::new();
-        kw_params.insert("name".to_string(), param_vtx);
-
-        genv.register_user_method(
-            Type::instance("Greeter"),
-            "greet",
-            param_vtx, // return vertex = param (returns name)
-            vec![],
-            Some(kw_params),
-        );
-
-        // Simulate call: Greeter.new.greet(name: "Alice")
-        let recv_vtx = genv.new_vertex();
-        let recv_src = genv.new_source(Type::instance("Greeter"));
-        genv.add_edge(recv_src, recv_vtx);
-
-        let arg_vtx = genv.new_source(Type::string());
-        let mut kwarg_vtxs = HashMap::new();
-        kwarg_vtxs.insert("name".to_string(), arg_vtx);
-
-        let ret_vtx = genv.new_vertex();
-        let box_id = genv.alloc_box_id();
-        let call_box = MethodCallBox::new(
-            box_id,
-            recv_vtx,
-            "greet".to_string(),
-            ret_vtx,
-            vec![],
-            Some(kwarg_vtxs),
-            None,
-        );
-        genv.register_box(box_id, Box::new(call_box));
-
-        genv.run_all();
-
-        // param_vtx should have String type (propagated from keyword argument)
-        assert_eq!(genv.get_vertex(param_vtx).unwrap().show(), "String");
-        assert_eq!(genv.get_vertex(ret_vtx).unwrap().show(), "String");
-    }
-
-    #[test]
-    fn test_keyword_arg_name_mismatch_skipped() {
-        let mut genv = GlobalEnv::new();
-
-        let param_vtx = genv.new_vertex();
-        let mut kw_params = HashMap::new();
-        kw_params.insert("name".to_string(), param_vtx);
-
-        genv.register_user_method(
-            Type::instance("Greeter"),
-            "greet",
-            param_vtx,
-            vec![],
-            Some(kw_params),
-        );
-
-        let recv_vtx = genv.new_vertex();
-        let recv_src = genv.new_source(Type::instance("Greeter"));
-        genv.add_edge(recv_src, recv_vtx);
-
-        // Wrong keyword name: "title" instead of "name"
-        let arg_vtx = genv.new_source(Type::string());
-        let mut kwarg_vtxs = HashMap::new();
-        kwarg_vtxs.insert("title".to_string(), arg_vtx);
-
-        let ret_vtx = genv.new_vertex();
-        let box_id = genv.alloc_box_id();
-        let call_box = MethodCallBox::new(
-            box_id,
-            recv_vtx,
-            "greet".to_string(),
-            ret_vtx,
-            vec![],
-            Some(kwarg_vtxs),
-            None,
-        );
-        genv.register_box(box_id, Box::new(call_box));
-
-        genv.run_all();
-
-        // param_vtx should remain untyped (name mismatch → no propagation)
-        assert_eq!(genv.get_vertex(param_vtx).unwrap().show(), "untyped");
-    }
-}

data/core/src/graph/change_set.rs

@@ -76,68 +76,3 @@ pub enum EdgeUpdate {
     Add { src: VertexId, dst: VertexId },
     Remove { src: VertexId, dst: VertexId },
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_change_set_default() {
-        let mut cs = ChangeSet::default();
-        cs.add_edge(VertexId(1), VertexId(2));
-        let updates = cs.reinstall();
-        assert_eq!(updates.len(), 1);
-    }
-
-    #[test]
-    fn test_change_set_add() {
-        let mut cs = ChangeSet::new();
-
-        cs.add_edge(VertexId(1), VertexId(2));
-        cs.add_edge(VertexId(2), VertexId(3));
-
-        let updates = cs.reinstall();
-
-        assert_eq!(updates.len(), 2);
-        assert!(updates.contains(&EdgeUpdate::Add {
-            src: VertexId(1),
-            dst: VertexId(2)
-        }));
-        assert!(updates.contains(&EdgeUpdate::Add {
-            src: VertexId(2),
-            dst: VertexId(3)
-        }));
-    }
-
-    #[test]
-    fn test_change_set_dedup() {
-        let mut cs = ChangeSet::new();
-
-        cs.add_edge(VertexId(1), VertexId(2));
-        cs.add_edge(VertexId(1), VertexId(2)); // Duplicate
-
-        let updates = cs.reinstall();
-
-        assert_eq!(updates.len(), 1); // Duplicates removed
-    }
-
-    #[test]
-    fn test_change_set_remove() {
-        let mut cs = ChangeSet::new();
-
-        // First commit
-        cs.add_edge(VertexId(1), VertexId(2));
-        cs.add_edge(VertexId(2), VertexId(3));
-        cs.reinstall();
-
-        // Second time: keep only (1,2)
-        cs.add_edge(VertexId(1), VertexId(2));
-        let updates = cs.reinstall();
-
-        assert_eq!(updates.len(), 1);
-        assert!(updates.contains(&EdgeUpdate::Remove {
-            src: VertexId(2),
-            dst: VertexId(3)
-        }));
-    }
-}

data/core/src/graph/vertex.rs

@@ -96,72 +96,3 @@ impl Default for Vertex {
         Self::new()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_source_type() {
-        let src = Source::new(Type::string());
-        assert_eq!(src.ty.show(), "String");
-    }
-
-    #[test]
-    fn test_vertex_empty() {
-        let vtx = Vertex::new();
-        assert_eq!(vtx.show(), "untyped");
-    }
-
-    #[test]
-    fn test_vertex_single_type() {
-        let mut vtx = Vertex::new();
-
-        // Add String type
-        let propagations = vtx.on_type_added(VertexId(1), vec![Type::string()]);
-        assert_eq!(vtx.show(), "String");
-        assert_eq!(propagations.len(), 0); // No propagation since no connections
-    }
-
-    #[test]
-    fn test_vertex_union_type() {
-        let mut vtx = Vertex::new();
-
-        // Add String type
-        vtx.on_type_added(VertexId(1), vec![Type::string()]);
-        assert_eq!(vtx.show(), "String");
-
-        // Add Integer type → becomes Union type
-        vtx.on_type_added(VertexId(1), vec![Type::integer()]);
-        assert_eq!(vtx.show(), "(Integer | String)");
-    }
-
-    #[test]
-    fn test_vertex_propagation() {
-        let mut vtx = Vertex::new();
-
-        // Add connections
-        vtx.add_next(VertexId(3));
-        vtx.add_next(VertexId(4));
-
-        // Add type → propagated to connections
-        let propagations = vtx.on_type_added(VertexId(1), vec![Type::string()]);
-
-        assert_eq!(propagations.len(), 2);
-        assert!(propagations.contains(&(VertexId(3), vec![Type::string()])));
-        assert!(propagations.contains(&(VertexId(4), vec![Type::string()])));
-    }
-
-    #[test]
-    fn test_vertex_no_duplicate_propagation() {
-        let mut vtx = Vertex::new();
-        vtx.add_next(VertexId(3));
-
-        // Add same type twice → only first time propagates
-        let prop1 = vtx.on_type_added(VertexId(1), vec![Type::string()]);
-        assert_eq!(prop1.len(), 1);
-
-        let prop2 = vtx.on_type_added(VertexId(1), vec![Type::string()]);
-        assert_eq!(prop2.len(), 0); // No propagation since already exists
-    }
-}