method-ray 0.1.2 → 0.1.4

data/rust/src/graph/box.rs

@@ -23,15 +23,22 @@ pub struct MethodCallBox {
     recv: VertexId,
     method_name: String,
     ret: VertexId,
+    arg_vtxs: Vec<VertexId>,
     location: Option<SourceLocation>, // Source code location
+    /// Number of times this box has been rescheduled
+    reschedule_count: u8,
 }
 
+/// Maximum number of reschedules before giving up
+const MAX_RESCHEDULE_COUNT: u8 = 3;
+
 impl MethodCallBox {
     pub fn new(
         id: BoxId,
         recv: VertexId,
         method_name: String,
         ret: VertexId,
+        arg_vtxs: Vec<VertexId>,
         location: Option<SourceLocation>,
     ) -> Self {
         Self {
@@ -39,7 +46,9 @@ impl MethodCallBox {
             recv,
             method_name,
             ret,
+            arg_vtxs,
             location,
+            reschedule_count: 0,
         }
     }
 }
@@ -66,14 +75,66 @@ impl BoxTrait for MethodCallBox {
             return;
         };
 
+        // If receiver has no types yet, reschedule this box for later
+        // This handles cases like block parameters that are typed later
+        if recv_types.is_empty() {
+            if self.reschedule_count < MAX_RESCHEDULE_COUNT {
+                self.reschedule_count += 1;
+                changes.reschedule(self.id);
+            }
+            // If max reschedules reached, just skip (receiver type is unknown)
+            return;
+        }
+
         for recv_ty in recv_types {
             // Resolve method
             if let Some(method_info) = genv.resolve_method(&recv_ty, &self.method_name) {
-                // Create return type as Source
-                let ret_src_id = genv.new_source(method_info.return_type.clone());
+                if let Some(return_vtx) = method_info.return_vertex {
+                    // User-defined: edge from body's last expr → call site return
+                    changes.add_edge(return_vtx, self.ret);
 
-                // Add edge to return value
-                changes.add_edge(ret_src_id, self.ret);
+                    // Propagate argument types to parameter vertices
+                    if let Some(param_vtxs) = &method_info.param_vertices {
+                        for (i, param_vtx) in param_vtxs.iter().enumerate() {
+                            if let Some(arg_vtx) = self.arg_vtxs.get(i) {
+                                changes.add_edge(*arg_vtx, *param_vtx);
+                            }
+                        }
+                    }
+                } else {
+                    // RBS/builtin: create Source with fixed return type
+                    let ret_src_id = genv.new_source(method_info.return_type.clone());
+                    changes.add_edge(ret_src_id, self.ret);
+                }
+            } else if self.method_name == "new" {
+                if let Type::Singleton { name } = &recv_ty {
+                    // singleton(User)#new → instance(User)
+                    let instance_type = Type::instance(name.full_name());
+                    let ret_src = genv.new_source(instance_type.clone());
+                    changes.add_edge(ret_src, self.ret);
+
+                    // Propagate arguments to initialize parameters
+                    if let Some(init_info) = genv.resolve_method(&instance_type, "initialize") {
+                        if let Some(param_vtxs) = &init_info.param_vertices {
+                            for (i, param_vtx) in param_vtxs.iter().enumerate() {
+                                if let Some(arg_vtx) = self.arg_vtxs.get(i) {
+                                    changes.add_edge(*arg_vtx, *param_vtx);
+                                }
+                            }
+                        }
+                    }
+                    continue;
+                }
+                // Non-singleton .new: record error
+                genv.record_type_error(
+                    recv_ty.clone(),
+                    self.method_name.clone(),
+                    self.location.clone(),
+                );
+            } else if matches!(&recv_ty, Type::Singleton { .. }) {
+                // Skip error for unknown class methods on Singleton types
+                // (class method RBS registration is not yet supported)
+                continue;
             } else {
                 // Record type error for diagnostic reporting
                 genv.record_type_error(
@@ -86,6 +147,148 @@ impl BoxTrait for MethodCallBox {
     }
 }
 
+/// Box for resolving block parameter types from method call receiver
+///
+/// When a method with a block is called (e.g., `str.each_char { |c| ... }`),
+/// this box resolves the block parameter types from the method's RBS definition
+/// and propagates them to the block parameter vertices.
+#[allow(dead_code)]
+pub struct BlockParameterTypeBox {
+    id: BoxId,
+    /// Receiver vertex of the method call
+    recv_vtx: VertexId,
+    /// Method name being called
+    method_name: String,
+    /// Block parameter vertices (in order)
+    block_param_vtxs: Vec<VertexId>,
+}
+
+impl BlockParameterTypeBox {
+    pub fn new(
+        id: BoxId,
+        recv_vtx: VertexId,
+        method_name: String,
+        block_param_vtxs: Vec<VertexId>,
+    ) -> Self {
+        Self {
+            id,
+            recv_vtx,
+            method_name,
+            block_param_vtxs,
+        }
+    }
+
+    /// Check if a type is a type variable name (e.g., Elem, K, V)
+    fn is_type_variable_name(name: &str) -> bool {
+        matches!(
+            name,
+            "Elem" | "K" | "V" | "T" | "U" | "A" | "B" | "Element" | "Key" | "Value" | "Out" | "In"
+        )
+    }
+
+    /// Try to resolve a type variable from receiver's type arguments.
+    ///
+    /// For `Array[Integer]#each { |x| }`, the block param type is `Elem`.
+    /// This resolves `Elem` → `Integer` using Array's type argument.
+    ///
+    /// Type variable mapping for common generic classes:
+    /// - Array[Elem]: Elem → type_args[0]
+    /// - Hash[K, V]: K → type_args[0], V → type_args[1]
+    fn resolve_type_variable(ty: &Type, recv_ty: &Type) -> Option<Type> {
+        let type_var_name = match ty {
+            Type::Instance { name } if Self::is_type_variable_name(name.full_name()) => {
+                name.full_name()
+            }
+            _ => return None, // Not a type variable
+        };
+
+        // Get type arguments from receiver
+        let type_args = recv_ty.type_args()?;
+        let class_name = recv_ty.base_class_name()?;
+
+        // Map type variable to type argument index based on class
+        let index = match (class_name, type_var_name) {
+            // Array[Elem]
+            ("Array", "Elem") => 0,
+            ("Array", "T") => 0,
+            ("Array", "Element") => 0,
+            // Hash[K, V]
+            ("Hash", "K") | ("Hash", "Key") => 0,
+            ("Hash", "V") | ("Hash", "Value") => 1,
+            // Generic fallback: first type arg for common names
+            (_, "Elem") | (_, "T") | (_, "Element") => 0,
+            _ => return None,
+        };
+
+        type_args.get(index).cloned()
+    }
+}
+
+impl BoxTrait for BlockParameterTypeBox {
+    fn id(&self) -> BoxId {
+        self.id
+    }
+
+    fn ret(&self) -> VertexId {
+        // This box doesn't have a single return value
+        // Return first param vtx as a placeholder
+        self.block_param_vtxs
+            .first()
+            .copied()
+            .unwrap_or(VertexId(0))
+    }
+
+    fn run(&mut self, genv: &mut GlobalEnv, changes: &mut ChangeSet) {
+        // Get receiver types
+        let recv_types: Vec<Type> = if let Some(recv_vertex) = genv.get_vertex(self.recv_vtx) {
+            recv_vertex.types.keys().cloned().collect()
+        } else if let Some(recv_source) = genv.get_source(self.recv_vtx) {
+            vec![recv_source.ty.clone()]
+        } else {
+            return;
+        };
+
+        for recv_ty in recv_types {
+            // Resolve method to get block parameter types
+            // Clone the block_param_types to avoid borrow issues
+            let block_param_types = genv
+                .resolve_method(&recv_ty, &self.method_name)
+                .and_then(|info| info.block_param_types.clone());
+
+            if let Some(param_types) = block_param_types {
+                // Map block parameter types to vertices
+                for (i, param_type) in param_types.iter().enumerate() {
+                    if i < self.block_param_vtxs.len() {
+                        let param_vtx = self.block_param_vtxs[i];
+
+                        // Try to resolve type variable from receiver's type arguments
+                        let resolved_type =
+                            if let Some(resolved) = Self::resolve_type_variable(param_type, &recv_ty) {
+                                // Type variable resolved (e.g., Elem → Integer)
+                                resolved
+                            } else if let Type::Instance { name } = &param_type {
+                                if Self::is_type_variable_name(name.full_name()) {
+                                    // Type variable couldn't be resolved, skip
+                                    continue;
+                                } else {
+                                    // Regular type, use as-is
+                                    param_type.clone()
+                                }
+                            } else {
+                                // Other type (Union, Generic, etc.), use as-is
+                                param_type.clone()
+                            };
+
+                        // Create source with the resolved type
+                        let src_id = genv.new_source(resolved_type);
+                        changes.add_edge(src_id, param_vtx);
+                    }
+                }
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -112,6 +315,7 @@ mod tests {
             x_vtx,
             "upcase".to_string(),
             ret_vtx,
+            vec![],
             None, // No location in test
         );
 
@@ -143,6 +347,7 @@ mod tests {
             x_vtx,
             "unknown_method".to_string(),
             ret_vtx,
+            vec![],
             None, // No location in test
         );
 
@@ -154,4 +359,273 @@ mod tests {
         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![]);
+
+        // 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,
+        );
+        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,
+        );
+        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],
+        );
+
+        // 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,
+        );
+        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");
+    }
 }

data/rust/src/graph/change_set.rs

@@ -1,3 +1,4 @@
+use super::r#box::BoxId;
 use super::VertexId;
 
 /// Manages edge changes for type propagation
@@ -5,6 +6,8 @@ use super::VertexId;
 pub struct ChangeSet {
     new_edges: Vec<(VertexId, VertexId)>,
     edges: Vec<(VertexId, VertexId)>,
+    /// Boxes to reschedule for later execution
+    reschedule_boxes: Vec<BoxId>,
 }
 
 impl ChangeSet {
@@ -12,6 +15,7 @@ impl ChangeSet {
         Self {
             new_edges: Vec::new(),
             edges: Vec::new(),
+            reschedule_boxes: Vec::new(),
         }
     }
 
@@ -20,6 +24,16 @@ impl ChangeSet {
         self.new_edges.push((src, dst));
     }
 
+    /// Request to reschedule a Box for later execution
+    pub fn reschedule(&mut self, box_id: BoxId) {
+        self.reschedule_boxes.push(box_id);
+    }
+
+    /// Get and clear boxes that need to be rescheduled
+    pub fn take_reschedule_boxes(&mut self) -> Vec<BoxId> {
+        std::mem::take(&mut self.reschedule_boxes)
+    }
+
     /// Commit changes and return list of added/removed edges
     pub fn reinstall(&mut self) -> Vec<EdgeUpdate> {
         // Remove duplicates

data/rust/src/graph/mod.rs

@@ -3,5 +3,5 @@ pub mod change_set;
 pub mod vertex;
 
 pub use change_set::{ChangeSet, EdgeUpdate};
-pub use r#box::{BoxId, BoxTrait, MethodCallBox};
+pub use r#box::{BlockParameterTypeBox, BoxId, BoxTrait, MethodCallBox};
 pub use vertex::{Source, Vertex, VertexId};

data/rust/src/lib.rs

@@ -11,7 +11,8 @@ pub mod parser;
 pub mod source_map;
 pub mod types;
 
-#[cfg(feature = "ruby-ffi")]
+// rbs module is always available (converter has no Ruby FFI dependency)
+// but loader and error require ruby-ffi feature
 pub mod rbs;
 
 #[cfg(any(feature = "cli", feature = "lsp"))]