rubydex 0.4.0-aarch64-linux → 0.4.2-aarch64-linux

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

@@ -10,9 +10,10 @@ use crate::{name_api, utils};
 use libc::{c_char, c_void};
 use rubydex::config::Config;
 use rubydex::indexing::LanguageId;
+use rubydex::model::definitions::Definition;
 use rubydex::model::encoding::Encoding;
 use rubydex::model::graph::Graph;
-use rubydex::model::ids::{DeclarationId, NameId, UriId, declaration_id_from_lookup_name};
+use rubydex::model::ids::{DeclarationId, DefinitionId, NameId, UriId, declaration_id_from_lookup_name};
 use rubydex::model::keywords;
 use rubydex::model::name::NameRef;
 use rubydex::model::visibility::Visibility;
@@ -133,6 +134,27 @@ pub unsafe extern "C" fn rdx_graph_declarations_fuzzy_search(
     DeclarationsIter::new(entries)
 }
 
+/// Returns an iterator over all dead code candidates in the graph.
+///
+/// # Safety
+///
+/// Expects `pointer` to be a valid graph. The returned iterator must be freed with `rdx_graph_declarations_iter_free`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_dead_code_candidates(pointer: GraphPointer) -> *mut DeclarationsIter {
+    let entries = with_graph(pointer, |graph| {
+        query::dead_code_candidates(graph)
+            .into_iter()
+            .filter_map(|id| {
+                let decl = graph.declarations().get(&id)?;
+                Some(CDeclaration::from_declaration(id, decl))
+            })
+            .collect::<Vec<CDeclaration>>()
+            .into_boxed_slice()
+    });
+
+    DeclarationsIter::new(entries)
+}
+
 /// # Panics
 ///
 /// Will panic if the nesting cannot be transformed into a vector of strings
@@ -151,25 +173,98 @@ pub unsafe extern "C" fn rdx_graph_resolve_constant(
         let nesting: Vec<String> = unsafe { utils::convert_double_pointer_to_vec(nesting, count).unwrap() };
         let const_name: String = unsafe { utils::convert_char_ptr_to_string(const_name).unwrap() };
 
-        let Some((name_id, names_to_untrack)) = name_api::nesting_stack_to_name_id(graph, &const_name, nesting) else {
+        let Some(tracked_name) = name_api::name_from_nesting_names(graph, &const_name, nesting) else {
             return ptr::null();
         };
 
-        let mut resolver = Resolver::new(graph);
+        resolve_constant_name(tracked_name)
+    })
+}
+
+/// Result of resolving a constant using a namespace definition as its lexical context.
+#[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CDefinitionConstantResolution {
+    Resolved = 0,
+    NotFound = 1,
+    DefinitionNotFound = 2,
+    InvalidDefinitionKind = 3,
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct CDefinitionConstantResolutionResult {
+    pub status: CDefinitionConstantResolution,
+    pub declaration: *const CDeclaration,
+}
 
-        let declaration = match resolver.resolve_constant(name_id) {
-            Some(id) => {
-                let decl = graph.declarations().get(&id).unwrap();
-                Box::into_raw(Box::new(CDeclaration::from_declaration(id, decl))).cast_const()
+/// Resolves a constant using a namespace definition as its lexical context.
+///
+/// # Panics
+///
+/// Panics if `const_name` cannot be converted to a string.
+///
+/// # Safety
+///
+/// Assumes that `pointer` and `const_name` are valid.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_resolve_constant_from_definition(
+    pointer: GraphPointer,
+    const_name: *const c_char,
+    definition_id: u64,
+) -> CDefinitionConstantResolutionResult {
+    with_mut_graph(pointer, |graph| {
+        let const_name: String = unsafe { utils::convert_char_ptr_to_string(const_name).unwrap() };
+        let nesting = match class_or_module_definition_name_id(graph, DefinitionId::new(definition_id)) {
+            Ok(nesting) => nesting,
+            Err(status) => {
+                return CDefinitionConstantResolutionResult {
+                    status,
+                    declaration: ptr::null(),
+                };
             }
-            None => ptr::null(),
         };
 
-        for name_id in names_to_untrack {
-            graph.untrack_name(name_id);
-        }
+        let Some(tracked_name) = name_api::name_from_lexical_nesting(graph, &const_name, Some(nesting)) else {
+            return CDefinitionConstantResolutionResult {
+                status: CDefinitionConstantResolution::NotFound,
+                declaration: ptr::null(),
+            };
+        };
+
+        let declaration = resolve_constant_name(tracked_name);
+        let status = if declaration.is_null() {
+            CDefinitionConstantResolution::NotFound
+        } else {
+            CDefinitionConstantResolution::Resolved
+        };
+
+        CDefinitionConstantResolutionResult { status, declaration }
+    })
+}
 
-        declaration
+fn class_or_module_definition_name_id(
+    graph: &Graph,
+    definition_id: DefinitionId,
+) -> Result<NameId, CDefinitionConstantResolution> {
+    let Some(definition) = graph.definitions().get(&definition_id) else {
+        return Err(CDefinitionConstantResolution::DefinitionNotFound);
+    };
+
+    match definition {
+        Definition::Class(definition) => Ok(*definition.name_id()),
+        Definition::SingletonClass(definition) => Ok(*definition.name_id()),
+        Definition::Module(definition) => Ok(*definition.name_id()),
+        _ => Err(CDefinitionConstantResolution::InvalidDefinitionKind),
+    }
+}
+
+fn resolve_constant_name(mut tracked_name: name_api::TrackedName<'_>) -> *const CDeclaration {
+    let name_id = tracked_name.name_id();
+    let declaration_id = Resolver::new(tracked_name.graph_mut()).resolve_constant(name_id);
+    declaration_id.map_or(ptr::null(), |id| {
+        let declaration = tracked_name.graph().declarations().get(&id).unwrap();
+        Box::into_raw(Box::new(CDeclaration::from_declaration(id, declaration))).cast_const()
     })
 }
 
@@ -644,7 +739,7 @@ pub unsafe extern "C" fn rdx_index_source(
     };
 
     with_mut_graph(pointer, |graph| {
-        indexing::index_source(graph, &uri_str, source_str, &language);
+        indexing::index_source(graph, uri_str.into(), source_str, &language);
         IndexSourceResult::Success
     })
 }
@@ -714,19 +809,19 @@ pub unsafe extern "C" fn rdx_completion_candidates_free(ptr: *mut CompletionCand
     }
 }
 
-/// Converts the nesting stack into a `NameId`.
-/// The last element of the nesting stack is treated as the self type; if the stack is empty, `"Object"` is used.
+/// Converts the nesting names into a tracked name.
+/// The last nesting name is treated as the self type; if the array is empty, `"Object"` is used.
 ///
-/// Returns `Err` if the nesting array contains invalid UTF-8.
+/// Returns `None` if the nesting array contains invalid UTF-8.
 ///
 /// # Safety
 ///
 /// `nesting` must point to `nesting_count` valid, null-terminated UTF-8 strings.
-unsafe fn completion_nesting_name_id(
+unsafe fn completion_nesting_name(
     graph: &mut Graph,
     nesting: *const *const c_char,
     nesting_count: usize,
-) -> Option<(NameId, Vec<NameId>)> {
+) -> Option<name_api::TrackedName<'_>> {
     let mut nesting: Vec<String> = unsafe { utils::convert_double_pointer_to_vec(nesting, nesting_count).ok()? };
 
     // When serving completion in a bare script, the self (top level) context is Object
@@ -736,7 +831,7 @@ unsafe fn completion_nesting_name_id(
         nesting.pop().unwrap()
     };
 
-    name_api::nesting_stack_to_name_id(graph, &self_name, nesting)
+    name_api::name_from_nesting_names(graph, &self_name, nesting)
 }
 
 /// The result of a completion operation, carrying either a candidate array or an error message.
@@ -765,19 +860,10 @@ impl CompletionResult {
 }
 
 /// Runs completion for the given receiver and returns a structured result with candidates or an error message
-fn run_and_finalize_completion(
-    graph: &mut Graph,
-    receiver: CompletionReceiver,
-    names_to_untrack: Vec<NameId>,
-) -> CompletionResult {
+fn run_and_finalize_completion(graph: &Graph, receiver: CompletionReceiver) -> CompletionResult {
     let candidates = match query::completion_candidates(graph, CompletionContext::new(receiver)) {
         Ok(candidates) => candidates,
-        Err(e) => {
-            for name_id in names_to_untrack {
-                graph.untrack_name(name_id);
-            }
-            return CompletionResult::error(&e.to_string());
-        }
+        Err(e) => return CompletionResult::error(&e.to_string()),
     };
 
     let entries: Vec<CCompletionCandidate> = candidates
@@ -825,10 +911,6 @@ fn run_and_finalize_completion(
         })
         .collect();
 
-    for name_id in names_to_untrack {
-        graph.untrack_name(name_id);
-    }
-
     CompletionResult::success(CompletionCandidateArray::from_vec(entries))
 }
 
@@ -849,20 +931,19 @@ pub unsafe extern "C" fn rdx_graph_complete_expression(
     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) })
-        else {
+        let Some(tracked_name) = (unsafe { completion_nesting_name(graph, nesting, nesting_count) }) else {
             return CompletionResult::success(ptr::null_mut());
         };
+        let name_id = tracked_name.name_id();
 
         let self_decl_id = unsafe { decl_id_from_char_ptr(self_receiver) };
 
         run_and_finalize_completion(
-            graph,
+            tracked_name.graph(),
             CompletionReceiver::Expression {
                 self_decl_id,
                 nesting_name_id: name_id,
             },
-            names_to_untrack,
         )
     })
 }
@@ -896,7 +977,6 @@ pub unsafe extern "C" fn rdx_graph_complete_namespace_access(
                 self_decl_id,
                 namespace_decl_id: declaration_id_from_lookup_name(&name_str),
             },
-            Vec::new(),
         )
     })
 }
@@ -930,7 +1010,6 @@ pub unsafe extern "C" fn rdx_graph_complete_method_call(
                 self_decl_id,
                 receiver_decl_id: declaration_id_from_lookup_name(&name_str),
             },
-            Vec::new(),
         )
     })
 }
@@ -959,22 +1038,20 @@ pub unsafe extern "C" fn rdx_graph_complete_method_argument(
     };
 
     with_mut_graph(pointer, |graph| {
-        let Some((nesting_name_id, names_to_untrack)) =
-            (unsafe { completion_nesting_name_id(graph, nesting, nesting_count) })
-        else {
+        let Some(tracked_name) = (unsafe { completion_nesting_name(graph, nesting, nesting_count) }) else {
             return CompletionResult::success(ptr::null_mut());
         };
+        let nesting_name_id = tracked_name.name_id();
 
         let self_decl_id = unsafe { decl_id_from_char_ptr(self_receiver) };
 
         run_and_finalize_completion(
-            graph,
+            tracked_name.graph(),
             CompletionReceiver::MethodArgument {
                 self_decl_id,
                 nesting_name_id,
                 method_decl_id: declaration_id_from_lookup_name(&name_str),
             },
-            names_to_untrack,
         )
     })
 }
@@ -1095,6 +1172,7 @@ pub unsafe extern "C" fn rdx_keyword_free(ptr: *const CKeyword) {
 
 #[cfg(test)]
 mod tests {
+    use crate::declaration_api;
     use rubydex::indexing::ruby_indexer::RubyIndexer;
 
     use super::*;
@@ -1145,7 +1223,9 @@ mod tests {
                 nesting_ptrs.as_ptr(),
                 nesting_ptrs.len(),
             );
+            assert!(!decl.is_null());
             assert_eq!((*decl).id(), *DeclarationId::from("Foo::BAR"));
+            declaration_api::free_c_declaration(decl);
         };
 
         let graph = unsafe { Box::from_raw(graph_ptr.cast::<RwLock<Graph>>()) };
@@ -1167,4 +1247,72 @@ mod tests {
                 .ref_count()
         );
     }
+
+    #[test]
+    fn names_are_untracked_after_completion_error() {
+        let mut indexer = RubyIndexer::new(
+            "file:///foo.rb".into(),
+            "
+            class Foo
+            end
+            ",
+        );
+        indexer.index();
+
+        let mut graph = Graph::new();
+        graph.consume_document_changes(indexer.local_graph());
+        let mut resolver = Resolver::new(&mut graph);
+        resolver.resolve();
+
+        let (foo_name_id, foo_string_id, name_ref_count, string_ref_count) = graph
+            .names()
+            .iter()
+            .find_map(|(name_id, name)| {
+                let string_id = *name.str();
+                if graph.strings().get(&string_id).unwrap().as_str() == "Foo"
+                    && name.parent_scope().is_none()
+                    && name.nesting().is_none()
+                {
+                    Some((
+                        *name_id,
+                        string_id,
+                        name.ref_count(),
+                        graph.strings().get(&string_id).unwrap().ref_count(),
+                    ))
+                } else {
+                    None
+                }
+            })
+            .unwrap();
+        let name_count = graph.names().len();
+        let string_count = graph.strings().len();
+
+        let graph_ptr = Box::into_raw(Box::new(RwLock::new(graph))) as GraphPointer;
+        let nesting_strings = [CString::new("Foo").unwrap()];
+        let nesting_ptrs: Vec<*const c_char> = nesting_strings.iter().map(|s| s.as_ptr()).collect();
+        let self_receiver = CString::new("Nonexistent").unwrap();
+
+        let result = unsafe {
+            rdx_graph_complete_expression(
+                graph_ptr,
+                nesting_ptrs.as_ptr(),
+                nesting_ptrs.len(),
+                self_receiver.as_ptr(),
+            )
+        };
+        assert!(result.candidates.is_null());
+        assert!(!result.error.is_null());
+        utils::free_c_string(result.error);
+
+        let graph = unsafe { Box::from_raw(graph_ptr.cast::<RwLock<Graph>>()) };
+        let graph = graph.read().unwrap();
+
+        assert_eq!(name_count, graph.names().len());
+        assert_eq!(string_count, graph.strings().len());
+        assert_eq!(name_ref_count, graph.names().get(&foo_name_id).unwrap().ref_count());
+        assert_eq!(
+            string_ref_count,
+            graph.strings().get(&foo_string_id).unwrap().ref_count()
+        );
+    }
 }