rubydex 0.2.1-x86_64-linux → 0.2.3-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af48ce975a55310aaf8f2026be413cad45663642baf60ddda21ddfaf678a0e96
-  data.tar.gz: 298d02687b6b96bddf246a83b9d808705d5ebe33ce0fd5a87f230d2d6fa2f6b2
+  metadata.gz: 4aa89b9ebd052a79e8e4d9c59e8692785b09068ff185362fcfad152b1744db4d
+  data.tar.gz: b19d59ff132c8382047e6d538e9d8894d613c7f52623d1aecec524ed87d5e7c1
 SHA512:
-  metadata.gz: 1e6840ad668950cf5cf8f823f86eeb561de8cd3b60b1bc4d01b7afa390fd473b7268df85d6bba802d270b27a61c5224f7b7c7f8359f56274c829004ee9491843
-  data.tar.gz: a64f5c6f3f2f4c1dbed7774ab03216be98545a40892a3dffba8c6bb98376db901065e18fc96d1b7028a1c46fa9c9adde054a19e5a651eff694f044fcf218c18c
+  metadata.gz: ebf4a08fc65b9825998e48afdd8a19ea787978116622e69f1b9f26a18237333ed680b07b3c8d1ef65817577e14413960223ba3d281e4fa4651c4d62f84d6e826
+  data.tar.gz: b0716909fff42f12ad084a25f642651e147c76ec49f810b6191f409203b4ca9a6ecc99db71e0e83c324976ecafb6307ac8e7216678fc65e5758eb3e92a680d81

data/ext/rubydex/definition.c

@@ -1,8 +1,10 @@
 #include "definition.h"
+#include "declaration.h"
 #include "graph.h"
 #include "handle.h"
 #include "location.h"
 #include "reference.h"
+#include "signature.h"
 #include "ruby/internal/scan_args.h"
 #include "rustbindings.h"
 
@@ -171,6 +173,28 @@ static VALUE rdxr_definition_name_location(VALUE self) {
     return location;
 }
 
+// Definition#declaration -> Rubydex::Declaration?
+// Returns the declaration this definition belongs to or nil when it cannot be located (for example, before
+// `Graph#resolve` has run).
+static VALUE rdxr_definition_declaration(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 struct CDeclaration *decl = rdx_definition_declaration(graph, data->id);
+    if (decl == NULL) {
+        return Qnil;
+    }
+
+    VALUE decl_class = rdxi_declaration_class_for_kind(decl->kind);
+    VALUE argv[] = {data->graph_obj, ULL2NUM(decl->id)};
+    free_c_declaration(decl);
+
+    return rb_class_new_instance(2, argv, decl_class);
+}
+
 static VALUE rdxi_build_constant_reference(VALUE graph_obj, const CConstantReference *cref) {
     VALUE ref_class = (cref->declaration_id == 0)
         ? cUnresolvedConstantReference
@@ -239,6 +263,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;
 
@@ -257,6 +305,7 @@ void rdxi_initialize_definition(VALUE mod) {
     rb_define_method(cDefinition, "name", rdxr_definition_name, 0);
     rb_define_method(cDefinition, "deprecated?", rdxr_definition_deprecated, 0);
     rb_define_method(cDefinition, "name_location", rdxr_definition_name_location, 0);
+    rb_define_method(cDefinition, "declaration", rdxr_definition_declaration, 0);
 
     cClassDefinition = rb_define_class_under(mRubydex, "ClassDefinition", cDefinition);
     rb_define_method(cClassDefinition, "superclass", rdxr_class_definition_superclass, 0);
@@ -273,6 +322,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 +330,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/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/reference.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Rubydex
+  class Reference
+    #: () -> Location
+    def location
+      raise NotImplementedError, "Subclasses must implement the #location method"
+    end
+  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.1"
+  VERSION = "0.2.3"
 end

data/lib/rubydex.rb

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

data/rbi/rubydex.rbi

@@ -15,6 +15,8 @@ class Rubydex::Comment
 end
 
 class Rubydex::ConstantReference < Rubydex::Reference
+  abstract!
+
   sig { returns(Rubydex::Location) }
   def location; end
 
@@ -36,6 +38,8 @@ class Rubydex::ResolvedConstantReference < Rubydex::ConstantReference
 end
 
 class Rubydex::Declaration
+  abstract!
+
   sig { returns(T::Enumerable[Rubydex::Definition]) }
   def definitions; end
 
@@ -92,6 +96,8 @@ class Rubydex::Method < Rubydex::Declaration
 end
 
 class Rubydex::Namespace < Rubydex::Declaration
+  abstract!
+
   sig { returns(T::Enumerable[Rubydex::ConstantReference]) }
   def references; end
 
@@ -119,6 +125,8 @@ class Rubydex::Module < Rubydex::Namespace; end
 class Rubydex::SingletonClass < Rubydex::Namespace; end
 
 class Rubydex::Definition
+  abstract!
+
   sig { returns(T::Array[Rubydex::Comment]) }
   def comments; end
 
@@ -134,6 +142,9 @@ class Rubydex::Definition
   sig { returns(T.nilable(Rubydex::Location)) }
   def name_location; end
 
+  sig { returns(T.nilable(Rubydex::Declaration)) }
+  def declaration; end
+
   class << self
     private
 
@@ -172,6 +183,8 @@ class Rubydex::ClassDefinition < Rubydex::Definition
 end
 
 class Rubydex::Mixin
+  abstract!
+
   sig { returns(Rubydex::ConstantReference) }
   attr_reader :constant_reference
 
@@ -454,6 +467,8 @@ class Rubydex::MethodReference < Rubydex::Reference
 end
 
 class Rubydex::Reference
+  abstract!
+
   class << self
     private