ctest: add foreign func tests

Author: mbyx

ctest-next/src/ast/function.rs

@@ -1,3 +1,5 @@
+use quote::ToTokens;
+
 use crate::{Abi, BoxStr, Parameter};
 
 /// Represents a function signature defined in Rust.
@@ -6,14 +8,12 @@ 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: syn::Signature,
 }
 
 impl Fn {
@@ -26,4 +26,9 @@ impl Fn {
     pub fn link_name(&self) -> Option<&str> {
         self.link_name.as_deref()
     }
+
+    /// Returns the signature of the function as a bare function type.
+    pub fn signature(&self) -> String {
+        self.bare_fn_signature.to_token_stream().to_string()
+    }
 }

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
@@ -47,7 +59,7 @@ pub(crate) enum Item {
     /// Represents a constant defined in Rust.
     Const(Const),
     /// Represents a function defined in Rust.
-    Fn(Fn),
+    Fn(Box<Fn>),
     /// Represents a static variable defined in Rust.
     Static(Static),
     /// Represents a type alias defined in Rust.

ctest-next/src/cdecl.rs

@@ -39,6 +39,20 @@ pub(crate) enum CTy {
 }
 
 impl CTy {
+    /// Walk through the C type and optionally modify each node.
+    pub(crate) fn walk_mut(&mut self, mut f: impl FnMut(&mut Self)) {
+        let mut head = self;
+        loop {
+            f(head);
+            match head {
+                Self::Named { .. } => break,
+                Self::Ptr { ty, .. } => head = ty,
+                Self::Array { ty, .. } => head = ty,
+                Self::Fn { ret, .. } => head = ret,
+            }
+        }
+    }
+
     /// Validate that we aren't returning an array or a function without indirection, which isn't
     /// allowed in C.
     fn check_ret_ty(&self) -> Result<(), InvalidReturn> {

ctest-next/src/ffi_items.rs

@@ -57,7 +57,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 +141,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.clone();
 
     table.foreign_functions.push(Fn {
         public,
@@ -150,6 +150,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

@@ -42,10 +42,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,
     pub(crate) skip_roundtrip: Option<SkipTest>,
     pub(crate) skip_signededness: Option<SkipTest>,
+    pub(crate) skip_fn_ptrcheck: Option<SkipTest>,
 }
 
 #[derive(Debug, Error)]
@@ -856,6 +857,30 @@ 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`.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use ctest_next::TestGenerator;
+    ///
+    /// let mut cfg = TestGenerator::new();
+    /// cfg.skip_fn_ptrcheck(|name| name == "T1p");
+    /// ```
+    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

@@ -37,7 +37,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.

ctest-next/src/template.rs

@@ -1,10 +1,12 @@
+use std::ops::Deref;
+
 use askama::Template;
 use proc_macro2::Span;
 use quote::ToTokens;
 use syn::spanned::Spanned;
 
 use crate::ffi_items::FfiItems;
-use crate::translator::Translator;
+use crate::translator::{TranslationErrorKind, Translator};
 use crate::{
     BoxStr, Field, MapInput, Result, TestGenerator, TranslationError, VolatileItemKind, cdecl,
 };
@@ -53,6 +55,7 @@ pub(crate) struct TestTemplate {
     pub field_ptr_tests: Vec<TestFieldPtr>,
     pub field_size_offset_tests: Vec<TestFieldSizeOffset>,
     pub roundtrip_tests: Vec<TestRoundtrip>,
+    pub foreign_fn_tests: Vec<TestForeignFn>,
     pub signededness_tests: Vec<TestSignededness>,
     pub size_align_tests: Vec<TestSizeAlign>,
     pub const_cstr_tests: Vec<TestCStr>,
@@ -75,6 +78,7 @@ impl TestTemplate {
         template.populate_field_size_offset_tests(&helper)?;
         template.populate_field_ptr_tests(&helper)?;
         template.populate_roundtrip_tests(&helper)?;
+        template.populate_foreign_fn_tests(&helper)?;
 
         Ok(template)
     }
@@ -359,7 +363,7 @@ impl TestTemplate {
             )
             .map_err(|_| {
                 TranslationError::new(
-                    crate::translator::TranslationErrorKind::InvalidReturn,
+                    TranslationErrorKind::InvalidReturn,
                     &field.ty.to_token_stream().to_string(),
                     field.ty.span(),
                 )
@@ -380,6 +384,54 @@ impl TestTemplate {
 
         Ok(())
     }
+
+    /// Populates tests for extern functions.
+    ///
+    /// It also keeps track of the names of each test.
+    fn populate_foreign_fn_tests(
+        &mut self,
+        helper: &TranslateHelper,
+    ) -> Result<(), TranslationError> {
+        let should_skip_fn_test = |ident| {
+            helper
+                .generator
+                .skip_fn_ptrcheck
+                .as_ref()
+                .is_some_and(|skip| skip(ident))
+        };
+        for func in helper.ffi_items.foreign_functions() {
+            if should_skip_fn_test(func.ident()) {
+                continue;
+            }
+
+            let signature =
+                helper.parse_signature_to_bare_fn(&func.signature(), &func.abi.to_string())?;
+            let bare_fn = helper
+                .translator
+                .translate_bare_fn(&signature, func.ident())?;
+            let return_type =
+                cdecl::cdecl(&bare_fn, format!("ctest_foreign_fn_type__{}", func.ident()))
+                    .map_err(|_| {
+                        TranslationError::new(
+                            TranslationErrorKind::InvalidReturn,
+                            func.ident(),
+                            func.return_type.span(),
+                        )
+                    })?;
+
+            let item = TestForeignFn {
+                test_name: foreign_fn_test_ident(func.ident()),
+                id: func.ident().into(),
+                c_val: helper.c_ident(func).into_boxed_str(),
+                return_type: return_type.into(),
+            };
+
+            self.foreign_fn_tests.push(item.clone());
+            self.test_idents.push(item.test_name);
+        }
+
+        Ok(())
+    }
 }
 
 /* Many test structures have the following fields:
@@ -457,6 +509,14 @@ pub(crate) struct TestRoundtrip {
     pub is_alias: bool,
 }
 
+#[derive(Clone, Debug)]
+pub(crate) struct TestForeignFn {
+    pub test_name: BoxStr,
+    pub c_val: BoxStr,
+    pub id: BoxStr,
+    pub return_type: BoxStr,
+}
+
 fn signededness_test_ident(ident: &str) -> BoxStr {
     format!("ctest_signededness_{ident}").into()
 }
@@ -485,6 +545,10 @@ fn roundtrip_test_ident(ident: &str) -> BoxStr {
     format!("ctest_roundtrip_{ident}").into()
 }
 
+fn foreign_fn_test_ident(ident: &str) -> BoxStr {
+    format!("ctest_foreign_fn_{ident}").into()
+}
+
 /// Wrap methods that depend on both ffi items and the generator.
 pub(crate) struct TranslateHelper<'a> {
     ffi_items: &'a FfiItems,
@@ -533,7 +597,7 @@ impl<'a> TranslateHelper<'a> {
 
         let ty = cdecl::cdecl(&ty, "".to_string()).map_err(|_| {
             TranslationError::new(
-                crate::translator::TranslationErrorKind::InvalidReturn,
+                TranslationErrorKind::InvalidReturn,
                 ident,
                 Span::call_site(),
             )
@@ -549,4 +613,30 @@ impl<'a> TranslateHelper<'a> {
 
         Ok(self.generator.rty_to_cty(item))
     }
+
+    /// Translate a proper function into a bare function type.
+    ///
+    /// Actual functions foreign or not do not have a type to use, however they can be
+    /// modelled as a bare function type. This method converts them into that bare function
+    /// type so that it can be used later for translation.
+    pub(crate) fn parse_signature_to_bare_fn(
+        &self,
+        signature: &str,
+        abi: &str,
+    ) -> Result<syn::TypeBareFn, TranslationError> {
+        // Transform `fn name() -> ...` to `fn() -> ...`.
+        let (_, s) = signature.split_once('(').unwrap();
+        let type_str = format!("type T = unsafe extern \"{abi}\" fn({s};");
+        let item: syn::ItemType = syn::parse_str(&type_str).map_err(|_| {
+            TranslationError::new(
+                TranslationErrorKind::UnsupportedType,
+                signature,
+                Span::call_site(),
+            )
+        })?;
+        if let syn::Type::BareFn(f) = item.ty.deref() {
+            return Ok(f.clone());
+        }
+        unreachable!("`parse_signature_to_bare_fn` returned a non function type.")
+    }
 }