method-ray 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee779223feab7110e29256fdc4860ba480d13d676d18e85284fd0765eef2cc4b
-  data.tar.gz: 249087d8f6b7772aa7428a4828ffc35eacb1b0aa8b27d5cd909b803176d6a683
+  metadata.gz: f44709f8354439522722c8ea65da30463fae9de68d9be1aa07c8dac9627a03ce
+  data.tar.gz: 2a09885854020892cf93a1c85e83735a23be60240fcbee09f77fa8c9fbf58801
 SHA512:
-  metadata.gz: 8d6534a955eaf4937c5ebc4c525e07f5f7cd8599861f128cbb10161e00a6a932f1b47760e1283e7e2f48940ea0a89bb5c038ac83cdd8ce8a629f8f91b05e534a
-  data.tar.gz: cbe0d247ffcbd0ce4965f9e20a2293336aca3d7a6eeb96878665cb7692e11ea4366d3c1f2a87ea32711dbcd00a404d4a41da3e84d34829d40568ec0bb37d74b4
+  metadata.gz: 4be6a23881adf54e88039c4e62255f09aa52005cf4085e6cbdc1910f642dae8e763ec7993445051bd3cff20693b5576e417f47b0864359c60db6becf1c21e204
+  data.tar.gz: cc9b502af18acc8463e9cddf95cc16b8ed6095ffc34d826642fe8193b2f4cc16aa7490a96f930493fe30fc4af21412cf2ff515f8f45e4d04bf9ec704f256ea26

data/CHANGELOG.md

@@ -5,6 +5,34 @@ 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
+
+- Kernel/Object methods loaded from RBS to reduce false positives ([#39](https://github.com/dak2/method-ray/pull/39))
+- Object/Kernel fallback chain for method resolution ([#40](https://github.com/dak2/method-ray/pull/40))
+- Constant namespace resolution for ConstantReadNode in nested scopes ([#41](https://github.com/dak2/method-ray/pull/41))
+- Cargo test added to CI workflow ([#38](https://github.com/dak2/method-ray/pull/38))
+
+### Changed
+
+- Extract `bytes_to_name` helper to consolidate 17 UTF-8 conversion sites ([#42](https://github.com/dak2/method-ray/pull/42))
+- Refactor MethodCallBox by extracting helper methods ([#43](https://github.com/dak2/method-ray/pull/43))
+
 ## [0.1.6] - 2026-02-23
 
 ### Fixed
@@ -95,6 +123,8 @@ 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
 [0.1.4]: https://github.com/dak2/method-ray/releases/tag/v0.1.4

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.6'
+  VERSION = '0.1.8'
 end

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "methodray-core"
-version = "0.1.6"
+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/blocks.rs

@@ -8,6 +8,7 @@
 use crate::env::{GlobalEnv, LocalEnv, ScopeKind};
 use crate::graph::{ChangeSet, VertexId};
 
+use super::bytes_to_name;
 use super::parameters::{install_optional_parameter, install_required_parameter, install_rest_parameter};
 
 /// Process block node
@@ -68,7 +69,7 @@ fn install_block_parameters_with_vtxs(
         // Required parameters (most common in blocks)
         for node in params.requireds().iter() {
             if let Some(req_param) = node.as_required_parameter_node() {
-                let name = String::from_utf8_lossy(req_param.name().as_slice()).to_string();
+                let name = bytes_to_name(req_param.name().as_slice());
                 let vtx = install_block_parameter(genv, lenv, name);
                 vtxs.push(vtx);
             }
@@ -77,7 +78,7 @@ fn install_block_parameters_with_vtxs(
         // Optional parameters: { |x = 1| ... }
         for node in params.optionals().iter() {
             if let Some(opt_param) = node.as_optional_parameter_node() {
-                let name = String::from_utf8_lossy(opt_param.name().as_slice()).to_string();
+                let name = bytes_to_name(opt_param.name().as_slice());
                 let default_value = opt_param.value();
 
                 if let Some(default_vtx) =
@@ -97,7 +98,7 @@ fn install_block_parameters_with_vtxs(
         if let Some(rest_node) = params.rest() {
             if let Some(rest_param) = rest_node.as_rest_parameter_node() {
                 if let Some(name_id) = rest_param.name() {
-                    let name = String::from_utf8_lossy(name_id.as_slice()).to_string();
+                    let name = bytes_to_name(name_id.as_slice());
                     let vtx = install_rest_parameter(genv, lenv, name);
                     vtxs.push(vtx);
                 }

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,11 +6,14 @@
 //! - 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;
 use ruby_prism::Node;
 
+use super::bytes_to_name;
 use super::install::install_statements;
 use super::parameters::install_parameters;
 
@@ -64,7 +67,7 @@ pub(crate) fn process_def_node(
     source: &str,
     def_node: &ruby_prism::DefNode,
 ) -> Option<VertexId> {
-    let method_name = String::from_utf8_lossy(def_node.name().as_slice()).to_string();
+    let method_name = bytes_to_name(def_node.name().as_slice());
 
     // Check if this is a class method (def self.foo)
     let is_class_method = def_node
@@ -77,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;
@@ -107,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,
             );
         }
     }
@@ -163,7 +168,7 @@ fn extract_module_name(module_node: &ruby_prism::ModuleNode) -> String {
 pub(crate) fn extract_constant_path(node: &Node) -> Option<String> {
     // Simple constant read: `User`
     if let Some(constant_read) = node.as_constant_read_node() {
-        return Some(String::from_utf8_lossy(constant_read.name().as_slice()).to_string());
+        return Some(bytes_to_name(constant_read.name().as_slice()));
     }
 
     // Constant path: `Api::User` or `Api::V1::User`
@@ -171,7 +176,7 @@ pub(crate) fn extract_constant_path(node: &Node) -> Option<String> {
         // name() returns Option<ConstantId>, use as_slice() to get &[u8]
         let name = constant_path
             .name()
-            .map(|id| String::from_utf8_lossy(id.as_slice()).to_string())?;
+            .map(|id| bytes_to_name(id.as_slice()))?;
 
         // Get parent path if exists
         if let Some(parent_node) = constant_path.parent() {