2 files changed, 126 insertions, 0 deletions
diff --git a/tests/expectations/tests/deleted-function.rs b/tests/expectations/tests/deleted-function.rs
new file mode 100644
index 00000000..96967bb4
--- /dev/null
+++ b/tests/expectations/tests/deleted-function.rs
@@ -0,0 +1,91 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct A {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_A() {
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        1usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        1usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1A17inline_definitionEv"]
+    pub fn A_inline_definition(this: *mut A);
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1A22out_of_line_definitionEv"]
+    pub fn A_out_of_line_definition(this: *mut A);
+}
+impl A {
+    #[inline]
+    pub unsafe fn inline_definition(&mut self) {
+        A_inline_definition(self)
+    }
+    #[inline]
+    pub unsafe fn out_of_line_definition(&mut self) {
+        A_out_of_line_definition(self)
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct B {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_B() {
+    assert_eq!(
+        ::std::mem::size_of::<B>(),
+        1usize,
+        concat!("Size of: ", stringify!(B))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B>(),
+        1usize,
+        concat!("Alignment of ", stringify!(B))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct C {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_C() {
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        1usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        1usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1CC1ERS_"]
+    pub fn C_C(this: *mut C, arg1: *mut C);
+}
+impl C {
+    #[inline]
+    pub unsafe fn new(arg1: *mut C) -> Self {
+        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
+        C_C(__bindgen_tmp.as_mut_ptr(), arg1);
+        __bindgen_tmp.assume_init()
+    }
+}
diff --git a/tests/headers/deleted-function.hpp b/tests/headers/deleted-function.hpp
new file mode 100644
index 00000000..61848a0a
--- /dev/null
+++ b/tests/headers/deleted-function.hpp
@@ -0,0 +1,35 @@
+// bindgen-flags: --generate-inline-functions -- -std=c++11
+
+class A {
+public:
+      // Deleted function should not get a binding.
+      void deleted() = delete;
+
+      // Inline functions should get bindings, whether they are defined inline
+      // (in the class) or out of line.
+      inline void inline_definition() {}
+      inline void out_of_line_definition();
+
+      // TODO: This is an edge case that we get wrong: An inline function
+      // without a definition in the same translation unit should still get a
+      // binding. We currently can't distinguish this case from a deleted member
+      // function because libclang doesn't provide a direct way to query for
+      // deleted member functions. This seems acceptable, however, as an inline
+      // function without a definition in the same translation unit is unlikely
+      // to be useful in practice.
+      inline void inline_without_definition();
+};
+
+void A::out_of_line_definition() {}
+
+class B {
+public:
+     // Deleted copy constructor should not get a binding.
+     B(B&) = delete;
+};
+
+class C {
+public:
+     // Defaulted copy constructor should get a binding.
+     C(C&) = default;
+};
+\ No newline at end of file