method-ray 0.1.9 → 0.1.10

data/core/src/analyzer/returns.rs

@@ -37,155 +37,3 @@ pub(crate) fn process_return_node(
 
     None
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::env::{GlobalEnv, LocalEnv};
-    use crate::graph::ChangeSet;
-    use crate::parser::ParseSession;
-    use crate::types::Type;
-
-    fn setup_and_infer(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 changes = ChangeSet::new();
-
-        for stmt in &program.statements().body() {
-            crate::analyzer::install::install_node(
-                &mut genv, &mut lenv, &mut changes, source, &stmt,
-            );
-        }
-
-        genv.apply_changes(changes);
-        genv.run_all();
-        genv
-    }
-
-    fn get_return_type(genv: &GlobalEnv, class_name: &str, method_name: &str) -> String {
-        let info = genv
-            .resolve_method(&Type::instance(class_name), method_name)
-            .unwrap_or_else(|| panic!("{}#{} should be registered", class_name, method_name));
-        let vtx = info
-            .return_vertex
-            .expect("return_vertex should be Some");
-
-        if let Some(source) = genv.get_source(vtx) {
-            source.ty.show()
-        } else if let Some(vertex) = genv.get_vertex(vtx) {
-            vertex.show()
-        } else {
-            panic!("return_vertex not found");
-        }
-    }
-
-    #[test]
-    fn test_simple_return() {
-        let source = r#"
-class Foo
-  def bar
-    return "hello"
-  end
-end
-"#;
-        let genv = setup_and_infer(source);
-        assert_eq!(get_return_type(&genv, "Foo", "bar"), "String");
-    }
-
-    #[test]
-    fn test_return_with_implicit_return_union() {
-        let source = r#"
-class Foo
-  def bar
-    return "hello" if true
-    42
-  end
-end
-"#;
-        let genv = setup_and_infer(source);
-        let ty = get_return_type(&genv, "Foo", "bar");
-        assert!(ty.contains("Integer"), "should contain Integer, got: {}", ty);
-        assert!(ty.contains("String"), "should contain String, got: {}", ty);
-    }
-
-    #[test]
-    fn test_multiple_returns() {
-        let source = r#"
-class Foo
-  def bar
-    return "a" if true
-    return :b if false
-    42
-  end
-end
-"#;
-        let genv = setup_and_infer(source);
-        let ty = get_return_type(&genv, "Foo", "bar");
-        assert!(ty.contains("Integer"), "should contain Integer, got: {}", ty);
-        assert!(ty.contains("String"), "should contain String, got: {}", ty);
-        assert!(ty.contains("Symbol"), "should contain Symbol, got: {}", ty);
-    }
-
-    #[test]
-    fn test_return_without_value() {
-        let source = r#"
-class Foo
-  def bar
-    return if true
-    42
-  end
-end
-"#;
-        let genv = setup_and_infer(source);
-        let ty = get_return_type(&genv, "Foo", "bar");
-        assert!(ty.contains("Integer"), "should contain Integer, got: {}", ty);
-        assert!(ty.contains("nil"), "should contain nil, got: {}", ty);
-    }
-
-    #[test]
-    fn test_no_return_backward_compat() {
-        let source = r#"
-class Foo
-  def bar
-    "hello"
-  end
-end
-"#;
-        let genv = setup_and_infer(source);
-        assert_eq!(get_return_type(&genv, "Foo", "bar"), "String");
-    }
-
-    #[test]
-    fn test_return_only_method() {
-        let source = r#"
-class Foo
-  def bar
-    return "hello"
-  end
-end
-"#;
-        let genv = setup_and_infer(source);
-        assert_eq!(get_return_type(&genv, "Foo", "bar"), "String");
-    }
-
-    #[test]
-    fn test_return_dead_code_over_approximation() {
-        let source = r#"
-class Foo
-  def bar
-    return "hello"
-    42
-  end
-end
-"#;
-        let genv = setup_and_infer(source);
-        let ty = get_return_type(&genv, "Foo", "bar");
-        // Dead code after return is still processed (over-approximation)
-        assert!(ty.contains("Integer"), "should contain Integer (dead code), got: {}", ty);
-        assert!(ty.contains("String"), "should contain String, got: {}", ty);
-    }
-}

data/core/src/analyzer/super_calls.rs

@@ -69,217 +69,6 @@ fn process_super_call(
         arg_vtxs,
         kw,
         Some(location),
+        false, // super calls cannot use safe navigation
     ))
 }
-
-#[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");
-    }
-}

data/core/src/analyzer/variables.rs

@@ -10,7 +10,7 @@ use crate::graph::{ChangeSet, VertexId};
 use crate::types::Type;
 
 /// Install local variable write: x = value
-pub fn install_local_var_write(
+pub(crate) fn install_local_var_write(
     genv: &mut GlobalEnv,
     lenv: &mut LocalEnv,
     changes: &mut ChangeSet,
@@ -24,7 +24,7 @@ pub fn install_local_var_write(
 }
 
 /// Install local variable read: x
-pub fn install_local_var_read(lenv: &LocalEnv, var_name: &str) -> Option<VertexId> {
+pub(crate) fn install_local_var_read(lenv: &LocalEnv, var_name: &str) -> Option<VertexId> {
     lenv.get_var(var_name)
 }
 
@@ -33,7 +33,7 @@ pub fn install_local_var_read(lenv: &LocalEnv, var_name: &str) -> Option<VertexI
 /// If @name already has a pre-allocated VertexId (e.g., from attr_reader),
 /// an edge is added from value_vtx to the existing vertex so types propagate.
 /// Otherwise, value_vtx is registered directly as the ivar's VertexId.
-pub fn install_ivar_write(
+pub(crate) fn install_ivar_write(
     genv: &mut GlobalEnv,
     ivar_name: String,
     value_vtx: VertexId,
@@ -49,36 +49,16 @@ pub fn install_ivar_write(
 }
 
 /// Install instance variable read: @name
-pub fn install_ivar_read(genv: &GlobalEnv, ivar_name: &str) -> Option<VertexId> {
+pub(crate) fn install_ivar_read(genv: &GlobalEnv, ivar_name: &str) -> Option<VertexId> {
     genv.scope_manager.lookup_instance_var(ivar_name)
 }
 
 /// Install self node
 /// Uses the fully qualified name if available (e.g., Api::V1::User instead of just User)
-pub fn install_self(genv: &mut GlobalEnv) -> VertexId {
+pub(crate) fn install_self(genv: &mut GlobalEnv) -> VertexId {
     if let Some(qualified_name) = genv.scope_manager.current_qualified_name() {
         genv.new_source(Type::instance(&qualified_name))
     } else {
         genv.new_source(Type::instance("Object"))
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_install_self_at_top_level() {
-        let mut genv = GlobalEnv::new();
-
-        let vtx = install_self(&mut genv);
-        assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "Object");
-    }
-
-    #[test]
-    fn test_local_var_read_not_found() {
-        let lenv = LocalEnv::new();
-
-        assert_eq!(install_local_var_read(&lenv, "unknown"), None);
-    }
-}

data/core/src/checker.rs

@@ -134,16 +134,3 @@ fn collect_diagnostics(genv: &GlobalEnv, file_path: &Path) -> Vec<Diagnostic> {
 
     diagnostics
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_file_checker_creation() {
-        // This test will fail if RBS cache doesn't exist
-        // That's expected - cache should be generated from Ruby side first
-        let result = FileChecker::new();
-        assert!(result.is_ok() || result.is_err()); // Just check it doesn't panic
-    }
-}

data/core/src/diagnostics/diagnostic.rs

@@ -79,44 +79,3 @@ impl Diagnostic {
         Self::warning(location, message)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_diagnostic_creation() {
-        let loc = Location {
-            file: PathBuf::from("test.rb"),
-            line: 10,
-            column: 5,
-            length: None,
-        };
-
-        let diag = Diagnostic::undefined_method(loc.clone(), "Integer", "upcase");
-        assert_eq!(diag.level, DiagnosticLevel::Error);
-        assert_eq!(diag.message, "undefined method `upcase` for Integer");
-    }
-
-    #[test]
-    fn test_union_partial_error() {
-        let loc = Location {
-            file: PathBuf::from("test.rb"),
-            line: 15,
-            column: 3,
-            length: None,
-        };
-
-        let diag = Diagnostic::union_partial_error(
-            loc,
-            vec!["String".to_string()],
-            vec!["Integer".to_string()],
-            "upcase",
-        );
-
-        assert_eq!(diag.level, DiagnosticLevel::Warning);
-        assert!(diag
-            .message
-            .contains("method `upcase` is defined for String but not for Integer"));
-    }
-}

data/core/src/diagnostics/formatter.rs

@@ -78,41 +78,3 @@ pub fn format_diagnostics_with_file(diagnostics: &[Diagnostic], file_path: &Path
         Err(_) => format_diagnostics(diagnostics), // Fallback to simple format
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::diagnostics::diagnostic::{Diagnostic, Location};
-    use std::path::PathBuf;
-
-    #[test]
-    fn test_format_diagnostics() {
-        let diagnostics = vec![
-            Diagnostic::undefined_method(
-                Location {
-                    file: PathBuf::from("test.rb"),
-                    line: 10,
-                    column: 5,
-                    length: None,
-                },
-                "Integer",
-                "upcase",
-            ),
-            Diagnostic::union_partial_error(
-                Location {
-                    file: PathBuf::from("test.rb"),
-                    line: 15,
-                    column: 3,
-                    length: None,
-                },
-                vec!["String".to_string()],
-                vec!["Integer".to_string()],
-                "upcase",
-            ),
-        ];
-
-        let output = format_diagnostics(&diagnostics);
-        assert!(output.contains("test.rb:10:5: error:"));
-        assert!(output.contains("test.rb:15:3: warning:"));
-    }
-}

data/core/src/env/box_manager.rs

@@ -87,33 +87,3 @@ impl BoxManager {
         self.boxes.is_empty()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_add_run_prevents_duplicates() {
-        let mut manager = BoxManager::new();
-
-        let id = BoxId(0);
-        manager.add_run(id);
-        manager.add_run(id); // Should be ignored
-
-        assert_eq!(manager.run_queue.len(), 1);
-    }
-
-    #[test]
-    fn test_pop_run() {
-        let mut manager = BoxManager::new();
-
-        let id1 = BoxId(0);
-        let id2 = BoxId(1);
-        manager.add_run(id1);
-        manager.add_run(id2);
-
-        assert_eq!(manager.pop_run(), Some(id1));
-        assert_eq!(manager.pop_run(), Some(id2));
-        assert_eq!(manager.pop_run(), None);
-    }
-}