method-ray 0.1.8 → 0.1.9

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

@@ -15,10 +15,11 @@ use super::definitions::{process_class_node, process_def_node, process_module_no
 use super::exceptions::{process_begin_node, process_rescue_modifier_node};
 use super::dispatch::{dispatch_needs_child, dispatch_simple, process_needs_child, DispatchResult};
 use super::literals::install_literal_node;
-use super::loops::{process_until_node, process_while_node};
+use super::loops::{process_for_node, process_until_node, process_while_node};
 use super::operators::{process_and_node, process_or_node};
 use super::parentheses::process_parentheses_node;
 use super::returns::process_return_node;
+use super::super_calls;
 
 /// Build graph from AST (public API wrapper)
 pub struct AstInstaller<'a> {
@@ -89,12 +90,26 @@ pub(crate) fn install_node(
         return process_rescue_modifier_node(genv, lenv, changes, source, &rescue_modifier);
     }
 
+    // SuperNode: super(args) — explicit arguments
+    if let Some(super_node) = node.as_super_node() {
+        return super_calls::process_super_node(genv, lenv, changes, source, &super_node);
+    }
+    // ForwardingSuperNode: super — implicit argument forwarding
+    if let Some(fwd_super_node) = node.as_forwarding_super_node() {
+        return super_calls::process_forwarding_super_node(
+            genv, lenv, changes, source, &fwd_super_node,
+        );
+    }
+
     if let Some(while_node) = node.as_while_node() {
         return process_while_node(genv, lenv, changes, source, &while_node);
     }
     if let Some(until_node) = node.as_until_node() {
         return process_until_node(genv, lenv, changes, source, &until_node);
     }
+    if let Some(for_node) = node.as_for_node() {
+        return process_for_node(genv, lenv, changes, source, &for_node);
+    }
 
     if let Some(paren_node) = node.as_parentheses_node() {
         return process_parentheses_node(genv, lenv, changes, source, &paren_node);

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

@@ -118,13 +118,9 @@ fn install_array_literal_elements(
 
     let array_type = if element_types.is_empty() {
         Type::array()
-    } else if element_types.len() == 1 {
-        let elem_type = element_types.into_iter().next().unwrap();
-        Type::array_of(elem_type)
     } else {
         let types_vec: Vec<Type> = element_types.into_iter().collect();
-        let union_type = Type::Union(types_vec);
-        Type::array_of(union_type)
+        Type::array_of(Type::union_of(types_vec))
     };
 
     Some(genv.new_source(array_type))
@@ -176,18 +172,8 @@ fn install_hash_literal_elements(
     let hash_type = if key_types.is_empty() || value_types.is_empty() {
         Type::hash()
     } else {
-        let key_type = if key_types.len() == 1 {
-            key_types.into_iter().next().unwrap()
-        } else {
-            let types_vec: Vec<Type> = key_types.into_iter().collect();
-            Type::Union(types_vec)
-        };
-        let value_type = if value_types.len() == 1 {
-            value_types.into_iter().next().unwrap()
-        } else {
-            let types_vec: Vec<Type> = value_types.into_iter().collect();
-            Type::Union(types_vec)
-        };
+        let key_type = Type::union_of(key_types.into_iter().collect());
+        let value_type = Type::union_of(value_types.into_iter().collect());
         Type::hash_of(key_type, value_type)
     };
 

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

@@ -6,8 +6,9 @@
 use crate::env::{GlobalEnv, LocalEnv};
 use crate::graph::{ChangeSet, VertexId};
 use crate::types::Type;
-use ruby_prism::{UntilNode, WhileNode};
+use ruby_prism::{ForNode, UntilNode, WhileNode};
 
+use super::bytes_to_name;
 use super::install::{install_node, install_statements};
 
 /// Process WhileNode: `while predicate; statements; end`
@@ -50,6 +51,48 @@ pub(crate) fn process_until_node(
     Some(genv.new_source(Type::Nil))
 }
 
+/// Process ForNode: `for index in collection; statements; end`
+///
+/// Ruby's `for` does NOT create a new scope — the loop variable persists
+/// after the loop. This differs from `collection.each { |x| }` which
+/// creates a block scope.
+///
+/// Returns nil (consistent with while/until; Ruby's for returns the
+/// collection, but the return value is rarely used in practice).
+pub(crate) fn process_for_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    for_node: &ForNode,
+) -> Option<VertexId> {
+    let collection_vtx = install_node(genv, lenv, changes, source, &for_node.collection());
+
+    // TODO: MultiTargetNode (e.g., `for a, b in [[1, "x"]]`) is not yet supported
+    if let Some(target) = for_node.index().as_local_variable_target_node() {
+        let name = bytes_to_name(target.name().as_slice());
+        let var_vtx = genv.new_vertex();
+
+        // Array[T] or Range[T] → loop var gets T
+        let elem_type = collection_vtx
+            .and_then(|vtx| genv.get_source(vtx))
+            .and_then(|src| src.ty.type_args())
+            .and_then(|args| args.first().cloned());
+        if let Some(ty) = elem_type {
+            let elem_src = genv.new_source(ty);
+            genv.add_edge(elem_src, var_vtx);
+        }
+
+        lenv.new_var(name, var_vtx);
+    }
+
+    if let Some(stmts) = for_node.statements() {
+        install_statements(genv, lenv, changes, source, &stmts);
+    }
+
+    Some(genv.new_source(Type::Nil))
+}
+
 #[cfg(test)]
 mod tests {
     use crate::analyzer::install::AstInstaller;
@@ -173,4 +216,86 @@ end
         let ret_vtx = info.return_vertex.unwrap();
         assert_eq!(get_type_show(&genv, ret_vtx), "nil");
     }
+
+    // --- for loop tests ---
+
+    #[test]
+    fn test_for_returns_nil() {
+        let source = r#"
+class Foo
+  def bar
+    for x in [1, 2, 3]
+      x
+    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();
+        assert_eq!(get_type_show(&genv, ret_vtx), "nil");
+    }
+
+    #[test]
+    fn test_for_variable_type_from_array() {
+        let source = r#"
+for item in [1, 2, 3]
+  item
+end
+"#;
+        // Should not panic; loop variable is registered
+        analyze(source);
+    }
+
+    #[test]
+    fn test_for_variable_persists_after_loop() {
+        // for does NOT create a new scope — variable persists
+        let source = r#"
+class Foo
+  def bar
+    for x in [1, 2, 3]
+    end
+    x
+  end
+end
+"#;
+        // Should not panic — x is accessible after the loop
+        analyze(source);
+    }
+
+    #[test]
+    fn test_for_empty_body() {
+        let source = r#"
+class Foo
+  def bar
+    for x in [1, 2, 3]
+    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();
+        assert_eq!(get_type_show(&genv, ret_vtx), "nil");
+    }
+
+    #[test]
+    fn test_for_with_method_call_in_body() {
+        // Should not panic — method call on loop variable is processed
+        // (type error check requires RBS, covered by Ruby integration test)
+        let source = r#"
+class Foo
+  def bar
+    for item in ["hello", "world"]
+      item.upcase
+    end
+  end
+end
+"#;
+        analyze(source);
+    }
 }

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

@@ -13,6 +13,7 @@ mod operators;
 mod parameters;
 mod parentheses;
 mod returns;
+mod super_calls;
 mod variables;
 
 pub use install::AstInstaller;

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

@@ -208,6 +208,36 @@ pub(crate) fn install_parameters(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::analyzer::install::AstInstaller;
+    use crate::parser::ParseSession;
+
+    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_install_required_parameter() {
@@ -266,4 +296,134 @@ mod tests {
         let vertex = genv.get_vertex(vtx).unwrap();
         assert_eq!(vertex.show(), "Integer");
     }
+
+    #[test]
+    fn test_required_parameter_type_propagation() {
+        let source = r#"
+class Foo
+  def greet(name)
+    name
+  end
+end
+
+Foo.new.greet("Alice")
+"#;
+        let genv = analyze(source);
+        let info = genv.resolve_method(&Type::instance("Foo"), "greet").unwrap();
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_optional_parameter_default_type() {
+        let source = r#"
+class Foo
+  def greet(name = "World")
+    name
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv.resolve_method(&Type::instance("Foo"), "greet").unwrap();
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_multiple_parameters_from_call_site() {
+        let source = r#"
+class Calc
+  def add(x, y)
+    x
+  end
+end
+
+Calc.new.add(1, 2)
+"#;
+        let genv = analyze(source);
+        let info = genv.resolve_method(&Type::instance("Calc"), "add").unwrap();
+        let param_vtxs = info.param_vertices.as_ref().unwrap();
+        assert_eq!(param_vtxs.len(), 2);
+        // Verify return type is Integer (method returns x, which receives 1)
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "Integer");
+    }
+
+    #[test]
+    fn test_keyword_parameter_propagation() {
+        let source = r#"
+class Foo
+  def greet(name:)
+    name
+  end
+end
+
+Foo.new.greet(name: "Alice")
+"#;
+        let genv = analyze(source);
+        let info = genv.resolve_method(&Type::instance("Foo"), "greet").unwrap();
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_optional_keyword_parameter_default() {
+        let source = r#"
+class Counter
+  def count(step: 1)
+    step
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv.resolve_method(&Type::instance("Counter"), "count").unwrap();
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "Integer");
+    }
+
+    #[test]
+    fn test_mixed_positional_and_keyword_params() {
+        let source = r#"
+class User
+  def initialize(id, name:)
+    @id = id
+    @name = name
+  end
+end
+
+User.new(1, name: "Alice")
+"#;
+        let genv = analyze(source);
+        assert!(genv.type_errors.is_empty());
+    }
+
+    #[test]
+    fn test_rest_parameter() {
+        let source = r#"
+class Foo
+  def bar(*args)
+    args
+  end
+end
+"#;
+        let genv = analyze(source);
+        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_no_parameters() {
+        let source = r#"
+class Foo
+  def bar
+    "hello"
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv.resolve_method(&Type::instance("Foo"), "bar").unwrap();
+        let param_vtxs = info.param_vertices.as_ref().unwrap();
+        assert!(param_vtxs.is_empty());
+    }
 }

data/core/src/analyzer/super_calls.rs

@@ -0,0 +1,285 @@
+//! Super call handling: `super` and `super(args)`
+//!
+//! Ruby's `super` calls the same-named method on the parent class.
+//! - `super(args)` → SuperNode: explicit arguments
+//! - `super` (bare) → ForwardingSuperNode: implicit argument forwarding
+//!
+//! Note: ForwardingSuperNode (bare `super`) is treated as a zero-argument
+//! call. In Ruby, bare `super` forwards all arguments from the enclosing
+//! method, but replicating this requires parameter-vertex forwarding that
+//! is not yet implemented. Return type inference is unaffected.
+
+use ruby_prism::{ForwardingSuperNode, SuperNode};
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::source_map::SourceLocation as SL;
+use crate::types::Type;
+
+/// Process SuperNode: `super(args)` — explicit arguments
+pub(crate) fn process_super_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    super_node: &SuperNode,
+) -> Option<VertexId> {
+    let location = SL::from_prism_location_with_source(&super_node.location(), source);
+    process_super_call(genv, lenv, changes, source, super_node.arguments(), location)
+}
+
+/// Process ForwardingSuperNode: `super` — implicit argument forwarding
+pub(crate) fn process_forwarding_super_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    node: &ForwardingSuperNode,
+) -> Option<VertexId> {
+    let location = SL::from_prism_location_with_source(&node.location(), source);
+    process_super_call(genv, lenv, changes, source, None, location)
+}
+
+/// Resolve a super call by looking up the same-named method on the superclass.
+///
+/// Returns `None` if there is no enclosing method scope (super outside a method)
+/// or no explicit superclass declared on the enclosing class.
+fn process_super_call(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    arguments: Option<ruby_prism::ArgumentsNode>,
+    location: SL,
+) -> Option<VertexId> {
+    let method_name = genv.scope_manager.current_method_name()?;
+    let superclass_name = genv.scope_manager.current_superclass()?;
+    let recv_vtx = genv.new_source(Type::instance(&superclass_name));
+
+    let (arg_vtxs, kw) = if let Some(args) = arguments {
+        super::dispatch::collect_arguments(genv, lenv, changes, source, args.arguments().iter())
+    } else {
+        (vec![], None)
+    };
+
+    Some(super::calls::install_method_call(
+        genv,
+        recv_vtx,
+        method_name,
+        arg_vtxs,
+        kw,
+        Some(location),
+    ))
+}
+
+#[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_super_basic() {
+        let source = r#"
+class Animal
+  def speak
+    "..."
+  end
+end
+
+class Dog < Animal
+  def speak
+    super
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Dog"), "speak")
+            .expect("Dog#speak should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_super_with_method_chain() {
+        let source = r#"
+class Animal
+  def speak
+    "hello"
+  end
+end
+
+class Dog < Animal
+  def speak
+    super.upcase
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Dog"), "speak")
+            .expect("Dog#speak should be registered");
+        assert!(info.return_vertex.is_some());
+    }
+
+    #[test]
+    fn test_super_with_arguments() {
+        let source = r#"
+class Base
+  def greet(name)
+    name
+  end
+end
+
+class Child < Base
+  def greet(name)
+    super(name)
+  end
+end
+
+Child.new.greet("Alice")
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Child"), "greet")
+            .expect("Child#greet should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_super_outside_method_ignored() {
+        let source = r#"
+class Foo < Object
+  super
+end
+"#;
+        analyze(source);
+    }
+
+    #[test]
+    fn test_super_explicit_empty_args() {
+        let source = r#"
+class Animal
+  def speak
+    "hello"
+  end
+end
+
+class Dog < Animal
+  def speak
+    super()
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Dog"), "speak")
+            .expect("Dog#speak should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_super_without_superclass_ignored() {
+        let source = r#"
+class Foo
+  def bar
+    super
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        assert!(info.return_vertex.is_some());
+    }
+
+    #[test]
+    fn test_super_qualified_superclass() {
+        let source = r#"
+module Animals
+  class Pet
+    def name
+      "pet"
+    end
+  end
+end
+
+class Dog < Animals::Pet
+  def name
+    super
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Dog"), "name")
+            .expect("Dog#name should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    #[test]
+    fn test_super_multi_level_inheritance() {
+        let source = r#"
+class A
+  def foo
+    "hello"
+  end
+end
+
+class B < A
+  def foo
+    super
+  end
+end
+
+class C < B
+  def foo
+    super
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("C"), "foo")
+            .expect("C#foo should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+}