Add callback to override field visibility

bindgen-tests/tests/headers/field-visibility-callback.h

@@ -0,0 +1,9 @@
+// bindgen-flags: --default-visibility private
+// bindgen-parse-callbacks: field-visibility-default-private
+
+struct my_struct {
+    int a;
+    int private_b;
+    int c: 1;
+    int private_d: 1;
+};

bindgen-tests/tests/headers/private_fields.hpp

@@ -1,4 +1,5 @@
 // bindgen-flags: --respect-cxx-access-specs
+// bindgen-parse-callbacks: field-visibility-default-public
 
 class PubPriv {
   public:
@@ -50,9 +51,13 @@ class Override {
   // override with annotation
   /** <div rustbindgen private></div> */
   unsigned int b;
+  // override with callback
+  unsigned int private_c;
 
   unsigned int bf_a : 4;
   // override with annotation
   /** <div rustbindgen private></div> */
   unsigned int bf_b : 4;
+  // override with callback
+  unsigned int private_bf_c : 4;
 };

bindgen-tests/tests/parse_callbacks/mod.rs

@@ -1,4 +1,5 @@
 use bindgen::callbacks::*;
+use bindgen::FieldVisibilityKind;
 
 #[derive(Debug)]
 pub struct RemovePrefixParseCallback {
@@ -86,25 +87,65 @@ impl ParseCallbacks for BlocklistedTypeImplementsTrait {
     }
 }
 
+#[derive(Debug)]
+struct FieldVisibility {
+    default: FieldVisibilityKind,
+}
+
+/// Implements the `field_visibility` function of the trait by checking if the
+/// field name starts with `private_`. If it does it makes it private, if it
+/// doesn't it makes it public, taking into account the default visibility.
+impl ParseCallbacks for FieldVisibility {
+    fn field_visibility(
+        &self,
+        FieldInfo { field_name, .. }: FieldInfo,
+    ) -> Option<FieldVisibilityKind> {
+        match (self.default, field_name.starts_with("private_")) {
+            (FieldVisibilityKind::Private, false) => {
+                Some(FieldVisibilityKind::Public)
+            }
+            (FieldVisibilityKind::Public, true) => {
+                Some(FieldVisibilityKind::Private)
+            }
+            (FieldVisibilityKind::PublicCrate, _) => unimplemented!(),
+            _ => None,
+        }
+    }
+}
+
 pub fn lookup(cb: &str) -> Box<dyn ParseCallbacks> {
+    fn try_strip_prefix<'a>(s: &'a str, prefix: &str) -> Option<&'a str> {
+        if s.starts_with(prefix) {
+            Some(&s[prefix.len()..])
+        } else {
+            None
+        }
+    }
+
     match cb {
         "enum-variant-rename" => Box::new(EnumVariantRename),
         "blocklisted-type-implements-trait" => {
             Box::new(BlocklistedTypeImplementsTrait)
         }
         call_back => {
-            if call_back.starts_with("remove-function-prefix-") {
-                let prefix = call_back
-                    .split("remove-function-prefix-")
-                    .last()
-                    .to_owned();
-                let lnopc = RemovePrefixParseCallback::new(prefix.unwrap());
+            if let Some(prefix) =
+                try_strip_prefix(call_back, "remove-function-prefix-")
+            {
+                let lnopc = RemovePrefixParseCallback::new(prefix);
                 Box::new(lnopc)
-            } else if call_back.starts_with("prefix-link-name-") {
-                let prefix =
-                    call_back.split("prefix-link-name-").last().to_owned();
-                let plnpc = PrefixLinkNameParseCallback::new(prefix.unwrap());
+            } else if let Some(prefix) =
+                try_strip_prefix(call_back, "prefix-link-name-")
+            {
+                let plnpc = PrefixLinkNameParseCallback::new(prefix);
                 Box::new(plnpc)
+            } else if let Some(default) =
+                try_strip_prefix(call_back, "field-visibility-default-")
+            {
+                Box::new(FieldVisibility {
+                    default: default.parse().expect(
+                        "unable to parse field-visibility-default callback",
+                    ),
+                })
             } else {
                 panic!("Couldn't find name ParseCallbacks: {}", cb)
             }