rubydex 0.2.0 → 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)"
             ]
         );
     }
@@ -5128,4 +5147,317 @@ mod visibility_resolution_tests {
         assert_owner_eq!(context, "Child#foo()", "Child");
         assert_visibility_eq!(context, "Child#foo()", Visibility::Private);
     }
+
+    #[test]
+    fn retroactive_constant_visibility_on_direct_member() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              BAR = 1
+              private_constant :BAR
+
+              BAZ = 2
+              public_constant :BAZ
+
+              QUX = 3
+
+              class Inner; end
+              private_constant :Inner
+
+              module InnerMod; end
+              private_constant :InnerMod
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo::BAR", Visibility::Private);
+        assert_visibility_eq!(context, "Foo::BAZ", Visibility::Public);
+        assert_visibility_eq!(context, "Foo::QUX", Visibility::Public);
+        assert_visibility_eq!(context, "Foo::Inner", Visibility::Private);
+        assert_visibility_eq!(context, "Foo::InnerMod", Visibility::Private);
+    }
+
+    #[test]
+    fn retroactive_constant_visibility_via_qualified_receiver() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              BAR = 1
+              BAZ = 2
+            end
+
+            ALIAS = Foo
+            Foo.private_constant :BAR
+            ALIAS.private_constant :BAZ
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo::BAR", Visibility::Private);
+        assert_visibility_eq!(context, "Foo::BAZ", Visibility::Private);
+    }
+
+    #[test]
+    fn retroactive_constant_visibility_multi_arg_undefined_emits_per_name_diagnostic() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              private_constant :NOPE_ONE, :NOPE_TWO
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_diagnostics_eq!(
+            context,
+            &[
+                "undefined-constant-visibility-target: undefined constant `NOPE_ONE` for visibility change in `Foo` (2:21-2:29)",
+                "undefined-constant-visibility-target: undefined constant `NOPE_TWO` for visibility change in `Foo` (2:32-2:40)",
+            ]
+        );
+    }
+
+    #[test]
+    fn retroactive_constant_visibility_inherited_constant_emits_diagnostic() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Parent
+              CONST = 1
+            end
+
+            class Child < Parent
+              private_constant :CONST
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_diagnostics_eq!(
+            context,
+            &[
+                "undefined-constant-visibility-target: undefined constant `CONST` for visibility change in `Child` (6:21-6:26)"
+            ]
+        );
+        assert_visibility_eq!(context, "Parent::CONST", Visibility::Public);
+    }
+
+    #[test]
+    fn retroactive_constant_visibility_clears_when_call_removed() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              BAR = 1
+            end
+            ",
+        );
+        context.index_uri(
+            "file:///vis.rb",
+            r"
+            Foo.private_constant :BAR
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo::BAR", Visibility::Private);
+
+        context.delete_uri("file:///vis.rb");
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo::BAR", Visibility::Public);
+    }
+
+    #[test]
+    fn retroactive_constant_visibility_inside_singleton_class_body() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              class << self
+                BAR = 1
+                private_constant :BAR
+              end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo::<Foo>::BAR", Visibility::Private);
+    }
+
+    #[test]
+    fn retroactive_constant_visibility_persists_across_reopened_class() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///a.rb",
+            r"
+            class Foo
+              BAR = 1
+              private_constant :BAR
+            end
+            ",
+        );
+        context.index_uri(
+            "file:///b.rb",
+            r"
+            class Foo
+              BAR = 2
+            end
+            ",
+        );
+        context.resolve();
+
+        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

@@ -64,6 +64,25 @@ impl CDeclaration {
     }
 }
 
+/// Convert a nullable C string to `Option<DeclarationId>`.
+/// Null, empty, or non-UTF-8 input yields `None`.
+///
+/// # Safety
+///
+/// If non-null, `ptr` must point to a valid, NUL-terminated C string that remains valid for the
+/// duration of the call. The contents do not need to be UTF-8 — non-UTF-8 input is handled by returning
+/// `None`.
+pub(crate) unsafe fn decl_id_from_char_ptr(ptr: *const c_char) -> Option<DeclarationId> {
+    if ptr.is_null() {
+        return None;
+    }
+    let s = unsafe { utils::convert_char_ptr_to_string(ptr) }.ok()?;
+    if s.is_empty() {
+        return None;
+    }
+    Some(DeclarationId::from(s.as_str()))
+}
+
 /// An iterator over declaration IDs
 ///
 /// We snapshot the IDs at iterator creation so if the graph is modified, the iterator will not see the changes
@@ -178,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/graph_api.rs

@@ -2,6 +2,7 @@
 
 use crate::declaration_api::CDeclaration;
 use crate::declaration_api::DeclarationsIter;
+use crate::declaration_api::decl_id_from_char_ptr;
 use crate::document_api::DocumentsIter;
 use crate::reference_api::{CConstantReference, CMethodReference, ConstantReferencesIter, MethodReferencesIter};
 use crate::{name_api, utils};
@@ -12,6 +13,7 @@ use rubydex::model::graph::Graph;
 use rubydex::model::ids::{DeclarationId, NameId, UriId};
 use rubydex::model::keywords;
 use rubydex::model::name::NameRef;
+use rubydex::model::visibility::Visibility;
 use rubydex::query::{CompletionCandidate, CompletionContext, CompletionReceiver};
 use rubydex::resolution::Resolver;
 use rubydex::{indexing, integrity, listing, query};
@@ -791,11 +793,15 @@ fn run_and_finalize_completion(
 ///
 /// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
 /// - `nesting` must point to `nesting_count` valid, null-terminated UTF-8 strings.
+/// - `self_receiver` must be null or a valid, null-terminated UTF-8 string. When non-null, it
+///   overrides the self-type (e.g., `"Foo::<Foo>"` for completion inside `def Foo.bar`), while
+///   the lexical nesting still comes from `nesting`.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_graph_complete_expression(
     pointer: GraphPointer,
     nesting: *const *const c_char,
     nesting_count: usize,
+    self_receiver: *const c_char,
 ) -> CompletionResult {
     with_mut_graph(pointer, |graph| {
         let Some((name_id, names_to_untrack)) = (unsafe { completion_nesting_name_id(graph, nesting, nesting_count) })
@@ -803,7 +809,16 @@ pub unsafe extern "C" fn rdx_graph_complete_expression(
             return CompletionResult::success(ptr::null_mut());
         };
 
-        run_and_finalize_completion(graph, CompletionReceiver::Expression(name_id), names_to_untrack)
+        let self_decl_id = unsafe { decl_id_from_char_ptr(self_receiver) };
+
+        run_and_finalize_completion(
+            graph,
+            CompletionReceiver::Expression {
+                self_decl_id,
+                nesting_name_id: name_id,
+            },
+            names_to_untrack,
+        )
     })
 }
 
@@ -815,19 +830,27 @@ pub unsafe extern "C" fn rdx_graph_complete_expression(
 ///
 /// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
 /// - `name` must be a valid, null-terminated UTF-8 string (FQN of the namespace).
+/// - `self_receiver` must be null or a valid, null-terminated UTF-8 string. When non-null, it
+///   is the caller's runtime self type (e.g., for filtering `private_class_method` visibility).
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_graph_complete_namespace_access(
     pointer: GraphPointer,
     name: *const c_char,
+    self_receiver: *const c_char,
 ) -> CompletionResult {
     let Ok(name_str) = (unsafe { utils::convert_char_ptr_to_string(name) }) else {
         return CompletionResult::success(ptr::null_mut());
     };
 
     with_mut_graph(pointer, |graph| {
+        let self_decl_id = unsafe { decl_id_from_char_ptr(self_receiver) };
+
         run_and_finalize_completion(
             graph,
-            CompletionReceiver::NamespaceAccess(DeclarationId::from(name_str.as_str())),
+            CompletionReceiver::NamespaceAccess {
+                self_decl_id,
+                namespace_decl_id: DeclarationId::from(name_str.as_str()),
+            },
             Vec::new(),
         )
     })
@@ -841,19 +864,27 @@ pub unsafe extern "C" fn rdx_graph_complete_namespace_access(
 ///
 /// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
 /// - `name` must be a valid, null-terminated UTF-8 string (FQN of the receiver).
+/// - `self_receiver` must be null or a valid, null-terminated UTF-8 string. When non-null, it
+///   is the caller's runtime self type, used for MRI-style visibility checks.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_graph_complete_method_call(
     pointer: GraphPointer,
     name: *const c_char,
+    self_receiver: *const c_char,
 ) -> CompletionResult {
     let Ok(name_str) = (unsafe { utils::convert_char_ptr_to_string(name) }) else {
         return CompletionResult::success(ptr::null_mut());
     };
 
     with_mut_graph(pointer, |graph| {
+        let self_decl_id = unsafe { decl_id_from_char_ptr(self_receiver) };
+
         run_and_finalize_completion(
             graph,
-            CompletionReceiver::MethodCall(DeclarationId::from(name_str.as_str())),
+            CompletionReceiver::MethodCall {
+                self_decl_id,
+                receiver_decl_id: DeclarationId::from(name_str.as_str()),
+            },
             Vec::new(),
         )
     })
@@ -868,28 +899,34 @@ pub unsafe extern "C" fn rdx_graph_complete_method_call(
 /// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
 /// - `name` must be a valid, null-terminated UTF-8 string (FQN of the method).
 /// - `nesting` must point to `nesting_count` valid, null-terminated UTF-8 strings.
+/// - `self_receiver` must be null or a valid, null-terminated UTF-8 string. See
+///   `rdx_graph_complete_expression` for semantics.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_graph_complete_method_argument(
     pointer: GraphPointer,
     name: *const c_char,
     nesting: *const *const c_char,
     nesting_count: usize,
+    self_receiver: *const c_char,
 ) -> CompletionResult {
     let Ok(name_str) = (unsafe { utils::convert_char_ptr_to_string(name) }) else {
         return CompletionResult::success(ptr::null_mut());
     };
 
     with_mut_graph(pointer, |graph| {
-        let Some((self_name_id, names_to_untrack)) =
+        let Some((nesting_name_id, names_to_untrack)) =
             (unsafe { completion_nesting_name_id(graph, nesting, nesting_count) })
         else {
             return CompletionResult::success(ptr::null_mut());
         };
 
+        let self_decl_id = unsafe { decl_id_from_char_ptr(self_receiver) };
+
         run_and_finalize_completion(
             graph,
             CompletionReceiver::MethodArgument {
-                self_name_id,
+                self_decl_id,
+                nesting_name_id,
                 method_decl_id: DeclarationId::from(name_str.as_str()),
             },
             names_to_untrack,
@@ -942,6 +979,53 @@ pub unsafe extern "C" fn rdx_keyword_get(name: *const c_char) -> *const CKeyword
     }
 }
 
+#[repr(u8)]
+#[derive(Debug, Clone, Copy)]
+pub enum CVisibility {
+    Public = 0,
+    Protected = 1,
+    Private = 2,
+}
+
+/// Returns the visibility of a declaration (method, constant, class, or module) as a heap-allocated
+/// `CVisibility`, or NULL when the declaration carries no visibility (e.g. variables, singleton
+/// classes, todos). Caller must free the returned pointer with `free_c_visibility`.
+///
+/// # Safety
+///
+/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_visibility(pointer: GraphPointer, declaration_id: u64) -> *const CVisibility {
+    with_graph(pointer, |graph| {
+        let Some(visibility) = graph.visibility(&DeclarationId::new(declaration_id)) else {
+            return ptr::null();
+        };
+
+        let c_visibility = match visibility {
+            Visibility::Public => CVisibility::Public,
+            Visibility::Protected => CVisibility::Protected,
+            Visibility::Private => CVisibility::Private,
+            Visibility::ModuleFunction => {
+                unimplemented!("module_function visibility translation is not implemented yet")
+            }
+        };
+
+        Box::into_raw(Box::new(c_visibility)).cast_const()
+    })
+}
+
+/// Frees a `CVisibility` previously returned by `rdx_graph_visibility`.
+///
+/// # Safety
+///
+/// - `ptr` must be a valid pointer previously returned by `rdx_graph_visibility`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn free_c_visibility(ptr: *const CVisibility) {
+    unsafe {
+        let _ = Box::from_raw(ptr.cast_mut());
+    }
+}
+
 /// Frees a `CKeyword` previously returned by `rdx_keyword_get`.
 ///
 /// # Safety

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;