method-ray 0.1.8 → 0.1.9

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

@@ -128,6 +128,55 @@ fn install_block_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, name: Stri
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::analyzer::install::AstInstaller;
+    use crate::env::LocalEnv;
+    use crate::parser::ParseSession;
+    use crate::types::Type;
+
+    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);
+        }
+    }
+
+    fn analyze_with_stdlib(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();
+
+        // Register stdlib methods needed for block tests
+        genv.register_builtin_method_with_block(
+            Type::array(),
+            "each",
+            Type::array(),
+            Some(vec![Type::instance("Elem")]),
+        );
+        genv.register_builtin_method_with_block(
+            Type::string(),
+            "each_char",
+            Type::string(),
+            Some(vec![Type::string()]),
+        );
+        genv.register_builtin_method(Type::integer(), "even?", Type::instance("TrueClass"));
+        genv.register_builtin_method(Type::string(), "upcase", Type::string());
+
+        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
+    }
 
     #[test]
     fn test_enter_exit_block_scope() {
@@ -173,4 +222,95 @@ mod tests {
 
         exit_block_scope(&mut genv);
     }
+
+    #[test]
+    fn test_block_parameter_type_from_array() {
+        let source = r#"
+class Foo
+  def bar
+    [1, 2, 3].each { |x| x.even? }
+  end
+end
+"#;
+        let genv = analyze_with_stdlib(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "x.even? should not produce type errors: {:?}",
+            genv.type_errors
+        );
+        // Verify bar returns Array (each returns its receiver)
+        let info = genv.resolve_method(&Type::instance("Foo"), "bar").unwrap();
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "Array");
+    }
+
+    #[test]
+    fn test_block_external_variable_access() {
+        let source = r#"
+class Foo
+  def bar
+    y = "hello"
+    [1].each { y.upcase }
+  end
+end
+"#;
+        let genv = analyze_with_stdlib(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "y.upcase should not produce type errors: {:?}",
+            genv.type_errors
+        );
+    }
+
+    #[test]
+    fn test_block_parameter_from_each_char() {
+        let source = r#"
+class Foo
+  def bar
+    "hello".each_char { |c| c.upcase }
+  end
+end
+"#;
+        let genv = analyze_with_stdlib(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "c.upcase should not produce type errors: {:?}",
+            genv.type_errors
+        );
+    }
+
+    #[test]
+    fn test_block_body_does_not_affect_method_return() {
+        let source = r#"
+class Foo
+  def bar
+    [1, 2].each { |x| "string" }
+  end
+end
+"#;
+        let genv = analyze_with_stdlib(source);
+        // each returns its receiver (Array), not the block body result (String)
+        let info = genv.resolve_method(&Type::instance("Foo"), "bar").unwrap();
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "Array");
+    }
+
+    #[test]
+    fn test_nested_blocks() {
+        let source = r#"
+class Foo
+  def bar
+    [1, 2].each { |x|
+      "hello".each_char { |c| c.upcase }
+    }
+  end
+end
+"#;
+        let genv = analyze_with_stdlib(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "nested block should not produce type errors: {:?}",
+            genv.type_errors
+        );
+    }
 }

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

@@ -26,7 +26,8 @@ pub(crate) fn process_class_node(
     class_node: &ruby_prism::ClassNode,
 ) -> Option<VertexId> {
     let class_name = extract_class_name(class_node);
-    install_class(genv, class_name);
+    let superclass = class_node.superclass().and_then(|sup| extract_constant_path(&sup));
+    install_class(genv, class_name, superclass.as_deref());
 
     if let Some(body) = class_node.body() {
         if let Some(statements) = body.as_statements_node() {
@@ -126,8 +127,8 @@ pub(crate) fn process_def_node(
 }
 
 /// Install class definition
-fn install_class(genv: &mut GlobalEnv, class_name: String) {
-    genv.enter_class(class_name);
+fn install_class(genv: &mut GlobalEnv, class_name: String, superclass: Option<&str>) {
+    genv.enter_class(class_name, superclass);
 }
 
 /// Install module definition
@@ -203,7 +204,7 @@ mod tests {
     fn test_enter_exit_class_scope() {
         let mut genv = GlobalEnv::new();
 
-        install_class(&mut genv, "User".to_string());
+        install_class(&mut genv, "User".to_string(), None);
         assert_eq!(
             genv.scope_manager.current_class_name(),
             Some("User".to_string())
@@ -231,7 +232,7 @@ mod tests {
     fn test_nested_method_scope() {
         let mut genv = GlobalEnv::new();
 
-        install_class(&mut genv, "User".to_string());
+        install_class(&mut genv, "User".to_string(), None);
         install_method(&mut genv, "greet".to_string());
 
         // Still in User class context

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

@@ -18,6 +18,45 @@ use super::variables::{
     install_self,
 };
 
+/// Collect positional and keyword arguments from AST argument nodes.
+///
+/// Shared by method calls (`dispatch.rs`) and super calls (`super_calls.rs`).
+pub(crate) fn collect_arguments<'a>(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    args: impl Iterator<Item = ruby_prism::Node<'a>>,
+) -> (Vec<VertexId>, Option<HashMap<String, VertexId>>) {
+    let mut positional: Vec<VertexId> = Vec::new();
+    let mut keyword: HashMap<String, VertexId> = HashMap::new();
+
+    for arg in args {
+        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.insert(name, vtx);
+                }
+            }
+        } else if let Some(vtx) = super::install::install_node(genv, lenv, changes, source, &arg) {
+            positional.push(vtx);
+        }
+    }
+
+    let kw = (!keyword.is_empty()).then_some(keyword);
+    (positional, kw)
+}
+
 /// Kind of attr_* declaration
 #[derive(Debug, Clone, Copy)]
 pub enum AttrKind {
@@ -62,6 +101,10 @@ pub enum NeedsChildKind<'a> {
         kind: AttrKind,
         attr_names: Vec<String>,
     },
+    /// include declaration: `include Greetable, Enumerable`
+    IncludeDeclaration {
+        module_names: Vec<String>,
+    },
 }
 
 /// First pass: check if node can be handled immediately without child processing
@@ -189,6 +232,25 @@ pub fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<NeedsCh
                 return None;
             }
 
+            if method_name == "include" {
+                let module_names: Vec<String> = call_node
+                    .arguments()
+                    .map(|args| {
+                        args.arguments()
+                            .iter()
+                            .filter_map(|arg| {
+                                super::definitions::extract_constant_path(&arg)
+                            })
+                            .collect()
+                    })
+                    .unwrap_or_default();
+
+                if !module_names.is_empty() {
+                    return Some(NeedsChildKind::IncludeDeclaration { module_names });
+                }
+                return None;
+            }
+
             let prism_location = call_node
                 .message_loc()
                 .unwrap_or_else(|| node.location());
@@ -262,6 +324,16 @@ pub(crate) fn process_needs_child(
             super::attributes::process_attr_declaration(genv, kind, attr_names);
             None
         }
+        NeedsChildKind::IncludeDeclaration { module_names } => {
+            if let Some(class_name) = genv.scope_manager.current_qualified_name() {
+                // Ruby processes `include A, B` right-to-left (B first, then A on top),
+                // so A ends up with higher MRO priority. Reverse to match this behavior.
+                for module_name in module_names.iter().rev() {
+                    genv.record_include(&class_name, module_name);
+                }
+            }
+            None
+        }
     }
 }
 
@@ -310,31 +382,8 @@ fn process_method_call_common<'a>(
         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);
-        }
-    }
+    let (positional_arg_vtxs, kwarg_vtxs) =
+        collect_arguments(genv, lenv, changes, source, arguments.into_iter());
 
     if let Some(block_node) = block {
         if let Some(block) = block_node.as_block_node() {
@@ -355,12 +404,6 @@ 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,
@@ -1134,4 +1177,225 @@ User.new.profile(name: "Alice", age: 30)
         let ret_vtx = info.return_vertex.unwrap();
         assert_eq!(get_type_show(&genv, ret_vtx), "String");
     }
+
+    // === Include (mixin) tests ===
+
+    // Test 31: Basic include — module method resolved on class instance
+    #[test]
+    fn test_include_basic() {
+        let source = r#"
+module Greetable
+  def greet
+    "Hello!"
+  end
+end
+
+class User
+  include Greetable
+end
+
+User.new.greet
+"#;
+        let genv = analyze(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "include should resolve Greetable#greet: {:?}",
+            genv.type_errors
+        );
+    }
+
+    // Test 32: Include method return type inference
+    #[test]
+    fn test_include_method_return_type() {
+        let source = r#"
+module Greetable
+  def greet
+    "Hello!"
+  end
+end
+
+class User
+  include Greetable
+
+  def say_hello
+    greet
+  end
+end
+"#;
+        let genv = analyze(source);
+
+        let info = genv
+            .resolve_method(&Type::instance("User"), "say_hello")
+            .expect("User#say_hello should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    // Test 33: Multiple includes — last included module has priority
+    #[test]
+    fn test_include_multiple_modules() {
+        let source = r#"
+module A
+  def foo
+    "from A"
+  end
+end
+
+module B
+  def foo
+    42
+  end
+end
+
+class User
+  include A
+  include B
+end
+
+User.new.foo
+"#;
+        let genv = analyze(source);
+        assert!(genv.type_errors.is_empty());
+
+        // B is included last → B#foo (Integer) should be resolved
+        let info = genv
+            .resolve_method(&Type::instance("User"), "foo")
+            .expect("User#foo should be resolved via include");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "Integer");
+    }
+
+    // Test 34: Class's own method takes priority over included module
+    #[test]
+    fn test_include_class_method_priority() {
+        let source = r#"
+module Greetable
+  def greet
+    "Hello from module!"
+  end
+end
+
+class User
+  include Greetable
+
+  def greet
+    42
+  end
+end
+
+User.new.greet
+"#;
+        let genv = analyze(source);
+
+        let info = genv
+            .resolve_method(&Type::instance("User"), "greet")
+            .expect("User#greet should be resolved");
+        let ret_vtx = info.return_vertex.unwrap();
+        // Class's own method (Integer) takes priority
+        assert_eq!(get_type_show(&genv, ret_vtx), "Integer");
+    }
+
+    // Test 35: Include with qualified module name
+    #[test]
+    fn test_include_qualified_module() {
+        let source = r#"
+module Api
+  module Helpers
+    def help
+      "help"
+    end
+  end
+end
+
+class User
+  include Api::Helpers
+end
+
+User.new.help
+"#;
+        let genv = analyze(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "include Api::Helpers should resolve: {:?}",
+            genv.type_errors
+        );
+    }
+
+    // Test 36: Include with simultaneous multiple modules
+    #[test]
+    fn test_include_simultaneous_multiple() {
+        let source = r#"
+module A
+  def a_method
+    "a"
+  end
+end
+
+module B
+  def b_method
+    42
+  end
+end
+
+class User
+  include A, B
+end
+
+User.new.a_method
+User.new.b_method
+"#;
+        let genv = analyze(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "include A, B should resolve both modules: {:?}",
+            genv.type_errors
+        );
+    }
+
+    // Test 37: Include with unknown module (no crash)
+    #[test]
+    fn test_include_unknown_module() {
+        let source = r#"
+class User
+  include UnknownModule
+end
+"#;
+        let genv = analyze(source);
+        // Should not panic; unknown module is recorded but methods won't resolve
+        let _ = genv;
+    }
+
+    // Test 38: Simultaneous include A, B — A has higher MRO priority (Ruby semantics)
+    #[test]
+    fn test_include_simultaneous_order() {
+        let source = r#"
+module A
+  def foo
+    "from A"
+  end
+end
+
+module B
+  def foo
+    42
+  end
+end
+
+class User
+  include A, B
+end
+
+User.new.foo
+"#;
+        let genv = analyze(source);
+        assert!(genv.type_errors.is_empty());
+
+        // Ruby's `include A, B` processes right-to-left: B first, then A on top.
+        // A has higher MRO priority → A#foo (String) should be resolved.
+        let info = genv
+            .resolve_method(&Type::instance("User"), "foo")
+            .expect("User#foo should be resolved via include");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
 }

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

@@ -81,6 +81,24 @@ fn process_rescue_chain(
     }
 }
 
+/// Extract the exception type from rescue node's exception class list.
+/// Falls back to StandardError when no exceptions are specified or none can be resolved.
+// TODO: Non-constant exception expressions (method calls, splats, variables) are silently skipped.
+fn extract_exception_type(rescue_node: &RescueNode) -> Type {
+    let types: Vec<Type> = rescue_node
+        .exceptions()
+        .iter()
+        .filter_map(|exc| super::definitions::extract_constant_path(&exc))
+        .map(|name| Type::instance(&name))
+        .collect();
+
+    if types.is_empty() {
+        Type::instance("StandardError")
+    } else {
+        Type::union_of(types)
+    }
+}
+
 /// Process a single RescueNode body.
 /// Registers the rescue variable (=> e), processes the body,
 /// then removes the variable from scope.
@@ -97,14 +115,14 @@ fn process_rescue_body(
 
     // Save/restore rescue variable binding (=> e)
     // TODO: Only LocalVariableTargetNode is handled; instance/global/class vars are not yet supported.
-    // TODO: Always typed as StandardError regardless of declared exception class.
     let var_binding = if let Some(ref_node) = rescue_node.reference() {
         ref_node.as_local_variable_target_node().map(|target| {
             let name = bytes_to_name(target.name().as_slice());
             let saved = lenv.get_var(&name);
             let exception_vtx = genv.new_vertex();
-            let std_err_src = genv.new_source(Type::instance("StandardError"));
-            genv.add_edge(std_err_src, exception_vtx);
+            let exception_type = extract_exception_type(rescue_node);
+            let exception_src = genv.new_source(exception_type);
+            genv.add_edge(exception_src, exception_vtx);
             lenv.new_var(name.clone(), exception_vtx);
             (name, saved)
         })
@@ -497,6 +515,89 @@ end
         );
     }
 
+    #[test]
+    fn test_rescue_specific_exception_class() {
+        let source = r#"
+class Foo
+  def bar
+    begin
+      "hello"
+    rescue ArgumentError => e
+      e
+    end
+  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("ArgumentError"),
+            "should contain ArgumentError: {}",
+            type_str
+        );
+    }
+
+    #[test]
+    fn test_rescue_multiple_exception_classes() {
+        let source = r#"
+class Foo
+  def bar
+    begin
+      "hello"
+    rescue TypeError, NameError => e
+      e
+    end
+  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("TypeError"),
+            "should contain TypeError: {}",
+            type_str
+        );
+        assert!(
+            type_str.contains("NameError"),
+            "should contain NameError: {}",
+            type_str
+        );
+    }
+
+    #[test]
+    fn test_rescue_qualified_exception_class() {
+        let source = r#"
+class Foo
+  def bar
+    begin
+      "hello"
+    rescue Net::HTTPError => e
+      e
+    end
+  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("Net::HTTPError"),
+            "should contain Net::HTTPError: {}",
+            type_str
+        );
+    }
+
     #[test]
     fn test_empty_rescue_body_is_nil() {
         let source = r#"