method-ray 0.1.7 → 0.1.9

data/core/src/analyzer/exceptions.rs

@@ -0,0 +1,622 @@
+//! Exceptions - begin/rescue/ensure type inference
+//!
+//! Collects types from each branch and merges them into a Union
+//! via edges into a single result Vertex.
+//! Applies the same MergeVertex pattern as conditionals.rs.
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::types::Type;
+use ruby_prism::{BeginNode, RescueModifierNode, RescueNode};
+
+use super::bytes_to_name;
+use super::install::{install_node, install_statements};
+
+/// Process BeginNode: begin/rescue/else/ensure
+///
+/// Type aggregation rules:
+///   - No rescue clause: return begin body type directly
+///   - With else clause: else type + all rescue types → Union (begin body excluded)
+///   - Without else clause: begin body type + all rescue types → Union
+///   - Ensure clause: processed for side effects only, does not affect return type
+pub(crate) fn process_begin_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    begin_node: &BeginNode,
+) -> Option<VertexId> {
+    let begin_vtx = begin_node
+        .statements()
+        .and_then(|s| install_statements(genv, lenv, changes, source, &s));
+
+    let result = if let Some(rescue_node) = begin_node.rescue_clause() {
+        let result_vtx = genv.new_vertex();
+
+        process_rescue_chain(genv, lenv, changes, source, &rescue_node, result_vtx);
+
+        if let Some(else_node) = begin_node.else_clause() {
+            // With else: else type replaces begin body type (Ruby spec)
+            let else_vtx = else_node
+                .statements()
+                .and_then(|s| install_statements(genv, lenv, changes, source, &s));
+            if let Some(vtx) = else_vtx {
+                genv.add_edge(vtx, result_vtx);
+            }
+        } else if let Some(vtx) = begin_vtx {
+            genv.add_edge(vtx, result_vtx);
+        }
+
+        Some(result_vtx)
+    } else {
+        begin_vtx
+    };
+
+    // Ensure: side effects only, does not affect return type
+    if let Some(ensure_node) = begin_node.ensure_clause() {
+        if let Some(stmts) = ensure_node.statements() {
+            let _ = install_statements(genv, lenv, changes, source, &stmts);
+        }
+    }
+
+    result
+}
+
+/// Process RescueNode chain recursively.
+/// Empty rescue body evaluates to nil.
+fn process_rescue_chain(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    rescue_node: &RescueNode,
+    result_vtx: VertexId,
+) {
+    let body_vtx = process_rescue_body(genv, lenv, changes, source, rescue_node);
+    let vtx = body_vtx.unwrap_or_else(|| genv.new_source(Type::Nil));
+    genv.add_edge(vtx, result_vtx);
+
+    if let Some(next) = rescue_node.subsequent() {
+        process_rescue_chain(genv, lenv, changes, source, &next, result_vtx);
+    }
+}
+
+/// 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.
+fn process_rescue_body(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    rescue_node: &RescueNode,
+) -> Option<VertexId> {
+    for exc in &rescue_node.exceptions() {
+        install_node(genv, lenv, changes, source, &exc);
+    }
+
+    // Save/restore rescue variable binding (=> e)
+    // TODO: Only LocalVariableTargetNode is handled; instance/global/class vars are not yet supported.
+    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 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)
+        })
+    } else {
+        None
+    };
+
+    let body_vtx = rescue_node
+        .statements()
+        .and_then(|s| install_statements(genv, lenv, changes, source, &s));
+
+    if let Some((name, saved)) = var_binding {
+        match saved {
+            Some(prev_vtx) => lenv.new_var(name, prev_vtx),
+            None => lenv.remove_var(&name),
+        }
+    }
+
+    body_vtx
+}
+
+/// Process RescueModifierNode: `expression rescue rescue_expression`
+pub(crate) fn process_rescue_modifier_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    node: &RescueModifierNode,
+) -> Option<VertexId> {
+    let result_vtx = genv.new_vertex();
+
+    let expr_vtx = install_node(genv, lenv, changes, source, &node.expression());
+    if let Some(vtx) = expr_vtx {
+        genv.add_edge(vtx, result_vtx);
+    }
+
+    let rescue_vtx = install_node(genv, lenv, changes, source, &node.rescue_expression());
+    if let Some(vtx) = rescue_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 (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_begin_rescue_basic() {
+        let source = r#"
+class Foo
+  def bar
+    begin
+      "hello"
+    rescue
+      42
+    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), "(Integer | String)");
+    }
+
+    #[test]
+    fn test_begin_rescue_else() {
+        let source = r#"
+class Foo
+  def bar
+    begin
+      "hello"
+    rescue
+      42
+    else
+      :ok
+    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);
+        // else present: begin body excluded, else + rescue types
+        assert!(type_str.contains("Symbol"), "should contain Symbol: {}", type_str);
+        assert!(type_str.contains("Integer"), "should contain Integer: {}", type_str);
+        assert!(!type_str.contains("String"), "should NOT contain String: {}", type_str);
+    }
+
+    #[test]
+    fn test_begin_ensure_only() {
+        let source = r#"
+class Foo
+  def bar
+    begin
+      "hello"
+    ensure
+      puts "cleanup"
+    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), "String");
+    }
+
+    #[test]
+    fn test_begin_rescue_ensure() {
+        let source = r#"
+class Foo
+  def bar
+    begin
+      "hello"
+    rescue
+      42
+    ensure
+      :cleanup
+    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);
+        // ensure does not affect return type
+        assert_eq!(type_str, "(Integer | String)");
+    }
+
+    #[test]
+    fn test_rescue_variable_type() {
+        let source = r#"
+class Foo
+  def bar
+    begin
+      "hello"
+    rescue => 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("StandardError"),
+            "should contain StandardError: {}",
+            type_str
+        );
+    }
+
+    #[test]
+    fn test_multiple_rescue_clauses() {
+        let source = r#"
+class Foo
+  def bar
+    begin
+      "hello"
+    rescue ArgumentError
+      42
+    rescue RuntimeError
+      :error
+    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("String"), "should contain String: {}", type_str);
+        assert!(type_str.contains("Integer"), "should contain Integer: {}", type_str);
+        assert!(type_str.contains("Symbol"), "should contain Symbol: {}", type_str);
+    }
+
+    #[test]
+    fn test_rescue_modifier_basic() {
+        let source = r#"
+class Foo
+  def bar
+    "hello" rescue 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 | String)");
+    }
+
+    #[test]
+    fn test_rescue_modifier_same_type() {
+        let source = r#"
+class Foo
+  def bar
+    "hello" rescue "world"
+  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_nested_begin_rescue() {
+        let source = r#"
+class Foo
+  def bar
+    begin
+      begin
+        "inner"
+      rescue
+        42
+      end
+    rescue
+      :outer
+    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);
+        // Outer: Union(inner_begin_rescue | :outer) = (Integer | String | Symbol)
+        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);
+    }
+
+    #[test]
+    fn test_begin_rescue_in_method() {
+        let source = r#"
+class Foo
+  def bar
+    x = begin
+      "hello"
+    rescue
+      42
+    end
+    x
+  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 | String)");
+    }
+
+    #[test]
+    fn test_ensure_side_effects() {
+        // ensure body should be processed (no panic) but not affect return type
+        let source = r#"
+class Foo
+  def bar
+    begin
+      "hello"
+    rescue
+      42
+    ensure
+      x = "side_effect"
+    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), "(Integer | String)");
+    }
+
+    #[test]
+    fn test_rescue_variable_scope_restore() {
+        // Rescue variable should not destroy outer binding
+        let source = r#"
+class Foo
+  def bar
+    e = "outer"
+    begin
+      "hello"
+    rescue => e
+      e
+    end
+    e
+  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);
+        // After rescue block, e should be restored to outer binding (String)
+        assert!(type_str.contains("String"), "should contain String: {}", type_str);
+    }
+
+    #[test]
+    fn test_rescue_variable_scope_removal() {
+        // When rescue variable has no prior binding, it should be removed after rescue block
+        let source = r#"
+class Foo
+  def bar
+    begin
+      "hello"
+    rescue => 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);
+        // begin body (String) + rescue body where e = StandardError
+        assert!(type_str.contains("String"), "should contain String: {}", type_str);
+        assert!(
+            type_str.contains("StandardError"),
+            "should contain StandardError: {}",
+            type_str
+        );
+    }
+
+    #[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#"
+class Foo
+  def bar
+    begin
+      "hello"
+    rescue
+    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("String"), "should contain String: {}", type_str);
+        assert!(type_str.contains("nil"), "should contain nil: {}", type_str);
+    }
+}

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

@@ -8,14 +8,18 @@ use crate::env::{GlobalEnv, LocalEnv};
 use crate::graph::{ChangeSet, VertexId};
 use ruby_prism::Node;
 
+use super::assignments::process_multi_write_node;
 use super::blocks::process_block_node;
 use super::conditionals::{process_case_node, process_if_node, process_unless_node};
 use super::definitions::{process_class_node, process_def_node, process_module_node};
+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::parentheses::process_parentheses_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> {
@@ -79,6 +83,34 @@ pub(crate) fn install_node(
         return process_case_node(genv, lenv, changes, source, &case_node);
     }
 
+    if let Some(begin_node) = node.as_begin_node() {
+        return process_begin_node(genv, lenv, changes, source, &begin_node);
+    }
+    if let Some(rescue_modifier) = node.as_rescue_modifier_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);
     }
@@ -94,6 +126,10 @@ pub(crate) fn install_node(
         return process_or_node(genv, lenv, changes, source, &or_node);
     }
 
+    if let Some(multi_write) = node.as_multi_write_node() {
+        return process_multi_write_node(genv, lenv, changes, source, &multi_write);
+    }
+
     match dispatch_simple(genv, lenv, node) {
         DispatchResult::Vertex(vtx) => return Some(vtx),
         DispatchResult::NotHandled => {}