Add --allowlist-file option

3 files changed, 197 insertions, 0 deletions

diff --git a/tests/expectations/tests/allowlist-file.rs b/tests/expectations/tests/allowlist-file.rs
new file mode 100644
index 00000000..2c2660a6
--- /dev/null
+++ b/tests/expectations/tests/allowlist-file.rs
@@ -0,0 +1,154 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const SOME_DEFUN: u32 = 123;
+extern "C" {
+    #[link_name = "\u{1}_Z12SomeFunctionv"]
+    pub fn SomeFunction();
+}
+extern "C" {
+    pub static mut someVar: ::std::os::raw::c_int;
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct someClass {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_someClass() {
+    assert_eq!(
+        ::std::mem::size_of::<someClass>(),
+        1usize,
+        concat!("Size of: ", stringify!(someClass))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<someClass>(),
+        1usize,
+        concat!("Alignment of ", stringify!(someClass))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN9someClass16somePublicMethodEi"]
+    pub fn someClass_somePublicMethod(
+        this: *mut someClass,
+        foo: ::std::os::raw::c_int,
+    );
+}
+impl someClass {
+    #[inline]
+    pub unsafe fn somePublicMethod(&mut self, foo: ::std::os::raw::c_int) {
+        someClass_somePublicMethod(self, foo)
+    }
+}
+extern "C" {
+    pub fn ExternFunction();
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3foo18NamespacedFunctionEv"]
+    pub fn foo_NamespacedFunction();
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StructWithAllowlistedDefinition {
+    pub other: *mut StructWithAllowlistedFwdDecl,
+}
+#[test]
+fn bindgen_test_layout_StructWithAllowlistedDefinition() {
+    assert_eq!(
+        ::std::mem::size_of::<StructWithAllowlistedDefinition>(),
+        8usize,
+        concat!("Size of: ", stringify!(StructWithAllowlistedDefinition))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StructWithAllowlistedDefinition>(),
+        8usize,
+        concat!("Alignment of ", stringify!(StructWithAllowlistedDefinition))
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<StructWithAllowlistedDefinition>())).other
+                as *const _ as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StructWithAllowlistedDefinition),
+            "::",
+            stringify!(other)
+        )
+    );
+}
+impl Default for StructWithAllowlistedDefinition {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct StructWithAllowlistedFwdDecl {
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_StructWithAllowlistedFwdDecl() {
+    assert_eq!(
+        ::std::mem::size_of::<StructWithAllowlistedFwdDecl>(),
+        4usize,
+        concat!("Size of: ", stringify!(StructWithAllowlistedFwdDecl))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StructWithAllowlistedFwdDecl>(),
+        4usize,
+        concat!("Alignment of ", stringify!(StructWithAllowlistedFwdDecl))
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<StructWithAllowlistedFwdDecl>())).b
+                as *const _ as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StructWithAllowlistedFwdDecl),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct AllowlistMe {
+    pub foo: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_AllowlistMe() {
+    assert_eq!(
+        ::std::mem::size_of::<AllowlistMe>(),
+        4usize,
+        concat!("Size of: ", stringify!(AllowlistMe))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AllowlistMe>(),
+        4usize,
+        concat!("Alignment of ", stringify!(AllowlistMe))
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<AllowlistMe>())).foo as *const _ as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AllowlistMe),
+            "::",
+            stringify!(foo)
+        )
+    );
+}
diff --git a/tests/headers/allowlist-file.hpp b/tests/headers/allowlist-file.hpp
new file mode 100644
index 00000000..b0354a04
--- /dev/null
+++ b/tests/headers/allowlist-file.hpp
@@ -0,0 +1,21 @@
+// bindgen-flags: --allowlist-file ".*/allowlisted/file.*" --allowlist-type AllowlistMe -- -Itests/headers
+
+
+// Forward declaration of struct that's defined in an allowlisted file.
+struct StructWithAllowlistedDefinition;
+
+#include "allowlisted/file.hpp"
+
+// Actual definition of struct that has a forward declaration in an allowlisted file.
+struct StructWithAllowlistedFwdDecl {
+    int b;
+};
+
+class Ignored {
+    char c;
+};
+
+// Also have an explicitly allowlisted type
+class AllowlistMe {
+    int foo;
+};
diff --git a/tests/headers/allowlisted/file.hpp b/tests/headers/allowlisted/file.hpp
new file mode 100644
index 00000000..5f360e5e
--- /dev/null
+++ b/tests/headers/allowlisted/file.hpp
@@ -0,0 +1,22 @@
+void SomeFunction();
+extern int someVar;
+#define SOME_DEFUN 123
+
+class someClass {
+  void somePrivateMethod();
+public:
+  void somePublicMethod(int foo);
+};
+
+extern "C" void ExternFunction();
+
+namespace foo {
+  void NamespacedFunction();
+}
+
+
+struct StructWithAllowlistedFwdDecl;
+
+struct StructWithAllowlistedDefinition {
+    StructWithAllowlistedFwdDecl* other;
+};