method-ray 0.1.7 → 0.1.9

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/core/src/analyzer/loops.rs

@@ -0,0 +1,301 @@
+//! Loops - while/until loop type inference
+//!
+//! Ruby loop expressions evaluate to nil (except when break passes a value).
+//! Break value propagation is not yet supported.
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::types::Type;
+use ruby_prism::{ForNode, UntilNode, WhileNode};
+
+use super::bytes_to_name;
+use super::install::{install_node, install_statements};
+
+/// Process WhileNode: `while predicate; statements; end`
+///
+/// Returns nil. Traverses predicate and body to register method calls
+/// and variable assignments in the type graph.
+pub(crate) fn process_while_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    while_node: &WhileNode,
+) -> Option<VertexId> {
+    install_node(genv, lenv, changes, source, &while_node.predicate());
+
+    if let Some(stmts) = while_node.statements() {
+        install_statements(genv, lenv, changes, source, &stmts);
+    }
+
+    Some(genv.new_source(Type::Nil))
+}
+
+/// Process UntilNode: `until predicate; statements; end`
+///
+/// Returns nil. Traverses predicate and body to register method calls
+/// and variable assignments in the type graph.
+pub(crate) fn process_until_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    until_node: &UntilNode,
+) -> Option<VertexId> {
+    install_node(genv, lenv, changes, source, &until_node.predicate());
+
+    if let Some(stmts) = until_node.statements() {
+        install_statements(genv, lenv, changes, source, &stmts);
+    }
+
+    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;
+    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 (checks both Vertex and Source)
+    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_while_returns_nil() {
+        let source = r#"
+class Foo
+  def bar
+    while true
+      "hello"
+    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_until_returns_nil() {
+        let source = r#"
+class Foo
+  def bar
+    until false
+      "hello"
+    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_while_variable_assignment_in_body() {
+        // Should not panic — variable assignment inside loop is processed
+        let source = r#"
+x = "initial"
+while true
+  x = "hello"
+end
+"#;
+        analyze(source);
+    }
+
+    #[test]
+    fn test_while_modifier_form() {
+        let source = r#"
+class Foo
+  def bar
+    x = "hello" while false
+  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_begin_end_while() {
+        let source = r#"
+class Foo
+  def bar
+    begin
+      "hello"
+    end while false
+  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");
+    }
+
+    // --- 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

@@ -1,15 +1,19 @@
+mod assignments;
 mod attributes;
 mod blocks;
 mod calls;
 mod conditionals;
 mod definitions;
+mod exceptions;
 mod dispatch;
 mod install;
 mod literals;
+mod loops;
 mod operators;
 mod parameters;
 mod parentheses;
 mod returns;
+mod super_calls;
 mod variables;
 
 pub use install::AstInstaller;

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

@@ -1,42 +1,52 @@
-//! Operators - logical operator type inference (&&, ||)
+//! Operators - logical operator type inference (&&, ||, !)
 
 use crate::env::{GlobalEnv, LocalEnv};
 use crate::graph::{ChangeSet, VertexId};
-use ruby_prism::{AndNode, OrNode};
+use crate::types::Type;
+use ruby_prism::{AndNode, Node, 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(
+/// Merge two branch nodes into a union type vertex.
+fn process_binary_logical_op<'a>(
     genv: &mut GlobalEnv,
     lenv: &mut LocalEnv,
     changes: &mut ChangeSet,
     source: &str,
-    and_node: &AndNode,
+    left: Node<'a>,
+    right: Node<'a>,
 ) -> 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 {
+    if let Some(vtx) = install_node(genv, lenv, changes, source, &left) {
         genv.add_edge(vtx, result_vtx);
     }
 
-    let right_vtx = install_node(genv, lenv, changes, source, &and_node.right());
-    if let Some(vtx) = right_vtx {
+    if let Some(vtx) = install_node(genv, lenv, changes, source, &right) {
         genv.add_edge(vtx, result_vtx);
     }
 
     Some(result_vtx)
 }
 
+/// Process AndNode (a && b): Union(type(a), type(b))
+///
+/// Runtime: if `a` is falsy, returns `a`; otherwise returns `b`.
+/// Static: 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> {
+    process_binary_logical_op(genv, lenv, changes, source, and_node.left(), and_node.right())
+}
+
 /// 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.
+/// Runtime: if `a` is truthy, returns `a`; otherwise returns `b`.
+/// Static: conservatively produce Union(type(a), type(b)).
 pub(crate) fn process_or_node(
     genv: &mut GlobalEnv,
     lenv: &mut LocalEnv,
@@ -44,19 +54,28 @@ pub(crate) fn process_or_node(
     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);
-    }
+    process_binary_logical_op(genv, lenv, changes, source, or_node.left(), or_node.right())
+}
 
-    Some(result_vtx)
+/// Process not operator (!expr): TrueClass | FalseClass
+///
+/// In ruby-prism, `!expr` is represented as a CallNode with method name "!".
+/// Static approximation: we cannot determine the receiver's truthiness at
+/// compile time, so conservatively return TrueClass | FalseClass for any `!` call.
+/// In practice, `!nil` and `!false` are always true, but we do not track that here.
+///
+/// Receiver side effects are already analyzed by the caller (process_needs_child).
+///
+/// TODO: Ruby allows overriding `BasicObject#!`. Currently we always return
+/// TrueClass | FalseClass, ignoring user-defined `!` methods. If needed, look up
+/// the receiver's RBS definition and use its return type instead.
+pub(crate) fn process_not_operator(genv: &mut GlobalEnv) -> VertexId {
+    let result_vtx = genv.new_vertex();
+    let true_vtx = genv.new_source(Type::instance("TrueClass"));
+    let false_vtx = genv.new_source(Type::instance("FalseClass"));
+    genv.add_edge(true_vtx, result_vtx);
+    genv.add_edge(false_vtx, result_vtx);
+    result_vtx
 }
 
 #[cfg(test)]
@@ -189,4 +208,77 @@ end
         assert!(type_str.contains("Symbol"), "should contain Symbol: {}", type_str);
     }
 
+    // ============================================
+    // Not operator (!) tests
+    // ============================================
+
+    #[test]
+    fn test_not_operator_returns_boolean_union() {
+        let source = r#"
+class Foo
+  def bar
+    !true
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("bar should be registered");
+        let ty = get_type_show(&genv, info.return_vertex.unwrap());
+        assert!(ty.contains("TrueClass"), "expected TrueClass in {}", ty);
+        assert!(ty.contains("FalseClass"), "expected FalseClass in {}", ty);
+    }
+
+    #[test]
+    fn test_not_operator_receiver_side_effects_analyzed() {
+        let source = r#"
+class Foo
+  def bar
+    !(1.upcase)
+  end
+end
+"#;
+        let genv = analyze(source);
+        assert!(
+            !genv.type_errors.is_empty(),
+            "expected type error for Integer#upcase"
+        );
+    }
+
+    #[test]
+    fn test_double_not_operator_union() {
+        let source = r#"
+class Foo
+  def bar
+    !!true
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("bar should be registered");
+        let ty = get_type_show(&genv, info.return_vertex.unwrap());
+        assert!(ty.contains("TrueClass"), "expected TrueClass in {}", ty);
+        assert!(ty.contains("FalseClass"), "expected FalseClass in {}", ty);
+    }
+
+    #[test]
+    fn test_not_nil_returns_boolean() {
+        let source = r#"
+class Foo
+  def bar
+    !nil
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("bar should be registered");
+        let ty = get_type_show(&genv, info.return_vertex.unwrap());
+        assert!(ty.contains("TrueClass"), "expected TrueClass in {}", ty);
+        assert!(ty.contains("FalseClass"), "expected FalseClass in {}", ty);
+    }
 }