rubydex 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b492c7be7e3fdd85ffa12dc17e7bdb19a77e469dbfa2a69cdb175a4c0b0cb84
-  data.tar.gz: e0b0f1f47e15a93f99e1e634ab76aee01aa6c4d78110a95344817fa4276b769a
+  metadata.gz: d664658212c249ae798590437722defaf30aaa69283bdcaa38c3e438d8506e74
+  data.tar.gz: e1ef82873e5ca9242436bb36ec0aa59f9fab359c8125a04f4dcf472d9e20359e
 SHA512:
-  metadata.gz: 31e6325b46717f297adacc1ceb08d5700f6f189976358677858710150073e1f016d6a739bc88cb936d777c1bb318e48f96d0cba9f3f6287697d33e0d5c679bc4
-  data.tar.gz: c9bc693cdb897e65def20958848762997cc3f6cb1d7b6d42e5b58f7620495da4bb20bf181391cc7d42cce9f5bf7d9106060019874f224214c22b9a6a2a15fec1
+  metadata.gz: 33f84d4ae8a4db1ae1335a1d75f897186b80450c9195597e8e7b2ce0eeeadd248ac4497089fe1b28963532a917d6b70f53026384b4bcf9f88a4743f62ca53614
+  data.tar.gz: 84fadad71d4b98345fe766f8956c7225a5fba9eb8a2e8c8e532c672dd6cf1ea5ca9150956c2091a03eb6d8fd73a3f8889dca7064d399f38d00091852358526b6

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/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/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.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"

data/rust/rubydex/src/indexing/ruby_indexer.rs

@@ -1200,9 +1200,7 @@ impl<'a> RubyIndexer<'a> {
             }
             Some(ruby_prism::Node::SelfNode { .. }) | None => match self.nesting_stack.last() {
                 Some(Nesting::Method(_)) => {
-                    // Dynamic private constant (called from a method), we ignore it but don't report an error since it's valid Ruby
-                    // if being called from a singleton method.
-
+                    self.visit_call_node_parts(node);
                     return;
                 }
                 None => {
@@ -1211,7 +1209,7 @@ impl<'a> RubyIndexer<'a> {
                         Offset::from_prism_location(&node.location()),
                         "Private constant called at top level".to_string(),
                     );
-
+                    self.visit_call_node_parts(node);
                     return;
                 }
                 _ => None,
@@ -1222,7 +1220,7 @@ impl<'a> RubyIndexer<'a> {
                     Offset::from_prism_location(&node.location()),
                     "Dynamic receiver for private constant".to_string(),
                 );
-
+                self.visit_call_node_parts(node);
                 return;
             }
         };
@@ -1252,8 +1250,8 @@ impl<'a> RubyIndexer<'a> {
                         Offset::from_prism_location(&argument.location()),
                         "Private constant called with non-symbol argument".to_string(),
                     );
-
-                    return;
+                    self.visit(&argument);
+                    continue;
                 }
             };
 
@@ -1276,6 +1274,60 @@ impl<'a> RubyIndexer<'a> {
         }
     }
 
+    fn handle_singleton_method_visibility(
+        &mut self,
+        node: &ruby_prism::CallNode,
+        visibility: Visibility,
+        call_name: &str,
+    ) {
+        match node.receiver() {
+            Some(ruby_prism::Node::SelfNode { .. }) | None => match self.nesting_stack.last() {
+                Some(Nesting::Method(_)) => {
+                    self.visit_call_node_parts(node);
+                    return;
+                }
+                None => {
+                    self.local_graph.add_diagnostic(
+                        Rule::InvalidMethodVisibility,
+                        Offset::from_prism_location(&node.location()),
+                        format!("`{call_name}` called at top level"),
+                    );
+                    self.visit_call_node_parts(node);
+                    return;
+                }
+                _ => {}
+            },
+            _ => {
+                self.visit_call_node_parts(node);
+                return;
+            }
+        }
+
+        let Some(arguments) = node.arguments() else {
+            return;
+        };
+
+        for argument in &arguments.arguments() {
+            match argument {
+                ruby_prism::Node::SymbolNode { .. } | ruby_prism::Node::StringNode { .. } => {
+                    self.create_method_visibility_definition(
+                        &argument,
+                        visibility,
+                        DefinitionFlags::SINGLETON_METHOD_VISIBILITY,
+                    );
+                }
+                _ => {
+                    self.local_graph.add_diagnostic(
+                        Rule::InvalidMethodVisibility,
+                        Offset::from_prism_location(&argument.location()),
+                        format!("`{call_name}` called with a non-literal argument"),
+                    );
+                    self.visit(&argument);
+                }
+            }
+        }
+    }
+
     fn is_attr_call(arg: &ruby_prism::Node) -> bool {
         arg.as_call_node().is_some_and(|call| {
             let receiver = call.receiver();
@@ -1313,7 +1365,7 @@ impl<'a> RubyIndexer<'a> {
                 arg,
                 ruby_prism::Node::SymbolNode { .. } | ruby_prism::Node::StringNode { .. }
             ) {
-                self.create_method_visibility_definition(&arg, visibility);
+                self.create_method_visibility_definition(&arg, visibility, DefinitionFlags::empty());
             } else {
                 // Unsupported arg — diagnostic + visit for side effects.
                 let arg_offset = Offset::from_prism_location(&arg.location());
@@ -1329,7 +1381,12 @@ impl<'a> RubyIndexer<'a> {
         }
     }
 
-    fn create_method_visibility_definition(&mut self, arg: &ruby_prism::Node, visibility: Visibility) {
+    fn create_method_visibility_definition(
+        &mut self,
+        arg: &ruby_prism::Node,
+        visibility: Visibility,
+        flags: DefinitionFlags,
+    ) {
         let (name, location) = match arg {
             ruby_prism::Node::SymbolNode { .. } => {
                 let symbol = arg.as_symbol_node().unwrap();
@@ -1355,7 +1412,7 @@ impl<'a> RubyIndexer<'a> {
             self.uri_id,
             arg_offset,
             Box::default(),
-            DefinitionFlags::empty(),
+            flags,
             self.current_nesting_definition_id(),
         )));
 
@@ -2049,6 +2106,12 @@ impl Visit<'_> for RubyIndexer<'_> {
             "public_constant" => {
                 self.handle_constant_visibility(node, Visibility::Public);
             }
+            "private_class_method" => {
+                self.handle_singleton_method_visibility(node, Visibility::Private, "private_class_method");
+            }
+            "public_class_method" => {
+                self.handle_singleton_method_visibility(node, Visibility::Public, "public_class_method");
+            }
             _ => {
                 // For method calls that we don't explicitly handle each part, we continue visiting their parts as we
                 // may discover something inside