rubydex 0.1.0.beta13 → 0.2.0

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

@@ -424,6 +424,34 @@ pub unsafe extern "C" fn rdx_declaration_members(pointer: GraphPointer, decl_id:
     DeclarationsIter::new(declarations.into_boxed_slice())
 }
 
+/// Returns the first resolved target declaration for a constant alias declaration, or NULL if the declaration is not
+/// a constant alias or none of its definitions have a resolved target.
+///
+/// # Safety
+///
+/// Assumes that the graph pointer is valid.
+///
+/// # Panics
+///
+/// Will panic if there's inconsistent graph data
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_constant_alias_target(pointer: GraphPointer, decl_id: u64) -> *const CDeclaration {
+    with_graph(pointer, |graph| {
+        let declaration_id = DeclarationId::new(decl_id);
+
+        let Some(targets) = graph.alias_targets(&declaration_id) else {
+            return ptr::null();
+        };
+
+        let Some(&target_id) = targets.first() else {
+            return ptr::null();
+        };
+
+        let target_decl = graph.declarations().get(&target_id).unwrap();
+        Box::into_raw(Box::new(CDeclaration::from_declaration(target_id, target_decl))).cast_const()
+    })
+}
+
 /// Creates a new iterator over constant references for a given declaration.
 ///
 /// # Safety

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

@@ -9,7 +9,7 @@ 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::query::{CompletionCandidate, CompletionContext, CompletionReceiver};
@@ -260,6 +260,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`.

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

@@ -44,9 +44,10 @@ pub fn nesting_stack_to_name_id(
 }
 
 /// Processes a qualified name (e.g., `"Foo::Bar"` or `"<Foo>"`) by splitting on `"::"` and registering each part in the
-/// graph. Singleton class names (starting with `<`) use `ParentScope::Attached` and `nesting=None`, matching how the
-/// indexer creates them. When a singleton is the first part (i.e., `current_name` has no parent), `current_nesting` is
-/// used as the attachment point.
+/// graph. Singleton class names (starting with `<`) use `ParentScope::Attached` and a `nesting` equal to the attached
+/// target, matching how the indexer creates them (`class << self` always sits lexically inside its attached class).
+/// When a singleton is the first part (i.e., `current_name` has no parent), `current_nesting` is used as the attachment
+/// point.
 fn process_qualified_name(
     graph: &mut Graph,
     qualified_name: &str,
@@ -61,12 +62,13 @@ fn process_qualified_name(
         }
 
         let (parent_scope, nesting_for_part) = if part.starts_with('<') {
-            let attached = match *current_name {
-                ParentScope::Some(id) | ParentScope::Attached(id) => ParentScope::Attached(id),
-                _ => current_nesting.map_or(ParentScope::None, ParentScope::Attached),
+            let attached_id = match *current_name {
+                ParentScope::Some(id) | ParentScope::Attached(id) => Some(id),
+                _ => *current_nesting,
             };
 
-            (attached, None)
+            let attached = attached_id.map_or(ParentScope::None, ParentScope::Attached);
+            (attached, attached_id)
         } else {
             (*current_name, *current_nesting)
         };

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.beta13
+  version: 0.2.0
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-21 00:00:00.000000000 Z
+date: 2026-05-01 00:00:00.000000000 Z
 dependencies: []
 description: A high-performance static analysis suite for Ruby, built in Rust with
   Ruby APIs