method-ray 0.1.2 → 0.1.4

data/rust/src/analyzer/install.rs

@@ -8,13 +8,13 @@ use crate::env::{GlobalEnv, LocalEnv};
 use crate::graph::{ChangeSet, VertexId};
 use ruby_prism::Node;
 
-use super::definitions::{exit_scope, extract_class_name, install_class, install_method};
-use super::dispatch::{
-    dispatch_needs_child, dispatch_simple, finish_ivar_write, finish_local_var_write,
-    finish_method_call, DispatchResult, NeedsChildKind,
-};
+use super::blocks::process_block_node;
+use super::conditionals::{process_case_node, process_if_node, process_unless_node};
+use super::definitions::{process_class_node, process_def_node, process_module_node};
+use super::dispatch::{dispatch_needs_child, dispatch_simple, process_needs_child, DispatchResult};
+use super::literals::install_literal_node;
 
-/// Build graph from AST
+/// Build graph from AST (public API wrapper)
 pub struct AstInstaller<'a> {
     genv: &'a mut GlobalEnv,
     lenv: &'a mut LocalEnv,
@@ -32,195 +32,77 @@ impl<'a> AstInstaller<'a> {
         }
     }
 
-    /// Install node (returns Vertex ID)
     pub fn install_node(&mut self, node: &Node) -> Option<VertexId> {
-        // Class definition
-        if let Some(class_node) = node.as_class_node() {
-            return self.install_class_node(&class_node);
-        }
-
-        // Method definition
-        if let Some(def_node) = node.as_def_node() {
-            return self.install_def_node(&def_node);
-        }
-
-        // Try simple dispatch first (no child processing needed)
-        match dispatch_simple(self.genv, self.lenv, node) {
-            DispatchResult::Vertex(vtx) => return Some(vtx),
-            DispatchResult::NotHandled => {}
-        }
-
-        // Check if node needs child processing
-        if let Some(kind) = dispatch_needs_child(node, self.source) {
-            return self.process_needs_child(kind);
-        }
-
-        None
+        install_node(self.genv, self.lenv, &mut self.changes, self.source, node)
     }
 
-    /// Process nodes that need child evaluation first
-    fn process_needs_child(&mut self, kind: NeedsChildKind) -> Option<VertexId> {
-        match kind {
-            NeedsChildKind::IvarWrite { ivar_name, value } => {
-                let value_vtx = self.install_node(&value)?;
-                Some(finish_ivar_write(self.genv, ivar_name, value_vtx))
-            }
-            NeedsChildKind::LocalVarWrite { var_name, value } => {
-                let value_vtx = self.install_node(&value)?;
-                Some(finish_local_var_write(
-                    self.genv,
-                    self.lenv,
-                    &mut self.changes,
-                    var_name,
-                    value_vtx,
-                ))
-            }
-            NeedsChildKind::MethodCall {
-                receiver,
-                method_name,
-                location,
-            } => {
-                let recv_vtx = self.install_node(&receiver)?;
-                Some(finish_method_call(
-                    self.genv,
-                    recv_vtx,
-                    method_name,
-                    location,
-                ))
-            }
-        }
-    }
-
-    /// Install class definition
-    fn install_class_node(&mut self, class_node: &ruby_prism::ClassNode) -> Option<VertexId> {
-        let class_name = extract_class_name(class_node);
-        install_class(self.genv, class_name);
-
-        if let Some(body) = class_node.body() {
-            if let Some(statements) = body.as_statements_node() {
-                self.install_statements(&statements);
-            }
-        }
-
-        exit_scope(self.genv);
-        None
-    }
-
-    /// Install method definition
-    fn install_def_node(&mut self, def_node: &ruby_prism::DefNode) -> Option<VertexId> {
-        let method_name = String::from_utf8_lossy(def_node.name().as_slice()).to_string();
-        install_method(self.genv, method_name);
-
-        if let Some(body) = def_node.body() {
-            if let Some(statements) = body.as_statements_node() {
-                self.install_statements(&statements);
-            }
-        }
-
-        exit_scope(self.genv);
-        None
-    }
-
-    /// Process multiple statements
-    fn install_statements(&mut self, statements: &ruby_prism::StatementsNode) {
-        for stmt in &statements.body() {
-            self.install_node(&stmt);
-        }
-    }
-
-    /// Finish installation (apply changes and execute Boxes)
     pub fn finish(self) {
         self.genv.apply_changes(self.changes);
         self.genv.run_all();
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::parser::parse_ruby_source;
-    use crate::types::Type;
-
-    #[test]
-    fn test_install_literal() {
-        let source = r#"x = "hello""#;
-        let parse_result = parse_ruby_source(source, "test.rb".to_string()).unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut installer = AstInstaller::new(&mut genv, &mut lenv, source);
-
-        let root = parse_result.node();
-        if let Some(program_node) = root.as_program_node() {
-            let statements = program_node.statements();
-            for stmt in &statements.body() {
-                installer.install_node(&stmt);
-            }
-        }
-
-        installer.finish();
+/// Install node (returns Vertex ID)
+pub(crate) fn install_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    node: &Node,
+) -> Option<VertexId> {
+    if let Some(class_node) = node.as_class_node() {
+        return process_class_node(genv, lenv, changes, source, &class_node);
+    }
 
-        let x_vtx = lenv.get_var("x").unwrap();
-        assert_eq!(genv.get_vertex(x_vtx).unwrap().show(), "String");
+    if let Some(module_node) = node.as_module_node() {
+        return process_module_node(genv, lenv, changes, source, &module_node);
     }
 
-    #[test]
-    fn test_install_multiple_vars() {
-        let source = r#"
-x = "hello"
-y = 42
-"#;
-        let parse_result = parse_ruby_source(source, "test.rb".to_string()).unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut installer = AstInstaller::new(&mut genv, &mut lenv, source);
-
-        let root = parse_result.node();
-        if let Some(program_node) = root.as_program_node() {
-            let statements = program_node.statements();
-            for stmt in &statements.body() {
-                installer.install_node(&stmt);
-            }
-        }
+    if let Some(def_node) = node.as_def_node() {
+        return process_def_node(genv, lenv, changes, source, &def_node);
+    }
 
-        installer.finish();
+    if let Some(block_node) = node.as_block_node() {
+        return process_block_node(genv, lenv, changes, source, &block_node);
+    }
 
-        let x_vtx = lenv.get_var("x").unwrap();
-        let y_vtx = lenv.get_var("y").unwrap();
+    if let Some(if_node) = node.as_if_node() {
+        return process_if_node(genv, lenv, changes, source, &if_node);
+    }
+    if let Some(unless_node) = node.as_unless_node() {
+        return process_unless_node(genv, lenv, changes, source, &unless_node);
+    }
+    if let Some(case_node) = node.as_case_node() {
+        return process_case_node(genv, lenv, changes, source, &case_node);
+    }
 
-        assert_eq!(genv.get_vertex(x_vtx).unwrap().show(), "String");
-        assert_eq!(genv.get_vertex(y_vtx).unwrap().show(), "Integer");
+    match dispatch_simple(genv, lenv, node) {
+        DispatchResult::Vertex(vtx) => return Some(vtx),
+        DispatchResult::NotHandled => {}
     }
 
-    #[test]
-    fn test_install_method_call() {
-        let source = r#"
-x = "hello"
-y = x.upcase
-"#;
-        let parse_result = parse_ruby_source(source, "test.rb".to_string()).unwrap();
-
-        let mut genv = GlobalEnv::new();
-        genv.register_builtin_method(Type::string(), "upcase", Type::string());
-
-        let mut lenv = LocalEnv::new();
-        let mut installer = AstInstaller::new(&mut genv, &mut lenv, source);
-
-        let root = parse_result.node();
-        if let Some(program_node) = root.as_program_node() {
-            let statements = program_node.statements();
-            for stmt in &statements.body() {
-                installer.install_node(&stmt);
-            }
-        }
+    if let Some(vtx) = install_literal_node(genv, lenv, changes, source, node) {
+        return Some(vtx);
+    }
 
-        installer.finish();
+    if let Some(kind) = dispatch_needs_child(node, source) {
+        return process_needs_child(genv, lenv, changes, source, kind);
+    }
 
-        let x_vtx = lenv.get_var("x").unwrap();
-        let y_vtx = lenv.get_var("y").unwrap();
+    None
+}
 
-        assert_eq!(genv.get_vertex(x_vtx).unwrap().show(), "String");
-        assert_eq!(genv.get_vertex(y_vtx).unwrap().show(), "String");
+/// Process multiple statements (returns last expression's VertexId)
+pub(crate) fn install_statements(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    statements: &ruby_prism::StatementsNode,
+) -> Option<VertexId> {
+    let mut last_vtx = None;
+    for stmt in &statements.body() {
+        last_vtx = install_node(genv, lenv, changes, source, &stmt);
     }
+    last_vtx
 }

data/rust/src/analyzer/literals.rs

@@ -1,63 +1,217 @@
 //! Literal Handlers - Processing Ruby literal values
 //!
 //! This module is responsible for:
-//! - String, Integer, Array, Hash literals
+//! - String, Integer, Float, Regexp literals
 //! - nil, true, false, Symbol literals
+//! - Array, Hash, Range literals with element type inference
 //! - Creating Source vertices with fixed types
 
-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
-pub fn install_literal(genv: &mut GlobalEnv, node: &Node) -> Option<VertexId> {
-    // "hello"
+/// 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);
+    }
+
+    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()));
     }
-
-    // 42
     if node.as_integer_node().is_some() {
         return Some(genv.new_source(Type::integer()));
     }
+    if node.as_float_node().is_some() {
+        return Some(genv.new_source(Type::float()));
+    }
+    if node.as_nil_node().is_some() {
+        return Some(genv.new_source(Type::Nil));
+    }
+    if node.as_true_node().is_some() {
+        return Some(genv.new_source(Type::instance("TrueClass")));
+    }
+    if node.as_false_node().is_some() {
+        return Some(genv.new_source(Type::instance("FalseClass")));
+    }
+    if node.as_symbol_node().is_some() {
+        return Some(genv.new_source(Type::symbol()));
+    }
+    if node.as_regular_expression_node().is_some() {
+        return Some(genv.new_source(Type::regexp()));
+    }
+    None
+}
 
-    // [1, 2, 3]
-    if node.as_array_node().is_some() {
+/// 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()));
     }
 
-    // {a: 1}
-    if node.as_hash_node().is_some() {
-        return Some(genv.new_source(Type::hash()));
-    }
+    let mut element_types: HashSet<Type> = HashSet::new();
 
-    // nil
-    if node.as_nil_node().is_some() {
-        return Some(genv.new_source(Type::Nil));
+    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());
+                }
+            }
+        }
     }
 
-    // true
-    if node.as_true_node().is_some() {
-        return Some(genv.new_source(Type::Instance {
-            class_name: "TrueClass".to_string(),
-        }));
-    }
+    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)
+    };
 
-    // false
-    if node.as_false_node().is_some() {
-        return Some(genv.new_source(Type::Instance {
-            class_name: "FalseClass".to_string(),
-        }));
+    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()));
     }
 
-    // :symbol
-    if node.as_symbol_node().is_some() {
-        return Some(genv.new_source(Type::Instance {
-            class_name: "Symbol".to_string(),
-        }));
+    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
 }
 
@@ -68,9 +222,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");
     }
@@ -78,8 +229,21 @@ 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");
     }
+
+    #[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");
+    }
 }

data/rust/src/analyzer/mod.rs

@@ -1,11 +1,12 @@
+mod attributes;
+mod blocks;
 mod calls;
+mod conditionals;
 mod definitions;
 mod dispatch;
 mod install;
 mod literals;
+mod parameters;
 mod variables;
 
-#[cfg(test)]
-mod tests;
-
 pub use install::AstInstaller;