method-ray 0.1.1

data/rust/src/analyzer/dispatch.rs

@@ -0,0 +1,134 @@
+//! Node Dispatch - Dispatch AST nodes to appropriate handlers
+//!
+//! This module handles the pattern matching of Ruby AST nodes
+//! and dispatches them to specialized handlers.
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::source_map::SourceLocation;
+use ruby_prism::Node;
+
+use super::calls::install_method_call;
+use super::literals::install_literal;
+use super::variables::{
+    install_ivar_read, install_ivar_write, install_local_var_read, install_local_var_write,
+    install_self,
+};
+
+/// Result of dispatching a simple node (no child processing needed)
+pub enum DispatchResult {
+    /// Node produced a vertex
+    Vertex(VertexId),
+    /// Node was not handled
+    NotHandled,
+}
+
+/// Kind of child processing needed
+pub enum NeedsChildKind<'a> {
+    /// Instance variable write: need to process value, then call finish_ivar_write
+    IvarWrite { ivar_name: String, value: Node<'a> },
+    /// Local variable write: need to process value, then call finish_local_var_write
+    LocalVarWrite { var_name: String, value: Node<'a> },
+    /// Method call: need to process receiver, then call finish_method_call
+    MethodCall {
+        receiver: Node<'a>,
+        method_name: String,
+        location: SourceLocation,
+    },
+}
+
+/// First pass: check if node can be handled immediately without child processing
+pub fn dispatch_simple(genv: &mut GlobalEnv, lenv: &mut LocalEnv, node: &Node) -> DispatchResult {
+    // Instance variable read: @name
+    if let Some(ivar_read) = node.as_instance_variable_read_node() {
+        let ivar_name = String::from_utf8_lossy(ivar_read.name().as_slice()).to_string();
+        return match install_ivar_read(genv, &ivar_name) {
+            Some(vtx) => DispatchResult::Vertex(vtx),
+            None => DispatchResult::NotHandled,
+        };
+    }
+
+    // self
+    if node.as_self_node().is_some() {
+        return DispatchResult::Vertex(install_self(genv));
+    }
+
+    // Local variable read: x
+    if let Some(read_node) = node.as_local_variable_read_node() {
+        let var_name = String::from_utf8_lossy(read_node.name().as_slice()).to_string();
+        return match install_local_var_read(lenv, &var_name) {
+            Some(vtx) => DispatchResult::Vertex(vtx),
+            None => DispatchResult::NotHandled,
+        };
+    }
+
+    // Literals (String, Integer, Array, Hash, nil, true, false, Symbol)
+    if let Some(vtx) = install_literal(genv, node) {
+        return DispatchResult::Vertex(vtx);
+    }
+
+    DispatchResult::NotHandled
+}
+
+/// Check if node needs child processing
+pub fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<NeedsChildKind<'a>> {
+    // Instance variable write: @name = value
+    if let Some(ivar_write) = node.as_instance_variable_write_node() {
+        let ivar_name = String::from_utf8_lossy(ivar_write.name().as_slice()).to_string();
+        return Some(NeedsChildKind::IvarWrite {
+            ivar_name,
+            value: ivar_write.value(),
+        });
+    }
+
+    // Local variable write: x = value
+    if let Some(write_node) = node.as_local_variable_write_node() {
+        let var_name = String::from_utf8_lossy(write_node.name().as_slice()).to_string();
+        return Some(NeedsChildKind::LocalVarWrite {
+            var_name,
+            value: write_node.value(),
+        });
+    }
+
+    // Method call: x.upcase
+    if let Some(call_node) = node.as_call_node() {
+        if let Some(receiver) = call_node.receiver() {
+            let method_name = String::from_utf8_lossy(call_node.name().as_slice()).to_string();
+            let location =
+                SourceLocation::from_prism_location_with_source(&node.location(), source);
+            return Some(NeedsChildKind::MethodCall {
+                receiver,
+                method_name,
+                location,
+            });
+        }
+    }
+
+    None
+}
+
+/// Finish instance variable write after child is processed
+pub fn finish_ivar_write(genv: &mut GlobalEnv, ivar_name: String, value_vtx: VertexId) -> VertexId {
+    install_ivar_write(genv, ivar_name, value_vtx)
+}
+
+/// Finish local variable write after child is processed
+pub fn finish_local_var_write(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    var_name: String,
+    value_vtx: VertexId,
+) -> VertexId {
+    install_local_var_write(genv, lenv, changes, var_name, value_vtx)
+}
+
+/// Finish method call after receiver is processed
+pub fn finish_method_call(
+    genv: &mut GlobalEnv,
+    recv_vtx: VertexId,
+    method_name: String,
+    location: SourceLocation,
+) -> VertexId {
+    install_method_call(genv, recv_vtx, method_name, Some(location))
+}

data/rust/src/analyzer/install.rs

@@ -0,0 +1,226 @@
+//! AST Installer - AST traversal and graph construction
+//!
+//! This module is responsible for:
+//! - Traversing the Ruby AST (Abstract Syntax Tree)
+//! - Coordinating the graph construction process
+
+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,
+};
+
+/// Build graph from AST
+pub struct AstInstaller<'a> {
+    genv: &'a mut GlobalEnv,
+    lenv: &'a mut LocalEnv,
+    changes: ChangeSet,
+    source: &'a str,
+}
+
+impl<'a> AstInstaller<'a> {
+    pub fn new(genv: &'a mut GlobalEnv, lenv: &'a mut LocalEnv, source: &'a str) -> Self {
+        Self {
+            genv,
+            lenv,
+            changes: ChangeSet::new(),
+            source,
+        }
+    }
+
+    /// 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
+    }
+
+    /// 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();
+
+        let x_vtx = lenv.get_var("x").unwrap();
+        assert_eq!(genv.get_vertex(x_vtx).unwrap().show(), "String");
+    }
+
+    #[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);
+            }
+        }
+
+        installer.finish();
+
+        let x_vtx = lenv.get_var("x").unwrap();
+        let y_vtx = lenv.get_var("y").unwrap();
+
+        assert_eq!(genv.get_vertex(x_vtx).unwrap().show(), "String");
+        assert_eq!(genv.get_vertex(y_vtx).unwrap().show(), "Integer");
+    }
+
+    #[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);
+            }
+        }
+
+        installer.finish();
+
+        let x_vtx = lenv.get_var("x").unwrap();
+        let y_vtx = lenv.get_var("y").unwrap();
+
+        assert_eq!(genv.get_vertex(x_vtx).unwrap().show(), "String");
+        assert_eq!(genv.get_vertex(y_vtx).unwrap().show(), "String");
+    }
+}

data/rust/src/analyzer/literals.rs

@@ -0,0 +1,85 @@
+//! Literal Handlers - Processing Ruby literal values
+//!
+//! This module is responsible for:
+//! - String, Integer, Array, Hash literals
+//! - nil, true, false, Symbol literals
+//! - Creating Source vertices with fixed types
+
+use crate::env::GlobalEnv;
+use crate::graph::VertexId;
+use crate::types::Type;
+use ruby_prism::Node;
+
+/// Install literal nodes and return their VertexId
+pub fn install_literal(genv: &mut GlobalEnv, node: &Node) -> Option<VertexId> {
+    // "hello"
+    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()));
+    }
+
+    // [1, 2, 3]
+    if node.as_array_node().is_some() {
+        return Some(genv.new_source(Type::array()));
+    }
+
+    // {a: 1}
+    if node.as_hash_node().is_some() {
+        return Some(genv.new_source(Type::hash()));
+    }
+
+    // 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 {
+            class_name: "TrueClass".to_string(),
+        }));
+    }
+
+    // false
+    if node.as_false_node().is_some() {
+        return Some(genv.new_source(Type::Instance {
+            class_name: "FalseClass".to_string(),
+        }));
+    }
+
+    // :symbol
+    if node.as_symbol_node().is_some() {
+        return Some(genv.new_source(Type::Instance {
+            class_name: "Symbol".to_string(),
+        }));
+    }
+
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[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");
+    }
+
+    #[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");
+    }
+}

data/rust/src/analyzer/mod.rs

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

data/rust/src/analyzer/tests/integration_test.rs

@@ -0,0 +1,136 @@
+//! Integration Tests - End-to-end analyzer tests
+//!
+//! This module contains integration tests that verify:
+//! - Class/method definition handling
+//! - Instance variable type tracking across methods
+//! - Type error detection for undefined methods
+//! - Method chain type inference
+
+use crate::analyzer::AstInstaller;
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::parser::parse_ruby_source;
+use crate::types::Type;
+
+/// Helper to run analysis on Ruby source code
+fn analyze(source: &str) -> (GlobalEnv, LocalEnv) {
+    let parse_result = parse_ruby_source(source, "test.rb".to_string()).unwrap();
+
+    let mut genv = GlobalEnv::new();
+
+    // Register common methods
+    genv.register_builtin_method(Type::string(), "upcase", Type::string());
+    genv.register_builtin_method(Type::string(), "downcase", 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);
+        }
+    }
+
+    installer.finish();
+
+    (genv, lenv)
+}
+
+#[test]
+fn test_class_method_error_detection() {
+    let source = r#"
+class User
+  def test
+    x = 123
+    y = x.upcase
+  end
+end
+"#;
+
+    let (genv, _lenv) = analyze(source);
+
+    // Type error should be detected: Integer doesn't have upcase method
+    assert_eq!(genv.type_errors.len(), 1);
+    assert_eq!(genv.type_errors[0].method_name, "upcase");
+}
+
+#[test]
+fn test_class_with_instance_variable() {
+    let source = r#"
+class User
+  def initialize
+    @name = "John"
+  end
+
+  def greet
+    @name.upcase
+  end
+end
+"#;
+
+    let (genv, _lenv) = analyze(source);
+
+    // No type errors should occur - @name is String
+    assert_eq!(genv.type_errors.len(), 0);
+}
+
+#[test]
+fn test_instance_variable_type_error() {
+    let source = r#"
+class User
+  def initialize
+    @name = 123
+  end
+
+  def greet
+    @name.upcase
+  end
+end
+"#;
+
+    let (genv, _lenv) = analyze(source);
+
+    // Type error should be detected: @name is Integer, not String
+    assert_eq!(genv.type_errors.len(), 1);
+    assert_eq!(genv.type_errors[0].method_name, "upcase");
+}
+
+#[test]
+fn test_multiple_classes() {
+    let source = r#"
+class User
+  def name
+    x = 123
+    x.upcase
+  end
+end
+
+class Post
+  def title
+    y = "hello"
+    y.upcase
+  end
+end
+"#;
+
+    let (genv, _lenv) = analyze(source);
+
+    // Only User#name should have error (Integer#upcase), Post#title is fine
+    assert_eq!(genv.type_errors.len(), 1);
+    assert_eq!(genv.type_errors[0].method_name, "upcase");
+}
+
+#[test]
+fn test_method_chain() {
+    let source = r#"
+x = "hello"
+y = x.upcase.downcase
+"#;
+
+    let (genv, lenv) = analyze(source);
+
+    let y_vtx = lenv.get_var("y").unwrap();
+    assert_eq!(genv.get_vertex(y_vtx).unwrap().show(), "String");
+}

data/rust/src/analyzer/tests/mod.rs

@@ -0,0 +1 @@
+mod integration_test;

data/rust/src/analyzer/variables.rs

@@ -0,0 +1,76 @@
+//! Variable Handlers - Processing Ruby variables
+//!
+//! This module is responsible for:
+//! - Local variable read/write (x, x = value)
+//! - Instance variable read/write (@name, @name = value)
+//! - self node handling
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::types::Type;
+
+/// Install local variable write: x = value
+pub fn install_local_var_write(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    var_name: String,
+    value_vtx: VertexId,
+) -> VertexId {
+    let var_vtx = genv.new_vertex();
+    lenv.new_var(var_name, var_vtx);
+    changes.add_edge(value_vtx, var_vtx);
+    var_vtx
+}
+
+/// Install local variable read: x
+pub fn install_local_var_read(lenv: &LocalEnv, var_name: &str) -> Option<VertexId> {
+    lenv.get_var(var_name)
+}
+
+/// Install instance variable write: @name = value
+pub fn install_ivar_write(
+    genv: &mut GlobalEnv,
+    ivar_name: String,
+    value_vtx: VertexId,
+) -> VertexId {
+    genv.scope_manager
+        .set_instance_var_in_class(ivar_name, value_vtx);
+    value_vtx
+}
+
+/// Install instance variable read: @name
+pub fn install_ivar_read(genv: &GlobalEnv, ivar_name: &str) -> Option<VertexId> {
+    genv.scope_manager.lookup_instance_var(ivar_name)
+}
+
+/// Install self node
+pub fn install_self(genv: &mut GlobalEnv) -> VertexId {
+    if let Some(class_name) = genv.scope_manager.current_class_name() {
+        genv.new_source(Type::Instance { class_name })
+    } else {
+        genv.new_source(Type::Instance {
+            class_name: "Object".to_string(),
+        })
+    }
+}
+
+#[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/rust/src/cache/mod.rs

@@ -0,0 +1,3 @@
+pub mod rbs_cache;
+
+pub use rbs_cache::RbsCache;