ctest: add foreign static test

Author: mbyx

ctest-next/src/ast/static_variable.rs

@@ -12,6 +12,7 @@ pub struct Static {
     pub(crate) ident: BoxStr,
     pub(crate) link_name: Option<BoxStr>,
     pub(crate) ty: syn::Type,
+    pub(crate) mutable: bool,
 }
 
 impl Static {

ctest-next/src/ffi_items.rs

@@ -63,7 +63,6 @@ impl FfiItems {
     }
 
     /// Return a list of all foreign statics found mapped by their ABI.
-    #[cfg_attr(not(test), expect(unused))]
     pub(crate) fn foreign_statics(&self) -> &Vec<Static> {
         &self.foreign_statics
     }
@@ -159,13 +158,15 @@ fn visit_foreign_item_static(table: &mut FfiItems, i: &syn::ForeignItemStatic, a
     let ident = i.ident.to_string().into_boxed_str();
     let ty = i.ty.deref().clone();
     let link_name = extract_single_link_name(&i.attrs);
+    let mutable = matches!(i.mutability, syn::StaticMutability::Mut(_));
 
     table.foreign_statics.push(Static {
         public,
         abi,
         ident,
         link_name,
         ty,
+        mutable,
     });
 }
 

ctest-next/src/lib.rs

@@ -24,6 +24,7 @@ pub use ast::{Abi, Const, Field, Fn, Parameter, Static, Struct, Type, Union};
 pub use generator::TestGenerator;
 pub use macro_expansion::expand;
 pub use runner::{__compile_test, __run_test, generate_test};
+use syn::visit::Visit;
 pub use translator::TranslationError;
 
 /// A possible error that can be encountered in our library.
@@ -107,3 +108,21 @@ impl<'a> From<&'a Union> for MapInput<'a> {
         MapInput::Union(u)
     }
 }
+
+/* A simple helper to find any nested bare fn types, such as `Option<unsafe extern "C" fn()>` */
+
+struct BareFnFinder {
+    found: bool,
+}
+
+impl<'ast> Visit<'ast> for BareFnFinder {
+    fn visit_type_bare_fn(&mut self, _: &'ast syn::TypeBareFn) {
+        self.found = true;
+    }
+}
+
+pub(crate) fn contains_bare_fn(ty: &syn::Type) -> bool {
+    let mut visitor = BareFnFinder { found: false };
+    visitor.visit_type(ty);
+    visitor.found
+}

ctest-next/src/template.rs

@@ -4,9 +4,10 @@ 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,
+    contains_bare_fn,
 };
 
 /// Represents the Rust side of the generated testing suite.
@@ -50,6 +51,7 @@ impl CTestTemplate {
 /// Stores all information necessary for generation of tests for all items.
 #[derive(Clone, Debug, Default)]
 pub(crate) struct TestTemplate {
+    pub foreign_static_tests: Vec<TestForeignStatic>,
     pub field_ptr_tests: Vec<TestFieldPtr>,
     pub field_size_offset_tests: Vec<TestFieldSizeOffset>,
     pub roundtrip_tests: Vec<TestRoundtrip>,
@@ -75,6 +77,7 @@ impl TestTemplate {
         template.populate_field_size_offset_tests(&helper)?;
         template.populate_field_ptr_tests(&helper)?;
         template.populate_roundtrip_tests(&helper)?;
+        template.populate_foreign_static_tests(&helper)?;
 
         Ok(template)
     }
@@ -380,6 +383,66 @@ impl TestTemplate {
 
         Ok(())
     }
+
+    /// Populates tests for foreign statics, keeping track of the names of each test.
+    fn populate_foreign_static_tests(
+        &mut self,
+        helper: &TranslateHelper,
+    ) -> Result<(), TranslationError> {
+        for static_ in helper.ffi_items.foreign_statics() {
+            let is_volatile = helper
+                .generator
+                .volatile_items
+                .iter()
+                .any(|is_volatile| is_volatile(VolatileItemKind::Static(static_.clone())));
+
+            let c_ty = helper.c_type(static_)?.into_boxed_str();
+            let rust_ty = static_.ty.to_token_stream().to_string().into_boxed_str();
+            let is_bare_fn = contains_bare_fn(&static_.ty);
+
+            let return_type = if is_bare_fn {
+                helper.translator.translate_type(&static_.ty)?
+            } else {
+                cdecl::ptr(
+                    helper.translator.translate_type(&static_.ty)?,
+                    cdecl::Constness::Mut,
+                )
+            };
+            let return_type = cdecl::cdecl(
+                &return_type,
+                format!("ctest_static_ty__{}", static_.ident()),
+            )
+            .map_err(|_| {
+                TranslationError::new(
+                    TranslationErrorKind::InvalidReturn,
+                    &static_.ty.to_token_stream().to_string(),
+                    static_.ty.span(),
+                )
+            })?;
+
+            let item = TestForeignStatic {
+                test_name: static_test_ident(static_.ident()),
+                id: static_.ident().into(),
+                c_val: helper.c_ident(static_).into_boxed_str(),
+                rust_ty,
+                is_bare_fn,
+                mutable: if static_.mutable { "mut" } else { "const" }.into(),
+                volatile_keyword: { if is_volatile { "volatile " } else { "" }.into() },
+                c_mutable: if c_ty.contains("const") || static_.mutable {
+                    ""
+                } else {
+                    "const "
+                }
+                .into(),
+                return_type: return_type.into(),
+            };
+
+            self.foreign_static_tests.push(item.clone());
+            self.test_idents.push(item.test_name);
+        }
+
+        Ok(())
+    }
 }
 
 /* Many test structures have the following fields:
@@ -457,6 +520,19 @@ pub(crate) struct TestRoundtrip {
     pub is_alias: bool,
 }
 
+#[derive(Clone, Debug)]
+pub(crate) struct TestForeignStatic {
+    pub test_name: BoxStr,
+    pub id: BoxStr,
+    pub c_val: BoxStr,
+    pub rust_ty: BoxStr,
+    pub is_bare_fn: bool,
+    pub mutable: BoxStr,
+    pub c_mutable: BoxStr,
+    pub return_type: BoxStr,
+    pub volatile_keyword: BoxStr,
+}
+
 fn signededness_test_ident(ident: &str) -> BoxStr {
     format!("ctest_signededness_{ident}").into()
 }
@@ -485,6 +561,10 @@ fn roundtrip_test_ident(ident: &str) -> BoxStr {
     format!("ctest_roundtrip_{ident}").into()
 }
 
+fn static_test_ident(ident: &str) -> BoxStr {
+    format!("ctest_static_{ident}").into()
+}
+
 /// Wrap methods that depend on both ffi items and the generator.
 pub(crate) struct TranslateHelper<'a> {
     ffi_items: &'a FfiItems,

ctest-next/templates/test.c

@@ -118,3 +118,19 @@ ctest_field_ptr__{{ item.id }}__{{ item.field.ident() }}({{ item.c_ty }} *b) {
 #ifdef _MSC_VER
 #  pragma warning(default:4365)
 #endif
+
+{%- for static_ in ctx.foreign_static_tests +%}
+
+// Return a pointer to the static variable content.
+{%- if static_.rust_ty.contains("extern") +%}
+typedef {{ static_.return_type }};
+ctest_static_ty__{{ static_.id }} ctest_static__{{ static_.id }}(void) {
+    return {{ static_.c_val }};
+}
+{%- else +%}
+typedef {{ static_.volatile_keyword }}{{ static_.c_mutable }}{{ static_.return_type }};
+ctest_static_ty__{{ static_.id }} ctest_static__{{ static_.id }}(void) {
+    return &{{ static_.c_val }};
+}
+{%- endif +%}
+{%- endfor +%}

ctest-next/templates/test.rs

@@ -10,7 +10,7 @@ mod generated_tests {
     #![allow(non_snake_case)]
     #![deny(improper_ctypes_definitions)]
     #[allow(unused_imports)]
-    use std::ffi::{CStr, c_int, c_char};
+    use std::ffi::{CStr, c_int, c_char, c_uint};
     use std::fmt::{Debug, LowerHex};
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
     #[allow(unused_imports)]
@@ -314,6 +314,34 @@ mod generated_tests {
         }
     }
 {%- endfor +%}
+
+{%- for static_ in ctx.foreign_static_tests +%}
+
+    // Tests if the pointer to the static variable matches in both Rust and C.
+    pub fn {{ static_.test_name }}() {
+    {%- if static_.is_bare_fn +%}
+        extern "C" {
+            fn ctest_static__{{ static_.id }}() -> {{ static_.rust_ty }};
+        }
+        let actual = unsafe {
+            std::mem::transmute::<_, *const ()>(*(&raw const {{ static_.id }})).addr()
+        };
+        let expected = unsafe {
+            std::mem::transmute::<_, *const ()>(ctest_static__{{ static_.id }}()).addr()
+        };
+        check_same(actual, expected, "{{ static_.id }} static");
+    {%- else +%}
+        extern "C" {
+            fn ctest_static__{{ static_.id }}() -> *{{ static_.mutable }} {{ static_.rust_ty }};
+        }
+        let actual = (&raw const {{ static_.id }}).addr();
+        let expected = unsafe {
+            ctest_static__{{ static_.id }}().addr()
+        };
+        check_same(actual, expected, "{{ static_.id }} static");
+    {%- endif +%}
+    }
+{%- endfor +%}
 }
 
 use generated_tests::*;

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

@@ -64,3 +64,9 @@ in6_addr ctest_roundtrip__in6_addr(
 #ifdef _MSC_VER
 #  pragma warning(default:4365)
 #endif
+
+// Return a pointer to the static variable content.
+typedef const in6_addr *ctest_static_ty__in6addr_any;
+ctest_static_ty__in6addr_any ctest_static__in6addr_any(void) {
+    return &in6addr_any;
+}

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

@@ -7,7 +7,7 @@ mod generated_tests {
     #![allow(non_snake_case)]
     #![deny(improper_ctypes_definitions)]
     #[allow(unused_imports)]
-    use std::ffi::{CStr, c_int, c_char};
+    use std::ffi::{CStr, c_int, c_char, c_uint};
     use std::fmt::{Debug, LowerHex};
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
     #[allow(unused_imports)]
@@ -213,6 +213,18 @@ mod generated_tests {
             }
         }
     }
+
+    // Tests if the pointer to the static variable matches in both Rust and C.
+    pub fn ctest_static_in6addr_any() {
+        extern "C" {
+            fn ctest_static__in6addr_any() -> *const in6_addr;
+        }
+        let actual = (&raw const in6addr_any).addr();
+        let expected = unsafe {
+            ctest_static__in6addr_any().addr()
+        };
+        check_same(actual, expected, "in6addr_any static");
+    }
 }
 
 use generated_tests::*;
@@ -236,4 +248,5 @@ fn run_all() {
     ctest_size_align_in6_addr();
     ctest_signededness_in6_addr();
     ctest_roundtrip_in6_addr();
+    ctest_static_in6addr_any();
 }

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

@@ -6,5 +6,5 @@ pub const ON: bool = true;
 unsafe extern "C" {
     fn malloc(size: usize) -> *mut c_void;
 
-    static in6addr_any: in6_addr;
+    pub static in6addr_any: in6_addr;
 }

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

@@ -7,7 +7,7 @@ mod generated_tests {
     #![allow(non_snake_case)]
     #![deny(improper_ctypes_definitions)]
     #[allow(unused_imports)]
-    use std::ffi::{CStr, c_int, c_char};
+    use std::ffi::{CStr, c_int, c_char, c_uint};
     use std::fmt::{Debug, LowerHex};
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
     #[allow(unused_imports)]