Add receiver to MethodAliasDefinition

alias_method can be called on a specific class, like
Foo.alias_method(:new, :old), where the alias belongs to Foo
rather than the enclosing scope. To handle this, we now store
the receiver on MethodAliasDefinition so the resolver knows
which class owns the alias.

Since alias_method always creates instance aliases (unlike
def Foo.bar which targets the singleton class), constant
receivers resolve to the class itself.

Author: alexcrocha

rust/rubydex/src/indexing/ruby_indexer.rs

@@ -361,34 +361,31 @@ impl<'a> RubyIndexer<'a> {
         })
     }
 
-    // Runs the given closure if the given call `node` is invoked directly on `self` for each one of its string or
-    // symbol arguments
+    // Runs the given closure for each string or symbol argument in the given call `node`
     fn each_string_or_symbol_arg<F>(node: &ruby_prism::CallNode, mut f: F)
     where
         F: FnMut(String, ruby_prism::Location),
     {
-        let receiver = node.receiver();
+        let Some(arguments) = node.arguments() else {
+            return;
+        };
 
-        if (receiver.is_none() || receiver.unwrap().as_self_node().is_some())
-            && let Some(arguments) = node.arguments()
-        {
-            for argument in &arguments.arguments() {
-                match argument {
-                    ruby_prism::Node::SymbolNode { .. } => {
-                        let symbol = argument.as_symbol_node().unwrap();
-
-                        if let Some(value_loc) = symbol.value_loc() {
-                            let name = Self::location_to_string(&value_loc);
-                            f(name, value_loc);
-                        }
-                    }
-                    ruby_prism::Node::StringNode { .. } => {
-                        let string = argument.as_string_node().unwrap();
-                        let name = String::from_utf8_lossy(string.unescaped()).to_string();
-                        f(name, argument.location());
+        for argument in &arguments.arguments() {
+            match argument {
+                ruby_prism::Node::SymbolNode { .. } => {
+                    let symbol = argument.as_symbol_node().unwrap();
+
+                    if let Some(value_loc) = symbol.value_loc() {
+                        let name = Self::location_to_string(&value_loc);
+                        f(name, value_loc);
                     }
-                    _ => {}
                 }
+                ruby_prism::Node::StringNode { .. } => {
+                    let string = argument.as_string_node().unwrap();
+                    let name = String::from_utf8_lossy(string.unescaped()).to_string();
+                    f(name, argument.location());
+                }
+                _ => {}
             }
         }
     }
@@ -1104,11 +1101,22 @@ impl<'a> RubyIndexer<'a> {
             return Some(name_id);
         }
 
+        let new_name_id = self.create_singleton_name_id(name_id);
+
+        let location = receiver.map_or(fallback_location, ruby_prism::Node::location);
+        let offset = Offset::from_prism_location(&location);
+        self.local_graph
+            .add_constant_reference(ConstantReference::new(new_name_id, self.uri_id, offset));
+        Some(new_name_id)
+    }
+
+    /// Creates a singleton class `NameId` (`<ClassName>`) attached to the given constant `NameId`.
+    fn create_singleton_name_id(&mut self, attached_name_id: NameId) -> NameId {
         let singleton_class_name = {
             let name = self
                 .local_graph
                 .names()
-                .get(&name_id)
+                .get(&attached_name_id)
                 .expect("Indexed constant name should exist");
 
             let target_str = self
@@ -1121,15 +1129,8 @@ impl<'a> RubyIndexer<'a> {
         };
 
         let string_id = self.local_graph.intern_string(singleton_class_name);
-        let new_name_id = self
-            .local_graph
-            .add_name(Name::new(string_id, ParentScope::Attached(name_id), None));
-
-        let location = receiver.map_or(fallback_location, ruby_prism::Node::location);
-        let offset = Offset::from_prism_location(&location);
         self.local_graph
-            .add_constant_reference(ConstantReference::new(new_name_id, self.uri_id, offset));
-        Some(new_name_id)
+            .add_name(Name::new(string_id, ParentScope::Attached(attached_name_id), None))
     }
 }
 
@@ -1540,6 +1541,11 @@ impl Visit<'_> for RubyIndexer<'_> {
         }
 
         let mut index_attr = |kind: AttrKind, call: &ruby_prism::CallNode| {
+            let receiver = call.receiver();
+            if receiver.as_ref().is_some_and(|r| r.as_self_node().is_none()) {
+                return;
+            }
+
             let call_offset = Offset::from_prism_location(&call.location());
 
             Self::each_string_or_symbol_arg(call, |name, location| {
@@ -1653,8 +1659,23 @@ impl Visit<'_> for RubyIndexer<'_> {
                 let new_name_str_id = self.local_graph.intern_string(format!("{new_name}()"));
                 let old_name_str_id = self.local_graph.intern_string(format!("{old_name}()"));
 
-                let method_receiver = self.method_receiver(node.receiver().as_ref(), node.location());
-                let reference = MethodRef::new(old_name_str_id, self.uri_id, old_offset.clone(), method_receiver);
+                let receiver_node = node.receiver();
+                let receiver = receiver_node.as_ref().and_then(|node| match node {
+                    ruby_prism::Node::ConstantPathNode { .. } | ruby_prism::Node::ConstantReadNode { .. } => self
+                        .index_constant_reference(node, true)
+                        .map(Receiver::ConstantReceiver),
+                    _ => None,
+                });
+
+                // alias_method references instance methods, so we use the class NameId directly
+                let method_ref_receiver = match &receiver {
+                    Some(Receiver::ConstantReceiver(name_id)) => Some(*name_id),
+                    Some(Receiver::SelfReceiver(_)) | None => {
+                        self.method_receiver(receiver_node.as_ref(), node.location())
+                    }
+                };
+
+                let reference = MethodRef::new(old_name_str_id, self.uri_id, old_offset.clone(), method_ref_receiver);
                 self.local_graph.add_method_reference(reference);
 
                 let offset = Offset::from_prism_location(&node.location());
@@ -1668,6 +1689,7 @@ impl Visit<'_> for RubyIndexer<'_> {
                     comments,
                     flags,
                     self.current_nesting_definition_id(),
+                    receiver,
                 )));
 
                 let definition_id = self.local_graph.add_definition(definition);
@@ -1978,6 +2000,7 @@ impl Visit<'_> for RubyIndexer<'_> {
             comments,
             flags,
             self.current_nesting_definition_id(),
+            None,
         )));
 
         let definition_id = self.local_graph.add_definition(definition);
@@ -4909,6 +4932,105 @@ mod tests {
         });
     }
 
+    #[test]
+    fn index_alias_method_with_constant_receiver() {
+        let context = index_source({
+            "
+            class Foo
+              def bar; end
+            end
+
+            Foo.alias_method :baz, :bar
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "5:1-5:28", MethodAlias, |def| {
+            let new_name = context.graph().strings().get(def.new_name_str_id()).unwrap();
+            let old_name = context.graph().strings().get(def.old_name_str_id()).unwrap();
+            assert_eq!(new_name.as_str(), "baz()");
+            assert_eq!(old_name.as_str(), "bar()");
+
+            match def.receiver() {
+                Some(Receiver::ConstantReceiver(name_id)) => {
+                    let name = context.graph().names().get(name_id).unwrap();
+                    let actual_name = context.graph().strings().get(name.str()).unwrap().as_str();
+                    assert_eq!(actual_name, "Foo");
+                }
+                other => panic!("Expected ConstantReceiver, got {other:?}"),
+            }
+        });
+
+        let method_ref = context
+            .graph()
+            .method_references()
+            .values()
+            .find(|m| context.graph().strings().get(m.str()).unwrap().as_str() == "bar()")
+            .expect("should have a method reference for bar()");
+
+        let receiver = context.graph().names().get(&method_ref.receiver().unwrap()).unwrap();
+        assert_eq!(context.graph().strings().get(receiver.str()).unwrap().as_str(), "Foo");
+    }
+
+    #[test]
+    fn index_alias_method_with_constant_path_receiver() {
+        let context = index_source({
+            "
+            module Outer
+              class Inner
+                def bar; end
+              end
+            end
+
+            Outer::Inner.alias_method :baz, :bar
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "7:1-7:37", MethodAlias, |def| {
+            let new_name = context.graph().strings().get(def.new_name_str_id()).unwrap();
+            let old_name = context.graph().strings().get(def.old_name_str_id()).unwrap();
+            assert_eq!(new_name.as_str(), "baz()");
+            assert_eq!(old_name.as_str(), "bar()");
+
+            match def.receiver() {
+                Some(Receiver::ConstantReceiver(name_id)) => {
+                    let name = context.graph().names().get(name_id).unwrap();
+                    let actual_name = context.graph().strings().get(name.str()).unwrap().as_str();
+                    assert_eq!(actual_name, "Inner");
+                }
+                other => panic!("Expected ConstantReceiver, got {other:?}"),
+            }
+        });
+    }
+
+    #[test]
+    fn index_alias_method_with_self_receiver_has_no_receiver() {
+        let context = index_source({
+            "
+            class Foo
+              self.alias_method :baz, :bar
+            end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "1:1-3:4", Class, |foo_class_def| {
+            assert_definition_at!(&context, "2:3-2:31", MethodAlias, |def| {
+                let new_name = context.graph().strings().get(def.new_name_str_id()).unwrap();
+                let old_name = context.graph().strings().get(def.old_name_str_id()).unwrap();
+                assert_eq!(new_name.as_str(), "baz()");
+                assert_eq!(old_name.as_str(), "bar()");
+
+                assert!(def.receiver().is_none());
+                assert_eq!(foo_class_def.id(), def.lexical_nesting_id().unwrap());
+            });
+        });
+    }
+
     #[test]
     fn index_alias_global_variables() {
         let context = index_source({

rust/rubydex/src/model/definitions.rs

@@ -724,7 +724,7 @@ pub struct MethodDefinition {
 assert_mem_size!(MethodDefinition, 112);
 
 /// The receiver of a singleton method definition.
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy)]
 pub enum Receiver {
     /// `def self.foo` - receiver is the enclosing definition (class, module, singleton class or DSL)
     SelfReceiver(DefinitionId),
@@ -734,6 +734,16 @@ pub enum Receiver {
 
 assert_mem_size!(Receiver, 16);
 
+impl Receiver {
+    /// Appends the receiver's inner ID to the given string for `DefinitionId` hashing.
+    pub fn append_to_id(&self, formatted_id: &mut String) {
+        match self {
+            Receiver::SelfReceiver(def_id) => formatted_id.push_str(&def_id.to_string()),
+            Receiver::ConstantReceiver(name_id) => formatted_id.push_str(&name_id.to_string()),
+        }
+    }
+}
+
 impl MethodDefinition {
     #[allow(clippy::too_many_arguments)]
     #[must_use]
@@ -766,12 +776,7 @@ impl MethodDefinition {
         let mut formatted_id = format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id);
 
         if let Some(receiver) = &self.receiver {
-            match receiver {
-                Receiver::SelfReceiver(def_id) => formatted_id.push_str(&def_id.to_string()),
-                Receiver::ConstantReceiver(name_id) => {
-                    formatted_id.push_str(&name_id.to_string());
-                }
-            }
+            receiver.append_to_id(&mut formatted_id);
         }
 
         DefinitionId::from(&formatted_id)
@@ -1332,11 +1337,13 @@ pub struct MethodAliasDefinition {
     flags: DefinitionFlags,
     comments: Vec<Comment>,
     lexical_nesting_id: Option<DefinitionId>,
+    receiver: Option<Receiver>,
 }
-assert_mem_size!(MethodAliasDefinition, 80);
+assert_mem_size!(MethodAliasDefinition, 96);
 
 impl MethodAliasDefinition {
     #[must_use]
+    #[allow(clippy::too_many_arguments)]
     pub const fn new(
         new_name_str_id: StringId,
         old_name_str_id: StringId,
@@ -1345,6 +1352,7 @@ impl MethodAliasDefinition {
         comments: Vec<Comment>,
         flags: DefinitionFlags,
         lexical_nesting_id: Option<DefinitionId>,
+        receiver: Option<Receiver>,
     ) -> Self {
         Self {
             new_name_str_id,
@@ -1354,18 +1362,25 @@ impl MethodAliasDefinition {
             flags,
             comments,
             lexical_nesting_id,
+            receiver,
         }
     }
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!(
+        let mut formatted_id = format!(
             "{}{}{}{}",
             *self.uri_id,
             self.offset.start(),
             *self.new_name_str_id,
             *self.old_name_str_id,
-        ))
+        );
+
+        if let Some(receiver) = &self.receiver {
+            receiver.append_to_id(&mut formatted_id);
+        }
+
+        DefinitionId::from(&formatted_id)
     }
 
     #[must_use]
@@ -1402,6 +1417,11 @@ impl MethodAliasDefinition {
     pub fn flags(&self) -> &DefinitionFlags {
         &self.flags
     }
+
+    #[must_use]
+    pub fn receiver(&self) -> &Option<Receiver> {
+        &self.receiver
+    }
 }
 
 #[derive(Debug)]