rubydex 0.2.2-x86_64-linux → 0.2.3-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf448d09196baf65923ae36025d997b78973a21f947552c83f8c230b57bb4009
-  data.tar.gz: 9bcfe91415218d546aca1929b9990222d269caccb8c14700df1e3cbb2ac0a275
+  metadata.gz: 4aa89b9ebd052a79e8e4d9c59e8692785b09068ff185362fcfad152b1744db4d
+  data.tar.gz: b19d59ff132c8382047e6d538e9d8894d613c7f52623d1aecec524ed87d5e7c1
 SHA512:
-  metadata.gz: 6b5204db7b41fde06d87c842d16467834c5b87dd1233f6f12306228a6ff2aef5b0062603cf7d376004e43d5904232c2dd14d9a49e253e66ccb701783d29e47cb
-  data.tar.gz: 9af30014522716456a0d5dc03e3174c3c5c33d0be1f26b85ac76460e3dc4a4e801bcd82e7221df62f5d683cab78ed0aad4f267331c21269222013a345386eac6
+  metadata.gz: ebf4a08fc65b9825998e48afdd8a19ea787978116622e69f1b9f26a18237333ed680b07b3c8d1ef65817577e14413960223ba3d281e4fa4651c4d62f84d6e826
+  data.tar.gz: b0716909fff42f12ad084a25f642651e147c76ec49f810b6191f409203b4ca9a6ecc99db71e0e83c324976ecafb6307ac8e7216678fc65e5758eb3e92a680d81

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/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.3"
 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,6 +96,8 @@ class Rubydex::Method < Rubydex::Declaration
 end
 
 class Rubydex::Namespace < Rubydex::Declaration
+  abstract!
+
   sig { returns(T::Enumerable[Rubydex::ConstantReference]) }
   def references; end
 
@@ -119,6 +125,8 @@ class Rubydex::Module < Rubydex::Namespace; end
 class Rubydex::SingletonClass < Rubydex::Namespace; end
 
 class Rubydex::Definition
+  abstract!
+
   sig { returns(T::Array[Rubydex::Comment]) }
   def comments; end
 
@@ -134,6 +142,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 +183,8 @@ class Rubydex::ClassDefinition < Rubydex::Definition
 end
 
 class Rubydex::Mixin
+  abstract!
+
   sig { returns(Rubydex::ConstantReference) }
   attr_reader :constant_reference
 
@@ -454,6 +467,8 @@ class Rubydex::MethodReference < Rubydex::Reference
 end
 
 class Rubydex::Reference
+  abstract!
+
   class << self
     private
 

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/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-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.3
 platform: x86_64-linux
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-05-08 00:00:00.000000000 Z
+date: 2026-05-11 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