method-ray 0.1.8 → 0.1.10

data/rust/src/analyzer/operators.rs

@@ -1,284 +0,0 @@
-//! Operators - logical operator type inference (&&, ||, !)
-
-use crate::env::{GlobalEnv, LocalEnv};
-use crate::graph::{ChangeSet, VertexId};
-use crate::types::Type;
-use ruby_prism::{AndNode, Node, OrNode};
-
-use super::install::install_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,
-    left: Node<'a>,
-    right: Node<'a>,
-) -> Option<VertexId> {
-    let result_vtx = genv.new_vertex();
-
-    if let Some(vtx) = install_node(genv, lenv, changes, source, &left) {
-        genv.add_edge(vtx, result_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))
-///
-/// 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,
-    changes: &mut ChangeSet,
-    source: &str,
-    or_node: &OrNode,
-) -> Option<VertexId> {
-    process_binary_logical_op(genv, lenv, changes, source, or_node.left(), or_node.right())
-}
-
-/// 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)]
-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/rust/src/analyzer/parentheses.rs

@@ -1,113 +0,0 @@
-//! Parentheses - pass-through type propagation for parenthesized expressions
-
-use crate::env::{GlobalEnv, LocalEnv};
-use crate::graph::{ChangeSet, VertexId};
-
-use super::install::{install_node, install_statements};
-
-/// Process ParenthesesNode: propagate inner expression's type
-pub(crate) fn process_parentheses_node(
-    genv: &mut GlobalEnv,
-    lenv: &mut LocalEnv,
-    changes: &mut ChangeSet,
-    source: &str,
-    paren_node: &ruby_prism::ParenthesesNode,
-) -> Option<VertexId> {
-    let body = paren_node.body()?;
-
-    if let Some(stmts) = body.as_statements_node() {
-        // (expr1; expr2) → process all, return last expression's type
-        install_statements(genv, lenv, changes, source, &stmts)
-    } else {
-        // (expr) → propagate inner expression's type directly
-        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");
-    }
-}

data/rust/src/analyzer/returns.rs

@@ -1,191 +0,0 @@
-//! Return statement handling
-//!
-//! Processes `return expr` by connecting the expression's vertex
-//! to the enclosing method's merge vertex.
-
-use crate::env::{GlobalEnv, LocalEnv};
-use crate::graph::{ChangeSet, VertexId};
-
-use super::install::install_node;
-
-/// Process ReturnNode: connect return value to method's merge vertex
-pub(crate) fn process_return_node(
-    genv: &mut GlobalEnv,
-    lenv: &mut LocalEnv,
-    changes: &mut ChangeSet,
-    source: &str,
-    return_node: &ruby_prism::ReturnNode,
-) -> Option<VertexId> {
-    // Process return value (first argument only; multi-value return not yet supported)
-    let value_vtx = if let Some(arguments) = return_node.arguments() {
-        arguments
-            .arguments()
-            .iter()
-            .next()
-            .and_then(|arg| install_node(genv, lenv, changes, source, &arg))
-    } else {
-        // `return` without value → nil
-        Some(genv.new_source(crate::types::Type::Nil))
-    };
-
-    // Connect return value to method's merge vertex
-    if let Some(vtx) = value_vtx {
-        if let Some(merge_vtx) = genv.scope_manager.current_method_return_vertex() {
-            genv.add_edge(vtx, merge_vtx);
-        }
-    }
-
-    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/rust/src/env/local_env.rs

@@ -1,92 +0,0 @@
-use crate::graph::VertexId;
-use std::collections::HashMap;
-
-/// Local environment: mapping of local variable names to VertexIDs
-pub struct LocalEnv {
-    locals: HashMap<String, VertexId>,
-}
-
-impl Default for LocalEnv {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl LocalEnv {
-    pub fn new() -> Self {
-        Self {
-            locals: HashMap::new(),
-        }
-    }
-
-    /// Register variable
-    pub fn new_var(&mut self, name: String, vtx_id: VertexId) {
-        self.locals.insert(name, vtx_id);
-    }
-
-    /// Get variable
-    pub fn get_var(&self, name: &str) -> Option<VertexId> {
-        self.locals.get(name).copied()
-    }
-
-    /// Remove a variable from the local environment.
-    /// Used for scoped variables like rescue's `=> e` binding.
-    pub fn remove_var(&mut self, name: &str) {
-        self.locals.remove(name);
-    }
-
-    /// Get all variables
-    pub fn all_vars(&self) -> impl Iterator<Item = (&String, &VertexId)> {
-        self.locals.iter()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_local_env_default() {
-        let lenv = LocalEnv::default();
-        assert_eq!(lenv.get_var("x"), None);
-    }
-
-    #[test]
-    fn test_local_env() {
-        let mut lenv = LocalEnv::new();
-
-        lenv.new_var("x".to_string(), VertexId(1));
-        lenv.new_var("y".to_string(), VertexId(2));
-
-        assert_eq!(lenv.get_var("x"), Some(VertexId(1)));
-        assert_eq!(lenv.get_var("y"), Some(VertexId(2)));
-        assert_eq!(lenv.get_var("z"), None);
-    }
-
-    #[test]
-    fn test_local_env_remove_var() {
-        let mut lenv = LocalEnv::new();
-
-        lenv.new_var("e".to_string(), VertexId(1));
-        assert_eq!(lenv.get_var("e"), Some(VertexId(1)));
-
-        lenv.remove_var("e");
-        assert_eq!(lenv.get_var("e"), None);
-    }
-
-    #[test]
-    fn test_local_env_remove_nonexistent() {
-        let mut lenv = LocalEnv::new();
-        lenv.remove_var("x"); // should not panic
-    }
-
-    #[test]
-    fn test_local_env_override() {
-        let mut lenv = LocalEnv::new();
-
-        lenv.new_var("x".to_string(), VertexId(1));
-        lenv.new_var("x".to_string(), VertexId(2)); // Override
-
-        assert_eq!(lenv.get_var("x"), Some(VertexId(2)));
-    }
-}