ctest: add foreign fn tests

Author: mbyx

ctest-next/src/ast/function.rs

@@ -6,14 +6,13 @@ use crate::{Abi, BoxStr, Parameter};
 #[derive(Debug, Clone)]
 pub struct Fn {
     pub(crate) public: bool,
-    #[expect(unused)]
     pub(crate) abi: Abi,
     pub(crate) ident: BoxStr,
     pub(crate) link_name: Option<BoxStr>,
-    #[expect(unused)]
     pub(crate) parameters: Vec<Parameter>,
     #[expect(unused)]
     pub(crate) return_type: Option<syn::Type>,
+    pub(crate) bare_fn_signature: BoxStr,
 }
 
 impl Fn {

ctest-next/src/ast/mod.rs

@@ -7,6 +7,8 @@ mod structure;
 mod type_alias;
 mod union;
 
+use std::fmt;
+
 pub use constant::Const;
 pub use field::Field;
 pub use function::Fn;
@@ -37,6 +39,16 @@ impl From<&str> for Abi {
     }
 }
 
+impl fmt::Display for Abi {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Abi::C => write!(f, "C"),
+            Abi::Rust => write!(f, "Rust"),
+            Abi::Other(s) => write!(f, "{s}"),
+        }
+    }
+}
+
 /// Things that can appear directly inside of a module or scope.
 ///
 /// This is not an exhaustive list and only contains variants directly useful

ctest-next/src/ffi_items.rs

@@ -1,5 +1,6 @@
 use std::ops::Deref;
 
+use quote::ToTokens;
 use syn::punctuated::Punctuated;
 use syn::visit::Visit;
 
@@ -57,7 +58,6 @@ impl FfiItems {
     }
 
     /// Return a list of all foreign functions found mapped by their ABI.
-    #[cfg_attr(not(test), expect(unused))]
     pub(crate) fn foreign_functions(&self) -> &Vec<Fn> {
         &self.foreign_functions
     }
@@ -142,6 +142,7 @@ fn visit_foreign_item_fn(table: &mut FfiItems, i: &syn::ForeignItemFn, abi: &Abi
         syn::ReturnType::Type(_, ty) => Some(ty.deref().clone()),
     };
     let link_name = extract_single_link_name(&i.attrs);
+    let bare_fn_signature = i.sig.to_token_stream().to_string().into_boxed_str();
 
     table.foreign_functions.push(Fn {
         public,
@@ -150,6 +151,7 @@ fn visit_foreign_item_fn(table: &mut FfiItems, i: &syn::ForeignItemFn, abi: &Abi
         link_name,
         parameters,
         return_type,
+        bare_fn_signature,
     });
 }
 

ctest-next/src/generator.rs

@@ -41,10 +41,11 @@ pub struct TestGenerator {
     pub(crate) skips: Vec<Skip>,
     verbose_skip: bool,
     pub(crate) volatile_items: Vec<VolatileItem>,
-    array_arg: Option<ArrayArg>,
+    pub(crate) array_arg: Option<ArrayArg>,
     skip_private: bool,
     skip_roundtrip: Option<SkipTest>,
     pub(crate) skip_signededness: Option<SkipTest>,
+    pub(crate) skip_fn_ptrcheck: Option<SkipTest>,
 }
 
 #[derive(Debug, Error)]
@@ -855,6 +856,21 @@ impl TestGenerator {
         self
     }
 
+    /// Configures whether tests for a function pointer's value are generated.
+    ///
+    /// The closure is given a Rust FFI function and returns whether
+    /// the test will be generated.
+    ///
+    /// By default generated tests will ensure that the function pointer in C
+    /// corresponds to the same function pointer in Rust. This can often
+    /// uncover subtle symbol naming issues where a header file is referenced
+    /// through the C identifier `foo` but the underlying symbol is mapped to
+    /// something like `__foo_compat`.
+    pub fn skip_fn_ptrcheck(&mut self, f: impl Fn(&str) -> bool + 'static) -> &mut Self {
+        self.skip_fn_ptrcheck = Some(Box::new(f));
+        self
+    }
+
     /// Generate the Rust and C testing files.
     ///
     /// Returns the path to the generated file.

ctest-next/src/lib.rs

@@ -36,7 +36,7 @@ type BoxStr = Box<str>;
 ///
 /// This is necessary because `ctest` does not parse the header file, so it
 /// does not know which items are volatile.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[non_exhaustive]
 pub enum VolatileItemKind {
     /// A struct field.