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/template.rs

@@ -2,10 +2,9 @@ use std::ops::Deref;
 
 use askama::Template;
 use quote::ToTokens;
-use syn::spanned::Spanned;
 
 use crate::ffi_items::FfiItems;
-use crate::translator::{TranslationErrorKind, Translator, translate_abi, translate_expr};
+use crate::translator::{Translator, extract_ffi_safe_option, translate_abi, translate_expr};
 use crate::{BoxStr, Field, MapInput, Result, TestGenerator, TranslationError, VolatileItemKind};
 
 /// Represents the Rust side of the generated testing suite.
@@ -49,6 +48,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 signededness_tests: Vec<TestSignededness>,
@@ -76,6 +76,7 @@ impl TestTemplate {
         template.populate_signededness_tests(&helper)?;
         template.populate_field_size_offset_tests(&helper)?;
         template.populate_field_ptr_tests(&helper)?;
+        template.populate_foreign_static_tests(&helper)?;
 
         Ok(template)
     }
@@ -325,6 +326,48 @@ 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 item = TestForeignStatic {
+                test_name: static_test_ident(static_.ident()),
+                id: static_.ident().into(),
+                c_val: helper.c_ident(static_).into_boxed_str(),
+                rust_ty: static_.ty.to_token_stream().to_string().into_boxed_str(),
+                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: helper
+                    .make_cdecl(
+                        &format!("ctest_static_ty__{}", static_.ident()),
+                        &static_.ty,
+                    )?
+                    .replacen("**ctest_", "*ctest_", 1)
+                    .into(),
+            };
+
+            self.foreign_static_tests.push(item.clone());
+            self.test_idents.push(item.test_name);
+        }
+
+        Ok(())
+    }
 }
 
 /* Many test structures have the following fields:
@@ -393,6 +436,18 @@ pub(crate) struct TestFieldSizeOffset {
     pub c_ty: BoxStr,
 }
 
+#[derive(Clone, Debug)]
+pub(crate) struct TestForeignStatic {
+    pub test_name: BoxStr,
+    pub id: BoxStr,
+    pub c_val: BoxStr,
+    pub rust_ty: BoxStr,
+    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()
 }
@@ -417,6 +472,10 @@ fn field_size_offset_test_ident(ident: &str, field_ident: &str) -> BoxStr {
     format!("ctest_field_size_offset_{ident}_{field_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,
@@ -536,26 +595,11 @@ impl<'a> TranslateHelper<'a> {
             syn::Type::Path(p) => {
                 let last = p.path.segments.last().unwrap();
                 let ident = last.ident.to_string();
-                if ident != "Option" {
+                if ident == "Option" {
+                    self.make_cdecl(name, &extract_ffi_safe_option(p)?)
+                } else {
                     let mapped_type = self.basic_c_type(ty)?;
-                    return Ok(format!("{mapped_type}* {name}"));
-                }
-                if let syn::PathArguments::AngleBracketed(args) = &last.arguments {
-                    if let syn::GenericArgument::Type(inner_ty) = args.args.first().unwrap() {
-                        // Option<T> is ONLY ffi-safe if it contains a function pointer, or a reference.
-                        match inner_ty {
-                            syn::Type::Reference(_) | syn::Type::BareFn(_) => {
-                                return self.make_cdecl(name, inner_ty);
-                            }
-                            _ => {
-                                return Err(TranslationError::new(
-                                    TranslationErrorKind::NotFfiCompatible,
-                                    &p.to_token_stream().to_string(),
-                                    inner_ty.span(),
-                                ));
-                            }
-                        }
-                    }
+                    Ok(format!("{mapped_type}* {name}"))
                 }
             }
             syn::Type::BareFn(f) => {
@@ -579,29 +623,28 @@ impl<'a> TranslateHelper<'a> {
                     args.push("void".to_string());
                 }
 
-                return Ok(format!("{} ({}**{})({})", ret, abi, name, args.join(", ")));
+                Ok(format!("{} ({}**{})({})", ret, abi, name, args.join(", ")))
             }
-            // Arrays are supported only up to 2D arrays.
-            syn::Type::Array(outer) => {
-                let elem = outer.elem.deref();
-                let len_outer = translate_expr(&outer.len);
-
-                if let syn::Type::Array(inner) = elem {
-                    let inner_type = self.basic_c_type(inner.elem.deref())?;
-                    let len_inner = translate_expr(&inner.len);
-                    return Ok(format!("{inner_type} (*{name})[{len_outer}][{len_inner}]",));
-                } else {
-                    let elem_type = self.basic_c_type(elem)?;
-                    return Ok(format!("{elem_type} (*{name})[{len_outer}]"));
+            syn::Type::Array(_) => {
+                let mut lens = Vec::new();
+                let mut elem = ty;
+
+                while let syn::Type::Array(array) = elem {
+                    lens.push(translate_expr(&array.len));
+                    elem = array.elem.deref();
                 }
+
+                let elem_type = self.basic_c_type(elem)?;
+                let dims = lens
+                    .into_iter()
+                    .map(|len| format!("[{len}]"))
+                    .collect::<String>();
+                Ok(format!("{elem_type} (*{name}){dims}"))
             }
             _ => {
                 let elem_type = self.basic_c_type(ty)?;
-                return Ok(format!("{elem_type} *{name}"));
+                Ok(format!("{elem_type} *{name}"))
             }
         }
-
-        let mapped_type = self.basic_c_type(ty)?;
-        Ok(format!("{mapped_type}* {name}"))
     }
 }

ctest-next/src/tests.rs

@@ -111,7 +111,7 @@ fn test_translation_type_bare_fn() {
 fn test_translation_type_array() {
     assert_eq!(
         ty("[&u8; 2 + 2]").unwrap(),
-        "const uint8_t*[2 + 2]".to_string()
+        "const uint8_t* [2 + 2]".to_string()
     );
 }
 
@@ -129,7 +129,7 @@ fn test_translate_helper_function_pointer() {
     );
     assert_eq!(
         cdecl("Option<extern \"stdcall\" fn(*const c_char, [u32; 16]) -> u8>").unwrap(),
-        "uint8_t (__stdcall **test_make_cdecl)(char const*, uint32_t[16])"
+        "uint8_t (__stdcall **test_make_cdecl)(char const*, uint32_t [16])"
     );
 }
 

ctest-next/src/translator.rs

@@ -264,13 +264,17 @@ impl Translator {
     /// Translate a Rust path into its C equivalent.
     fn translate_path(&self, path: &syn::TypePath) -> Result<String, TranslationError> {
         let last = path.path.segments.last().unwrap();
-        Ok(self.translate_primitive_type(&last.ident))
+        if last.ident == "Option" {
+            self.translate_type(&extract_ffi_safe_option(path)?)
+        } else {
+            Ok(self.translate_primitive_type(&last.ident))
+        }
     }
 
     /// Translate a Rust array declaration into its C equivalent.
     fn translate_array(&self, array: &syn::TypeArray) -> Result<String, TranslationError> {
         Ok(format!(
-            "{}[{}]",
+            "{} [{}]",
             self.translate_type(array.elem.deref())?,
             translate_expr(&array.len)
         ))
@@ -373,3 +377,34 @@ pub(crate) fn translate_abi(abi: &syn::Abi, target: &str) -> &'static str {
         Some(a) => panic!("unknown ABI: {a}"),
     }
 }
+
+pub(crate) fn extract_ffi_safe_option(p: &syn::TypePath) -> Result<syn::Type, TranslationError> {
+    let last = p.path.segments.last().unwrap();
+    let ident = last.ident.to_string();
+
+    if ident != "Option" {
+        return Err(TranslationError::new(
+            TranslationErrorKind::NotFfiCompatible,
+            &p.to_token_stream().to_string(),
+            p.span(),
+        ));
+    }
+
+    if let syn::PathArguments::AngleBracketed(args) = &last.arguments {
+        if let syn::GenericArgument::Type(inner_ty) = args.args.first().unwrap() {
+            // Option<T> is ONLY ffi-safe if it contains a function pointer, or a reference.
+            match inner_ty {
+                syn::Type::Reference(_) | syn::Type::BareFn(_) => {
+                    return Ok(inner_ty.clone());
+                }
+                _ => (),
+            }
+        }
+    }
+
+    Err(TranslationError::new(
+        TranslationErrorKind::NotFfiCompatible,
+        &p.to_token_stream().to_string(),
+        p.span(),
+    ))
+}

ctest-next/templates/test.c

@@ -78,3 +78,19 @@ ctest_field_ptr__{{ item.id }}__{{ item.field.ident() }}({{ item.c_ty }} *b) {
     return &b->{{ item.c_field }};
 }
 {%- endfor +%}
+
+{%- 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

@@ -9,7 +9,8 @@
 mod generated_tests {
     #![allow(non_snake_case)]
     #![deny(improper_ctypes_definitions)]
-    use std::ffi::{CStr, c_char};
+    #[allow(unused_imports)]
+    use std::ffi::{CStr, c_char, c_uint};
     use std::fmt::{Debug, LowerHex};
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
     #[allow(unused_imports)]
@@ -190,6 +191,37 @@ mod generated_tests {
             "field type {{ item.field.ident() }} of {{ item.id }}");
     }
 {%- 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_.rust_ty.contains("extern") +%}
+        extern "C" {
+            fn ctest_static__{{ static_.id }}() -> {{ static_.rust_ty }};
+        }
+        unsafe {
+            // We must use addr_of! here because of https://github.com/rust-lang/rust/issues/114447
+            let actual = std::mem::transmute_copy::<_, usize>(&*std::ptr::addr_of!({{ static_.id }}));
+            let expected = {
+                let val = ctest_static__{{ static_.id }}();
+                std::mem::transmute_copy::<_, usize>(&val)
+            };
+            check_same(actual, expected, "{{ static_.id }} static");
+        }
+    {%- else +%}
+        extern "C" {
+            fn ctest_static__{{ static_.id }}() -> *{{ static_.mutable }} {{ static_.rust_ty }};
+        }
+        unsafe {
+            // We must use addr_of! here because of https://github.com/rust-lang/rust/issues/114447
+            check_same(std::ptr::addr_of!({{ static_.id }}) as usize,
+                    ctest_static__{{ static_.id }}() as usize,
+                    "{{ static_.id }} static");
+        }
+    {%- endif +%}
+    }
+{%- endfor +%}
 }
 
 use generated_tests::*;

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

@@ -27,3 +27,9 @@ uint32_t ctest_signededness_of__in6_addr(void) {
     in6_addr all_ones = (in6_addr) -1;
     return all_ones < 0;
 }
+
+// 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;
+}