method-ray 0.1.6 → 0.1.8

data/rust/src/analyzer/dispatch.rs

@@ -3,12 +3,15 @@
 //! 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,
@@ -68,7 +71,7 @@ pub enum NeedsChildKind<'a> {
 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();
+        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,
@@ -82,17 +85,19 @@ pub fn dispatch_simple(genv: &mut GlobalEnv, lenv: &mut LocalEnv, node: &Node) -
 
     // 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();
+        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")
+    // ConstantReadNode: User → Type::Singleton("User") or Type::Singleton("Api::User")
     if let Some(const_read) = node.as_constant_read_node() {
-        let name = String::from_utf8_lossy(const_read.name().as_slice()).to_string();
-        let vtx = genv.new_source(Type::singleton(&name));
+        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);
     }
 
@@ -116,7 +121,7 @@ fn extract_symbol_names(call_node: &ruby_prism::CallNode) -> Vec<String> {
                 .iter()
                 .filter_map(|arg| {
                     arg.as_symbol_node().map(|sym| {
-                        String::from_utf8_lossy(&sym.unescaped()).to_string()
+                        bytes_to_name(sym.unescaped())
                     })
                 })
                 .collect()
@@ -128,7 +133,7 @@ fn extract_symbol_names(call_node: &ruby_prism::CallNode) -> Vec<String> {
 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();
+        let ivar_name = bytes_to_name(ivar_write.name().as_slice());
         return Some(NeedsChildKind::IvarWrite {
             ivar_name,
             value: ivar_write.value(),
@@ -137,7 +142,7 @@ pub fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<NeedsCh
 
     // 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();
+        let var_name = bytes_to_name(write_node.name().as_slice());
         return Some(NeedsChildKind::LocalVarWrite {
             var_name,
             value: write_node.value(),
@@ -146,7 +151,7 @@ pub fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<NeedsCh
 
     // Method call: x.upcase, x.each { |i| ... }, or name (implicit self)
     if let Some(call_node) = node.as_call_node() {
-        let method_name = String::from_utf8_lossy(call_node.name().as_slice()).to_string();
+        let method_name = bytes_to_name(call_node.name().as_slice());
         let block = call_node.block();
         let arguments: Vec<Node<'a>> = call_node
             .arguments()
@@ -232,7 +237,8 @@ pub(crate) fn process_needs_child(
         } => {
             let recv_vtx = super::install::install_node(genv, lenv, changes, source, &receiver)?;
             process_method_call_common(
-                genv, lenv, changes, source, recv_vtx, method_name, location, block, arguments,
+                genv, lenv, changes, source,
+                MethodCallContext { recv_vtx, method_name, location, block, arguments },
             )
         }
         NeedsChildKind::ImplicitSelfCall {
@@ -248,7 +254,8 @@ pub(crate) fn process_needs_child(
                 genv.new_source(Type::instance("Object"))
             };
             process_method_call_common(
-                genv, lenv, changes, source, recv_vtx, method_name, location, block, arguments,
+                genv, lenv, changes, source,
+                MethodCallContext { recv_vtx, method_name, location, block, arguments },
             )
         }
         NeedsChildKind::AttrDeclaration { kind, attr_names } => {
@@ -274,6 +281,15 @@ fn finish_local_var_write(
     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>>,
+}
+
 /// MethodCall / ImplicitSelfCall common processing:
 /// Handles argument processing, block processing, and MethodCallBox creation after recv_vtx is obtained
 fn process_method_call_common<'a>(
@@ -281,16 +297,44 @@ fn process_method_call_common<'a>(
     lenv: &mut LocalEnv,
     changes: &mut ChangeSet,
     source: &str,
-    recv_vtx: VertexId,
-    method_name: String,
-    location: SourceLocation,
-    block: Option<Node<'a>>,
-    arguments: Vec<Node<'a>>,
+    ctx: MethodCallContext<'a>,
 ) -> Option<VertexId> {
-    let arg_vtxs: Vec<VertexId> = arguments
-        .iter()
-        .filter_map(|arg| super::install::install_node(genv, lenv, changes, source, arg))
-        .collect();
+    let MethodCallContext {
+        recv_vtx,
+        method_name,
+        location,
+        block,
+        arguments,
+    } = ctx;
+    if method_name == "!" {
+        return Some(super::operators::process_not_operator(genv));
+    }
+
+    // Separate positional arguments and keyword arguments
+    let mut positional_arg_vtxs: Vec<VertexId> = Vec::new();
+    let mut keyword_arg_vtxs: HashMap<String, VertexId> = HashMap::new();
+
+    for arg in &arguments {
+        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_arg_vtxs.insert(name, vtx);
+                }
+            }
+        } else if let Some(vtx) = super::install::install_node(genv, lenv, changes, source, arg) {
+            positional_arg_vtxs.push(vtx);
+        }
+    }
 
     if let Some(block_node) = block {
         if let Some(block) = block_node.as_block_node() {
@@ -311,8 +355,19 @@ fn process_method_call_common<'a>(
         }
     }
 
+    let kwarg_vtxs = if keyword_arg_vtxs.is_empty() {
+        None
+    } else {
+        Some(keyword_arg_vtxs)
+    };
+
     Some(finish_method_call(
-        genv, recv_vtx, method_name, arg_vtxs, location,
+        genv,
+        recv_vtx,
+        method_name,
+        positional_arg_vtxs,
+        kwarg_vtxs,
+        location,
     ))
 }
 
@@ -322,9 +377,10 @@ fn finish_method_call(
     recv_vtx: VertexId,
     method_name: String,
     arg_vtxs: Vec<VertexId>,
+    kwarg_vtxs: Option<HashMap<String, VertexId>>,
     location: SourceLocation,
 ) -> VertexId {
-    install_method_call(genv, recv_vtx, method_name, arg_vtxs, Some(location))
+    install_method_call(genv, recv_vtx, method_name, arg_vtxs, kwarg_vtxs, Some(location))
 }
 
 #[cfg(test)]
@@ -463,8 +519,8 @@ end
 
         // Utils.run should be registered
         let info = genv
-            .resolve_method(&Type::instance("Utils"), "run")
-            .expect("Utils#run should be registered");
+            .resolve_method(&Type::singleton("Utils"), "run")
+            .expect("Utils.run should be registered");
         assert!(info.return_vertex.is_some());
     }
 
@@ -893,4 +949,189 @@ Api::User.new.name
             genv.type_errors
         );
     }
+
+    // Test 23: ConstantReadNode inside module resolves to qualified name
+    #[test]
+    fn test_constant_read_inside_module_resolves_qualified() {
+        let source = r#"
+module Api
+  class User
+    def name
+      "Alice"
+    end
+  end
+
+  class Service
+    def run
+      User.new.name
+    end
+  end
+end
+"#;
+        let genv = analyze(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "User.new inside module Api should resolve to Api::User: {:?}",
+            genv.type_errors
+        );
+    }
+
+    // Test 24: ConstantReadNode in deeply nested modules
+    #[test]
+    fn test_constant_read_deeply_nested() {
+        let source = r#"
+module Api
+  module V1
+    class User
+      def name
+        "Alice"
+      end
+    end
+
+    class Service
+      def run
+        User.new.name
+      end
+    end
+  end
+end
+"#;
+        let genv = analyze(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "User.new inside Api::V1 should resolve to Api::V1::User: {:?}",
+            genv.type_errors
+        );
+    }
+
+    // Test 25: Same constant name in different modules
+    #[test]
+    fn test_constant_read_same_name_different_modules() {
+        let source = r#"
+module Api
+  class User
+    def name; "Api User"; end
+  end
+end
+
+module Admin
+  class User
+    def name; "Admin User"; end
+  end
+
+  class Service
+    def run
+      User.new.name
+    end
+  end
+end
+"#;
+        let genv = analyze(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "User.new inside Admin should resolve to Admin::User: {:?}",
+            genv.type_errors
+        );
+    }
+
+    // === Keyword argument tests ===
+
+    // Test 26: Required keyword argument type propagation
+    #[test]
+    fn test_keyword_arg_required_propagation() {
+        let source = r#"
+class Greeter
+  def greet(name:)
+    name
+  end
+end
+
+Greeter.new.greet(name: "Alice")
+"#;
+        let genv = analyze(source);
+
+        let info = genv
+            .resolve_method(&Type::instance("Greeter"), "greet")
+            .expect("Greeter#greet should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    // Test 27: Optional keyword argument with default type
+    #[test]
+    fn test_keyword_arg_optional_default_type() {
+        let source = r#"
+class Counter
+  def count(step: 1)
+    step
+  end
+end
+"#;
+        let genv = analyze(source);
+
+        let info = genv
+            .resolve_method(&Type::instance("Counter"), "count")
+            .expect("Counter#count should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        // step has Integer type from default value
+        assert_eq!(get_type_show(&genv, ret_vtx), "Integer");
+    }
+
+    // Test 28: Positional and keyword arguments mixed
+    #[test]
+    fn test_positional_and_keyword_mixed() {
+        let source = r#"
+class User
+  def initialize(id, name:)
+    @id = id
+    @name = name
+  end
+end
+
+User.new(1, name: "Alice")
+"#;
+        let genv = analyze(source);
+        assert!(genv.type_errors.is_empty());
+    }
+
+    // Test 29: Keyword argument via .new propagation to initialize
+    #[test]
+    fn test_keyword_arg_via_new_to_initialize() {
+        let source = r#"
+class Config
+  def initialize(debug:)
+    @debug = debug
+  end
+
+  def debug?
+    @debug
+  end
+end
+
+Config.new(debug: true)
+"#;
+        let genv = analyze(source);
+        assert!(genv.type_errors.is_empty());
+    }
+
+    // Test 30: Multiple keyword arguments
+    #[test]
+    fn test_multiple_keyword_args() {
+        let source = r#"
+class User
+  def profile(name:, age:)
+    name
+  end
+end
+
+User.new.profile(name: "Alice", age: 30)
+"#;
+        let genv = analyze(source);
+
+        let info = genv
+            .resolve_method(&Type::instance("User"), "profile")
+            .expect("User#profile should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
 }