ctest-next: miscellaneous filtering bug fixes

Author: mbyx

.github/workflows/ci.yaml

@@ -89,7 +89,7 @@ jobs:
               # Remove `-Dwarnings` at the MSRV since lints may be different
               export RUSTFLAGS=""
               # Remove `ctest-next` which uses the 2024 edition
-              perl -i -ne 'print unless /"ctest-(next|test)",/' Cargo.toml
+              perl -i -ne 'print unless /"ctest-(next|test)",/ || /"libc-test",/' Cargo.toml
           fi
 
           ./ci/verify-build.sh
@@ -320,7 +320,7 @@ jobs:
     - name: Install Rust
       run: rustup update "$MSRV" --no-self-update && rustup default "$MSRV"
     - name: Remove edition 2024 crates
-      run: perl -i -ne 'print unless /"ctest-(next|test)",/' Cargo.toml
+      run: perl -i -ne 'print unless /"ctest-(next|test)",/ || /"libc-test",/' Cargo.toml
     - uses: Swatinem/rust-cache@v2
     - run: cargo build -p ctest
 

Cargo.lock

@@ -3,7 +3,6 @@ use crate::{BoxStr, Field};
 /// Represents a union defined in Rust.
 #[derive(Debug, Clone)]
 pub struct Union {
-    #[expect(unused)]
     pub(crate) public: bool,
     pub(crate) ident: BoxStr,
     pub(crate) fields: Vec<Field>,

ctest-next/src/ast/union.rs

@@ -39,10 +39,10 @@ pub struct TestGenerator {
     cfg: Vec<(String, Option<String>)>,
     mapped_names: Vec<MappedName>,
     pub(crate) skips: Vec<Skip>,
-    verbose_skip: bool,
+    pub(crate) verbose_skip: bool,
     pub(crate) volatile_items: Vec<VolatileItem>,
     array_arg: Option<ArrayArg>,
-    skip_private: bool,
+    pub(crate) skip_private: bool,
     pub(crate) skip_roundtrip: Option<SkipTest>,
     pub(crate) skip_signededness: Option<SkipTest>,
 }
@@ -872,8 +872,6 @@ impl TestGenerator {
         let mut ffi_items = FfiItems::new();
         ffi_items.visit_file(&ast);
 
-        self.filter_ffi_items(&mut ffi_items);
-
         let output_directory = self
             .out_dir
             .clone()
@@ -912,37 +910,6 @@ impl TestGenerator {
         Ok(output_file_path)
     }
 
-    /// Skips entire items such as structs, constants, and aliases from being tested.
-    ///
-    /// Does not skip specific tests or specific fields. If `skip_private` is true,
-    /// it will skip tests for all private items.
-    fn filter_ffi_items(&self, ffi_items: &mut FfiItems) {
-        let verbose = self.verbose_skip;
-
-        macro_rules! filter {
-            ($field:ident, $variant:ident, $label:literal) => {{
-                let skipped: Vec<_> = ffi_items
-                    .$field
-                    .extract_if(.., |item| {
-                        self.skips.iter().any(|f| f(&MapInput::$variant(item)))
-                            || (self.skip_private && !item.public)
-                    })
-                    .collect();
-                if verbose {
-                    skipped
-                        .iter()
-                        .for_each(|item| eprintln!("Skipping {} \"{}\"", $label, item.ident()));
-                }
-            }};
-        }
-
-        filter!(aliases, Alias, "alias");
-        filter!(constants, Const, "const");
-        filter!(structs, Struct, "struct");
-        filter!(foreign_functions, Fn, "fn");
-        filter!(foreign_statics, Static, "static");
-    }
-
     /// Maps Rust identifiers or types to C counterparts, or defaults to the original name.
     pub(crate) fn rty_to_cty<'a>(&self, item: impl Into<MapInput<'a>>) -> String {
         let item = item.into();

ctest-next/src/generator.rs

@@ -1,6 +1,7 @@
 use std::ops::Deref;
 
 use askama::Template;
+use proc_macro2::Span;
 use quote::ToTokens;
 use syn::spanned::Spanned;
 
@@ -65,11 +66,7 @@ impl TestTemplate {
         ffi_items: &FfiItems,
         generator: &TestGenerator,
     ) -> Result<Self, TranslationError> {
-        let helper = TranslateHelper {
-            ffi_items,
-            generator,
-            translator: Translator::new(),
-        };
+        let helper = TranslateHelper::new(ffi_items, generator);
 
         let mut template = Self::default();
         template.populate_const_and_cstr_tests(&helper)?;
@@ -87,7 +84,7 @@ impl TestTemplate {
         &mut self,
         helper: &TranslateHelper,
     ) -> Result<(), TranslationError> {
-        for constant in helper.ffi_items.constants() {
+        for constant in helper.filtered_ffi_items.constants() {
             if let syn::Type::Ptr(ptr) = &constant.ty
                 && let syn::Type::Path(path) = &*ptr.elem
                 && path.path.segments.last().unwrap().ident == "c_char"
@@ -125,7 +122,7 @@ impl TestTemplate {
         &mut self,
         helper: &TranslateHelper,
     ) -> Result<(), TranslationError> {
-        for alias in helper.ffi_items.aliases() {
+        for alias in helper.filtered_ffi_items.aliases() {
             let item = TestSizeAlign {
                 test_name: size_align_test_ident(alias.ident()),
                 id: alias.ident().into(),
@@ -135,7 +132,7 @@ impl TestTemplate {
             self.size_align_tests.push(item.clone());
             self.test_idents.push(item.test_name);
         }
-        for struct_ in helper.ffi_items.structs() {
+        for struct_ in helper.filtered_ffi_items.structs() {
             let item = TestSizeAlign {
                 test_name: size_align_test_ident(struct_.ident()),
                 id: struct_.ident().into(),
@@ -145,7 +142,7 @@ impl TestTemplate {
             self.size_align_tests.push(item.clone());
             self.test_idents.push(item.test_name);
         }
-        for union_ in helper.ffi_items.unions() {
+        for union_ in helper.filtered_ffi_items.unions() {
             let item = TestSizeAlign {
                 test_name: size_align_test_ident(union_.ident()),
                 id: union_.ident().into(),
@@ -166,7 +163,7 @@ impl TestTemplate {
         &mut self,
         helper: &TranslateHelper,
     ) -> Result<(), TranslationError> {
-        for alias in helper.ffi_items.aliases() {
+        for alias in helper.filtered_ffi_items.aliases() {
             let should_skip_signededness_test = helper
                 .generator
                 .skip_signededness
@@ -200,7 +197,7 @@ impl TestTemplate {
         let should_skip = |map_input| helper.generator.skips.iter().any(|f| f(&map_input));
 
         let struct_fields = helper
-            .ffi_items
+            .filtered_ffi_items
             .structs()
             .iter()
             .flat_map(|struct_| struct_.fields.iter().map(move |field| (struct_, field)))
@@ -216,7 +213,7 @@ impl TestTemplate {
                 )
             });
         let union_fields = helper
-            .ffi_items
+            .filtered_ffi_items
             .unions()
             .iter()
             .flat_map(|union_| union_.fields.iter().map(move |field| (union_, field)))
@@ -254,15 +251,15 @@ impl TestTemplate {
         &mut self,
         helper: &TranslateHelper,
     ) -> Result<(), TranslationError> {
-        for alias in helper.ffi_items.aliases() {
+        for alias in helper.filtered_ffi_items.aliases() {
             let c_ty = helper.c_type(alias)?;
             self.add_roundtrip_test(helper, alias.ident(), &[], &c_ty, true);
         }
-        for struct_ in helper.ffi_items.structs() {
+        for struct_ in helper.filtered_ffi_items.structs() {
             let c_ty = helper.c_type(struct_)?;
             self.add_roundtrip_test(helper, struct_.ident(), &struct_.fields, &c_ty, false);
         }
-        for union_ in helper.ffi_items.unions() {
+        for union_ in helper.filtered_ffi_items.unions() {
             let c_ty = helper.c_type(union_)?;
             self.add_roundtrip_test(helper, union_.ident(), &union_.fields, &c_ty, false);
         }
@@ -306,14 +303,14 @@ impl TestTemplate {
         let should_skip = |map_input| helper.generator.skips.iter().any(|f| f(&map_input));
 
         let struct_fields = helper
-            .ffi_items
+            .filtered_ffi_items
             .structs()
             .iter()
             .flat_map(|s| s.fields.iter().map(move |f| (s, f)))
             .filter(|(s, f)| {
-                !should_skip(MapInput::StructField(s, f))
-                    && !should_skip(MapInput::StructFieldType(s, f))
-                    && f.public
+                !(should_skip(MapInput::StructField(s, f))
+                    || should_skip(MapInput::StructFieldType(s, f))
+                    || !f.public)
             })
             .map(|(s, f)| {
                 (
@@ -335,14 +332,14 @@ impl TestTemplate {
                 )
             });
         let union_fields = helper
-            .ffi_items
+            .filtered_ffi_items
             .unions()
             .iter()
             .flat_map(|u| u.fields.iter().map(move |f| (u, f)))
             .filter(|(u, f)| {
-                !should_skip(MapInput::UnionField(u, f))
-                    && !should_skip(MapInput::UnionFieldType(u, f))
-                    && f.public
+                !(should_skip(MapInput::UnionField(u, f))
+                    || should_skip(MapInput::UnionFieldType(u, f))
+                    || !f.public)
             })
             .map(|(u, f)| {
                 (
@@ -483,20 +480,61 @@ fn roundtrip_test_ident(ident: &str) -> BoxStr {
 
 /// Wrap methods that depend on both ffi items and the generator.
 pub(crate) struct TranslateHelper<'a> {
+    filtered_ffi_items: FfiItems,
     ffi_items: &'a FfiItems,
     generator: &'a TestGenerator,
     translator: Translator,
 }
 
 impl<'a> TranslateHelper<'a> {
     /// Create a new translation helper.
-    #[cfg_attr(not(test), expect(unused))]
     pub(crate) fn new(ffi_items: &'a FfiItems, generator: &'a TestGenerator) -> Self {
-        Self {
+        let filtered_ffi_items = ffi_items.clone();
+        let mut helper = Self {
+            filtered_ffi_items,
             ffi_items,
             generator,
             translator: Translator::new(),
+        };
+        helper.filter_ffi_items();
+
+        helper
+    }
+
+    /// Skips entire items such as structs, constants, and aliases from being tested.
+    ///
+    /// Does not skip specific tests or specific fields. If `skip_private` is true,
+    /// it will skip tests for all private items.
+    fn filter_ffi_items(&mut self) {
+        let verbose = self.generator.verbose_skip;
+
+        macro_rules! filter {
+            ($field:ident, $variant:ident, $label:literal) => {{
+                let skipped: Vec<_> = self
+                    .filtered_ffi_items
+                    .$field
+                    .extract_if(.., |item| {
+                        self.generator
+                            .skips
+                            .iter()
+                            .any(|f| f(&MapInput::$variant(item)))
+                            || (self.generator.skip_private && !item.public)
+                    })
+                    .collect();
+                if verbose {
+                    skipped
+                        .iter()
+                        .for_each(|item| eprintln!("Skipping {} \"{}\"", $label, item.ident()));
+                }
+            }};
         }
+
+        filter!(aliases, Alias, "alias");
+        filter!(constants, Const, "const");
+        filter!(structs, Struct, "struct");
+        filter!(unions, Union, "union");
+        filter!(foreign_functions, Fn, "fn");
+        filter!(foreign_statics, Static, "static");
     }
 
     /// Returns the equivalent C/Cpp identifier of the Rust item.
@@ -517,7 +555,14 @@ impl<'a> TranslateHelper<'a> {
             // inside of `Fn` when parsed.
             MapInput::Fn(_) => unimplemented!(),
             // For structs/unions/aliases, their type is the same as their identifier.
-            MapInput::Alias(a) => (a.ident(), a.ident().to_string()),
+            // FIXME(ctest): For some specific primitives such as c_uint, they don't exist on the
+            // C side and have to be manually translated. If they are removed to use `std::ffi`,
+            // then this becomes unneeded (although it won't break).
+            MapInput::Alias(a) => (
+                a.ident(),
+                self.translator
+                    .translate_primitive_type(&syn::Ident::new(a.ident(), Span::call_site())),
+            ),
             MapInput::Struct(s) => (s.ident(), s.ident().to_string()),
             MapInput::Union(u) => (u.ident(), u.ident().to_string()),
 
@@ -528,7 +573,7 @@ impl<'a> TranslateHelper<'a> {
             MapInput::Type(_) => panic!("MapInput::Type is not allowed!"),
         };
 
-        let item = if self.ffi_items.contains_struct(ident) {
+        let item = if self.ffi_items.contains_struct(&ty) {
             MapInput::StructType(&ty)
         } else if self.ffi_items.contains_union(ident) {
             MapInput::UnionType(&ty)
@@ -546,21 +591,30 @@ impl<'a> TranslateHelper<'a> {
     fn basic_c_type(&self, ty: &syn::Type) -> Result<String, TranslationError> {
         let type_name = match ty {
             syn::Type::Path(p) => p.path.segments.last().unwrap().ident.to_string(),
-            syn::Type::Ptr(p) => self.basic_c_type(&p.elem)?,
-            syn::Type::Reference(r) => self.basic_c_type(&r.elem)?,
+            // Using recursion here causes breakage.
+            // FIXME(ctest): Might be possible to extract this part into a function.
+            syn::Type::Ptr(p) => match p.elem.deref() {
+                syn::Type::Path(p) => p.path.segments.last().unwrap().ident.to_string(),
+                _ => p.to_token_stream().to_string(),
+            },
+            syn::Type::Reference(r) => match r.elem.deref() {
+                syn::Type::Path(p) => p.path.segments.last().unwrap().ident.to_string(),
+                _ => r.to_token_stream().to_string(),
+            },
             _ => ty.to_token_stream().to_string(),
         };
 
         let unmapped_c_type = self.translator.translate_type(ty)?;
         let item = if self.ffi_items.contains_struct(&type_name) {
-            MapInput::StructType(&unmapped_c_type)
+            MapInput::StructType(&type_name)
         } else if self.ffi_items.contains_union(&type_name) {
-            MapInput::UnionType(&unmapped_c_type)
+            MapInput::UnionType(&type_name)
         } else {
-            MapInput::Type(&unmapped_c_type)
+            MapInput::Type(&type_name)
         };
 
-        Ok(self.generator.rty_to_cty(item))
+        let mapped_type = self.generator.rty_to_cty(item.clone());
+        Ok(unmapped_c_type.replace(&type_name, &mapped_type))
     }
 
     /// Partially translate a Rust bare function type into its equivalent C type.

ctest-next/src/template.rs

@@ -228,7 +228,7 @@ impl Translator {
     }
 
     /// Translate a Rust primitive type into its C equivalent.
-    fn translate_primitive_type(&self, ty: &syn::Ident) -> String {
+    pub(crate) fn translate_primitive_type(&self, ty: &syn::Ident) -> String {
         match ty.to_string().as_str() {
             "usize" => "size_t".to_string(),
             "isize" => "ssize_t".to_string(),
@@ -347,6 +347,16 @@ impl Translator {
 /// This function will just pass the expression as is in most cases.
 pub(crate) fn translate_expr(expr: &syn::Expr) -> String {
     match expr {
+        // This is done to deal with things like 3usize.
+        syn::Expr::Index(i) => {
+            let base = translate_expr(&i.expr);
+            let index = translate_expr(&i.index);
+            format!("{base}[{index}]")
+        }
+        syn::Expr::Lit(l) => match &l.lit {
+            syn::Lit::Int(i) => i.base10_digits().to_string(),
+            _ => l.to_token_stream().to_string(),
+        },
         syn::Expr::Path(p) => p.path.segments.last().unwrap().ident.to_string(),
         syn::Expr::Cast(c) => translate_expr(c.expr.deref()),
         expr => expr.to_token_stream().to_string(),