Index method aliases with RBS indexer

Handle alias and alias self.x self.y declarations in RBS
files. Instance aliases use the enclosing class as owner, while
singleton aliases (self. prefix) use SelfReceiver to route
through the singleton class during resolution

Author: alexcrocha

rust/rubydex/src/indexing/rbs_indexer.rs

@@ -1,16 +1,16 @@
 //! Visit the RBS AST and create type definitions.
 
 use ruby_rbs::node::{
-    self, ClassNode, CommentNode, ConstantNode, ExtendNode, GlobalNode, IncludeNode, ModuleNode, Node, NodeList,
-    PrependNode, TypeNameNode, Visit,
+    self, AliasKind, ClassNode, CommentNode, ConstantNode, ExtendNode, GlobalNode, IncludeNode, ModuleNode, Node,
+    NodeList, PrependNode, TypeNameNode, Visit,
 };
 
 use crate::diagnostic::Rule;
 use crate::indexing::local_graph::LocalGraph;
 use crate::model::comment::Comment;
 use crate::model::definitions::{
     ClassDefinition, ConstantDefinition, Definition, DefinitionFlags, ExtendDefinition, GlobalVariableDefinition,
-    IncludeDefinition, Mixin, ModuleDefinition, PrependDefinition,
+    IncludeDefinition, MethodAliasDefinition, Mixin, ModuleDefinition, PrependDefinition, Receiver,
 };
 use crate::model::document::Document;
 use crate::model::ids::{DefinitionId, NameId, ReferenceId, UriId};
@@ -324,6 +324,37 @@ impl Visit for RBSIndexer<'_> {
             Mixin::Extend(ExtendDefinition::new(ref_id))
         });
     }
+
+    fn visit_alias_node(&mut self, alias_node: &node::AliasNode) {
+        let lexical_nesting_id = self.parent_lexical_scope_id();
+
+        let receiver = match alias_node.kind() {
+            AliasKind::Instance => None,
+            AliasKind::Singleton => lexical_nesting_id.map(Receiver::SelfReceiver),
+        };
+
+        let new_name = Self::bytes_to_string(alias_node.new_name().name());
+        let old_name = Self::bytes_to_string(alias_node.old_name().name());
+
+        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 offset = Offset::from_rbs_location(&alias_node.location());
+        let comments = Self::collect_comments(alias_node.comment());
+
+        let definition = Definition::MethodAlias(Box::new(MethodAliasDefinition::new(
+            new_name_str_id,
+            old_name_str_id,
+            self.uri_id,
+            offset,
+            comments,
+            Self::flags(&alias_node.annotations()),
+            lexical_nesting_id,
+            receiver,
+        )));
+
+        self.register_definition(definition, lexical_nesting_id);
+    }
 }
 
 #[cfg(test)]
@@ -336,6 +367,7 @@ mod tests {
     use crate::{
         assert_def_comments_eq, assert_def_mixins_eq, assert_def_name_eq, assert_def_name_offset_eq, assert_def_str_eq,
         assert_def_superclass_ref_eq, assert_definition_at, assert_local_diagnostics_eq, assert_no_local_diagnostics,
+        assert_string_eq,
     };
 
     fn index_source(source: &str) -> LocalGraphTest {
@@ -714,4 +746,73 @@ mod tests {
             assert!(def.flags().contains(DefinitionFlags::DEPRECATED));
         });
     }
+
+    #[test]
+    fn index_alias_node() {
+        let context = index_source({
+            "
+            class Foo
+              # Some documentation
+              alias bar baz
+              alias qux quux
+            end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "1:1-5:4", Class, |class_def| {
+            assert_eq!(2, class_def.members().len());
+
+            assert_definition_at!(&context, "3:3-3:16", MethodAlias, |def| {
+                assert_string_eq!(&context, def.new_name_str_id(), "bar()");
+                assert_string_eq!(&context, def.old_name_str_id(), "baz()");
+                assert_def_comments_eq!(&context, def, ["Some documentation\n"]);
+                assert_eq!(class_def.id(), def.lexical_nesting_id().unwrap());
+            });
+
+            assert_definition_at!(&context, "4:3-4:17", MethodAlias, |def| {
+                assert_string_eq!(&context, def.new_name_str_id(), "qux()");
+                assert_string_eq!(&context, def.old_name_str_id(), "quux()");
+            });
+        });
+    }
+
+    #[test]
+    fn index_alias_node_with_deprecation() {
+        let context = index_source({
+            "
+            class Foo
+              %a{deprecated}
+              alias bar baz
+            end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "3:3-3:16", MethodAlias, |def| {
+            assert!(def.flags().contains(DefinitionFlags::DEPRECATED));
+        });
+    }
+
+    #[test]
+    fn index_alias_node_singleton() {
+        let context = index_source({
+            "
+            class Foo
+              alias self.bar self.baz
+            end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+        assert_eq!(context.graph().definitions().len(), 2);
+
+        assert_definition_at!(&context, "2:3-2:26", MethodAlias, |def| {
+            assert_string_eq!(&context, def.new_name_str_id(), "bar()");
+            assert_string_eq!(&context, def.old_name_str_id(), "baz()");
+            assert!(def.receiver().is_some());
+        });
+    }
 }

rust/rubydex/src/resolution.rs

@@ -489,7 +489,15 @@ impl<'a> Resolver<'a> {
                             NameRef::Resolved(resolved) => *resolved.declaration_id(),
                             NameRef::Unresolved(_) => continue,
                         },
-                        Some(Receiver::SelfReceiver(_)) | None => {
+                        // RBS `alias self.x self.y` creates singleton aliases
+                        Some(Receiver::SelfReceiver(_)) => {
+                            let Some(owner_id) = self.resolve_singleton_owner(receiver.as_ref(), lexical_nesting_id)
+                            else {
+                                continue;
+                            };
+                            owner_id
+                        }
+                        None => {
                             let Some(resolved) = self.resolve_lexical_owner(lexical_nesting_id) else {
                                 continue;
                             };
@@ -4722,6 +4730,42 @@ mod tests {
         assert_ancestors_eq!(context, "Foo", ["Foo", "Baz", "Bar", "Object"]);
     }
 
+    #[test]
+    fn rbs_method_alias_resolution() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///foo.rb", {
+            r"
+            class Foo
+              def bar; end
+              def self.class_method; end
+            end
+
+            module Baz
+              def original; end
+            end
+            "
+        });
+        context.index_rbs_uri("file:///test.rbs", {
+            r"
+            class Foo
+              alias qux bar
+              alias self.class_alias self.class_method
+            end
+
+            module Baz
+              alias copy original
+            end
+            "
+        });
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+
+        assert_members_eq!(context, "Foo", ["bar()", "qux()"]);
+        assert_members_eq!(context, "Foo::<Foo>", ["class_alias()", "class_method()"]);
+        assert_members_eq!(context, "Baz", ["copy()", "original()"]);
+    }
+
     #[test]
     fn resolving_meta_programming_class_reopened() {
         // It's often not possible to provide first-class support to meta-programming constructs, but we have to prevent