method-ray 0.1.7 → 0.1.9

data/{rust → core}/src/analyzer/dispatch.rs

@@ -3,6 +3,8 @@
 //! 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;
@@ -16,6 +18,45 @@ use super::variables::{
     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 enum AttrKind {
@@ -60,6 +101,10 @@ pub enum NeedsChildKind<'a> {
         kind: AttrKind,
         attr_names: Vec<String>,
     },
+    /// include declaration: `include Greetable, Enumerable`
+    IncludeDeclaration {
+        module_names: Vec<String>,
+    },
 }
 
 /// First pass: check if node can be handled immediately without child processing
@@ -187,6 +232,25 @@ pub fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<NeedsCh
                 return None;
             }
 
+            if method_name == "include" {
+                let module_names: Vec<String> = call_node
+                    .arguments()
+                    .map(|args| {
+                        args.arguments()
+                            .iter()
+                            .filter_map(|arg| {
+                                super::definitions::extract_constant_path(&arg)
+                            })
+                            .collect()
+                    })
+                    .unwrap_or_default();
+
+                if !module_names.is_empty() {
+                    return Some(NeedsChildKind::IncludeDeclaration { module_names });
+                }
+                return None;
+            }
+
             let prism_location = call_node
                 .message_loc()
                 .unwrap_or_else(|| node.location());
@@ -235,7 +299,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 {
@@ -251,13 +316,24 @@ 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 } => {
             super::attributes::process_attr_declaration(genv, kind, attr_names);
             None
         }
+        NeedsChildKind::IncludeDeclaration { module_names } => {
+            if let Some(class_name) = genv.scope_manager.current_qualified_name() {
+                // Ruby processes `include 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() {
+                    genv.record_include(&class_name, module_name);
+                }
+            }
+            None
+        }
     }
 }
 
@@ -277,6 +353,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>(
@@ -284,16 +369,21 @@ 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));
+    }
+
+    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() {
@@ -315,7 +405,12 @@ fn process_method_call_common<'a>(
     }
 
     Some(finish_method_call(
-        genv, recv_vtx, method_name, arg_vtxs, location,
+        genv,
+        recv_vtx,
+        method_name,
+        positional_arg_vtxs,
+        kwarg_vtxs,
+        location,
     ))
 }
 
@@ -325,9 +420,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)]
@@ -980,4 +1076,326 @@ end
             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");
+    }
+
+    // === Include (mixin) tests ===
+
+    // Test 31: Basic include — module method resolved on class instance
+    #[test]
+    fn test_include_basic() {
+        let source = r#"
+module Greetable
+  def greet
+    "Hello!"
+  end
+end
+
+class User
+  include Greetable
+end
+
+User.new.greet
+"#;
+        let genv = analyze(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "include should resolve Greetable#greet: {:?}",
+            genv.type_errors
+        );
+    }
+
+    // Test 32: Include method return type inference
+    #[test]
+    fn test_include_method_return_type() {
+        let source = r#"
+module Greetable
+  def greet
+    "Hello!"
+  end
+end
+
+class User
+  include Greetable
+
+  def say_hello
+    greet
+  end
+end
+"#;
+        let genv = analyze(source);
+
+        let info = genv
+            .resolve_method(&Type::instance("User"), "say_hello")
+            .expect("User#say_hello should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    // Test 33: Multiple includes — last included module has priority
+    #[test]
+    fn test_include_multiple_modules() {
+        let source = r#"
+module A
+  def foo
+    "from A"
+  end
+end
+
+module B
+  def foo
+    42
+  end
+end
+
+class User
+  include A
+  include B
+end
+
+User.new.foo
+"#;
+        let genv = analyze(source);
+        assert!(genv.type_errors.is_empty());
+
+        // B is included last → B#foo (Integer) should be resolved
+        let info = genv
+            .resolve_method(&Type::instance("User"), "foo")
+            .expect("User#foo should be resolved via include");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "Integer");
+    }
+
+    // Test 34: Class's own method takes priority over included module
+    #[test]
+    fn test_include_class_method_priority() {
+        let source = r#"
+module Greetable
+  def greet
+    "Hello from module!"
+  end
+end
+
+class User
+  include Greetable
+
+  def greet
+    42
+  end
+end
+
+User.new.greet
+"#;
+        let genv = analyze(source);
+
+        let info = genv
+            .resolve_method(&Type::instance("User"), "greet")
+            .expect("User#greet should be resolved");
+        let ret_vtx = info.return_vertex.unwrap();
+        // Class's own method (Integer) takes priority
+        assert_eq!(get_type_show(&genv, ret_vtx), "Integer");
+    }
+
+    // Test 35: Include with qualified module name
+    #[test]
+    fn test_include_qualified_module() {
+        let source = r#"
+module Api
+  module Helpers
+    def help
+      "help"
+    end
+  end
+end
+
+class User
+  include Api::Helpers
+end
+
+User.new.help
+"#;
+        let genv = analyze(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "include Api::Helpers should resolve: {:?}",
+            genv.type_errors
+        );
+    }
+
+    // Test 36: Include with simultaneous multiple modules
+    #[test]
+    fn test_include_simultaneous_multiple() {
+        let source = r#"
+module A
+  def a_method
+    "a"
+  end
+end
+
+module B
+  def b_method
+    42
+  end
+end
+
+class User
+  include A, B
+end
+
+User.new.a_method
+User.new.b_method
+"#;
+        let genv = analyze(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "include A, B should resolve both modules: {:?}",
+            genv.type_errors
+        );
+    }
+
+    // Test 37: Include with unknown module (no crash)
+    #[test]
+    fn test_include_unknown_module() {
+        let source = r#"
+class User
+  include UnknownModule
+end
+"#;
+        let genv = analyze(source);
+        // Should not panic; unknown module is recorded but methods won't resolve
+        let _ = genv;
+    }
+
+    // Test 38: Simultaneous include A, B — A has higher MRO priority (Ruby semantics)
+    #[test]
+    fn test_include_simultaneous_order() {
+        let source = r#"
+module A
+  def foo
+    "from A"
+  end
+end
+
+module B
+  def foo
+    42
+  end
+end
+
+class User
+  include A, B
+end
+
+User.new.foo
+"#;
+        let genv = analyze(source);
+        assert!(genv.type_errors.is_empty());
+
+        // Ruby's `include A, B` processes right-to-left: B first, then A on top.
+        // A has higher MRO priority → A#foo (String) should be resolved.
+        let info = genv
+            .resolve_method(&Type::instance("User"), "foo")
+            .expect("User#foo should be resolved via include");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
 }