method-ray 0.1.4 → 0.1.6

data/rust/src/analyzer/operators.rs

@@ -0,0 +1,192 @@
+//! Operators - logical operator type inference (&&, ||)
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use ruby_prism::{AndNode, OrNode};
+
+use super::install::install_node;
+
+/// Process AndNode (a && b): Union(type(a), type(b))
+///
+/// Short-circuit semantics: if `a` is falsy, returns `a`; otherwise returns `b`.
+/// Static approximation: we cannot determine truthiness at compile time,
+/// so we conservatively produce Union(type(a), type(b)).
+pub(crate) fn process_and_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    and_node: &AndNode,
+) -> Option<VertexId> {
+    let result_vtx = genv.new_vertex();
+
+    let left_vtx = install_node(genv, lenv, changes, source, &and_node.left());
+    if let Some(vtx) = left_vtx {
+        genv.add_edge(vtx, result_vtx);
+    }
+
+    let right_vtx = install_node(genv, lenv, changes, source, &and_node.right());
+    if let Some(vtx) = right_vtx {
+        genv.add_edge(vtx, result_vtx);
+    }
+
+    Some(result_vtx)
+}
+
+/// Process OrNode (a || b): Union(type(a), type(b))
+///
+/// Short-circuit semantics: if `a` is truthy, returns `a`; otherwise returns `b`.
+/// Static approximation: identical to AndNode — Union of both sides.
+pub(crate) fn process_or_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    or_node: &OrNode,
+) -> Option<VertexId> {
+    let result_vtx = genv.new_vertex();
+
+    let left_vtx = install_node(genv, lenv, changes, source, &or_node.left());
+    if let Some(vtx) = left_vtx {
+        genv.add_edge(vtx, result_vtx);
+    }
+
+    let right_vtx = install_node(genv, lenv, changes, source, &or_node.right());
+    if let Some(vtx) = right_vtx {
+        genv.add_edge(vtx, result_vtx);
+    }
+
+    Some(result_vtx)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::analyzer::install::AstInstaller;
+    use crate::env::{GlobalEnv, LocalEnv};
+    use crate::graph::VertexId;
+    use crate::parser::ParseSession;
+    use crate::types::Type;
+
+    /// Helper: parse Ruby source, process with AstInstaller, and return GlobalEnv
+    fn analyze(source: &str) -> GlobalEnv {
+        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
+    }
+
+    /// Helper: get the type string for a vertex ID
+    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_and_node_union_type() {
+        let source = r#"
+class Foo
+  def bar
+    true && "hello"
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        let type_str = get_type_show(&genv, ret_vtx);
+        assert!(type_str.contains("TrueClass"), "should contain TrueClass: {}", type_str);
+        assert!(type_str.contains("String"), "should contain String: {}", type_str);
+    }
+
+    #[test]
+    fn test_and_node_same_type() {
+        let source = r#"
+class Foo
+  def bar
+    "a" && "b"
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_or_node_union_type() {
+        let source = r#"
+class Foo
+  def bar
+    42 || "hello"
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        let type_str = get_type_show(&genv, ret_vtx);
+        assert!(type_str.contains("Integer"), "should contain Integer: {}", type_str);
+        assert!(type_str.contains("String"), "should contain String: {}", type_str);
+    }
+
+    #[test]
+    fn test_or_node_same_type() {
+        let source = r#"
+class Foo
+  def bar
+    1 || 2
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "Integer");
+    }
+
+    #[test]
+    fn test_nested_logical_operators() {
+        let source = r#"
+class Foo
+  def bar
+    1 && "a" || :b
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        let type_str = get_type_show(&genv, ret_vtx);
+        assert!(type_str.contains("Integer"), "should contain Integer: {}", type_str);
+        assert!(type_str.contains("String"), "should contain String: {}", type_str);
+        assert!(type_str.contains("Symbol"), "should contain Symbol: {}", type_str);
+    }
+
+}

data/rust/src/analyzer/parentheses.rs

@@ -0,0 +1,113 @@
+//! Parentheses - pass-through type propagation for parenthesized expressions
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+
+use super::install::{install_node, install_statements};
+
+/// Process ParenthesesNode: propagate inner expression's type
+pub(crate) fn process_parentheses_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    paren_node: &ruby_prism::ParenthesesNode,
+) -> Option<VertexId> {
+    let body = paren_node.body()?;
+
+    if let Some(stmts) = body.as_statements_node() {
+        // (expr1; expr2) → process all, return last expression's type
+        install_statements(genv, lenv, changes, source, &stmts)
+    } else {
+        // (expr) → propagate inner expression's type directly
+        install_node(genv, lenv, changes, source, &body)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::analyzer::install::AstInstaller;
+    use crate::env::{GlobalEnv, LocalEnv};
+    use crate::graph::VertexId;
+    use crate::parser::ParseSession;
+    use crate::types::Type;
+
+    fn analyze(source: &str) -> GlobalEnv {
+        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
+    }
+
+    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_parenthesized_integer() {
+        let source = r#"
+class Foo
+  def bar
+    x = (42)
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "Integer");
+    }
+
+    #[test]
+    fn test_parenthesized_string() {
+        let source = r#"
+class Foo
+  def bar
+    x = ("hello")
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_parenthesized_multiple_statements() {
+        let source = r#"
+class Foo
+  def bar
+    x = (a = 1; "hello")
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+}

data/rust/src/analyzer/returns.rs

@@ -0,0 +1,191 @@
+//! Return statement handling
+//!
+//! Processes `return expr` by connecting the expression's vertex
+//! to the enclosing method's merge vertex.
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+
+use super::install::install_node;
+
+/// Process ReturnNode: connect return value to method's merge vertex
+pub(crate) fn process_return_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    return_node: &ruby_prism::ReturnNode,
+) -> Option<VertexId> {
+    // Process return value (first argument only; multi-value return not yet supported)
+    let value_vtx = if let Some(arguments) = return_node.arguments() {
+        arguments
+            .arguments()
+            .iter()
+            .next()
+            .and_then(|arg| install_node(genv, lenv, changes, source, &arg))
+    } else {
+        // `return` without value → nil
+        Some(genv.new_source(crate::types::Type::Nil))
+    };
+
+    // Connect return value to method's merge vertex
+    if let Some(vtx) = value_vtx {
+        if let Some(merge_vtx) = genv.scope_manager.current_method_return_vertex() {
+            genv.add_edge(vtx, merge_vtx);
+        }
+    }
+
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::env::{GlobalEnv, LocalEnv};
+    use crate::graph::ChangeSet;
+    use crate::parser::ParseSession;
+    use crate::types::Type;
+
+    fn setup_and_infer(source: &str) -> GlobalEnv {
+        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,
+            );
+        }
+
+        genv.apply_changes(changes);
+        genv.run_all();
+        genv
+    }
+
+    fn get_return_type(genv: &GlobalEnv, class_name: &str, method_name: &str) -> String {
+        let info = genv
+            .resolve_method(&Type::instance(class_name), method_name)
+            .unwrap_or_else(|| panic!("{}#{} should be registered", class_name, method_name));
+        let vtx = info
+            .return_vertex
+            .expect("return_vertex should be Some");
+
+        if let Some(source) = genv.get_source(vtx) {
+            source.ty.show()
+        } else if let Some(vertex) = genv.get_vertex(vtx) {
+            vertex.show()
+        } else {
+            panic!("return_vertex not found");
+        }
+    }
+
+    #[test]
+    fn test_simple_return() {
+        let source = r#"
+class Foo
+  def bar
+    return "hello"
+  end
+end
+"#;
+        let genv = setup_and_infer(source);
+        assert_eq!(get_return_type(&genv, "Foo", "bar"), "String");
+    }
+
+    #[test]
+    fn test_return_with_implicit_return_union() {
+        let source = r#"
+class Foo
+  def bar
+    return "hello" if true
+    42
+  end
+end
+"#;
+        let genv = setup_and_infer(source);
+        let ty = get_return_type(&genv, "Foo", "bar");
+        assert!(ty.contains("Integer"), "should contain Integer, got: {}", ty);
+        assert!(ty.contains("String"), "should contain String, got: {}", ty);
+    }
+
+    #[test]
+    fn test_multiple_returns() {
+        let source = r#"
+class Foo
+  def bar
+    return "a" if true
+    return :b if false
+    42
+  end
+end
+"#;
+        let genv = setup_and_infer(source);
+        let ty = get_return_type(&genv, "Foo", "bar");
+        assert!(ty.contains("Integer"), "should contain Integer, got: {}", ty);
+        assert!(ty.contains("String"), "should contain String, got: {}", ty);
+        assert!(ty.contains("Symbol"), "should contain Symbol, got: {}", ty);
+    }
+
+    #[test]
+    fn test_return_without_value() {
+        let source = r#"
+class Foo
+  def bar
+    return if true
+    42
+  end
+end
+"#;
+        let genv = setup_and_infer(source);
+        let ty = get_return_type(&genv, "Foo", "bar");
+        assert!(ty.contains("Integer"), "should contain Integer, got: {}", ty);
+        assert!(ty.contains("nil"), "should contain nil, got: {}", ty);
+    }
+
+    #[test]
+    fn test_no_return_backward_compat() {
+        let source = r#"
+class Foo
+  def bar
+    "hello"
+  end
+end
+"#;
+        let genv = setup_and_infer(source);
+        assert_eq!(get_return_type(&genv, "Foo", "bar"), "String");
+    }
+
+    #[test]
+    fn test_return_only_method() {
+        let source = r#"
+class Foo
+  def bar
+    return "hello"
+  end
+end
+"#;
+        let genv = setup_and_infer(source);
+        assert_eq!(get_return_type(&genv, "Foo", "bar"), "String");
+    }
+
+    #[test]
+    fn test_return_dead_code_over_approximation() {
+        let source = r#"
+class Foo
+  def bar
+    return "hello"
+    42
+  end
+end
+"#;
+        let genv = setup_and_infer(source);
+        let ty = get_return_type(&genv, "Foo", "bar");
+        // Dead code after return is still processed (over-approximation)
+        assert!(ty.contains("Integer"), "should contain Integer (dead code), got: {}", ty);
+        assert!(ty.contains("String"), "should contain String, got: {}", ty);
+    }
+}

data/rust/src/checker.rs

@@ -17,8 +17,7 @@ impl FileChecker {
         // Just verify cache exists
         use crate::cache::RbsCache;
         RbsCache::load().context(
-            "Failed to load RBS cache. Please run from Ruby first to generate cache:\n\
-             ruby -rmethodray -e 'MethodRay::Analyzer.new(\".\").infer_types(\"x=1\")'",
+            "Failed to load RBS cache.",
         )?;
 
         Ok(Self {})
@@ -70,8 +69,7 @@ fn load_rbs_from_cache(genv: &mut GlobalEnv) -> Result<()> {
     use crate::types::Type;
 
     let cache = RbsCache::load().context(
-        "Failed to load RBS cache. Please run from Ruby first to generate cache:\n\
-         ruby -rmethodray -e 'MethodRay::Analyzer.new(\".\").infer_types(\"x=1\")'",
+        "Failed to load RBS cache.",
     )?;
 
     let methods = cache.methods();

data/rust/src/cli/args.rs

@@ -35,6 +35,6 @@ pub enum Commands {
     /// Show version information
     Version,
 
-    /// Clear RBS cache
+    /// [DEPRECATED] Clear RBS cache
     ClearCache,
 }

data/rust/src/env/global_env.rs

@@ -209,13 +209,12 @@ impl GlobalEnv {
     /// Enter a method scope
     pub fn enter_method(&mut self, name: String) -> ScopeId {
         // Look for class or module context
-        let receiver_type = self
-            .scope_manager
-            .current_class_name()
-            .or_else(|| self.scope_manager.current_module_name());
+        let receiver_type = self.scope_manager.current_qualified_name();
+        let return_vertex = Some(self.new_vertex());
         let scope_id = self.scope_manager.new_scope(ScopeKind::Method {
             name,
             receiver_type,
+            return_vertex,
         });
         self.scope_manager.enter_scope(scope_id);
         scope_id

data/rust/src/env/scope.rs

@@ -20,6 +20,7 @@ pub enum ScopeKind {
     Method {
         name: String,
         receiver_type: Option<String>, // Receiver class/module name
+        return_vertex: Option<VertexId>, // Merge vertex for return statements
     },
     Block,
 }
@@ -309,6 +310,22 @@ impl ScopeManager {
         Some(result)
     }
 
+    /// Get return_vertex from the nearest enclosing method scope
+    pub fn current_method_return_vertex(&self) -> Option<VertexId> {
+        let mut current = Some(self.current_scope);
+        while let Some(scope_id) = current {
+            if let Some(scope) = self.scopes.get(&scope_id) {
+                if let ScopeKind::Method { return_vertex, .. } = &scope.kind {
+                    return *return_vertex;
+                }
+                current = scope.parent;
+            } else {
+                break;
+            }
+        }
+        None
+    }
+
     /// Lookup instance variable in enclosing module scope
     pub fn lookup_instance_var_in_module(&self, name: &str) -> Option<VertexId> {
         let mut current = Some(self.current_scope);
@@ -448,6 +465,7 @@ mod tests {
         let method_id = sm.new_scope(ScopeKind::Method {
             name: "test".to_string(),
             receiver_type: None,
+            return_vertex: None,
         });
         sm.enter_scope(method_id);
 
@@ -472,6 +490,7 @@ mod tests {
         let method_id = sm.new_scope(ScopeKind::Method {
             name: "helper".to_string(),
             receiver_type: Some("Utils".to_string()),
+            return_vertex: None,
         });
         sm.enter_scope(method_id);
 
@@ -500,6 +519,7 @@ mod tests {
         let method_id = sm.new_scope(ScopeKind::Method {
             name: "get_setting".to_string(),
             receiver_type: Some("Config".to_string()),
+            return_vertex: None,
         });
         sm.enter_scope(method_id);
 
@@ -559,6 +579,7 @@ mod tests {
         let method_id = sm.new_scope(ScopeKind::Method {
             name: "greet".to_string(),
             receiver_type: None,
+            return_vertex: None,
         });
         sm.enter_scope(method_id);
 

data/rust/src/graph/box.rs

@@ -132,8 +132,10 @@ impl BoxTrait for MethodCallBox {
                     self.location.clone(),
                 );
             } else if matches!(&recv_ty, Type::Singleton { .. }) {
-                // Skip error for unknown class methods on Singleton types
-                // (class method RBS registration is not yet supported)
+                // Skip error for unknown class methods on Singleton types.
+                // User-defined class methods (def self.foo) are resolved by
+                // resolve_method above. Only unresolved methods reach here
+                // (e.g., RBS class methods not yet supported).
                 continue;
             } else {
                 // Record type error for diagnostic reporting

data/rust/src/main.rs

@@ -38,6 +38,7 @@ fn main() -> Result<()> {
             commands::print_version();
         }
         Commands::ClearCache => {
+            eprintln!("WARNING: 'clear-cache' is deprecated and will be removed in a future version.");
             commands::clear_cache()?;
         }
     }

data/rust/src/rbs/loader.rs

@@ -37,12 +37,11 @@ impl<'a> RbsLoader<'a> {
 
     /// Load all method definitions from RBS
     pub fn load_methods(&self) -> Result<Vec<RbsMethodInfo>, RbsError> {
-        // Load method_loader.rb
-        let rb_path = concat!(env!("CARGO_MANIFEST_DIR"), "/src/rbs/method_loader.rb");
-        let load_code = format!("require '{}'", rb_path);
+        // Load method_loader.rb (embedded at compile time to avoid hardcoded paths)
+        let ruby_code = include_str!("method_loader.rb");
         let _: Value = self
             .ruby
-            .eval(&load_code)
+            .eval(ruby_code)
             .map_err(|e| RbsError::LoadError(format!("Failed to load method_loader.rb: {}", e)))?;
 
         // Instantiate Rbs::MethodLoader class and call method

data/rust/src/rbs/mod.rs

@@ -14,3 +14,32 @@ pub mod loader;
 pub use error::RbsError;
 #[cfg(feature = "ruby-ffi")]
 pub use loader::{register_rbs_methods, RbsLoader, RbsMethodInfo};
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_embedded_method_loader_contains_expected_class() {
+        let ruby_code = include_str!("method_loader.rb");
+        assert!(
+            ruby_code.contains("class MethodLoader"),
+            "Embedded Ruby code should contain MethodLoader class definition"
+        );
+        assert!(
+            ruby_code.contains("def load_methods"),
+            "Embedded Ruby code should contain load_methods method"
+        );
+    }
+
+    #[test]
+    fn test_embedded_method_loader_has_no_absolute_paths() {
+        let ruby_code = include_str!("method_loader.rb");
+        let forbidden_patterns = ["/home/runner/", "/Users/", "/tmp/build/"];
+        for pattern in &forbidden_patterns {
+            assert!(
+                !ruby_code.contains(pattern),
+                "Embedded Ruby code should not contain absolute path: {}",
+                pattern
+            );
+        }
+    }
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: method-ray
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - dak2
@@ -57,7 +57,10 @@ files:
 - 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