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
+
+struct my_struct {
+    int a;
+    int private_b;
+    int c: 1;
+    int private_d: 1;
+};

bindgen-tests/tests/parse_callbacks/mod.rs

@@ -86,9 +86,27 @@ impl ParseCallbacks for BlocklistedTypeImplementsTrait {
     }
 }
 
+#[derive(Debug)]
+struct FieldVisibility;
+
+impl ParseCallbacks for FieldVisibility {
+    fn field_visibility(
+        &self,
+        _type_name: &str,
+        field_name: &str,
+    ) -> Option<bindgen::FieldVisibilityKind> {
+        if !field_name.starts_with("private_") {
+            Some(bindgen::FieldVisibilityKind::Public)
+        } else {
+            None
+        }
+    }
+}
+
 pub fn lookup(cb: &str) -> Box<dyn ParseCallbacks> {
     match cb {
         "enum-variant-rename" => Box::new(EnumVariantRename),
+        "field-visibility" => Box::new(FieldVisibility),
         "blocklisted-type-implements-trait" => {
             Box::new(BlocklistedTypeImplementsTrait)
         }

bindgen/callbacks.rs

@@ -135,6 +135,15 @@ pub trait ParseCallbacks: fmt::Debug {
     fn process_comment(&self, _comment: &str) -> Option<String> {
         None
     }
+
+    /// Potentially override the visibility of a composite type field
+    fn field_visibility(
+        &self,
+        _type_name: &str,
+        _field_name: &str,
+    ) -> Option<crate::FieldVisibilityKind> {
+        None
+    }
 }
 
 /// Relevant information about a type to which new derive attributes will be added using

bindgen/codegen/mod.rs

@@ -1291,6 +1291,7 @@ trait FieldCodegen<'a> {
         visibility_kind: FieldVisibilityKind,
         accessor_kind: FieldAccessorKind,
         parent: &CompInfo,
+        parent_item: &Item,
         result: &mut CodegenResult,
         struct_layout: &mut StructLayoutTracker,
         fields: &mut F,
@@ -1310,6 +1311,7 @@ impl<'a> FieldCodegen<'a> for Field {
         visibility_kind: FieldVisibilityKind,
         accessor_kind: FieldAccessorKind,
         parent: &CompInfo,
+        parent_item: &Item,
         result: &mut CodegenResult,
         struct_layout: &mut StructLayoutTracker,
         fields: &mut F,
@@ -1326,6 +1328,7 @@ impl<'a> FieldCodegen<'a> for Field {
                     visibility_kind,
                     accessor_kind,
                     parent,
+                    parent_item,
                     result,
                     struct_layout,
                     fields,
@@ -1339,6 +1342,7 @@ impl<'a> FieldCodegen<'a> for Field {
                     visibility_kind,
                     accessor_kind,
                     parent,
+                    parent_item,
                     result,
                     struct_layout,
                     fields,
@@ -1388,6 +1392,7 @@ impl<'a> FieldCodegen<'a> for FieldData {
         parent_visibility_kind: FieldVisibilityKind,
         accessor_kind: FieldAccessorKind,
         parent: &CompInfo,
+        parent_item: &Item,
         result: &mut CodegenResult,
         struct_layout: &mut StructLayoutTracker,
         fields: &mut F,
@@ -1451,6 +1456,12 @@ impl<'a> FieldCodegen<'a> for FieldData {
         let visibility = compute_visibility(
             ctx,
             self.is_public(),
+            ctx.options().last_callback(|cb| {
+                cb.field_visibility(
+                    &parent_item.canonical_name(ctx),
+                    &field_name,
+                )
+            }),
             self.annotations(),
             parent_visibility_kind,
         );
@@ -1604,27 +1615,28 @@ fn access_specifier(
 fn compute_visibility(
     ctx: &BindgenContext,
     is_declared_public: bool,
+    callback_override: Option<FieldVisibilityKind>,
     annotations: &Annotations,
     default_kind: FieldVisibilityKind,
 ) -> FieldVisibilityKind {
-    match (
-        is_declared_public,
-        ctx.options().respect_cxx_access_specs,
-        annotations.visibility_kind(),
-    ) {
-        (true, true, annotated_visibility) => {
-            // declared as public, cxx specs are respected
-            annotated_visibility.unwrap_or(FieldVisibilityKind::Public)
-        }
-        (false, true, annotated_visibility) => {
-            // declared as private, cxx specs are respected
-            annotated_visibility.unwrap_or(FieldVisibilityKind::Private)
-        }
-        (_, false, annotated_visibility) => {
-            // cxx specs are not respected, declaration does not matter.
-            annotated_visibility.unwrap_or(default_kind)
-        }
-    }
+    callback_override
+        .or_else(|| annotations.visibility_kind())
+        .unwrap_or_else(|| {
+            match (is_declared_public, ctx.options().respect_cxx_access_specs) {
+                (true, true) => {
+                    // declared as public, cxx specs are respected
+                    FieldVisibilityKind::Public
+                }
+                (false, true) => {
+                    // declared as private, cxx specs are respected
+                    FieldVisibilityKind::Private
+                }
+                (_, false) => {
+                    // cxx specs are not respected, declaration does not matter.
+                    default_kind
+                }
+            }
+        })
 }
 
 impl<'a> FieldCodegen<'a> for BitfieldUnit {
@@ -1636,6 +1648,7 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit {
         visibility_kind: FieldVisibilityKind,
         accessor_kind: FieldAccessorKind,
         parent: &CompInfo,
+        parent_item: &Item,
         result: &mut CodegenResult,
         struct_layout: &mut StructLayoutTracker,
         fields: &mut F,
@@ -1715,6 +1728,7 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit {
                 visibility_kind,
                 accessor_kind,
                 parent,
+                parent_item,
                 result,
                 struct_layout,
                 fields,
@@ -1796,6 +1810,7 @@ impl<'a> FieldCodegen<'a> for Bitfield {
         visibility_kind: FieldVisibilityKind,
         _accessor_kind: FieldAccessorKind,
         parent: &CompInfo,
+        parent_item: &Item,
         _result: &mut CodegenResult,
         struct_layout: &mut StructLayoutTracker,
         _fields: &mut F,
@@ -1838,9 +1853,15 @@ impl<'a> FieldCodegen<'a> for Bitfield {
         let offset = self.offset_into_unit();
         let width = self.width() as u8;
 
+        let override_visibility = self.name().and_then(|fname| {
+            ctx.options().last_callback(|cb| {
+                cb.field_visibility(&parent_item.canonical_name(ctx), fname)
+            })
+        });
         *bitfield_visibility = compute_visibility(
             ctx,
             self.is_public(),
+            override_visibility,
             self.annotations(),
             visibility_kind,
         );
@@ -2007,6 +2028,7 @@ impl CodeGenerator for CompInfo {
                     visibility,
                     struct_accessor_kind,
                     self,
+                    item,
                     result,
                     &mut struct_layout,
                     &mut fields,