method-ray 0.1.3 → 0.1.5

data/rust/src/analyzer/literals.rs

@@ -3,60 +3,239 @@
 //! This module is responsible for:
 //! - String, Integer, Float, Regexp literals
 //! - nil, true, false, Symbol literals
+//! - Array, Hash, Range literals with element type inference
 //! - Creating Source vertices with fixed types
-//!
-//! Note: Array, Hash, and Range literals are handled in install.rs for element type inference
 
-use crate::env::GlobalEnv;
-use crate::graph::VertexId;
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
 use crate::types::Type;
 use ruby_prism::Node;
+use std::collections::HashSet;
 
-/// Install literal nodes and return their VertexId
-///
-/// Note: Array and Hash literals are NOT handled here because they require
-/// child processing for element type inference. See install.rs.
-pub fn install_literal(genv: &mut GlobalEnv, node: &Node) -> Option<VertexId> {
-    // "hello"
-    if node.as_string_node().is_some() {
+/// Install literal node (including complex types: Array, Hash, Range)
+pub(crate) fn install_literal_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    node: &Node,
+) -> Option<VertexId> {
+    if node.as_array_node().is_some() {
+        let elements: Vec<Node> = node.as_array_node().unwrap().elements().iter().collect();
+        return install_array_literal_elements(genv, lenv, changes, source, elements);
+    }
+
+    if node.as_hash_node().is_some() {
+        let elements: Vec<Node> = node.as_hash_node().unwrap().elements().iter().collect();
+        return install_hash_literal_elements(genv, lenv, changes, source, elements);
+    }
+
+    if let Some(range_node) = node.as_range_node() {
+        return install_range_literal(genv, lenv, changes, source, &range_node);
+    }
+
+    // InterpolatedStringNode: "Hello, #{expr}" → String
+    if let Some(interp) = node.as_interpolated_string_node() {
+        for part in &interp.parts() {
+            super::install::install_node(genv, lenv, changes, source, &part);
+        }
         return Some(genv.new_source(Type::string()));
     }
 
-    // 42
+    // InterpolatedSymbolNode: :"hello_#{expr}" → Symbol
+    if let Some(interp) = node.as_interpolated_symbol_node() {
+        for part in &interp.parts() {
+            super::install::install_node(genv, lenv, changes, source, &part);
+        }
+        return Some(genv.new_source(Type::symbol()));
+    }
+
+    // InterpolatedRegularExpressionNode: /hello #{expr}/ → Regexp
+    if let Some(interp) = node.as_interpolated_regular_expression_node() {
+        for part in &interp.parts() {
+            super::install::install_node(genv, lenv, changes, source, &part);
+        }
+        return Some(genv.new_source(Type::regexp()));
+    }
+
+    install_simple_literal(genv, node)
+}
+
+/// Install simple literal nodes (String, Integer, Float, nil, true, false, Symbol, Regexp)
+fn install_simple_literal(genv: &mut GlobalEnv, node: &Node) -> Option<VertexId> {
+    if node.as_string_node().is_some() {
+        return Some(genv.new_source(Type::string()));
+    }
     if node.as_integer_node().is_some() {
         return Some(genv.new_source(Type::integer()));
     }
-
-    // 3.14
     if node.as_float_node().is_some() {
         return Some(genv.new_source(Type::float()));
     }
-
-    // nil
     if node.as_nil_node().is_some() {
         return Some(genv.new_source(Type::Nil));
     }
-
-    // true
     if node.as_true_node().is_some() {
         return Some(genv.new_source(Type::instance("TrueClass")));
     }
-
-    // false
     if node.as_false_node().is_some() {
         return Some(genv.new_source(Type::instance("FalseClass")));
     }
-
-    // :symbol
     if node.as_symbol_node().is_some() {
         return Some(genv.new_source(Type::symbol()));
     }
-
-    // /pattern/
     if node.as_regular_expression_node().is_some() {
         return Some(genv.new_source(Type::regexp()));
     }
+    None
+}
+
+/// Install array literal with element type inference
+fn install_array_literal_elements(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    elements: Vec<Node>,
+) -> Option<VertexId> {
+    if elements.is_empty() {
+        return Some(genv.new_source(Type::array()));
+    }
+
+    let mut element_types: HashSet<Type> = HashSet::new();
 
+    for element in &elements {
+        if let Some(vtx) = super::install::install_node(genv, lenv, changes, source, element) {
+            if let Some(src) = genv.get_source(vtx) {
+                element_types.insert(src.ty.clone());
+            } else if let Some(vertex) = genv.get_vertex(vtx) {
+                for ty in vertex.types.keys() {
+                    element_types.insert(ty.clone());
+                }
+            }
+        }
+    }
+
+    let array_type = if element_types.is_empty() {
+        Type::array()
+    } else if element_types.len() == 1 {
+        let elem_type = element_types.into_iter().next().unwrap();
+        Type::array_of(elem_type)
+    } else {
+        let types_vec: Vec<Type> = element_types.into_iter().collect();
+        let union_type = Type::Union(types_vec);
+        Type::array_of(union_type)
+    };
+
+    Some(genv.new_source(array_type))
+}
+
+/// Install hash literal with key/value type inference
+fn install_hash_literal_elements(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    elements: Vec<Node>,
+) -> Option<VertexId> {
+    if elements.is_empty() {
+        return Some(genv.new_source(Type::hash()));
+    }
+
+    let mut key_types: HashSet<Type> = HashSet::new();
+    let mut value_types: HashSet<Type> = HashSet::new();
+
+    for element in &elements {
+        if let Some(assoc_node) = element.as_assoc_node() {
+            if let Some(key_vtx) =
+                super::install::install_node(genv, lenv, changes, source, &assoc_node.key())
+            {
+                if let Some(src) = genv.get_source(key_vtx) {
+                    key_types.insert(src.ty.clone());
+                } else if let Some(vertex) = genv.get_vertex(key_vtx) {
+                    for ty in vertex.types.keys() {
+                        key_types.insert(ty.clone());
+                    }
+                }
+            }
+
+            if let Some(value_vtx) =
+                super::install::install_node(genv, lenv, changes, source, &assoc_node.value())
+            {
+                if let Some(src) = genv.get_source(value_vtx) {
+                    value_types.insert(src.ty.clone());
+                } else if let Some(vertex) = genv.get_vertex(value_vtx) {
+                    for ty in vertex.types.keys() {
+                        value_types.insert(ty.clone());
+                    }
+                }
+            }
+        }
+    }
+
+    let hash_type = if key_types.is_empty() || value_types.is_empty() {
+        Type::hash()
+    } else {
+        let key_type = if key_types.len() == 1 {
+            key_types.into_iter().next().unwrap()
+        } else {
+            let types_vec: Vec<Type> = key_types.into_iter().collect();
+            Type::Union(types_vec)
+        };
+        let value_type = if value_types.len() == 1 {
+            value_types.into_iter().next().unwrap()
+        } else {
+            let types_vec: Vec<Type> = value_types.into_iter().collect();
+            Type::Union(types_vec)
+        };
+        Type::hash_of(key_type, value_type)
+    };
+
+    Some(genv.new_source(hash_type))
+}
+
+/// Install range literal with element type inference
+fn install_range_literal(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    range_node: &ruby_prism::RangeNode,
+) -> Option<VertexId> {
+    let element_type = if let Some(left) = range_node.left() {
+        infer_range_element_type(genv, lenv, changes, source, &left)
+    } else if let Some(right) = range_node.right() {
+        infer_range_element_type(genv, lenv, changes, source, &right)
+    } else {
+        None
+    };
+
+    let range_type = match element_type {
+        Some(ty) => Type::range_of(ty),
+        None => Type::range(),
+    };
+
+    Some(genv.new_source(range_type))
+}
+
+/// Infer element type from a range endpoint node
+fn infer_range_element_type(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    node: &Node,
+) -> Option<Type> {
+    if let Some(vtx) = super::install::install_node(genv, lenv, changes, source, node) {
+        if let Some(src) = genv.get_source(vtx) {
+            return Some(src.ty.clone());
+        }
+        if let Some(vertex) = genv.get_vertex(vtx) {
+            if let Some(ty) = vertex.types.keys().next() {
+                return Some(ty.clone());
+            }
+        }
+    }
     None
 }
 
@@ -67,9 +246,6 @@ mod tests {
     #[test]
     fn test_install_string_literal() {
         let mut genv = GlobalEnv::new();
-
-        // Create a mock string node - we test via integration instead
-        // Unit test just verifies the type creation
         let vtx = genv.new_source(Type::string());
         assert_eq!(genv.get_source(vtx).unwrap().ty.show(), "String");
     }
@@ -77,7 +253,6 @@ mod tests {
     #[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");
     }
@@ -85,7 +260,6 @@ mod tests {
     #[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");
     }
@@ -93,7 +267,27 @@ mod tests {
     #[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/rust/src/analyzer/mod.rs

@@ -1,10 +1,15 @@
+mod attributes;
 mod blocks;
 mod calls;
+mod conditionals;
 mod definitions;
 mod dispatch;
 mod install;
 mod literals;
+mod operators;
 mod parameters;
+mod parentheses;
+mod returns;
 mod variables;
 
 pub use install::AstInstaller;

data/rust/src/analyzer/operators.rs

@@ -0,0 +1,192 @@
+//! Operators - logical operator type inference (&&, ||)
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use ruby_prism::{AndNode, OrNode};
+
+use super::install::install_node;
+
+/// Process AndNode (a && b): Union(type(a), type(b))
+///
+/// Short-circuit semantics: if `a` is falsy, returns `a`; otherwise returns `b`.
+/// Static approximation: we cannot determine truthiness at compile time,
+/// so we 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> {
+    let result_vtx = genv.new_vertex();
+
+    let left_vtx = install_node(genv, lenv, changes, source, &and_node.left());
+    if let Some(vtx) = left_vtx {
+        genv.add_edge(vtx, result_vtx);
+    }
+
+    let right_vtx = install_node(genv, lenv, changes, source, &and_node.right());
+    if let Some(vtx) = right_vtx {
+        genv.add_edge(vtx, result_vtx);
+    }
+
+    Some(result_vtx)
+}
+
+/// Process OrNode (a || b): Union(type(a), type(b))
+///
+/// Short-circuit semantics: if `a` is truthy, returns `a`; otherwise returns `b`.
+/// Static approximation: identical to AndNode — Union of both sides.
+pub(crate) fn process_or_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    or_node: &OrNode,
+) -> Option<VertexId> {
+    let result_vtx = genv.new_vertex();
+
+    let left_vtx = install_node(genv, lenv, changes, source, &or_node.left());
+    if let Some(vtx) = left_vtx {
+        genv.add_edge(vtx, result_vtx);
+    }
+
+    let right_vtx = install_node(genv, lenv, changes, source, &or_node.right());
+    if let Some(vtx) = right_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
+    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);
+    }
+
+}

data/rust/src/analyzer/parameters.rs

@@ -113,6 +113,70 @@ pub fn install_keyword_rest_parameter(
     param_vtx
 }
 
+/// Install method parameters as local variables
+///
+/// Returns a Vec of VertexId for required and optional parameters (positional),
+/// which can be used for argument-to-parameter type propagation.
+pub(crate) fn install_parameters(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    params_node: &ruby_prism::ParametersNode,
+) -> Vec<VertexId> {
+    let mut param_vtxs = Vec::new();
+
+    // Required parameters: def foo(a, b)
+    for node in params_node.requireds().iter() {
+        if let Some(req_param) = node.as_required_parameter_node() {
+            let name = String::from_utf8_lossy(req_param.name().as_slice()).to_string();
+            let vtx = install_required_parameter(genv, lenv, name);
+            param_vtxs.push(vtx);
+        }
+    }
+
+    // Optional parameters: def foo(a = 1, b = "hello")
+    for node in params_node.optionals().iter() {
+        if let Some(opt_param) = node.as_optional_parameter_node() {
+            let name = String::from_utf8_lossy(opt_param.name().as_slice()).to_string();
+            let default_value = opt_param.value();
+
+            let vtx = if let Some(default_vtx) =
+                super::install::install_node(genv, lenv, changes, source, &default_value)
+            {
+                install_optional_parameter(genv, lenv, changes, name, default_vtx)
+            } else {
+                install_required_parameter(genv, lenv, name)
+            };
+            param_vtxs.push(vtx);
+        }
+    }
+
+    // Rest parameter: def foo(*args)
+    // Not included in param_vtxs (variadic args need special handling)
+    if let Some(rest_node) = params_node.rest() {
+        if let Some(rest_param) = rest_node.as_rest_parameter_node() {
+            if let Some(name_id) = rest_param.name() {
+                let name = String::from_utf8_lossy(name_id.as_slice()).to_string();
+                install_rest_parameter(genv, lenv, name);
+            }
+        }
+    }
+
+    // Keyword rest parameter: def foo(**kwargs)
+    // Not included in param_vtxs (keyword args need special handling)
+    if let Some(kwrest_node) = params_node.keyword_rest() {
+        if let Some(kwrest_param) = kwrest_node.as_keyword_rest_parameter_node() {
+            if let Some(name_id) = kwrest_param.name() {
+                let name = String::from_utf8_lossy(name_id.as_slice()).to_string();
+                install_keyword_rest_parameter(genv, lenv, name);
+            }
+        }
+    }
+
+    param_vtxs
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

data/rust/src/analyzer/parentheses.rs

@@ -0,0 +1,113 @@
+//! 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");
+    }
+}