rubydex 0.2.0-aarch64-linux → 0.2.2-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44787b43319481966587e2e358c33a55e58800a092864ef132d9c10d2271f5c0
-  data.tar.gz: 520ab23713bc163e050622c52b986672e591c116954935e6957c7f8e52dfe343
+  metadata.gz: 220a0eb3de71608c1daa45286224aa1f11ebd03b893564e60cfd9e7db66124c2
+  data.tar.gz: 747ef3a246e405c236b9efcc6b2d592033025b154cdf5e9afa03006732a10303
 SHA512:
-  metadata.gz: 941b4124e0ec93076390a9a777d538189316512a964d4cc2210ad9775ff14408ccd2912c2e757314304ba4eb343bef241a82399b8a99d8f3b5a9b959608126ff
-  data.tar.gz: 74a4eaeeb123b057140cd64529dc4502232ca4b3821a992f6a91cb85994de0b3173f0042249aa8eeab4c53cb7486dde3bb9e7ee3c790dde6d29ad6bbb00b7750
+  metadata.gz: 4afa9fef910c50747666dbb3b464d86ba791e13e1a260041b9c845b32786a049b02da55a76583c98c749a4deabaa412e35fc71c45cb7da476b6058c88199fd08
+  data.tar.gz: 851d2924ff4d895866b5663e1f144960823fe57375a20511a08378840d013f9c6bf4f7de4a1303f9a1da2ea28ee4c2376aceb848d702f41175e933ccd98c7f8f

data/ext/rubydex/declaration.c

@@ -407,6 +407,38 @@ static VALUE rdxr_variable_declaration_references(VALUE self) {
     return rb_ary_new();
 }
 
+static VALUE rdxi_visibility_to_symbol(CVisibility visibility) {
+    switch (visibility) {
+    case CVisibility_Public:
+        return ID2SYM(rb_intern("public"));
+    case CVisibility_Protected:
+        return ID2SYM(rb_intern("protected"));
+    case CVisibility_Private:
+        return ID2SYM(rb_intern("private"));
+    default:
+        rb_raise(rb_eRuntimeError, "Unknown CVisibility: %d", visibility);
+    }
+}
+
+// Declaration#visibility -> Symbol
+static VALUE rdxr_declaration_visibility(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    const CVisibility *visibility = rdx_graph_visibility(graph, data->id);
+    if (visibility == NULL) {
+        rb_raise(rb_eRuntimeError, "declaration has no visibility");
+    }
+
+    VALUE symbol = rdxi_visibility_to_symbol(*visibility);
+    free_c_visibility(visibility);
+
+    return symbol;
+}
+
 // ConstantAlias#target -> Declaration?
 // Returns the first resolved target declaration for this constant alias, or nil if none of its definitions resolved to
 // a target
@@ -459,13 +491,19 @@ void rdxi_initialize_declaration(VALUE mRubydex) {
     rb_define_method(cNamespace, "descendants", rdxr_declaration_descendants, 0);
     rb_define_method(cNamespace, "members", rdxr_declaration_members, 0);
 
+    rb_define_method(cClass, "visibility", rdxr_declaration_visibility, 0);
+    rb_define_method(cModule, "visibility", rdxr_declaration_visibility, 0);
+
     // Constant and ConstantAlias have constant references
     rb_define_method(cConstant, "references", rdxr_constant_declaration_references, 0);
+    rb_define_method(cConstant, "visibility", rdxr_declaration_visibility, 0);
     rb_define_method(cConstantAlias, "references", rdxr_constant_declaration_references, 0);
     rb_define_method(cConstantAlias, "target", rdxr_constant_alias_target, 0);
+    rb_define_method(cConstantAlias, "visibility", rdxr_declaration_visibility, 0);
 
     // Method has method references
     rb_define_method(cMethod, "references", rdxr_method_declaration_references, 0);
+    rb_define_method(cMethod, "visibility", rdxr_declaration_visibility, 0);
 
     // Variable declarations don't yet support references
     rb_define_method(cGlobalVariable, "references", rdxr_variable_declaration_references, 0);

data/ext/rubydex/definition.c

@@ -3,6 +3,7 @@
 #include "handle.h"
 #include "location.h"
 #include "reference.h"
+#include "signature.h"
 #include "ruby/internal/scan_args.h"
 #include "rustbindings.h"
 
@@ -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,6 +298,7 @@ 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);
@@ -280,5 +306,6 @@ void rdxi_initialize_definition(VALUE mod) {
     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);
 }

data/ext/rubydex/graph.c

@@ -13,6 +13,31 @@ static VALUE mRubydex;
 static VALUE cKeyword;
 static VALUE cKeywordParameter;
 
+// Interned once in `rdxi_initialize_graph` to avoid repeated symbol-table lookups on hot completion paths.
+static ID id_self_receiver;
+
+// Extracts the optional `self_receiver:` kwarg from `opts`. Returns NULL when the kwarg is
+// absent or nil; raises ArgumentError when the value is the wrong type or empty.
+static const char *extract_self_receiver(VALUE opts) {
+    if (NIL_P(opts)) {
+        return NULL;
+    }
+
+    VALUE kwarg_val;
+    rb_get_kwargs(opts, &id_self_receiver, 0, 1, &kwarg_val);
+
+    if (kwarg_val == Qundef || NIL_P(kwarg_val)) {
+        return NULL;
+    }
+
+    Check_Type(kwarg_val, T_STRING);
+    if (RSTRING_LEN(kwarg_val) == 0) {
+        rb_raise(rb_eArgError, "self_receiver cannot be empty");
+    }
+
+    return StringValueCStr(kwarg_val);
+}
+
 // Free function for the custom Graph allocator. We always have to call into Rust to free data allocated by it
 static void graph_free(void *ptr) {
     if (ptr) {
@@ -564,12 +589,18 @@ static VALUE completion_result_to_ruby_array(struct CompletionResult result, VAL
     return ruby_array;
 }
 
-// Graph#complete_expression: (Array[String] nesting) -> Array[Declaration | Keyword]
+// Graph#complete_expression: (Array[String] nesting, self_receiver: nil) -> Array[Declaration | Keyword]
 // Returns completion candidates for an expression context.
-// The nesting array represents the lexical scope stack
-static VALUE rdxr_graph_complete_expression(VALUE self, VALUE nesting) {
+// The nesting array represents the lexical scope stack. The optional self_receiver keyword argument
+// overrides the self-type (e.g., "Foo::<Foo>" for `def Foo.bar`); when nil, self is derived from
+// the innermost nesting element.
+static VALUE rdxr_graph_complete_expression(int argc, VALUE *argv, VALUE self) {
+    VALUE nesting, opts;
+    rb_scan_args(argc, argv, "1:", &nesting, &opts);
     rdxi_check_array_of_strings(nesting);
 
+    const char *self_receiver = extract_self_receiver(opts);
+
     void *graph;
     TypedData_Get_Struct(self, void *, &graph_type, graph);
 
@@ -577,42 +608,62 @@ static VALUE rdxr_graph_complete_expression(VALUE self, VALUE nesting) {
     char **converted_nesting = rdxi_str_array_to_char(nesting, nesting_count);
 
     struct CompletionResult result =
-        rdx_graph_complete_expression(graph, (const char *const *)converted_nesting, nesting_count);
+        rdx_graph_complete_expression(graph, (const char *const *)converted_nesting, nesting_count, self_receiver);
 
     rdxi_free_str_array(converted_nesting, nesting_count);
     return completion_result_to_ruby_array(result, self);
 }
 
-// Graph#complete_namespace_access: (String name) -> Array[Declaration]
+// Graph#complete_namespace_access: (String name, self_receiver: nil) -> Array[Declaration]
 // Returns completion candidates after a namespace access operator (e.g., `Foo::`).
-static VALUE rdxr_graph_complete_namespace_access(VALUE self, VALUE name) {
+// The optional self_receiver kwarg is the caller's runtime self type, used to filter
+// visibility-restricted singleton methods (e.g., `private_class_method`).
+static VALUE rdxr_graph_complete_namespace_access(int argc, VALUE *argv, VALUE self) {
+    VALUE name, opts;
+    rb_scan_args(argc, argv, "1:", &name, &opts);
     Check_Type(name, T_STRING);
 
+    const char *self_receiver = extract_self_receiver(opts);
+
     void *graph;
     TypedData_Get_Struct(self, void *, &graph_type, graph);
 
-    struct CompletionResult result = rdx_graph_complete_namespace_access(graph, StringValueCStr(name));
+    struct CompletionResult result =
+        rdx_graph_complete_namespace_access(graph, StringValueCStr(name), self_receiver);
     return completion_result_to_ruby_array(result, self);
 }
 
-// Graph#complete_method_call: (String name) -> Array[Declaration]
+// Graph#complete_method_call: (String name, self_receiver: nil) -> Array[Declaration]
 // Returns completion candidates after a method call operator (e.g., `foo.`).
-static VALUE rdxr_graph_complete_method_call(VALUE self, VALUE name) {
+// The optional self_receiver kwarg is the caller's runtime self type, used for MRI-style
+// visibility checks (private/protected).
+static VALUE rdxr_graph_complete_method_call(int argc, VALUE *argv, VALUE self) {
+    VALUE name, opts;
+    rb_scan_args(argc, argv, "1:", &name, &opts);
     Check_Type(name, T_STRING);
 
+    const char *self_receiver = extract_self_receiver(opts);
+
     void *graph;
     TypedData_Get_Struct(self, void *, &graph_type, graph);
 
-    struct CompletionResult result = rdx_graph_complete_method_call(graph, StringValueCStr(name));
+    struct CompletionResult result =
+        rdx_graph_complete_method_call(graph, StringValueCStr(name), self_receiver);
     return completion_result_to_ruby_array(result, self);
 }
 
-// Graph#complete_method_argument: (String name, Array[String] nesting) -> Array[Declaration | Keyword | KeywordParameter]
+// Graph#complete_method_argument: (String name, Array[String] nesting, self_receiver: nil) -> Array[Declaration | Keyword | KeywordParameter]
 // Returns completion candidates inside a method call's argument list (e.g., `foo.bar(|)`).
-static VALUE rdxr_graph_complete_method_argument(VALUE self, VALUE name, VALUE nesting) {
+// See complete_expression for semantics of self_receiver.
+static VALUE rdxr_graph_complete_method_argument(int argc, VALUE *argv, VALUE self) {
+    VALUE name, nesting, opts;
+    rb_scan_args(argc, argv, "2:", &name, &nesting, &opts);
+
     Check_Type(name, T_STRING);
     rdxi_check_array_of_strings(nesting);
 
+    const char *self_receiver = extract_self_receiver(opts);
+
     void *graph;
     TypedData_Get_Struct(self, void *, &graph_type, graph);
 
@@ -620,7 +671,7 @@ static VALUE rdxr_graph_complete_method_argument(VALUE self, VALUE name, VALUE n
     char **converted_nesting = rdxi_str_array_to_char(nesting, nesting_count);
 
     struct CompletionResult result = rdx_graph_complete_method_argument(
-        graph, StringValueCStr(name), (const char *const *)converted_nesting, nesting_count);
+        graph, StringValueCStr(name), (const char *const *)converted_nesting, nesting_count, self_receiver);
 
     rdxi_free_str_array(converted_nesting, nesting_count);
     return completion_result_to_ruby_array(result, self);
@@ -691,6 +742,8 @@ void rdxi_initialize_graph(VALUE moduleRubydex) {
     cKeyword = rb_define_class_under(mRubydex, "Keyword", rb_cObject);
     cKeywordParameter = rb_define_class_under(mRubydex, "KeywordParameter", rb_cObject);
 
+    id_self_receiver = rb_intern("self_receiver");
+
     rb_define_alloc_func(cGraph, rdxr_graph_alloc);
     rb_define_method(cGraph, "index_all", rdxr_graph_index_all, 1);
     rb_define_method(cGraph, "index_source", rdxr_graph_index_source, 3);
@@ -710,10 +763,10 @@ void rdxi_initialize_graph(VALUE moduleRubydex) {
     rb_define_method(cGraph, "encoding=", rdxr_graph_set_encoding, 1);
     rb_define_method(cGraph, "resolve_require_path", rdxr_graph_resolve_require_path, 2);
     rb_define_method(cGraph, "require_paths", rdxr_graph_require_paths, 1);
-    rb_define_method(cGraph, "complete_expression", rdxr_graph_complete_expression, 1);
-    rb_define_method(cGraph, "complete_namespace_access", rdxr_graph_complete_namespace_access, 1);
-    rb_define_method(cGraph, "complete_method_call", rdxr_graph_complete_method_call, 1);
-    rb_define_method(cGraph, "complete_method_argument", rdxr_graph_complete_method_argument, 2);
+    rb_define_method(cGraph, "complete_expression", rdxr_graph_complete_expression, -1);
+    rb_define_method(cGraph, "complete_namespace_access", rdxr_graph_complete_namespace_access, -1);
+    rb_define_method(cGraph, "complete_method_call", rdxr_graph_complete_method_call, -1);
+    rb_define_method(cGraph, "complete_method_argument", rdxr_graph_complete_method_argument, -1);
     rb_define_method(cGraph, "exclude_paths", rdxr_graph_exclude_paths, 1);
     rb_define_method(cGraph, "excluded_paths", rdxr_graph_excluded_paths, 0);
     rb_define_method(cGraph, "keyword", rdxr_graph_keyword, 1);

data/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);
 }

data/ext/rubydex/signature.c

@@ -0,0 +1,83 @@
+#include "signature.h"
+#include "location.h"
+
+static VALUE empty_params = Qundef;
+
+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 signature;
+        if (sig_entry.parameters_len == 0) {
+            signature = rb_class_new_instance(1, &empty_params, cSignature);
+        } else {
+            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);
+            }
+
+            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);
+
+    empty_params = rb_ary_new();
+    OBJ_FREEZE(empty_params);
+    rb_gc_register_mark_object(empty_params);
+}

data/ext/rubydex/signature.h

@@ -0,0 +1,23 @@
+#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;
+
+void rdxi_initialize_signature(VALUE mRubydex);
+
+VALUE rdxi_signatures_to_ruby(SignatureArray *arr);
+
+#endif // RUBYDEX_SIGNATURE_H

data/lib/rubydex/declaration.rb

@@ -1,6 +1,17 @@
 # frozen_string_literal: true
 
 module Rubydex
+  module Visibility
+    #: () -> bool
+    def public? = visibility == :public
+
+    #: () -> bool
+    def private? = visibility == :private
+
+    #: () -> bool
+    def protected? = visibility == :protected
+  end
+
   class Declaration
     # @abstract
     #: () -> Enumerable[Reference]
@@ -8,4 +19,24 @@ module Rubydex
       raise NotImplementedError, "Subclasses must implement #references"
     end
   end
+
+  class Class < Namespace
+    include Visibility
+  end
+
+  class Module < Namespace
+    include Visibility
+  end
+
+  class Constant < Declaration
+    include Visibility
+  end
+
+  class ConstantAlias < Declaration
+    include Visibility
+  end
+
+  class Method < Declaration
+    include Visibility
+  end
 end

data/lib/rubydex/signature.rb

@@ -0,0 +1,130 @@
+# 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
+
+    class PositionalParameter < Parameter; end
+    class OptionalPositionalParameter < Parameter; end
+    class RestPositionalParameter < Parameter; end
+    class PostParameter < Parameter; end
+    class KeywordParameter < Parameter; end
+    class OptionalKeywordParameter < Parameter; end
+    class RestKeywordParameter < Parameter; end
+    class ForwardParameter < Parameter; end
+    class BlockParameter < Parameter; end
+
+    #: Array[Parameter]
+    attr_reader :parameters
+
+    #: (Array[Parameter]) -> void
+    def initialize(parameters)
+      @parameters = parameters
+    end
+
+    #: () -> [Array[PositionalParameter], Array[OptionalPositionalParameter], RestPositionalParameter?, Array[PostParameter], Array[KeywordParameter], Array[OptionalKeywordParameter], RestKeywordParameter?, ForwardParameter?, BlockParameter?]
+    def deconstruct
+      positionals = [] #: Array[PositionalParameter]
+      optional_positionals = [] #: Array[OptionalPositionalParameter]
+      rest_positional = nil #: RestPositionalParameter?
+      posts = [] #: Array[PostParameter]
+      keywords = [] #: Array[KeywordParameter]
+      optional_keywords = [] #: Array[OptionalKeywordParameter]
+      rest_keyword = nil #: RestKeywordParameter?
+      forward = nil #: ForwardParameter?
+      block = nil #: BlockParameter?
+
+      parameters.each do |param|
+        case param
+        when PositionalParameter then positionals << param
+        when OptionalPositionalParameter then optional_positionals << param
+        when RestPositionalParameter then rest_positional = param
+        when PostParameter then posts << param
+        when KeywordParameter then keywords << param
+        when OptionalKeywordParameter then optional_keywords << param
+        when RestKeywordParameter then rest_keyword = param
+        when ForwardParameter then forward = param
+        when BlockParameter then block = param
+        end
+      end
+
+      [positionals, optional_positionals, rest_positional, posts, keywords, optional_keywords, rest_keyword, forward, block]
+    end
+
+    DECONSTRUCT_KEYS = [
+      :positional_parameters,
+      :optional_positional_parameters,
+      :rest_positional_parameter,
+      :post_parameters,
+      :keyword_parameters,
+      :optional_keyword_parameters,
+      :rest_keyword_parameter,
+      :forward_parameter,
+      :block_parameter,
+    ].freeze #: Array[Symbol]
+    private_constant :DECONSTRUCT_KEYS
+
+    #: (Array[Symbol]?) -> Hash[Symbol, untyped]
+    def deconstruct_keys(keys)
+      keys = DECONSTRUCT_KEYS if keys.nil?
+
+      positionals, optional_positionals, rest_positional, posts,
+        keywords, optional_keywords, rest_keyword, forward, block = deconstruct
+
+      result = {} #: Hash[Symbol, untyped]
+      keys.each do |key|
+        case key
+        when :positional_parameters then result[key] = positionals
+        when :optional_positional_parameters then result[key] = optional_positionals
+        when :rest_positional_parameter then result[key] = rest_positional
+        when :post_parameters then result[key] = posts
+        when :keyword_parameters then result[key] = keywords
+        when :optional_keyword_parameters then result[key] = optional_keywords
+        when :rest_keyword_parameter then result[key] = rest_keyword
+        when :forward_parameter then result[key] = forward
+        when :block_parameter then result[key] = block
+        end
+      end
+      result
+    end
+
+    #: () -> Array[PositionalParameter]
+    def positional_parameters = deconstruct[0]
+
+    #: () -> Array[OptionalPositionalParameter]
+    def optional_positional_parameters = deconstruct[1]
+
+    #: () -> RestPositionalParameter?
+    def rest_positional_parameter = deconstruct[2]
+
+    #: () -> Array[PostParameter]
+    def post_parameters = deconstruct[3]
+
+    #: () -> Array[KeywordParameter]
+    def keyword_parameters = deconstruct[4]
+
+    #: () -> Array[OptionalKeywordParameter]
+    def optional_keyword_parameters = deconstruct[5]
+
+    #: () -> RestKeywordParameter?
+    def rest_keyword_parameter = deconstruct[6]
+
+    #: () -> ForwardParameter?
+    def forward_parameter = deconstruct[7]
+
+    #: () -> BlockParameter?
+    def block_parameter = deconstruct[8]
+  end
+end

data/lib/rubydex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubydex
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 end

data/lib/rubydex.rb

@@ -22,3 +22,4 @@ require "rubydex/keyword"
 require "rubydex/keyword_parameter"
 require "rubydex/graph"
 require "rubydex/declaration"
+require "rubydex/signature"