ctest: Add extraction of relevant types.

Author: mbyx

ctest-next/src/ast/mod.rs

@@ -42,7 +42,8 @@ impl From<&str> for Abi {
 /// This is not an exhaustive list and only contains variants directly useful
 /// for our purposes.
 #[derive(Debug, Clone)]
-pub enum Item {
+#[expect(unused)]
+pub(crate) enum Item {
     /// Represents a constant defined in Rust.
     Const(Const),
     /// Represents a function defined in Rust.

ctest-next/src/ffi_items.rs

@@ -8,7 +8,7 @@ use crate::{Abi, Const, Field, Fn, Parameter, Static, Struct, Type, Union};
 ///
 /// Includes foreign functions/statics, type aliases, structs, unions, and constants.
 #[derive(Default, Clone, Debug)]
-pub struct FfiItems {
+pub(crate) struct FfiItems {
     aliases: Vec<Type>,
     structs: Vec<Struct>,
     unions: Vec<Union>,
@@ -19,49 +19,55 @@ pub struct FfiItems {
 
 impl FfiItems {
     /// Creates a new blank FfiItems.
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Self::default()
     }
 
     /// Return whether the type has parsed a struct with the given identifier.
-    pub fn contains_struct(&self, ident: &str) -> bool {
+    #[expect(unused)]
+    pub(crate) fn contains_struct(&self, ident: &str) -> bool {
         self.structs()
             .iter()
             .any(|structure| structure.ident() == ident)
     }
 
     /// Return whether the type has parsed a union with the given identifier.
-    pub fn contains_union(&self, ident: &str) -> bool {
+    #[expect(unused)]
+    pub(crate) fn contains_union(&self, ident: &str) -> bool {
         self.unions().iter().any(|union| union.ident() == ident)
     }
 
     /// Return a list of all type aliases found.
-    pub fn aliases(&self) -> &Vec<Type> {
+    #[expect(unused)]
+    pub(crate) fn aliases(&self) -> &Vec<Type> {
         &self.aliases
     }
 
     /// Return a list of all structs found.
-    pub fn structs(&self) -> &Vec<Struct> {
+    pub(crate) fn structs(&self) -> &Vec<Struct> {
         &self.structs
     }
 
     /// Return a list of all unions found.
-    pub fn unions(&self) -> &Vec<Union> {
+    pub(crate) fn unions(&self) -> &Vec<Union> {
         &self.unions
     }
 
     /// Return a list of all constants found.
-    pub fn constants(&self) -> &Vec<Const> {
+    #[expect(unused)]
+    pub(crate) fn constants(&self) -> &Vec<Const> {
         &self.constants
     }
 
     /// Return a list of all foreign functions found mapped by their ABI.
-    pub fn foreign_functions(&self) -> &Vec<Fn> {
+    #[expect(unused)]
+    pub(crate) fn foreign_functions(&self) -> &Vec<Fn> {
         &self.foreign_functions
     }
 
     /// Return a list of all foreign statics found mapped by their ABI.
-    pub fn foreign_statics(&self) -> &Vec<Static> {
+    #[expect(unused)]
+    pub(crate) fn foreign_statics(&self) -> &Vec<Static> {
         &self.foreign_statics
     }
 }
@@ -211,3 +217,75 @@ impl<'ast> Visit<'ast> for FfiItems {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::expand;
+
+    use super::*;
+
+    use syn::visit::Visit;
+
+    #[test]
+    fn test_extraction_ffi_items() {
+        let expanded = expand("./tests/input/all_items.rs").unwrap();
+        let ast = syn::parse_file(&expanded).unwrap();
+
+        let mut ffi_items = FfiItems::new();
+        ffi_items.visit_file(&ast);
+
+        assert_eq!(
+            ffi_items
+                .aliases()
+                .iter()
+                .map(|a| a.ident())
+                .collect::<Vec<_>>(),
+            ["Foo"]
+        );
+
+        assert_eq!(
+            ffi_items
+                .constants()
+                .iter()
+                .map(|a| a.ident())
+                .collect::<Vec<_>>(),
+            ["bar"]
+        );
+
+        assert_eq!(
+            ffi_items
+                .foreign_functions()
+                .iter()
+                .map(|a| a.ident())
+                .collect::<Vec<_>>(),
+            ["malloc"]
+        );
+
+        assert_eq!(
+            ffi_items
+                .foreign_statics()
+                .iter()
+                .map(|a| a.ident())
+                .collect::<Vec<_>>(),
+            ["baz"]
+        );
+
+        assert_eq!(
+            ffi_items
+                .structs()
+                .iter()
+                .map(|a| a.ident())
+                .collect::<Vec<_>>(),
+            ["Array"]
+        );
+
+        assert_eq!(
+            ffi_items
+                .unions()
+                .iter()
+                .map(|a| a.ident())
+                .collect::<Vec<_>>(),
+            ["Word"]
+        );
+    }
+}

ctest-next/src/generator.rs

@@ -2,7 +2,7 @@ use std::path::Path;
 
 use syn::visit::Visit;
 
-use crate::{expand, FfiItems, Result};
+use crate::{expand, ffi_items::FfiItems, Result};
 
 /// A builder used to generate a test suite.
 #[non_exhaustive]

ctest-next/src/lib.rs

@@ -13,8 +13,7 @@ mod ffi_items;
 mod generator;
 mod macro_expansion;
 
-pub use ast::{Abi, Const, Field, Fn, Item, Parameter, Static, Struct, Type, Union};
-pub use ffi_items::FfiItems;
+pub use ast::{Abi, Const, Field, Fn, Parameter, Static, Struct, Type, Union};
 pub use generator::TestGenerator;
 pub use macro_expansion::expand;