Add MethodDefinition#signatures to Ruby API

ext/rubydex/definition.c

@@ -5,6 +5,7 @@
 #include "reference.h"
 #include "ruby/internal/scan_args.h"
 #include "rustbindings.h"
+#include "signature.h"
 
 static VALUE mRubydex;
 static VALUE cInclude;
@@ -239,6 +240,30 @@ static VALUE rdxr_definition_mixins(VALUE self) {
     return ary;
 }
 
+// MethodDefinition#signatures -> [Rubydex::Signature]
+static VALUE rdxr_method_definition_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_definition_signatures(graph, data->id);
+    return rdxi_signatures_to_ruby(arr);
+}
+
+// MethodAliasDefinition#signatures -> [Rubydex::Signature]
+static VALUE rdxr_method_alias_definition_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_method_alias_definition_signatures(graph, data->id);
+    return rdxi_signatures_to_ruby(arr);
+}
+
 void rdxi_initialize_definition(VALUE mod) {
     mRubydex = mod;
 
@@ -273,12 +298,14 @@ void rdxi_initialize_definition(VALUE mod) {
     cConstantVisibilityDefinition = rb_define_class_under(mRubydex, "ConstantVisibilityDefinition", cDefinition);
     cMethodVisibilityDefinition = rb_define_class_under(mRubydex, "MethodVisibilityDefinition", cDefinition);
     cMethodDefinition = rb_define_class_under(mRubydex, "MethodDefinition", cDefinition);
+    rb_define_method(cMethodDefinition, "signatures", rdxr_method_definition_signatures, 0);
     cAttrAccessorDefinition = rb_define_class_under(mRubydex, "AttrAccessorDefinition", cDefinition);
     cAttrReaderDefinition = rb_define_class_under(mRubydex, "AttrReaderDefinition", cDefinition);
     cAttrWriterDefinition = rb_define_class_under(mRubydex, "AttrWriterDefinition", cDefinition);
     cGlobalVariableDefinition = rb_define_class_under(mRubydex, "GlobalVariableDefinition", cDefinition);
     cInstanceVariableDefinition = rb_define_class_under(mRubydex, "InstanceVariableDefinition", cDefinition);
     cClassVariableDefinition = rb_define_class_under(mRubydex, "ClassVariableDefinition", cDefinition);
     cMethodAliasDefinition = rb_define_class_under(mRubydex, "MethodAliasDefinition", cDefinition);
+    rb_define_method(cMethodAliasDefinition, "signatures", rdxr_method_alias_definition_signatures, 0);
     cGlobalVariableAliasDefinition = rb_define_class_under(mRubydex, "GlobalVariableAliasDefinition", cDefinition);
 }

ext/rubydex/rubydex.c

@@ -5,6 +5,7 @@
 #include "graph.h"
 #include "location.h"
 #include "reference.h"
+#include "signature.h"
 
 VALUE mRubydex;
 
@@ -19,4 +20,5 @@ void Init_rubydex(void) {
     rdxi_initialize_location(mRubydex);
     rdxi_initialize_diagnostic(mRubydex);
     rdxi_initialize_reference(mRubydex);
+    rdxi_initialize_signature(mRubydex);
 }

ext/rubydex/signature.c

@@ -0,0 +1,72 @@
+#include "signature.h"
+#include "location.h"
+
+VALUE cSignature;
+VALUE cParameter;
+VALUE cPositionalParameter;
+VALUE cOptionalPositionalParameter;
+VALUE cRestPositionalParameter;
+VALUE cPostParameter;
+VALUE cKeywordParameter;
+VALUE cOptionalKeywordParameter;
+VALUE cRestKeywordParameter;
+VALUE cForwardParameter;
+VALUE cBlockParameter;
+
+static VALUE parameter_class_for_kind(ParameterKind kind) {
+    switch (kind) {
+    case ParameterKind_RequiredPositional: return cPositionalParameter;
+    case ParameterKind_OptionalPositional: return cOptionalPositionalParameter;
+    case ParameterKind_RestPositional:     return cRestPositionalParameter;
+    case ParameterKind_Post:              return cPostParameter;
+    case ParameterKind_RequiredKeyword:    return cKeywordParameter;
+    case ParameterKind_OptionalKeyword:    return cOptionalKeywordParameter;
+    case ParameterKind_RestKeyword:        return cRestKeywordParameter;
+    case ParameterKind_Forward:            return cForwardParameter;
+    case ParameterKind_Block:              return cBlockParameter;
+    default: rb_raise(rb_eRuntimeError, "Unknown ParameterKind: %d", kind);
+    }
+}
+
+VALUE rdxi_signatures_to_ruby(SignatureArray *arr) {
+    VALUE signatures = rb_ary_new_capa((long)arr->len);
+
+    for (size_t i = 0; i < arr->len; i++) {
+        SignatureEntry sig_entry = arr->items[i];
+
+        VALUE parameters = rb_ary_new_capa((long)sig_entry.parameters_len);
+        for (size_t j = 0; j < sig_entry.parameters_len; j++) {
+            ParameterEntry param_entry = sig_entry.parameters[j];
+
+            VALUE param_class = parameter_class_for_kind(param_entry.kind);
+            VALUE name_sym = rb_str_intern(rb_utf8_str_new_cstr(param_entry.name));
+            VALUE location = rdxi_build_location_value(param_entry.location);
+            VALUE param_argv[] = {name_sym, location};
+            VALUE param = rb_class_new_instance(2, param_argv, param_class);
+
+            rb_ary_push(parameters, param);
+        }
+
+        VALUE signature = rb_class_new_instance(1, &parameters, cSignature);
+
+        rb_ary_push(signatures, signature);
+    }
+
+    rdx_definition_signatures_free(arr);
+    return signatures;
+}
+
+void rdxi_initialize_signature(VALUE mRubydex) {
+    cSignature = rb_define_class_under(mRubydex, "Signature", rb_cObject);
+
+    cParameter = rb_define_class_under(cSignature, "Parameter", rb_cObject);
+    cPositionalParameter = rb_define_class_under(cSignature, "PositionalParameter", cParameter);
+    cOptionalPositionalParameter = rb_define_class_under(cSignature, "OptionalPositionalParameter", cParameter);
+    cRestPositionalParameter = rb_define_class_under(cSignature, "RestPositionalParameter", cParameter);
+    cPostParameter = rb_define_class_under(cSignature, "PostParameter", cParameter);
+    cKeywordParameter = rb_define_class_under(cSignature, "KeywordParameter", cParameter);
+    cOptionalKeywordParameter = rb_define_class_under(cSignature, "OptionalKeywordParameter", cParameter);
+    cRestKeywordParameter = rb_define_class_under(cSignature, "RestKeywordParameter", cParameter);
+    cForwardParameter = rb_define_class_under(cSignature, "ForwardParameter", cParameter);
+    cBlockParameter = rb_define_class_under(cSignature, "BlockParameter", cParameter);
+}

ext/rubydex/signature.h

@@ -0,0 +1,25 @@
+#ifndef RUBYDEX_SIGNATURE_H
+#define RUBYDEX_SIGNATURE_H
+
+#include "ruby.h"
+#include "rustbindings.h"
+
+extern VALUE cSignature;
+extern VALUE cParameter;
+extern VALUE cPositionalParameter;
+extern VALUE cOptionalPositionalParameter;
+extern VALUE cRestPositionalParameter;
+extern VALUE cPostParameter;
+extern VALUE cKeywordParameter;
+extern VALUE cOptionalKeywordParameter;
+extern VALUE cRestKeywordParameter;
+extern VALUE cForwardParameter;
+extern VALUE cBlockParameter;
+
+// Convert a SignatureArray into a Ruby array of Rubydex::Signature objects.
+// The SignatureArray is freed after conversion.
+VALUE rdxi_signatures_to_ruby(SignatureArray *arr);
+
+void rdxi_initialize_signature(VALUE mRubydex);
+
+#endif // RUBYDEX_SIGNATURE_H

lib/rubydex.rb

@@ -17,6 +17,7 @@
 require "rubydex/failures"
 require "rubydex/location"
 require "rubydex/comment"
+require "rubydex/signature"
 require "rubydex/diagnostic"
 require "rubydex/keyword"
 require "rubydex/keyword_parameter"

lib/rubydex/signature.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Rubydex
+  class Signature
+    class Parameter
+      #: Symbol
+      attr_reader :name
+
+      #: Location
+      attr_reader :location
+
+      #: (Symbol, Location) -> void
+      def initialize(name, location)
+        @name = name
+        @location = location
+      end
+    end
+
+    #: Array[Parameter]
+    attr_reader :parameters
+
+    #: (Array[Parameter]) -> void
+    def initialize(parameters)
+      @parameters = parameters
+    end
+  end
+end

rust/rubydex-sys/src/declaration_api.rs

@@ -178,42 +178,15 @@ pub unsafe extern "C" fn rdx_declaration_find_member(
 
     with_graph(pointer, |graph| {
         let id = DeclarationId::new(declaration_id);
+        let member_id = StringId::from(member_str.as_str());
 
-        let Some(Declaration::Namespace(decl)) = graph.declarations().get(&id) else {
+        let Some(member_decl_id) = rubydex::query::find_member_in_ancestors(graph, id, member_id, only_inherited)
+        else {
             return ptr::null();
         };
 
-        let member_id = StringId::from(member_str.as_str());
-        let mut found_main_namespace = false;
-
-        decl.ancestors()
-            .iter()
-            .find_map(|ancestor| match ancestor {
-                Ancestor::Complete(ancestor_id) => {
-                    // When only_inherited, skip self and prepended modules
-                    if only_inherited {
-                        let is_self = *ancestor_id == id;
-                        if is_self {
-                            found_main_namespace = true;
-                        }
-                        if is_self || !found_main_namespace {
-                            return None;
-                        }
-                    }
-
-                    let ancestor_decl = graph.declarations().get(ancestor_id).unwrap().as_namespace().unwrap();
-
-                    if let Some(member_decl_id) = ancestor_decl.member(&member_id) {
-                        return Some((member_decl_id, graph.declarations().get(member_decl_id).unwrap()));
-                    }
-
-                    None
-                }
-                Ancestor::Partial(_) => None,
-            })
-            .map_or(ptr::null(), |(member_decl_id, member_decl)| {
-                Box::into_raw(Box::new(CDeclaration::from_declaration(*member_decl_id, member_decl))).cast_const()
-            })
+        let member_decl = graph.declarations().get(&member_decl_id).unwrap();
+        Box::into_raw(Box::new(CDeclaration::from_declaration(member_decl_id, member_decl))).cast_const()
     })
 }
 

rust/rubydex-sys/src/lib.rs

@@ -76,4 +76,5 @@ pub mod graph_api;
 pub mod location_api;
 pub mod name_api;
 pub mod reference_api;
+pub mod signature_api;
 pub mod utils;