ctest: test ctest-next in ctest-test

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",/' Cargo.toml
+              perl -i -ne 'print unless /"ctest-(next|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",/' Cargo.toml
+      run: perl -i -ne 'print unless /"ctest-(next|test)",/' Cargo.toml
     - uses: Swatinem/rust-cache@v2
     - run: cargo build -p ctest
 

Cargo.lock

@@ -9,6 +9,7 @@ pub struct Fn {
     #[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)]
@@ -20,4 +21,9 @@ impl Fn {
     pub fn ident(&self) -> &str {
         &self.ident
     }
+
+    /// Return the name of the function to be linked C side with.
+    pub fn link_name(&self) -> Option<&str> {
+        self.link_name.as_deref()
+    }
 }

ctest-next/src/ast/function.rs

@@ -10,6 +10,7 @@ pub struct Static {
     #[expect(unused)]
     pub(crate) abi: Abi,
     pub(crate) ident: BoxStr,
+    pub(crate) link_name: Option<BoxStr>,
     pub(crate) ty: syn::Type,
 }
 
@@ -18,4 +19,9 @@ impl Static {
     pub fn ident(&self) -> &str {
         &self.ident
     }
+
+    /// Return the name of the function to be linked C side with.
+    pub fn link_name(&self) -> Option<&str> {
+        self.link_name.as_deref()
+    }
 }

ctest-next/src/ast/static_variable.rs

@@ -3,7 +3,7 @@ use std::ops::Deref;
 use syn::punctuated::Punctuated;
 use syn::visit::Visit;
 
-use crate::{Abi, Const, Field, Fn, Parameter, Static, Struct, Type, Union};
+use crate::{Abi, BoxStr, Const, Field, Fn, Parameter, Static, Struct, Type, Union};
 
 /// Represents a collected set of top-level Rust items relevant to FFI generation or analysis.
 ///
@@ -94,6 +94,30 @@ fn collect_fields(fields: &Punctuated<syn::Field, syn::Token![,]>) -> Vec<Field>
         .collect()
 }
 
+fn extract_single_link_name(attrs: &[syn::Attribute]) -> Option<BoxStr> {
+    let mut link_name_iter = attrs
+        .iter()
+        .filter(|attr| attr.path().is_ident("link_name"));
+
+    let link_name = link_name_iter.next().and_then(|attr| match &attr.meta {
+        syn::Meta::NameValue(nv) => {
+            if let syn::Expr::Lit(expr_lit) = &nv.value {
+                if let syn::Lit::Str(lit_str) = &expr_lit.lit {
+                    return Some(lit_str.value().into_boxed_str());
+                }
+            }
+            None
+        }
+        _ => None,
+    });
+
+    if let Some(attr) = link_name_iter.next() {
+        panic!("multiple `#[link_name = ...]` attributes found: {attr:?}");
+    }
+
+    link_name
+}
+
 fn visit_foreign_item_fn(table: &mut FfiItems, i: &syn::ForeignItemFn, abi: &Abi) {
     let public = is_visible(&i.vis);
     let abi = abi.clone();
@@ -121,11 +145,13 @@ fn visit_foreign_item_fn(table: &mut FfiItems, i: &syn::ForeignItemFn, abi: &Abi
         syn::ReturnType::Default => None,
         syn::ReturnType::Type(_, ty) => Some(ty.deref().clone()),
     };
+    let link_name = extract_single_link_name(&i.attrs);
 
     table.foreign_functions.push(Fn {
         public,
         abi,
         ident,
+        link_name,
         parameters,
         return_type,
     });
@@ -136,11 +162,13 @@ fn visit_foreign_item_static(table: &mut FfiItems, i: &syn::ForeignItemStatic, a
     let abi = abi.clone();
     let ident = i.ident.to_string().into_boxed_str();
     let ty = i.ty.deref().clone();
+    let link_name = extract_single_link_name(&i.attrs);
 
     table.foreign_statics.push(Static {
         public,
         abi,
         ident,
+        link_name,
         ty,
     });
 }

ctest-next/src/ffi_items.rs

@@ -9,9 +9,10 @@
 mod generated_tests {
     #![allow(non_snake_case)]
     #![deny(improper_ctypes_definitions)]
-    use std::ffi::CStr;
+    use std::ffi::{CStr, c_char};
     use std::fmt::{Debug, LowerHex};
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+    #[expect(unused_imports)]
     use std::{mem, ptr, slice};
 
     use super::*;
@@ -62,7 +63,7 @@ mod generated_tests {
 
         // SAFETY: FFI call returns a valid C string.
         let c_val = unsafe {
-            let c_ptr: *const c_char = unsafe { ctest_const_cstr__{{ const_cstr.id }}()  };
+            let c_ptr: *const c_char = ctest_const_cstr__{{ const_cstr.id }}();
             CStr::from_ptr(c_ptr)
         };
 
@@ -89,7 +90,7 @@ mod generated_tests {
         };
 
         let c_bytes = unsafe {
-            let c_ptr: *const T = unsafe { ctest_const__{{ constant.id }}() };
+            let c_ptr: *const T = ctest_const__{{ constant.id }}();
             slice::from_raw_parts(c_ptr.cast::<u8>(), size_of::<T>())
         };
 

ctest-next/templates/test.rs

@@ -6,9 +6,10 @@
 mod generated_tests {
     #![allow(non_snake_case)]
     #![deny(improper_ctypes_definitions)]
-    use std::ffi::CStr;
+    use std::ffi::{CStr, c_char};
     use std::fmt::{Debug, LowerHex};
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+    #[expect(unused_imports)]
     use std::{mem, ptr, slice};
 
     use super::*;
@@ -58,7 +59,7 @@ mod generated_tests {
         };
 
         let c_bytes = unsafe {
-            let c_ptr: *const T = unsafe { ctest_const__ON() };
+            let c_ptr: *const T = ctest_const__ON();
             slice::from_raw_parts(c_ptr.cast::<u8>(), size_of::<T>())
         };
 

ctest-next/tests/input/hierarchy.out.rs

@@ -6,9 +6,10 @@
 mod generated_tests {
     #![allow(non_snake_case)]
     #![deny(improper_ctypes_definitions)]
-    use std::ffi::CStr;
+    use std::ffi::{CStr, c_char};
     use std::fmt::{Debug, LowerHex};
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+    #[expect(unused_imports)]
     use std::{mem, ptr, slice};
 
     use super::*;

ctest-next/tests/input/macro.out.rs

@@ -6,9 +6,10 @@
 mod generated_tests {
     #![allow(non_snake_case)]
     #![deny(improper_ctypes_definitions)]
-    use std::ffi::CStr;
+    use std::ffi::{CStr, c_char};
     use std::fmt::{Debug, LowerHex};
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+    #[expect(unused_imports)]
     use std::{mem, ptr, slice};
 
     use super::*;
@@ -57,7 +58,7 @@ mod generated_tests {
 
         // SAFETY: FFI call returns a valid C string.
         let c_val = unsafe {
-            let c_ptr: *const c_char = unsafe { ctest_const_cstr__A()  };
+            let c_ptr: *const c_char = ctest_const_cstr__A();
             CStr::from_ptr(c_ptr)
         };
 
@@ -80,7 +81,7 @@ mod generated_tests {
 
         // SAFETY: FFI call returns a valid C string.
         let c_val = unsafe {
-            let c_ptr: *const c_char = unsafe { ctest_const_cstr__B()  };
+            let c_ptr: *const c_char = ctest_const_cstr__B();
             CStr::from_ptr(c_ptr)
         };
 

ctest-next/tests/input/simple.out.with-renames.rs

@@ -6,9 +6,10 @@
 mod generated_tests {
     #![allow(non_snake_case)]
     #![deny(improper_ctypes_definitions)]
-    use std::ffi::CStr;
+    use std::ffi::{CStr, c_char};
     use std::fmt::{Debug, LowerHex};
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+    #[expect(unused_imports)]
     use std::{mem, ptr, slice};
 
     use super::*;
@@ -57,7 +58,7 @@ mod generated_tests {
 
         // SAFETY: FFI call returns a valid C string.
         let c_val = unsafe {
-            let c_ptr: *const c_char = unsafe { ctest_const_cstr__A()  };
+            let c_ptr: *const c_char = ctest_const_cstr__A();
             CStr::from_ptr(c_ptr)
         };