Squashed 'third_party/autocxx/' changes from 629e8fa53..c35090b75
c35090b75 Merge pull request #1131 from google/rev-0.22.3
94f20d716 Revise to 0.22.3.
b4776fdd5 Merge pull request #1070 from google/reference-wrapper
25f08f567 Better encapsulate TypeConversionPolicy. No functional changes.
b389afdeb Add reference wrapper safety policy.
cd169853b Merge pull request #1126 from google/issue-1125
92f48fa30 Merge pull request #1123 from google/segfault-detection
ca60bacca Add comment
724a4971d Add test for issue 1125.
d8a9a8ca7 Detect segfaults in reduction
e147efc7c Merge pull request #1122 from google/rev-0.22.2
dfa9b99a4 Revise to 0.22.2.
4cb1da848 Merge pull request #1120 from chbaker0/main
79afb97d9 Replace lingering tempdir usages with tempfile
f945331a3 Merge pull request #1118 from google/fix-test-fixed-num
5a8b28751 Merge pull request #1117 from google/docs-tweaks
b5486faa1 Merge pull request #1109 from bsilver8192/bindgen-skip-rustfmt
f62c17273 Fix faulty test_fixed_num test.
ad954fa72 Minor doc updates.
eaa1f8737 Leave bindgen enabled when logging is
bdff5db56 Merge pull request #1110 from bsilver8192/subclass-std
922f98be4 Merge pull request #1111 from bsilver8192/subclass-unsafe
bfbcc6b94 Merge pull request #1114 from google/rev-0.22.1
4f68a2e59 Merge pull request #1112 from bsilver8192/subclass-upcast-uniqueptr
993c5705b Revise to 0.22.1.
7bf667bbf Add a function to upcast UniquePtr
733d751a2 Fix clippy and docs
8023cee43 Fix and test subclass without `safety!(unsafe)`
4ae4d47e4 Fix and test subclasses with C++ std in scope
c50b1ee7e Tell bindgen to skip rustfmt
f9b24b90e Merge pull request #1107 from google/reject-anon-namespace-typedefs
070c9755d Merge pull request #1093 from google/always-output-rs
8eb71c5e7 Merge pull request #1095 from google/issue-1094
c86f1ce7e Reject forward declared nested types.
c118dba64 Merge branch 'main' into reject-anon-namespace-typedefs
243079997 Merge pull request #1108 from google/reject-type-param-typedefs
f803c3ba5 Reject type params - fixes #1098
f3381ba52 Reject typedefs to anon namespaces.
669d932a7 Merge pull request #1106 from google/lotsa-failing-tests
f0e8487fe Marking tests as ignored.
524c2bbfc Add tests for multiple issues.
67e16ac2a Merge branch 'main' of github.com:google/autocxx into always-output-rs
5f62daf3f Merge pull request #1104 from google/roll-cxx
43ee55ca2 Further upgrade from 1.0.67 to 1.0.68
e29e3c899 Merge pull request #1100 from bsilver8192/extern_cpp_type-namespace
d2c8edef4 Merge pull request #1101 from google/fix-1081
094dbd957 Roll cxx minimal version.
94c39f35b Merge pull request #1102 from google/fix-book-build
8764f1218 Alter mdbook-mermaid installation.
85543656f Test for issue 1081
b170df056 Fix and test extern_cpp_type with type in a C++ namespace
e4b56dd49 Fix gen tests.
5457e615d Fix #1092.
git-subtree-dir: third_party/autocxx
git-subtree-split: c35090b754619531b4eebdf4d8b583db72349943
Signed-off-by: Brian Silverman <bsilver16384@gmail.com>
Change-Id: Ia34285bc1c30f7e3c71fa9e7b677a58902648843
diff --git a/integration-tests/tests/integration_test.rs b/integration-tests/tests/integration_test.rs
index 2a3340a..16c792b8 100644
--- a/integration-tests/tests/integration_test.rs
+++ b/integration-tests/tests/integration_test.rs
@@ -16,8 +16,8 @@
},
};
use autocxx_integration_tests::{
- directives_from_lists, do_run_test, do_run_test_manual, run_test, run_test_ex,
- run_test_expect_fail, run_test_expect_fail_ex, TestError,
+ directives_from_lists, do_run_test, do_run_test_manual, run_generate_all_test, run_test,
+ run_test_ex, run_test_expect_fail, run_test_expect_fail_ex, TestError,
};
use indoc::indoc;
use itertools::Itertools;
@@ -3541,20 +3541,7 @@
template <class _Ty>
using _Remove_cvref_t = remove_cv_t<remove_reference_t<_Ty>>;
"};
-
- let rs = quote! {};
-
- run_test_ex(
- "",
- hdr,
- rs,
- quote! {
- generate_all!()
- },
- None,
- None,
- None,
- );
+ run_generate_all_test(hdr);
}
#[test]
@@ -5044,15 +5031,7 @@
inline void a() {}
};
"};
- run_test_ex(
- "",
- hdr,
- quote! {},
- quote! { generate_all!() },
- None,
- None,
- None,
- );
+ run_generate_all_test(hdr);
}
#[test]
@@ -5941,6 +5920,7 @@
None,
None,
None,
+ "unsafe_ffi",
) {
Err(TestError::CppBuild(_)) => {} // be sure this fails due to a static_assert
// rather than some runtime problem
@@ -6232,20 +6212,7 @@
typedef bitset<1> mybitset;
"};
-
- let rs = quote! {};
-
- run_test_ex(
- "",
- hdr,
- rs,
- quote! {
- generate_all!()
- },
- None,
- None,
- None,
- );
+ run_generate_all_test(hdr);
}
#[test]
@@ -6433,18 +6400,7 @@
typedef std::a<b<d>::c, int, int> e;
};
"};
- let rs = quote! {};
- run_test_ex(
- "",
- hdr,
- rs,
- quote! {
- generate_all!()
- },
- None,
- None,
- None,
- );
+ run_generate_all_test(hdr);
}
#[test]
@@ -6505,18 +6461,7 @@
}
typedef char daft;
"};
- let rs = quote! {};
- run_test_ex(
- "",
- hdr,
- rs,
- quote! {
- generate_all!()
- },
- None,
- None,
- None,
- );
+ run_generate_all_test(hdr);
}
#[test]
@@ -6738,6 +6683,50 @@
}
#[test]
+/// Tests extern_cpp_type with a type inside a namespace.
+fn test_extern_cpp_type_namespace() {
+ let hdr = indoc! {"
+ #include <cstdint>
+ namespace b {
+ struct B {
+ B() {}
+ };
+ } // namespace b
+ struct A {
+ A() {}
+ b::B make_b() { return b::B(); }
+ };
+ "};
+ let hexathorpe = Token);
+ let rs = quote! {
+ pub mod b {
+ autocxx::include_cpp! {
+ #hexathorpe include "input.h"
+ safety!(unsafe_ffi)
+ name!(ffi_b)
+ generate_pod!("b::B")
+ }
+ pub use ffi_b::b::B;
+ }
+ pub mod a {
+ autocxx::include_cpp! {
+ #hexathorpe include "input.h"
+ safety!(unsafe_ffi)
+ name!(ffi_a)
+ generate_pod!("A")
+ extern_cpp_type!("b::B", crate::b::B)
+ }
+ pub use ffi_a::A;
+ }
+ fn main() {
+ use autocxx::prelude::*;
+ let _ = crate::a::A::new().within_unique_ptr().as_mut().unwrap().make_b();
+ }
+ };
+ do_run_test_manual("", hdr, rs, None, None).unwrap();
+}
+
+#[test]
#[ignore] // because we currently require UniquePtrTarget which this can't implement
fn test_extern_cpp_type_manual() {
let hdr = indoc! {"
@@ -7600,6 +7589,49 @@
}
#[test]
+/// Tests the Rust code generated for subclasses when there's a `std` module in scope representing
+/// the C++ `std` namespace. This breaks if any of the generated Rust code fails to fully qualify
+/// its references to the Rust `std`.
+fn test_subclass_with_std() {
+ let hdr = indoc! {"
+ #include <cstdint>
+ #include <chrono>
+
+ class Observer {
+ public:
+ Observer() {}
+ virtual void foo() const {}
+ virtual ~Observer() {}
+
+ void unused(std::chrono::nanoseconds) {}
+ };
+ "};
+ run_test_ex(
+ "",
+ hdr,
+ quote! {
+ let obs = MyObserver::new_rust_owned(MyObserver { a: 3, cpp_peer: Default::default() });
+ obs.borrow().foo();
+ },
+ quote! {
+ subclass!("Observer",MyObserver)
+ },
+ None,
+ None,
+ Some(quote! {
+ use autocxx::subclass::CppSubclass;
+ use ffi::Observer_methods;
+ #[autocxx::subclass::subclass]
+ pub struct MyObserver {
+ a: u32
+ }
+ impl Observer_methods for MyObserver {
+ }
+ }),
+ );
+}
+
+#[test]
fn test_two_subclasses() {
let hdr = indoc! {"
#include <cstdint>
@@ -7704,6 +7736,54 @@
}
#[test]
+fn test_subclass_no_safety() {
+ let hdr = indoc! {"
+ #include <cstdint>
+
+ class Observer {
+ public:
+ Observer() {}
+ virtual void foo() = 0;
+ virtual ~Observer() {}
+ };
+ "};
+ let hexathorpe = Token);
+ let unexpanded_rust = quote! {
+ use autocxx::prelude::*;
+
+ include_cpp!(
+ #hexathorpe include "input.h"
+ subclass!("Observer",MyObserver)
+ );
+
+ use ffi::Observer_methods;
+ #hexathorpe [autocxx::subclass::subclass]
+ pub struct MyObserver;
+ impl Observer_methods for MyObserver {
+ unsafe fn foo(&mut self) {}
+ }
+
+ use autocxx::subclass::{CppSubclass, CppPeerConstructor, CppSubclassRustPeerHolder};
+ use cxx::UniquePtr;
+ impl CppPeerConstructor<ffi::MyObserverCpp> for MyObserver {
+ fn make_peer(
+ &mut self,
+ peer_holder: CppSubclassRustPeerHolder<Self>,
+ ) -> UniquePtr<ffi::MyObserverCpp> {
+ UniquePtr::emplace(unsafe { ffi::MyObserverCpp::new(peer_holder) })
+ }
+ }
+
+ fn main() {
+ let obs = MyObserver::new_rust_owned(MyObserver { cpp_peer: Default::default() });
+ unsafe { obs.borrow_mut().foo() };
+ }
+ };
+
+ do_run_test_manual("", hdr, unexpanded_rust, None, None).unwrap()
+}
+
+#[test]
fn test_pv_protected_constructor() {
let hdr = indoc! {"
#include <cstdint>
@@ -8291,6 +8371,74 @@
}
#[test]
+fn test_pv_subclass_as_superclass() {
+ let hdr = indoc! {"
+ #include <cstdint>
+ #include <memory>
+
+ class TestObserver {
+ public:
+ TestObserver() {}
+ virtual void a() const = 0;
+ virtual ~TestObserver() {}
+ };
+
+ inline void call_observer(std::unique_ptr<TestObserver> obs) { obs->a(); }
+ "};
+ run_test_ex(
+ "",
+ hdr,
+ quote! {
+ use autocxx::subclass::CppSubclass;
+ let obs = MyTestObserver::new_cpp_owned(
+ MyTestObserver::default()
+ );
+ let obs = MyTestObserver::as_TestObserver_unique_ptr(obs);
+ assert!(!Lazy::force(&STATUS).lock().unwrap().dropped);
+ ffi::call_observer(obs);
+ assert!(Lazy::force(&STATUS).lock().unwrap().sub_a_called);
+ assert!(Lazy::force(&STATUS).lock().unwrap().dropped);
+ *Lazy::force(&STATUS).lock().unwrap() = Default::default();
+ },
+ quote! {
+ generate!("call_observer")
+ subclass!("TestObserver",MyTestObserver)
+ },
+ None,
+ None,
+ Some(quote! {
+ use once_cell::sync::Lazy;
+ use std::sync::Mutex;
+
+ use ffi::TestObserver_methods;
+ #[autocxx::subclass::subclass]
+ #[derive(Default)]
+ pub struct MyTestObserver {
+ }
+ impl TestObserver_methods for MyTestObserver {
+ fn a(&self) {
+ assert!(!Lazy::force(&STATUS).lock().unwrap().dropped);
+ Lazy::force(&STATUS).lock().unwrap().sub_a_called = true;
+ }
+ }
+ impl Drop for MyTestObserver {
+ fn drop(&mut self) {
+ Lazy::force(&STATUS).lock().unwrap().dropped = true;
+ }
+ }
+
+ #[derive(Default)]
+ struct Status {
+ sub_a_called: bool,
+ dropped: bool,
+ }
+
+ static STATUS: Lazy<Mutex<Status>> = Lazy::new(|| Mutex::new(Status::default()));
+ }),
+ );
+}
+
+#[test]
fn test_cycle_nonpod_simple() {
let hdr = indoc! {"
#include <string>
@@ -10925,15 +11073,7 @@
d e();
};
"};
- run_test_ex(
- "",
- hdr,
- quote! {},
- quote! { generate_all!() },
- None,
- None,
- None,
- );
+ run_generate_all_test(hdr);
}
#[test]
@@ -10948,15 +11088,7 @@
};
} // namespace
"};
- run_test_ex(
- "",
- hdr,
- quote! {},
- quote! { generate_all!() },
- None,
- None,
- None,
- );
+ run_generate_all_test(hdr);
}
#[test]
@@ -11015,15 +11147,7 @@
};
} // namespace a
"};
- run_test_ex(
- "",
- hdr,
- quote! {},
- quote! { generate_all!() },
- None,
- None,
- None,
- );
+ run_generate_all_test(hdr);
}
#[test]
@@ -11044,15 +11168,7 @@
_CharT b;
};
"};
- run_test_ex(
- "",
- hdr,
- quote! {},
- quote! { generate_all!() },
- None,
- None,
- None,
- );
+ run_generate_all_test(hdr);
}
#[test]
@@ -11063,15 +11179,7 @@
b c;
};
"};
- run_test_ex(
- "",
- hdr,
- quote! {},
- quote! { generate_all!() },
- None,
- None,
- None,
- );
+ run_generate_all_test(hdr);
}
#[test]
@@ -11086,15 +11194,7 @@
}
}
"};
- run_test_ex(
- "",
- hdr,
- quote! {},
- quote! { generate_all!() },
- None,
- None,
- None,
- );
+ run_generate_all_test(hdr);
}
#[test]
@@ -11116,15 +11216,171 @@
} // namespace
} // namespace a
"};
- run_test_ex(
- "",
- hdr,
- quote! {},
- quote! { generate_all!() },
- None,
- None,
- None,
- );
+ run_generate_all_test(hdr);
+}
+
+/// The problem here is that 'g' doesn't get annotated with
+/// the unused_template semantic attribute.
+/// This seems to be because both g and f have template
+/// parameters, so they're all "used", but effectively cancel
+/// out and thus bindgen generates
+/// pub type g = root::b::f;
+/// So, what we should do here is spot any typedef depending
+/// on a template which takes template args, and reject that too.
+/// Probably.
+#[test]
+#[ignore] // https://github.com/google/autocxx/pull/1094
+fn test_issue_1094() {
+ let hdr = indoc! {"
+ namespace {
+ typedef int a;
+ }
+ namespace b {
+ template <typename> struct c;
+ template <typename d, d e> using f = __make_integer_seq<c, d, e>;
+ template <a e> using g = f<a, e>;
+ } // namespace b
+ "};
+ run_generate_all_test(hdr);
+}
+
+#[test]
+fn test_issue_1096a() {
+ let hdr = indoc! {"
+ namespace a {
+ class b {
+ class c;
+ };
+ } // namespace a
+ "};
+ run_generate_all_test(hdr);
+}
+
+#[test]
+fn test_issue_1096b() {
+ let hdr = indoc! {"
+ namespace a {
+ class b {
+ public:
+ class c;
+ };
+ } // namespace a
+ "};
+ run_generate_all_test(hdr);
+}
+
+#[test]
+fn test_issue_1096c() {
+ let hdr = indoc! {"
+ namespace a {
+ class b {
+ public:
+ class c {
+ public:
+ int d;
+ };
+ };
+ } // namespace a
+ "};
+ run_generate_all_test(hdr);
+}
+
+#[test]
+fn test_issue_1096d() {
+ let hdr = indoc! {"
+ namespace a {
+ class b {
+ private:
+ class c {
+ public:
+ int d;
+ };
+ };
+ } // namespace a
+ "};
+ run_generate_all_test(hdr);
+}
+
+#[test]
+fn test_issue_1096e() {
+ let hdr = indoc! {"
+ namespace a {
+ class b {
+ private:
+ enum c {
+ D,
+ };
+ };
+ } // namespace a
+ "};
+ run_generate_all_test(hdr);
+}
+
+/// Unclear why minimization resulted in this particular test case.
+#[test]
+#[ignore] // https://github.com/google/autocxx/pull/1097
+fn test_issue_1097() {
+ let hdr = indoc! {"
+ namespace rust {
+ inline namespace a {
+ class Str {
+ public:
+ ~Str();
+ };
+ } // namespace a
+ } // namespace rust
+ "};
+ run_generate_all_test(hdr);
+}
+
+#[test]
+fn test_issue_1098a() {
+ let hdr = indoc! {"
+ namespace {
+ namespace {
+ template <typename _CharT> class a {
+ typedef _CharT b;
+ b c;
+ };
+ template <typename _CharT> class d : a<_CharT> {};
+ } // namespace
+ } // namespace
+ "};
+ run_generate_all_test(hdr);
+}
+
+/// Need to spot structs like this:
+/// pub struct d<_CharT> {
+/// _base: root::a<_CharT>,
+/// }
+/// and not create concrete types where the inner type is something from
+/// the outer context.
+#[test]
+fn test_issue_1098b() {
+ let hdr = indoc! {"
+ template <typename _CharT> class a {
+ typedef _CharT b;
+ b c;
+ };
+ template <typename _CharT> class d : a<_CharT> {};
+ "};
+ run_generate_all_test(hdr);
+}
+
+#[test]
+fn test_issue_1098c() {
+ let hdr = indoc! {"
+ namespace {
+ namespace {
+ struct A {
+ int a;
+ };
+ typedef A B;
+ } // namespace
+ } // namespace
+ inline void take_b(const B&) {}
+ "};
+ run_generate_all_test(hdr);
}
#[test]
@@ -11185,6 +11441,58 @@
run_test("", hdr, rs, &["RenderFrameHost"], &[]);
}
+#[test]
+fn test_issue_1081() {
+ let hdr = indoc! {"
+ namespace libtorrent {
+ char version;
+ }
+ namespace libtorrent {
+ struct session;
+ }
+ "};
+ let rs = quote! {};
+ run_test("", hdr, rs, &["libtorrent::session"], &[]);
+}
+
+#[test]
+#[ignore] // This test passes under all normal builds. However
+ // it triggers a stack use-after-return in older versions of
+ // libclang which is only detected under ASAN (obviously it
+ // sometimes causes crashes the rest of the time).
+ // This UaR does not occur when the same code is processed
+ // with a HEAD version of clang itself as of June 2022. This
+ // may mean that the UaR has been fixed in later versions of
+ // the clang code, or that it only occurs when the code is used
+ // in a libclang context (not a plain clang compilation context).
+ // If the problem recurs, we should work out which of these is
+ // the case.
+fn test_issue_1125() {
+ let hdr = indoc! {"
+ namespace {
+ namespace {
+ template <class a> class b {
+ typedef a c;
+ struct {
+ c : sizeof(c);
+ };
+ };
+ } // namespace
+ } // namespace
+ "};
+ run_test_ex(
+ "",
+ hdr,
+ quote! {},
+ quote! {
+ generate_all!()
+ },
+ make_cpp17_adder(),
+ None,
+ None,
+ );
+}
+
// Yet to test:
// - Ifdef
// - Out param pointers