method-ray 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b5b60b4408b5e547cb40911fb0eb68d4dce182bc32fdf1ce3e6c8cd25f24975
-  data.tar.gz: 44f0b585ad8f2c83568d0df520711b2c1d09affd6fded8e35fbc3f27b082f073
+  metadata.gz: f44709f8354439522722c8ea65da30463fae9de68d9be1aa07c8dac9627a03ce
+  data.tar.gz: 2a09885854020892cf93a1c85e83735a23be60240fcbee09f77fa8c9fbf58801
 SHA512:
-  metadata.gz: 1a7988edfb76b4fe4d1e03b8558104cc378299ebf8651b79dfc743e0e48b9cd4a04d235be1ca054f3ad172f9b7a8b0689e4bf99250935c02ab5cedb0737f1340
-  data.tar.gz: b6d94d5ce791e5b8317a880e986d60618a017434bc5823412dba3c8a04dcf3fb25089dff2a86e3662ecb7c2cdd13790cd32d5b18bc73960cf488ad8e8849a35b
+  metadata.gz: 4be6a23881adf54e88039c4e62255f09aa52005cf4085e6cbdc1910f642dae8e763ec7993445051bd3cff20693b5576e417f47b0864359c60db6becf1c21e204
+  data.tar.gz: cc9b502af18acc8463e9cddf95cc16b8ed6095ffc34d826642fe8193b2f4cc16aa7490a96f930493fe30fc4af21412cf2ff515f8f45e4d04bf9ec704f256ea26

data/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.8] - 2026-03-09
+
+### Added
+
+- while/until loop support to type inference ([#46](https://github.com/dak2/method-ray/pull/46))
+- Not operator (!) support to type inference ([#47](https://github.com/dak2/method-ray/pull/47))
+- begin/rescue/ensure exception handling support to type inference ([#48](https://github.com/dak2/method-ray/pull/48))
+- Keyword argument support to type inference ([#49](https://github.com/dak2/method-ray/pull/49))
+- Multiple assignment support to type inference ([#50](https://github.com/dak2/method-ray/pull/50))
+
+### Changed
+
+- Resolve all Clippy warnings for cleaner, more idiomatic Rust ([#51](https://github.com/dak2/method-ray/pull/51))
+
 ## [0.1.7] - 2026-03-07
 
 ### Added
@@ -109,6 +123,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Initial release
 - `methodray check` - Static type checking for Ruby files
 
+[0.1.8]: https://github.com/dak2/method-ray/releases/tag/v0.1.8
 [0.1.7]: https://github.com/dak2/method-ray/releases/tag/v0.1.7
 [0.1.6]: https://github.com/dak2/method-ray/releases/tag/v0.1.6
 [0.1.5]: https://github.com/dak2/method-ray/releases/tag/v0.1.5

data/ext/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "methodray"
-version = "0.1.6"
+version = "0.1.8"
 edition = "2021"
 
 [lib]

data/lib/methodray/version.rb

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

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "methodray-core"
-version = "0.1.7"
+version = "0.1.8"
 edition = "2021"
 
 [lib]

data/rust/src/analyzer/assignments.rs

@@ -0,0 +1,152 @@
+//! Multiple Assignment Handlers - Processing Ruby multiple assignment
+//!
+//! v0.1.8 scope: Only RHS as ArrayNode (multiple literal values) is supported.
+//! TODO: Support RHS as single expression (array decomposition)
+//! TODO: Support splat target (*rest) as Array type
+//! TODO: Support RHS as method return value decomposition
+//! TODO: When LHS is longer than RHS, register trailing targets as NilClass
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+
+use super::bytes_to_name;
+use super::variables::install_local_var_write;
+
+/// Process multiple assignment node (e.g., `a, b = 1, "hello"`)
+pub(crate) fn process_multi_write_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    node: &ruby_prism::MultiWriteNode,
+) -> Option<VertexId> {
+    let value = node.value();
+    let mut last_vtx = None;
+
+    if let Some(array_node) = value.as_array_node() {
+        for (target, rhs_elem) in node.lefts().iter().zip(array_node.elements().iter()) {
+            if let Some(target_node) = target.as_local_variable_target_node() {
+                let var_name = bytes_to_name(target_node.name().as_slice());
+                let rhs_vtx =
+                    super::install::install_node(genv, lenv, changes, source, &rhs_elem);
+                if let Some(rv) = rhs_vtx {
+                    last_vtx = Some(install_local_var_write(genv, lenv, changes, var_name, rv));
+                } else {
+                    let var_vtx = genv.new_vertex();
+                    lenv.new_var(var_name, var_vtx);
+                    last_vtx = Some(var_vtx);
+                }
+            }
+        }
+    } else {
+        for target in node.lefts().iter() {
+            if let Some(target_node) = target.as_local_variable_target_node() {
+                let var_name = bytes_to_name(target_node.name().as_slice());
+                let var_vtx = genv.new_vertex();
+                lenv.new_var(var_name, var_vtx);
+                last_vtx = Some(var_vtx);
+            }
+        }
+    }
+
+    last_vtx
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::analyzer::install::AstInstaller;
+    use crate::env::{GlobalEnv, LocalEnv};
+    use crate::graph::VertexId;
+    use crate::parser::ParseSession;
+
+    fn analyze(source: &str) -> (GlobalEnv, LocalEnv) {
+        let session = ParseSession::new();
+        let parse_result = session.parse_source(source, "test.rb").unwrap();
+        let root = parse_result.node();
+        let program = root.as_program_node().unwrap();
+
+        let mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+
+        let mut installer = AstInstaller::new(&mut genv, &mut lenv, source);
+        for stmt in &program.statements().body() {
+            installer.install_node(&stmt);
+        }
+        installer.finish();
+
+        (genv, lenv)
+    }
+
+    fn get_type_show(genv: &GlobalEnv, vtx: VertexId) -> String {
+        if let Some(vertex) = genv.get_vertex(vtx) {
+            vertex.show()
+        } else if let Some(source) = genv.get_source(vtx) {
+            source.ty.show()
+        } else {
+            panic!("vertex {:?} not found as either Vertex or Source", vtx);
+        }
+    }
+
+    #[test]
+    fn test_multi_write_integer_and_string() {
+        let source = r#"a, b = 1, "hello""#;
+        let (genv, lenv) = analyze(source);
+
+        let a_vtx = lenv.get_var("a").expect("a should be registered");
+        assert_eq!(get_type_show(&genv, a_vtx), "Integer");
+
+        let b_vtx = lenv.get_var("b").expect("b should be registered");
+        assert_eq!(get_type_show(&genv, b_vtx), "String");
+    }
+
+    #[test]
+    fn test_multi_write_all_integer() {
+        let source = "a, b, c = 1, 2, 3";
+        let (genv, lenv) = analyze(source);
+
+        let a_vtx = lenv.get_var("a").expect("a should be registered");
+        assert_eq!(get_type_show(&genv, a_vtx), "Integer");
+
+        let b_vtx = lenv.get_var("b").expect("b should be registered");
+        assert_eq!(get_type_show(&genv, b_vtx), "Integer");
+
+        let c_vtx = lenv.get_var("c").expect("c should be registered");
+        assert_eq!(get_type_show(&genv, c_vtx), "Integer");
+    }
+
+    #[test]
+    fn test_multi_write_variable_reference_after_assignment() {
+        let source = r#"
+a, b = 1, "hello"
+x = a
+"#;
+        let (genv, lenv) = analyze(source);
+
+        let x_vtx = lenv.get_var("x").expect("x should be registered");
+        assert_eq!(get_type_show(&genv, x_vtx), "Integer");
+    }
+
+    #[test]
+    fn test_multi_write_lhs_longer_than_rhs() {
+        let source = "a, b, c = 1, 2";
+        let (_, lenv) = analyze(source);
+
+        assert!(lenv.get_var("a").is_some(), "a should be registered");
+        assert!(lenv.get_var("b").is_some(), "b should be registered");
+        // KNOWN LIMITATION (v0.1.8): In Ruby, c receives nil, but zip skips it here
+        assert!(
+            lenv.get_var("c").is_none(),
+            "c should not be registered (zip skips)"
+        );
+    }
+
+    #[test]
+    fn test_multi_write_does_not_panic_on_non_array_rhs() {
+        let source = "a, b = some_expr";
+        let (_, lenv) = analyze(source);
+
+        // Variables should be registered (untyped) without panic
+        assert!(lenv.get_var("a").is_some(), "a should be registered");
+        assert!(lenv.get_var("b").is_some(), "b should be registered");
+    }
+}

data/rust/src/analyzer/attributes.rs

@@ -39,7 +39,7 @@ pub(crate) fn process_attr_declaration(
 
         // Register getter (attr_reader / attr_accessor)
         if matches!(kind, AttrKind::Reader | AttrKind::Accessor) {
-            genv.register_user_method(recv_ty.clone(), &attr_name, ivar_vtx, vec![]);
+            genv.register_user_method(recv_ty.clone(), &attr_name, ivar_vtx, vec![], None);
         }
 
         // Register setter (attr_writer / attr_accessor)
@@ -51,6 +51,7 @@ pub(crate) fn process_attr_declaration(
                 &format!("{}=", attr_name),
                 ivar_vtx,
                 vec![param_vtx],
+                None,
             );
         }
     }

data/rust/src/analyzer/calls.rs

@@ -5,6 +5,8 @@
 //! - Managing return value vertices
 //! - Attaching source location for error reporting
 
+use std::collections::HashMap;
+
 use crate::env::GlobalEnv;
 use crate::graph::{MethodCallBox, VertexId};
 use crate::source_map::SourceLocation;
@@ -15,6 +17,7 @@ pub fn install_method_call(
     recv_vtx: VertexId,
     method_name: String,
     arg_vtxs: Vec<VertexId>,
+    kwarg_vtxs: Option<HashMap<String, VertexId>>,
     location: Option<SourceLocation>,
 ) -> VertexId {
     // Create Vertex for return value
@@ -22,7 +25,8 @@ pub fn install_method_call(
 
     // Create MethodCallBox with location and argument vertices
     let box_id = genv.alloc_box_id();
-    let call_box = MethodCallBox::new(box_id, recv_vtx, method_name, ret_vtx, arg_vtxs, location);
+    let call_box =
+        MethodCallBox::new(box_id, recv_vtx, method_name, ret_vtx, arg_vtxs, kwarg_vtxs, location);
     genv.register_box(box_id, Box::new(call_box));
 
     ret_vtx
@@ -39,7 +43,7 @@ mod tests {
 
         let recv_vtx = genv.new_source(Type::string());
         let ret_vtx =
-            install_method_call(&mut genv, recv_vtx, "upcase".to_string(), vec![], None);
+            install_method_call(&mut genv, recv_vtx, "upcase".to_string(), vec![], None, None);
 
         // Return vertex should exist
         assert!(genv.get_vertex(ret_vtx).is_some());
@@ -51,7 +55,7 @@ mod tests {
 
         let recv_vtx = genv.new_source(Type::string());
         let _ret_vtx =
-            install_method_call(&mut genv, recv_vtx, "upcase".to_string(), vec![], None);
+            install_method_call(&mut genv, recv_vtx, "upcase".to_string(), vec![], None, None);
 
         // Box should be added
         assert_eq!(genv.box_count(), 1);

data/rust/src/analyzer/definitions.rs

@@ -6,6 +6,8 @@
 //! - Method definition scope management (def baz ... end)
 //! - Extracting class/module names from AST nodes (including qualified names like Api::User)
 
+use std::collections::HashMap;
+
 use crate::env::{GlobalEnv, LocalEnv};
 use crate::graph::{ChangeSet, VertexId};
 use crate::types::Type;
@@ -78,10 +80,10 @@ pub(crate) fn process_def_node(
     let merge_vtx = genv.scope_manager.current_method_return_vertex();
 
     // Process parameters BEFORE processing body
-    let param_vtxs = if let Some(params_node) = def_node.parameters() {
+    let (param_vtxs, keyword_param_vtxs) = if let Some(params_node) = def_node.parameters() {
         install_parameters(genv, lenv, changes, source, &params_node)
     } else {
-        vec![]
+        (vec![], HashMap::new())
     };
 
     let mut last_vtx = None;
@@ -108,11 +110,13 @@ pub(crate) fn process_def_node(
             } else {
                 Type::instance(&name)
             };
+            let kw_params = (!keyword_param_vtxs.is_empty()).then_some(keyword_param_vtxs);
             genv.register_user_method(
                 recv_type,
                 &method_name,
                 ret_vtx,
                 param_vtxs,
+                kw_params,
             );
         }
     }

data/rust/src/analyzer/dispatch.rs

@@ -3,6 +3,8 @@
 //! This module handles the pattern matching of Ruby AST nodes
 //! and dispatches them to specialized handlers.
 
+use std::collections::HashMap;
+
 use crate::env::{GlobalEnv, LocalEnv};
 use crate::graph::{BlockParameterTypeBox, ChangeSet, VertexId};
 use crate::source_map::SourceLocation;
@@ -235,7 +237,8 @@ pub(crate) fn process_needs_child(
         } => {
             let recv_vtx = super::install::install_node(genv, lenv, changes, source, &receiver)?;
             process_method_call_common(
-                genv, lenv, changes, source, recv_vtx, method_name, location, block, arguments,
+                genv, lenv, changes, source,
+                MethodCallContext { recv_vtx, method_name, location, block, arguments },
             )
         }
         NeedsChildKind::ImplicitSelfCall {
@@ -251,7 +254,8 @@ pub(crate) fn process_needs_child(
                 genv.new_source(Type::instance("Object"))
             };
             process_method_call_common(
-                genv, lenv, changes, source, recv_vtx, method_name, location, block, arguments,
+                genv, lenv, changes, source,
+                MethodCallContext { recv_vtx, method_name, location, block, arguments },
             )
         }
         NeedsChildKind::AttrDeclaration { kind, attr_names } => {
@@ -277,6 +281,15 @@ fn finish_local_var_write(
     install_local_var_write(genv, lenv, changes, var_name, value_vtx)
 }
 
+/// Bundled parameters for method call processing
+struct MethodCallContext<'a> {
+    recv_vtx: VertexId,
+    method_name: String,
+    location: SourceLocation,
+    block: Option<Node<'a>>,
+    arguments: Vec<Node<'a>>,
+}
+
 /// MethodCall / ImplicitSelfCall common processing:
 /// Handles argument processing, block processing, and MethodCallBox creation after recv_vtx is obtained
 fn process_method_call_common<'a>(
@@ -284,16 +297,44 @@ fn process_method_call_common<'a>(
     lenv: &mut LocalEnv,
     changes: &mut ChangeSet,
     source: &str,
-    recv_vtx: VertexId,
-    method_name: String,
-    location: SourceLocation,
-    block: Option<Node<'a>>,
-    arguments: Vec<Node<'a>>,
+    ctx: MethodCallContext<'a>,
 ) -> Option<VertexId> {
-    let arg_vtxs: Vec<VertexId> = arguments
-        .iter()
-        .filter_map(|arg| super::install::install_node(genv, lenv, changes, source, arg))
-        .collect();
+    let MethodCallContext {
+        recv_vtx,
+        method_name,
+        location,
+        block,
+        arguments,
+    } = ctx;
+    if method_name == "!" {
+        return Some(super::operators::process_not_operator(genv));
+    }
+
+    // Separate positional arguments and keyword arguments
+    let mut positional_arg_vtxs: Vec<VertexId> = Vec::new();
+    let mut keyword_arg_vtxs: HashMap<String, VertexId> = HashMap::new();
+
+    for arg in &arguments {
+        if let Some(kw_hash) = arg.as_keyword_hash_node() {
+            for element in kw_hash.elements().iter() {
+                let assoc = match element.as_assoc_node() {
+                    Some(a) => a,
+                    None => continue,
+                };
+                let name = match assoc.key().as_symbol_node() {
+                    Some(sym) => bytes_to_name(sym.unescaped()),
+                    None => continue,
+                };
+                if let Some(vtx) =
+                    super::install::install_node(genv, lenv, changes, source, &assoc.value())
+                {
+                    keyword_arg_vtxs.insert(name, vtx);
+                }
+            }
+        } else if let Some(vtx) = super::install::install_node(genv, lenv, changes, source, arg) {
+            positional_arg_vtxs.push(vtx);
+        }
+    }
 
     if let Some(block_node) = block {
         if let Some(block) = block_node.as_block_node() {
@@ -314,8 +355,19 @@ fn process_method_call_common<'a>(
         }
     }
 
+    let kwarg_vtxs = if keyword_arg_vtxs.is_empty() {
+        None
+    } else {
+        Some(keyword_arg_vtxs)
+    };
+
     Some(finish_method_call(
-        genv, recv_vtx, method_name, arg_vtxs, location,
+        genv,
+        recv_vtx,
+        method_name,
+        positional_arg_vtxs,
+        kwarg_vtxs,
+        location,
     ))
 }
 
@@ -325,9 +377,10 @@ fn finish_method_call(
     recv_vtx: VertexId,
     method_name: String,
     arg_vtxs: Vec<VertexId>,
+    kwarg_vtxs: Option<HashMap<String, VertexId>>,
     location: SourceLocation,
 ) -> VertexId {
-    install_method_call(genv, recv_vtx, method_name, arg_vtxs, Some(location))
+    install_method_call(genv, recv_vtx, method_name, arg_vtxs, kwarg_vtxs, Some(location))
 }
 
 #[cfg(test)]
@@ -980,4 +1033,105 @@ end
             genv.type_errors
         );
     }
+
+    // === Keyword argument tests ===
+
+    // Test 26: Required keyword argument type propagation
+    #[test]
+    fn test_keyword_arg_required_propagation() {
+        let source = r#"
+class Greeter
+  def greet(name:)
+    name
+  end
+end
+
+Greeter.new.greet(name: "Alice")
+"#;
+        let genv = analyze(source);
+
+        let info = genv
+            .resolve_method(&Type::instance("Greeter"), "greet")
+            .expect("Greeter#greet should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    // Test 27: Optional keyword argument with default type
+    #[test]
+    fn test_keyword_arg_optional_default_type() {
+        let source = r#"
+class Counter
+  def count(step: 1)
+    step
+  end
+end
+"#;
+        let genv = analyze(source);
+
+        let info = genv
+            .resolve_method(&Type::instance("Counter"), "count")
+            .expect("Counter#count should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        // step has Integer type from default value
+        assert_eq!(get_type_show(&genv, ret_vtx), "Integer");
+    }
+
+    // Test 28: Positional and keyword arguments mixed
+    #[test]
+    fn test_positional_and_keyword_mixed() {
+        let source = r#"
+class User
+  def initialize(id, name:)
+    @id = id
+    @name = name
+  end
+end
+
+User.new(1, name: "Alice")
+"#;
+        let genv = analyze(source);
+        assert!(genv.type_errors.is_empty());
+    }
+
+    // Test 29: Keyword argument via .new propagation to initialize
+    #[test]
+    fn test_keyword_arg_via_new_to_initialize() {
+        let source = r#"
+class Config
+  def initialize(debug:)
+    @debug = debug
+  end
+
+  def debug?
+    @debug
+  end
+end
+
+Config.new(debug: true)
+"#;
+        let genv = analyze(source);
+        assert!(genv.type_errors.is_empty());
+    }
+
+    // Test 30: Multiple keyword arguments
+    #[test]
+    fn test_multiple_keyword_args() {
+        let source = r#"
+class User
+  def profile(name:, age:)
+    name
+  end
+end
+
+User.new.profile(name: "Alice", age: 30)
+"#;
+        let genv = analyze(source);
+
+        let info = genv
+            .resolve_method(&Type::instance("User"), "profile")
+            .expect("User#profile should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
 }