rubydex 0.1.0.beta11 → 0.1.0.beta13

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

@@ -1,195 +1,267 @@
-//! C API for exposing references through ID handles (like definitions)
-
-use std::ffi::CString;
-
-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::ids::ReferenceId;
-
-/// Kind of reference for FFI dispatch
-#[repr(C)]
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum ReferenceKind {
-    Constant = 0,
-    Method = 1,
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, Copy)]
-pub struct CReference {
-    id: u64,
-    kind: ReferenceKind,
-}
-
-impl CReference {
-    #[must_use]
-    pub fn new(id: u64, kind: ReferenceKind) -> Self {
-        Self { id, kind }
-    }
-}
-
-#[derive(Debug)]
-pub struct ReferencesIter {
-    pub entries: Box<[CReference]>,
-    pub index: usize,
-}
-
-impl ReferencesIter {
-    #[must_use]
-    pub fn new(entries: Box<[CReference]>) -> *mut ReferencesIter {
-        Box::into_raw(Box::new(ReferencesIter { entries, index: 0 }))
-    }
-}
-
-/// Returns the total number of entries in the iterator snapshot.
-///
-/// # Safety
-/// - `iter` must be a valid pointer previously returned by `ReferencesIter::new`.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_references_iter_len(iter: *const ReferencesIter) -> usize {
-    if iter.is_null() {
-        return 0;
-    }
-    unsafe { (&*iter).entries.len() }
-}
-
-/// Advances the iterator and writes the next entry into `out_ref`.
-/// Returns `true` if an entry was written, or `false` if the iterator is exhausted or inputs are invalid.
-///
-/// # Safety
-/// - `iter` must be a valid pointer previously returned by `ReferencesIter::new`.
-/// - `out_ref` must be a valid, writable pointer.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_references_iter_next(iter: *mut ReferencesIter, out_ref: *mut CReference) -> bool {
-    if iter.is_null() || out_ref.is_null() {
-        return false;
-    }
-
-    let it = unsafe { &mut *iter };
-    if it.index >= it.entries.len() {
-        return false;
-    }
-
-    let entry = it.entries[it.index];
-    it.index += 1;
-    unsafe {
-        *out_ref = entry;
-    }
-    true
-}
-
-/// Frees an iterator created by `ReferencesIter::new`.
-///
-/// # Safety
-/// - `iter` must be a pointer previously returned by `ReferencesIter::new`.
-/// - `iter` must not be used after being freed.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_references_iter_free(iter: *mut ReferencesIter) {
-    if iter.is_null() {
-        return;
-    }
-    unsafe {
-        let _ = Box::from_raw(iter);
-    }
-}
-
-/// Returns the UTF-8 name string for a constant reference id.
-/// Caller must free with `free_c_string`.
-///
-/// # 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_constant_reference_name(pointer: GraphPointer, reference_id: u64) -> *const c_char {
-    with_graph(pointer, |graph| {
-        let ref_id = ReferenceId::new(reference_id);
-        let reference = graph.constant_references().get(&ref_id).expect("Reference not found");
-        let name = graph.names().get(reference.name_id()).expect("Name ID should exist");
-
-        let name_string = graph
-            .strings()
-            .get(name.str())
-            .expect("String ID should exist")
-            .to_string();
-        CString::new(name_string).unwrap().into_raw().cast_const()
-    })
-}
-
-/// Returns the UTF-8 name string for a method reference id.
-/// Caller must free with `free_c_string`.
-///
-/// # 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_name(pointer: GraphPointer, reference_id: u64) -> *const c_char {
-    with_graph(pointer, |graph| {
-        let ref_id = ReferenceId::new(reference_id);
-        let reference = graph.method_references().get(&ref_id).expect("Reference not found");
-        let name = graph
-            .strings()
-            .get(reference.str())
-            .expect("Name ID should exist")
-            .to_string();
-        CString::new(name).unwrap().into_raw().cast_const()
-    })
-}
-
-/// Returns a newly allocated `Location` for the given constant reference id.
-/// Caller must free the returned pointer with `rdx_location_free`.
-///
-/// # Safety
-///
-/// - `pointer` must be a valid pointer previously returned by `rdx_graph_new`.
-/// - `reference_id` must be a valid reference id.
-///
-/// # Panics
-///
-/// This function will panic if a reference or document cannot be found.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_constant_reference_location(pointer: GraphPointer, reference_id: u64) -> *mut Location {
-    with_graph(pointer, |graph| {
-        let ref_id = ReferenceId::new(reference_id);
-        let reference = graph.constant_references().get(&ref_id).expect("Reference not found");
-        let document = graph
-            .documents()
-            .get(&reference.uri_id())
-            .expect("Document should exist");
-
-        create_location_for_uri_and_offset(graph, document, reference.offset())
-    })
-}
-
-/// Returns a newly allocated `Location` for the given method reference id.
-/// Caller must free the returned pointer with `rdx_location_free`.
-///
-/// # Safety
-///
-/// - `pointer` must be a valid pointer previously returned by `rdx_graph_new`.
-/// - `reference_id` must be a valid reference id.
-///
-/// # Panics
-///
-/// This function will panic if a reference or document cannot be found.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_method_reference_location(pointer: GraphPointer, reference_id: u64) -> *mut Location {
-    with_graph(pointer, |graph| {
-        let ref_id = ReferenceId::new(reference_id);
-        let reference = graph.method_references().get(&ref_id).expect("Reference not found");
-        let document = graph
-            .documents()
-            .get(&reference.uri_id())
-            .expect("Document should exist");
-
-        create_location_for_uri_and_offset(graph, document, reference.offset())
-    })
-}
+//! C API for exposing references through ID handles (like definitions)
+
+use std::ffi::CString;
+use std::ptr;
+
+use crate::declaration_api::CDeclaration;
+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::graph::Graph;
+use rubydex::model::ids::{ConstantReferenceId, MethodReferenceId};
+use rubydex::model::name::NameRef;
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CConstantReference {
+    pub id: u64,
+    pub declaration_id: u64,
+}
+
+impl CConstantReference {
+    /// Build a `CConstantReference` from a graph and reference ID. Sets `declaration_id` to 0 when the reference is
+    /// unresolved.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if there's inconsistent data in the graph
+    #[must_use]
+    pub fn from_id(graph: &Graph, ref_id: ConstantReferenceId) -> Self {
+        let reference = graph
+            .constant_references()
+            .get(&ref_id)
+            .expect("Constant reference not found");
+
+        let name_ref = graph.names().get(reference.name_id()).expect("Name ID should exist");
+
+        let declaration_id = match name_ref {
+            NameRef::Resolved(resolved) => **resolved.declaration_id(),
+            NameRef::Unresolved(_) => 0,
+        };
+
+        Self {
+            id: *ref_id,
+            declaration_id,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ConstantReferencesIter {
+    entries: Box<[CConstantReference]>,
+    index: usize,
+}
+
+iterator!(ConstantReferencesIter, entries: CConstantReference);
+
+/// # Safety
+/// `iter` must be a valid pointer previously returned by `ConstantReferencesIter::new`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_constant_references_iter_len(iter: *const ConstantReferencesIter) -> usize {
+    unsafe { ConstantReferencesIter::len(iter) }
+}
+
+/// # Safety
+/// - `iter` must be a valid pointer previously returned by `ConstantReferencesIter::new`.
+/// - `out` must be a valid, writable pointer.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_constant_references_iter_next(
+    iter: *mut ConstantReferencesIter,
+    out: *mut CConstantReference,
+) -> bool {
+    unsafe { ConstantReferencesIter::next(iter, out) }
+}
+
+/// # Safety
+/// - `iter` must be a pointer previously returned by `ConstantReferencesIter::new`.
+/// - `iter` must not be used after being freed.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_constant_references_iter_free(iter: *mut ConstantReferencesIter) {
+    unsafe { ConstantReferencesIter::free(iter) }
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CMethodReference {
+    pub id: u64,
+}
+
+#[derive(Debug)]
+pub struct MethodReferencesIter {
+    entries: Box<[CMethodReference]>,
+    index: usize,
+}
+
+iterator!(MethodReferencesIter, entries: CMethodReference);
+
+/// # Safety
+/// `iter` must be a valid pointer previously returned by `MethodReferencesIter::new`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_method_references_iter_len(iter: *const MethodReferencesIter) -> usize {
+    unsafe { MethodReferencesIter::len(iter) }
+}
+
+/// # Safety
+/// - `iter` must be a valid pointer previously returned by `MethodReferencesIter::new`.
+/// - `out` must be a valid, writable pointer.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_method_references_iter_next(
+    iter: *mut MethodReferencesIter,
+    out: *mut CMethodReference,
+) -> bool {
+    unsafe { MethodReferencesIter::next(iter, out) }
+}
+
+/// # Safety
+/// - `iter` must be a pointer previously returned by `MethodReferencesIter::new`.
+/// - `iter` must not be used after being freed.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_method_references_iter_free(iter: *mut MethodReferencesIter) {
+    unsafe { MethodReferencesIter::free(iter) }
+}
+
+/// Returns the UTF-8 name string for a constant reference id.
+/// Caller must free with `free_c_string`.
+///
+/// # 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_constant_reference_name(pointer: GraphPointer, reference_id: u64) -> *const c_char {
+    with_graph(pointer, |graph| {
+        let ref_id = ConstantReferenceId::new(reference_id);
+        let reference = graph.constant_references().get(&ref_id).expect("Reference not found");
+        let name = graph.names().get(reference.name_id()).expect("Name ID should exist");
+
+        let name_string = graph
+            .strings()
+            .get(name.str())
+            .expect("String ID should exist")
+            .to_string();
+        CString::new(name_string).unwrap().into_raw().cast_const()
+    })
+}
+
+/// Returns the UTF-8 name string for a method reference id.
+/// Caller must free with `free_c_string`.
+///
+/// # 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_name(pointer: GraphPointer, reference_id: u64) -> *const c_char {
+    with_graph(pointer, |graph| {
+        let ref_id = MethodReferenceId::new(reference_id);
+        let reference = graph.method_references().get(&ref_id).expect("Reference not found");
+        let name = graph
+            .strings()
+            .get(reference.str())
+            .expect("Name ID should exist")
+            .to_string();
+        CString::new(name).unwrap().into_raw().cast_const()
+    })
+}
+
+/// Returns a newly allocated `Location` for the given constant reference id.
+/// Caller must free the returned pointer with `rdx_location_free`.
+///
+/// # Safety
+///
+/// - `pointer` must be a valid pointer previously returned by `rdx_graph_new`.
+/// - `reference_id` must be a valid reference id.
+///
+/// # Panics
+///
+/// This function will panic if a reference or document cannot be found.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_constant_reference_location(pointer: GraphPointer, reference_id: u64) -> *mut Location {
+    with_graph(pointer, |graph| {
+        let ref_id = ConstantReferenceId::new(reference_id);
+        let reference = graph.constant_references().get(&ref_id).expect("Reference not found");
+        let document = graph
+            .documents()
+            .get(&reference.uri_id())
+            .expect("Document should exist");
+
+        create_location_for_uri_and_offset(graph, document, reference.offset())
+    })
+}
+
+/// Returns the declaration that the given resolved constant reference points to. Returns NULL if the reference is
+/// unresolved. 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_resolved_constant_reference_declaration(
+    pointer: GraphPointer,
+    reference_id: u64,
+) -> *const CDeclaration {
+    with_graph(pointer, |graph| {
+        let ref_id = ConstantReferenceId::new(reference_id);
+        let reference = graph.constant_references().get(&ref_id).expect("Reference not found");
+        let name_ref = graph.names().get(reference.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`.
+///
+/// # Safety
+///
+/// - `pointer` must be a valid pointer previously returned by `rdx_graph_new`.
+/// - `reference_id` must be a valid reference id.
+///
+/// # Panics
+///
+/// This function will panic if a reference or document cannot be found.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_method_reference_location(pointer: GraphPointer, reference_id: u64) -> *mut Location {
+    with_graph(pointer, |graph| {
+        let ref_id = MethodReferenceId::new(reference_id);
+        let reference = graph.method_references().get(&ref_id).expect("Reference not found");
+        let document = graph
+            .documents()
+            .get(&reference.uri_id())
+            .expect("Document should exist");
+
+        create_location_for_uri_and_offset(graph, document, reference.offset())
+    })
+}
+
+/// Frees a `CConstantReference` previously returned by an FFI function.
+///
+/// # Safety
+/// - `ptr` must be a valid pointer previously returned by an FFI function that allocates a `CConstantReference`, or
+///   NULL.
+/// - `ptr` must not be used after being freed.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn free_c_constant_reference(ptr: *const CConstantReference) {
+    if !ptr.is_null() {
+        unsafe {
+            let _ = Box::from_raw(ptr.cast_mut());
+        }
+    }
+}

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

@@ -1,70 +1,70 @@
-use libc::{c_char, size_t};
-use std::ffi::{CStr, CString};
-use std::slice;
-use std::str::Utf8Error;
-
-/// Converts a C array of strings into a Vec<String>
-///
-/// # Safety
-///
-/// This function is unsafe because it attempts to instantiate a Vec<String> from a raw char** pointer
-///
-/// # Errors
-///
-/// This function errors if any of the strings inside the array contain invalid UTF-8 data
-pub unsafe fn convert_double_pointer_to_vec(data: *const *const c_char, len: size_t) -> Result<Vec<String>, Utf8Error> {
-    unsafe {
-        slice::from_raw_parts(data, len)
-            .iter()
-            .map(|arg| CStr::from_ptr(*arg).to_str().map(ToString::to_string))
-            .collect()
-    }
-}
-
-/// # Safety
-///
-/// This function is unsafe because it dereferences the char pointer, which needs to be valid for the duration of the
-/// function
-///
-/// # Errors
-///
-/// This function errors if any of the strings inside the array contain invalid UTF-8 data
-pub unsafe fn convert_char_ptr_to_string(data: *const c_char) -> Result<String, Utf8Error> {
-    unsafe { CStr::from_ptr(data).to_str().map(ToString::to_string) }
-}
-
-/// Frees a `CString` allocated on the Rust side
-#[unsafe(no_mangle)]
-pub extern "C" fn free_c_string(ptr: *const c_char) {
-    unsafe {
-        let _ = CString::from_raw(ptr.cast_mut());
-    }
-}
-
-/// Frees a boxed u64 allocated on the Rust side
-#[unsafe(no_mangle)]
-pub extern "C" fn free_u64(ptr: *const u64) {
-    unsafe {
-        let _ = Box::from_raw(ptr.cast_mut());
-    }
-}
-
-/// Frees an array of C strings allocated by Rust.
-///
-/// # Safety
-/// - `ptr` must be a pointer to a boxed slice of C strings previously allocated by this crate.
-/// - `count` must be the length of the array.
-/// - `ptr` must not be used after being freed.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn free_c_string_array(ptr: *const *const c_char, count: usize) {
-    if ptr.is_null() {
-        return;
-    }
-
-    let slice = unsafe { Box::from_raw(std::ptr::slice_from_raw_parts_mut(ptr.cast_mut(), count)) };
-    let _: Vec<_> = slice
-        .iter()
-        .filter(|p| !p.is_null())
-        .map(|arg| unsafe { CString::from_raw((*arg).cast_mut()) })
-        .collect();
-}
+use libc::{c_char, size_t};
+use std::ffi::{CStr, CString};
+use std::slice;
+use std::str::Utf8Error;
+
+/// Converts a C array of strings into a Vec<String>
+///
+/// # Safety
+///
+/// This function is unsafe because it attempts to instantiate a Vec<String> from a raw char** pointer
+///
+/// # Errors
+///
+/// This function errors if any of the strings inside the array contain invalid UTF-8 data
+pub unsafe fn convert_double_pointer_to_vec(data: *const *const c_char, len: size_t) -> Result<Vec<String>, Utf8Error> {
+    unsafe {
+        slice::from_raw_parts(data, len)
+            .iter()
+            .map(|arg| CStr::from_ptr(*arg).to_str().map(ToString::to_string))
+            .collect()
+    }
+}
+
+/// # Safety
+///
+/// This function is unsafe because it dereferences the char pointer, which needs to be valid for the duration of the
+/// function
+///
+/// # Errors
+///
+/// This function errors if any of the strings inside the array contain invalid UTF-8 data
+pub unsafe fn convert_char_ptr_to_string(data: *const c_char) -> Result<String, Utf8Error> {
+    unsafe { CStr::from_ptr(data).to_str().map(ToString::to_string) }
+}
+
+/// Frees a `CString` allocated on the Rust side
+#[unsafe(no_mangle)]
+pub extern "C" fn free_c_string(ptr: *const c_char) {
+    unsafe {
+        let _ = CString::from_raw(ptr.cast_mut());
+    }
+}
+
+/// Frees a boxed u64 allocated on the Rust side
+#[unsafe(no_mangle)]
+pub extern "C" fn free_u64(ptr: *const u64) {
+    unsafe {
+        let _ = Box::from_raw(ptr.cast_mut());
+    }
+}
+
+/// Frees an array of C strings allocated by Rust.
+///
+/// # Safety
+/// - `ptr` must be a pointer to a boxed slice of C strings previously allocated by this crate.
+/// - `count` must be the length of the array.
+/// - `ptr` must not be used after being freed.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn free_c_string_array(ptr: *const *const c_char, count: usize) {
+    if ptr.is_null() {
+        return;
+    }
+
+    let slice = unsafe { Box::from_raw(std::ptr::slice_from_raw_parts_mut(ptr.cast_mut(), count)) };
+    let _: Vec<_> = slice
+        .iter()
+        .filter(|p| !p.is_null())
+        .map(|arg| unsafe { CString::from_raw((*arg).cast_mut()) })
+        .collect();
+}

data/rust/rustfmt.toml

@@ -1,2 +1,2 @@
-max_width = 120
-edition = "2024"
+max_width = 120
+edition = "2024"