method-ray 0.1.7 → 0.1.8

data/rust/src/env/method_registry.rs

@@ -1,9 +1,10 @@
 //! Method registration and resolution
 
+use std::collections::HashMap;
+
 use crate::graph::VertexId;
 use crate::types::Type;
 use smallvec::SmallVec;
-use std::collections::HashMap;
 
 const OBJECT_CLASS: &str = "Object";
 const KERNEL_MODULE: &str = "Kernel";
@@ -15,6 +16,7 @@ pub struct MethodInfo {
     pub block_param_types: Option<Vec<Type>>,
     pub return_vertex: Option<VertexId>,
     pub param_vertices: Option<Vec<VertexId>>,
+    pub keyword_param_vertices: Option<HashMap<String, VertexId>>,
 }
 
 /// Registry for method definitions
@@ -51,6 +53,7 @@ impl MethodRegistry {
                 block_param_types,
                 return_vertex: None,
                 param_vertices: None,
+                keyword_param_vertices: None,
             },
         );
     }
@@ -62,6 +65,7 @@ impl MethodRegistry {
         method_name: &str,
         return_vertex: VertexId,
         param_vertices: Vec<VertexId>,
+        keyword_param_vertices: Option<HashMap<String, VertexId>>,
     ) {
         self.methods.insert(
             (recv_ty, method_name.to_string()),
@@ -70,6 +74,7 @@ impl MethodRegistry {
                 block_param_types: None,
                 return_vertex: Some(return_vertex),
                 param_vertices: Some(param_vertices),
+                keyword_param_vertices,
             },
         );
     }
@@ -134,7 +139,7 @@ mod tests {
     fn test_register_user_method_and_resolve() {
         let mut registry = MethodRegistry::new();
         let return_vtx = VertexId(42);
-        registry.register_user_method(Type::instance("User"), "name", return_vtx, vec![]);
+        registry.register_user_method(Type::instance("User"), "name", return_vtx, vec![], None);
 
         let info = registry.resolve(&Type::instance("User"), "name").unwrap();
         assert_eq!(info.return_vertex, Some(VertexId(42)));
@@ -151,6 +156,7 @@ mod tests {
             "add",
             return_vtx,
             param_vtxs,
+            None,
         );
 
         let info = registry.resolve(&Type::instance("Calc"), "add").unwrap();

data/rust/src/env/scope.rs

@@ -7,7 +7,6 @@ pub struct ScopeId(pub usize);
 
 /// Scope kind
 #[derive(Debug, Clone)]
-#[allow(dead_code)]
 pub enum ScopeKind {
     TopLevel,
     Class {
@@ -27,7 +26,6 @@ pub enum ScopeKind {
 
 /// Scope information
 #[derive(Debug, Clone)]
-#[allow(dead_code)]
 pub struct Scope {
     pub id: ScopeId,
     pub kind: ScopeKind,
@@ -46,7 +44,6 @@ pub struct Scope {
     pub constants: HashMap<String, String>,
 }
 
-#[allow(dead_code)]
 impl Scope {
     pub fn new(id: ScopeId, kind: ScopeKind, parent: Option<ScopeId>) -> Self {
         Self {
@@ -89,7 +86,12 @@ pub struct ScopeManager {
     current_scope: ScopeId,
 }
 
-#[allow(dead_code)]
+impl Default for ScopeManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ScopeManager {
     pub fn new() -> Self {
         let top_level = Scope::new(ScopeId(0), ScopeKind::TopLevel, None);
@@ -278,6 +280,13 @@ impl ScopeManager {
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_scope_manager_default() {
+        let sm = ScopeManager::default();
+        assert_eq!(sm.current_scope().id, ScopeId(0));
+        assert!(matches!(sm.current_scope().kind, ScopeKind::TopLevel));
+    }
+
     #[test]
     fn test_scope_manager_creation() {
         let sm = ScopeManager::new();

data/rust/src/env/vertex_manager.rs

@@ -17,7 +17,6 @@ pub struct VertexManager {
     next_vertex_id: usize,
 }
 
-#[allow(dead_code)]
 impl VertexManager {
     /// Create a new empty vertex manager
     pub fn new() -> Self {

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,7 +11,6 @@ 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);
@@ -28,14 +29,30 @@ fn propagate_arguments(
     }
 }
 
+/// 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,
@@ -51,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 {
@@ -59,6 +77,7 @@ impl MethodCallBox {
             method_name,
             ret,
             arg_vtxs,
+            kwarg_vtxs,
             location,
             reschedule_count: 0,
         }
@@ -90,6 +109,11 @@ impl MethodCallBox {
                     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());
@@ -118,10 +142,17 @@ impl MethodCallBox {
             let ret_src = genv.new_source(instance_type.clone());
             changes.add_edge(ret_src, self.ret);
 
-            let init_params = genv
-                .resolve_method(&instance_type, "initialize")
-                .and_then(|info| info.param_vertices.as_deref());
-            propagate_arguments(&self.arg_vtxs, init_params, changes);
+            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);
         }
@@ -166,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
@@ -325,6 +355,7 @@ mod tests {
             "upcase".to_string(),
             ret_vtx,
             vec![],
+            None,
             None, // No location in test
         );
 
@@ -357,6 +388,7 @@ mod tests {
             "unknown_method".to_string(),
             ret_vtx,
             vec![],
+            None,
             None, // No location in test
         );
 
@@ -552,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();
@@ -568,6 +600,7 @@ mod tests {
             ret_vtx,
             vec![],
             None,
+            None,
         );
         genv.register_box(box_id, Box::new(call_box));
 
@@ -598,6 +631,7 @@ mod tests {
             inner_ret_vtx,
             vec![],
             None,
+            None,
         );
         genv.register_box(inner_box_id, Box::new(inner_call));
 
@@ -607,6 +641,7 @@ mod tests {
             "format",
             inner_ret_vtx,
             vec![param_vtx],
+            None,
         );
 
         // 5. Simulate call: Formatter.new.format(42)
@@ -625,6 +660,7 @@ mod tests {
             call_ret_vtx,
             vec![arg_vtx],
             None,
+            None,
         );
         genv.register_box(call_box_id, Box::new(call_box));
 
@@ -637,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.7
+  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