method-ray 0.1.8 → 0.1.10

data/core/src/analyzer/definitions.rs

@@ -0,0 +1,205 @@
+//! Definition Handlers - Processing Ruby class/method/module definitions
+//!
+//! This module is responsible for:
+//! - Class definition scope management (class Foo ... end)
+//! - 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 std::collections::HashMap;
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::types::Type;
+use ruby_prism::Node;
+
+use super::bytes_to_name;
+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);
+    let superclass = class_node.superclass().and_then(|sup| extract_constant_path(&sup));
+
+    // Warn if superclass is a dynamic expression (not a constant path)
+    // TODO: Replace eprintln! with structured diagnostic (record_type_error or warning)
+    //       so this is visible in LSP mode and includes source location.
+    if class_node.superclass().is_some() && superclass.is_none() {
+        eprintln!(
+            "[methodray] warning: dynamic superclass expression in class {}; inheritance will be ignored",
+            class_name
+        );
+    }
+
+    install_class(genv, class_name, superclass.as_deref());
+
+    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 = bytes_to_name(def_node.name().as_slice());
+
+    // Check if this is a class method (def self.foo)
+    let is_class_method = def_node
+        .receiver()
+        .map(|r| r.as_self_node().is_some())
+        .unwrap_or(false);
+
+    install_method(genv, method_name.clone());
+
+    let merge_vtx = genv.scope_manager.current_method_return_vertex();
+
+    // Process parameters BEFORE processing body
+    let (param_vtxs, keyword_param_vtxs) = if let Some(params_node) = def_node.parameters() {
+        install_parameters(genv, lenv, changes, source, &params_node)
+    } else {
+        (vec![], HashMap::new())
+    };
+
+    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);
+        }
+    }
+
+    // Connect last expression to merge vertex so that implicit return
+    // (Ruby's last-expression-is-return-value) is included in the union type
+    if let (Some(last), Some(merge)) = (last_vtx, merge_vtx) {
+        genv.add_edge(last, merge);
+    }
+
+    // Register user-defined method with merge vertex as return vertex
+    let return_vtx = merge_vtx.or(last_vtx);
+    if let Some(ret_vtx) = return_vtx {
+        let recv_type_name = genv.scope_manager.current_qualified_name();
+
+        if let Some(name) = recv_type_name {
+            let recv_type = if is_class_method {
+                Type::singleton(&name)
+            } else {
+                Type::instance(&name)
+            };
+            let kw_params = (!keyword_param_vtxs.is_empty()).then_some(keyword_param_vtxs);
+            genv.register_user_method(
+                recv_type,
+                &method_name,
+                ret_vtx,
+                param_vtxs,
+                kw_params,
+            );
+        }
+    }
+
+    exit_scope(genv);
+    None
+}
+
+/// Install class definition
+fn install_class(genv: &mut GlobalEnv, class_name: String, superclass: Option<&str>) {
+    genv.enter_class(class_name, superclass);
+}
+
+/// Install module definition
+fn install_module(genv: &mut GlobalEnv, module_name: String) {
+    genv.enter_module(module_name);
+}
+
+/// Install method definition
+fn install_method(genv: &mut GlobalEnv, method_name: String) {
+    genv.enter_method(method_name);
+}
+
+/// Exit current scope (class, module, or method)
+fn exit_scope(genv: &mut GlobalEnv) {
+    genv.exit_scope();
+}
+
+/// Extract class name from ClassNode
+/// 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(bytes_to_name(constant_read.name().as_slice()));
+    }
+
+    // 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| bytes_to_name(id.as_slice()))?;
+
+        // 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
+}

data/core/src/analyzer/dispatch.rs

@@ -0,0 +1,455 @@
+//! 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 std::collections::HashMap;
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{BlockParameterTypeBox, ChangeSet, VertexId};
+use crate::source_map::SourceLocation;
+use crate::types::Type;
+use ruby_prism::Node;
+
+use super::bytes_to_name;
+use super::calls::install_method_call;
+use super::variables::{
+    install_ivar_read, install_ivar_write, install_local_var_read, install_local_var_write,
+    install_self,
+};
+
+/// Collect positional and keyword arguments from AST argument nodes.
+///
+/// Shared by method calls (`dispatch.rs`) and super calls (`super_calls.rs`).
+pub(crate) fn collect_arguments<'a>(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    args: impl Iterator<Item = ruby_prism::Node<'a>>,
+) -> (Vec<VertexId>, Option<HashMap<String, VertexId>>) {
+    let mut positional: Vec<VertexId> = Vec::new();
+    let mut keyword: HashMap<String, VertexId> = HashMap::new();
+
+    for arg in args {
+        if let Some(kw_hash) = arg.as_keyword_hash_node() {
+            for element in kw_hash.elements().iter() {
+                let assoc = match element.as_assoc_node() {
+                    Some(a) => a,
+                    None => continue,
+                };
+                let name = match assoc.key().as_symbol_node() {
+                    Some(sym) => bytes_to_name(sym.unescaped()),
+                    None => continue,
+                };
+                if let Some(vtx) =
+                    super::install::install_node(genv, lenv, changes, source, &assoc.value())
+                {
+                    keyword.insert(name, vtx);
+                }
+            }
+        } else if let Some(vtx) = super::install::install_node(genv, lenv, changes, source, &arg) {
+            positional.push(vtx);
+        }
+    }
+
+    let kw = (!keyword.is_empty()).then_some(keyword);
+    (positional, kw)
+}
+
+/// Kind of attr_* declaration
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum AttrKind {
+    Reader,
+    Writer,
+    Accessor,
+}
+
+/// Result of dispatching a simple node (no child processing needed)
+pub(crate) enum DispatchResult {
+    /// Node produced a vertex
+    Vertex(VertexId),
+    /// Node was not handled
+    NotHandled,
+}
+
+/// Kind of child processing needed
+pub(crate) 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,
+        /// Optional block attached to the method call
+        block: Option<Node<'a>>,
+        /// Arguments to the method call
+        arguments: Vec<Node<'a>>,
+        /// Whether this is a safe navigation call (`&.`)
+        safe_navigation: bool,
+    },
+    /// Implicit self method call: method call without explicit receiver (implicit self)
+    ImplicitSelfCall {
+        method_name: String,
+        location: SourceLocation,
+        block: Option<Node<'a>>,
+        arguments: Vec<Node<'a>>,
+    },
+    /// attr_reader / attr_writer / attr_accessor declaration
+    AttrDeclaration {
+        kind: AttrKind,
+        attr_names: Vec<String>,
+    },
+    /// include / extend declaration: `include Greetable`, `extend ClassMethods`
+    ModuleMixinDeclaration {
+        module_names: Vec<String>,
+        kind: MixinKind,
+    },
+}
+
+/// Kind of module mixin (include or extend)
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum MixinKind {
+    Include,
+    Extend,
+}
+
+/// First pass: check if node can be handled immediately without child processing
+///
+/// Note: Literals (including Array) are handled in install.rs via install_literal
+/// because Array literals need child processing for element type inference.
+pub(crate) 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 = bytes_to_name(ivar_read.name().as_slice());
+        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 = bytes_to_name(read_node.name().as_slice());
+        return match install_local_var_read(lenv, &var_name) {
+            Some(vtx) => DispatchResult::Vertex(vtx),
+            None => DispatchResult::NotHandled,
+        };
+    }
+
+    // ConstantReadNode: User → Type::Singleton("User") or Type::Singleton("Api::User")
+    if let Some(const_read) = node.as_constant_read_node() {
+        let name = bytes_to_name(const_read.name().as_slice());
+        let resolved_name = genv.scope_manager.lookup_constant(&name)
+            .unwrap_or(name);
+        let vtx = genv.new_source(Type::singleton(&resolved_name));
+        return DispatchResult::Vertex(vtx);
+    }
+
+    // ConstantPathNode: Api::User → Type::Singleton("Api::User")
+    if node.as_constant_path_node().is_some() {
+        if let Some(name) = super::definitions::extract_constant_path(node) {
+            let vtx = genv.new_source(Type::singleton(&name));
+            return DispatchResult::Vertex(vtx);
+        }
+    }
+
+    DispatchResult::NotHandled
+}
+
+/// Extract symbol names from attr_* arguments (e.g., `attr_reader :name, :email`)
+fn extract_symbol_names(call_node: &ruby_prism::CallNode) -> Vec<String> {
+    call_node
+        .arguments()
+        .map(|args| {
+            args.arguments()
+                .iter()
+                .filter_map(|arg| {
+                    arg.as_symbol_node().map(|sym| {
+                        bytes_to_name(sym.unescaped())
+                    })
+                })
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+/// Extract module names from include/extend arguments
+fn extract_mixin_module_names(call_node: &ruby_prism::CallNode) -> Vec<String> {
+    call_node
+        .arguments()
+        .map(|args| {
+            args.arguments()
+                .iter()
+                .filter_map(|arg| super::definitions::extract_constant_path(&arg))
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+/// Check if node needs child processing
+pub(crate) 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 = bytes_to_name(ivar_write.name().as_slice());
+        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 = bytes_to_name(write_node.name().as_slice());
+        return Some(NeedsChildKind::LocalVarWrite {
+            var_name,
+            value: write_node.value(),
+        });
+    }
+
+    // Method call: x.upcase, x.each { |i| ... }, or name (implicit self)
+    if let Some(call_node) = node.as_call_node() {
+        let method_name = bytes_to_name(call_node.name().as_slice());
+        let block = call_node.block();
+        let arguments: Vec<Node<'a>> = call_node
+            .arguments()
+            .map(|args| args.arguments().iter().collect())
+            .unwrap_or_default();
+
+        if let Some(receiver) = call_node.receiver() {
+            // Explicit receiver: x.upcase, x.each { |i| ... }
+            let prism_location = call_node
+                .call_operator_loc()
+                .unwrap_or_else(|| node.location());
+            let location =
+                SourceLocation::from_prism_location_with_source(&prism_location, source);
+
+            return Some(NeedsChildKind::MethodCall {
+                receiver,
+                method_name,
+                location,
+                block,
+                arguments,
+                safe_navigation: call_node.is_safe_navigation(),
+            });
+        } else {
+            // No receiver: implicit self method call (e.g., `name`, `puts "hello"`)
+
+            if let Some(kind) = match method_name.as_str() {
+                "attr_reader" => Some(AttrKind::Reader),
+                "attr_writer" => Some(AttrKind::Writer),
+                "attr_accessor" => Some(AttrKind::Accessor),
+                _ => None,
+            } {
+                let attr_names = extract_symbol_names(&call_node);
+                if !attr_names.is_empty() {
+                    return Some(NeedsChildKind::AttrDeclaration { kind, attr_names });
+                }
+                return None;
+            }
+
+            let mixin_kind = match method_name.as_str() {
+                "include" => Some(MixinKind::Include),
+                "extend" => Some(MixinKind::Extend),
+                _ => None,
+            };
+
+            if let Some(kind) = mixin_kind {
+                let module_names = extract_mixin_module_names(&call_node);
+                if !module_names.is_empty() {
+                    return Some(NeedsChildKind::ModuleMixinDeclaration { module_names, kind });
+                }
+                return None;
+            }
+
+            let prism_location = call_node
+                .message_loc()
+                .unwrap_or_else(|| node.location());
+            let location =
+                SourceLocation::from_prism_location_with_source(&prism_location, source);
+
+            return Some(NeedsChildKind::ImplicitSelfCall {
+                method_name,
+                location,
+                block,
+                arguments,
+            });
+        }
+    }
+
+    None
+}
+
+/// Process a node that needs child processing
+///
+/// This function handles the second phase of two-phase dispatch:
+/// 1. `dispatch_needs_child` identifies the node kind and extracts data
+/// 2. `process_needs_child` processes child nodes and completes the operation
+pub(crate) fn process_needs_child(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    kind: NeedsChildKind,
+) -> Option<VertexId> {
+    match kind {
+        NeedsChildKind::IvarWrite { ivar_name, value } => {
+            let value_vtx = super::install::install_node(genv, lenv, changes, source, &value)?;
+            Some(finish_ivar_write(genv, ivar_name, value_vtx))
+        }
+        NeedsChildKind::LocalVarWrite { var_name, value } => {
+            let value_vtx = super::install::install_node(genv, lenv, changes, source, &value)?;
+            Some(finish_local_var_write(genv, lenv, changes, var_name, value_vtx))
+        }
+        NeedsChildKind::MethodCall {
+            receiver,
+            method_name,
+            location,
+            block,
+            arguments,
+            safe_navigation,
+        } => {
+            let recv_vtx = super::install::install_node(genv, lenv, changes, source, &receiver)?;
+            process_method_call_common(
+                genv, lenv, changes, source,
+                MethodCallContext { recv_vtx, method_name, location, block, arguments, safe_navigation },
+            )
+        }
+        NeedsChildKind::ImplicitSelfCall {
+            method_name,
+            location,
+            block,
+            arguments,
+        } => {
+            // Use qualified name to match method registration in definitions.rs
+            let recv_vtx = if let Some(name) = genv.scope_manager.current_qualified_name() {
+                genv.new_source(Type::instance(&name))
+            } else {
+                genv.new_source(Type::instance("Object"))
+            };
+            process_method_call_common(
+                genv, lenv, changes, source,
+                // Implicit self calls cannot use safe navigation (`&.` requires explicit receiver)
+                MethodCallContext { recv_vtx, method_name, location, block, arguments, safe_navigation: false },
+            )
+        }
+        NeedsChildKind::AttrDeclaration { kind, attr_names } => {
+            super::attributes::process_attr_declaration(genv, kind, attr_names);
+            None
+        }
+        NeedsChildKind::ModuleMixinDeclaration { module_names, kind } => {
+            if let Some(class_name) = genv.scope_manager.current_qualified_name() {
+                // Ruby processes `include/extend A, B` right-to-left (B first, then A on top),
+                // so A ends up with higher MRO priority. Reverse to match this behavior.
+                for module_name in module_names.iter().rev() {
+                    match kind {
+                        MixinKind::Include => genv.record_include(&class_name, module_name),
+                        MixinKind::Extend => genv.record_extend(&class_name, module_name),
+                    }
+                }
+            }
+            None
+        }
+    }
+}
+
+/// Finish instance variable write after child is processed
+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
+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)
+}
+
+/// Bundled parameters for method call processing
+struct MethodCallContext<'a> {
+    recv_vtx: VertexId,
+    method_name: String,
+    location: SourceLocation,
+    block: Option<Node<'a>>,
+    arguments: Vec<Node<'a>>,
+    safe_navigation: bool,
+}
+
+/// MethodCall / ImplicitSelfCall common processing:
+/// Handles argument processing, block processing, and MethodCallBox creation after recv_vtx is obtained
+fn process_method_call_common<'a>(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    ctx: MethodCallContext<'a>,
+) -> Option<VertexId> {
+    let MethodCallContext {
+        recv_vtx,
+        method_name,
+        location,
+        block,
+        arguments,
+        safe_navigation,
+    } = ctx;
+    if method_name == "!" {
+        return Some(super::operators::process_not_operator(genv));
+    }
+
+    let (positional_arg_vtxs, kwarg_vtxs) =
+        collect_arguments(genv, lenv, changes, source, arguments.into_iter());
+
+    if let Some(block_node) = block {
+        if let Some(block) = block_node.as_block_node() {
+            let param_vtxs = super::blocks::process_block_node_with_params(
+                genv, lenv, changes, source, &block,
+            );
+
+            if !param_vtxs.is_empty() {
+                let box_id = genv.alloc_box_id();
+                let block_box = BlockParameterTypeBox::new(
+                    box_id,
+                    recv_vtx,
+                    method_name.clone(),
+                    param_vtxs,
+                );
+                genv.register_box(box_id, Box::new(block_box));
+            }
+        }
+    }
+
+    Some(finish_method_call(
+        genv,
+        recv_vtx,
+        method_name,
+        positional_arg_vtxs,
+        kwarg_vtxs,
+        location,
+        safe_navigation,
+    ))
+}
+
+/// Finish method call after receiver is processed
+fn finish_method_call(
+    genv: &mut GlobalEnv,
+    recv_vtx: VertexId,
+    method_name: String,
+    arg_vtxs: Vec<VertexId>,
+    kwarg_vtxs: Option<HashMap<String, VertexId>>,
+    location: SourceLocation,
+    safe_navigation: bool,
+) -> VertexId {
+    install_method_call(genv, recv_vtx, method_name, arg_vtxs, kwarg_vtxs, Some(location), safe_navigation)
+}