method-ray 0.1.7 → 0.1.9

data/{rust → core}/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 → core}/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 → core}/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 → core}/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 → core}/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 → core}/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 },
@@ -277,6 +276,17 @@ impl Type {
             type_args: vec![element_type],
         }
     }
+
+    /// Collapse a Vec<Type> into a single Type or Union.
+    /// Returns the single element if len==1, or Union if len>1.
+    /// Panics if the vec is empty.
+    pub fn union_of(mut types: Vec<Type>) -> Self {
+        match types.len() {
+            0 => panic!("union_of called with empty types"),
+            1 => types.pop().unwrap(),
+            _ => Type::Union(types),
+        }
+    }
 }
 
 #[cfg(test)]

data/ext/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "methodray"
-version = "0.1.6"
+version = "0.1.9"
 edition = "2021"
 
 [lib]
@@ -18,7 +18,7 @@ default = []
 cli = ["methodray-core/cli", "dep:clap", "dep:anyhow"]
 
 [dependencies]
-methodray-core = { path = "../rust", features = ["ruby-ffi"] }
+methodray-core = { path = "../core", features = ["ruby-ffi"] }
 magnus = "0.8"
 clap = { version = "4", features = ["derive"], optional = true }
 anyhow = { version = "1", optional = true }

data/lib/methodray/binary_locator.rb

@@ -21,8 +21,8 @@ module MethodRay
         File.expand_path(@binary_name, LIB_DIR),
         # Development: target/release (project root)
         File.expand_path("../../target/release/#{@binary_name}", LIB_DIR),
-        # Development: rust/target/release (legacy standalone binary)
-        File.expand_path("../../rust/target/release/#{@legacy_binary_name}", LIB_DIR)
+        # Development: core/target/release (legacy standalone binary)
+        File.expand_path("../../core/target/release/#{@legacy_binary_name}", LIB_DIR)
       ]
     end
   end

data/lib/methodray/commands.rb

@@ -46,7 +46,7 @@ module MethodRay
           warn 'Error: CLI binary not found.'
           warn ''
           warn 'For development, build with:'
-          warn '  cd rust && cargo build --release --bin methodray --features cli'
+          warn '  cd core && cargo build --release --bin methodray --features cli'
           warn ''
           warn 'If installed via gem, this might be a platform compatibility issue.'
           warn 'Please report at: https://github.com/dak2/method-ray/issues'

data/lib/methodray/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MethodRay
-  VERSION = '0.1.7'
+  VERSION = '0.1.9'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: method-ray
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.9
 platform: ruby
 authors:
 - dak2
@@ -37,6 +37,59 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- core/Cargo.toml
+- core/src/analyzer/assignments.rs
+- core/src/analyzer/attributes.rs
+- core/src/analyzer/blocks.rs
+- core/src/analyzer/calls.rs
+- core/src/analyzer/conditionals.rs
+- core/src/analyzer/definitions.rs
+- core/src/analyzer/dispatch.rs
+- core/src/analyzer/exceptions.rs
+- core/src/analyzer/install.rs
+- core/src/analyzer/literals.rs
+- core/src/analyzer/loops.rs
+- core/src/analyzer/mod.rs
+- core/src/analyzer/operators.rs
+- core/src/analyzer/parameters.rs
+- core/src/analyzer/parentheses.rs
+- core/src/analyzer/returns.rs
+- core/src/analyzer/super_calls.rs
+- core/src/analyzer/variables.rs
+- core/src/cache/mod.rs
+- core/src/cache/rbs_cache.rs
+- core/src/checker.rs
+- core/src/cli/args.rs
+- core/src/cli/commands.rs
+- core/src/cli/mod.rs
+- core/src/diagnostics/diagnostic.rs
+- core/src/diagnostics/formatter.rs
+- core/src/diagnostics/mod.rs
+- core/src/env/box_manager.rs
+- core/src/env/global_env.rs
+- core/src/env/local_env.rs
+- core/src/env/method_registry.rs
+- core/src/env/mod.rs
+- core/src/env/scope.rs
+- core/src/env/type_error.rs
+- core/src/env/vertex_manager.rs
+- core/src/graph/box.rs
+- core/src/graph/change_set.rs
+- core/src/graph/mod.rs
+- core/src/graph/vertex.rs
+- core/src/lib.rs
+- core/src/lsp/diagnostics.rs
+- core/src/lsp/main.rs
+- core/src/lsp/mod.rs
+- core/src/lsp/server.rs
+- core/src/main.rs
+- core/src/parser.rs
+- core/src/rbs/converter.rs
+- core/src/rbs/error.rs
+- core/src/rbs/loader.rs
+- core/src/rbs/mod.rs
+- core/src/source_map.rs
+- core/src/types.rs
 - exe/methodray
 - ext/Cargo.toml
 - ext/extconf.rb
@@ -47,55 +100,6 @@ files:
 - lib/methodray/cli.rb
 - lib/methodray/commands.rb
 - lib/methodray/version.rb
-- rust/Cargo.toml
-- 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/install.rs
-- rust/src/analyzer/literals.rs
-- rust/src/analyzer/mod.rs
-- rust/src/analyzer/operators.rs
-- rust/src/analyzer/parameters.rs
-- rust/src/analyzer/parentheses.rs
-- rust/src/analyzer/returns.rs
-- rust/src/analyzer/variables.rs
-- rust/src/cache/mod.rs
-- rust/src/cache/rbs_cache.rs
-- rust/src/checker.rs
-- rust/src/cli/args.rs
-- rust/src/cli/commands.rs
-- rust/src/cli/mod.rs
-- rust/src/diagnostics/diagnostic.rs
-- rust/src/diagnostics/formatter.rs
-- rust/src/diagnostics/mod.rs
-- rust/src/env/box_manager.rs
-- rust/src/env/global_env.rs
-- rust/src/env/local_env.rs
-- rust/src/env/method_registry.rs
-- rust/src/env/mod.rs
-- rust/src/env/scope.rs
-- rust/src/env/type_error.rs
-- rust/src/env/vertex_manager.rs
-- rust/src/graph/box.rs
-- rust/src/graph/change_set.rs
-- rust/src/graph/mod.rs
-- rust/src/graph/vertex.rs
-- rust/src/lib.rs
-- rust/src/lsp/diagnostics.rs
-- rust/src/lsp/main.rs
-- rust/src/lsp/mod.rs
-- rust/src/lsp/server.rs
-- rust/src/main.rs
-- rust/src/parser.rs
-- rust/src/rbs/converter.rs
-- rust/src/rbs/error.rs
-- rust/src/rbs/loader.rs
-- rust/src/rbs/mod.rs
-- rust/src/source_map.rs
-- rust/src/types.rs
 homepage: https://github.com/dak2/method-ray
 licenses:
 - MIT