rubydex 0.2.9 → 0.3.0

data/ext/rubydex/reference.c

@@ -17,6 +17,8 @@ VALUE cUnresolvedConstantReference;
 VALUE cResolvedConstantReference;
 VALUE cMethodReference;
 
+static VALUE cDocument;
+
 /*
  * call-seq:
  *   name -> String
@@ -28,6 +30,9 @@ static VALUE rdxr_constant_reference_name(VALUE self) {
     void *graph = rdxi_graph_from_handle(self, &data);
 
     const char *name = rdx_constant_reference_name(graph, data->id);
+    if (name == NULL) {
+        rb_raise(rb_eRuntimeError, "Constant reference must exist for a valid id");
+    }
     return rdxi_owned_c_string_to_ruby(name);
 }
 
@@ -42,11 +47,35 @@ static VALUE rdxr_constant_reference_location(VALUE self) {
     void *graph = rdxi_graph_from_handle(self, &data);
 
     Location *loc = rdx_constant_reference_location(graph, data->id);
+    if (loc == NULL) {
+        rb_raise(rb_eRuntimeError, "Constant reference must exist for a valid id");
+    }
     VALUE location = rdxi_build_location_value(loc);
     rdx_location_free(loc);
     return location;
 }
 
+/*
+ * call-seq:
+ *   document -> Rubydex::Document
+ *
+ * Returns the document this constant reference belongs to.
+ */
+static VALUE rdxr_constant_reference_document(VALUE self) {
+    HandleData *data;
+    void *graph = rdxi_graph_from_handle(self, &data);
+
+    const uint64_t *uri_id = rdx_constant_reference_document(graph, data->id);
+    if (uri_id == NULL) {
+        rb_raise(rb_eRuntimeError, "Constant reference not found");
+    }
+
+    VALUE argv[] = {data->graph_obj, ULL2NUM(*uri_id)};
+    free_u64(uri_id);
+
+    return rb_class_new_instance(2, argv, cDocument);
+}
+
 /*
  * call-seq:
  *   name -> String
@@ -58,6 +87,9 @@ static VALUE rdxr_method_reference_name(VALUE self) {
     void *graph = rdxi_graph_from_handle(self, &data);
 
     const char *name = rdx_method_reference_name(graph, data->id);
+    if (name == NULL) {
+        rb_raise(rb_eRuntimeError, "Method reference must exist for a valid id");
+    }
     return rdxi_owned_c_string_to_ruby(name);
 }
 
@@ -72,6 +104,9 @@ static VALUE rdxr_method_reference_location(VALUE self) {
     void *graph = rdxi_graph_from_handle(self, &data);
 
     Location *loc = rdx_method_reference_location(graph, data->id);
+    if (loc == NULL) {
+        rb_raise(rb_eRuntimeError, "Method reference must exist for a valid id");
+    }
     VALUE location = rdxi_build_location_value(loc);
     rdx_location_free(loc);
     return location;
@@ -100,6 +135,27 @@ static VALUE rdxr_method_reference_receiver(VALUE self) {
     return rb_class_new_instance(2, argv, decl_class);
 }
 
+/*
+ * call-seq:
+ *   document -> Rubydex::Document
+ *
+ * Returns the document this method reference belongs to.
+ */
+static VALUE rdxr_method_reference_document(VALUE self) {
+    HandleData *data;
+    void *graph = rdxi_graph_from_handle(self, &data);
+
+    const uint64_t *uri_id = rdx_method_reference_document(graph, data->id);
+    if (uri_id == NULL) {
+        rb_raise(rb_eRuntimeError, "Method reference not found");
+    }
+
+    VALUE argv[] = {data->graph_obj, ULL2NUM(*uri_id)};
+    free_u64(uri_id);
+
+    return rb_class_new_instance(2, argv, cDocument);
+}
+
 /*
  * call-seq:
  *   declaration -> Rubydex::Declaration
@@ -123,6 +179,8 @@ static VALUE rdxr_resolved_constant_reference_declaration(VALUE self) {
 }
 
 void rdxi_initialize_reference(VALUE mRubydex) {
+    cDocument = rb_const_get(mRubydex, rb_intern("Document"));
+
     cReference = rb_define_class_under(mRubydex, "Reference", rb_cObject);
     rb_define_alloc_func(cReference, rdxr_handle_alloc);
     rb_define_method(cReference, "initialize", rdxr_handle_initialize, 2);
@@ -132,6 +190,7 @@ void rdxi_initialize_reference(VALUE mRubydex) {
     rb_define_alloc_func(cConstantReference, rdxr_handle_alloc);
     rb_define_method(cConstantReference, "initialize", rdxr_handle_initialize, 2);
     rb_define_method(cConstantReference, "location", rdxr_constant_reference_location, 0);
+    rb_define_method(cConstantReference, "document", rdxr_constant_reference_document, 0);
     rb_funcall(rb_singleton_class(cConstantReference), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
 
     cUnresolvedConstantReference = rb_define_class_under(mRubydex, "UnresolvedConstantReference", cConstantReference);
@@ -148,4 +207,5 @@ void rdxi_initialize_reference(VALUE mRubydex) {
     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);
+    rb_define_method(cMethodReference, "document", rdxr_method_reference_document, 0);
 }

data/ext/rubydex/rubydex.c

@@ -4,6 +4,7 @@
 #include "document.h"
 #include "graph.h"
 #include "location.h"
+#include "query.h"
 #include "reference.h"
 #include "signature.h"
 
@@ -19,6 +20,7 @@ void Init_rubydex(void) {
      */
     mRubydex = rb_define_module("Rubydex");
     rdxi_initialize_graph(mRubydex);
+    rdxi_initialize_query(mRubydex);
     rdxi_initialize_declaration(mRubydex);
     rdxi_initialize_document(mRubydex);
     rdxi_initialize_definition(mRubydex);

data/ext/rubydex/utils.c

@@ -52,6 +52,18 @@ VALUE rdxi_owned_c_string_to_ruby(const char *string) {
     return value;
 }
 
+// Coerce an optional String, Symbol, or nil to a C string, defaulting to `default_value` for nil.
+const char *rdxi_symbol_or_string_cstr(VALUE value, const char *default_value) {
+    if (NIL_P(value)) {
+        return default_value;
+    }
+    if (RB_TYPE_P(value, T_SYMBOL)) {
+        value = rb_sym2str(value);
+    }
+    Check_Type(value, T_STRING);
+    return StringValueCStr(value);
+}
+
 // Yield body for iterating over declarations
 VALUE rdxi_declarations_yield(VALUE args) {
     VALUE self = rb_ary_entry(args, 0);

data/ext/rubydex/utils.h

@@ -17,6 +17,11 @@ void rdxi_check_array_of_strings(VALUE array);
 // Returns nil when the Rust side returned NULL.
 VALUE rdxi_owned_c_string_to_ruby(const char *string);
 
+// Coerce an optional String, Symbol, or nil to a C string, returning `default_value` when the value
+// is nil. A non-nil value must be a String or Symbol, otherwise a `TypeError` is raised. The
+// returned pointer is owned by the Ruby VALUE and is only valid while it stays live.
+const char *rdxi_symbol_or_string_cstr(VALUE value, const char *default_value);
+
 // Yield body for iterating over declarations
 VALUE rdxi_declarations_yield(VALUE args);
 

data/lib/rubydex/version.rb

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

data/rbi/rubydex.rbi

@@ -20,6 +20,9 @@ class Rubydex::ConstantReference < Rubydex::Reference
   sig { returns(Rubydex::Location) }
   def location; end
 
+  sig { returns(Rubydex::Document) }
+  def document; end
+
   class << self
     private
 
@@ -158,6 +161,9 @@ class Rubydex::Definition
   sig { returns(T::Array[Rubydex::Definition]) }
   def lexical_nesting; end
 
+  sig { returns(Rubydex::Document) }
+  def document; end
+
   class << self
     private
 
@@ -278,6 +284,19 @@ end
 
 class Rubydex::IntegrityFailure < Rubydex::Failure; end
 
+class Rubydex::Query
+  class << self
+    sig { params(query: String).returns(Rubydex::Query) }
+    def parse(query); end
+
+    sig { params(format: T.any(String, Symbol)).returns(String) }
+    def schema(format = :table); end
+  end
+
+  sig { params(graph: Rubydex::Graph, format: T.any(String, Symbol)).returns(String) }
+  def render(graph, format = :table); end
+end
+
 class Rubydex::Graph
   sig { params(workspace_path: T.nilable(String)).void }
   def initialize(workspace_path: nil); end
@@ -502,6 +521,9 @@ class Rubydex::MethodReference < Rubydex::Reference
 
   sig { returns(T.nilable(Rubydex::Declaration)) }
   def receiver; end
+
+  sig { returns(Rubydex::Document) }
+  def document; end
 end
 
 class Rubydex::Reference

data/rust/Cargo.lock

@@ -260,6 +260,12 @@ version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
+[[package]]
+name = "cypher-parser"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fed0d1e561d51e651bdf70f8439da293fd0f1fe34d8431059061eadaefc7abb1"
+
 [[package]]
 name = "difflib"
 version = "0.4.0"
@@ -763,6 +769,7 @@ dependencies = [
  "crossbeam-channel",
  "crossbeam-deque",
  "crossbeam-utils",
+ "cypher-parser",
  "glob",
  "libc",
  "line-index",

data/rust/rubydex/Cargo.toml

@@ -27,6 +27,7 @@ jemalloc_dylib = ["jemalloc", "tikv-jemallocator/disable_initial_exec_tls"]
 test_utils = ["dep:tempfile"]
 
 [dependencies]
+cypher-parser = "0.2"
 ruby-prism = "1.9.0"
 ruby-rbs = "0.3"
 url = "2.5.4"

data/rust/rubydex/benches/graph_memory.rs

@@ -1,6 +1,6 @@
 #[cfg(all(feature = "jemalloc", not(target_os = "windows")))]
 mod imp {
-    use std::collections::HashSet;
+    use std::time::Instant;
 
     use rubydex::{
         indexing::{self, IndexerBackend},
@@ -18,13 +18,31 @@ mod imp {
     }
 
     pub fn run() {
-        let paths: Vec<String> = std::env::args().skip(1).collect();
-        let paths = if paths.is_empty() { vec![".".to_string()] } else { paths };
-        let (file_paths, _) = listing::collect_file_paths(paths, &HashSet::new());
+        let mut args = std::env::args().skip(1);
+
+        let workspace = args
+            .next()
+            .expect("incorrect usage of cargo bench --bench graph_memory. Please use `utils/bench-graph-memory` instead of invoking this benchmark directly.");
+        let workspace_path = std::fs::canonicalize(&workspace).expect("the workspace path must exist");
+        assert!(workspace_path.is_dir(), "the workspace path must be a directory");
 
         let mut graph = Graph::new();
+        graph.set_workspace_path(workspace_path);
+
+        if let Err(error) = graph.load_config(None) {
+            eprintln!("{error}");
+        }
+
+        let time = Instant::now();
+
+        let (file_paths, _) = listing::collect_file_paths(args.collect(), &graph.excluded_patterns());
+        println!("Listing {:.2}s", time.elapsed().as_secs_f64());
+
         let _ = indexing::index_files(&mut graph, file_paths, IndexerBackend::RubyIndexer);
+        println!("Indexing {:.2}s", time.elapsed().as_secs_f64());
+
         Resolver::new(&mut graph).resolve();
+        println!("Resolution {:.2}s", time.elapsed().as_secs_f64());
 
         // Compare the total memory used in the allocator before and after dropping the graph
         let before_drop = allocated_bytes();

data/rust/rubydex/src/compile_assertions.rs

@@ -11,3 +11,18 @@ macro_rules! assert_mem_size {
         const _: [(); $size] = [(); std::mem::size_of::<$struct>()];
     };
 }
+
+/// Asserts at compile time that a type is `Send + Sync`.
+///
+/// The `Graph` is shared across Ractors/threads behind a `RwLock`, so it must stay
+/// `Send + Sync`. This assertion fails the build if a field that breaks either trait
+/// is ever added.
+#[macro_export]
+macro_rules! assert_send_sync {
+    ($struct:ident) => {
+        const _: fn() = || {
+            fn assert_send_sync<T: ?Sized + Send + Sync>() {}
+            assert_send_sync::<$struct>();
+        };
+    };
+}

data/rust/rubydex/src/diagnostic.rs

@@ -103,7 +103,7 @@ rules! {
     DynamicSingletonDefinition;
     DynamicAncestor;
     TopLevelMixinSelf;
-    InvalidPrivateConstant;
+    InvalidConstantVisibility;
     InvalidMethodVisibility;
 
     // Resolution

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

@@ -80,7 +80,16 @@ impl<'a> RBSIndexer<'a> {
             let Node::Symbol(symbol) = path_node else {
                 continue;
             };
-            parent_scope = ParentScope::Some(self.intern_name(&symbol, parent_scope, nesting_name_id));
+            let name_id = self.intern_name(&symbol, parent_scope, nesting_name_id);
+
+            // Emit a constant reference for each parent-scope segment so it gets its own resolution
+            // unit, mirroring the Ruby indexer (see `index_constant_reference`). Otherwise the
+            // parent scope is an orphan name that never resolves, leaving qualified references stuck.
+            let offset = Offset::from_rbs_location(&symbol.location());
+            self.local_graph
+                .add_constant_reference(ConstantReference::new(name_id, self.uri_id, offset));
+
+            parent_scope = ParentScope::Some(name_id);
         }
 
         self.intern_name(&type_name.name(), parent_scope, nesting_name_id)
@@ -486,7 +495,10 @@ impl Visit for RBSIndexer<'_> {
             self.uri_id,
             offset,
             comments,
-            Self::flags(&constant_node.annotations()),
+            // RBS establishes that the constant exists, but its value type is intentionally not
+            // represented in the graph. Treat it like a dynamic Ruby assignment so resolution
+            // may promote it when a namespace or singleton receiver is required.
+            Self::flags(&constant_node.annotations()) | DefinitionFlags::PROMOTABLE,
             lexical_nesting_id,
         )));
 

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

@@ -386,21 +386,8 @@ impl<'a> RubyIndexer<'a> {
     {
         if let Some(arguments) = node.arguments() {
             for argument in &arguments.arguments() {
-                match argument {
-                    ruby_prism::Node::SymbolNode { .. } => {
-                        let symbol = argument.as_symbol_node().unwrap();
-
-                        if let Some(value_loc) = symbol.value_loc() {
-                            let name = Self::location_to_string(&value_loc);
-                            f(name, value_loc);
-                        }
-                    }
-                    ruby_prism::Node::StringNode { .. } => {
-                        let string = argument.as_string_node().unwrap();
-                        let name = String::from_utf8_lossy(string.unescaped()).to_string();
-                        f(name, argument.location());
-                    }
-                    _ => {}
+                if let Some((name, location)) = Self::extract_literal_name(&argument) {
+                    f(name, location);
                 }
             }
         }
@@ -1193,10 +1180,11 @@ impl<'a> RubyIndexer<'a> {
 
     fn handle_constant_visibility(&mut self, node: &ruby_prism::CallNode, visibility: Visibility) {
         let receiver = node.receiver();
+        let call_name = String::from_utf8_lossy(node.name().as_slice());
 
-        let receiver_name_id = match receiver {
+        let receiver_name_id = match &receiver {
             Some(ruby_prism::Node::ConstantPathNode { .. } | ruby_prism::Node::ConstantReadNode { .. }) => {
-                self.index_constant_reference(&receiver.unwrap(), true)
+                self.index_constant_reference(receiver.as_ref().unwrap(), true)
             }
             Some(ruby_prism::Node::SelfNode { .. }) | None => match self.nesting_stack.last() {
                 Some(Nesting::Method(_)) => {
@@ -1205,20 +1193,20 @@ impl<'a> RubyIndexer<'a> {
                 }
                 None => {
                     self.local_graph.add_diagnostic(
-                        Rule::InvalidPrivateConstant,
+                        Rule::InvalidConstantVisibility,
                         Offset::from_prism_location(&node.location()),
-                        "Private constant called at top level".to_string(),
+                        format!("`{call_name}` called at top level"),
                     );
                     self.visit_call_node_parts(node);
                     return;
                 }
                 _ => None,
             },
-            _ => {
+            Some(other) => {
                 self.local_graph.add_diagnostic(
-                    Rule::InvalidPrivateConstant,
-                    Offset::from_prism_location(&node.location()),
-                    "Dynamic receiver for private constant".to_string(),
+                    Rule::InvalidConstantVisibility,
+                    Offset::from_prism_location(&other.location()),
+                    format!("Dynamic receiver for `{call_name}`"),
                 );
                 self.visit_call_node_parts(node);
                 return;
@@ -1230,29 +1218,14 @@ impl<'a> RubyIndexer<'a> {
         };
 
         for argument in &arguments.arguments() {
-            let (name, location) = match argument {
-                ruby_prism::Node::SymbolNode { .. } => {
-                    let symbol = argument.as_symbol_node().unwrap();
-                    if let Some(value_loc) = symbol.value_loc() {
-                        (Self::location_to_string(&value_loc), value_loc)
-                    } else {
-                        continue;
-                    }
-                }
-                ruby_prism::Node::StringNode { .. } => {
-                    let string = argument.as_string_node().unwrap();
-                    let name = String::from_utf8_lossy(string.unescaped()).to_string();
-                    (name, argument.location())
-                }
-                _ => {
-                    self.local_graph.add_diagnostic(
-                        Rule::InvalidPrivateConstant,
-                        Offset::from_prism_location(&argument.location()),
-                        "Private constant called with non-symbol argument".to_string(),
-                    );
-                    self.visit(&argument);
-                    continue;
-                }
+            let Some((name, location)) = Self::extract_literal_name(&argument) else {
+                self.local_graph.add_diagnostic(
+                    Rule::InvalidConstantVisibility,
+                    Offset::from_prism_location(&argument.location()),
+                    format!("`{call_name}` called with a non-literal argument"),
+                );
+                self.visit(&argument);
+                continue;
             };
 
             let str_id = self.local_graph.intern_string(name);
@@ -1414,6 +1387,22 @@ impl<'a> RubyIndexer<'a> {
         }
     }
 
+    fn extract_literal_name<'b>(arg: &ruby_prism::Node<'b>) -> Option<(String, ruby_prism::Location<'b>)> {
+        match arg {
+            ruby_prism::Node::SymbolNode { .. } => {
+                let symbol = arg.as_symbol_node().unwrap();
+                let value_loc = symbol.value_loc()?;
+                Some((Self::location_to_string(&value_loc), value_loc))
+            }
+            ruby_prism::Node::StringNode { .. } => {
+                let string = arg.as_string_node().unwrap();
+                let name = String::from_utf8_lossy(string.unescaped()).to_string();
+                Some((name, arg.location()))
+            }
+            _ => None,
+        }
+    }
+
     fn is_attr_call(arg: &ruby_prism::Node) -> bool {
         arg.as_call_node().is_some_and(|call| {
             let receiver = call.receiver();
@@ -1452,6 +1441,18 @@ impl<'a> RubyIndexer<'a> {
                 ruby_prism::Node::SymbolNode { .. } | ruby_prism::Node::StringNode { .. }
             ) {
                 self.create_method_visibility_definition(&arg, visibility, DefinitionFlags::empty());
+                if visibility == Visibility::ModuleFunction {
+                    // `module_function` also creates a public singleton method, so we emit a
+                    // second def for the singleton side. The two defs stay separate (rather than
+                    // shared) so reverse-lookup invalidation can detach `Foo#bar` and
+                    // `Foo::<Foo>#bar` independently. The `SINGLETON_METHOD_VISIBILITY` flag
+                    // routes this one to the singleton class.
+                    self.create_method_visibility_definition(
+                        &arg,
+                        visibility,
+                        DefinitionFlags::SINGLETON_METHOD_VISIBILITY,
+                    );
+                }
             } else {
                 // Unsupported arg — diagnostic + visit for side effects.
                 let arg_offset = Offset::from_prism_location(&arg.location());
@@ -1473,18 +1474,8 @@ impl<'a> RubyIndexer<'a> {
         visibility: Visibility,
         flags: DefinitionFlags,
     ) {
-        let (name, location) = match arg {
-            ruby_prism::Node::SymbolNode { .. } => {
-                let symbol = arg.as_symbol_node().unwrap();
-                let Some(value_loc) = symbol.value_loc() else { return };
-                (Self::location_to_string(&value_loc), value_loc)
-            }
-            ruby_prism::Node::StringNode { .. } => {
-                let string = arg.as_string_node().unwrap();
-                let name = String::from_utf8_lossy(string.unescaped()).to_string();
-                (name, arg.location())
-            }
-            _ => return,
+        let Some((name, location)) = Self::extract_literal_name(arg) else {
+            return;
         };
 
         self.create_method_visibility_definition_from_name(&name, &location, visibility, flags);

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

@@ -1750,20 +1750,20 @@ mod visibility_tests {
     fn index_private_constant_calls_diagnostics() {
         let context = index_source({
             "
-            private_constant :NOT_INDEXED
-            self.private_constant :NOT_INDEXED
-            foo.private_constant :NOT_INDEXED # not indexed, dynamic receiver
+            private_constant :BAR # not indexed, called at top level
+            self.private_constant :BAR # not indexed, self receiver at top level
+            foo.private_constant :BAR # not indexed, dynamic receiver
 
             module Foo
-              private_constant NOT_INDEXED, not_indexed # not indexed, not a symbol
+              private_constant SomeConst, some_method # not indexed, non-literal arguments
               private_constant # not indexed, no arguments
 
               def self.qux
-                private_constant :Bar # not indexed, dynamic
+                private_constant :BAR # not indexed, inside a method
               end
 
               def foo
-                private_constant :Bar # not indexed, dynamic
+                private_constant :BAR # not indexed, inside a method
               end
             end
             "
@@ -1772,15 +1772,52 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-private-constant: Private constant called at top level (1:1-1:30)",
-                "invalid-private-constant: Private constant called at top level (2:1-2:35)",
-                "invalid-private-constant: Dynamic receiver for private constant (3:1-3:34)",
-                "invalid-private-constant: Private constant called with non-symbol argument (6:20-6:31)",
-                "invalid-private-constant: Private constant called with non-symbol argument (6:33-6:44)",
+                "invalid-constant-visibility: `private_constant` called at top level (1:1-1:22)",
+                "invalid-constant-visibility: `private_constant` called at top level (2:1-2:27)",
+                "invalid-constant-visibility: Dynamic receiver for `private_constant` (3:1-3:4)",
+                "invalid-constant-visibility: `private_constant` called with a non-literal argument (6:20-6:29)",
+                "invalid-constant-visibility: `private_constant` called with a non-literal argument (6:31-6:42)",
             ]
         );
 
-        assert_eq!(context.graph().definitions().len(), 3); // Foo, Foo::Qux, Foo#foo
+        assert_eq!(context.graph().definitions().len(), 3); // Foo, Foo.qux, Foo#foo
+    }
+
+    #[test]
+    fn index_public_constant_calls_diagnostics() {
+        let context = index_source({
+            "
+            public_constant :BAR # not indexed, called at top level
+            self.public_constant :BAR # not indexed, self receiver at top level
+            foo.public_constant :BAR # not indexed, dynamic receiver
+
+            module Foo
+              public_constant SomeConst, some_method # not indexed, non-literal arguments
+              public_constant # not indexed, no arguments
+
+              def self.qux
+                public_constant :BAR # not indexed, inside a method
+              end
+
+              def foo
+                public_constant :BAR # not indexed, inside a method
+              end
+            end
+            "
+        });
+
+        assert_local_diagnostics_eq!(
+            &context,
+            vec![
+                "invalid-constant-visibility: `public_constant` called at top level (1:1-1:21)",
+                "invalid-constant-visibility: `public_constant` called at top level (2:1-2:26)",
+                "invalid-constant-visibility: Dynamic receiver for `public_constant` (3:1-3:4)",
+                "invalid-constant-visibility: `public_constant` called with a non-literal argument (6:19-6:28)",
+                "invalid-constant-visibility: `public_constant` called with a non-literal argument (6:30-6:41)",
+            ]
+        );
+
+        assert_eq!(context.graph().definitions().len(), 3); // Foo, Foo.qux, Foo#foo
     }
 
     #[test]
@@ -2021,10 +2058,29 @@ mod visibility_tests {
 
         assert_no_local_diagnostics!(&context);
 
-        assert_definition_at!(&context, "4:20-4:23", MethodVisibility, |def| {
-            assert_def_str_eq!(&context, def, "foo()");
-            assert_eq!(def.visibility(), &Visibility::ModuleFunction);
-        });
+        let defs = context.all_definitions_at("4:20-4:23");
+        assert_eq!(defs.len(), 2, "expected two MethodVisibility defs");
+
+        let mut instance_side = None;
+        let mut singleton_side = None;
+        for def in defs {
+            let Definition::MethodVisibility(method_vis) = def else {
+                panic!("expected MethodVisibility, got {:?}", def.kind());
+            };
+            if method_vis.flags().is_singleton_method_visibility() {
+                singleton_side = Some(method_vis.as_ref());
+            } else {
+                instance_side = Some(method_vis.as_ref());
+            }
+        }
+
+        let instance_side = instance_side.expect("missing instance-side def");
+        assert_def_str_eq!(&context, instance_side, "foo()");
+        assert_eq!(instance_side.visibility(), &Visibility::ModuleFunction);
+
+        let singleton_side = singleton_side.expect("missing singleton-side def");
+        assert_def_str_eq!(&context, singleton_side, "foo()");
+        assert_eq!(singleton_side.visibility(), &Visibility::ModuleFunction);
     }
 
     #[test]