method-ray 0.1.9 → 0.1.10

data/core/src/analyzer/mod.rs

@@ -31,18 +31,3 @@ pub use install::AstInstaller;
 pub(crate) fn bytes_to_name(bytes: &[u8]) -> String {
     String::from_utf8_lossy(bytes).to_string()
 }
-
-#[cfg(test)]
-mod tests {
-    use super::bytes_to_name;
-
-    #[test]
-    fn test_bytes_to_name_valid_utf8() {
-        assert_eq!(bytes_to_name(b"hello"), "hello");
-    }
-
-    #[test]
-    fn test_bytes_to_name_invalid_utf8_replaced() {
-        assert_eq!(bytes_to_name(b"hello\xff"), "hello\u{FFFD}");
-    }
-}

data/core/src/analyzer/operators.rs

@@ -77,208 +77,3 @@ pub(crate) fn process_not_operator(genv: &mut GlobalEnv) -> VertexId {
     genv.add_edge(false_vtx, result_vtx);
     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
-    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_and_node_union_type() {
-        let source = r#"
-class Foo
-  def bar
-    true && "hello"
-  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("TrueClass"), "should contain TrueClass: {}", type_str);
-        assert!(type_str.contains("String"), "should contain String: {}", type_str);
-    }
-
-    #[test]
-    fn test_and_node_same_type() {
-        let source = r#"
-class Foo
-  def bar
-    "a" && "b"
-  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_or_node_union_type() {
-        let source = r#"
-class Foo
-  def bar
-    42 || "hello"
-  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("Integer"), "should contain Integer: {}", type_str);
-        assert!(type_str.contains("String"), "should contain String: {}", type_str);
-    }
-
-    #[test]
-    fn test_or_node_same_type() {
-        let source = r#"
-class Foo
-  def bar
-    1 || 2
-  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");
-    }
-
-    #[test]
-    fn test_nested_logical_operators() {
-        let source = r#"
-class Foo
-  def bar
-    1 && "a" || :b
-  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("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);
-    }
-
-    // ============================================
-    // 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);
-    }
-}

data/core/src/analyzer/parameters.rs

@@ -24,7 +24,7 @@ use super::bytes_to_name;
 ///   name.upcase
 /// end
 /// ```
-pub fn install_required_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, name: String) -> VertexId {
+pub(crate) fn install_required_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, name: String) -> VertexId {
     // Create a vertex for the parameter (starts as Bot/untyped)
     let param_vtx = genv.new_vertex();
 
@@ -44,7 +44,7 @@ pub fn install_required_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, nam
 ///   name.upcase
 /// end
 /// ```
-pub fn install_optional_parameter(
+pub(crate) fn install_optional_parameter(
     genv: &mut GlobalEnv,
     lenv: &mut LocalEnv,
     _changes: &mut ChangeSet,
@@ -75,7 +75,7 @@ pub fn install_optional_parameter(
 ///   items.first
 /// end
 /// ```
-pub fn install_rest_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, name: String) -> VertexId {
+pub(crate) fn install_rest_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, name: String) -> VertexId {
     // Create a vertex for the parameter
     let param_vtx = genv.new_vertex();
 
@@ -99,7 +99,7 @@ pub fn install_rest_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, name: S
 ///   options[:debug]
 /// end
 /// ```
-pub fn install_keyword_rest_parameter(
+pub(crate) fn install_keyword_rest_parameter(
     genv: &mut GlobalEnv,
     lenv: &mut LocalEnv,
     name: String,
@@ -204,226 +204,3 @@ pub(crate) fn install_parameters(
 
     (param_vtxs, keyword_param_vtxs)
 }
-
-#[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() {
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-
-        let vtx = install_required_parameter(&mut genv, &mut lenv, "name".to_string());
-
-        // Parameter should be registered in LocalEnv
-        assert_eq!(lenv.get_var("name"), Some(vtx));
-
-        // Vertex should exist in GlobalEnv (as untyped)
-        let vertex = genv.get_vertex(vtx);
-        assert!(vertex.is_some());
-    }
-
-    #[test]
-    fn test_install_multiple_parameters() {
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-
-        let vtx_a = install_required_parameter(&mut genv, &mut lenv, "a".to_string());
-        let vtx_b = install_required_parameter(&mut genv, &mut lenv, "b".to_string());
-        let vtx_c = install_required_parameter(&mut genv, &mut lenv, "c".to_string());
-
-        // All parameters should be registered
-        assert_eq!(lenv.get_var("a"), Some(vtx_a));
-        assert_eq!(lenv.get_var("b"), Some(vtx_b));
-        assert_eq!(lenv.get_var("c"), Some(vtx_c));
-
-        // All vertices should be different
-        assert_ne!(vtx_a, vtx_b);
-        assert_ne!(vtx_b, vtx_c);
-        assert_ne!(vtx_a, vtx_c);
-    }
-
-    #[test]
-    fn test_install_optional_parameter_inherits_default_type() {
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut changes = ChangeSet::new();
-
-        // Default value: 0 (Integer)
-        let default_vtx = genv.new_source(Type::integer());
-        let vtx = install_optional_parameter(
-            &mut genv,
-            &mut lenv,
-            &mut changes,
-            "age".to_string(),
-            default_vtx,
-        );
-
-        assert_eq!(lenv.get_var("age"), Some(vtx));
-
-        // Type should propagate from default value
-        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/parentheses.rs

@@ -23,91 +23,3 @@ pub(crate) fn process_parentheses_node(
         install_node(genv, lenv, changes, source, &body)
     }
 }
-
-#[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;
-
-    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_parenthesized_integer() {
-        let source = r#"
-class Foo
-  def bar
-    x = (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");
-    }
-
-    #[test]
-    fn test_parenthesized_string() {
-        let source = r#"
-class Foo
-  def bar
-    x = ("hello")
-  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_parenthesized_multiple_statements() {
-        let source = r#"
-class Foo
-  def bar
-    x = (a = 1; "hello")
-  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");
-    }
-}