Add support for out-of-line bitfields declarations

tests/expectations/bitflags.c

@@ -52,4 +52,14 @@ typedef struct {
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
 #define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
-void root(AlignFlags flags, DebugFlags bigger_flags, LargeFlags largest_flags);
+typedef struct {
+  uint32_t _0;
+} OutOfLine;
+#define OutOfLine_A (OutOfLine){ ._0 = (uint32_t)1 }
+#define OutOfLine_B (OutOfLine){ ._0 = (uint32_t)2 }
+#define OutOfLine_AB (OutOfLine){ ._0 = (uint32_t)((OutOfLine_A)._0 | (OutOfLine_B)._0) }
+
+void root(AlignFlags flags,
+          DebugFlags bigger_flags,
+          LargeFlags largest_flags,
+          OutOfLine out_of_line);

tests/expectations/bitflags.compat.c

@@ -52,11 +52,21 @@ typedef struct {
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
 #define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
+typedef struct {
+  uint32_t _0;
+} OutOfLine;
+#define OutOfLine_A (OutOfLine){ ._0 = (uint32_t)1 }
+#define OutOfLine_B (OutOfLine){ ._0 = (uint32_t)2 }
+#define OutOfLine_AB (OutOfLine){ ._0 = (uint32_t)((OutOfLine_A)._0 | (OutOfLine_B)._0) }
+
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
-void root(AlignFlags flags, DebugFlags bigger_flags, LargeFlags largest_flags);
+void root(AlignFlags flags,
+          DebugFlags bigger_flags,
+          LargeFlags largest_flags,
+          OutOfLine out_of_line);
 
 #ifdef __cplusplus
 } // extern "C"

tests/expectations/bitflags.cpp

@@ -121,8 +121,46 @@ struct LargeFlags {
 constexpr static const LargeFlags LargeFlags_LARGE_SHIFT = LargeFlags{ /* .bits = */ (uint64_t)(1ull << 44) };
 constexpr static const LargeFlags LargeFlags_INVERTED = LargeFlags{ /* .bits = */ (uint64_t)~(LargeFlags_LARGE_SHIFT).bits };
 
+struct OutOfLine {
+  uint32_t _0;
+
+  constexpr explicit operator bool() const {
+    return !!_0;
+  }
+  constexpr OutOfLine operator~() const {
+    return OutOfLine { static_cast<decltype(_0)>(~_0) };
+  }
+  constexpr OutOfLine operator|(const OutOfLine& other) const {
+    return OutOfLine { static_cast<decltype(_0)>(this->_0 | other._0) };
+  }
+  OutOfLine& operator|=(const OutOfLine& other) {
+    *this = (*this | other);
+    return *this;
+  }
+  constexpr OutOfLine operator&(const OutOfLine& other) const {
+    return OutOfLine { static_cast<decltype(_0)>(this->_0 & other._0) };
+  }
+  OutOfLine& operator&=(const OutOfLine& other) {
+    *this = (*this & other);
+    return *this;
+  }
+  constexpr OutOfLine operator^(const OutOfLine& other) const {
+    return OutOfLine { static_cast<decltype(_0)>(this->_0 ^ other._0) };
+  }
+  OutOfLine& operator^=(const OutOfLine& other) {
+    *this = (*this ^ other);
+    return *this;
+  }
+};
+constexpr static const OutOfLine OutOfLine_A = OutOfLine{ /* ._0 = */ (uint32_t)1 };
+constexpr static const OutOfLine OutOfLine_B = OutOfLine{ /* ._0 = */ (uint32_t)2 };
+constexpr static const OutOfLine OutOfLine_AB = OutOfLine{ /* ._0 = */ (uint32_t)((OutOfLine_A)._0 | (OutOfLine_B)._0) };
+
 extern "C" {
 
-void root(AlignFlags flags, DebugFlags bigger_flags, LargeFlags largest_flags);
+void root(AlignFlags flags,
+          DebugFlags bigger_flags,
+          LargeFlags largest_flags,
+          OutOfLine out_of_line);
 
 } // extern "C"

tests/expectations/bitflags.pyx

@@ -36,4 +36,13 @@ cdef extern from *:
   const LargeFlags LargeFlags_LARGE_SHIFT # = <LargeFlags>{ <uint64_t>(1ull << 44) }
   const LargeFlags LargeFlags_INVERTED # = <LargeFlags>{ <uint64_t>~(LargeFlags_LARGE_SHIFT).bits }
 
-  void root(AlignFlags flags, DebugFlags bigger_flags, LargeFlags largest_flags);
+  ctypedef struct OutOfLine:
+    uint32_t _0;
+  const OutOfLine OutOfLine_A # = <OutOfLine>{ <uint32_t>1 }
+  const OutOfLine OutOfLine_B # = <OutOfLine>{ <uint32_t>2 }
+  const OutOfLine OutOfLine_AB # = <OutOfLine>{ <uint32_t>((OutOfLine_A)._0 | (OutOfLine_B)._0) }
+
+  void root(AlignFlags flags,
+            DebugFlags bigger_flags,
+            LargeFlags largest_flags,
+            OutOfLine out_of_line);

tests/expectations/bitflags_both.c

@@ -52,4 +52,14 @@ typedef struct LargeFlags {
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
 #define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
-void root(struct AlignFlags flags, struct DebugFlags bigger_flags, struct LargeFlags largest_flags);
+typedef struct OutOfLine {
+  uint32_t _0;
+} OutOfLine;
+#define OutOfLine_A (OutOfLine){ ._0 = (uint32_t)1 }
+#define OutOfLine_B (OutOfLine){ ._0 = (uint32_t)2 }
+#define OutOfLine_AB (OutOfLine){ ._0 = (uint32_t)((OutOfLine_A)._0 | (OutOfLine_B)._0) }
+
+void root(struct AlignFlags flags,
+          struct DebugFlags bigger_flags,
+          struct LargeFlags largest_flags,
+          struct OutOfLine out_of_line);

tests/expectations/bitflags_both.compat.c

@@ -52,11 +52,21 @@ typedef struct LargeFlags {
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
 #define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
+typedef struct OutOfLine {
+  uint32_t _0;
+} OutOfLine;
+#define OutOfLine_A (OutOfLine){ ._0 = (uint32_t)1 }
+#define OutOfLine_B (OutOfLine){ ._0 = (uint32_t)2 }
+#define OutOfLine_AB (OutOfLine){ ._0 = (uint32_t)((OutOfLine_A)._0 | (OutOfLine_B)._0) }
+
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
-void root(struct AlignFlags flags, struct DebugFlags bigger_flags, struct LargeFlags largest_flags);
+void root(struct AlignFlags flags,
+          struct DebugFlags bigger_flags,
+          struct LargeFlags largest_flags,
+          struct OutOfLine out_of_line);
 
 #ifdef __cplusplus
 } // extern "C"

tests/expectations/bitflags_tag.c

@@ -52,4 +52,14 @@ struct LargeFlags {
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
 #define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
-void root(struct AlignFlags flags, struct DebugFlags bigger_flags, struct LargeFlags largest_flags);
+struct OutOfLine {
+  uint32_t _0;
+};
+#define OutOfLine_A (OutOfLine){ ._0 = (uint32_t)1 }
+#define OutOfLine_B (OutOfLine){ ._0 = (uint32_t)2 }
+#define OutOfLine_AB (OutOfLine){ ._0 = (uint32_t)((OutOfLine_A)._0 | (OutOfLine_B)._0) }
+
+void root(struct AlignFlags flags,
+          struct DebugFlags bigger_flags,
+          struct LargeFlags largest_flags,
+          struct OutOfLine out_of_line);

tests/expectations/bitflags_tag.compat.c

@@ -52,11 +52,21 @@ struct LargeFlags {
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
 #define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
+struct OutOfLine {
+  uint32_t _0;
+};
+#define OutOfLine_A (OutOfLine){ ._0 = (uint32_t)1 }
+#define OutOfLine_B (OutOfLine){ ._0 = (uint32_t)2 }
+#define OutOfLine_AB (OutOfLine){ ._0 = (uint32_t)((OutOfLine_A)._0 | (OutOfLine_B)._0) }
+
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
-void root(struct AlignFlags flags, struct DebugFlags bigger_flags, struct LargeFlags largest_flags);
+void root(struct AlignFlags flags,
+          struct DebugFlags bigger_flags,
+          struct LargeFlags largest_flags,
+          struct OutOfLine out_of_line);
 
 #ifdef __cplusplus
 } // extern "C"

tests/expectations/bitflags_tag.pyx

@@ -36,4 +36,13 @@ cdef extern from *:
   const LargeFlags LargeFlags_LARGE_SHIFT # = <LargeFlags>{ <uint64_t>(1ull << 44) }
   const LargeFlags LargeFlags_INVERTED # = <LargeFlags>{ <uint64_t>~(LargeFlags_LARGE_SHIFT).bits }
 
-  void root(AlignFlags flags, DebugFlags bigger_flags, LargeFlags largest_flags);
+  cdef struct OutOfLine:
+    uint32_t _0;
+  const OutOfLine OutOfLine_A # = <OutOfLine>{ <uint32_t>1 }
+  const OutOfLine OutOfLine_B # = <OutOfLine>{ <uint32_t>2 }
+  const OutOfLine OutOfLine_AB # = <OutOfLine>{ <uint32_t>((OutOfLine_A)._0 | (OutOfLine_B)._0) }
+
+  void root(AlignFlags flags,
+            DebugFlags bigger_flags,
+            LargeFlags largest_flags,
+            OutOfLine out_of_line);

tests/rust/bitflags.rs

@@ -38,6 +38,24 @@ bitflags! {
     }
 }
 
+// bitflags 2 allows to define types out-of-line for custom derives
+// #[derive(SomeTrait)]
+#[repr(C)]
+pub struct OutOfLine(u32);
+
+bitflags! {
+    impl OutOfLine: u32 {
+        const A = 1;
+        const B = 2;
+        const AB = Self::A.bits() | Self::B.bits();
+    }
+}
 
 #[no_mangle]
-pub extern "C" fn root(flags: AlignFlags, bigger_flags: DebugFlags, largest_flags: LargeFlags) {}
+pub extern "C" fn root(
+    flags: AlignFlags,
+    bigger_flags: DebugFlags,
+    largest_flags: LargeFlags,
+    out_of_line: OutOfLine,
+) {
+}