rubydex 0.1.0.beta11 → 0.1.0.beta13

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

@@ -1,9 +1,79 @@
-pub mod declaration_api;
-pub mod definition_api;
-pub mod diagnostic_api;
-pub mod document_api;
-pub mod graph_api;
-pub mod location_api;
-pub mod name_api;
-pub mod reference_api;
-pub mod utils;
+/// Helper macro to generate all required functions for an iterator. We use iterators to go over any collection of data
+/// that exists on the Rust side (e.g.: definitions, documents, declarations, references). The goal is to avoid eager
+/// allocation of large collections when possible.
+///
+/// Note: structs must be defined manually so that the cbindgen can see them. The actual methods are not extern "C" and
+/// so they can be expanded from the macro.
+///
+/// # Example
+///
+/// ```ignore
+/// pub struct FoosIter {
+///     entries: Box<[Foo]>,
+///     index: usize,
+/// }
+///
+/// iterator!(FoosIter, entries: Foo);
+/// ```
+macro_rules! iterator {
+    ($name:ident, $field:ident : $entry:ty) => {
+        impl $name {
+            #[must_use]
+            pub fn new($field: Box<[$entry]>) -> *mut $name {
+                Box::into_raw(Box::new($name { $field, index: 0 }))
+            }
+
+            /// # Safety
+            /// `iter` must be a valid pointer returned by `new`, or null.
+            pub unsafe fn len(iter: *const Self) -> usize {
+                if iter.is_null() {
+                    return 0;
+                }
+                unsafe { (&*iter).$field.len() }
+            }
+
+            /// # Safety
+            /// - `iter` must be a valid pointer returned by `new`, or null.
+            /// - `out` must be a valid, writable pointer, or null.
+            pub unsafe fn next(iter: *mut Self, out: *mut $entry) -> bool {
+                if iter.is_null() || out.is_null() {
+                    return false;
+                }
+
+                let it = unsafe { &mut *iter };
+                if it.index >= it.$field.len() {
+                    return false;
+                }
+
+                let entry = it.$field[it.index];
+                it.index += 1;
+                unsafe {
+                    *out = entry;
+                }
+
+                true
+            }
+
+            /// # Safety
+            /// `iter` must be a pointer returned by `new` (or null). Must not be used after.
+            pub unsafe fn free(iter: *mut Self) {
+                if iter.is_null() {
+                    return;
+                }
+                unsafe {
+                    let _ = Box::from_raw(iter);
+                }
+            }
+        }
+    };
+}
+
+pub mod declaration_api;
+pub mod definition_api;
+pub mod diagnostic_api;
+pub mod document_api;
+pub mod graph_api;
+pub mod location_api;
+pub mod name_api;
+pub mod reference_api;
+pub mod utils;

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

@@ -1,79 +1,79 @@
-//! Location-related C API and structs
-
-use libc::c_char;
-use rubydex::model::document::Document;
-use rubydex::model::graph::Graph;
-use rubydex::offset::Offset;
-use std::ffi::CString;
-
-/// C-compatible struct representing a definition location with offsets and line/column positions.
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub struct Location {
-    pub uri: *const c_char,
-    pub start_line: u32,
-    pub end_line: u32,
-    pub start_column: u32,
-    pub end_column: u32,
-}
-
-/// Helper to create a location for a given URI and byte-offset range.
-/// Allocates and returns a pointer to `Location`. Caller must free with `rdx_location_free`.
-///
-/// # Panics
-///
-/// - If the URI cannot be converted to a file path.
-/// - If the file cannot be read.
-/// - If the offset cannot be converted to a position.
-#[must_use]
-pub(crate) fn create_location_for_uri_and_offset(graph: &Graph, document: &Document, offset: &Offset) -> *mut Location {
-    let line_index = document.line_index();
-    let start_pos = line_index.line_col(offset.start().into());
-    let end_pos = line_index.line_col(offset.end().into());
-
-    let loc = if let Some(wide_encoding) = graph.encoding().to_wide() {
-        let wide_start_pos = line_index.to_wide(wide_encoding, start_pos).unwrap();
-        let wide_end_pos = line_index.to_wide(wide_encoding, end_pos).unwrap();
-
-        Location {
-            uri: CString::new(document.uri()).unwrap().into_raw().cast_const(),
-            start_line: wide_start_pos.line,
-            end_line: wide_end_pos.line,
-            start_column: wide_start_pos.col,
-            end_column: wide_end_pos.col,
-        }
-    } else {
-        Location {
-            uri: CString::new(document.uri()).unwrap().into_raw().cast_const(),
-            start_line: start_pos.line,
-            end_line: end_pos.line,
-            start_column: start_pos.col,
-            end_column: end_pos.col,
-        }
-    };
-
-    Box::into_raw(Box::new(loc))
-}
-
-/// Frees a `Location` struct and its owned inner strings.
-///
-/// # Safety
-///
-/// - `ptr` must be a valid pointer previously returned by `create_location_for_uri_and_offset`.
-/// - `ptr` must not be used after being freed.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_location_free(ptr: *mut Location) {
-    if ptr.is_null() {
-        return;
-    }
-    unsafe {
-        // Take ownership of the box so we can free inner allocations first
-        let boxed = Box::from_raw(ptr);
-
-        if !boxed.uri.is_null() {
-            let _ = CString::from_raw(boxed.uri.cast_mut());
-        }
-
-        // Box drops here, freeing the struct memory
-    }
-}
+//! Location-related C API and structs
+
+use libc::c_char;
+use rubydex::model::document::Document;
+use rubydex::model::graph::Graph;
+use rubydex::offset::Offset;
+use std::ffi::CString;
+
+/// C-compatible struct representing a definition location with offsets and line/column positions.
+#[repr(C)]
+#[derive(Debug, Clone)]
+pub struct Location {
+    pub uri: *const c_char,
+    pub start_line: u32,
+    pub end_line: u32,
+    pub start_column: u32,
+    pub end_column: u32,
+}
+
+/// Helper to create a location for a given URI and byte-offset range.
+/// Allocates and returns a pointer to `Location`. Caller must free with `rdx_location_free`.
+///
+/// # Panics
+///
+/// - If the URI cannot be converted to a file path.
+/// - If the file cannot be read.
+/// - If the offset cannot be converted to a position.
+#[must_use]
+pub(crate) fn create_location_for_uri_and_offset(graph: &Graph, document: &Document, offset: &Offset) -> *mut Location {
+    let line_index = document.line_index();
+    let start_pos = line_index.line_col(offset.start().into());
+    let end_pos = line_index.line_col(offset.end().into());
+
+    let loc = if let Some(wide_encoding) = graph.encoding().to_wide() {
+        let wide_start_pos = line_index.to_wide(wide_encoding, start_pos).unwrap();
+        let wide_end_pos = line_index.to_wide(wide_encoding, end_pos).unwrap();
+
+        Location {
+            uri: CString::new(document.uri()).unwrap().into_raw().cast_const(),
+            start_line: wide_start_pos.line,
+            end_line: wide_end_pos.line,
+            start_column: wide_start_pos.col,
+            end_column: wide_end_pos.col,
+        }
+    } else {
+        Location {
+            uri: CString::new(document.uri()).unwrap().into_raw().cast_const(),
+            start_line: start_pos.line,
+            end_line: end_pos.line,
+            start_column: start_pos.col,
+            end_column: end_pos.col,
+        }
+    };
+
+    Box::into_raw(Box::new(loc))
+}
+
+/// Frees a `Location` struct and its owned inner strings.
+///
+/// # Safety
+///
+/// - `ptr` must be a valid pointer previously returned by `create_location_for_uri_and_offset`.
+/// - `ptr` must not be used after being freed.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_location_free(ptr: *mut Location) {
+    if ptr.is_null() {
+        return;
+    }
+    unsafe {
+        // Take ownership of the box so we can free inner allocations first
+        let boxed = Box::from_raw(ptr);
+
+        if !boxed.uri.is_null() {
+            let _ = CString::from_raw(boxed.uri.cast_mut());
+        }
+
+        // Box drops here, freeing the struct memory
+    }
+}

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

@@ -1,135 +1,187 @@
-use rubydex::model::{
-    graph::Graph,
-    ids::NameId,
-    name::{Name, ParentScope},
-};
-
-/// Takes a constant name and a nesting stack (e.g.: `["Foo", "Bar::Baz", "Qux"]`) and transforms it into a `NameId`,
-/// registering each required part in the graph. Returns the `NameId` and a list of name ids that need to be untracked
-/// afterwards
-///
-/// # Panics
-///
-/// Should not panic because `const_name` will always be turned into a name
-pub fn nesting_stack_to_name_id(graph: &mut Graph, const_name: &str, nesting: Vec<String>) -> (NameId, Vec<NameId>) {
-    let mut current_nesting = None;
-    let mut current_name = ParentScope::None;
-    let mut names_to_untrack = Vec::new();
-
-    for entry in nesting {
-        for part in entry.split("::").map(String::from) {
-            if part.is_empty() {
-                current_name = ParentScope::TopLevel;
-                continue;
-            }
-
-            let str_id = graph.intern_string(part);
-            let name_id = graph.add_name(Name::new(str_id, current_name, current_nesting));
-            names_to_untrack.push(name_id);
-            current_name = ParentScope::Some(name_id);
-        }
-
-        current_nesting = current_name.map_or(None, |id| Some(*id));
-        current_name = ParentScope::None;
-    }
-
-    for part in const_name.split("::").map(String::from) {
-        if part.is_empty() {
-            current_name = ParentScope::TopLevel;
-            continue;
-        }
-
-        let str_id = graph.intern_string(part);
-        let name_id = graph.add_name(Name::new(str_id, current_name, current_nesting));
-        names_to_untrack.push(name_id);
-        current_name = ParentScope::Some(name_id);
-    }
-
-    (
-        current_name.expect("The NameId cannot be None since it contains at least `const_name`"),
-        names_to_untrack,
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use rubydex::model::ids::StringId;
-
-    use super::*;
-
-    #[test]
-    fn nesting_is_converted_to_name_id() {
-        let mut graph = Graph::new();
-
-        let (name_id, _) = nesting_stack_to_name_id(
-            &mut graph,
-            "Some::CONST",
-            vec!["Foo".into(), "Bar::Zip".into(), "Qux".into()],
-        );
-
-        let const_name = graph.names().get(&name_id).unwrap();
-        assert_eq!(StringId::from("CONST"), *const_name.str());
-
-        let some_name = graph
-            .names()
-            .get(&const_name.parent_scope().expect("Parent scope should exist"))
-            .unwrap();
-        assert_eq!(StringId::from("Some"), *some_name.str());
-        assert_eq!(const_name.nesting(), some_name.nesting());
-
-        let qux_name = graph.names().get(&some_name.nesting().unwrap()).unwrap();
-        assert_eq!(StringId::from("Qux"), *qux_name.str());
-        assert!(qux_name.parent_scope().is_none());
-
-        let zip_name = graph.names().get(&qux_name.nesting().unwrap()).unwrap();
-        assert_eq!(StringId::from("Zip"), *zip_name.str());
-
-        let bar_name = graph
-            .names()
-            .get(&zip_name.parent_scope().expect("Parent scope should exist"))
-            .unwrap();
-        assert_eq!(StringId::from("Bar"), *bar_name.str());
-        assert_eq!(zip_name.nesting(), bar_name.nesting());
-
-        let foo_name = graph.names().get(&bar_name.nesting().unwrap()).unwrap();
-        assert_eq!(StringId::from("Foo"), *foo_name.str());
-        assert!(foo_name.parent_scope().is_none());
-        assert!(foo_name.nesting().is_none());
-    }
-
-    #[test]
-    fn top_level_reference_is_converted_to_name_id() {
-        let mut graph = Graph::new();
-
-        let (name_id, _) = nesting_stack_to_name_id(&mut graph, "::CONST", vec!["Foo".into()]);
-
-        let const_name = graph.names().get(&name_id).unwrap();
-        assert_eq!(StringId::from("CONST"), *const_name.str());
-        assert!(const_name.parent_scope().is_top_level());
-
-        let foo_name = graph.names().get(&const_name.nesting().unwrap()).unwrap();
-        assert_eq!(StringId::from("Foo"), *foo_name.str());
-        assert!(foo_name.nesting().is_none());
-        assert!(foo_name.parent_scope().is_none());
-    }
-
-    #[test]
-    fn top_level_nesting_is_converted_to_name_id() {
-        let mut graph = Graph::new();
-
-        let (name_id, _) = nesting_stack_to_name_id(&mut graph, "CONST", vec!["Foo".into(), "::Bar".into()]);
-
-        let const_name = graph.names().get(&name_id).unwrap();
-        assert_eq!(StringId::from("CONST"), *const_name.str());
-        assert!(const_name.parent_scope().is_none());
-
-        let bar_name = graph.names().get(&const_name.nesting().unwrap()).unwrap();
-        assert_eq!(StringId::from("Bar"), *bar_name.str());
-        assert!(bar_name.parent_scope().is_top_level());
-
-        let foo_name = graph.names().get(&bar_name.nesting().unwrap()).unwrap();
-        assert_eq!(StringId::from("Foo"), *foo_name.str());
-        assert!(foo_name.parent_scope().is_none());
-        assert!(foo_name.nesting().is_none());
-    }
-}
+use rubydex::model::{
+    graph::Graph,
+    ids::NameId,
+    name::{Name, ParentScope},
+};
+
+/// Takes a constant name and a nesting stack (e.g.: `["Foo", "Bar::Baz", "Qux"]`) and transforms it into a `NameId`,
+/// registering each required part in the graph. Returns the `NameId` and a list of name ids that need to be untracked
+/// afterwards. Returns `None` if the constant name contains no valid identifier parts (e.g.: `""`, `"::"`, `"Foo::"`).
+pub fn nesting_stack_to_name_id(
+    graph: &mut Graph,
+    const_name: &str,
+    nesting: Vec<String>,
+) -> Option<(NameId, Vec<NameId>)> {
+    let mut current_nesting = None;
+    let mut current_name = ParentScope::None;
+    let mut names_to_untrack = Vec::new();
+
+    for entry in nesting {
+        process_qualified_name(
+            graph,
+            &entry,
+            &mut current_name,
+            &mut current_nesting,
+            &mut names_to_untrack,
+        );
+        current_nesting = current_name.as_ref().copied();
+        current_name = ParentScope::None;
+    }
+
+    process_qualified_name(
+        graph,
+        const_name,
+        &mut current_name,
+        &mut current_nesting,
+        &mut names_to_untrack,
+    );
+
+    let (ParentScope::Some(name_id) | ParentScope::Attached(name_id)) = current_name else {
+        return None;
+    };
+
+    Some((name_id, names_to_untrack))
+}
+
+/// 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.
+fn process_qualified_name(
+    graph: &mut Graph,
+    qualified_name: &str,
+    current_name: &mut ParentScope,
+    current_nesting: &mut Option<NameId>,
+    names_to_untrack: &mut Vec<NameId>,
+) {
+    for part in qualified_name.split("::") {
+        if part.is_empty() {
+            *current_name = ParentScope::TopLevel;
+            continue;
+        }
+
+        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),
+            };
+
+            (attached, None)
+        } else {
+            (*current_name, *current_nesting)
+        };
+
+        let str_id = graph.intern_string(part.to_owned());
+        let name_id = graph.add_name(Name::new(str_id, parent_scope, nesting_for_part));
+        names_to_untrack.push(name_id);
+        *current_name = ParentScope::Some(name_id);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rubydex::model::ids::StringId;
+
+    use super::*;
+
+    #[test]
+    fn nesting_is_converted_to_name_id() {
+        let mut graph = Graph::new();
+
+        let (name_id, _) = nesting_stack_to_name_id(
+            &mut graph,
+            "Some::CONST",
+            vec!["Foo".into(), "Bar::Zip".into(), "Qux".into()],
+        )
+        .unwrap();
+
+        let const_name = graph.names().get(&name_id).unwrap();
+        assert_eq!(StringId::from("CONST"), *const_name.str());
+
+        let some_name = graph
+            .names()
+            .get(&const_name.parent_scope().expect("Parent scope should exist"))
+            .unwrap();
+        assert_eq!(StringId::from("Some"), *some_name.str());
+        assert_eq!(const_name.nesting(), some_name.nesting());
+
+        let qux_name = graph.names().get(&some_name.nesting().unwrap()).unwrap();
+        assert_eq!(StringId::from("Qux"), *qux_name.str());
+        assert!(qux_name.parent_scope().is_none());
+
+        let zip_name = graph.names().get(&qux_name.nesting().unwrap()).unwrap();
+        assert_eq!(StringId::from("Zip"), *zip_name.str());
+
+        let bar_name = graph
+            .names()
+            .get(&zip_name.parent_scope().expect("Parent scope should exist"))
+            .unwrap();
+        assert_eq!(StringId::from("Bar"), *bar_name.str());
+        assert_eq!(zip_name.nesting(), bar_name.nesting());
+
+        let foo_name = graph.names().get(&bar_name.nesting().unwrap()).unwrap();
+        assert_eq!(StringId::from("Foo"), *foo_name.str());
+        assert!(foo_name.parent_scope().is_none());
+        assert!(foo_name.nesting().is_none());
+    }
+
+    #[test]
+    fn top_level_reference_is_converted_to_name_id() {
+        let mut graph = Graph::new();
+
+        let (name_id, _) = nesting_stack_to_name_id(&mut graph, "::CONST", vec!["Foo".into()]).unwrap();
+
+        let const_name = graph.names().get(&name_id).unwrap();
+        assert_eq!(StringId::from("CONST"), *const_name.str());
+        assert!(const_name.parent_scope().is_top_level());
+
+        let foo_name = graph.names().get(&const_name.nesting().unwrap()).unwrap();
+        assert_eq!(StringId::from("Foo"), *foo_name.str());
+        assert!(foo_name.nesting().is_none());
+        assert!(foo_name.parent_scope().is_none());
+    }
+
+    #[test]
+    fn singleton_class_names_use_attached_parent_scope() {
+        let mut graph = Graph::new();
+
+        let (name_id, _) = nesting_stack_to_name_id(&mut graph, "CONST", vec!["Foo".into(), "<Foo>".into()]).unwrap();
+
+        let const_name = graph.names().get(&name_id).unwrap();
+        assert_eq!(StringId::from("CONST"), *const_name.str());
+
+        // The nesting should be <Foo> with an Attached parent scope
+        let singleton_name = graph.names().get(&const_name.nesting().unwrap()).unwrap();
+        assert_eq!(StringId::from("<Foo>"), *singleton_name.str());
+        assert!(
+            matches!(singleton_name.parent_scope(), ParentScope::Attached(_)),
+            "Expected ParentScope::Attached, got {}",
+            singleton_name.parent_scope()
+        );
+
+        // The attached parent should be Foo
+        let foo_id = singleton_name.parent_scope().expect("Attached should have an id");
+        let foo_name = graph.names().get(&foo_id).unwrap();
+        assert_eq!(StringId::from("Foo"), *foo_name.str());
+    }
+
+    #[test]
+    fn top_level_nesting_is_converted_to_name_id() {
+        let mut graph = Graph::new();
+
+        let (name_id, _) = nesting_stack_to_name_id(&mut graph, "CONST", vec!["Foo".into(), "::Bar".into()]).unwrap();
+
+        let const_name = graph.names().get(&name_id).unwrap();
+        assert_eq!(StringId::from("CONST"), *const_name.str());
+        assert!(const_name.parent_scope().is_none());
+
+        let bar_name = graph.names().get(&const_name.nesting().unwrap()).unwrap();
+        assert_eq!(StringId::from("Bar"), *bar_name.str());
+        assert!(bar_name.parent_scope().is_top_level());
+
+        let foo_name = graph.names().get(&bar_name.nesting().unwrap()).unwrap();
+        assert_eq!(StringId::from("Foo"), *foo_name.str());
+        assert!(foo_name.parent_scope().is_none());
+        assert!(foo_name.nesting().is_none());
+    }
+}