method-ray 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f44709f8354439522722c8ea65da30463fae9de68d9be1aa07c8dac9627a03ce
-  data.tar.gz: 2a09885854020892cf93a1c85e83735a23be60240fcbee09f77fa8c9fbf58801
+  metadata.gz: 228f256ea9848bd9b2447e097aee95f59f47db2bd252611a7dfa30363be34a23
+  data.tar.gz: 0ff2217ee68021004331bd580f26739ce067f223ea113b741ab0636f2771e30e
 SHA512:
-  metadata.gz: 4be6a23881adf54e88039c4e62255f09aa52005cf4085e6cbdc1910f642dae8e763ec7993445051bd3cff20693b5576e417f47b0864359c60db6becf1c21e204
-  data.tar.gz: cc9b502af18acc8463e9cddf95cc16b8ed6095ffc34d826642fe8193b2f4cc16aa7490a96f930493fe30fc4af21412cf2ff515f8f45e4d04bf9ec704f256ea26
+  metadata.gz: 3c274c68e498eed4f432b60c4a68a6ca469b7850db539954f584d89bd96cbf3612e03a9a9f43a1b8a8941be6302142e7f34e886b279cde41bc22a0376ba48ac7
+  data.tar.gz: 57e66add8decf8c951f890f140f76fca86b642af91a7df9d7622c5144414b20f158444838aeca5082a46efa185280747a32117980654ae5f03d0c1dc23bbcd35

data/CHANGELOG.md

@@ -5,6 +5,42 @@ 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.10] - 2026-03-24
+
+### Added
+
+- Add safe navigation operator (`&.`) support ([#65](https://github.com/dak2/method-ray/pull/65))
+- Add inheritance chain method resolution for user-defined classes ([#66](https://github.com/dak2/method-ray/pull/66))
+- Add extend support for module methods as class methods ([#67](https://github.com/dak2/method-ray/pull/67))
+- Add pull request template ([#82](https://github.com/dak2/method-ray/pull/82))
+
+### Changed
+
+- Migrate Rust integration tests to Ruby integration tests ([#68](https://github.com/dak2/method-ray/pull/68), [#69](https://github.com/dak2/method-ray/pull/69), [#70](https://github.com/dak2/method-ray/pull/70), [#71](https://github.com/dak2/method-ray/pull/71), [#72](https://github.com/dak2/method-ray/pull/72), [#73](https://github.com/dak2/method-ray/pull/73), [#74](https://github.com/dak2/method-ray/pull/74), [#75](https://github.com/dak2/method-ray/pull/75))
+- Remove redundant Rust unit tests ([#77](https://github.com/dak2/method-ray/pull/77), [#78](https://github.com/dak2/method-ray/pull/78), [#80](https://github.com/dak2/method-ray/pull/80), [#83](https://github.com/dak2/method-ray/pull/83), [#84](https://github.com/dak2/method-ray/pull/84), [#85](https://github.com/dak2/method-ray/pull/85), [#86](https://github.com/dak2/method-ray/pull/86))
+- Simplify README to focus on core value proposition ([#76](https://github.com/dak2/method-ray/pull/76))
+
+### Fixed
+
+- Fix release workflow to include gem assets in GitHub Release ([#63](https://github.com/dak2/method-ray/pull/63), [#64](https://github.com/dak2/method-ray/pull/64))
+
+## [0.1.9] - 2026-03-15
+
+### Added
+
+- Add linter CI workflow for Clippy and RuboCop ([#61](https://github.com/dak2/method-ray/pull/61))
+- Add unit tests for blocks and parameters analyzers ([#60](https://github.com/dak2/method-ray/pull/60))
+- Add super call type inference support ([#59](https://github.com/dak2/method-ray/pull/59))
+- Add for loop type inference support ([#58](https://github.com/dak2/method-ray/pull/58))
+- Add module include support for mixin method resolution ([#57](https://github.com/dak2/method-ray/pull/57))
+- Add complete multi-assignment type inference ([#56](https://github.com/dak2/method-ray/pull/56))
+- Add auto-tagging workflow for release PR merges ([#53](https://github.com/dak2/method-ray/pull/53))
+
+### Changed
+
+- Rename rust/ directory to core/ ([#55](https://github.com/dak2/method-ray/pull/55))
+- Infer actual exception types in rescue clauses ([#54](https://github.com/dak2/method-ray/pull/54))
+
 ## [0.1.8] - 2026-03-09
 
 ### Added
@@ -123,6 +159,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.10]: https://github.com/dak2/method-ray/releases/tag/v0.1.10
+[0.1.9]: https://github.com/dak2/method-ray/releases/tag/v0.1.9
 [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

data/README.md

@@ -16,28 +16,26 @@ gem install methodray
 
 ## Quick Start
 
-### VSCode Extension (under development)
-
-1. Install the [Method-Ray VSCode extension](https://github.com/dak2/method-ray-vscode)
-2. Open a Ruby file in VSCode
-3. Errors will be highlighted automatically
-
-### CLI
+### Checking Methods
 
 ```bash
 # Check a single file
 bundle exec methodray check app/models/user.rb
+```
 
-# Watch mode - auto re-check on file changes
+### Watching for File Changes, Re-checking Methods
+
+```bash
+# Watch a file for changes and re-check on save
 bundle exec methodray watch app/models/user.rb
 ```
 
-#### Example
-
-`methodray check <file>`: Performs static type checking on the specified Ruby file.
+#### Example Usage
 
+`bundle exec methodray check app/models/user.rb`
 
 ```ruby
+# app/models/user.rb
 class User
   def greeting
     name = "Alice"

data/{rust → core}/Cargo.toml

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

data/core/src/analyzer/assignments.rs

@@ -0,0 +1,219 @@
+//! Multiple Assignment Handlers - Processing Ruby multiple assignment
+//!
+//! Supports: ArrayNode RHS with 1:1 mapping, LHS > RHS nil fill,
+//! splat targets (*rest) as Array type, and basic single-expression RHS decomposition.
+//! TODO: Support RHS as method return value decomposition (requires graph lazy resolution)
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::types::Type;
+
+use super::bytes_to_name;
+use super::variables::install_local_var_write;
+
+/// Install an RHS node and assign it to a named local variable.
+/// Falls back to an untyped vertex when `install_node` returns `None`.
+fn install_target(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    var_name: String,
+    rhs_node: &ruby_prism::Node,
+) -> VertexId {
+    if let Some(rv) = super::install::install_node(genv, lenv, changes, source, rhs_node) {
+        install_local_var_write(genv, lenv, changes, var_name, rv)
+    } else {
+        let vtx = genv.new_vertex();
+        lenv.new_var(var_name, vtx);
+        vtx
+    }
+}
+
+/// Assign `Type::Nil` to a named local variable.
+fn install_nil_target(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    var_name: String,
+) -> VertexId {
+    let nil_src = genv.new_source(Type::Nil);
+    install_local_var_write(genv, lenv, changes, var_name, nil_src)
+}
+
+/// Extract the splat target variable name from a `node.rest()` result.
+fn splat_var_name(rest_node: &ruby_prism::Node) -> Option<String> {
+    let splat = rest_node.as_splat_node()?;
+    let expr = splat.expression()?;
+    let target = expr.as_local_variable_target_node()?;
+    Some(bytes_to_name(target.name().as_slice()))
+}
+
+/// Collect unique types from a slice of elements, returning element type for Array[T].
+/// Only nodes that resolve to a Source (fixed type) contribute; Vertex-type nodes
+/// are excluded (known limitation — requires lazy resolution for method return values).
+fn collect_element_type(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    elements: &[ruby_prism::Node],
+) -> Type {
+    let mut types: Vec<Type> = Vec::new();
+    for elem in elements {
+        if let Some(vtx) = super::install::install_node(genv, lenv, changes, source, elem) {
+            if let Some(src) = genv.get_source(vtx) {
+                if !types.contains(&src.ty) {
+                    types.push(src.ty.clone());
+                }
+            }
+        }
+    }
+    if types.is_empty() {
+        Type::Bot
+    } else {
+        Type::union_of(types)
+    }
+}
+
+/// 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() {
+        let lefts = node.lefts();
+        let elements: Vec<_> = array_node.elements().iter().collect();
+        let total = elements.len();
+        let lefts_count = lefts.len();
+        let rights = node.rights();
+        let rights_count = rights.len();
+
+        // Phase 1: Left targets — assign from start, nil for missing RHS
+        for (i, target) in lefts.iter().enumerate() {
+            if let Some(target_node) = target.as_local_variable_target_node() {
+                let var_name = bytes_to_name(target_node.name().as_slice());
+                if i < total {
+                    last_vtx = Some(install_target(
+                        genv,
+                        lenv,
+                        changes,
+                        source,
+                        var_name,
+                        &elements[i],
+                    ));
+                } else {
+                    last_vtx = Some(install_nil_target(genv, lenv, changes, var_name));
+                }
+            }
+        }
+
+        // Phase 2: Splat target (*rest) — collect middle elements (after lefts, before rights) into Array[T]
+        if let Some(rest_node) = node.rest() {
+            if let Some(var_name) = splat_var_name(&rest_node) {
+                let splat_start = lefts_count;
+                let splat_end = total.saturating_sub(rights_count);
+                let splat_elements = if splat_start < splat_end {
+                    &elements[splat_start..splat_end]
+                } else {
+                    &elements[0..0]
+                };
+                let element_type = collect_element_type(
+                    genv,
+                    lenv,
+                    changes,
+                    source,
+                    splat_elements,
+                );
+                let array_src = genv.new_source(Type::array_of(element_type));
+                last_vtx = Some(install_local_var_write(
+                    genv, lenv, changes, var_name, array_src,
+                ));
+            }
+        }
+
+        // Phase 3: Right targets — assigned from end of elements, nil if overlapping with lefts
+        for (i, target) in rights.iter().enumerate() {
+            if let Some(target_node) = target.as_local_variable_target_node() {
+                let var_name = bytes_to_name(target_node.name().as_slice());
+                let signed_idx = total as isize - rights_count as isize + i as isize;
+                if signed_idx >= lefts_count as isize && (signed_idx as usize) < total {
+                    last_vtx = Some(install_target(
+                        genv,
+                        lenv,
+                        changes,
+                        source,
+                        var_name,
+                        &elements[signed_idx as usize],
+                    ));
+                } else {
+                    last_vtx = Some(install_nil_target(genv, lenv, changes, var_name));
+                }
+            }
+        }
+    } else {
+        // RHS is a single expression (not comma-separated)
+        let rhs_vtx = super::install::install_node(genv, lenv, changes, source, &value);
+
+        let rhs_type = rhs_vtx
+            .and_then(|vtx| genv.get_source(vtx))
+            .map(|src| src.ty.clone());
+
+        // If RHS is Array[T], each target gets T; otherwise first target gets RHS, rest get nil
+        let element_type = rhs_type
+            .as_ref()
+            .and_then(|ty| ty.type_args())
+            .and_then(|args| args.first().cloned());
+
+        for (i, target) in node.lefts().iter().enumerate() {
+            if let Some(target_node) = target.as_local_variable_target_node() {
+                let var_name = bytes_to_name(target_node.name().as_slice());
+                if let Some(ref elem_ty) = element_type {
+                    let src = genv.new_source(elem_ty.clone());
+                    last_vtx = Some(install_local_var_write(genv, lenv, changes, var_name, src));
+                } else if i == 0 {
+                    if let Some(rv) = rhs_vtx {
+                        last_vtx = Some(install_local_var_write(genv, lenv, changes, var_name, rv));
+                    } else {
+                        let vtx = genv.new_vertex();
+                        lenv.new_var(var_name, vtx);
+                        last_vtx = Some(vtx);
+                    }
+                } else if rhs_type.is_some() {
+                    last_vtx = Some(install_nil_target(genv, lenv, changes, var_name));
+                } else {
+                    let vtx = genv.new_vertex();
+                    lenv.new_var(var_name, vtx);
+                    last_vtx = Some(vtx);
+                }
+            }
+        }
+
+        // Splat in single-expression RHS
+        if let Some(rest_node) = node.rest() {
+            if let Some(var_name) = splat_var_name(&rest_node) {
+                let elem_ty = element_type.unwrap_or(Type::Bot);
+                let array_src = genv.new_source(Type::array_of(elem_ty));
+                last_vtx = Some(install_local_var_write(
+                    genv, lenv, changes, var_name, array_src,
+                ));
+            }
+        }
+
+        // Right targets in single-expression RHS → nil
+        for target in node.rights().iter() {
+            if let Some(target_node) = target.as_local_variable_target_node() {
+                let var_name = bytes_to_name(target_node.name().as_slice());
+                last_vtx = Some(install_nil_target(genv, lenv, changes, var_name));
+            }
+        }
+    }
+
+    last_vtx
+}

data/{rust → core}/src/analyzer/blocks.rs

@@ -124,53 +124,3 @@ fn exit_block_scope(genv: &mut GlobalEnv) {
 fn install_block_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, name: String) -> VertexId {
     install_required_parameter(genv, lenv, name)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_enter_exit_block_scope() {
-        let mut genv = GlobalEnv::new();
-
-        let initial_scope_id = genv.scope_manager.current_scope().id;
-
-        enter_block_scope(&mut genv);
-        let block_scope_id = genv.scope_manager.current_scope().id;
-
-        assert_ne!(initial_scope_id, block_scope_id);
-
-        exit_block_scope(&mut genv);
-
-        assert_eq!(genv.scope_manager.current_scope().id, initial_scope_id);
-    }
-
-    #[test]
-    fn test_install_block_parameter() {
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-
-        enter_block_scope(&mut genv);
-
-        let vtx = install_block_parameter(&mut genv, &mut lenv, "x".to_string());
-
-        assert_eq!(lenv.get_var("x"), Some(vtx));
-
-        exit_block_scope(&mut genv);
-    }
-
-    #[test]
-    fn test_block_inherits_parent_scope_vars() {
-        let mut genv = GlobalEnv::new();
-
-        genv.scope_manager
-            .current_scope_mut()
-            .set_local_var("outer".to_string(), VertexId(100));
-
-        enter_block_scope(&mut genv);
-
-        assert_eq!(genv.scope_manager.lookup_var("outer"), Some(VertexId(100)));
-
-        exit_block_scope(&mut genv);
-    }
-}

data/{rust → core}/src/analyzer/calls.rs

@@ -12,13 +12,14 @@ use crate::graph::{MethodCallBox, VertexId};
 use crate::source_map::SourceLocation;
 
 /// Install method call and return the return value's VertexId
-pub fn install_method_call(
+pub(crate) fn install_method_call(
     genv: &mut GlobalEnv,
     recv_vtx: VertexId,
     method_name: String,
     arg_vtxs: Vec<VertexId>,
     kwarg_vtxs: Option<HashMap<String, VertexId>>,
     location: Option<SourceLocation>,
+    safe_navigation: bool,
 ) -> VertexId {
     // Create Vertex for return value
     let ret_vtx = genv.new_vertex();
@@ -26,38 +27,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, kwarg_vtxs, location);
+        MethodCallBox::new(box_id, recv_vtx, method_name, ret_vtx, arg_vtxs, kwarg_vtxs, location, safe_navigation);
     genv.register_box(box_id, Box::new(call_box));
 
     ret_vtx
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::types::Type;
-
-    #[test]
-    fn test_install_method_call_creates_vertex() {
-        let mut genv = GlobalEnv::new();
-
-        let recv_vtx = genv.new_source(Type::string());
-        let ret_vtx =
-            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());
-    }
-
-    #[test]
-    fn test_install_method_call_adds_box() {
-        let mut genv = GlobalEnv::new();
-
-        let recv_vtx = genv.new_source(Type::string());
-        let _ret_vtx =
-            install_method_call(&mut genv, recv_vtx, "upcase".to_string(), vec![], None, None);
-
-        // Box should be added
-        assert_eq!(genv.box_count(), 1);
-    }
-}

data/core/src/analyzer/conditionals.rs

@@ -0,0 +1,190 @@
+//! Conditionals - if/unless/case type inference
+//!
+//! Collects types from each branch and merges them into a Union
+//! via edges into a single result Vertex.
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::types::Type;
+use ruby_prism::{CaseNode, ElseNode, IfNode, Node, UnlessNode, WhenNode};
+
+use super::install::{install_node, install_statements};
+
+/// Process IfNode: if/elsif/else chain
+pub(crate) fn process_if_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    if_node: &IfNode,
+) -> Option<VertexId> {
+    // Process predicate for side effects
+    install_node(genv, lenv, changes, source, &if_node.predicate());
+
+    let result_vtx = genv.new_vertex();
+
+    // then branch
+    let vtx_then = if_node
+        .statements()
+        .and_then(|stmts| install_statements(genv, lenv, changes, source, &stmts));
+    if let Some(vtx) = vtx_then {
+        genv.add_edge(vtx, result_vtx);
+    }
+
+    // elsif/else branch (subsequent)
+    let has_else = if let Some(subsequent) = if_node.subsequent() {
+        let vtx_sub = process_subsequent(genv, lenv, changes, source, &subsequent);
+        if let Some(vtx) = vtx_sub {
+            genv.add_edge(vtx, result_vtx);
+        }
+        true
+    } else {
+        false
+    };
+
+    // No else clause → add nil
+    if !has_else {
+        let nil_vtx = genv.new_source(Type::Nil);
+        genv.add_edge(nil_vtx, result_vtx);
+    }
+
+    Some(result_vtx)
+}
+
+/// Process UnlessNode: unless/else
+pub(crate) fn process_unless_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    unless_node: &UnlessNode,
+) -> Option<VertexId> {
+    // Process predicate for side effects
+    install_node(genv, lenv, changes, source, &unless_node.predicate());
+
+    let result_vtx = genv.new_vertex();
+
+    // body branch
+    let vtx_body = unless_node
+        .statements()
+        .and_then(|stmts| install_statements(genv, lenv, changes, source, &stmts));
+    if let Some(vtx) = vtx_body {
+        genv.add_edge(vtx, result_vtx);
+    }
+
+    // else clause
+    let has_else = if let Some(else_node) = unless_node.else_clause() {
+        let vtx_else = process_else_clause(genv, lenv, changes, source, &else_node);
+        if let Some(vtx) = vtx_else {
+            genv.add_edge(vtx, result_vtx);
+        }
+        true
+    } else {
+        false
+    };
+
+    // No else clause → add nil
+    if !has_else {
+        let nil_vtx = genv.new_source(Type::Nil);
+        genv.add_edge(nil_vtx, result_vtx);
+    }
+
+    Some(result_vtx)
+}
+
+/// Process CaseNode: case/when/else
+pub(crate) fn process_case_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    case_node: &CaseNode,
+) -> Option<VertexId> {
+    // Process predicate for side effects
+    if let Some(pred) = case_node.predicate() {
+        install_node(genv, lenv, changes, source, &pred);
+    }
+
+    let result_vtx = genv.new_vertex();
+
+    // Process each when clause
+    for condition in &case_node.conditions() {
+        if let Some(when_node) = condition.as_when_node() {
+            let vtx_when = process_when_clause(genv, lenv, changes, source, &when_node);
+            if let Some(vtx) = vtx_when {
+                genv.add_edge(vtx, result_vtx);
+            }
+        }
+    }
+
+    // else clause
+    let has_else = if let Some(else_node) = case_node.else_clause() {
+        let vtx_else = process_else_clause(genv, lenv, changes, source, &else_node);
+        if let Some(vtx) = vtx_else {
+            genv.add_edge(vtx, result_vtx);
+        }
+        true
+    } else {
+        false
+    };
+
+    // No else clause → add nil
+    if !has_else {
+        let nil_vtx = genv.new_source(Type::Nil);
+        genv.add_edge(nil_vtx, result_vtx);
+    }
+
+    Some(result_vtx)
+}
+
+/// Process subsequent node (elsif chain or else)
+fn process_subsequent(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    node: &Node,
+) -> Option<VertexId> {
+    // elsif: subsequent is another IfNode
+    if let Some(if_node) = node.as_if_node() {
+        return process_if_node(genv, lenv, changes, source, &if_node);
+    }
+
+    // else: subsequent is an ElseNode
+    if let Some(else_node) = node.as_else_node() {
+        return process_else_clause(genv, lenv, changes, source, &else_node);
+    }
+
+    None
+}
+
+/// Process ElseNode
+fn process_else_clause(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    else_node: &ElseNode,
+) -> Option<VertexId> {
+    else_node
+        .statements()
+        .and_then(|stmts| install_statements(genv, lenv, changes, source, &stmts))
+}
+
+/// Process WhenNode
+fn process_when_clause(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    when_node: &WhenNode,
+) -> Option<VertexId> {
+    // Process when conditions for side effects
+    for cond in &when_node.conditions() {
+        install_node(genv, lenv, changes, source, &cond);
+    }
+
+    when_node
+        .statements()
+        .and_then(|stmts| install_statements(genv, lenv, changes, source, &stmts))
+}