method-ray 0.1.2 → 0.1.4

data/rust/src/analyzer/definitions.rs

@@ -1,39 +1,180 @@
-//! Definition Handlers - Processing Ruby class/method definitions
+//! Definition Handlers - Processing Ruby class/method/module definitions
 //!
 //! This module is responsible for:
 //! - Class definition scope management (class Foo ... end)
-//! - Method definition scope management (def bar ... end)
-//! - Extracting class names from AST nodes
+//! - Module definition scope management (module Bar ... end)
+//! - Method definition scope management (def baz ... end)
+//! - Extracting class/module names from AST nodes (including qualified names like Api::User)
 
-use crate::env::GlobalEnv;
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::types::Type;
+use ruby_prism::Node;
+
+use super::install::install_statements;
+use super::parameters::install_parameters;
+
+/// Process class definition node
+pub(crate) fn process_class_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    class_node: &ruby_prism::ClassNode,
+) -> Option<VertexId> {
+    let class_name = extract_class_name(class_node);
+    install_class(genv, class_name);
+
+    if let Some(body) = class_node.body() {
+        if let Some(statements) = body.as_statements_node() {
+            install_statements(genv, lenv, changes, source, &statements);
+        }
+    }
+
+    exit_scope(genv);
+    None
+}
+
+/// Process module definition node
+pub(crate) fn process_module_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    module_node: &ruby_prism::ModuleNode,
+) -> Option<VertexId> {
+    let module_name = extract_module_name(module_node);
+    install_module(genv, module_name);
+
+    if let Some(body) = module_node.body() {
+        if let Some(statements) = body.as_statements_node() {
+            install_statements(genv, lenv, changes, source, &statements);
+        }
+    }
+
+    exit_scope(genv);
+    None
+}
+
+/// Process method definition node
+pub(crate) fn process_def_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    def_node: &ruby_prism::DefNode,
+) -> Option<VertexId> {
+    let method_name = String::from_utf8_lossy(def_node.name().as_slice()).to_string();
+    install_method(genv, method_name.clone());
+
+    // Process parameters BEFORE processing body
+    let param_vtxs = if let Some(params_node) = def_node.parameters() {
+        install_parameters(genv, lenv, changes, source, &params_node)
+    } else {
+        vec![]
+    };
+
+    let mut last_vtx = None;
+    if let Some(body) = def_node.body() {
+        if let Some(statements) = body.as_statements_node() {
+            last_vtx = install_statements(genv, lenv, changes, source, &statements);
+        }
+    }
+
+    // Register user-defined method with return vertex and param vertices (before exiting scope)
+    if let Some(return_vtx) = last_vtx {
+        let recv_type_name = genv
+            .scope_manager
+            .current_class_name()
+            .or_else(|| genv.scope_manager.current_module_name());
+
+        if let Some(name) = recv_type_name {
+            genv.register_user_method(
+                Type::instance(&name),
+                &method_name,
+                return_vtx,
+                param_vtxs,
+            );
+        }
+    }
+
+    exit_scope(genv);
+    None
+}
 
 /// Install class definition
-pub fn install_class(genv: &mut GlobalEnv, class_name: String) {
+fn install_class(genv: &mut GlobalEnv, class_name: String) {
     genv.enter_class(class_name);
 }
 
+/// Install module definition
+fn install_module(genv: &mut GlobalEnv, module_name: String) {
+    genv.enter_module(module_name);
+}
+
 /// Install method definition
-pub fn install_method(genv: &mut GlobalEnv, method_name: String) {
+fn install_method(genv: &mut GlobalEnv, method_name: String) {
     genv.enter_method(method_name);
 }
 
-/// Exit current scope (class or method)
-pub fn exit_scope(genv: &mut GlobalEnv) {
+/// Exit current scope (class, module, or method)
+fn exit_scope(genv: &mut GlobalEnv) {
     genv.exit_scope();
 }
 
 /// Extract class name from ClassNode
-pub fn extract_class_name(class_node: &ruby_prism::ClassNode) -> String {
-    if let Some(constant_read) = class_node.constant_path().as_constant_read_node() {
-        String::from_utf8_lossy(constant_read.name().as_slice()).to_string()
-    } else {
-        "UnknownClass".to_string()
+/// Supports both simple names (User) and qualified names (Api::V1::User)
+fn extract_class_name(class_node: &ruby_prism::ClassNode) -> String {
+    extract_constant_path(&class_node.constant_path()).unwrap_or_else(|| "UnknownClass".to_string())
+}
+
+/// Extract module name from ModuleNode
+/// Supports both simple names (Utils) and qualified names (Api::V1::Utils)
+fn extract_module_name(module_node: &ruby_prism::ModuleNode) -> String {
+    extract_constant_path(&module_node.constant_path())
+        .unwrap_or_else(|| "UnknownModule".to_string())
+}
+
+/// Extract constant path from a Node (handles both ConstantReadNode and ConstantPathNode)
+///
+/// Examples:
+/// - `User` (ConstantReadNode) → "User"
+/// - `Api::User` (ConstantPathNode) → "Api::User"
+/// - `Api::V1::User` (nested ConstantPathNode) → "Api::V1::User"
+/// - `::Api::User` (absolute path with COLON3) → "Api::User"
+pub(crate) fn extract_constant_path(node: &Node) -> Option<String> {
+    // Simple constant read: `User`
+    if let Some(constant_read) = node.as_constant_read_node() {
+        return Some(String::from_utf8_lossy(constant_read.name().as_slice()).to_string());
+    }
+
+    // Constant path: `Api::User` or `Api::V1::User`
+    if let Some(constant_path) = node.as_constant_path_node() {
+        // name() returns Option<ConstantId>, use as_slice() to get &[u8]
+        let name = constant_path
+            .name()
+            .map(|id| String::from_utf8_lossy(id.as_slice()).to_string())?;
+
+        // Get parent path if exists
+        if let Some(parent_node) = constant_path.parent() {
+            if let Some(parent_path) = extract_constant_path(&parent_node) {
+                return Some(format!("{}::{}", parent_path, name));
+            }
+        }
+
+        // No parent (absolute path like `::User`)
+        return Some(name);
     }
+
+    None
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::graph::ChangeSet;
+    use crate::parser::ParseSession;
+    use crate::types::Type;
 
     #[test]
     fn test_enter_exit_class_scope() {
@@ -49,6 +190,20 @@ mod tests {
         assert_eq!(genv.scope_manager.current_class_name(), None);
     }
 
+    #[test]
+    fn test_enter_exit_module_scope() {
+        let mut genv = GlobalEnv::new();
+
+        install_module(&mut genv, "Utils".to_string());
+        assert_eq!(
+            genv.scope_manager.current_module_name(),
+            Some("Utils".to_string())
+        );
+
+        exit_scope(&mut genv);
+        assert_eq!(genv.scope_manager.current_module_name(), None);
+    }
+
     #[test]
     fn test_nested_method_scope() {
         let mut genv = GlobalEnv::new();
@@ -67,4 +222,116 @@ mod tests {
 
         assert_eq!(genv.scope_manager.current_class_name(), None);
     }
+
+    #[test]
+    fn test_method_in_module() {
+        let mut genv = GlobalEnv::new();
+
+        install_module(&mut genv, "Helpers".to_string());
+        install_method(&mut genv, "format".to_string());
+
+        // Should find module context from within method
+        assert_eq!(
+            genv.scope_manager.current_module_name(),
+            Some("Helpers".to_string())
+        );
+
+        exit_scope(&mut genv); // exit method
+        exit_scope(&mut genv); // exit module
+
+        assert_eq!(genv.scope_manager.current_module_name(), None);
+    }
+
+    #[test]
+    fn test_extract_simple_class_name() {
+        let source = "class User; end";
+        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 stmt = program.statements().body().first().unwrap();
+        let class_node = stmt.as_class_node().unwrap();
+
+        let name = extract_class_name(&class_node);
+        assert_eq!(name, "User");
+    }
+
+    #[test]
+    fn test_extract_qualified_class_name() {
+        let source = "class Api::User; end";
+        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 stmt = program.statements().body().first().unwrap();
+        let class_node = stmt.as_class_node().unwrap();
+
+        let name = extract_class_name(&class_node);
+        assert_eq!(name, "Api::User");
+    }
+
+    #[test]
+    fn test_extract_deeply_qualified_class_name() {
+        let source = "class Api::V1::Admin::User; end";
+        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 stmt = program.statements().body().first().unwrap();
+        let class_node = stmt.as_class_node().unwrap();
+
+        let name = extract_class_name(&class_node);
+        assert_eq!(name, "Api::V1::Admin::User");
+    }
+
+    #[test]
+    fn test_extract_simple_module_name() {
+        let source = "module Utils; end";
+        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 stmt = program.statements().body().first().unwrap();
+        let module_node = stmt.as_module_node().unwrap();
+
+        let name = extract_module_name(&module_node);
+        assert_eq!(name, "Utils");
+    }
+
+    #[test]
+    fn test_extract_qualified_module_name() {
+        let source = "module Api::V1; end";
+        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 stmt = program.statements().body().first().unwrap();
+        let module_node = stmt.as_module_node().unwrap();
+
+        let name = extract_module_name(&module_node);
+        assert_eq!(name, "Api::V1");
+    }
+
+    #[test]
+    fn test_process_def_node_registers_user_method() {
+        let source = "class User; def name; \"Alice\"; end; end";
+        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();
+
+        let stmt = program.statements().body().first().unwrap();
+        let class_node = stmt.as_class_node().unwrap();
+        process_class_node(&mut genv, &mut lenv, &mut changes, source, &class_node);
+
+        // User#name should be registered as a user-defined method
+        let info = genv
+            .resolve_method(&Type::instance("User"), "name")
+            .expect("User#name should be registered");
+        assert!(info.return_vertex.is_some());
+    }
 }