rubydex 0.2.1 → 0.2.2

data/rust/rubydex/src/resolution_tests.rs

@@ -4926,6 +4926,25 @@ mod visibility_resolution_tests {
         };
     }
 
+    #[test]
+    fn retroactive_visibility_override_applies_in_source_order() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              def bar; end
+              private :bar
+              public :bar
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo#bar()", Visibility::Public);
+    }
+
     #[test]
     fn retroactive_visibility_on_direct_method() {
         let mut context = GraphTest::new();
@@ -5066,7 +5085,7 @@ mod visibility_resolution_tests {
         assert_diagnostics_eq!(
             context,
             &[
-                "undefined-method-visibility-target: undefined method `nonexistent()` for visibility change in `Foo` (2:12-2:23)"
+                "undefined-method-visibility-target: undefined method `Foo#nonexistent()` for visibility change (2:12-2:23)"
             ]
         );
     }
@@ -5306,4 +5325,139 @@ mod visibility_resolution_tests {
 
         assert_visibility_eq!(context, "Foo::BAR", Visibility::Private);
     }
+
+    #[test]
+    fn retroactive_singleton_method_visibility_on_direct_member() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              def self.bar; end
+              def self.baz; end
+
+              private_class_method :bar
+              private_class_method :baz
+              public_class_method :baz
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Private);
+        assert_visibility_eq!(context, "Foo::<Foo>#baz()", Visibility::Public);
+    }
+
+    #[test]
+    fn retroactive_singleton_method_visibility_on_inherited_method() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Parent
+              def self.foo; end
+            end
+
+            class Child < Parent
+              private_class_method :foo
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_declaration_exists!(context, "Child::<Child>#foo()");
+        assert_visibility_eq!(context, "Child::<Child>#foo()", Visibility::Private);
+        assert_visibility_eq!(context, "Parent::<Parent>#foo()", Visibility::Public);
+    }
+
+    #[test]
+    fn retroactive_singleton_method_visibility_on_undefined_method_emits_diagnostic() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              private_class_method :nonexistent
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_diagnostics_eq!(
+            context,
+            &[
+                "undefined-method-visibility-target: undefined method `Foo::<Foo>#nonexistent()` for visibility change (2:25-2:36)"
+            ]
+        );
+    }
+
+    #[test]
+    fn retroactive_singleton_method_visibility_undefined_target_diagnostic_clears_when_file_deleted() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+            end
+            ",
+        );
+        context.index_uri(
+            "file:///bad.rb",
+            r"
+            class Foo
+              private_class_method :missing
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_diagnostics_eq!(
+            context,
+            &[
+                "undefined-method-visibility-target: undefined method `Foo::<Foo>#missing()` for visibility change (2:25-2:32)"
+            ]
+        );
+
+        context.delete_uri("file:///bad.rb");
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+    }
+
+    #[test]
+    fn retroactive_singleton_method_visibility_undefined_target_diagnostic_clears_when_target_added() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              private_class_method :missing
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_diagnostics_eq!(
+            context,
+            &[
+                "undefined-method-visibility-target: undefined method `Foo::<Foo>#missing()` for visibility change (2:25-2:32)"
+            ]
+        );
+
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              def self.missing; end
+              private_class_method :missing
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo::<Foo>#missing()", Visibility::Private);
+    }
 }

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

@@ -197,42 +197,19 @@ pub unsafe extern "C" fn rdx_declaration_find_member(
 
     with_graph(pointer, |graph| {
         let id = DeclarationId::new(declaration_id);
+        let member_id = StringId::from(member_str.as_str());
 
-        let Some(Declaration::Namespace(decl)) = graph.declarations().get(&id) else {
-            return ptr::null();
+        let member_decl_id = match rubydex::query::find_member_in_ancestors(graph, id, member_id, only_inherited) {
+            Ok(decl_id) => decl_id,
+            Err(rubydex::query::FindMemberError::MemberNotFound) => return ptr::null(),
+            Err(err) => unreachable!(
+                "Namespace#find_member is only exposed on namespace declarations, so the declaration must exist and be \
+                 a namespace, got {err:?}"
+            ),
         };
 
-        let member_id = StringId::from(member_str.as_str());
-        let mut found_main_namespace = false;
-
-        decl.ancestors()
-            .iter()
-            .find_map(|ancestor| match ancestor {
-                Ancestor::Complete(ancestor_id) => {
-                    // When only_inherited, skip self and prepended modules
-                    if only_inherited {
-                        let is_self = *ancestor_id == id;
-                        if is_self {
-                            found_main_namespace = true;
-                        }
-                        if is_self || !found_main_namespace {
-                            return None;
-                        }
-                    }
-
-                    let ancestor_decl = graph.declarations().get(ancestor_id).unwrap().as_namespace().unwrap();
-
-                    if let Some(member_decl_id) = ancestor_decl.member(&member_id) {
-                        return Some((member_decl_id, graph.declarations().get(member_decl_id).unwrap()));
-                    }
-
-                    None
-                }
-                Ancestor::Partial(_) => None,
-            })
-            .map_or(ptr::null(), |(member_decl_id, member_decl)| {
-                Box::into_raw(Box::new(CDeclaration::from_declaration(*member_decl_id, member_decl))).cast_const()
-            })
+        let member_decl = graph.declarations().get(&member_decl_id).unwrap();
+        Box::into_raw(Box::new(CDeclaration::from_declaration(member_decl_id, member_decl))).cast_const()
     })
 }
 

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

@@ -76,4 +76,5 @@ pub mod graph_api;
 pub mod location_api;
 pub mod name_api;
 pub mod reference_api;
+pub mod signature_api;
 pub mod utils;

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

@@ -0,0 +1,209 @@
+//! C API for method signature accessors
+
+use crate::graph_api::{GraphPointer, with_graph};
+use crate::location_api::{Location, create_location_for_uri_and_offset};
+use libc::c_char;
+use rubydex::model::declaration::Declaration;
+use rubydex::model::definitions::{Definition, MethodDefinition, Parameter};
+use rubydex::model::graph::Graph;
+use rubydex::model::ids::DefinitionId;
+use std::ffi::CString;
+use std::ptr;
+
+/// C-compatible enum representing the kind of a parameter.
+#[repr(C)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum ParameterKind {
+    RequiredPositional = 0,
+    OptionalPositional = 1,
+    RestPositional = 2,
+    Post = 3,
+    RequiredKeyword = 4,
+    OptionalKeyword = 5,
+    RestKeyword = 6,
+    Forward = 7,
+    Block = 8,
+}
+
+fn map_parameter_kind(param: &Parameter) -> ParameterKind {
+    match param {
+        Parameter::RequiredPositional(_) => ParameterKind::RequiredPositional,
+        Parameter::Post(_) => ParameterKind::Post,
+        Parameter::OptionalPositional(_) => ParameterKind::OptionalPositional,
+        Parameter::RestPositional(_) => ParameterKind::RestPositional,
+        Parameter::RequiredKeyword(_) => ParameterKind::RequiredKeyword,
+        Parameter::OptionalKeyword(_) => ParameterKind::OptionalKeyword,
+        Parameter::RestKeyword(_) => ParameterKind::RestKeyword,
+        Parameter::Block(_) => ParameterKind::Block,
+        Parameter::Forward(_) => ParameterKind::Forward,
+    }
+}
+
+/// C-compatible struct representing a single parameter with its name, kind, and location.
+#[repr(C)]
+pub struct ParameterEntry {
+    pub name: *const c_char,
+    pub location: *mut Location,
+    pub kind: ParameterKind,
+}
+
+/// C-compatible struct representing a single method signature (a list of parameters).
+#[repr(C)]
+pub struct SignatureEntry {
+    pub parameters: *mut ParameterEntry,
+    pub parameters_len: usize,
+}
+
+/// C-compatible array of signatures.
+#[repr(C)]
+pub struct SignatureArray {
+    pub items: *mut SignatureEntry,
+    pub len: usize,
+}
+
+/// Returns a newly allocated array of signatures for the given method definition id.
+/// Caller must free the returned pointer with `rdx_definition_signatures_free`.
+///
+/// # Safety
+/// - `pointer` must be a valid pointer previously returned by `rdx_graph_new`.
+/// - `definition_id` must be a valid definition id.
+///
+/// # Panics
+/// Panics if `definition_id` does not exist or is not a `MethodDefinition`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_definition_signatures(pointer: GraphPointer, definition_id: u64) -> *mut SignatureArray {
+    with_graph(pointer, |graph| {
+        let def_id = DefinitionId::new(definition_id);
+        let Definition::Method(method_def) = graph.definitions().get(&def_id).expect("definition should exist") else {
+            panic!("expected a method definition");
+        };
+
+        let sig_entries = collect_method_signatures(graph, method_def);
+
+        let len = sig_entries.len();
+        let items_ptr = Box::into_raw(sig_entries.into_boxed_slice()).cast::<SignatureEntry>();
+
+        Box::into_raw(Box::new(SignatureArray { items: items_ptr, len }))
+    })
+}
+
+/// Helper: build signature entries from a `MethodDefinition`.
+fn collect_method_signatures(graph: &Graph, method_def: &MethodDefinition) -> Vec<SignatureEntry> {
+    let uri_id = *method_def.uri_id();
+    let document = graph.documents().get(&uri_id).expect("document should exist");
+
+    method_def
+        .signatures()
+        .as_slice()
+        .iter()
+        .map(|sig| {
+            let param_entries: Vec<ParameterEntry> = sig
+                .iter()
+                .map(|param| {
+                    let param_struct = param.inner();
+                    let name = graph
+                        .strings()
+                        .get(param_struct.str())
+                        .expect("parameter name string should exist");
+                    let name_str = CString::new(name.as_str()).unwrap().into_raw().cast_const();
+
+                    ParameterEntry {
+                        name: name_str,
+                        kind: map_parameter_kind(param),
+                        location: create_location_for_uri_and_offset(graph, document, param_struct.offset()),
+                    }
+                })
+                .collect();
+
+            let parameters_len = param_entries.len();
+            let parameters_ptr = Box::into_raw(param_entries.into_boxed_slice()).cast::<ParameterEntry>();
+
+            SignatureEntry {
+                parameters: parameters_ptr,
+                parameters_len,
+            }
+        })
+        .collect()
+}
+
+/// Returns signatures for a `MethodAliasDefinition` by following the alias chain.
+/// Always returns a valid `SignatureArray` pointer (possibly with `len == 0`).
+/// Errors during alias resolution (unresolved receivers, circular chains, etc.)
+/// are silently ignored.
+///
+/// # Safety
+/// - `pointer` must be a valid pointer previously returned by `rdx_graph_new`.
+/// - `definition_id` must be a valid definition id.
+///
+/// # Panics
+/// Panics if `definition_id` does not exist or is not a `MethodAliasDefinition`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_method_alias_definition_signatures(
+    pointer: GraphPointer,
+    definition_id: u64,
+) -> *mut SignatureArray {
+    with_graph(pointer, |graph| {
+        let def_id = DefinitionId::new(definition_id);
+        let resolved = rubydex::query::follow_method_alias(graph, def_id);
+
+        let mut sig_entries: Vec<SignatureEntry> = Vec::new();
+
+        if let Ok(declaration_id) = resolved {
+            if let Some(Declaration::Method(method_def)) = graph.declarations().get(&declaration_id) {
+                for definition_id in method_def.definitions() {
+                    if let Some(Definition::Method(method_definition)) = graph.definitions().get(definition_id) {
+                        sig_entries.extend(collect_method_signatures(graph, method_definition));
+                    }
+                }
+            } else {
+                panic!("expected a method declaration");
+            }
+        }
+
+        let mut boxed = sig_entries.into_boxed_slice();
+        let len = boxed.len();
+        let items_ptr = boxed.as_mut_ptr();
+        std::mem::forget(boxed);
+
+        Box::into_raw(Box::new(SignatureArray { items: items_ptr, len }))
+    })
+}
+
+/// Frees a `SignatureArray` previously returned by `rdx_definition_signatures`.
+///
+/// # Safety
+/// - `ptr` must be a valid pointer previously returned by `rdx_definition_signatures`.
+/// - `ptr` must not be used after being freed.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_definition_signatures_free(ptr: *mut SignatureArray) {
+    if ptr.is_null() {
+        return;
+    }
+
+    let arr = unsafe { Box::from_raw(ptr) };
+
+    if arr.items.is_null() || arr.len == 0 {
+        return;
+    }
+
+    let slice_ptr = ptr::slice_from_raw_parts_mut(arr.items, arr.len);
+    let sig_slice: Box<[SignatureEntry]> = unsafe { Box::from_raw(slice_ptr) };
+
+    for sig_entry in &*sig_slice {
+        if sig_entry.parameters.is_null() || sig_entry.parameters_len == 0 {
+            continue;
+        }
+
+        let param_slice_ptr = ptr::slice_from_raw_parts_mut(sig_entry.parameters, sig_entry.parameters_len);
+        let param_slice: Box<[ParameterEntry]> = unsafe { Box::from_raw(param_slice_ptr) };
+
+        for param_entry in &*param_slice {
+            if !param_entry.name.is_null() {
+                drop(unsafe { CString::from_raw(param_entry.name.cast_mut()) });
+            }
+            if !param_entry.location.is_null() {
+                unsafe { crate::location_api::rdx_location_free(param_entry.location) };
+            }
+        }
+    }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubydex
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-06 00:00:00.000000000 Z
+date: 2026-05-08 00:00:00.000000000 Z
 dependencies: []
 description: A high-performance static analysis suite for Ruby, built in Rust with
   Ruby APIs
@@ -41,6 +41,8 @@ files:
 - ext/rubydex/reference.c
 - ext/rubydex/reference.h
 - ext/rubydex/rubydex.c
+- ext/rubydex/signature.c
+- ext/rubydex/signature.h
 - ext/rubydex/utils.c
 - ext/rubydex/utils.h
 - lib/rubydex.rb
@@ -53,6 +55,7 @@ files:
 - lib/rubydex/keyword_parameter.rb
 - lib/rubydex/location.rb
 - lib/rubydex/mixin.rb
+- lib/rubydex/signature.rb
 - lib/rubydex/version.rb
 - rbi/rubydex.rbi
 - rust/Cargo.lock
@@ -77,6 +80,7 @@ files:
 - rust/rubydex-sys/src/location_api.rs
 - rust/rubydex-sys/src/name_api.rs
 - rust/rubydex-sys/src/reference_api.rs
+- rust/rubydex-sys/src/signature_api.rs
 - rust/rubydex-sys/src/utils.rs
 - rust/rubydex/Cargo.toml
 - rust/rubydex/src/compile_assertions.rs