method-ray 0.1.6 → 0.1.8

data/rust/src/graph/box.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use crate::env::GlobalEnv;
 use crate::graph::change_set::ChangeSet;
 use crate::graph::vertex::VertexId;
@@ -9,21 +11,48 @@ use crate::types::Type;
 pub struct BoxId(pub usize);
 
 /// Box trait: represents constraints such as method calls
-#[allow(dead_code)]
 pub trait BoxTrait: Send + Sync {
     fn id(&self) -> BoxId;
     fn run(&mut self, genv: &mut GlobalEnv, changes: &mut ChangeSet);
     fn ret(&self) -> VertexId;
 }
 
+/// Propagate argument types to parameter vertices by adding edges
+/// from each argument vertex to the corresponding parameter vertex.
+fn propagate_arguments(
+    arg_vtxs: &[VertexId],
+    param_vtxs: Option<&[VertexId]>,
+    changes: &mut ChangeSet,
+) {
+    for (arg_vtx, param_vtx) in arg_vtxs.iter().zip(param_vtxs.unwrap_or_default()) {
+        changes.add_edge(*arg_vtx, *param_vtx);
+    }
+}
+
+/// Propagate keyword argument types to keyword parameter vertices by name
+fn propagate_keyword_arguments(
+    kwarg_vtxs: Option<&HashMap<String, VertexId>>,
+    kw_param_vtxs: Option<&HashMap<String, VertexId>>,
+    changes: &mut ChangeSet,
+) {
+    let (Some(args), Some(params)) = (kwarg_vtxs, kw_param_vtxs) else {
+        return;
+    };
+    for (name, arg_vtx) in args {
+        if let Some(&param_vtx) = params.get(name) {
+            changes.add_edge(*arg_vtx, param_vtx);
+        }
+    }
+}
+
 /// Box representing a method call
-#[allow(dead_code)]
 pub struct MethodCallBox {
     id: BoxId,
     recv: VertexId,
     method_name: String,
     ret: VertexId,
     arg_vtxs: Vec<VertexId>,
+    kwarg_vtxs: Option<HashMap<String, VertexId>>,
     location: Option<SourceLocation>, // Source code location
     /// Number of times this box has been rescheduled
     reschedule_count: u8,
@@ -39,6 +68,7 @@ impl MethodCallBox {
         method_name: String,
         ret: VertexId,
         arg_vtxs: Vec<VertexId>,
+        kwarg_vtxs: Option<HashMap<String, VertexId>>,
         location: Option<SourceLocation>,
     ) -> Self {
         Self {
@@ -47,10 +77,94 @@ impl MethodCallBox {
             method_name,
             ret,
             arg_vtxs,
+            kwarg_vtxs,
             location,
             reschedule_count: 0,
         }
     }
+
+    /// Reschedule this box for re-execution if the limit hasn't been reached.
+    /// Handles cases where the receiver has no types yet (e.g., block parameters
+    /// that get typed by a later box). If max reschedules are reached, the box
+    /// is silently dropped (receiver type remains unknown).
+    fn try_reschedule(&mut self, changes: &mut ChangeSet) {
+        if self.reschedule_count < MAX_RESCHEDULE_COUNT {
+            self.reschedule_count += 1;
+            changes.reschedule(self.id);
+        }
+    }
+
+    fn process_recv_type(
+        &self,
+        recv_ty: &Type,
+        genv: &mut GlobalEnv,
+        changes: &mut ChangeSet,
+    ) {
+        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
+                changes.add_edge(return_vtx, self.ret);
+                propagate_arguments(
+                    &self.arg_vtxs,
+                    method_info.param_vertices.as_deref(),
+                    changes,
+                );
+                propagate_keyword_arguments(
+                    self.kwarg_vtxs.as_ref(),
+                    method_info.keyword_param_vertices.as_ref(),
+                    changes,
+                );
+            } else {
+                // Builtin/RBS method: 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" {
+            self.handle_new_call(recv_ty, genv, changes);
+        } else if !matches!(recv_ty, Type::Singleton { .. }) {
+            // Singleton types with unresolved methods are silently skipped;
+            // these are typically RBS class methods not yet supported.
+            self.report_type_error(recv_ty, genv);
+        }
+    }
+
+    /// Handle `.new` calls: singleton(Foo)#new produces instance(Foo),
+    /// and propagates arguments to the `initialize` method's parameters.
+    fn handle_new_call(
+        &self,
+        recv_ty: &Type,
+        genv: &mut GlobalEnv,
+        changes: &mut ChangeSet,
+    ) {
+        if let Type::Singleton { name } = recv_ty {
+            let instance_type = Type::instance(name.full_name());
+
+            let ret_src = genv.new_source(instance_type.clone());
+            changes.add_edge(ret_src, self.ret);
+
+            let init_info = genv.resolve_method(&instance_type, "initialize");
+            propagate_arguments(
+                &self.arg_vtxs,
+                init_info.and_then(|info| info.param_vertices.as_deref()),
+                changes,
+            );
+            propagate_keyword_arguments(
+                self.kwarg_vtxs.as_ref(),
+                init_info.and_then(|info| info.keyword_param_vertices.as_ref()),
+                changes,
+            );
+        } else {
+            self.report_type_error(recv_ty, genv);
+        }
+    }
+
+    fn report_type_error(&self, recv_ty: &Type, genv: &mut GlobalEnv) {
+        genv.record_type_error(
+            recv_ty.clone(),
+            self.method_name.clone(),
+            self.location.clone(),
+        );
+    }
 }
 
 impl BoxTrait for MethodCallBox {
@@ -63,88 +177,17 @@ impl BoxTrait for MethodCallBox {
     }
 
     fn run(&mut self, genv: &mut GlobalEnv, changes: &mut ChangeSet) {
-        // Get receiver type (handles both Vertex and Source)
-        let recv_types: Vec<Type> = if let Some(recv_vertex) = genv.get_vertex(self.recv) {
-            // Vertex case: may have multiple types
-            recv_vertex.types.keys().cloned().collect()
-        } else if let Some(recv_source) = genv.get_source(self.recv) {
-            // Source case: has one fixed type (e.g., literals)
-            vec![recv_source.ty.clone()]
-        } else {
-            // Receiver not found
+        let Some(recv_types) = genv.get_receiver_types(self.recv) else {
             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)
+            self.try_reschedule(changes);
             return;
         }
 
         for recv_ty in recv_types {
-            // Resolve method
-            if let Some(method_info) = genv.resolve_method(&recv_ty, &self.method_name) {
-                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);
-
-                    // 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.
-                // User-defined class methods (def self.foo) are resolved by
-                // resolve_method above. Only unresolved methods reach here
-                // (e.g., RBS class methods not yet supported).
-                continue;
-            } else {
-                // Record type error for diagnostic reporting
-                genv.record_type_error(
-                    recv_ty.clone(),
-                    self.method_name.clone(),
-                    self.location.clone(),
-                );
-            }
+            self.process_recv_type(&recv_ty, genv, changes);
         }
     }
 }
@@ -154,7 +197,6 @@ impl BoxTrait for MethodCallBox {
 /// 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
@@ -241,12 +283,7 @@ impl BoxTrait for BlockParameterTypeBox {
     }
 
     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 {
+        let Some(recv_types) = genv.get_receiver_types(self.recv_vtx) else {
             return;
         };
 
@@ -318,6 +355,7 @@ mod tests {
             "upcase".to_string(),
             ret_vtx,
             vec![],
+            None,
             None, // No location in test
         );
 
@@ -350,6 +388,7 @@ mod tests {
             "unknown_method".to_string(),
             ret_vtx,
             vec![],
+            None,
             None, // No location in test
         );
 
@@ -545,7 +584,7 @@ mod tests {
         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![]);
+        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();
@@ -561,6 +600,7 @@ mod tests {
             ret_vtx,
             vec![],
             None,
+            None,
         );
         genv.register_box(box_id, Box::new(call_box));
 
@@ -591,6 +631,7 @@ mod tests {
             inner_ret_vtx,
             vec![],
             None,
+            None,
         );
         genv.register_box(inner_box_id, Box::new(inner_call));
 
@@ -600,6 +641,7 @@ mod tests {
             "format",
             inner_ret_vtx,
             vec![param_vtx],
+            None,
         );
 
         // 5. Simulate call: Formatter.new.format(42)
@@ -618,6 +660,7 @@ mod tests {
             call_ret_vtx,
             vec![arg_vtx],
             None,
+            None,
         );
         genv.register_box(call_box_id, Box::new(call_box));
 
@@ -630,4 +673,94 @@ mod tests {
         // 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/rust/src/graph/change_set.rs

@@ -10,6 +10,12 @@ pub struct ChangeSet {
     reschedule_boxes: Vec<BoxId>,
 }
 
+impl Default for ChangeSet {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ChangeSet {
     pub fn new() -> Self {
         Self {
@@ -75,6 +81,14 @@ pub enum EdgeUpdate {
 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();

data/rust/src/lsp/server.rs

@@ -132,7 +132,7 @@ pub async fn run_server() {
     let stdin = tokio::io::stdin();
     let stdout = tokio::io::stdout();
 
-    let (service, socket) = LspService::new(|client| MethodRayServer::new(client));
+    let (service, socket) = LspService::new(MethodRayServer::new);
 
     Server::new(stdin, stdout, socket).serve(service).await;
 }

data/rust/src/rbs/loader.rs

@@ -155,8 +155,7 @@ pub fn register_rbs_methods(genv: &mut GlobalEnv, ruby: &Ruby) -> Result<usize,
             cache.to_method_infos()
         } else {
             eprintln!("Cache invalid, reloading from RBS...");
-            let methods = load_and_cache_rbs_methods(ruby, methodray_version, &rbs_version)?;
-            methods
+            load_and_cache_rbs_methods(ruby, methodray_version, &rbs_version)?
         }
     } else {
         eprintln!("No cache found, loading from RBS...");

data/rust/src/source_map.rs

@@ -30,7 +30,6 @@ pub struct SourceLocation {
     pub length: usize,
 }
 
-#[allow(dead_code)]
 impl SourceLocation {
     pub fn new(line: usize, column: usize, length: usize) -> Self {
         Self {

data/rust/src/types.rs

@@ -125,7 +125,6 @@ impl From<String> for QualifiedName {
 
 /// Type system for graph-based type inference
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[allow(dead_code)]
 pub enum Type {
     /// Instance type: String, Integer, Api::User, etc.
     Instance { name: QualifiedName },

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: method-ray
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - dak2
@@ -48,14 +48,17 @@ files:
 - lib/methodray/commands.rb
 - lib/methodray/version.rb
 - rust/Cargo.toml
+- rust/src/analyzer/assignments.rs
 - rust/src/analyzer/attributes.rs
 - rust/src/analyzer/blocks.rs
 - rust/src/analyzer/calls.rs
 - rust/src/analyzer/conditionals.rs
 - rust/src/analyzer/definitions.rs
 - rust/src/analyzer/dispatch.rs
+- rust/src/analyzer/exceptions.rs
 - rust/src/analyzer/install.rs
 - rust/src/analyzer/literals.rs
+- rust/src/analyzer/loops.rs
 - rust/src/analyzer/mod.rs
 - rust/src/analyzer/operators.rs
 - rust/src/analyzer/parameters.rs