method-ray 0.1.9 → 0.1.10

data/core/src/analyzer/exceptions.rs

@@ -166,457 +166,3 @@ pub(crate) fn process_rescue_modifier_node(
 
     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/core/src/analyzer/literals.rs

@@ -224,57 +224,3 @@ fn infer_range_element_type(
     }
     None
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_install_string_literal() {
-        let mut genv = GlobalEnv::new();
-        let vtx = genv.new_source(Type::string());
-        assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "String");
-    }
-
-    #[test]
-    fn test_install_integer_literal() {
-        let mut genv = GlobalEnv::new();
-        let vtx = genv.new_source(Type::integer());
-        assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "Integer");
-    }
-
-    #[test]
-    fn test_install_float_literal() {
-        let mut genv = GlobalEnv::new();
-        let vtx = genv.new_source(Type::float());
-        assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "Float");
-    }
-
-    #[test]
-    fn test_install_regexp_literal() {
-        let mut genv = GlobalEnv::new();
-        let vtx = genv.new_source(Type::regexp());
-        assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "Regexp");
-    }
-
-    #[test]
-    fn test_install_interpolated_string_literal() {
-        let mut genv = GlobalEnv::new();
-        let vtx = genv.new_source(Type::string());
-        assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "String");
-    }
-
-    #[test]
-    fn test_install_interpolated_symbol_literal() {
-        let mut genv = GlobalEnv::new();
-        let vtx = genv.new_source(Type::symbol());
-        assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "Symbol");
-    }
-
-    #[test]
-    fn test_install_interpolated_regexp_literal() {
-        let mut genv = GlobalEnv::new();
-        let vtx = genv.new_source(Type::regexp());
-        assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "Regexp");
-    }
-}

data/core/src/analyzer/loops.rs

@@ -92,210 +92,3 @@ pub(crate) fn process_for_node(
 
     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);
-    }
-}