rubydex 0.1.0.beta14 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55c47ced758d8aff486a445a0c15a1ffe6525b5d2ee59fea8d38be40bc791207
-  data.tar.gz: 9e73f9244f197ed1b062f475ddc077b25f1dd0a5d8c29de430c7b256b20c380e
+  metadata.gz: 8b492c7be7e3fdd85ffa12dc17e7bdb19a77e469dbfa2a69cdb175a4c0b0cb84
+  data.tar.gz: e0b0f1f47e15a93f99e1e634ab76aee01aa6c4d78110a95344817fa4276b769a
 SHA512:
-  metadata.gz: 50444ddd1ca5576961316b2c8db705a872eaf658366587d11f9cc2860b2f97f517257ffbcc51bf9fbfa0036e436b5fe338479431c90e285ad155048616f77897
-  data.tar.gz: 856b302c492ccc0ba74a4ea1dc5c2fc993ba43a47a0f635ee005af764ae39c1be61a50fcc79f8b151c1b20e77a7e0b719115fe3427fed880ed0f0cbdd47fed45
+  metadata.gz: 31e6325b46717f297adacc1ceb08d5700f6f189976358677858710150073e1f016d6a739bc88cb936d777c1bb318e48f96d0cba9f3f6287697d33e0d5c679bc4
+  data.tar.gz: c9bc693cdb897e65def20958848762997cc3f6cb1d7b6d42e5b58f7620495da4bb20bf181391cc7d42cce9f5bf7d9106060019874f224214c22b9a6a2a15fec1

data/exe/rdx

@@ -2,11 +2,12 @@
 # frozen_string_literal: true
 
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
 require "optparse"
 
-OptionParser.new do |parser|
-  parser.banner = "Usage: [path1, path2]"
+options = {}
 
+OptionParser.new do |parser|
   parser.on("--version", "Print the gem's version") do
     require "rubydex/version"
     puts "v#{Rubydex::VERSION}"
@@ -17,31 +18,34 @@ OptionParser.new do |parser|
     puts parser
     exit
   end
+
+  parser.on("-i", "--interactive", "Open an interactive session with a populated graph for the current workspace") do
+    options[:interactive] = true
+  end
 end.parse!
 
 require "rubydex"
 
-workspace_path = ARGV.first
-
-# If a workspace path is passed, we need to ensure that Bundler is setup in that context so that we find the
-# dependencies for that project
-if workspace_path
-  gemfile_path = File.join(workspace_path, "Gemfile")
-
-  if File.exist?(gemfile_path)
-    ENV["BUNDLE_GEMFILE"] = gemfile_path
-
-    begin
-      Bundler.setup
-    rescue Bundler::BundlerError => e
-      $stderr.puts(<<~MESSAGE)
-        Bundle setup failed for #{gemfile_path}. Indexing of dependencies may be partial
-        Error:
-          #{e.message}
-      MESSAGE
-    end
-  end
+def __with_timer(message, &block)
+  print(message)
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+  block.call
+  duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start
+  puts " finished in #{duration.round(2)}ms"
 end
 
-graph = Rubydex::Graph.new(workspace_path: workspace_path)
-graph.index_workspace
+graph = Rubydex::Graph.new
+__with_timer("Indexing workspace...") { graph.index_workspace }
+__with_timer("Resolving graph...") { graph.resolve }
+
+if options[:interactive]
+  begin
+    require "irb"
+    IRB.setup(nil)
+    IRB.conf[:IRB_NAME] = "rubydex"
+    workspace = IRB::WorkSpace.new(binding)
+    IRB::Irb.new(workspace).run(IRB.conf)
+  rescue LoadError
+    abort("Interactive mode requires `irb` to be in the bundle")
+  end
+end

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/extconf.rb

@@ -141,10 +141,12 @@ end
 
 File.write("Makefile", new_makefile)
 
-begin
-  require "extconf_compile_commands_json"
+if developing_rubydex
+  begin
+    require "extconf_compile_commands_json"
 
-  ExtconfCompileCommandsJson.generate!
-  ExtconfCompileCommandsJson.symlink!
-rescue LoadError # rubocop:disable Lint/SuppressedException
+    ExtconfCompileCommandsJson.generate!
+    ExtconfCompileCommandsJson.symlink!
+  rescue LoadError # rubocop:disable Lint/SuppressedException
+  end
 end

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) {
@@ -303,6 +328,24 @@ static VALUE rdxr_graph_method_references(VALUE self) {
     return self;
 }
 
+// Graph#document: (String uri) -> Document?
+// Returns the Document for the given URI, or nil if it doesn't exist.
+static VALUE rdxr_graph_document(VALUE self, VALUE uri) {
+    Check_Type(uri, T_STRING);
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+    const uint64_t *uri_id = rdx_graph_get_document(graph, StringValueCStr(uri));
+
+    if (uri_id == NULL) {
+        return Qnil;
+    }
+
+    VALUE argv[] = {self, ULL2NUM(*uri_id)};
+    free_u64(uri_id);
+    return rb_class_new_instance(2, argv, cDocument);
+}
+
 // Graph#delete_document: (String uri) -> Document?
 // Deletes a document and all of its definitions from the graph.
 // Returns the removed Document or nil if it doesn't exist.
@@ -546,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);
 
@@ -559,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);
 
@@ -602,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);
@@ -673,9 +742,12 @@ 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);
+    rb_define_method(cGraph, "document", rdxr_graph_document, 1);
     rb_define_method(cGraph, "delete_document", rdxr_graph_delete_document, 1);
     rb_define_method(cGraph, "resolve", rdxr_graph_resolve, 0);
     rb_define_method(cGraph, "resolve_constant", rdxr_graph_resolve_constant, 2);
@@ -691,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/reference.c

@@ -75,6 +75,28 @@ static VALUE rdxr_method_reference_location(VALUE self) {
     return location;
 }
 
+// MethodReference#receiver -> Rubydex::Declaration?
+// Returns the resolved declaration for the receiver of the method call. Returns nil when the receiver is not a
+// tracked constant or cannot be resolved.
+static VALUE rdxr_method_reference_receiver(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_method_reference_receiver_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);
+}
+
 // ResolvedConstantReference#declaration -> Declaration
 static VALUE rdxr_resolved_constant_reference_declaration(VALUE self) {
     HandleData *data;
@@ -120,4 +142,5 @@ void rdxi_initialize_reference(VALUE mRubydex) {
     rb_define_method(cMethodReference, "initialize", rdxr_handle_initialize, 2);
     rb_define_method(cMethodReference, "name", rdxr_method_reference_name, 0);
     rb_define_method(cMethodReference, "location", rdxr_method_reference_location, 0);
+    rb_define_method(cMethodReference, "receiver", rdxr_method_reference_receiver, 0);
 }

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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubydex
-  VERSION = "0.1.0.beta14"
+  VERSION = "0.2.1"
 end

data/rbi/rubydex.rbi

@@ -152,6 +152,7 @@ class Rubydex::GlobalVariableDefinition < Rubydex::Definition; end
 class Rubydex::InstanceVariableDefinition < Rubydex::Definition; end
 class Rubydex::MethodAliasDefinition < Rubydex::Definition; end
 class Rubydex::MethodDefinition < Rubydex::Definition; end
+
 class Rubydex::ModuleDefinition < Rubydex::Definition
   sig { returns(T::Array[Rubydex::Mixin]) }
   def mixins; end
@@ -259,6 +260,9 @@ class Rubydex::Graph
   sig { params(uri: String).returns(T.nilable(Rubydex::Document)) }
   def delete_document(uri); end
 
+  sig { params(uri: String).returns(T.nilable(Rubydex::Document)) }
+  def document(uri); end
+
   sig { returns(T::Array[Rubydex::Diagnostic]) }
   def diagnostics; end
 
@@ -314,27 +318,56 @@ class Rubydex::Graph
   # Returns completion candidates for an expression context. This includes all keywords, constants, methods, instance
   # variables, class variables and global variables reachable from the current lexical scope and self type.
   #
-  # The nesting array represents the lexical scope stack, where the last element is the self type. An empty array
-  # defaults to `Object` as the self type (top-level context).
-  sig { params(nesting: T::Array[String]).returns(T::Array[T.any(Rubydex::Declaration, Rubydex::Keyword)]) }
-  def complete_expression(nesting); end
+  # The nesting array represents the lexical scope stack. The optional `self_receiver` keyword argument overrides the
+  # self type independently of the lexical scope (e.g., `"Foo::<Foo>"` for `def Foo.bar`). This distinction is important
+  # because constants and class variables are always attached to the lexical scope. Meanwhile, methods and instance
+  # variables are attached to the type of `self` and those don't always match.
+  sig do
+    params(
+      nesting: T::Array[String],
+      self_receiver: T.nilable(String),
+    ).returns(T::Array[T.any(Rubydex::Declaration, Rubydex::Keyword)])
+  end
+  def complete_expression(nesting, self_receiver: nil); end
 
   # Returns completion candidates after a namespace access operator (e.g., `Foo::`). This includes all constants and
   # singleton methods for the namespace and its ancestors.
-  sig { params(name: String).returns(T::Array[Rubydex::Declaration]) }
-  def complete_namespace_access(name); end
+  #
+  # The optional `self_receiver` kwarg is the caller's runtime self type. It's used to filter visibility-restricted
+  # singleton methods (e.g., `private_class_method`). Pass `nil` (the default) for top-level/script scope.
+  sig do
+    params(
+      name: String,
+      self_receiver: T.nilable(String),
+    ).returns(T::Array[Rubydex::Declaration])
+  end
+  def complete_namespace_access(name, self_receiver: nil); end
 
   # Returns completion candidates after a method call operator (e.g., `foo.`). This includes all methods that exist on
   # the type of the receiver and its ancestors.
-  sig { params(name: String).returns(T::Array[Rubydex::Method]) }
-  def complete_method_call(name); end
+  #
+  # The optional `self_receiver` kwarg is the caller's runtime self type. It's used for visibility checks for `private`
+  # and `protected` methods. Pass `nil` (the default) for top-level/script scope.
+  sig do
+    params(
+      name: String,
+      self_receiver: T.nilable(String),
+    ).returns(T::Array[Rubydex::Method])
+  end
+  def complete_method_call(name, self_receiver: nil); end
 
   # Returns completion candidates inside a method call's argument list (e.g., `foo.bar(|)`). This includes everything
   # that expression completion provides plus keyword argument names of the method being called.
   #
-  # The nesting array represents the lexical scope stack, where the last element is the self type.
-  sig { params(name: String, nesting: T::Array[String]).returns(T::Array[T.any(Rubydex::Declaration, Rubydex::Keyword, Rubydex::KeywordParameter)]) }
-  def complete_method_argument(name, nesting); end
+  # See `complete_expression` for the semantics of `nesting` and `self_receiver`.
+  sig do
+    params(
+      name: String,
+      nesting: T::Array[String],
+      self_receiver: T.nilable(String),
+    ).returns(T::Array[T.any(Rubydex::Declaration, Rubydex::Keyword, Rubydex::KeywordParameter)])
+  end
+  def complete_method_argument(name, nesting, self_receiver: nil); end
 
   private
 
@@ -415,6 +448,9 @@ class Rubydex::MethodReference < Rubydex::Reference
 
   sig { returns(String) }
   def name; end
+
+  sig { returns(T.nilable(Rubydex::Declaration)) }
+  def receiver; end
 end
 
 class Rubydex::Reference

data/rust/rubydex/src/diagnostic.rs

@@ -108,4 +108,5 @@ rules! {
 
     // Resolution
     UndefinedMethodVisibilityTarget;
+    UndefinedConstantVisibilityTarget;
 }

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

@@ -234,6 +234,7 @@ impl<'a> RubyIndexer<'a> {
                     Offset::from_prism_location(&name_loc),
                     str_id,
                 )));
+                self.visit(&opt_param.value());
             }
 
             if let Some(rest) = parameters_list.rest() {
@@ -276,6 +277,7 @@ impl<'a> RubyIndexer<'a> {
                         let str_id = self.local_graph.intern_string(self.offset_to_string(&offset));
 
                         parameters.push(Parameter::OptionalKeyword(ParameterStruct::new(offset, str_id)));
+                        self.visit(&optional.value());
                     }
                     _ => {}
                 }
@@ -1258,11 +1260,8 @@ impl<'a> RubyIndexer<'a> {
             let str_id = self.local_graph.intern_string(name);
             let offset = Offset::from_prism_location(&location);
             let definition = Definition::ConstantVisibility(Box::new(ConstantVisibilityDefinition::new(
-                self.local_graph.add_name(Name::new(
-                    str_id,
-                    receiver_name_id.map_or(ParentScope::None, ParentScope::Some),
-                    self.current_lexical_scope_name_id(),
-                )),
+                receiver_name_id,
+                str_id,
                 visibility,
                 self.uri_id,
                 offset,

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

@@ -3271,31 +3271,38 @@ mod visibility_tests {
         assert_no_local_diagnostics!(&context);
 
         assert_definition_at!(&context, "6:21-6:24", ConstantVisibility, |def| {
-            assert_def_name_eq!(&context, def, "BAR");
+            assert_string_eq!(&context, def.target(), "BAR");
+            assert!(def.receiver().is_none());
             assert_eq!(def.visibility(), &Visibility::Private);
         });
         assert_definition_at!(&context, "6:27-6:30", ConstantVisibility, |def| {
-            assert_def_name_eq!(&context, def, "BAZ");
+            assert_string_eq!(&context, def.target(), "BAZ");
+            assert!(def.receiver().is_none());
             assert_eq!(def.visibility(), &Visibility::Private);
         });
         assert_definition_at!(&context, "7:20-7:25", ConstantVisibility, |def| {
-            assert_def_name_eq!(&context, def, "FOO");
+            assert_string_eq!(&context, def.target(), "FOO");
+            assert!(def.receiver().is_none());
             assert_eq!(def.visibility(), &Visibility::Private);
         });
         assert_definition_at!(&context, "13:26-13:29", ConstantVisibility, |def| {
-            assert_def_name_eq!(&context, def, "Foo::BAR");
+            assert_string_eq!(&context, def.target(), "BAR");
+            assert_name_path_eq!(&context, "Foo", def.receiver().unwrap());
             assert_eq!(def.visibility(), &Visibility::Public);
         });
         assert_definition_at!(&context, "14:25-14:30", ConstantVisibility, |def| {
-            assert_def_name_eq!(&context, def, "Foo::BAZ");
+            assert_string_eq!(&context, def.target(), "BAZ");
+            assert_name_path_eq!(&context, "Foo", def.receiver().unwrap());
             assert_eq!(def.visibility(), &Visibility::Public);
         });
         assert_definition_at!(&context, "17:26-17:29", ConstantVisibility, |def| {
-            assert_def_name_eq!(&context, def, "Qux");
+            assert_string_eq!(&context, def.target(), "Qux");
+            assert!(def.receiver().is_none());
             assert_eq!(def.visibility(), &Visibility::Private);
         });
         assert_definition_at!(&context, "20:22-20:25", ConstantVisibility, |def| {
-            assert_def_name_eq!(&context, def, "Foo::BAR");
+            assert_string_eq!(&context, def.target(), "BAR");
+            assert_name_path_eq!(&context, "Foo", def.receiver().unwrap());
             assert_eq!(def.visibility(), &Visibility::Public);
         });
     }
@@ -4060,6 +4067,19 @@ mod constant_reference_tests {
         );
     }
 
+    #[test]
+    fn index_unresolved_constant_references_in_default_values() {
+        let context = index_source({
+            "
+            def foo(a = C1, b = C2::C3); end
+            def bar(a: C4, b: C5::C6); end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+        assert_constant_references_eq!(&context, ["C1", "C2", "C3", "C4", "C5", "C6"]);
+    }
+
     #[test]
     fn index_constant_path_and_write_visits_value() {
         let context = index_source({