method-ray 0.1.9 → 0.1.10

data/core/src/analyzer/dispatch.rs

@@ -59,14 +59,14 @@ pub(crate) fn collect_arguments<'a>(
 
 /// Kind of attr_* declaration
 #[derive(Debug, Clone, Copy)]
-pub enum AttrKind {
+pub(crate) enum AttrKind {
     Reader,
     Writer,
     Accessor,
 }
 
 /// Result of dispatching a simple node (no child processing needed)
-pub enum DispatchResult {
+pub(crate) enum DispatchResult {
     /// Node produced a vertex
     Vertex(VertexId),
     /// Node was not handled
@@ -74,7 +74,7 @@ pub enum DispatchResult {
 }
 
 /// Kind of child processing needed
-pub enum NeedsChildKind<'a> {
+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
@@ -88,6 +88,8 @@ pub enum NeedsChildKind<'a> {
         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 {
@@ -101,17 +103,25 @@ pub enum NeedsChildKind<'a> {
         kind: AttrKind,
         attr_names: Vec<String>,
     },
-    /// include declaration: `include Greetable, Enumerable`
-    IncludeDeclaration {
+    /// 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 fn dispatch_simple(genv: &mut GlobalEnv, lenv: &mut LocalEnv, node: &Node) -> DispatchResult {
+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());
@@ -172,8 +182,21 @@ fn extract_symbol_names(call_node: &ruby_prism::CallNode) -> Vec<String> {
         .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 fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<NeedsChildKind<'a>> {
+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());
@@ -215,6 +238,7 @@ pub fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<NeedsCh
                 location,
                 block,
                 arguments,
+                safe_navigation: call_node.is_safe_navigation(),
             });
         } else {
             // No receiver: implicit self method call (e.g., `name`, `puts "hello"`)
@@ -232,21 +256,16 @@ 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();
+            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::IncludeDeclaration { module_names });
+                    return Some(NeedsChildKind::ModuleMixinDeclaration { module_names, kind });
                 }
                 return None;
             }
@@ -296,11 +315,12 @@ pub(crate) fn process_needs_child(
             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 },
+                MethodCallContext { recv_vtx, method_name, location, block, arguments, safe_navigation },
             )
         }
         NeedsChildKind::ImplicitSelfCall {
@@ -317,19 +337,23 @@ pub(crate) fn process_needs_child(
             };
             process_method_call_common(
                 genv, lenv, changes, source,
-                MethodCallContext { recv_vtx, method_name, location, block, arguments },
+                // 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::IncludeDeclaration { module_names } => {
+        NeedsChildKind::ModuleMixinDeclaration { module_names, kind } => {
             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),
+                // 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() {
-                    genv.record_include(&class_name, module_name);
+                    match kind {
+                        MixinKind::Include => genv.record_include(&class_name, module_name),
+                        MixinKind::Extend => genv.record_extend(&class_name, module_name),
+                    }
                 }
             }
             None
@@ -360,6 +384,7 @@ struct MethodCallContext<'a> {
     location: SourceLocation,
     block: Option<Node<'a>>,
     arguments: Vec<Node<'a>>,
+    safe_navigation: bool,
 }
 
 /// MethodCall / ImplicitSelfCall common processing:
@@ -377,6 +402,7 @@ fn process_method_call_common<'a>(
         location,
         block,
         arguments,
+        safe_navigation,
     } = ctx;
     if method_name == "!" {
         return Some(super::operators::process_not_operator(genv));
@@ -411,6 +437,7 @@ fn process_method_call_common<'a>(
         positional_arg_vtxs,
         kwarg_vtxs,
         location,
+        safe_navigation,
     ))
 }
 
@@ -422,980 +449,7 @@ fn finish_method_call(
     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))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::analyzer::install::AstInstaller;
-    use crate::parser::ParseSession;
-
-    /// Helper: parse Ruby source, process with AstInstaller, and return GlobalEnv
-    fn analyze(source: &str) -> GlobalEnv {
-        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 installer = AstInstaller::new(&mut genv, &mut lenv, source);
-        for stmt in &program.statements().body() {
-            installer.install_node(&stmt);
-        }
-        installer.finish();
-
-        genv
-    }
-
-    /// Helper: get the type string for a vertex ID (checks both Vertex and Source)
-    fn get_type_show(genv: &GlobalEnv, vtx: VertexId) -> String {
-        if let Some(vertex) = genv.get_vertex(vtx) {
-            vertex.show()
-        } else if let Some(source) = genv.get_source(vtx) {
-            source.ty.show()
-        } else {
-            panic!("vertex {:?} not found as either Vertex or Source", vtx);
-        }
-    }
-
-    // Test 1: Receiverless method call type resolution
-    #[test]
-    fn test_implicit_self_call_type_resolution() {
-        let source = r#"
-class User
-  def name
-    "Alice"
-  end
-
-  def greet
-    name
-  end
-end
-"#;
-        let genv = analyze(source);
-
-        // User#greet should resolve to String via User#name
-        let info = genv
-            .resolve_method(&Type::instance("User"), "greet")
-            .expect("User#greet should be registered");
-        assert!(info.return_vertex.is_some());
-
-        let ret_vtx = info.return_vertex.unwrap();
-        assert_eq!(get_type_show(&genv, ret_vtx), "String");
-    }
-
-    // Test 2: Receiverless method call with arguments
-    #[test]
-    fn test_implicit_self_call_with_arguments() {
-        let source = r#"
-class Calculator
-  def add(x, y)
-    x
-  end
-
-  def compute
-    add(1, 2)
-  end
-end
-"#;
-        let genv = analyze(source);
-
-        // Calculator#compute should resolve via Calculator#add
-        let info = genv
-            .resolve_method(&Type::instance("Calculator"), "compute")
-            .expect("Calculator#compute should be registered");
-        assert!(info.return_vertex.is_some());
-
-        let ret_vtx = info.return_vertex.unwrap();
-        assert_eq!(get_type_show(&genv, ret_vtx), "Integer");
-    }
-
-    // Test 3: Receiverless call in nested class
-    #[test]
-    fn test_implicit_self_call_in_nested_class() {
-        let source = r#"
-module Api
-  module V1
-    class User
-      def name
-        "Alice"
-      end
-
-      def greet
-        name
-      end
-    end
-  end
-end
-"#;
-        let genv = analyze(source);
-
-        // Method registered with qualified name "Api::V1::User"
-        let info = genv
-            .resolve_method(&Type::instance("Api::V1::User"), "greet")
-            .expect("Api::V1::User#greet should be registered");
-        assert!(info.return_vertex.is_some());
-
-        let ret_vtx = info.return_vertex.unwrap();
-        assert_eq!(get_type_show(&genv, ret_vtx), "String");
-    }
-
-    // Test 4: Receiverless call in module
-    #[test]
-    fn test_implicit_self_call_in_module() {
-        let source = r#"
-module Utils
-  def self.format(value)
-    value
-  end
-
-  def self.run
-    format("test")
-  end
-end
-"#;
-        let genv = analyze(source);
-
-        // Utils.run should be registered
-        let info = genv
-            .resolve_method(&Type::singleton("Utils"), "run")
-            .expect("Utils.run should be registered");
-        assert!(info.return_vertex.is_some());
-    }
-
-    // Test 5: Receiverless call from within block
-    #[test]
-    fn test_implicit_self_call_from_block() {
-        let source = r#"
-class User
-  def name
-    "Alice"
-  end
-
-  def greet
-    [1].each { name }
-  end
-end
-"#;
-        let genv = analyze(source);
-
-        // User#name should be registered and resolve to String
-        let name_info = genv
-            .resolve_method(&Type::instance("User"), "name")
-            .expect("User#name should be registered");
-        assert!(name_info.return_vertex.is_some());
-        assert_eq!(get_type_show(&genv, name_info.return_vertex.unwrap()), "String");
-
-        // User#greet should also be registered (block contains implicit self call)
-        let greet_info = genv
-            .resolve_method(&Type::instance("User"), "greet")
-            .expect("User#greet should be registered");
-        assert!(greet_info.return_vertex.is_some());
-    }
-
-    // Test 6: Top-level receiverless call (Object receiver)
-    #[test]
-    fn test_implicit_self_call_at_top_level() {
-        let source = r#"
-def helper
-  "result"
-end
-
-helper
-"#;
-        let genv = analyze(source);
-
-        // Should not panic; top-level call uses Object as receiver type
-        // NOTE: top-level def is not registered in method_registry yet,
-        // so this will produce a type error (false positive).
-        // The important thing is that it doesn't panic.
-        // No panic is the real assertion - top-level call should be processed without error
-        let _ = genv;
-    }
-
-    // Test 7: attr_reader basic — getter type resolution
-    #[test]
-    fn test_attr_reader_basic() {
-        let source = r#"
-class User
-  attr_reader :name
-
-  def initialize
-    @name = "Alice"
-  end
-end
-"#;
-        let genv = analyze(source);
-
-        // User#name should be registered and resolve to String via @name
-        let info = genv
-            .resolve_method(&Type::instance("User"), "name")
-            .expect("User#name should be registered");
-        assert!(info.return_vertex.is_some());
-        let ret_vtx = info.return_vertex.unwrap();
-        assert_eq!(get_type_show(&genv, ret_vtx), "String");
-
-        // Other methods still work
-        let greet_src = r#"
-class User
-  attr_reader :name
-
-  def greet
-    "hello"
-  end
-end
-"#;
-        let genv2 = analyze(greet_src);
-        let info2 = genv2
-            .resolve_method(&Type::instance("User"), "greet")
-            .expect("User#greet should be registered");
-        assert_eq!(get_type_show(&genv2, info2.return_vertex.unwrap()), "String");
-    }
-
-    // Test 8: attr_reader + self.name method call
-    #[test]
-    fn test_attr_reader_with_self_call() {
-        let source = r#"
-class User
-  attr_reader :name
-
-  def initialize
-    @name = "Alice"
-  end
-
-  def greet
-    self.name
-  end
-end
-"#;
-        let genv = analyze(source);
-
-        // User#greet should resolve to String via User#name → @name
-        let info = genv
-            .resolve_method(&Type::instance("User"), "greet")
-            .expect("User#greet should be registered");
-        assert!(info.return_vertex.is_some());
-        let ret_vtx = info.return_vertex.unwrap();
-        assert_eq!(get_type_show(&genv, ret_vtx), "String");
-    }
-
-    // Test 9: attr_reader + receiverless name call (proposal D integration)
-    #[test]
-    fn test_attr_reader_receiverless_call() {
-        let source = r#"
-class User
-  attr_reader :name
-
-  def initialize
-    @name = "Alice"
-  end
-
-  def greet
-    name
-  end
-end
-"#;
-        let genv = analyze(source);
-
-        // User#greet should resolve to String via implicit self → User#name → @name
-        let info = genv
-            .resolve_method(&Type::instance("User"), "greet")
-            .expect("User#greet should be registered");
-        assert!(info.return_vertex.is_some());
-        let ret_vtx = info.return_vertex.unwrap();
-        assert_eq!(get_type_show(&genv, ret_vtx), "String");
-    }
-
-    // Test 10: attr_accessor — both getter and setter
-    #[test]
-    fn test_attr_accessor() {
-        let source = r#"
-class User
-  attr_accessor :age
-
-  def initialize
-    @age = 30
-  end
-end
-"#;
-        let genv = analyze(source);
-
-        // User#age (getter) should be registered and resolve to Integer
-        let getter = genv
-            .resolve_method(&Type::instance("User"), "age")
-            .expect("User#age getter should be registered");
-        assert!(getter.return_vertex.is_some());
-        assert_eq!(get_type_show(&genv, getter.return_vertex.unwrap()), "Integer");
-
-        // User#age= (setter) should also be registered
-        let setter = genv
-            .resolve_method(&Type::instance("User"), "age=")
-            .expect("User#age= setter should be registered");
-        assert!(setter.return_vertex.is_some());
-    }
-
-    // Test 11: multiple attributes in single declaration
-    #[test]
-    fn test_attr_reader_multiple() {
-        let source = r#"
-class User
-  attr_reader :name, :email
-
-  def initialize
-    @name = "Alice"
-    @email = "alice@test.com"
-  end
-end
-"#;
-        let genv = analyze(source);
-
-        let name_info = genv
-            .resolve_method(&Type::instance("User"), "name")
-            .expect("User#name should be registered");
-        assert_eq!(get_type_show(&genv, name_info.return_vertex.unwrap()), "String");
-
-        let email_info = genv
-            .resolve_method(&Type::instance("User"), "email")
-            .expect("User#email should be registered");
-        assert_eq!(get_type_show(&genv, email_info.return_vertex.unwrap()), "String");
-    }
-
-    // Test 12: attr_reader in nested class
-    #[test]
-    fn test_attr_reader_nested_class() {
-        let source = r#"
-module Api
-  class User
-    attr_reader :name
-
-    def initialize
-      @name = "Alice"
-    end
-  end
-end
-"#;
-        let genv = analyze(source);
-
-        // Registered with qualified name "Api::User"
-        let info = genv
-            .resolve_method(&Type::instance("Api::User"), "name")
-            .expect("Api::User#name should be registered");
-        assert!(info.return_vertex.is_some());
-        assert_eq!(get_type_show(&genv, info.return_vertex.unwrap()), "String");
-    }
-
-    // Test 13: attr_writer only — setter registered, getter not
-    #[test]
-    fn test_attr_writer_only() {
-        let source = r#"
-class User
-  attr_writer :name
-end
-"#;
-        let genv = analyze(source);
-
-        // User#name= should be registered
-        let setter = genv.resolve_method(&Type::instance("User"), "name=");
-        assert!(setter.is_some(), "User#name= should be registered");
-
-        // User#name (getter) should NOT be registered
-        let getter = genv.resolve_method(&Type::instance("User"), "name");
-        assert!(getter.is_none(), "User#name getter should NOT be registered for attr_writer");
-    }
-
-    // Test 14: attr_reader with no assignment (empty vertex)
-    #[test]
-    fn test_attr_reader_unassigned() {
-        let source = r#"
-class User
-  attr_reader :unknown
-end
-"#;
-        let genv = analyze(source);
-
-        // User#unknown should be registered (with empty vertex)
-        let info = genv
-            .resolve_method(&Type::instance("User"), "unknown")
-            .expect("User#unknown should be registered");
-        assert!(info.return_vertex.is_some());
-    }
-
-    // Test 15: super call independence (SuperNode is not CallNode)
-    #[test]
-    fn test_super_call_independence() {
-        let source = r#"
-class Base
-  def greet
-    "hello"
-  end
-end
-
-class Child < Base
-  def greet
-    super
-  end
-end
-"#;
-        let genv = analyze(source);
-
-        // super is a SuperNode, not a CallNode, so ImplicitSelfCall should not be triggered.
-        // Base#greet should still work.
-        let info = genv
-            .resolve_method(&Type::instance("Base"), "greet")
-            .expect("Base#greet should be registered");
-        assert!(info.return_vertex.is_some());
-
-        let ret_vtx = info.return_vertex.unwrap();
-        assert_eq!(get_type_show(&genv, ret_vtx), "String");
-    }
-
-    // Test 16: User.new → instance(User)
-    #[test]
-    fn test_constant_read_user_new() {
-        let source = r#"
-class User
-  def name
-    "Alice"
-  end
-end
-
-x = User.new
-"#;
-        let genv = analyze(source);
-        assert!(
-            genv.type_errors.is_empty(),
-            "User.new should not produce type errors: {:?}",
-            genv.type_errors
-        );
-    }
-
-    // Test 17: User.new.name → String
-    #[test]
-    fn test_constant_read_user_new_method_chain() {
-        let source = r#"
-class User
-  def name
-    "Alice"
-  end
-end
-
-x = User.new.name
-"#;
-        let genv = analyze(source);
-        assert!(
-            genv.type_errors.is_empty(),
-            "User.new.name should not produce type errors: {:?}",
-            genv.type_errors
-        );
-    }
-
-    // Test 18: Api::User.new → instance(Api::User) (ConstantPathNode)
-    #[test]
-    fn test_constant_path_qualified_new() {
-        let source = r#"
-class Api::User
-  def name
-    "Alice"
-  end
-end
-
-x = Api::User.new
-"#;
-        let genv = analyze(source);
-        assert!(
-            genv.type_errors.is_empty(),
-            "Api::User.new should not produce type errors: {:?}",
-            genv.type_errors
-        );
-    }
-
-    // Test 19: User.new("Alice") → initialize parameter propagation
-    #[test]
-    fn test_constant_read_new_with_initialize_params() {
-        let source = r#"
-class User
-  def initialize(name)
-    @name = name
-  end
-end
-
-x = User.new("Alice")
-"#;
-        let genv = analyze(source);
-        assert!(genv.type_errors.is_empty());
-    }
-
-    // Test 20: user = User.new; user.name → String
-    #[test]
-    fn test_constant_read_assign_and_call() {
-        let source = r#"
-class User
-  def name
-    "Alice"
-  end
-end
-
-user = User.new
-user.name
-"#;
-        let genv = analyze(source);
-        assert!(
-            genv.type_errors.is_empty(),
-            "user = User.new; user.name should not produce type errors: {:?}",
-            genv.type_errors
-        );
-    }
-
-    // Test 21: User.some_method should not produce type error (Singleton error suppression)
-    #[test]
-    fn test_constant_read_no_false_positive() {
-        let source = r#"
-class User
-  def name
-    "Alice"
-  end
-end
-
-User.some_method
-"#;
-        let genv = analyze(source);
-        assert!(
-            genv.type_errors.is_empty(),
-            "User.some_method should not produce type errors (Singleton suppression): {:?}",
-            genv.type_errors
-        );
-    }
-
-    // Test: ConstantPathNode.new resolves with qualified method name
-    #[test]
-    fn test_constant_path_new_with_qualified_method() {
-        let source = r#"
-module Api
-  class User
-    def name
-      "Alice"
-    end
-  end
-end
-
-Api::User.new.name
-"#;
-        let genv = analyze(source);
-        // Api::User.new.name should resolve correctly — no type errors
-        assert!(
-            genv.type_errors.is_empty(),
-            "Api::User.new.name should not produce type errors: {:?}",
-            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");
-    }
-
-    // === 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");
-    }
+    install_method_call(genv, recv_vtx, method_name, arg_vtxs, kwarg_vtxs, Some(location), safe_navigation)
 }