ctest: Add skips and mappings.

Author: mbyx

ctest-next/Cargo.toml

@@ -2,7 +2,7 @@
 name = "ctest-next"
 version = "0.1.0"
 edition = "2021"
-rust-version = "1.77"
+rust-version = "1.87"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/rust-lang/libc"
 publish = false

ctest-next/src/generator.rs

@@ -13,8 +13,7 @@ use crate::{
     expand,
     ffi_items::FfiItems,
     template::{CTestTemplate, RustTestTemplate},
-    Const, Field, Language, MapInput, Parameter, Result, Static, Struct, TyKind, Type,
-    VolatileItemKind,
+    Const, Field, MapInput, Parameter, Result, Static, Struct, Type, VolatileItemKind,
 };
 
 /// A function that takes a mappable input and returns its mapping as Some, otherwise
@@ -35,14 +34,12 @@ pub struct TestGenerator {
     pub(crate) target: Option<String>,
     pub(crate) includes: Vec<PathBuf>,
     out_dir: Option<PathBuf>,
-    /// The language chosen for testing bindings.
-    pub language: Language,
     flags: Vec<String>,
     defines: Vec<(String, Option<String>)>,
     mapped_names: Vec<MappedName>,
     skips: Vec<Skip>,
     verbose_skip: bool,
-    volatile_item: Option<VolatileItem>,
+    volatile_items: Vec<VolatileItem>,
     array_arg: Option<ArrayArg>,
 }
 
@@ -156,37 +153,116 @@ impl TestGenerator {
         self
     }
 
-    /// Is volatile?
+    /// Is field volatile?
     ///
-    /// The closure given takes a `VolatileKind` denoting a particular item that
-    /// could be volatile, and returns whether this is the case. This is used to
-    /// make sure that the generated test code also has the volatile keyword.
+    /// This is used to make sure that the generated test code also has the volatile keyword.
     ///
     /// # Examples
     ///
     /// ```no_run
     /// use ctest_next::{TestGenerator, VolatileItemKind};
     ///
     /// let mut cfg = TestGenerator::new();
-    /// cfg.volatile_item(|item| {
-    ///     match item {
-    ///         VolatileItemKind::StructField(s, f)
-    ///             if s.ident() == "foo_struct" && f.ident() == "foo_field"
-    ///              => true,
-    ///         _ => false,
-    /// }});
+    /// cfg.volatile_field(|s, f| {
+    ///     s.ident() == "foo_t" && f.ident() == "inner_t"
+    /// });
+    /// ```
+    pub fn volatile_field(&mut self, f: impl Fn(Struct, Field) -> bool + 'static) -> &mut Self {
+        self.volatile_items.push(Box::new(move |item| {
+            if let VolatileItemKind::StructField(s, f_) = item {
+                f(s, f_)
+            } else {
+                false
+            }
+        }));
+        self
+    }
+
+    /// Is static variable volatile?
+    ///
+    /// This is used to make sure that the generated test code also has the volatile keyword.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use ctest_next::{TestGenerator, VolatileItemKind};
+    ///
+    /// let mut cfg = TestGenerator::new();
+    /// cfg.volatile_static(|s| {
+    ///     s.ident() == "foo_t"
+    /// });
+    /// ```
+    pub fn volatile_static(&mut self, f: impl Fn(Static) -> bool + 'static) -> &mut Self {
+        self.volatile_items.push(Box::new(move |item| {
+            if let VolatileItemKind::Static(s) = item {
+                f(s)
+            } else {
+                false
+            }
+        }));
+        self
+    }
+
+    /// Is function argument volatile?
+    ///
+    /// This is used to make sure that the generated test code also has the volatile keyword.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use ctest_next::{TestGenerator, VolatileItemKind};
+    ///
+    /// let mut cfg = TestGenerator::new();
+    /// cfg.volatile_fn_arg(|f, _p| {
+    ///     f.ident() == "size_of_T"
+    /// });
     /// ```
-    pub fn volatile_item(&mut self, f: impl Fn(VolatileItemKind) -> bool + 'static) -> &mut Self {
-        self.volatile_item = Some(Box::new(f));
+    pub fn volatile_fn_arg(
+        &mut self,
+        f: impl Fn(crate::Fn, Box<Parameter>) -> bool + 'static,
+    ) -> &mut Self {
+        self.volatile_items.push(Box::new(move |item| {
+            if let VolatileItemKind::FnArgument(func, param) = item {
+                f(func, param)
+            } else {
+                false
+            }
+        }));
+        self
+    }
+
+    /// Is function return type volatile?
+    ///
+    /// This is used to make sure that the generated test code also has the volatile keyword.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use ctest_next::{TestGenerator, VolatileItemKind};
+    ///
+    /// let mut cfg = TestGenerator::new();
+    /// cfg.volatile_fn_return_type(|f| {
+    ///     f.ident() == "size_of_T"
+    /// });
+    /// ```
+    pub fn volatile_fn_return_type(
+        &mut self,
+        f: impl Fn(crate::Fn) -> bool + 'static,
+    ) -> &mut Self {
+        self.volatile_items.push(Box::new(move |item| {
+            if let VolatileItemKind::FnReturnType(func) = item {
+                f(func)
+            } else {
+                false
+            }
+        }));
         self
     }
 
     /// Is argument of function an array?
     ///
-    /// The closure denotes whether particular argument of a function is an array.
-    /// This is used to figure out which pointer argument is actually an array. For
-    /// example, `uint8_t*` could be a pointer to an integer or pointer to the start
-    /// of an array.
+    /// This closure should return true if a pointer argument to a function should be generated
+    /// with `T foo[]` syntax rather than `T *foo`.
     ///
     /// # Examples
     ///
@@ -343,27 +419,6 @@ impl TestGenerator {
         self
     }
 
-    /// Sets the programming language.
-    ///
-    /// This is used to generate C++ versions of the test that can be compiled
-    /// and ran in the same way as C.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::env;
-    /// use std::path::PathBuf;
-    ///
-    /// use ctest_next::{TestGenerator, Language};
-    ///
-    /// let mut cfg = TestGenerator::new();
-    /// cfg.language(Language::CXX);
-    /// ```
-    pub fn language(&mut self, language: Language) -> &mut Self {
-        self.language = language;
-        self
-    }
-
     /// Add a flag to the C compiler invocation.
     ///
     /// # Examples
@@ -466,24 +521,63 @@ impl TestGenerator {
     /// # Examples
     ///
     /// ```no_run
-    /// use ctest_next::{TestGenerator, TyKind};
+    /// use ctest_next::TestGenerator;
     ///
     /// let mut cfg = TestGenerator::new();
-    /// cfg.rename_type(|ty, kind| {
-    ///     if kind == TyKind::Struct {
-    ///         Some(format!("{}_t", ty))
-    ///     } else {
-    ///         None
-    ///     }
+    /// cfg.rename_type(|ty| {
+    ///     Some(format!("{}_t", ty))
     /// });
     /// ```
-    pub fn rename_type(
-        &mut self,
-        f: impl Fn(&str, TyKind) -> Option<String> + 'static,
-    ) -> &mut Self {
+    pub fn rename_type(&mut self, f: impl Fn(&str) -> Option<String> + 'static) -> &mut Self {
+        self.mapped_names.push(Box::new(move |item| {
+            if let MapInput::Type(ty) = item {
+                f(ty)
+            } else {
+                None
+            }
+        }));
+        self
+    }
+
+    /// Configures how a Rust struct type is translated to a C struct type.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use ctest_next::TestGenerator;
+    ///
+    /// let mut cfg = TestGenerator::new();
+    /// cfg.rename_struct_ty(|ty| {
+    ///     (ty == "timeval").then(|| format!("{ty}_t"))
+    /// });
+    /// ```
+    pub fn rename_struct_ty(&mut self, f: impl Fn(&str) -> Option<String> + 'static) -> &mut Self {
         self.mapped_names.push(Box::new(move |item| {
-            if let MapInput::Type(ty, kind) = item {
-                f(ty, *kind)
+            if let MapInput::StructType(ty) = item {
+                f(ty)
+            } else {
+                None
+            }
+        }));
+        self
+    }
+
+    /// Configures how a Rust union type is translated to a C union type.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use ctest_next::TestGenerator;
+    ///
+    /// let mut cfg = TestGenerator::new();
+    /// cfg.rename_struct_ty(|ty| {
+    ///     (ty == "T1Union").then(|| format!("__{ty}"))
+    /// });
+    /// ```
+    pub fn rename_union_ty(&mut self, f: impl Fn(&str) -> Option<String> + 'static) -> &mut Self {
+        self.mapped_names.push(Box::new(move |item| {
+            if let MapInput::UnionType(ty) = item {
+                f(ty)
             } else {
                 None
             }
@@ -531,18 +625,13 @@ impl TestGenerator {
             .map_err(GenerationError::OsError)?;
 
         // Generate the C/Cxx side of the tests.
-        let c_output_path = output_file_path.with_extension(self.language.extension());
+        let c_output_path = output_file_path.with_extension("c");
         File::create(&c_output_path)
             .map_err(GenerationError::OsError)?
             .write_all(
                 CTestTemplate::new(&ffi_items, self)
                     .render()
-                    .map_err(|e| {
-                        GenerationError::TemplateRender(
-                            self.language.display_name().to_string(),
-                            e.to_string(),
-                        )
-                    })?
+                    .map_err(|e| GenerationError::TemplateRender("C".to_string(), e.to_string()))?
                     .as_bytes(),
             )
             .map_err(GenerationError::OsError)?;
@@ -557,11 +646,12 @@ impl TestGenerator {
 
         macro_rules! filter {
             ($field:ident, $variant:ident, $label:literal) => {{
-                let (retained, skipped): (Vec<_>, Vec<_>) = ffi_items
+                let skipped: Vec<_> = ffi_items
                     .$field
-                    .drain(..)
-                    .partition(|item| !self.skips.iter().any(|f| f(&MapInput::$variant(item))));
-                ffi_items.$field = retained;
+                    .extract_if(.., |item| {
+                        self.skips.iter().any(|f| f(&MapInput::$variant(item)))
+                    })
+                    .collect();
                 if verbose {
                     skipped
                         .iter()
@@ -590,9 +680,9 @@ impl TestGenerator {
             MapInput::Struct(s) => s.ident().to_string(),
             MapInput::Alias(t) => t.ident().to_string(),
             MapInput::Field(_, f) => f.ident().to_string(),
-            MapInput::Type(ty, TyKind::Struct) => format!("struct {ty}"),
-            MapInput::Type(ty, TyKind::Union) => format!("union {ty}"),
-            MapInput::Type(ty, TyKind::Other) => ty.to_string(),
+            MapInput::StructType(ty) => format!("struct {ty}"),
+            MapInput::UnionType(ty) => format!("union {ty}"),
+            MapInput::Type(ty) => ty.to_string(),
         })
     }
 }