Anchor regex and make test more comprehensive

Blocklist specific bitfields etc instead of whole types, and document
why each one is blocklisted. Also support field renames for mangling
(e.g. `type`).

Author: ian-h-chamberlain

ctru-sys/build.rs

@@ -162,27 +162,13 @@ fn main() {
 
     #[cfg(feature = "layout-tests")]
     {
-        let test_file = out_dir.join("generated_layout_test.rs");
-        test_generator
-            // There are several bindgen-generated types that we don't want/need to check
-            // (because they are opaque, use bitfields, anonymous structs etc.)
-            .blocklist_type("Thread_tag")
-            .blocklist_type("MiiData.*")
-            .blocklist_type("ExHeader_(System|Arm11).*")
-            .blocklist_type("FS_((Ext|System)SaveData|Program)Info")
-            .blocklist_type("Y2RU_ConversionParams")
-            .blocklist_field("romfs_(dir|file)", "name")
-            // Bindgen generated types have no c++ equivalent:
-            .blocklist_type(".*__bindgen.*")
-            .blocklist_field(".*", "__bindgen.*")
-            // TODO: maybe we could translate type <-> `type_` or something...
-            .blocklist_field(".*", "type_")
-            .generate_layout_tests(&test_file)
+        let gen_test_file = out_dir.join("generated_layout_test.rs");
+        generate_layout_tests(&gen_test_file, &test_generator)
             .unwrap_or_else(|err| panic!("Failed to generate layout tests: {err}"));
 
         cpp_build::Config::from(cc_build)
-            .compiler(&cpp)
-            .build(test_file);
+            .compiler(cpp)
+            .build(gen_test_file);
     }
 }
 
@@ -285,3 +271,43 @@ fn track_libctru_files(pacman: &Path) -> Result<(), String> {
 
     Ok(())
 }
+
+#[cfg(feature = "layout-tests")]
+fn generate_layout_tests(
+    output_file: &Path,
+    test_generator: &build::test_gen::LayoutTestGenerator,
+) -> Result<(), Box<dyn Error>> {
+    // There are several bindgen-generated types/fields that we can't check:
+    test_generator
+            // Opaque types:
+            .blocklist_type("MiiData")
+            // Bitfields:
+            .blocklist_field(
+                "ExHeader_SystemInfoFlags",
+                "compress_exefs_code|is_sd_application",
+            )
+            .blocklist_field(
+                "ExHeader_Arm11StorageInfo",
+                "reserved|no_romfs|use_extended_savedata_access",
+            )
+            .blocklist_field(
+                "ExHeader_Arm11CoreInfo",
+                "use_cpu_clockrate_804MHz|enable_l2c|flag[12]_unused|[no]3ds_system_mode|ideal_processor|affinity_mask",
+            )
+            .blocklist_field(
+                "Y2RU_ConversionParams",
+                "(input|output)_format|rotation|block_alignment|standard_coefficient",
+            )
+            .blocklist_field(
+                "FS_(Program|(System|Ext)SaveData)Info",
+                "mediaType"
+            )
+            // Variable-length arrays:
+            .blocklist_field("romfs_(dir|file)", "name")
+            // Bindgen anonymous types (and their associated fields):
+            .blocklist_type(".*__bindgen.*")
+            .blocklist_field(".*", "__bindgen.*")
+            // Bindgen mangles `type` (a Rust keyword) to `type_`:
+            .rename_field("type", "type_")
+            .generate_layout_tests(output_file)
+}

ctru-sys/build/test_gen.rs

@@ -71,34 +71,44 @@ impl ParseCallbacks for LayoutTestCallbacks {
 
 #[derive(Debug)]
 pub struct LayoutTestGenerator {
-    struct_fields: RefCell<BTreeMap<String, BTreeSet<String>>>,
     blocklist: RefCell<Vec<(Regex, Option<Regex>)>>,
     headers: RefCell<Vec<String>>,
+    renames: RefCell<BTreeMap<String, String>>,
+    struct_fields: RefCell<BTreeMap<String, BTreeSet<String>>>,
 }
 
 impl LayoutTestGenerator {
     fn new() -> Self {
         Self {
-            struct_fields: RefCell::default(),
             blocklist: RefCell::default(),
             headers: RefCell::default(),
+            renames: RefCell::default(),
+            struct_fields: RefCell::default(),
         }
     }
 
     pub fn blocklist_type(&self, pattern: &str) -> &Self {
         self.blocklist
             .borrow_mut()
-            .push((Regex::new(pattern).unwrap(), None));
+            .push((Regex::new(&format!("^({pattern})$")).unwrap(), None));
         self
     }
 
     pub fn blocklist_field(&self, struct_pattern: &str, field_pattern: &str) -> &Self {
         self.blocklist.borrow_mut().push((
-            Regex::new(struct_pattern).unwrap(),
-            Some(Regex::new(field_pattern).unwrap()),
+            Regex::new(&format!("^({struct_pattern})$")).unwrap(),
+            Some(Regex::new(&format!("^({field_pattern})$")).unwrap()),
         ));
         self
     }
+
+    pub fn rename_field(&self, cpp_name: &str, rust_name: &str) -> &Self {
+        self.renames
+            .borrow_mut()
+            .insert(rust_name.to_string(), cpp_name.to_string());
+        self
+    }
+
     pub fn generate_layout_tests(
         &self,
         output_path: impl AsRef<Path>,
@@ -172,21 +182,23 @@ impl LayoutTestGenerator {
                     continue;
                 }
 
-                let field = format_ident!("{field}");
+                let rust_field = format_ident!("{field}");
+                let cpp_field =
+                    format_ident!("{}", self.renames.borrow().get(field).unwrap_or(field));
 
                 field_tests.push(build_assert_eq(
-                    &quote!(size_of!(#name::#field)),
-                    &quote!(sizeof(#name::#field)),
+                    &quote!(size_of!(#name::#rust_field)),
+                    &quote!(sizeof(#name::#cpp_field)),
                 ));
 
                 field_tests.push(build_assert_eq(
-                    &quote!(align_of!(#name::#field)),
-                    &quote!(alignof(#name::#field)),
+                    &quote!(align_of!(#name::#rust_field)),
+                    &quote!(alignof(#name::#cpp_field)),
                 ));
 
                 field_tests.push(build_assert_eq(
-                    &quote!(offset_of!(#name, #field)),
-                    &quote!(offsetof(#name, #field)),
+                    &quote!(offset_of!(#name, #rust_field)),
+                    &quote!(offsetof(#name, #cpp_field)),
                 ));
             }
         }

ctru-sys/tests/layout_test.rs

@@ -13,9 +13,6 @@ extern crate shim_3ds;
 
 use std::mem::offset_of;
 
-use cpp::cpp;
-use ctru_sys::*;
-
 fn size_of_ret<T, U>(_f: impl Fn(U) -> T) -> usize {
     ::std::mem::size_of::<T>()
 }
@@ -53,13 +50,16 @@ macro_rules! align_of {
 
 #[allow(non_snake_case)]
 #[allow(non_upper_case_globals)]
-mod generated {
+mod generated_tests {
     use super::*;
 
+    use cpp::cpp;
+    use ctru_sys::*;
+
     include!(concat!(env!("OUT_DIR"), "/generated_layout_test.rs"));
 }
 
-mod helper_test {
+mod helper_tests {
     macro_rules! packed_struct {
         ($name:ident, $size:literal) => {
             #[repr(C, packed($size))]