feat: Support ManuallyDrop, MaybeUninit and Box as simplified types for C only

src/bindgen/ir/ty.rs

@@ -433,7 +433,7 @@ impl Type {
                 is_nullable: false,
                 is_ref: false,
             }),
-            "Cell" => Some(generic),
+            "Cell" | "ManuallyDrop" | "MaybeUninit" => Some(generic),
             _ => None,
         }
     }

src/bindgen/parser.rs

@@ -392,6 +392,8 @@ impl Parse {
         add_opaque("BTreeSet", vec!["T"]);
         add_opaque("LinkedList", vec!["T"]);
         add_opaque("VecDeque", vec!["T"]);
+        add_opaque("ManuallyDrop", vec!["T"]);
+        add_opaque("MaybeUninit", vec!["T"]);
     }
 
     pub fn extend_with(&mut self, other: &Parse) {

tests/expectations/both/manuallydrop.c

@@ -0,0 +1,21 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct NotReprC_ManuallyDrop_Point NotReprC_ManuallyDrop_Point;
+
+typedef NotReprC_ManuallyDrop_Point Foo;
+
+typedef struct Point {
+  int32_t x;
+  int32_t y;
+} Point;
+
+typedef struct MyStruct {
+  Point point;
+} MyStruct;
+
+void root(const Foo *a, const MyStruct *with_manual_drop);
+
+void take(Point with_manual_drop);

tests/expectations/both/manuallydrop.compat.c

@@ -0,0 +1,29 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct NotReprC_ManuallyDrop_Point NotReprC_ManuallyDrop_Point;
+
+typedef NotReprC_ManuallyDrop_Point Foo;
+
+typedef struct Point {
+  int32_t x;
+  int32_t y;
+} Point;
+
+typedef struct MyStruct {
+  Point point;
+} MyStruct;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(const Foo *a, const MyStruct *with_manual_drop);
+
+void take(Point with_manual_drop);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

tests/expectations/both/maybeuninit.c

@@ -0,0 +1,14 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct NotReprC_MaybeUninit______i32 NotReprC_MaybeUninit______i32;
+
+typedef NotReprC_MaybeUninit______i32 Foo;
+
+typedef struct MyStruct {
+  const int32_t *number;
+} MyStruct;
+
+void root(const Foo *a, const MyStruct *with_maybe_uninit);

tests/expectations/both/maybeuninit.compat.c

@@ -0,0 +1,22 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct NotReprC_MaybeUninit______i32 NotReprC_MaybeUninit______i32;
+
+typedef NotReprC_MaybeUninit______i32 Foo;
+
+typedef struct MyStruct {
+  const int32_t *number;
+} MyStruct;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(const Foo *a, const MyStruct *with_maybe_uninit);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

tests/expectations/manuallydrop.c

@@ -0,0 +1,21 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct NotReprC_ManuallyDrop_Point NotReprC_ManuallyDrop_Point;
+
+typedef NotReprC_ManuallyDrop_Point Foo;
+
+typedef struct {
+  int32_t x;
+  int32_t y;
+} Point;
+
+typedef struct {
+  Point point;
+} MyStruct;
+
+void root(const Foo *a, const MyStruct *with_manual_drop);
+
+void take(Point with_manual_drop);

tests/expectations/manuallydrop.compat.c

@@ -0,0 +1,29 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct NotReprC_ManuallyDrop_Point NotReprC_ManuallyDrop_Point;
+
+typedef NotReprC_ManuallyDrop_Point Foo;
+
+typedef struct {
+  int32_t x;
+  int32_t y;
+} Point;
+
+typedef struct {
+  Point point;
+} MyStruct;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(const Foo *a, const MyStruct *with_manual_drop);
+
+void take(Point with_manual_drop);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

tests/expectations/manuallydrop.cpp

@@ -0,0 +1,29 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <new>
+
+template<typename T = void>
+struct ManuallyDrop;
+
+template<typename T = void>
+struct NotReprC;
+
+struct Point {
+  int32_t x;
+  int32_t y;
+};
+
+using Foo = NotReprC<ManuallyDrop<Point>>;
+
+struct MyStruct {
+  Point point;
+};
+
+extern "C" {
+
+void root(const Foo *a, const MyStruct *with_manual_drop);
+
+void take(Point with_manual_drop);
+
+} // extern "C"

tests/expectations/maybeuninit.c

@@ -0,0 +1,14 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct NotReprC_MaybeUninit______i32 NotReprC_MaybeUninit______i32;
+
+typedef NotReprC_MaybeUninit______i32 Foo;
+
+typedef struct {
+  const int32_t *number;
+} MyStruct;
+
+void root(const Foo *a, const MyStruct *with_maybe_uninit);

tests/expectations/maybeuninit.compat.c

@@ -0,0 +1,22 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct NotReprC_MaybeUninit______i32 NotReprC_MaybeUninit______i32;
+
+typedef NotReprC_MaybeUninit______i32 Foo;
+
+typedef struct {
+  const int32_t *number;
+} MyStruct;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(const Foo *a, const MyStruct *with_maybe_uninit);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

tests/expectations/maybeuninit.cpp

@@ -0,0 +1,22 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <new>
+
+template<typename T = void>
+struct MaybeUninit;
+
+template<typename T = void>
+struct NotReprC;
+
+using Foo = NotReprC<MaybeUninit<const int32_t*>>;
+
+struct MyStruct {
+  const int32_t *number;
+};
+
+extern "C" {
+
+void root(const Foo *a, const MyStruct *with_maybe_uninit);
+
+} // extern "C"

tests/expectations/tag/manuallydrop.c

@@ -0,0 +1,21 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct NotReprC_ManuallyDrop_Point;
+
+typedef struct NotReprC_ManuallyDrop_Point Foo;
+
+struct Point {
+  int32_t x;
+  int32_t y;
+};
+
+struct MyStruct {
+  struct Point point;
+};
+
+void root(const Foo *a, const struct MyStruct *with_manual_drop);
+
+void take(struct Point with_manual_drop);

tests/expectations/tag/manuallydrop.compat.c

@@ -0,0 +1,29 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct NotReprC_ManuallyDrop_Point;
+
+typedef struct NotReprC_ManuallyDrop_Point Foo;
+
+struct Point {
+  int32_t x;
+  int32_t y;
+};
+
+struct MyStruct {
+  struct Point point;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(const Foo *a, const struct MyStruct *with_manual_drop);
+
+void take(struct Point with_manual_drop);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

tests/expectations/tag/maybeuninit.c

@@ -0,0 +1,14 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct NotReprC_MaybeUninit______i32;
+
+typedef struct NotReprC_MaybeUninit______i32 Foo;
+
+struct MyStruct {
+  const int32_t *number;
+};
+
+void root(const Foo *a, const struct MyStruct *with_maybe_uninit);

tests/expectations/tag/maybeuninit.compat.c

@@ -0,0 +1,22 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct NotReprC_MaybeUninit______i32;
+
+typedef struct NotReprC_MaybeUninit______i32 Foo;
+
+struct MyStruct {
+  const int32_t *number;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(const Foo *a, const struct MyStruct *with_maybe_uninit);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

tests/rust/manuallydrop.rs

@@ -0,0 +1,22 @@
+#[repr(C)]
+pub struct Point {
+    x: i32,
+    y: i32,
+}
+
+#[repr(C)]
+pub struct MyStruct {
+    point: std::mem::ManuallyDrop<Point>,
+}
+
+pub struct NotReprC<T> {
+    inner: T,
+}
+
+pub type Foo = NotReprC<std::mem::ManuallyDrop<Point>>;
+
+#[no_mangle]
+pub extern "C" fn root(a: &Foo, with_manual_drop: &MyStruct) {}
+
+#[no_mangle]
+pub extern "C" fn take(with_manual_drop: std::mem::ManuallyDrop<Point>) {}

tests/rust/maybeuninit.rs

@@ -0,0 +1,13 @@
+#[repr(C)]
+pub struct MyStruct {
+    number: std::mem::MaybeUninit<&i32>,
+}
+
+pub struct NotReprC<T> {
+    inner: T,
+}
+
+pub type Foo = NotReprC<std::mem::MaybeUninit<&i32>>;
+
+#[no_mangle]
+pub extern "C" fn root(a: &Foo, with_maybe_uninit: &MyStruct) {}