constant: Add support for unary negation.

Author: emilio

src/bindgen/ir/constant.rs

@@ -417,6 +417,13 @@ impl Literal {
             syn::Expr::Unary(syn::ExprUnary {
                 ref op, ref expr, ..
             }) => match *op {
+                UnOp::Not(_) => {
+                    let val = Self::load(expr)?;
+                    Ok(Literal::PostfixUnaryOp {
+                        op: "~",
+                        value: Box::new(val),
+                    })
+                }
                 UnOp::Neg(_) => {
                     let val = Self::load(expr)?;
                     Ok(Literal::PostfixUnaryOp {

tests/expectations/bitflags.both.c

@@ -50,5 +50,6 @@ typedef struct LargeFlags {
  * Flag with a very large shift that usually would be narrowed.
  */
 #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);

tests/expectations/bitflags.both.compat.c

@@ -50,6 +50,7 @@ typedef struct LargeFlags {
  * Flag with a very large shift that usually would be narrowed.
  */
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
+#define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
 #ifdef __cplusplus
 extern "C" {

tests/expectations/bitflags.c

@@ -50,5 +50,6 @@ typedef struct {
  * Flag with a very large shift that usually would be narrowed.
  */
 #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);

tests/expectations/bitflags.compat.c

@@ -50,6 +50,7 @@ typedef struct {
  * Flag with a very large shift that usually would be narrowed.
  */
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
+#define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
 #ifdef __cplusplus
 extern "C" {

tests/expectations/bitflags.cpp

@@ -119,6 +119,7 @@ struct LargeFlags {
 };
 /// Flag with a very large shift that usually would be narrowed.
 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 };
 
 extern "C" {
 

tests/expectations/bitflags.pyx

@@ -34,5 +34,6 @@ cdef extern from *:
     uint64_t bits;
   # Flag with a very large shift that usually would be narrowed.
   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);

tests/expectations/bitflags.tag.c

@@ -50,5 +50,6 @@ struct LargeFlags {
  * Flag with a very large shift that usually would be narrowed.
  */
 #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);

tests/expectations/bitflags.tag.compat.c

@@ -50,6 +50,7 @@ struct LargeFlags {
  * Flag with a very large shift that usually would be narrowed.
  */
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
+#define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
 #ifdef __cplusplus
 extern "C" {

tests/expectations/bitflags.tag.pyx

@@ -34,5 +34,6 @@ cdef extern from *:
     uint64_t bits;
   # Flag with a very large shift that usually would be narrowed.
   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);

tests/rust/bitflags.rs

@@ -34,6 +34,7 @@ bitflags! {
     pub struct LargeFlags: u64 {
         /// Flag with a very large shift that usually would be narrowed.
         const LARGE_SHIFT = 1u64 << 44;
+        const INVERTED = !Self::LARGE_SHIFT.bits;
     }
 }