rubydex 0.2.0-x86_64-linux → 0.2.1-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: becc016a629bebc1a97c5c55e03b9fdfff6ec3b19c70c043a8c1d1e2b836f5fb
-  data.tar.gz: f9a29d4ba9b08f793d9b173484e6499f340add0f38a66f8a24628961ecf52e78
+  metadata.gz: af48ce975a55310aaf8f2026be413cad45663642baf60ddda21ddfaf678a0e96
+  data.tar.gz: 298d02687b6b96bddf246a83b9d808705d5ebe33ce0fd5a87f230d2d6fa2f6b2
 SHA512:
-  metadata.gz: 2d194e96078296c7c52f303b55da3ef2d728402d2b5a5b948239be38426054981b5a14d45f297f78796c857bbd9811ec2205ddd4f4cef1a92b8da6319bbe680a
-  data.tar.gz: fceba88316043c60e27b0153bb5f3a0cea66b318453cef8a4f56f4edcb88745fa4b2ec32945a5006bb4d6d923904c37b0d7275eb9a5552baf05c8c560dac5395
+  metadata.gz: 1e6840ad668950cf5cf8f823f86eeb561de8cd3b60b1bc4d01b7afa390fd473b7268df85d6bba802d270b27a61c5224f7b7c7f8359f56274c829004ee9491843
+  data.tar.gz: a64f5c6f3f2f4c1dbed7774ab03216be98545a40892a3dffba8c6bb98376db901065e18fc96d1b7028a1c46fa9c9adde054a19e5a651eff694f044fcf218c18c

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/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/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.2.0"
+  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
@@ -317,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
 

data/rust/rubydex/src/diagnostic.rs

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

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

@@ -1260,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);
         });
     }

data/rust/rubydex/src/model/declaration.rs

@@ -339,6 +339,54 @@ impl Declaration {
         }
     }
 
+    #[must_use]
+    pub fn as_constant(&self) -> Option<&ConstantDeclaration> {
+        match self {
+            Declaration::Constant(constant) => Some(constant),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn as_constant_alias(&self) -> Option<&ConstantAliasDeclaration> {
+        match self {
+            Declaration::ConstantAlias(alias) => Some(alias),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn as_method(&self) -> Option<&MethodDeclaration> {
+        match self {
+            Declaration::Method(method) => Some(method),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn as_global_variable(&self) -> Option<&GlobalVariableDeclaration> {
+        match self {
+            Declaration::GlobalVariable(global) => Some(global),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn as_class_variable(&self) -> Option<&ClassVariableDeclaration> {
+        match self {
+            Declaration::ClassVariable(cvar) => Some(cvar),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn as_instance_variable(&self) -> Option<&InstanceVariableDeclaration> {
+        match self {
+            Declaration::InstanceVariable(ivar) => Some(ivar),
+            _ => None,
+        }
+    }
+
     #[must_use]
     pub fn definitions(&self) -> &[DefinitionId] {
         all_declarations!(self, it => &it.definition_ids)

data/rust/rubydex/src/model/definitions.rs

@@ -155,8 +155,8 @@ impl Definition {
             Definition::Module(d) => Some(d.name_id()),
             Definition::Constant(d) => Some(d.name_id()),
             Definition::ConstantAlias(d) => Some(d.name_id()),
-            Definition::ConstantVisibility(d) => Some(d.name_id()),
-            Definition::MethodVisibility(_)
+            Definition::ConstantVisibility(_)
+            | Definition::MethodVisibility(_)
             | Definition::GlobalVariable(_)
             | Definition::InstanceVariable(_)
             | Definition::ClassVariable(_)
@@ -711,7 +711,8 @@ impl ConstantAliasDefinition {
 
 #[derive(Debug)]
 pub struct ConstantVisibilityDefinition {
-    name_id: NameId,
+    receiver: Option<NameId>,
+    target: StringId,
     visibility: Visibility,
     uri_id: UriId,
     offset: Offset,
@@ -722,8 +723,10 @@ pub struct ConstantVisibilityDefinition {
 
 impl ConstantVisibilityDefinition {
     #[must_use]
+    #[allow(clippy::too_many_arguments)]
     pub const fn new(
-        name_id: NameId,
+        receiver: Option<NameId>,
+        target: StringId,
         visibility: Visibility,
         uri_id: UriId,
         offset: Offset,
@@ -732,7 +735,8 @@ impl ConstantVisibilityDefinition {
         lexical_nesting_id: Option<DefinitionId>,
     ) -> Self {
         Self {
-            name_id,
+            receiver,
+            target,
             visibility,
             uri_id,
             offset,
@@ -744,12 +748,17 @@ impl ConstantVisibilityDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.name_id))
+        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.target))
     }
 
     #[must_use]
-    pub fn name_id(&self) -> &NameId {
-        &self.name_id
+    pub fn receiver(&self) -> &Option<NameId> {
+        &self.receiver
+    }
+
+    #[must_use]
+    pub fn target(&self) -> &StringId {
+        &self.target
     }
 
     #[must_use]
@@ -782,7 +791,7 @@ impl ConstantVisibilityDefinition {
         &self.flags
     }
 }
-assert_mem_size!(ConstantVisibilityDefinition, 56);
+assert_mem_size!(ConstantVisibilityDefinition, 64);
 
 #[derive(Debug)]
 pub struct MethodVisibilityDefinition {