method-ray 0.1.4 → 0.1.5

data/rust/src/analyzer/definitions.rs

@@ -65,8 +65,17 @@ pub(crate) fn process_def_node(
     def_node: &ruby_prism::DefNode,
 ) -> Option<VertexId> {
     let method_name = String::from_utf8_lossy(def_node.name().as_slice()).to_string();
+
+    // Check if this is a class method (def self.foo)
+    let is_class_method = def_node
+        .receiver()
+        .map(|r| r.as_self_node().is_some())
+        .unwrap_or(false);
+
     install_method(genv, method_name.clone());
 
+    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() {
         install_parameters(genv, lenv, changes, source, &params_node)
@@ -81,18 +90,27 @@ pub(crate) fn process_def_node(
         }
     }
 
-    // Register user-defined method with return vertex and param vertices (before exiting scope)
-    if let Some(return_vtx) = last_vtx {
-        let recv_type_name = genv
-            .scope_manager
-            .current_class_name()
-            .or_else(|| genv.scope_manager.current_module_name());
+    // Connect last expression to merge vertex so that implicit return
+    // (Ruby's last-expression-is-return-value) is included in the union type
+    if let (Some(last), Some(merge)) = (last_vtx, merge_vtx) {
+        genv.add_edge(last, merge);
+    }
+
+    // Register user-defined method with merge vertex as return vertex
+    let return_vtx = merge_vtx.or(last_vtx);
+    if let Some(ret_vtx) = return_vtx {
+        let recv_type_name = genv.scope_manager.current_qualified_name();
 
         if let Some(name) = recv_type_name {
+            let recv_type = if is_class_method {
+                Type::singleton(&name)
+            } else {
+                Type::instance(&name)
+            };
             genv.register_user_method(
-                Type::instance(&name),
+                recv_type,
                 &method_name,
-                return_vtx,
+                ret_vtx,
                 param_vtxs,
             );
         }
@@ -334,4 +352,363 @@ mod tests {
             .expect("User#name should be registered");
         assert!(info.return_vertex.is_some());
     }
+
+    #[test]
+    fn test_qualified_name_method_registration() {
+        let source = r#"
+module Api
+  module V1
+    class User
+      def name
+        "Alice"
+      end
+    end
+  end
+end
+"#;
+        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 changes = ChangeSet::new();
+
+        for stmt in &program.statements().body() {
+            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
+        }
+
+        // Method should be registered with qualified name "Api::V1::User"
+        let info = genv
+            .resolve_method(&Type::instance("Api::V1::User"), "name")
+            .expect("Api::V1::User#name should be registered");
+        assert!(info.return_vertex.is_some());
+
+        // Should NOT be registered with simple name "User"
+        assert!(
+            genv.resolve_method(&Type::instance("User"), "name").is_none(),
+            "User#name should not exist — method should be registered under qualified name"
+        );
+    }
+
+    #[test]
+    fn test_same_class_name_different_namespace() {
+        let source = r#"
+module Api
+  class User
+    def name
+      "api_user"
+    end
+  end
+end
+
+module Admin
+  class User
+    def name
+      "admin_user"
+    end
+  end
+end
+"#;
+        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 changes = ChangeSet::new();
+
+        for stmt in &program.statements().body() {
+            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
+        }
+
+        // Both should be registered separately
+        let api_info = genv
+            .resolve_method(&Type::instance("Api::User"), "name")
+            .expect("Api::User#name should be registered");
+        assert!(api_info.return_vertex.is_some());
+
+        let admin_info = genv
+            .resolve_method(&Type::instance("Admin::User"), "name")
+            .expect("Admin::User#name should be registered");
+        assert!(admin_info.return_vertex.is_some());
+
+        // Simple "User" should not resolve
+        assert!(
+            genv.resolve_method(&Type::instance("User"), "name").is_none(),
+            "User#name should not exist — both are under qualified names"
+        );
+    }
+
+    #[test]
+    fn test_class_method_registration() {
+        let source = r#"
+class User
+  def self.create
+    "created"
+  end
+end
+"#;
+        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 changes = ChangeSet::new();
+
+        for stmt in &program.statements().body() {
+            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
+        }
+
+        // def self.create should be registered as singleton method
+        let info = genv
+            .resolve_method(&Type::singleton("User"), "create")
+            .expect("User.create should be registered as singleton method");
+        assert!(info.return_vertex.is_some());
+    }
+
+    #[test]
+    fn test_class_method_with_params() {
+        let source = r#"
+class User
+  def self.find(id)
+    "user"
+  end
+end
+"#;
+        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 changes = ChangeSet::new();
+
+        for stmt in &program.statements().body() {
+            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
+        }
+
+        let info = genv
+            .resolve_method(&Type::singleton("User"), "find")
+            .expect("User.find should be registered");
+        assert!(info.return_vertex.is_some());
+        assert_eq!(info.param_vertices.as_ref().unwrap().len(), 1);
+    }
+
+    #[test]
+    fn test_class_method_in_qualified_namespace() {
+        let source = r#"
+module Api
+  class User
+    def self.create
+      "created"
+    end
+  end
+end
+"#;
+        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 changes = ChangeSet::new();
+
+        for stmt in &program.statements().body() {
+            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
+        }
+
+        let info = genv
+            .resolve_method(&Type::singleton("Api::User"), "create")
+            .expect("Api::User.create should be registered");
+        assert!(info.return_vertex.is_some());
+    }
+
+    #[test]
+    fn test_class_method_not_registered_as_instance() {
+        let source = r#"
+class User
+  def self.create
+    "created"
+  end
+end
+"#;
+        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 changes = ChangeSet::new();
+
+        for stmt in &program.statements().body() {
+            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
+        }
+
+        // def self.create should NOT be registered as instance method
+        assert!(
+            genv.resolve_method(&Type::instance("User"), "create").is_none(),
+            "User#create should not exist — it's a class method"
+        );
+    }
+
+    #[test]
+    fn test_non_self_receiver_not_treated_as_class_method() {
+        let source = r#"
+class User
+  def other.foo
+    "test"
+  end
+end
+"#;
+        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 changes = ChangeSet::new();
+
+        for stmt in &program.statements().body() {
+            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
+        }
+
+        // def other.foo should NOT be registered as singleton method
+        assert!(
+            genv.resolve_method(&Type::singleton("User"), "foo").is_none(),
+            "User.foo should not exist — receiver is not self"
+        );
+    }
+
+    #[test]
+    fn test_class_method_return_type_inference() {
+        let source = r#"
+class User
+  def self.create
+    "created"
+  end
+end
+"#;
+        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 changes = ChangeSet::new();
+
+        for stmt in &program.statements().body() {
+            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
+        }
+
+        let info = genv
+            .resolve_method(&Type::singleton("User"), "create")
+            .expect("User.create should be registered");
+        let ret_vtx = info.return_vertex.expect("should have return vertex");
+
+        // Run solver to propagate types
+        genv.apply_changes(changes);
+        genv.run_all();
+
+        let vertex = genv.get_vertex(ret_vtx).or_else(|| {
+            // return vertex might be a source
+            None
+        });
+        if let Some(v) = vertex {
+            assert_eq!(v.show(), "String");
+        } else {
+            // Check if it's a source
+            let src = genv.get_source(ret_vtx).expect("should have source or vertex");
+            assert_eq!(src.ty, Type::string());
+        }
+    }
+
+    #[test]
+    fn test_class_method_in_reopened_class() {
+        let source = r#"
+class User
+  def self.create
+    "created"
+  end
+end
+
+class User
+  def self.destroy
+    "destroyed"
+  end
+end
+"#;
+        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 changes = ChangeSet::new();
+
+        for stmt in &program.statements().body() {
+            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
+        }
+
+        // Both class methods should be registered
+        assert!(
+            genv.resolve_method(&Type::singleton("User"), "create").is_some(),
+            "User.create should be registered"
+        );
+        assert!(
+            genv.resolve_method(&Type::singleton("User"), "destroy").is_some(),
+            "User.destroy should be registered"
+        );
+    }
+
+    #[test]
+    fn test_class_method_param_type_propagation() {
+        let source = r#"
+class User
+  def self.find(id)
+    id
+  end
+end
+
+User.find(42)
+"#;
+        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 changes = ChangeSet::new();
+
+        for stmt in &program.statements().body() {
+            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
+        }
+
+        let info = genv
+            .resolve_method(&Type::singleton("User"), "find")
+            .expect("User.find should be registered");
+        let param_vtxs = info.param_vertices.as_ref().expect("should have param vertices");
+        assert_eq!(param_vtxs.len(), 1);
+
+        let param_vtx = param_vtxs[0];
+
+        // Run solver to propagate argument types
+        genv.apply_changes(changes);
+        genv.run_all();
+
+        // Parameter should have Integer type propagated from call site
+        let vertex = genv.get_vertex(param_vtx).expect("param vertex should exist");
+        assert_eq!(vertex.show(), "Integer");
+    }
 }

data/rust/src/analyzer/dispatch.rs

@@ -241,12 +241,8 @@ pub(crate) fn process_needs_child(
             block,
             arguments,
         } => {
-            // Use the same naming as method registration in definitions.rs
-            let recv_type_name = genv
-                .scope_manager
-                .current_class_name()
-                .or_else(|| genv.scope_manager.current_module_name());
-            let recv_vtx = if let Some(name) = recv_type_name {
+            // Use qualified name to match method registration in definitions.rs
+            let recv_vtx = if let Some(name) = genv.scope_manager.current_qualified_name() {
                 genv.new_source(Type::instance(&name))
             } else {
                 genv.new_source(Type::instance("Object"))
@@ -439,10 +435,10 @@ end
 "#;
         let genv = analyze(source);
 
-        // Method registered with simple class name "User" (current behavior of definitions.rs)
+        // Method registered with qualified name "Api::V1::User"
         let info = genv
-            .resolve_method(&Type::instance("User"), "greet")
-            .expect("User#greet should be registered");
+            .resolve_method(&Type::instance("Api::V1::User"), "greet")
+            .expect("Api::V1::User#greet should be registered");
         assert!(info.return_vertex.is_some());
 
         let ret_vtx = info.return_vertex.unwrap();
@@ -685,10 +681,10 @@ end
 "#;
         let genv = analyze(source);
 
-        // Registered with simple class name "User"
+        // Registered with qualified name "Api::User"
         let info = genv
-            .resolve_method(&Type::instance("User"), "name")
-            .expect("User#name should be registered");
+            .resolve_method(&Type::instance("Api::User"), "name")
+            .expect("Api::User#name should be registered");
         assert!(info.return_vertex.is_some());
         assert_eq!(get_type_show(&genv, info.return_vertex.unwrap()), "String");
     }
@@ -874,4 +870,27 @@ User.some_method
             genv.type_errors
         );
     }
+
+    // Test: ConstantPathNode.new resolves with qualified method name
+    #[test]
+    fn test_constant_path_new_with_qualified_method() {
+        let source = r#"
+module Api
+  class User
+    def name
+      "Alice"
+    end
+  end
+end
+
+Api::User.new.name
+"#;
+        let genv = analyze(source);
+        // Api::User.new.name should resolve correctly — no type errors
+        assert!(
+            genv.type_errors.is_empty(),
+            "Api::User.new.name should not produce type errors: {:?}",
+            genv.type_errors
+        );
+    }
 }

data/rust/src/analyzer/install.rs

@@ -13,6 +13,9 @@ use super::conditionals::{process_case_node, process_if_node, process_unless_nod
 use super::definitions::{process_class_node, process_def_node, process_module_node};
 use super::dispatch::{dispatch_needs_child, dispatch_simple, process_needs_child, DispatchResult};
 use super::literals::install_literal_node;
+use super::parentheses::process_parentheses_node;
+use super::operators::{process_and_node, process_or_node};
+use super::returns::process_return_node;
 
 /// Build graph from AST (public API wrapper)
 pub struct AstInstaller<'a> {
@@ -76,6 +79,21 @@ pub(crate) fn install_node(
         return process_case_node(genv, lenv, changes, source, &case_node);
     }
 
+    if let Some(paren_node) = node.as_parentheses_node() {
+        return process_parentheses_node(genv, lenv, changes, source, &paren_node);
+    }
+
+    if let Some(return_node) = node.as_return_node() {
+        return process_return_node(genv, lenv, changes, source, &return_node);
+    }
+
+    if let Some(and_node) = node.as_and_node() {
+        return process_and_node(genv, lenv, changes, source, &and_node);
+    }
+    if let Some(or_node) = node.as_or_node() {
+        return process_or_node(genv, lenv, changes, source, &or_node);
+    }
+
     match dispatch_simple(genv, lenv, node) {
         DispatchResult::Vertex(vtx) => return Some(vtx),
         DispatchResult::NotHandled => {}

data/rust/src/analyzer/literals.rs

@@ -34,6 +34,30 @@ pub(crate) fn install_literal_node(
         return install_range_literal(genv, lenv, changes, source, &range_node);
     }
 
+    // InterpolatedStringNode: "Hello, #{expr}" → String
+    if let Some(interp) = node.as_interpolated_string_node() {
+        for part in &interp.parts() {
+            super::install::install_node(genv, lenv, changes, source, &part);
+        }
+        return Some(genv.new_source(Type::string()));
+    }
+
+    // InterpolatedSymbolNode: :"hello_#{expr}" → Symbol
+    if let Some(interp) = node.as_interpolated_symbol_node() {
+        for part in &interp.parts() {
+            super::install::install_node(genv, lenv, changes, source, &part);
+        }
+        return Some(genv.new_source(Type::symbol()));
+    }
+
+    // InterpolatedRegularExpressionNode: /hello #{expr}/ → Regexp
+    if let Some(interp) = node.as_interpolated_regular_expression_node() {
+        for part in &interp.parts() {
+            super::install::install_node(genv, lenv, changes, source, &part);
+        }
+        return Some(genv.new_source(Type::regexp()));
+    }
+
     install_simple_literal(genv, node)
 }
 
@@ -246,4 +270,25 @@ mod tests {
         let vtx = genv.new_source(Type::regexp());
         assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "Regexp");
     }
+
+    #[test]
+    fn test_install_interpolated_string_literal() {
+        let mut genv = GlobalEnv::new();
+        let vtx = genv.new_source(Type::string());
+        assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "String");
+    }
+
+    #[test]
+    fn test_install_interpolated_symbol_literal() {
+        let mut genv = GlobalEnv::new();
+        let vtx = genv.new_source(Type::symbol());
+        assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "Symbol");
+    }
+
+    #[test]
+    fn test_install_interpolated_regexp_literal() {
+        let mut genv = GlobalEnv::new();
+        let vtx = genv.new_source(Type::regexp());
+        assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "Regexp");
+    }
 }

data/rust/src/analyzer/mod.rs

@@ -6,7 +6,10 @@ mod definitions;
 mod dispatch;
 mod install;
 mod literals;
+mod operators;
 mod parameters;
+mod parentheses;
+mod returns;
 mod variables;
 
 pub use install::AstInstaller;