Add Rubydex::Method#signatures with alias resolution

Add signatures method to method declarations (Rubydex::Method) that
aggregates signatures from all definitions, resolving method aliases
to the original method's signatures.

- Add query::method_definitions() in Rust for alias-aware lookup
- Add rdx_declaration_method_signatures C API function
- Register Method#signatures in the C extension

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: soutaro

ext/rubydex/declaration.c

@@ -4,6 +4,7 @@
 #include "handle.h"
 #include "reference.h"
 #include "rustbindings.h"
+#include "signature.h"
 #include "utils.h"
 
 VALUE cDeclaration;
@@ -331,6 +332,18 @@ static VALUE rdxr_declaration_references(VALUE self) {
     return self;
 }
 
+// Method#signatures -> [Rubydex::Signature]
+static VALUE rdxr_method_declaration_signatures(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    SignatureArray *arr = rdx_declaration_method_signatures(graph, data->id);
+    return rdxi_signatures_to_ruby(arr, data->graph_obj, Qnil);
+}
+
 void rdxi_initialize_declaration(VALUE mRubydex) {
     cDeclaration = rb_define_class_under(mRubydex, "Declaration", rb_cObject);
     cNamespace = rb_define_class_under(mRubydex, "Namespace", cDeclaration);
@@ -341,6 +354,7 @@ void rdxi_initialize_declaration(VALUE mRubydex) {
     cConstant = rb_define_class_under(mRubydex, "Constant", cDeclaration);
     cConstantAlias = rb_define_class_under(mRubydex, "ConstantAlias", cDeclaration);
     cMethod = rb_define_class_under(mRubydex, "Method", cDeclaration);
+    rb_define_method(cMethod, "signatures", rdxr_method_declaration_signatures, 0);
     cGlobalVariable = rb_define_class_under(mRubydex, "GlobalVariable", cDeclaration);
     cInstanceVariable = rb_define_class_under(mRubydex, "InstanceVariable", cDeclaration);
     cClassVariable = rb_define_class_under(mRubydex, "ClassVariable", cDeclaration);

rust/rubydex-sys/src/declaration_api.rs

@@ -5,7 +5,9 @@ use rubydex::model::declaration::{Ancestor, Declaration, Namespace};
 use std::ffi::CString;
 use std::ptr;
 
-use crate::definition_api::{DefinitionsIter, rdx_definitions_iter_new_from_ids};
+use crate::definition_api::{
+    DefinitionsIter, SignatureArray, SignatureEntry, collect_method_signatures, rdx_definitions_iter_new_from_ids,
+};
 use crate::graph_api::{GraphPointer, with_graph};
 use crate::reference_api::{CReference, ReferenceKind, ReferencesIter};
 use crate::utils;
@@ -439,3 +441,42 @@ pub unsafe extern "C" fn rdx_declaration_references_iter_new(
         ReferencesIter::new(entries.into_boxed_slice())
     })
 }
+
+/// Returns a newly allocated array of signatures for the given method declaration id.
+/// Aggregates signatures from all definitions. For alias definitions, resolves to the
+/// original method's signatures.
+/// Returns NULL if the declaration is not a method declaration.
+/// Caller must free the returned pointer with `rdx_definition_signatures_free`.
+///
+/// # Safety
+/// - `pointer` must be a valid pointer previously returned by `rdx_graph_new`.
+/// - `declaration_id` must be a valid declaration id.
+///
+/// # Panics
+/// This function will panic if declarations or definitions cannot be found.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_declaration_method_signatures(
+    pointer: GraphPointer,
+    declaration_id: u64,
+) -> *mut SignatureArray {
+    with_graph(pointer, |graph| {
+        let decl_id = DeclarationId::new(declaration_id);
+        let method_defs = rubydex::query::method_definitions(graph, decl_id);
+
+        if method_defs.is_empty() {
+            return ptr::null_mut();
+        }
+
+        let mut sig_entries: Vec<SignatureEntry> = Vec::new();
+        for (def_id, method_def) in &method_defs {
+            collect_method_signatures(graph, method_def, **def_id, &mut sig_entries);
+        }
+
+        let mut boxed = sig_entries.into_boxed_slice();
+        let len = boxed.len();
+        let items_ptr = boxed.as_mut_ptr();
+        std::mem::forget(boxed);
+
+        Box::into_raw(Box::new(SignatureArray { items: items_ptr, len }))
+    })
+}

rust/rubydex-sys/src/definition_api.rs

@@ -433,7 +433,7 @@ pub unsafe extern "C" fn rdx_definition_signatures(pointer: GraphPointer, defini
     })
 }
 
-/// Helper: build signature entries from a MethodDefinition and append them to the output vector.
+/// Helper: build signature entries from a `MethodDefinition` and append them to the output vector.
 pub(crate) fn collect_method_signatures(
     graph: &rubydex::model::graph::Graph,
     method_def: &rubydex::model::definitions::MethodDefinition,

rust/rubydex/src/query.rs

@@ -6,10 +6,10 @@ use std::thread;
 use url::Url;
 
 use crate::model::declaration::{Ancestor, Declaration};
-use crate::model::definitions::{Definition, Parameter};
+use crate::model::definitions::{Definition, MethodDefinition, Parameter};
 use crate::model::graph::{Graph, OBJECT_ID};
 use crate::model::identity_maps::IdentityHashSet;
-use crate::model::ids::{DeclarationId, NameId, StringId, UriId};
+use crate::model::ids::{DeclarationId, DefinitionId, NameId, StringId, UriId};
 use crate::model::keywords::{self, Keyword};
 use crate::model::name::NameRef;
 
@@ -207,6 +207,78 @@ macro_rules! collect_candidates {
     };
 }
 
+/// Returns the method definitions associated with a method declaration, resolving aliases.
+///
+/// For regular method declarations, returns the `MethodDefinition`s directly.
+/// For alias declarations, follows the alias to the original method and returns its definitions.
+///
+/// # Panics
+///
+/// Panics if:
+/// - the `declaration_id` does not exist in the graph
+/// - the declaration is not a method declaration
+/// - any definition or owner declaration referenced by the method is missing from the graph
+#[must_use]
+pub fn method_definitions(graph: &Graph, declaration_id: DeclarationId) -> Vec<(DefinitionId, &MethodDefinition)> {
+    let decl = graph
+        .declarations()
+        .get(&declaration_id)
+        .expect("declaration should exist in graph");
+    assert!(
+        matches!(decl, Declaration::Method(_)),
+        "expected a method declaration, got {:?}",
+        decl.kind()
+    );
+
+    let owner_id = *decl.owner_id();
+    let mut result = Vec::new();
+
+    for def_id in decl.definitions() {
+        let defn = graph
+            .definitions()
+            .get(def_id)
+            .expect("definition should exist in graph");
+
+        match defn {
+            Definition::Method(method_def) => {
+                result.push((*def_id, method_def.as_ref()));
+            }
+            Definition::MethodAlias(alias_def) => {
+                // Resolve alias: look up the original method in the owner's members
+                let owner = graph
+                    .declarations()
+                    .get(&owner_id)
+                    .expect("owner declaration should exist")
+                    .as_namespace()
+                    .expect("owner should be a namespace");
+
+                // Alias target may not exist (e.g. aliasing an undefined method)
+                let Some(original_decl_id) = owner.member(alias_def.old_name_str_id()) else {
+                    continue;
+                };
+
+                let original_decl = graph
+                    .declarations()
+                    .get(original_decl_id)
+                    .expect("original declaration should exist");
+
+                for original_def_id in original_decl.definitions() {
+                    let original_defn = graph
+                        .definitions()
+                        .get(original_def_id)
+                        .expect("original definition should exist in graph");
+                    if let Definition::Method(original_method_def) = original_defn {
+                        result.push((*original_def_id, original_method_def.as_ref()));
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    result
+}
+
 /// Determines all possible completion candidates based on the current context of the cursor. There are multiple cases
 /// that change what has to be collected for completion:
 ///
@@ -1621,4 +1693,99 @@ mod tests {
 
         assert!(!candidates.iter().any(|c| matches!(c, CompletionCandidate::Keyword(_))));
     }
+
+    /// Helper to get source text at an offset
+    fn source_at<'a>(source: &'a str, offset: &crate::offset::Offset) -> &'a str {
+        &source[offset.start() as usize..offset.end() as usize]
+    }
+
+    #[test]
+    fn test_method_definitions_returns_method_definitions() {
+        let mut context = GraphTest::new();
+        //                 0123456789...
+        let source = "class Foo\n  def bar(a, b); end\nend\n";
+        context.index_uri("file:///foo.rb", source);
+        context.resolve();
+
+        let defs = method_definitions(context.graph(), DeclarationId::from("Foo#bar()"));
+        assert_eq!(1, defs.len());
+        assert_eq!("def bar(a, b); end", source_at(source, defs[0].1.offset()));
+    }
+
+    #[test]
+    fn test_method_definitions_resolves_alias() {
+        let mut context = GraphTest::new();
+        let source = "class Foo\n  def bar(a, b); end\n  alias_method :baz, :bar\nend\n";
+        context.index_uri("file:///foo.rb", source);
+        context.resolve();
+
+        let defs = method_definitions(context.graph(), DeclarationId::from("Foo#baz()"));
+        assert_eq!(1, defs.len());
+        // Returns the original method's definition
+        assert_eq!("def bar(a, b); end", source_at(source, defs[0].1.offset()));
+    }
+
+    #[test]
+    fn test_method_definitions_alias_to_undefined_method() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///foo.rb", "class Foo\n  alias_method :baz, :nonexistent\nend\n");
+        context.resolve();
+
+        let defs = method_definitions(context.graph(), DeclarationId::from("Foo#baz()"));
+        assert!(defs.is_empty());
+    }
+
+    #[test]
+    fn test_method_definitions_with_override() {
+        let mut context = GraphTest::new();
+        let source = "class Foo\n  def bar(a); end\n  def bar(a, b); end\nend\n";
+        context.index_uri("file:///foo.rb", source);
+        context.resolve();
+
+        let defs = method_definitions(context.graph(), DeclarationId::from("Foo#bar()"));
+        assert_eq!(2, defs.len());
+
+        let mut texts: Vec<&str> = defs.iter().map(|(_, d)| source_at(source, d.offset())).collect();
+        texts.sort();
+        assert_eq!(vec!["def bar(a); end", "def bar(a, b); end"], texts);
+    }
+
+    #[test]
+    #[should_panic(expected = "expected a method declaration")]
+    fn test_method_definitions_panics_for_non_method() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///foo.rb", "class Foo; end");
+        context.resolve();
+
+        method_definitions(context.graph(), DeclarationId::from("Foo"));
+    }
+
+    #[test]
+    fn test_method_definitions_from_rbs() {
+        let mut context = GraphTest::new();
+        let source = "class Foo\n  def bar: (String name) -> void\n         | (Integer id) -> String\nend\n";
+        context.index_rbs_uri("file:///foo.rbs", source);
+        context.resolve();
+
+        let defs = method_definitions(context.graph(), DeclarationId::from("Foo#bar()"));
+        assert_eq!(1, defs.len());
+        assert_eq!(
+            "def bar: (String name) -> void\n         | (Integer id) -> String",
+            source_at(source, defs[0].1.offset())
+        );
+    }
+
+    #[test]
+    fn test_method_definitions_from_rbs_alias() {
+        let mut context = GraphTest::new();
+        let rb_source = "class Foo\n  def bar(a, b); end\nend\n";
+        let rbs_source = "class Foo\n  alias baz bar\nend\n";
+        context.index_uri("file:///foo.rb", rb_source);
+        context.index_rbs_uri("file:///foo.rbs", rbs_source);
+        context.resolve();
+
+        let defs = method_definitions(context.graph(), DeclarationId::from("Foo#baz()"));
+        assert_eq!(1, defs.len());
+        assert_eq!("def bar(a, b); end", source_at(rb_source, defs[0].1.offset()));
+    }
 }

test/declaration_test.rb

@@ -538,4 +538,90 @@ def initialize
       assert_equal("Foo#initialize()", decl.name)
     end
   end
+
+  def test_method_declaration_signatures
+    with_context do |context|
+      context.write!("file1.rb", <<~RUBY)
+        class Foo
+          def bar(a, b = 1); end
+        end
+      RUBY
+
+      graph = Rubydex::Graph.new
+      graph.index_all(context.glob("**/*.rb"))
+      graph.resolve
+
+      decl = graph["Foo#bar()"]
+      assert_instance_of(Rubydex::Method, decl)
+
+      signatures = decl.signatures
+      assert_equal(1, signatures.length)
+
+      sig = signatures.first
+      assert_instance_of(Rubydex::Signature, sig)
+      assert_instance_of(Rubydex::MethodDefinition, sig.method_definition)
+
+      params = sig.parameters
+      assert_equal(2, params.length)
+      assert_equal([:req, :a], params[0][0..1])
+      assert_equal([:opt, :b], params[1][0..1])
+    end
+  end
+
+  def test_method_declaration_signatures_with_alias
+    with_context do |context|
+      context.write!("file1.rb", <<~RUBY)
+        class Foo
+          def bar(a, b); end
+          alias_method :baz, :bar
+        end
+      RUBY
+
+      graph = Rubydex::Graph.new
+      graph.index_all(context.glob("**/*.rb"))
+      graph.resolve
+
+      # Alias resolves to original method's signatures
+      decl = graph["Foo#baz()"]
+      assert_instance_of(Rubydex::Method, decl)
+
+      signatures = decl.signatures
+      assert_equal(1, signatures.length)
+
+      params = signatures.first.parameters
+      assert_equal(2, params.length)
+      assert_equal([:req, :a], params[0][0..1])
+      assert_equal([:req, :b], params[1][0..1])
+
+      # method_definition points to the original MethodDefinition
+      assert_instance_of(Rubydex::MethodDefinition, signatures.first.method_definition)
+      assert_equal("bar()", signatures.first.method_definition.name)
+    end
+  end
+
+  def test_method_declaration_signatures_with_override
+    with_context do |context|
+      context.write!("file1.rb", <<~RUBY)
+        class Foo
+          def bar(a); end
+          def bar(a, b); end
+        end
+      RUBY
+
+      graph = Rubydex::Graph.new
+      graph.index_all(context.glob("**/*.rb"))
+      graph.resolve
+
+      decl = graph["Foo#bar()"]
+      signatures = decl.signatures
+      assert_equal(2, signatures.length)
+
+      # Each signature comes from a different definition
+      params0 = signatures[0].parameters
+      params1 = signatures[1].parameters
+
+      param_counts = [params0.length, params1.length].sort
+      assert_equal([1, 2], param_counts)
+    end
+  end
 end