bitflags: proper handling of repr(transparent) bitflags structs

Bitflags can be represented using either repr(C) or repr(transparent),
but previously cbindgen would output field accesses w/ repr(transparent)
bitflags. This commit falls back to using int_t typedefs and associated
constants for those cases.

Author: nullstalgia

src/bindgen/bitflags.rs

@@ -8,6 +8,8 @@ use syn::ext::IdentExt;
 use syn::fold::Fold;
 use syn::parse::{Parse, ParseStream, Parser, Result as ParseResult};
 
+use crate::bindgen::ir::{Repr, ReprStyle};
+
 // $(#[$outer:meta])*
 // ($($vis:tt)*) $BitFlags:ident: $T:ty {
 //     $(
@@ -52,7 +54,17 @@ pub enum Bitflags {
 }
 
 impl Bitflags {
-    pub fn expand(&self) -> (Option<syn::ItemStruct>, syn::ItemImpl) {
+    pub fn self_ty_name(&self) -> &syn::Ident {
+        match self {
+            Bitflags::Struct(s) => &s.name,
+            Bitflags::Impl(i) => &i.name,
+        }
+    }
+
+    pub fn expand(
+        &self,
+        out_of_line_transparent: bool,
+    ) -> (Option<syn::ItemStruct>, syn::ItemImpl) {
         match self {
             Bitflags::Struct(BitflagsStruct {
                 attrs,
@@ -69,7 +81,13 @@ impl Bitflags {
                     }
                 };
 
-                let consts = flags.expand(name, repr, false);
+                let is_transparent = if let Ok(repr) = Repr::load(attrs) {
+                    matches!(repr.style, ReprStyle::Transparent)
+                } else {
+                    false
+                };
+
+                let consts = flags.expand(name, repr, false, is_transparent);
                 let impl_ = parse_quote! {
                     impl #name {
                         #consts
@@ -81,7 +99,7 @@ impl Bitflags {
             Bitflags::Impl(BitflagsImpl {
                 name, repr, flags, ..
             }) => {
-                let consts = flags.expand(name, repr, true);
+                let consts = flags.expand(name, repr, true, out_of_line_transparent);
                 let impl_: syn::ItemImpl = parse_quote! {
                     impl #name {
                         #consts
@@ -136,6 +154,7 @@ struct FlagValueFold<'a> {
     struct_name: &'a syn::Ident,
     flag_names: &'a HashSet<String>,
     out_of_line: bool,
+    is_transparent: bool,
 }
 
 impl FlagValueFold<'_> {
@@ -192,6 +211,12 @@ impl Fold for FlagValueFold<'_> {
                             .flag_names
                             .contains(&path.segments.last().unwrap().ident.to_string())) =>
             {
+                // In the transparent case the struct is rendered as a plain typedef to the
+                // underlying integer (e.g. `typedef uint8_t Flags;`), so there is no field
+                // to access, so we keep just the receiver.
+                if self.is_transparent {
+                    return *receiver;
+                }
                 return syn::Expr::Field(syn::ExprField {
                     attrs,
                     base: receiver,
@@ -216,6 +241,7 @@ impl Flag {
         repr: &syn::Type,
         flag_names: &HashSet<String>,
         out_of_line: bool,
+        is_transparent: bool,
     ) -> TokenStream {
         let Flag {
             ref attrs,
@@ -227,9 +253,10 @@ impl Flag {
             struct_name,
             flag_names,
             out_of_line,
+            is_transparent,
         }
         .fold_expr(value.clone());
-        let value = if out_of_line {
+        let value = if out_of_line || is_transparent {
             quote! { ((#folded_value) as #repr) }
         } else {
             quote! { { bits: (#folded_value) as #repr } }
@@ -275,15 +302,21 @@ impl Parse for Flags {
 }
 
 impl Flags {
-    fn expand(&self, struct_name: &syn::Ident, repr: &syn::Type, out_of_line: bool) -> TokenStream {
+    fn expand(
+        &self,
+        struct_name: &syn::Ident,
+        repr: &syn::Type,
+        out_of_line: bool,
+        is_transparent: bool,
+    ) -> TokenStream {
         let mut ts = quote! {};
         let flag_names = self
             .0
             .iter()
             .map(|flag| flag.name.to_string())
             .collect::<HashSet<_>>();
         for flag in &self.0 {
-            ts.extend(flag.expand(struct_name, repr, &flag_names, out_of_line));
+            ts.extend(flag.expand(struct_name, repr, &flag_names, out_of_line, is_transparent));
         }
         ts
     }

src/bindgen/parser.rs

@@ -1017,7 +1017,16 @@ impl Parse {
             }
         };
 
-        let (struct_, impl_) = bitflags.expand();
+        let out_of_line_transparent = {
+            let mut transparent = false;
+            let bitflag_ident = bitflags.self_ty_name().unraw().to_string();
+            self.structs.for_items(&Path::new(&bitflag_ident), |s| {
+                transparent |= s.is_transparent;
+            });
+            transparent
+        };
+
+        let (struct_, impl_) = bitflags.expand(out_of_line_transparent);
         if let Some(struct_) = struct_ {
             self.load_syn_struct(config, crate_name, mod_cfg, &struct_);
         }

tests/expectations-symbols/bitflags_repr_transparent.c.sym

@@ -0,0 +1,3 @@
+{
+root;
+};

tests/expectations-symbols/bitflags_repr_transparent.sym

@@ -0,0 +1,3 @@
+{
+root;
+};

tests/expectations/bitflags_repr_transparent.c

@@ -0,0 +1,57 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+typedef uint8_t AlignFlags;
+/**
+ * 'auto'
+ */
+#define AlignFlags_AUTO (uint8_t)0
+/**
+ * 'normal'
+ */
+#define AlignFlags_NORMAL (uint8_t)1
+/**
+ * 'start'
+ */
+#define AlignFlags_START (uint8_t)(1 << 1)
+/**
+ * 'end'
+ */
+#define AlignFlags_END (uint8_t)(1 << 2)
+#define AlignFlags_ALIAS (uint8_t)AlignFlags_END
+/**
+ * 'flex-start'
+ */
+#define AlignFlags_FLEX_START (uint8_t)(1 << 3)
+#define AlignFlags_MIXED (uint8_t)(((1 << 4) | AlignFlags_FLEX_START) | AlignFlags_END)
+#define AlignFlags_MIXED_SELF (uint8_t)(((1 << 5) | AlignFlags_FLEX_START) | AlignFlags_END)
+
+typedef uint32_t DebugFlags;
+/**
+ * Flag with the topmost bit set of the u32
+ */
+#define DebugFlags_BIGGEST_ALLOWED (uint32_t)(1 << 31)
+
+typedef uint64_t LargeFlags;
+/**
+ * Flag with a very large shift that usually would be narrowed.
+ */
+#define LargeFlags_LARGE_SHIFT (uint64_t)(1ull << 44)
+#define LargeFlags_INVERTED (uint64_t)~LargeFlags_LARGE_SHIFT
+
+typedef uint32_t OutOfLine;
+#define OutOfLine_A (uint32_t)1
+#define OutOfLine_B (uint32_t)2
+#define OutOfLine_AB (uint32_t)(OutOfLine_A | OutOfLine_B)
+
+void root(AlignFlags flags,
+          DebugFlags bigger_flags,
+          LargeFlags largest_flags,
+          OutOfLine out_of_line);

tests/expectations/bitflags_repr_transparent.compat.c

@@ -0,0 +1,65 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+typedef uint8_t AlignFlags;
+/**
+ * 'auto'
+ */
+#define AlignFlags_AUTO (uint8_t)0
+/**
+ * 'normal'
+ */
+#define AlignFlags_NORMAL (uint8_t)1
+/**
+ * 'start'
+ */
+#define AlignFlags_START (uint8_t)(1 << 1)
+/**
+ * 'end'
+ */
+#define AlignFlags_END (uint8_t)(1 << 2)
+#define AlignFlags_ALIAS (uint8_t)AlignFlags_END
+/**
+ * 'flex-start'
+ */
+#define AlignFlags_FLEX_START (uint8_t)(1 << 3)
+#define AlignFlags_MIXED (uint8_t)(((1 << 4) | AlignFlags_FLEX_START) | AlignFlags_END)
+#define AlignFlags_MIXED_SELF (uint8_t)(((1 << 5) | AlignFlags_FLEX_START) | AlignFlags_END)
+
+typedef uint32_t DebugFlags;
+/**
+ * Flag with the topmost bit set of the u32
+ */
+#define DebugFlags_BIGGEST_ALLOWED (uint32_t)(1 << 31)
+
+typedef uint64_t LargeFlags;
+/**
+ * Flag with a very large shift that usually would be narrowed.
+ */
+#define LargeFlags_LARGE_SHIFT (uint64_t)(1ull << 44)
+#define LargeFlags_INVERTED (uint64_t)~LargeFlags_LARGE_SHIFT
+
+typedef uint32_t OutOfLine;
+#define OutOfLine_A (uint32_t)1
+#define OutOfLine_B (uint32_t)2
+#define OutOfLine_AB (uint32_t)(OutOfLine_A | OutOfLine_B)
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(AlignFlags flags,
+          DebugFlags bigger_flags,
+          LargeFlags largest_flags,
+          OutOfLine out_of_line);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus

tests/expectations/bitflags_repr_transparent.cpp

@@ -0,0 +1,46 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+/// Constants shared by multiple CSS Box Alignment properties
+///
+/// These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+using AlignFlags = uint8_t;
+/// 'auto'
+constexpr static const AlignFlags AlignFlags_AUTO = (uint8_t)0;
+/// 'normal'
+constexpr static const AlignFlags AlignFlags_NORMAL = (uint8_t)1;
+/// 'start'
+constexpr static const AlignFlags AlignFlags_START = (uint8_t)(1 << 1);
+/// 'end'
+constexpr static const AlignFlags AlignFlags_END = (uint8_t)(1 << 2);
+constexpr static const AlignFlags AlignFlags_ALIAS = (uint8_t)AlignFlags_END;
+/// 'flex-start'
+constexpr static const AlignFlags AlignFlags_FLEX_START = (uint8_t)(1 << 3);
+constexpr static const AlignFlags AlignFlags_MIXED = (uint8_t)(((1 << 4) | AlignFlags_FLEX_START) | AlignFlags_END);
+constexpr static const AlignFlags AlignFlags_MIXED_SELF = (uint8_t)(((1 << 5) | AlignFlags_FLEX_START) | AlignFlags_END);
+
+using DebugFlags = uint32_t;
+/// Flag with the topmost bit set of the u32
+constexpr static const DebugFlags DebugFlags_BIGGEST_ALLOWED = (uint32_t)(1 << 31);
+
+using LargeFlags = uint64_t;
+/// Flag with a very large shift that usually would be narrowed.
+constexpr static const LargeFlags LargeFlags_LARGE_SHIFT = (uint64_t)(1ull << 44);
+constexpr static const LargeFlags LargeFlags_INVERTED = (uint64_t)~LargeFlags_LARGE_SHIFT;
+
+using OutOfLine = uint32_t;
+constexpr static const OutOfLine OutOfLine_A = (uint32_t)1;
+constexpr static const OutOfLine OutOfLine_B = (uint32_t)2;
+constexpr static const OutOfLine OutOfLine_AB = (uint32_t)(OutOfLine_A | OutOfLine_B);
+
+extern "C" {
+
+void root(AlignFlags flags,
+          DebugFlags bigger_flags,
+          LargeFlags largest_flags,
+          OutOfLine out_of_line);
+
+}  // extern "C"

tests/expectations/bitflags_repr_transparent.pyx

@@ -0,0 +1,44 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  # Constants shared by multiple CSS Box Alignment properties
+  #
+  # These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+  ctypedef uint8_t AlignFlags;
+  # 'auto'
+  const AlignFlags AlignFlags_AUTO # = <uint8_t>0
+  # 'normal'
+  const AlignFlags AlignFlags_NORMAL # = <uint8_t>1
+  # 'start'
+  const AlignFlags AlignFlags_START # = <uint8_t>(1 << 1)
+  # 'end'
+  const AlignFlags AlignFlags_END # = <uint8_t>(1 << 2)
+  const AlignFlags AlignFlags_ALIAS # = <uint8_t>AlignFlags_END
+  # 'flex-start'
+  const AlignFlags AlignFlags_FLEX_START # = <uint8_t>(1 << 3)
+  const AlignFlags AlignFlags_MIXED # = <uint8_t>(((1 << 4) | AlignFlags_FLEX_START) | AlignFlags_END)
+  const AlignFlags AlignFlags_MIXED_SELF # = <uint8_t>(((1 << 5) | AlignFlags_FLEX_START) | AlignFlags_END)
+
+  ctypedef uint32_t DebugFlags;
+  # Flag with the topmost bit set of the u32
+  const DebugFlags DebugFlags_BIGGEST_ALLOWED # = <uint32_t>(1 << 31)
+
+  ctypedef uint64_t LargeFlags;
+  # Flag with a very large shift that usually would be narrowed.
+  const LargeFlags LargeFlags_LARGE_SHIFT # = <uint64_t>(1ull << 44)
+  const LargeFlags LargeFlags_INVERTED # = <uint64_t>~LargeFlags_LARGE_SHIFT
+
+  ctypedef uint32_t OutOfLine;
+  const OutOfLine OutOfLine_A # = <uint32_t>1
+  const OutOfLine OutOfLine_B # = <uint32_t>2
+  const OutOfLine OutOfLine_AB # = <uint32_t>(OutOfLine_A | OutOfLine_B)
+
+  void root(AlignFlags flags,
+            DebugFlags bigger_flags,
+            LargeFlags largest_flags,
+            OutOfLine out_of_line);