rubydex 0.2.2-aarch64-linux → 0.2.4-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 220a0eb3de71608c1daa45286224aa1f11ebd03b893564e60cfd9e7db66124c2
-  data.tar.gz: 747ef3a246e405c236b9efcc6b2d592033025b154cdf5e9afa03006732a10303
+  metadata.gz: 49147264143f618ef7d2b5bbfa983e511b86123dc01548c2a4176e686a44b57e
+  data.tar.gz: cbd51f1380330f85dde7861c7df96cbc1db4117458952c561164eef9c511901e
 SHA512:
-  metadata.gz: 4afa9fef910c50747666dbb3b464d86ba791e13e1a260041b9c845b32786a049b02da55a76583c98c749a4deabaa412e35fc71c45cb7da476b6058c88199fd08
-  data.tar.gz: 851d2924ff4d895866b5663e1f144960823fe57375a20511a08378840d013f9c6bf4f7de4a1303f9a1da2ea28ee4c2376aceb848d702f41175e933ccd98c7f8f
+  metadata.gz: 5daa009adaef78d504f2710aac72ec36875a3a7ae169048b36e7220d984ddaf7dd562431a460a44b95530bb030a341887ccf300d14646051f722ba0cc941e9bb
+  data.tar.gz: adf4c9a9faf405356b64e6de927a7aa4b8499164c9cf48918683b45ab0e7825668f5505d50e0b29305292bae3db511ae6ffb6ab2e96628c1b1ecdc2076fb8b3b

data/THIRD_PARTY_LICENSES.html

@@ -2957,10 +2957,10 @@ limitations under the License.
                             1.0.25</a></li>
                     <li><a
                             href=" https://github.com/modelcontextprotocol/rust-sdk/ ">rmcp-macros
-                            0.15.0</a></li>
+                            1.6.0</a></li>
                     <li><a
                             href=" https://github.com/modelcontextprotocol/rust-sdk/ ">rmcp
-                            0.15.0</a></li>
+                            1.4.0</a></li>
                     <li><a
                             href=" https://github.com/rust-lang/rustc-hash ">rustc-hash
                             2.1.1</a></li>

data/ext/rubydex/definition.c

@@ -1,4 +1,5 @@
 #include "definition.h"
+#include "declaration.h"
 #include "graph.h"
 #include "handle.h"
 #include "location.h"
@@ -172,6 +173,28 @@ static VALUE rdxr_definition_name_location(VALUE self) {
     return location;
 }
 
+// Definition#declaration -> Rubydex::Declaration?
+// Returns the declaration this definition belongs to or nil when it cannot be located (for example, before
+// `Graph#resolve` has run).
+static VALUE rdxr_definition_declaration(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    const struct CDeclaration *decl = rdx_definition_declaration(graph, data->id);
+    if (decl == NULL) {
+        return Qnil;
+    }
+
+    VALUE decl_class = rdxi_declaration_class_for_kind(decl->kind);
+    VALUE argv[] = {data->graph_obj, ULL2NUM(decl->id)};
+    free_c_declaration(decl);
+
+    return rb_class_new_instance(2, argv, decl_class);
+}
+
 static VALUE rdxi_build_constant_reference(VALUE graph_obj, const CConstantReference *cref) {
     VALUE ref_class = (cref->declaration_id == 0)
         ? cUnresolvedConstantReference
@@ -282,6 +305,7 @@ void rdxi_initialize_definition(VALUE mod) {
     rb_define_method(cDefinition, "name", rdxr_definition_name, 0);
     rb_define_method(cDefinition, "deprecated?", rdxr_definition_deprecated, 0);
     rb_define_method(cDefinition, "name_location", rdxr_definition_name_location, 0);
+    rb_define_method(cDefinition, "declaration", rdxr_definition_declaration, 0);
 
     cClassDefinition = rb_define_class_under(mRubydex, "ClassDefinition", cDefinition);
     rb_define_method(cClassDefinition, "superclass", rdxr_class_definition_superclass, 0);

data/lib/rubydex/declaration.rb

@@ -20,6 +20,13 @@ module Rubydex
     end
   end
 
+  class Namespace < Declaration
+    #: (String ancestor_name) -> bool
+    def has_ancestor?(ancestor_name)
+      ancestors.any? { |ancestor| ancestor.name == ancestor_name }
+    end
+  end
+
   class Class < Namespace
     include Visibility
   end
@@ -28,6 +35,11 @@ module Rubydex
     include Visibility
   end
 
+  class SingletonClass < Namespace
+    #: () -> Declaration
+    alias_method :attached_class, :owner
+  end
+
   class Constant < Declaration
     include Visibility
   end

data/lib/rubydex/reference.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Rubydex
+  class Reference
+    #: () -> Location
+    def location
+      raise NotImplementedError, "Subclasses must implement the #location method"
+    end
+  end
+end

data/lib/rubydex/version.rb

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

data/lib/rubydex.rb

@@ -23,3 +23,4 @@ require "rubydex/keyword_parameter"
 require "rubydex/graph"
 require "rubydex/declaration"
 require "rubydex/signature"
+require "rubydex/reference"

data/rbi/rubydex.rbi

@@ -15,6 +15,8 @@ class Rubydex::Comment
 end
 
 class Rubydex::ConstantReference < Rubydex::Reference
+  abstract!
+
   sig { returns(Rubydex::Location) }
   def location; end
 
@@ -36,6 +38,8 @@ class Rubydex::ResolvedConstantReference < Rubydex::ConstantReference
 end
 
 class Rubydex::Declaration
+  abstract!
+
   sig { returns(T::Enumerable[Rubydex::Definition]) }
   def definitions; end
 
@@ -92,12 +96,17 @@ class Rubydex::Method < Rubydex::Declaration
 end
 
 class Rubydex::Namespace < Rubydex::Declaration
+  abstract!
+
   sig { returns(T::Enumerable[Rubydex::ConstantReference]) }
   def references; end
 
   sig { returns(T::Enumerable[Rubydex::Namespace]) }
   def ancestors; end
 
+  sig { params(ancestor_name: String).returns(T::Boolean) }
+  def has_ancestor?(ancestor_name); end
+
   sig { returns(T::Enumerable[Rubydex::Namespace]) }
   def descendants; end
 
@@ -116,9 +125,15 @@ end
 
 class Rubydex::Class < Rubydex::Namespace; end
 class Rubydex::Module < Rubydex::Namespace; end
-class Rubydex::SingletonClass < Rubydex::Namespace; end
+
+class Rubydex::SingletonClass < Rubydex::Namespace
+  sig { returns(Rubydex::Declaration) }
+  def attached_class; end
+end
 
 class Rubydex::Definition
+  abstract!
+
   sig { returns(T::Array[Rubydex::Comment]) }
   def comments; end
 
@@ -134,6 +149,9 @@ class Rubydex::Definition
   sig { returns(T.nilable(Rubydex::Location)) }
   def name_location; end
 
+  sig { returns(T.nilable(Rubydex::Declaration)) }
+  def declaration; end
+
   class << self
     private
 
@@ -172,6 +190,8 @@ class Rubydex::ClassDefinition < Rubydex::Definition
 end
 
 class Rubydex::Mixin
+  abstract!
+
   sig { returns(Rubydex::ConstantReference) }
   attr_reader :constant_reference
 
@@ -454,6 +474,8 @@ class Rubydex::MethodReference < Rubydex::Reference
 end
 
 class Rubydex::Reference
+  abstract!
+
   class << self
     private
 

data/rust/Cargo.lock

@@ -971,9 +971,9 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rmcp"
-version = "0.15.0"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bef41ebc9ebed2c1b1d90203e9d1756091e8a00bbc3107676151f39868ca0ee"
+checksum = "f542f74cf247da16f19bbc87e298cd201e912314f4083e88cdd671f44f5fcb53"
 dependencies = [
  "async-trait",
  "base64",
@@ -993,9 +993,9 @@ dependencies = [
 
 [[package]]
 name = "rmcp-macros"
-version = "0.15.0"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e88ad84b8b6237a934534a62b379a5be6388915663c0cc598ceb9b3292bbbfe"
+checksum = "7caa6743cc0888e433105fe1bc551a7f607940b126a37bc97b478e86064627eb"
 dependencies = [
  "darling",
  "proc-macro2",

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

@@ -1274,6 +1274,7 @@ impl<'a> RubyIndexer<'a> {
         }
     }
 
+    #[allow(clippy::too_many_lines)]
     fn handle_singleton_method_visibility(
         &mut self,
         node: &ruby_prism::CallNode,
@@ -1307,7 +1308,10 @@ impl<'a> RubyIndexer<'a> {
             return;
         };
 
-        for argument in &arguments.arguments() {
+        let args = arguments.arguments();
+        let arg_count = args.len();
+
+        for argument in &args {
             match argument {
                 ruby_prism::Node::SymbolNode { .. } | ruby_prism::Node::StringNode { .. } => {
                     self.create_method_visibility_definition(
@@ -1316,6 +1320,88 @@ impl<'a> RubyIndexer<'a> {
                         DefinitionFlags::SINGLETON_METHOD_VISIBILITY,
                     );
                 }
+                ruby_prism::Node::ArrayNode { .. } if arg_count == 1 => {
+                    let array = argument.as_array_node().unwrap();
+                    for element in &array.elements() {
+                        match element {
+                            ruby_prism::Node::SymbolNode { .. } | ruby_prism::Node::StringNode { .. } => {
+                                self.create_method_visibility_definition(
+                                    &element,
+                                    visibility,
+                                    DefinitionFlags::SINGLETON_METHOD_VISIBILITY,
+                                );
+                            }
+                            ruby_prism::Node::DefNode { .. } => {
+                                let def_node = element.as_def_node().unwrap();
+                                if def_node.receiver().is_none() {
+                                    self.local_graph.add_diagnostic(
+                                        Rule::InvalidMethodVisibility,
+                                        Offset::from_prism_location(&element.location()),
+                                        format!("`{call_name}` requires a singleton method definition"),
+                                    );
+                                    self.visit(&element);
+                                    continue;
+                                }
+                                let name_loc = def_node.name_loc();
+                                let name = Self::location_to_string(&name_loc);
+                                self.create_method_visibility_definition_from_name(
+                                    &name,
+                                    &name_loc,
+                                    visibility,
+                                    DefinitionFlags::SINGLETON_METHOD_VISIBILITY,
+                                );
+                                self.visit(&element);
+                            }
+                            _ => {
+                                self.local_graph.add_diagnostic(
+                                    Rule::InvalidMethodVisibility,
+                                    Offset::from_prism_location(&element.location()),
+                                    format!(
+                                        "`{call_name}` array element must be a Symbol, String, or method definition"
+                                    ),
+                                );
+                                self.visit(&element);
+                            }
+                        }
+                    }
+                }
+                ruby_prism::Node::DefNode { .. } => {
+                    let def_node = argument.as_def_node().unwrap();
+                    if def_node.receiver().is_none() {
+                        self.local_graph.add_diagnostic(
+                            Rule::InvalidMethodVisibility,
+                            Offset::from_prism_location(&argument.location()),
+                            format!("`{call_name}` requires a singleton method definition"),
+                        );
+                        self.visit(&argument);
+                        continue;
+                    }
+                    let name_loc = def_node.name_loc();
+                    let name = Self::location_to_string(&name_loc);
+                    self.create_method_visibility_definition_from_name(
+                        &name,
+                        &name_loc,
+                        visibility,
+                        DefinitionFlags::SINGLETON_METHOD_VISIBILITY,
+                    );
+                    self.visit(&argument);
+                }
+                arg if Self::is_attr_call(&arg) => {
+                    self.local_graph.add_diagnostic(
+                        Rule::InvalidMethodVisibility,
+                        Offset::from_prism_location(&arg.location()),
+                        format!("`{call_name}` does not accept `attr_*` arguments"),
+                    );
+                    self.visit(&arg);
+                }
+                ruby_prism::Node::ArrayNode { .. } => {
+                    self.local_graph.add_diagnostic(
+                        Rule::InvalidMethodVisibility,
+                        Offset::from_prism_location(&argument.location()),
+                        format!("`{call_name}` array argument must be the only argument"),
+                    );
+                    self.visit(&argument);
+                }
                 _ => {
                     self.local_graph.add_diagnostic(
                         Rule::InvalidMethodVisibility,
@@ -1390,11 +1476,8 @@ impl<'a> RubyIndexer<'a> {
         let (name, location) = match arg {
             ruby_prism::Node::SymbolNode { .. } => {
                 let symbol = arg.as_symbol_node().unwrap();
-                if let Some(value_loc) = symbol.value_loc() {
-                    (Self::location_to_string(&value_loc), value_loc)
-                } else {
-                    return;
-                }
+                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();
@@ -1404,8 +1487,18 @@ impl<'a> RubyIndexer<'a> {
             _ => return,
         };
 
+        self.create_method_visibility_definition_from_name(&name, &location, visibility, flags);
+    }
+
+    fn create_method_visibility_definition_from_name(
+        &mut self,
+        name: &str,
+        location: &ruby_prism::Location,
+        visibility: Visibility,
+        flags: DefinitionFlags,
+    ) {
         let str_id = self.local_graph.intern_string(format!("{name}()"));
-        let arg_offset = Offset::from_prism_location(&location);
+        let arg_offset = Offset::from_prism_location(location);
         let definition = Definition::MethodVisibility(Box::new(MethodVisibilityDefinition::new(
             str_id,
             visibility,

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

@@ -2237,6 +2237,9 @@ mod visibility_tests {
 
             module Foo
               private_class_method NOT_INDEXED
+              attr_reader :a_attr_target
+              private_class_method attr_reader(:bad)
+              private_class_method def inline; end
             end
             ",
         );
@@ -2247,6 +2250,8 @@ mod visibility_tests {
                 "invalid-method-visibility: `private_class_method` called at top level (1:1-1:34)",
                 "invalid-method-visibility: `private_class_method` called at top level (2:1-2:39)",
                 "invalid-method-visibility: `private_class_method` called with a non-literal argument (6:24-6:35)",
+                "invalid-method-visibility: `private_class_method` does not accept `attr_*` arguments (8:24-8:41)",
+                "invalid-method-visibility: `private_class_method` requires a singleton method definition (9:24-9:39)",
             ]
         );
     }
@@ -2306,6 +2311,159 @@ mod visibility_tests {
         );
         assert_constant_references_eq!(&context, ["NESTED_REF"]);
     }
+
+    #[test]
+    fn index_private_class_method_inline_def() {
+        let context = index_source(
+            r"
+            class Foo
+              private_class_method def self.inline; end
+            end
+            ",
+        );
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "2:33-2:39", MethodVisibility, |def| {
+            assert!(def.flags().is_singleton_method_visibility());
+            assert_string_eq!(&context, def.str_id(), "inline()");
+            assert_eq!(def.visibility(), &Visibility::Private);
+        });
+    }
+
+    #[test]
+    fn index_private_class_method_array_form() {
+        let context = index_source(
+            r#"
+            class Foo
+              def self.flat; end
+              def self.flat2; end
+              def self.mixed; end
+
+              private_class_method [:flat, :flat2]
+              public_class_method [:mixed, "flat"]
+              private_class_method [def self.dyn; end]
+            end
+            "#,
+        );
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "6:26-6:30", MethodVisibility, |def| {
+            assert!(def.flags().is_singleton_method_visibility());
+            assert_string_eq!(&context, def.str_id(), "flat()");
+            assert_eq!(def.visibility(), &Visibility::Private);
+        });
+        assert_definition_at!(&context, "6:33-6:38", MethodVisibility, |def| {
+            assert!(def.flags().is_singleton_method_visibility());
+            assert_string_eq!(&context, def.str_id(), "flat2()");
+            assert_eq!(def.visibility(), &Visibility::Private);
+        });
+        assert_definition_at!(&context, "7:25-7:30", MethodVisibility, |def| {
+            assert!(def.flags().is_singleton_method_visibility());
+            assert_string_eq!(&context, def.str_id(), "mixed()");
+            assert_eq!(def.visibility(), &Visibility::Public);
+        });
+        assert_definition_at!(&context, "7:32-7:38", MethodVisibility, |def| {
+            assert!(def.flags().is_singleton_method_visibility());
+            assert_string_eq!(&context, def.str_id(), "flat()");
+            assert_eq!(def.visibility(), &Visibility::Public);
+        });
+        assert_definition_at!(&context, "8:34-8:37", MethodVisibility, |def| {
+            assert!(def.flags().is_singleton_method_visibility());
+            assert_string_eq!(&context, def.str_id(), "dyn()");
+            assert_eq!(def.visibility(), &Visibility::Private);
+        });
+    }
+
+    #[test]
+    fn index_private_class_method_array_continues_past_invalid_element() {
+        let context = index_source(
+            r"
+            class Foo
+              def self.flat; end
+              def self.later; end
+
+              private_class_method [:flat, SOME_CONST, :later]
+            end
+            ",
+        );
+
+        assert_local_diagnostics_eq!(
+            &context,
+            vec![
+                "invalid-method-visibility: `private_class_method` array element must be a Symbol, String, or method definition (5:32-5:42)"
+            ]
+        );
+
+        assert_definition_at!(&context, "5:26-5:30", MethodVisibility, |def| {
+            assert!(def.flags().is_singleton_method_visibility());
+            assert_string_eq!(&context, def.str_id(), "flat()");
+            assert_eq!(def.visibility(), &Visibility::Private);
+        });
+        assert_definition_at!(&context, "5:45-5:50", MethodVisibility, |def| {
+            assert!(def.flags().is_singleton_method_visibility());
+            assert_string_eq!(&context, def.str_id(), "later()");
+            assert_eq!(def.visibility(), &Visibility::Private);
+        });
+    }
+
+    #[test]
+    fn index_private_class_method_array_rejects_receiverless_def() {
+        let context = index_source(
+            r"
+            class Foo
+              private_class_method [def instance_method; end]
+            end
+            ",
+        );
+
+        assert_local_diagnostics_eq!(
+            &context,
+            vec![
+                "invalid-method-visibility: `private_class_method` requires a singleton method definition (2:25-2:49)"
+            ]
+        );
+
+        for def in context.graph().definitions().values() {
+            assert!(
+                !matches!(def, Definition::MethodVisibility(d) if d.flags().is_singleton_method_visibility()),
+                "should not record visibility for receiverless def in array"
+            );
+        }
+
+        assert_definition_at!(&context, "2:25-2:49", Method, |def| {
+            assert_def_str_eq!(&context, def, "instance_method()");
+            assert!(def.receiver().is_none());
+        });
+    }
+
+    #[test]
+    fn index_private_class_method_array_not_sole_arg_diagnostic() {
+        let context = index_source(
+            r"
+            class Foo
+              def self.a; end
+              def self.b; end
+
+              private_class_method [:a], :b
+            end
+            ",
+        );
+
+        assert_local_diagnostics_eq!(
+            &context,
+            vec![
+                "invalid-method-visibility: `private_class_method` array argument must be the only argument (5:24-5:28)"
+            ]
+        );
+
+        assert_definition_at!(&context, "5:31-5:32", MethodVisibility, |def| {
+            assert!(def.flags().is_singleton_method_visibility());
+            assert_string_eq!(&context, def.str_id(), "b()");
+            assert_eq!(def.visibility(), &Visibility::Private);
+        });
+    }
 }
 
 mod attr_accessor_tests {

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

@@ -15,7 +15,7 @@ use crate::model::name::{Name, NameRef, ParentScope, ResolvedName};
 use crate::model::references::{ConstantReference, MethodRef};
 use crate::model::string_ref::StringRef;
 use crate::model::visibility::Visibility;
-use crate::stats;
+use crate::{query, stats};
 
 /// An entity whose validity depends on a particular `NameId`.
 /// Used as the value type in the `name_dependents` reverse index.
@@ -650,7 +650,7 @@ impl Graph {
         let definitions = declaration.definitions();
 
         match declaration {
-            Declaration::Namespace(Namespace::Class(_) | Namespace::Module(_))
+            Declaration::Namespace(Namespace::Class(_) | Namespace::Module(_) | Namespace::Todo(_))
             | Declaration::Constant(_)
             | Declaration::ConstantAlias(_) => {
                 for def_id in definitions.iter().rev() {
@@ -661,25 +661,42 @@ impl Graph {
                 Some(Visibility::Public)
             }
             Declaration::Method(_) => {
+                let mut latest_alias: Option<DefinitionId> = None;
+
                 for def_id in definitions.iter().rev() {
                     let Some(definition) = self.definitions.get(def_id) else {
                         continue;
                     };
+
                     let visibility = match definition {
                         Definition::MethodVisibility(vis) => Some(*vis.visibility()),
                         Definition::Method(method) => Some(*method.visibility()),
                         Definition::AttrAccessor(attr) => Some(*attr.visibility()),
                         Definition::AttrReader(attr) => Some(*attr.visibility()),
                         Definition::AttrWriter(attr) => Some(*attr.visibility()),
+                        Definition::MethodAlias(_) => {
+                            if latest_alias.is_none() {
+                                latest_alias = Some(*def_id);
+                            }
+                            None
+                        }
                         _ => None,
                     };
+
                     if visibility.is_some() {
                         return visibility;
                     }
                 }
-                None
+
+                if let Some(alias_def_id) = latest_alias
+                    && let Ok(target_id) = query::follow_method_alias(self, alias_def_id)
+                {
+                    return self.visibility(&target_id);
+                }
+
+                Some(Visibility::Public)
             }
-            Declaration::Namespace(Namespace::SingletonClass(_) | Namespace::Todo(_))
+            Declaration::Namespace(Namespace::SingletonClass(_))
             | Declaration::GlobalVariable(_)
             | Declaration::InstanceVariable(_)
             | Declaration::ClassVariable(_) => None,

data/rust/rubydex/src/resolution_tests.rs

@@ -5460,4 +5460,45 @@ mod visibility_resolution_tests {
         assert_no_diagnostics!(&context);
         assert_visibility_eq!(context, "Foo::<Foo>#missing()", Visibility::Private);
     }
+
+    #[test]
+    fn retroactive_singleton_method_visibility_inline_def() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              private_class_method def self.bar; end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Private);
+    }
+
+    #[test]
+    fn retroactive_singleton_method_visibility_array_form() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r#"
+            class Foo
+              def self.a; end
+              def self.b; end
+              def self.c; end
+
+              private_class_method [:a, "b"]
+              public_class_method [:c]
+            end
+            "#,
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo::<Foo>#a()", Visibility::Private);
+        assert_visibility_eq!(context, "Foo::<Foo>#b()", Visibility::Private);
+        assert_visibility_eq!(context, "Foo::<Foo>#c()", Visibility::Public);
+    }
 }

data/rust/rubydex-mcp/Cargo.toml

@@ -12,7 +12,7 @@ path = "src/main.rs"
 [dependencies]
 rubydex = { path = "../rubydex" }
 clap = { version = "4.5.16", features = ["derive"] }
-rmcp = { version = "0.15", features = ["server", "macros", "transport-io", "schemars"] }
+rmcp = { version = "1.4", features = ["server", "macros", "transport-io", "schemars"] }
 tokio = { version = "1", features = ["macros", "rt", "io-std"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

data/rust/rubydex-mcp/src/server.rs

@@ -565,14 +565,13 @@ Pagination: tools that may return a high number of results include `total` for p
 
 Use Grep instead for: literal string search, log messages, comments, non-Ruby files, or content search rather than structural queries."#;
 
-#[tool_handler]
+#[tool_handler(router = self.tool_router)]
 impl ServerHandler for RubydexServer {
     fn get_info(&self) -> ServerInfo {
-        ServerInfo {
-            instructions: Some(SERVER_INSTRUCTIONS.into()),
-            capabilities: ServerCapabilities::builder().enable_tools().build(),
-            ..Default::default()
-        }
+        let mut info = ServerInfo::default();
+        info.instructions = Some(SERVER_INSTRUCTIONS.into());
+        info.capabilities = ServerCapabilities::builder().enable_tools().build();
+        info
     }
 }
 

data/rust/rubydex-sys/src/definition_api.rs

@@ -1,5 +1,6 @@
 //! This file provides the C API for Definition accessors
 
+use crate::declaration_api::CDeclaration;
 use crate::graph_api::{GraphPointer, with_graph};
 use crate::location_api::{Location, create_location_for_uri_and_offset};
 use crate::reference_api::CConstantReference;
@@ -250,6 +251,31 @@ pub unsafe extern "C" fn rdx_definition_location(pointer: GraphPointer, definiti
     })
 }
 
+/// Returns the declaration that the given definition belongs to. Returns NULL when the definition has no associated
+/// declaration (for example, before resolution has run or when the declaration cannot be located). Caller must free
+/// with `free_c_declaration`.
+///
+/// # Safety
+/// - `pointer` must be a valid pointer previously returned by `rdx_graph_new`.
+/// - `definition_id` must be a valid definition id.
+///
+/// # Panics
+/// This function will panic if the definition cannot be found.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_definition_declaration(pointer: GraphPointer, definition_id: u64) -> *const CDeclaration {
+    with_graph(pointer, |graph| {
+        let def_id = DefinitionId::new(definition_id);
+        let Some(decl_id) = graph.definition_id_to_declaration_id(def_id) else {
+            return ptr::null();
+        };
+        let Some(decl) = graph.declarations().get(decl_id) else {
+            return ptr::null();
+        };
+
+        Box::into_raw(Box::new(CDeclaration::from_declaration(*decl_id, decl))).cast_const()
+    })
+}
+
 /// Creates a new iterator over definition IDs for a given declaration by snapshotting the current set of IDs.
 ///
 /// # Panics

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubydex
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: aarch64-linux
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-05-08 00:00:00.000000000 Z
+date: 2026-05-26 00:00:00.000000000 Z
 dependencies: []
 description: A high-performance static analysis suite for Ruby, built in Rust with
   Ruby APIs
@@ -59,6 +59,7 @@ files:
 - lib/rubydex/librubydex_sys.so
 - lib/rubydex/location.rb
 - lib/rubydex/mixin.rb
+- lib/rubydex/reference.rb
 - lib/rubydex/signature.rb
 - lib/rubydex/version.rb
 - rbi/rubydex.rbi