rubydex 0.2.0 → 0.2.1

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubydex
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-01 00:00:00.000000000 Z
+date: 2026-05-06 00:00:00.000000000 Z
 dependencies: []
 description: A high-performance static analysis suite for Ruby, built in Rust with
   Ruby APIs