rubydex 0.1.0.beta14-aarch64-linux → 0.2.1-aarch64-linux

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};
@@ -9,9 +10,10 @@ use libc::{c_char, c_void};
 use rubydex::indexing::LanguageId;
 use rubydex::model::encoding::Encoding;
 use rubydex::model::graph::Graph;
-use rubydex::model::ids::{DeclarationId, NameId};
+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};
@@ -260,6 +262,29 @@ pub unsafe extern "C" fn rdx_index_all(
     })
 }
 
+/// Returns a pointer to the URI ID of the document identified by `uri`, or NULL if it doesn't exist.
+/// Caller must free the returned pointer with `free_u64`.
+///
+/// # Safety
+///
+/// Expects both the graph pointer and uri string pointer to be valid
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_get_document(pointer: GraphPointer, uri: *const c_char) -> *const u64 {
+    let Ok(uri_str) = (unsafe { utils::convert_char_ptr_to_string(uri) }) else {
+        return ptr::null();
+    };
+
+    with_graph(pointer, |graph| {
+        let uri_id = UriId::from(uri_str.as_str());
+
+        if graph.documents().contains_key(&uri_id) {
+            Box::into_raw(Box::new(*uri_id)).cast_const()
+        } else {
+            ptr::null()
+        }
+    })
+}
+
 /// Deletes a document and all of its definitions from the graph.
 /// Returns a pointer to the URI ID if the document was found and removed, or NULL if it didn't exist.
 /// Caller must free the returned pointer with `free_u64`.
@@ -768,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) })
@@ -780,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,
+        )
     })
 }
 
@@ -792,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(),
         )
     })
@@ -818,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(),
         )
     })
@@ -845,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,
@@ -919,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/reference_api.rs

@@ -226,6 +226,43 @@ pub unsafe extern "C" fn rdx_resolved_constant_reference_declaration(
     })
 }
 
+/// Returns the declaration of the resolved receiver for the given method reference. Returns NULL when the method
+/// reference has no tracked receiver or when the receiver could not be resolved. Caller must free with
+/// `free_c_declaration`.
+///
+/// # Safety
+///
+/// Assumes pointer is valid.
+///
+/// # Panics
+///
+/// This function will panic if the reference cannot be found.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_method_reference_receiver_declaration(
+    pointer: GraphPointer,
+    reference_id: u64,
+) -> *const CDeclaration {
+    with_graph(pointer, |graph| {
+        let ref_id = MethodReferenceId::new(reference_id);
+        let reference = graph.method_references().get(&ref_id).expect("Reference not found");
+
+        let Some(name_id) = reference.receiver() else {
+            return ptr::null();
+        };
+
+        let name_ref = graph.names().get(&name_id).expect("Name ID should exist");
+
+        match name_ref {
+            NameRef::Resolved(resolved) => {
+                let decl_id = *resolved.declaration_id();
+                let decl = graph.declarations().get(&decl_id).expect("Declaration not found");
+                Box::into_raw(Box::new(CDeclaration::from_declaration(decl_id, decl))).cast_const()
+            }
+            NameRef::Unresolved(_) => ptr::null(),
+        }
+    })
+}
+
 /// Returns a newly allocated `Location` for the given method reference id.
 /// Caller must free the returned pointer with `rdx_location_free`.
 ///

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubydex
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta14
+  version: 0.2.1
 platform: aarch64-linux
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-04-28 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