Merging upstream version 1.71.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

139 files changed, 2457 insertions, 0 deletions

diff --git a/vendor/cxx/tests/BUCK b/vendor/cxx/tests/BUCK
new file mode 100644
index 000000000..865eebc93
--- /dev/null
+++ b/vendor/cxx/tests/BUCK
@@ -0,0 +1,57 @@
+load("//tools/buck:rust_cxx_bridge.bzl", "rust_cxx_bridge")
+
+rust_test(
+    name = "test",
+    srcs = ["test.rs"],
+    edition = "2018",
+    deps = [
+        ":ffi",
+        "//:cxx",
+    ],
+)
+
+rust_library(
+    name = "ffi",
+    srcs = [
+        "ffi/cast.rs",
+        "ffi/lib.rs",
+        "ffi/module.rs",
+    ],
+    crate = "cxx_test_suite",
+    edition = "2018",
+    deps = [
+        ":impl",
+        "//:cxx",
+    ],
+)
+
+cxx_library(
+    name = "impl",
+    srcs = [
+        "ffi/tests.cc",
+        ":bridge/source",
+        ":module/source",
+    ],
+    exported_deps = ["//:core"],
+    exported_headers = {
+        "ffi/lib.rs.h": ":bridge/header",
+        "ffi/module.rs.h": ":module/header",
+        "ffi/tests.h": "ffi/tests.h",
+    },
+)
+
+rust_cxx_bridge(
+    name = "bridge",
+    src = "ffi/lib.rs",
+    deps = [
+        ":impl",
+    ],
+)
+
+rust_cxx_bridge(
+    name = "module",
+    src = "ffi/module.rs",
+    deps = [
+        ":impl",
+    ],
+)
diff --git a/vendor/cxx/tests/BUILD b/vendor/cxx/tests/BUILD
new file mode 100644
index 000000000..3c25d9633
--- /dev/null
+++ b/vendor/cxx/tests/BUILD
@@ -0,0 +1,55 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+load("//tools/bazel:rust_cxx_bridge.bzl", "rust_cxx_bridge")
+
+rust_test(
+    name = "test",
+    size = "small",
+    srcs = ["test.rs"],
+    edition = "2018",
+    deps = [
+        ":cxx_test_suite",
+        "//:cxx",
+    ],
+)
+
+rust_library(
+    name = "cxx_test_suite",
+    srcs = [
+        "ffi/cast.rs",
+        "ffi/lib.rs",
+        "ffi/module.rs",
+    ],
+    edition = "2018",
+    deps = [
+        ":impl",
+        "//:cxx",
+    ],
+)
+
+cc_library(
+    name = "impl",
+    srcs = [
+        "ffi/tests.cc",
+        ":bridge/source",
+        ":module/source",
+    ],
+    hdrs = ["ffi/tests.h"],
+    deps = [
+        ":bridge/include",
+        ":module/include",
+        "//:core",
+    ],
+)
+
+rust_cxx_bridge(
+    name = "bridge",
+    src = "ffi/lib.rs",
+    deps = [":impl"],
+)
+
+rust_cxx_bridge(
+    name = "module",
+    src = "ffi/module.rs",
+    deps = [":impl"],
+)
diff --git a/vendor/cxx/tests/compiletest.rs b/vendor/cxx/tests/compiletest.rs
new file mode 100644
index 000000000..cd58514f1
--- /dev/null
+++ b/vendor/cxx/tests/compiletest.rs
@@ -0,0 +1,9 @@
+#[allow(unused_attributes)]
+#[rustversion::attr(not(nightly), ignore)]
+#[cfg_attr(skip_ui_tests, ignore)]
+#[cfg_attr(miri, ignore)]
+#[test]
+fn ui() {
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/*.rs");
+}
diff --git a/vendor/cxx/tests/cxx_gen.rs b/vendor/cxx/tests/cxx_gen.rs
new file mode 100644
index 000000000..e91675d9d
--- /dev/null
+++ b/vendor/cxx/tests/cxx_gen.rs
@@ -0,0 +1,34 @@
+#![allow(clippy::field_reassign_with_default)]
+
+use cxx_gen::{generate_header_and_cc, Opt};
+use std::str;
+
+const BRIDGE0: &str = r#"
+    #[cxx::bridge]
+    mod ffi {
+        unsafe extern "C++" {
+            pub fn do_cpp_thing(foo: &str);
+        }
+    }
+"#;
+
+#[test]
+fn test_extern_c_function() {
+    let opt = Opt::default();
+    let source = BRIDGE0.parse().unwrap();
+    let generated = generate_header_and_cc(source, &opt).unwrap();
+    let output = str::from_utf8(&generated.implementation).unwrap();
+    // To avoid continual breakage we won't test every byte.
+    // Let's look for the major features.
+    assert!(output.contains("void cxxbridge1$do_cpp_thing(::rust::Str foo)"));
+}
+
+#[test]
+fn test_impl_annotation() {
+    let mut opt = Opt::default();
+    opt.cxx_impl_annotations = Some("ANNOTATION".to_owned());
+    let source = BRIDGE0.parse().unwrap();
+    let generated = generate_header_and_cc(source, &opt).unwrap();
+    let output = str::from_utf8(&generated.implementation).unwrap();
+    assert!(output.contains("ANNOTATION void cxxbridge1$do_cpp_thing(::rust::Str foo)"));
+}
diff --git a/vendor/cxx/tests/cxx_string.rs b/vendor/cxx/tests/cxx_string.rs
new file mode 100644
index 000000000..349a4e1f1
--- /dev/null
+++ b/vendor/cxx/tests/cxx_string.rs
@@ -0,0 +1,41 @@
+use cxx::{let_cxx_string, CxxString};
+use std::fmt::Write as _;
+
+#[test]
+fn test_async_cxx_string() {
+    async fn f() {
+        let_cxx_string!(s = "...");
+
+        async fn g(_: &CxxString) {}
+        g(&s).await;
+    }
+
+    // https://github.com/dtolnay/cxx/issues/693
+    fn assert_send(_: impl Send) {}
+    assert_send(f());
+}
+
+#[test]
+fn test_debug() {
+    let_cxx_string!(s = "x\"y\'z");
+
+    assert_eq!(format!("{:?}", s), r#""x\"y'z""#);
+}
+
+#[test]
+fn test_fmt_write() {
+    let_cxx_string!(s = "");
+
+    let name = "world";
+    write!(s, "Hello, {name}!").unwrap();
+    assert_eq!(s.to_str(), Ok("Hello, world!"));
+}
+
+#[test]
+fn test_io_write() {
+    let_cxx_string!(s = "");
+    let mut reader: &[u8] = b"Hello, world!";
+
+    std::io::copy(&mut reader, &mut s).unwrap();
+    assert_eq!(s.to_str(), Ok("Hello, world!"));
+}
diff --git a/vendor/cxx/tests/test.rs b/vendor/cxx/tests/test.rs
new file mode 100644
index 000000000..bcf0a2cd1
--- /dev/null
+++ b/vendor/cxx/tests/test.rs
@@ -0,0 +1,380 @@
+#![allow(
+    clippy::assertions_on_constants,
+    clippy::assertions_on_result_states,
+    clippy::cast_possible_truncation,
+    clippy::cast_possible_wrap,
+    clippy::float_cmp,
+    clippy::needless_pass_by_value,
+    clippy::unit_cmp,
+    clippy::unseparated_literal_suffix
+)]
+
+use cxx::SharedPtr;
+use cxx_test_suite::module::ffi2;
+use cxx_test_suite::{cast, ffi, R};
+use std::cell::Cell;
+use std::ffi::CStr;
+
+thread_local! {
+    static CORRECT: Cell<bool> = Cell::new(false);
+}
+
+#[no_mangle]
+extern "C" fn cxx_test_suite_set_correct() {
+    CORRECT.with(|correct| correct.set(true));
+}
+
+macro_rules! check {
+    ($run:expr) => {{
+        CORRECT.with(|correct| correct.set(false));
+        $run;
+        assert!(CORRECT.with(Cell::get), "{}", stringify!($run));
+    }};
+}
+
+#[test]
+fn test_c_return() {
+    let shared = ffi::Shared { z: 2020 };
+    let ns_shared = ffi::AShared { z: 2020 };
+    let nested_ns_shared = ffi::ABShared { z: 2020 };
+
+    assert_eq!(2020, ffi::c_return_primitive());
+    assert_eq!(2020, ffi::c_return_shared().z);
+    assert_eq!(2020, ffi::c_return_box().0);
+    ffi::c_return_unique_ptr();
+    ffi2::c_return_ns_unique_ptr();
+    assert_eq!(2020, *ffi::c_return_ref(&shared));
+    assert_eq!(2020, *ffi::c_return_ns_ref(&ns_shared));
+    assert_eq!(2020, *ffi::c_return_nested_ns_ref(&nested_ns_shared));
+    assert_eq!("2020", ffi::c_return_str(&shared));
+    assert_eq!(
+        b"2020\0",
+        cast::c_char_to_unsigned(ffi::c_return_slice_char(&shared)),
+    );
+    assert_eq!("2020", ffi::c_return_rust_string());
+    assert_eq!("Hello \u{fffd}World", ffi::c_return_rust_string_lossy());
+    assert_eq!("2020", ffi::c_return_unique_ptr_string().to_str().unwrap());
+    assert_eq!(4, ffi::c_return_unique_ptr_vector_u8().len());
+    assert_eq!(
+        200_u8,
+        ffi::c_return_unique_ptr_vector_u8().into_iter().sum(),
+    );
+    assert_eq!(
+        200.5_f64,
+        ffi::c_return_unique_ptr_vector_f64().into_iter().sum(),
+    );
+    assert_eq!(2, ffi::c_return_unique_ptr_vector_shared().len());
+    assert_eq!(
+        2021_usize,
+        ffi::c_return_unique_ptr_vector_shared()
+            .into_iter()
+            .map(|o| o.z)
+            .sum(),
+    );
+    assert_eq!(b"\x02\0\x02\0"[..], ffi::c_return_rust_vec_u8());
+    assert_eq!([true, true, false][..], ffi::c_return_rust_vec_bool());
+    assert_eq!(2020, ffi::c_return_identity(2020));
+    assert_eq!(2021, ffi::c_return_sum(2020, 1));
+    match ffi::c_return_enum(0) {
+        enm @ ffi::Enum::AVal => assert_eq!(0, enm.repr),
+        _ => assert!(false),
+    }
+    match ffi::c_return_enum(1) {
+        enm @ ffi::Enum::BVal => assert_eq!(2020, enm.repr),
+        _ => assert!(false),
+    }
+    match ffi::c_return_enum(2021) {
+        enm @ ffi::Enum::LastVal => assert_eq!(2021, enm.repr),
+        _ => assert!(false),
+    }
+    match ffi::c_return_ns_enum(0) {
+        enm @ ffi::AEnum::AAVal => assert_eq!(0, enm.repr),
+        _ => assert!(false),
+    }
+    match ffi::c_return_nested_ns_enum(0) {
+        enm @ ffi::ABEnum::ABAVal => assert_eq!(0, enm.repr),
+        _ => assert!(false),
+    }
+}
+
+#[test]
+fn test_c_try_return() {
+    assert_eq!((), ffi::c_try_return_void().unwrap());
+    assert_eq!(2020, ffi::c_try_return_primitive().unwrap());
+    assert_eq!(
+        "logic error",
+        ffi::c_fail_return_primitive().unwrap_err().what(),
+    );
+    assert_eq!(2020, ffi::c_try_return_box().unwrap().0);
+    assert_eq!("2020", *ffi::c_try_return_ref(&"2020".to_owned()).unwrap());
+    assert_eq!("2020", ffi::c_try_return_str("2020").unwrap());
+    assert_eq!(b"2020", ffi::c_try_return_sliceu8(b"2020").unwrap());
+    assert_eq!("2020", ffi::c_try_return_rust_string().unwrap());
+    assert_eq!("2020", &*ffi::c_try_return_unique_ptr_string().unwrap());
+}
+
+#[test]
+fn test_c_take() {
+    let unique_ptr = ffi::c_return_unique_ptr();
+    let unique_ptr_ns = ffi2::c_return_ns_unique_ptr();
+
+    check!(ffi::c_take_primitive(2020));
+    check!(ffi::c_take_shared(ffi::Shared { z: 2020 }));
+    check!(ffi::c_take_ns_shared(ffi::AShared { z: 2020 }));
+    check!(ffi::ns_c_take_ns_shared(ffi::AShared { z: 2020 }));
+    check!(ffi::c_take_nested_ns_shared(ffi::ABShared { z: 2020 }));
+    check!(ffi::c_take_box(Box::new(R(2020))));
+    check!(ffi::c_take_ref_c(&unique_ptr));
+    check!(ffi2::c_take_ref_ns_c(&unique_ptr_ns));
+    check!(cxx_test_suite::module::ffi::c_take_unique_ptr(unique_ptr));
+    check!(ffi::c_take_str("2020"));
+    check!(ffi::c_take_slice_char(cast::unsigned_to_c_char(b"2020")));
+    check!(ffi::c_take_slice_shared(&[
+        ffi::Shared { z: 2020 },
+        ffi::Shared { z: 2021 },
+    ]));
+    let shared_sort_slice = &mut [
+        ffi::Shared { z: 2 },
+        ffi::Shared { z: 0 },
+        ffi::Shared { z: 7 },
+        ffi::Shared { z: 4 },
+    ];
+    check!(ffi::c_take_slice_shared_sort(shared_sort_slice));
+    assert_eq!(shared_sort_slice[0].z, 0);
+    assert_eq!(shared_sort_slice[1].z, 2);
+    assert_eq!(shared_sort_slice[2].z, 4);
+    assert_eq!(shared_sort_slice[3].z, 7);
+    let r_sort_slice = &mut [R(2020), R(2050), R(2021)];
+    check!(ffi::c_take_slice_r(r_sort_slice));
+    check!(ffi::c_take_slice_r_sort(r_sort_slice));
+    assert_eq!(r_sort_slice[0].0, 2020);
+    assert_eq!(r_sort_slice[1].0, 2021);
+    assert_eq!(r_sort_slice[2].0, 2050);
+    check!(ffi::c_take_rust_string("2020".to_owned()));
+    check!(ffi::c_take_unique_ptr_string(
+        ffi::c_return_unique_ptr_string()
+    ));
+    let mut vector = ffi::c_return_unique_ptr_vector_u8();
+    assert_eq!(vector.pin_mut().pop(), Some(9));
+    check!(ffi::c_take_unique_ptr_vector_u8(vector));
+    let mut vector = ffi::c_return_unique_ptr_vector_f64();
+    vector.pin_mut().push(9.0);
+    check!(ffi::c_take_unique_ptr_vector_f64(vector));
+    let mut vector = ffi::c_return_unique_ptr_vector_shared();
+    vector.pin_mut().push(ffi::Shared { z: 9 });
+    check!(ffi::c_take_unique_ptr_vector_shared(vector));
+    check!(ffi::c_take_ref_vector(&ffi::c_return_unique_ptr_vector_u8()));
+    let test_vec = [86_u8, 75_u8, 30_u8, 9_u8].to_vec();
+    check!(ffi::c_take_rust_vec(test_vec.clone()));
+    check!(ffi::c_take_rust_vec_index(test_vec.clone()));
+    let shared_test_vec = vec![ffi::Shared { z: 1010 }, ffi::Shared { z: 1011 }];
+    check!(ffi::c_take_rust_vec_shared(shared_test_vec.clone()));
+    check!(ffi::c_take_rust_vec_shared_index(shared_test_vec.clone()));
+    check!(ffi::c_take_rust_vec_shared_push(shared_test_vec.clone()));
+    check!(ffi::c_take_rust_vec_shared_truncate(
+        shared_test_vec.clone()
+    ));
+    check!(ffi::c_take_rust_vec_shared_clear(shared_test_vec.clone()));
+    check!(ffi::c_take_rust_vec_shared_forward_iterator(
+        shared_test_vec,
+    ));
+    let shared_sort_vec = vec![
+        ffi::Shared { z: 2 },
+        ffi::Shared { z: 0 },
+        ffi::Shared { z: 7 },
+        ffi::Shared { z: 4 },
+    ];
+    check!(ffi::c_take_rust_vec_shared_sort(shared_sort_vec));
+    check!(ffi::c_take_ref_rust_vec(&test_vec));
+    check!(ffi::c_take_ref_rust_vec_index(&test_vec));
+    check!(ffi::c_take_ref_rust_vec_copy(&test_vec));
+    check!(ffi::c_take_ref_shared_string(&ffi::SharedString {
+        msg: "2020".to_owned()
+    }));
+    let ns_shared_test_vec = vec![ffi::AShared { z: 1010 }, ffi::AShared { z: 1011 }];
+    check!(ffi::c_take_rust_vec_ns_shared(ns_shared_test_vec));
+    let nested_ns_shared_test_vec = vec![ffi::ABShared { z: 1010 }, ffi::ABShared { z: 1011 }];
+    check!(ffi::c_take_rust_vec_nested_ns_shared(
+        nested_ns_shared_test_vec
+    ));
+
+    check!(ffi::c_take_enum(ffi::Enum::AVal));
+    check!(ffi::c_take_ns_enum(ffi::AEnum::AAVal));
+    check!(ffi::c_take_nested_ns_enum(ffi::ABEnum::ABAVal));
+}
+
+#[test]
+fn test_c_callback() {
+    fn callback(s: String) -> usize {
+        if s == "2020" {
+            cxx_test_suite_set_correct();
+        }
+        0
+    }
+
+    #[allow(clippy::ptr_arg)]
+    fn callback_ref(s: &String) {
+        if s == "2020" {
+            cxx_test_suite_set_correct();
+        }
+    }
+
+    fn callback_mut(s: &mut String) {
+        if s == "2020" {
+            cxx_test_suite_set_correct();
+        }
+    }
+
+    check!(ffi::c_take_callback(callback));
+    check!(ffi::c_take_callback_ref(callback_ref));
+    check!(ffi::c_take_callback_ref_lifetime(callback_ref));
+    check!(ffi::c_take_callback_mut(callback_mut));
+}
+
+#[test]
+fn test_c_call_r() {
+    fn cxx_run_test() {
+        extern "C" {
+            fn cxx_run_test() -> *const i8;
+        }
+        let failure = unsafe { cxx_run_test() };
+        if !failure.is_null() {
+            let msg = unsafe { CStr::from_ptr(failure as *mut std::os::raw::c_char) };
+            eprintln!("{}", msg.to_string_lossy());
+        }
+    }
+    check!(cxx_run_test());
+}
+
+#[test]
+fn test_c_method_calls() {
+    let mut unique_ptr = ffi::c_return_unique_ptr();
+
+    let old_value = unique_ptr.get();
+    assert_eq!(2020, old_value);
+    assert_eq!(2021, unique_ptr.pin_mut().set(2021));
+    assert_eq!(2021, unique_ptr.get());
+    assert_eq!(2021, unique_ptr.get2());
+    assert_eq!(2021, *unique_ptr.getRef());
+    assert_eq!(2021, *unique_ptr.pin_mut().getMut());
+    assert_eq!(2022, unique_ptr.pin_mut().set_succeed(2022).unwrap());
+    assert!(unique_ptr.pin_mut().get_fail().is_err());
+    assert_eq!(2021, ffi::Shared { z: 0 }.c_method_on_shared());
+    assert_eq!(2022, *ffi::Shared { z: 2022 }.c_method_ref_on_shared());
+    assert_eq!(2023, *ffi::Shared { z: 2023 }.c_method_mut_on_shared());
+
+    let val = 42;
+    let mut array = ffi::Array {
+        a: [0, 0, 0, 0],
+        b: ffi::Buffer::default(),
+    };
+    array.c_set_array(val);
+    assert_eq!(array.a.len() as i32 * val, array.r_get_array_sum());
+}
+
+#[test]
+fn test_shared_ptr_weak_ptr() {
+    let shared_ptr = ffi::c_return_shared_ptr();
+    let weak_ptr = SharedPtr::downgrade(&shared_ptr);
+    assert_eq!(1, ffi::c_get_use_count(&weak_ptr));
+
+    assert!(!weak_ptr.upgrade().is_null());
+    assert_eq!(1, ffi::c_get_use_count(&weak_ptr));
+
+    drop(shared_ptr);
+    assert_eq!(0, ffi::c_get_use_count(&weak_ptr));
+    assert!(weak_ptr.upgrade().is_null());
+}
+
+#[test]
+fn test_c_ns_method_calls() {
+    let unique_ptr = ffi2::ns_c_return_unique_ptr_ns();
+
+    let old_value = unique_ptr.get();
+    assert_eq!(1000, old_value);
+}
+
+#[test]
+fn test_enum_representations() {
+    assert_eq!(0, ffi::Enum::AVal.repr);
+    assert_eq!(2020, ffi::Enum::BVal.repr);
+    assert_eq!(2021, ffi::Enum::LastVal.repr);
+}
+
+#[test]
+fn test_debug() {
+    assert_eq!("Shared { z: 1 }", format!("{:?}", ffi::Shared { z: 1 }));
+    assert_eq!("BVal", format!("{:?}", ffi::Enum::BVal));
+    assert_eq!("Enum(9)", format!("{:?}", ffi::Enum { repr: 9 }));
+}
+
+#[no_mangle]
+extern "C" fn cxx_test_suite_get_box() -> *mut R {
+    Box::into_raw(Box::new(R(2020usize)))
+}
+
+#[no_mangle]
+unsafe extern "C" fn cxx_test_suite_r_is_correct(r: *const R) -> bool {
+    (*r).0 == 2020
+}
+
+#[test]
+fn test_rust_name_attribute() {
+    assert_eq!("2020", ffi::i32_overloaded_function(2020));
+    assert_eq!("2020", ffi::str_overloaded_function("2020"));
+    let unique_ptr = ffi::c_return_unique_ptr();
+    assert_eq!("2020", unique_ptr.i32_overloaded_method(2020));
+    assert_eq!("2020", unique_ptr.str_overloaded_method("2020"));
+}
+
+#[test]
+fn test_extern_trivial() {
+    let mut d = ffi2::c_return_trivial();
+    check!(ffi2::c_take_trivial_ref(&d));
+    check!(d.c_take_trivial_ref_method());
+    check!(d.c_take_trivial_mut_ref_method());
+    check!(ffi2::c_take_trivial(d));
+    let mut d = ffi2::c_return_trivial_ptr();
+    check!(d.c_take_trivial_ref_method());
+    check!(d.c_take_trivial_mut_ref_method());
+    check!(ffi2::c_take_trivial_ptr(d));
+    cxx::UniquePtr::new(ffi2::D { d: 42 });
+    let d = ffi2::ns_c_return_trivial();
+    check!(ffi2::ns_c_take_trivial(d));
+
+    let g = ffi2::c_return_trivial_ns();
+    check!(ffi2::c_take_trivial_ns_ref(&g));
+    check!(ffi2::c_take_trivial_ns(g));
+    let g = ffi2::c_return_trivial_ns_ptr();
+    check!(ffi2::c_take_trivial_ns_ptr(g));
+    cxx::UniquePtr::new(ffi2::G { g: 42 });
+}
+
+#[test]
+fn test_extern_opaque() {
+    let mut e = ffi2::c_return_opaque_ptr();
+    check!(ffi2::c_take_opaque_ref(e.as_ref().unwrap()));
+    check!(e.c_take_opaque_ref_method());
+    check!(e.pin_mut().c_take_opaque_mut_ref_method());
+    check!(ffi2::c_take_opaque_ptr(e));
+
+    let f = ffi2::c_return_ns_opaque_ptr();
+    check!(ffi2::c_take_opaque_ns_ref(f.as_ref().unwrap()));
+    check!(ffi2::c_take_opaque_ns_ptr(f));
+}
+
+#[test]
+fn test_raw_ptr() {
+    let c = ffi::c_return_mut_ptr(2023);
+    let mut c_unique = unsafe { cxx::UniquePtr::from_raw(c) };
+    assert_eq!(2023, c_unique.pin_mut().set_succeed(2023).unwrap());
+    // c will be dropped as it's now in a UniquePtr
+
+    let c2 = ffi::c_return_mut_ptr(2024);
+    assert_eq!(2024, unsafe { ffi::c_take_const_ptr(c2) });
+    assert_eq!(2024, unsafe { ffi::c_take_mut_ptr(c2) }); // deletes c2
+
+    let c3 = ffi::c_return_const_ptr(2025);
+    assert_eq!(2025, unsafe { ffi::c_take_const_ptr(c3) });
+    assert_eq!(2025, unsafe { ffi::c_take_mut_ptr(c3 as *mut ffi::C) }); // deletes c3
+}
diff --git a/vendor/cxx/tests/ui/array_len_expr.rs b/vendor/cxx/tests/ui/array_len_expr.rs
new file mode 100644
index 000000000..73da57c8f
--- /dev/null
+++ b/vendor/cxx/tests/ui/array_len_expr.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+    struct Shared {
+        arraystr: [String; "13"],
+        arraysub: [String; 15 - 1],
+        arrayzero: [String; 0],
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/array_len_expr.stderr b/vendor/cxx/tests/ui/array_len_expr.stderr
new file mode 100644
index 000000000..c58cfbc2c
--- /dev/null
+++ b/vendor/cxx/tests/ui/array_len_expr.stderr
@@ -0,0 +1,17 @@
+error: array length must be an integer literal
+ --> tests/ui/array_len_expr.rs:4:28
+  |
+4 |         arraystr: [String; "13"],
+  |                            ^^^^
+
+error: unsupported expression, array length must be an integer literal
+ --> tests/ui/array_len_expr.rs:5:28
+  |
+5 |         arraysub: [String; 15 - 1],
+  |                            ^^^^^^
+
+error: array with zero size is not supported
+ --> tests/ui/array_len_expr.rs:6:20
+  |
+6 |         arrayzero: [String; 0],
+  |                    ^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/array_len_suffix.rs b/vendor/cxx/tests/ui/array_len_suffix.rs
new file mode 100644
index 000000000..1e9d514fc
--- /dev/null
+++ b/vendor/cxx/tests/ui/array_len_suffix.rs
@@ -0,0 +1,8 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        fn array() -> [String; 12u16];
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/array_len_suffix.stderr b/vendor/cxx/tests/ui/array_len_suffix.stderr
new file mode 100644
index 000000000..1dde790e8
--- /dev/null
+++ b/vendor/cxx/tests/ui/array_len_suffix.stderr
@@ -0,0 +1,10 @@
+error[E0308]: mismatched types
+ --> tests/ui/array_len_suffix.rs:4:32
+  |
+4 |         fn array() -> [String; 12u16];
+  |                                ^^^^^ expected `usize`, found `u16`
+  |
+help: change the type of the numeric literal from `u16` to `usize`
+  |
+4 |         fn array() -> [String; 12usize];
+  |                                  ~~~~~
diff --git a/vendor/cxx/tests/ui/async_fn.rs b/vendor/cxx/tests/ui/async_fn.rs
new file mode 100644
index 000000000..4e663a0b6
--- /dev/null
+++ b/vendor/cxx/tests/ui/async_fn.rs
@@ -0,0 +1,14 @@
+#[cxx::bridge]
+mod ffi {
+    extern "Rust" {
+        async fn f();
+    }
+
+    extern "C++" {
+        async fn g();
+    }
+}
+
+async fn f() {}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/async_fn.stderr b/vendor/cxx/tests/ui/async_fn.stderr
new file mode 100644
index 000000000..78108650f
--- /dev/null
+++ b/vendor/cxx/tests/ui/async_fn.stderr
@@ -0,0 +1,11 @@
+error: async function is not directly supported yet, but see https://cxx.rs/async.html for a working approach, and https://github.com/pcwalton/cxx-async for some helpers; eventually what you wrote will work but it isn't integrated into the cxx::bridge macro yet
+ --> tests/ui/async_fn.rs:4:9
+  |
+4 |         async fn f();
+  |         ^^^^^^^^^^^^^
+
+error: async function is not directly supported yet, but see https://cxx.rs/async.html for a working approach, and https://github.com/pcwalton/cxx-async for some helpers; eventually what you wrote will work but it isn't integrated into the cxx::bridge macro yet
+ --> tests/ui/async_fn.rs:8:9
+  |
+8 |         async fn g();
+  |         ^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/bad_explicit_impl.rs b/vendor/cxx/tests/ui/bad_explicit_impl.rs
new file mode 100644
index 000000000..210644661
--- /dev/null
+++ b/vendor/cxx/tests/ui/bad_explicit_impl.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+    struct S {
+        x: u8,
+    }
+
+    impl fn() -> &S {}
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/bad_explicit_impl.stderr b/vendor/cxx/tests/ui/bad_explicit_impl.stderr
new file mode 100644
index 000000000..c4748f421
--- /dev/null
+++ b/vendor/cxx/tests/ui/bad_explicit_impl.stderr
@@ -0,0 +1,5 @@
+error: unsupported Self type of explicit impl
+ --> tests/ui/bad_explicit_impl.rs:7:5
+  |
+7 |     impl fn() -> &S {}
+  |     ^^^^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/by_value_not_supported.rs b/vendor/cxx/tests/ui/by_value_not_supported.rs
new file mode 100644
index 000000000..62bf8d4f3
--- /dev/null
+++ b/vendor/cxx/tests/ui/by_value_not_supported.rs
@@ -0,0 +1,22 @@
+#[cxx::bridge]
+mod ffi {
+    struct S {
+        c: C,
+        r: R,
+        s: CxxString,
+    }
+
+    extern "C++" {
+        type C;
+    }
+
+    extern "Rust" {
+        type R;
+
+        fn f(c: C) -> C;
+        fn g(r: R) -> R;
+        fn h(s: CxxString) -> CxxString;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/by_value_not_supported.stderr b/vendor/cxx/tests/ui/by_value_not_supported.stderr
new file mode 100644
index 000000000..254c7bb45
--- /dev/null
+++ b/vendor/cxx/tests/ui/by_value_not_supported.stderr
@@ -0,0 +1,59 @@
+error: using opaque C++ type by value is not supported
+ --> tests/ui/by_value_not_supported.rs:4:9
+  |
+4 |         c: C,
+  |         ^^^^
+
+error: using opaque Rust type by value is not supported
+ --> tests/ui/by_value_not_supported.rs:5:9
+  |
+5 |         r: R,
+  |         ^^^^
+
+error: using C++ string by value is not supported
+ --> tests/ui/by_value_not_supported.rs:6:9
+  |
+6 |         s: CxxString,
+  |         ^^^^^^^^^^^^
+
+error: needs a cxx::ExternType impl in order to be used as a field of `S`, argument of `f` or return value of `f`
+  --> tests/ui/by_value_not_supported.rs:10:9
+   |
+10 |         type C;
+   |         ^^^^^^
+
+error: passing opaque C++ type by value is not supported
+  --> tests/ui/by_value_not_supported.rs:16:14
+   |
+16 |         fn f(c: C) -> C;
+   |              ^^^^
+
+error: returning opaque C++ type by value is not supported
+  --> tests/ui/by_value_not_supported.rs:16:23
+   |
+16 |         fn f(c: C) -> C;
+   |                       ^
+
+error: passing opaque Rust type by value is not supported
+  --> tests/ui/by_value_not_supported.rs:17:14
+   |
+17 |         fn g(r: R) -> R;
+   |              ^^^^
+
+error: returning opaque Rust type by value is not supported
+  --> tests/ui/by_value_not_supported.rs:17:23
+   |
+17 |         fn g(r: R) -> R;
+   |                       ^
+
+error: passing C++ string by value is not supported
+  --> tests/ui/by_value_not_supported.rs:18:14
+   |
+18 |         fn h(s: CxxString) -> CxxString;
+   |              ^^^^^^^^^^^^
+
+error: returning C++ string by value is not supported
+  --> tests/ui/by_value_not_supported.rs:18:31
+   |
+18 |         fn h(s: CxxString) -> CxxString;
+   |                               ^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/const_fn.rs b/vendor/cxx/tests/ui/const_fn.rs
new file mode 100644
index 000000000..1ad489411
--- /dev/null
+++ b/vendor/cxx/tests/ui/const_fn.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+    extern "Rust" {
+        const fn f();
+    }
+}
+
+const fn f() {}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/const_fn.stderr b/vendor/cxx/tests/ui/const_fn.stderr
new file mode 100644
index 000000000..2dd6608af
--- /dev/null
+++ b/vendor/cxx/tests/ui/const_fn.stderr
@@ -0,0 +1,5 @@
+error: const extern function is not supported
+ --> tests/ui/const_fn.rs:4:9
+  |
+4 |         const fn f();
+  |         ^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/data_enums.rs b/vendor/cxx/tests/ui/data_enums.rs
new file mode 100644
index 000000000..aa23200dc
--- /dev/null
+++ b/vendor/cxx/tests/ui/data_enums.rs
@@ -0,0 +1,8 @@
+#[cxx::bridge]
+mod ffi {
+    enum A {
+        Field(u64),
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/data_enums.stderr b/vendor/cxx/tests/ui/data_enums.stderr
new file mode 100644
index 000000000..d8aa09e39
--- /dev/null
+++ b/vendor/cxx/tests/ui/data_enums.stderr
@@ -0,0 +1,5 @@
+error: enums with data are not supported yet
+ --> tests/ui/data_enums.rs:4:9
+  |
+4 |         Field(u64),
+  |         ^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/deny_elided_lifetimes.rs b/vendor/cxx/tests/ui/deny_elided_lifetimes.rs
new file mode 100644
index 000000000..0ab3f750a
--- /dev/null
+++ b/vendor/cxx/tests/ui/deny_elided_lifetimes.rs
@@ -0,0 +1,27 @@
+#![deny(elided_lifetimes_in_paths)]
+
+#[cxx::bridge]
+mod ffi {
+    #[derive(PartialEq, PartialOrd, Hash)]
+    struct Struct<'a> {
+        reference: &'a i32,
+    }
+
+    extern "Rust" {
+        type Rust<'a>;
+    }
+
+    unsafe extern "C++" {
+        type Cpp<'a>;
+
+        fn lifetime_named<'a>(s: &'a i32) -> UniquePtr<Cpp<'a>>;
+
+        fn lifetime_underscore(s: &i32) -> UniquePtr<Cpp<'_>>;
+
+        fn lifetime_elided(s: &i32) -> UniquePtr<Cpp>;
+    }
+}
+
+pub struct Rust<'a>(&'a i32);
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/deny_elided_lifetimes.stderr b/vendor/cxx/tests/ui/deny_elided_lifetimes.stderr
new file mode 100644
index 000000000..857bb5b7f
--- /dev/null
+++ b/vendor/cxx/tests/ui/deny_elided_lifetimes.stderr
@@ -0,0 +1,15 @@
+error: hidden lifetime parameters in types are deprecated
+  --> tests/ui/deny_elided_lifetimes.rs:21:50
+   |
+21 |         fn lifetime_elided(s: &i32) -> UniquePtr<Cpp>;
+   |                                                  ^^^ expected lifetime parameter
+   |
+note: the lint level is defined here
+  --> tests/ui/deny_elided_lifetimes.rs:1:9
+   |
+1  | #![deny(elided_lifetimes_in_paths)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
+help: indicate the anonymous lifetime
+   |
+21 |         fn lifetime_elided(s: &i32) -> UniquePtr<Cpp<'_>>;
+   |                                                     ++++
diff --git a/vendor/cxx/tests/ui/deny_missing_docs.rs b/vendor/cxx/tests/ui/deny_missing_docs.rs
new file mode 100644
index 000000000..037894bb8
--- /dev/null
+++ b/vendor/cxx/tests/ui/deny_missing_docs.rs
@@ -0,0 +1,94 @@
+// TODO: More work is needed so that the missing_docs lints produced by rustc
+// are properly positioned inside of the bridge.
+
+//! ...
+
+#![deny(missing_docs)]
+
+/// ...
+#[cxx::bridge]
+pub mod ffi {
+    pub struct UndocumentedStruct {
+        pub undocumented_field: u8,
+    }
+
+    /// ...
+    pub struct DocumentedStruct {
+        /// ...
+        pub documented_field: u8,
+    }
+
+    pub enum UndocumentedEnum {
+        UndocumentedVariant = 0,
+    }
+
+    /// ...
+    pub enum DocumentedEnum {
+        /// ...
+        DocumentedVariant = 0,
+    }
+
+    extern "Rust" {
+        pub type UndocumentedRustType;
+
+        /// ...
+        pub type DocumentedRustType;
+
+        pub fn undocumented_rust_fn() -> u8;
+
+        /// ...
+        pub fn documented_rust_fn() -> u8;
+    }
+
+    unsafe extern "C++" {
+        pub type UndocumentedForeignType;
+
+        /// ...
+        pub type DocumentedForeignType;
+
+        pub type UndocumentedTypeAlias = crate::bindgen::UndocumentedTypeAlias;
+
+        /// ...
+        pub type DocumentedTypeAlias = crate::bindgen::DocumentedTypeAlias;
+
+        pub fn undocumented_foreign_fn() -> u8;
+
+        /// ...
+        pub fn documented_foreign_fn() -> u8;
+    }
+
+    #[allow(missing_docs)]
+    pub struct SuppressUndocumentedStruct {
+        pub undocumented_field: u8,
+    }
+}
+
+struct UndocumentedRustType;
+struct DocumentedRustType;
+
+mod bindgen {
+    use cxx::{type_id, ExternType};
+
+    pub struct UndocumentedTypeAlias;
+    pub struct DocumentedTypeAlias;
+
+    unsafe impl ExternType for UndocumentedTypeAlias {
+        type Id = type_id!("UndocumentedTypeAlias");
+        type Kind = cxx::kind::Opaque;
+    }
+
+    unsafe impl ExternType for DocumentedTypeAlias {
+        type Id = type_id!("DocumentedTypeAlias");
+        type Kind = cxx::kind::Opaque;
+    }
+}
+
+fn undocumented_rust_fn() -> u8 {
+    0
+}
+
+fn documented_rust_fn() -> u8 {
+    0
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/deny_missing_docs.stderr b/vendor/cxx/tests/ui/deny_missing_docs.stderr
new file mode 100644
index 000000000..54ab987b4
--- /dev/null
+++ b/vendor/cxx/tests/ui/deny_missing_docs.stderr
@@ -0,0 +1,47 @@
+error: missing documentation for a struct
+  --> tests/ui/deny_missing_docs.rs:11:5
+   |
+11 |     pub struct UndocumentedStruct {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> tests/ui/deny_missing_docs.rs:6:9
+   |
+6  | #![deny(missing_docs)]
+   |         ^^^^^^^^^^^^
+
+error: missing documentation for a struct field
+  --> tests/ui/deny_missing_docs.rs:12:9
+   |
+12 |         pub undocumented_field: u8,
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a struct
+  --> tests/ui/deny_missing_docs.rs:21:5
+   |
+21 |     pub enum UndocumentedEnum {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for an associated constant
+  --> tests/ui/deny_missing_docs.rs:22:9
+   |
+22 |         UndocumentedVariant = 0,
+   |         ^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a struct
+  --> tests/ui/deny_missing_docs.rs:44:9
+   |
+44 |         pub type UndocumentedForeignType;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a type alias
+  --> tests/ui/deny_missing_docs.rs:49:9
+   |
+49 |         pub type UndocumentedTypeAlias = crate::bindgen::UndocumentedTypeAlias;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a function
+  --> tests/ui/deny_missing_docs.rs:54:9
+   |
+54 |         pub fn undocumented_foreign_fn() -> u8;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/derive_duplicate.rs b/vendor/cxx/tests/ui/derive_duplicate.rs
new file mode 100644
index 000000000..3061f765c
--- /dev/null
+++ b/vendor/cxx/tests/ui/derive_duplicate.rs
@@ -0,0 +1,9 @@
+#[cxx::bridge]
+mod ffi {
+    #[derive(Clone, Clone)]
+    struct Struct {
+        x: usize,
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/derive_duplicate.stderr b/vendor/cxx/tests/ui/derive_duplicate.stderr
new file mode 100644
index 000000000..759208629
--- /dev/null
+++ b/vendor/cxx/tests/ui/derive_duplicate.stderr
@@ -0,0 +1,7 @@
+error[E0119]: conflicting implementations of trait `Clone` for type `Struct`
+ --> tests/ui/derive_duplicate.rs:3:21
+  |
+3 |     #[derive(Clone, Clone)]
+  |              -----  ^^^^^ conflicting implementation for `Struct`
+  |              |
+  |              first implementation here
diff --git a/vendor/cxx/tests/ui/derive_noncopy.rs b/vendor/cxx/tests/ui/derive_noncopy.rs
new file mode 100644
index 000000000..ae705fd00
--- /dev/null
+++ b/vendor/cxx/tests/ui/derive_noncopy.rs
@@ -0,0 +1,13 @@
+#[cxx::bridge]
+mod ffi {
+    #[derive(Copy)]
+    struct TryCopy {
+        other: Other,
+    }
+
+    struct Other {
+        x: usize,
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/derive_noncopy.stderr b/vendor/cxx/tests/ui/derive_noncopy.stderr
new file mode 100644
index 000000000..b4f35d3e4
--- /dev/null
+++ b/vendor/cxx/tests/ui/derive_noncopy.stderr
@@ -0,0 +1,7 @@
+error[E0204]: the trait `Copy` cannot be implemented for this type
+ --> tests/ui/derive_noncopy.rs:4:12
+  |
+4 |     struct TryCopy {
+  |            ^^^^^^^
+5 |         other: Other,
+  |         ------------ this field does not implement `Copy`
diff --git a/vendor/cxx/tests/ui/drop_shared.rs b/vendor/cxx/tests/ui/drop_shared.rs
new file mode 100644
index 000000000..5e3de4a1e
--- /dev/null
+++ b/vendor/cxx/tests/ui/drop_shared.rs
@@ -0,0 +1,14 @@
+#[cxx::bridge]
+mod ffi {
+    struct Shared {
+        fd: i32,
+    }
+}
+
+impl Drop for ffi::Shared {
+    fn drop(&mut self) {
+        println!("close({})", self.fd);
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/drop_shared.stderr b/vendor/cxx/tests/ui/drop_shared.stderr
new file mode 100644
index 000000000..41a5287f7
--- /dev/null
+++ b/vendor/cxx/tests/ui/drop_shared.stderr
@@ -0,0 +1,8 @@
+error[E0119]: conflicting implementations of trait `forbid::Drop` for type `Shared`
+ --> tests/ui/drop_shared.rs:3:5
+  |
+1 | #[cxx::bridge]
+  | -------------- first implementation here
+2 | mod ffi {
+3 |     struct Shared {
+  |     ^^^^^^^^^^^^^ conflicting implementation for `Shared`
diff --git a/vendor/cxx/tests/ui/empty_enum.rs b/vendor/cxx/tests/ui/empty_enum.rs
new file mode 100644
index 000000000..987004bb3
--- /dev/null
+++ b/vendor/cxx/tests/ui/empty_enum.rs
@@ -0,0 +1,6 @@
+#[cxx::bridge]
+mod ffi {
+    enum A {}
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/empty_enum.stderr b/vendor/cxx/tests/ui/empty_enum.stderr
new file mode 100644
index 000000000..60d3b5da3
--- /dev/null
+++ b/vendor/cxx/tests/ui/empty_enum.stderr
@@ -0,0 +1,5 @@
+error: explicit #[repr(...)] is required for enum without any variants
+ --> tests/ui/empty_enum.rs:3:5
+  |
+3 |     enum A {}
+  |     ^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/empty_struct.rs b/vendor/cxx/tests/ui/empty_struct.rs
new file mode 100644
index 000000000..060cfe0fa
--- /dev/null
+++ b/vendor/cxx/tests/ui/empty_struct.rs
@@ -0,0 +1,6 @@
+#[cxx::bridge]
+mod ffi {
+    struct Empty {}
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/empty_struct.stderr b/vendor/cxx/tests/ui/empty_struct.stderr
new file mode 100644
index 000000000..f6fbfc117
--- /dev/null
+++ b/vendor/cxx/tests/ui/empty_struct.stderr
@@ -0,0 +1,5 @@
+error: structs without any fields are not supported
+ --> tests/ui/empty_struct.rs:3:5
+  |
+3 |     struct Empty {}
+  |     ^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/enum_inconsistent.rs b/vendor/cxx/tests/ui/enum_inconsistent.rs
new file mode 100644
index 000000000..cd5ffa5b9
--- /dev/null
+++ b/vendor/cxx/tests/ui/enum_inconsistent.rs
@@ -0,0 +1,9 @@
+#[cxx::bridge]
+mod ffi {
+    enum Bad {
+        A = 1u16,
+        B = 2i64,
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/enum_inconsistent.stderr b/vendor/cxx/tests/ui/enum_inconsistent.stderr
new file mode 100644
index 000000000..d6d7837e1
--- /dev/null
+++ b/vendor/cxx/tests/ui/enum_inconsistent.stderr
@@ -0,0 +1,5 @@
+error: expected u16, found i64
+ --> tests/ui/enum_inconsistent.rs:5:9
+  |
+5 |         B = 2i64,
+  |         ^^^^^^^^
diff --git a/vendor/cxx/tests/ui/enum_match_without_wildcard.rs b/vendor/cxx/tests/ui/enum_match_without_wildcard.rs
new file mode 100644
index 000000000..1a119429b
--- /dev/null
+++ b/vendor/cxx/tests/ui/enum_match_without_wildcard.rs
@@ -0,0 +1,16 @@
+#[cxx::bridge]
+mod ffi {
+    enum A {
+        FieldA,
+        FieldB,
+    }
+}
+
+fn main() {}
+
+fn matcher(a: ffi::A) -> u32 {
+    match a {
+        ffi::A::FieldA => 2020,
+        ffi::A::FieldB => 2021,
+    }
+}
diff --git a/vendor/cxx/tests/ui/enum_match_without_wildcard.stderr b/vendor/cxx/tests/ui/enum_match_without_wildcard.stderr
new file mode 100644
index 000000000..5808d6f8f
--- /dev/null
+++ b/vendor/cxx/tests/ui/enum_match_without_wildcard.stderr
@@ -0,0 +1,17 @@
+error[E0004]: non-exhaustive patterns: `ffi::A { repr: 2_u8..=u8::MAX }` not covered
+  --> tests/ui/enum_match_without_wildcard.rs:12:11
+   |
+12 |     match a {
+   |           ^ pattern `ffi::A { repr: 2_u8..=u8::MAX }` not covered
+   |
+note: `ffi::A` defined here
+  --> tests/ui/enum_match_without_wildcard.rs:3:10
+   |
+3  |     enum A {
+   |          ^
+   = note: the matched value is of type `ffi::A`
+help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
+   |
+14 ~         ffi::A::FieldB => 2021,
+15 ~         ffi::A { repr: 2_u8..=u8::MAX } => todo!(),
+   |
diff --git a/vendor/cxx/tests/ui/enum_out_of_bounds.rs b/vendor/cxx/tests/ui/enum_out_of_bounds.rs
new file mode 100644
index 000000000..9e0090b08
--- /dev/null
+++ b/vendor/cxx/tests/ui/enum_out_of_bounds.rs
@@ -0,0 +1,13 @@
+#[cxx::bridge]
+mod ffi {
+    #[repr(u32)]
+    enum Bad1 {
+        A = 0xFFFF_FFFF_FFFF_FFFF,
+    }
+    enum Bad2 {
+        A = 2000,
+        B = 1u8,
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/enum_out_of_bounds.stderr b/vendor/cxx/tests/ui/enum_out_of_bounds.stderr
new file mode 100644
index 000000000..3244b6a7b
--- /dev/null
+++ b/vendor/cxx/tests/ui/enum_out_of_bounds.stderr
@@ -0,0 +1,11 @@
+error: discriminant value `18446744073709551615` is outside the limits of u32
+ --> tests/ui/enum_out_of_bounds.rs:5:9
+  |
+5 |         A = 0xFFFF_FFFF_FFFF_FFFF,
+  |         ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: discriminant value `2000` is outside the limits of u8
+ --> tests/ui/enum_out_of_bounds.rs:9:9
+  |
+9 |         B = 1u8,
+  |         ^^^^^^^
diff --git a/vendor/cxx/tests/ui/enum_overflows.rs b/vendor/cxx/tests/ui/enum_overflows.rs
new file mode 100644
index 000000000..29de1a008
--- /dev/null
+++ b/vendor/cxx/tests/ui/enum_overflows.rs
@@ -0,0 +1,17 @@
+#[cxx::bridge]
+mod ffi {
+    enum Good1 {
+        A = 0xFFFF_FFFF_FFFF_FFFF,
+    }
+    enum Good2 {
+        B = 0xFFFF_FFFF_FFFF_FFFF,
+        C = 2020,
+    }
+    enum Bad {
+        D = 0xFFFF_FFFF_FFFF_FFFE,
+        E,
+        F,
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/enum_overflows.stderr b/vendor/cxx/tests/ui/enum_overflows.stderr
new file mode 100644
index 000000000..76c37bb03
--- /dev/null
+++ b/vendor/cxx/tests/ui/enum_overflows.stderr
@@ -0,0 +1,5 @@
+error: discriminant overflow on value after 18446744073709551615
+  --> tests/ui/enum_overflows.rs:13:9
+   |
+13 |         F,
+   |         ^
diff --git a/vendor/cxx/tests/ui/enum_receiver.rs b/vendor/cxx/tests/ui/enum_receiver.rs
new file mode 100644
index 000000000..a27f27468
--- /dev/null
+++ b/vendor/cxx/tests/ui/enum_receiver.rs
@@ -0,0 +1,11 @@
+#[cxx::bridge]
+mod ffi {
+    enum Enum {
+        Variant,
+    }
+    extern "Rust" {
+        fn f(self: &Enum);
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/enum_receiver.stderr b/vendor/cxx/tests/ui/enum_receiver.stderr
new file mode 100644
index 000000000..ace767760
--- /dev/null
+++ b/vendor/cxx/tests/ui/enum_receiver.stderr
@@ -0,0 +1,5 @@
+error: unsupported receiver type; C++ does not allow member functions on enums
+ --> tests/ui/enum_receiver.rs:7:20
+  |
+7 |         fn f(self: &Enum);
+  |                    ^^^^^
diff --git a/vendor/cxx/tests/ui/enum_unsatisfiable.rs b/vendor/cxx/tests/ui/enum_unsatisfiable.rs
new file mode 100644
index 000000000..619128743
--- /dev/null
+++ b/vendor/cxx/tests/ui/enum_unsatisfiable.rs
@@ -0,0 +1,9 @@
+#[cxx::bridge]
+mod ffi {
+    enum Bad {
+        A = -0xFFFF_FFFF_FFFF_FFFF,
+        B = 0xFFFF_FFFF_FFFF_FFFF,
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/enum_unsatisfiable.stderr b/vendor/cxx/tests/ui/enum_unsatisfiable.stderr
new file mode 100644
index 000000000..e2b37bdd0
--- /dev/null
+++ b/vendor/cxx/tests/ui/enum_unsatisfiable.stderr
@@ -0,0 +1,8 @@
+error: these discriminant values do not fit in any supported enum repr type
+ --> tests/ui/enum_unsatisfiable.rs:3:5
+  |
+3 | /     enum Bad {
+4 | |         A = -0xFFFF_FFFF_FFFF_FFFF,
+5 | |         B = 0xFFFF_FFFF_FFFF_FFFF,
+6 | |     }
+  | |_____^
diff --git a/vendor/cxx/tests/ui/expected_named.rs b/vendor/cxx/tests/ui/expected_named.rs
new file mode 100644
index 000000000..31626d1f6
--- /dev/null
+++ b/vendor/cxx/tests/ui/expected_named.rs
@@ -0,0 +1,9 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        type Borrowed<'a>;
+        fn borrowed() -> UniquePtr<Borrowed>;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/expected_named.stderr b/vendor/cxx/tests/ui/expected_named.stderr
new file mode 100644
index 000000000..0068bdf36
--- /dev/null
+++ b/vendor/cxx/tests/ui/expected_named.stderr
@@ -0,0 +1,11 @@
+error[E0106]: missing lifetime specifier
+ --> tests/ui/expected_named.rs:5:36
+  |
+5 |         fn borrowed() -> UniquePtr<Borrowed>;
+  |                                    ^^^^^^^^ expected named lifetime parameter
+  |
+  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
+help: consider using the `'static` lifetime
+  |
+5 |         fn borrowed() -> UniquePtr<Borrowed<'static>>;
+  |                                            +++++++++
diff --git a/vendor/cxx/tests/ui/extern_fn_abi.rs b/vendor/cxx/tests/ui/extern_fn_abi.rs
new file mode 100644
index 000000000..1f9333885
--- /dev/null
+++ b/vendor/cxx/tests/ui/extern_fn_abi.rs
@@ -0,0 +1,8 @@
+#[cxx::bridge]
+mod ffi {
+    extern "C++" {
+        extern "Java" fn f();
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/extern_fn_abi.stderr b/vendor/cxx/tests/ui/extern_fn_abi.stderr
new file mode 100644
index 000000000..32ef9c3e0
--- /dev/null
+++ b/vendor/cxx/tests/ui/extern_fn_abi.stderr
@@ -0,0 +1,5 @@
+error: explicit ABI on extern function is not supported
+ --> tests/ui/extern_fn_abi.rs:4:9
+  |
+4 |         extern "Java" fn f();
+  |         ^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/extern_type_bound.rs b/vendor/cxx/tests/ui/extern_type_bound.rs
new file mode 100644
index 000000000..958accd38
--- /dev/null
+++ b/vendor/cxx/tests/ui/extern_type_bound.rs
@@ -0,0 +1,15 @@
+#[cxx::bridge]
+mod ffi {
+    extern "C++" {
+        type Opaque: PartialEq + PartialOrd;
+    }
+}
+
+#[cxx::bridge]
+mod ffi {
+    extern "C++" {
+        type Opaque: for<'de> Deserialize<'de>;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/extern_type_bound.stderr b/vendor/cxx/tests/ui/extern_type_bound.stderr
new file mode 100644
index 000000000..1d6796bc6
--- /dev/null
+++ b/vendor/cxx/tests/ui/extern_type_bound.stderr
@@ -0,0 +1,11 @@
+error: extern type bounds are not implemented yet
+ --> tests/ui/extern_type_bound.rs:4:22
+  |
+4 |         type Opaque: PartialEq + PartialOrd;
+  |                      ^^^^^^^^^^^^^^^^^^^^^^
+
+error: unsupported trait
+  --> tests/ui/extern_type_bound.rs:11:22
+   |
+11 |         type Opaque: for<'de> Deserialize<'de>;
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/extern_type_generic.rs b/vendor/cxx/tests/ui/extern_type_generic.rs
new file mode 100644
index 000000000..4de2c981f
--- /dev/null
+++ b/vendor/cxx/tests/ui/extern_type_generic.rs
@@ -0,0 +1,8 @@
+#[cxx::bridge]
+mod ffi {
+    extern "C++" {
+        type Generic<T>;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/extern_type_generic.stderr b/vendor/cxx/tests/ui/extern_type_generic.stderr
new file mode 100644
index 000000000..2b312f0e0
--- /dev/null
+++ b/vendor/cxx/tests/ui/extern_type_generic.stderr
@@ -0,0 +1,5 @@
+error: extern type with generic type parameter is not supported yet
+ --> tests/ui/extern_type_generic.rs:4:22
+  |
+4 |         type Generic<T>;
+  |                      ^
diff --git a/vendor/cxx/tests/ui/extern_type_lifetime_bound.rs b/vendor/cxx/tests/ui/extern_type_lifetime_bound.rs
new file mode 100644
index 000000000..ad581818b
--- /dev/null
+++ b/vendor/cxx/tests/ui/extern_type_lifetime_bound.rs
@@ -0,0 +1,8 @@
+#[cxx::bridge]
+mod ffi {
+    extern "C++" {
+        type Complex<'a, 'b: 'a>;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/extern_type_lifetime_bound.stderr b/vendor/cxx/tests/ui/extern_type_lifetime_bound.stderr
new file mode 100644
index 000000000..6c3fc7f19
--- /dev/null
+++ b/vendor/cxx/tests/ui/extern_type_lifetime_bound.stderr
@@ -0,0 +1,5 @@
+error: lifetime parameter with bounds is not supported yet
+ --> tests/ui/extern_type_lifetime_bound.rs:4:26
+  |
+4 |         type Complex<'a, 'b: 'a>;
+  |                          ^^^^^^
diff --git a/vendor/cxx/tests/ui/fallible_fnptr.rs b/vendor/cxx/tests/ui/fallible_fnptr.rs
new file mode 100644
index 000000000..c45813de5
--- /dev/null
+++ b/vendor/cxx/tests/ui/fallible_fnptr.rs
@@ -0,0 +1,8 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        fn f(callback: fn() -> Result<()>);
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/fallible_fnptr.stderr b/vendor/cxx/tests/ui/fallible_fnptr.stderr
new file mode 100644
index 000000000..4635ec8f7
--- /dev/null
+++ b/vendor/cxx/tests/ui/fallible_fnptr.stderr
@@ -0,0 +1,5 @@
+error: function pointer returning Result is not supported yet
+ --> tests/ui/fallible_fnptr.rs:4:24
+  |
+4 |         fn f(callback: fn() -> Result<()>);
+  |                        ^^^^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/function_with_body.rs b/vendor/cxx/tests/ui/function_with_body.rs
new file mode 100644
index 000000000..52be79af0
--- /dev/null
+++ b/vendor/cxx/tests/ui/function_with_body.rs
@@ -0,0 +1,8 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        fn f() {}
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/function_with_body.stderr b/vendor/cxx/tests/ui/function_with_body.stderr
new file mode 100644
index 000000000..f2078df4d
--- /dev/null
+++ b/vendor/cxx/tests/ui/function_with_body.stderr
@@ -0,0 +1,5 @@
+error: expected `;`
+ --> tests/ui/function_with_body.rs:4:16
+  |
+4 |         fn f() {}
+  |                ^
diff --git a/vendor/cxx/tests/ui/generic_enum.rs b/vendor/cxx/tests/ui/generic_enum.rs
new file mode 100644
index 000000000..feeb94be6
--- /dev/null
+++ b/vendor/cxx/tests/ui/generic_enum.rs
@@ -0,0 +1,16 @@
+#[cxx::bridge]
+mod ffi {
+    enum A<T> {
+        Field,
+    }
+
+    enum B<T> where T: Copy {
+        Field,
+    }
+
+    enum C where void: Copy {
+        Field,
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/generic_enum.stderr b/vendor/cxx/tests/ui/generic_enum.stderr
new file mode 100644
index 000000000..2529af733
--- /dev/null
+++ b/vendor/cxx/tests/ui/generic_enum.stderr
@@ -0,0 +1,17 @@
+error: enum with generic parameters is not supported
+ --> tests/ui/generic_enum.rs:3:5
+  |
+3 |     enum A<T> {
+  |     ^^^^^^^^^
+
+error: enum with generic parameters is not supported
+ --> tests/ui/generic_enum.rs:7:5
+  |
+7 |     enum B<T> where T: Copy {
+  |     ^^^^^^^^^
+
+error: enum with where-clause is not supported
+  --> tests/ui/generic_enum.rs:11:12
+   |
+11 |     enum C where void: Copy {
+   |            ^^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/impl_trait_for_type.rs b/vendor/cxx/tests/ui/impl_trait_for_type.rs
new file mode 100644
index 000000000..9284f738b
--- /dev/null
+++ b/vendor/cxx/tests/ui/impl_trait_for_type.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+    struct S {
+        x: u8,
+    }
+
+    impl UniquePtrTarget for S {}
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/impl_trait_for_type.stderr b/vendor/cxx/tests/ui/impl_trait_for_type.stderr
new file mode 100644
index 000000000..fa99de5a9
--- /dev/null
+++ b/vendor/cxx/tests/ui/impl_trait_for_type.stderr
@@ -0,0 +1,5 @@
+error: unexpected impl, expected something like `impl UniquePtr<T> {}`
+ --> tests/ui/impl_trait_for_type.rs:7:10
+  |
+7 |     impl UniquePtrTarget for S {}
+  |          ^^^^^^^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/include.rs b/vendor/cxx/tests/ui/include.rs
new file mode 100644
index 000000000..3e848b581
--- /dev/null
+++ b/vendor/cxx/tests/ui/include.rs
@@ -0,0 +1,12 @@
+#[cxx::bridge]
+mod ffi {
+    extern "C++" {
+        include!("path/to" what);
+        include!(<path/to> what);
+        include!(<path/to);
+        include!(<path[to]>);
+        include!(...);
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/include.stderr b/vendor/cxx/tests/ui/include.stderr
new file mode 100644
index 000000000..b801530e1
--- /dev/null
+++ b/vendor/cxx/tests/ui/include.stderr
@@ -0,0 +1,29 @@
+error: unexpected token
+ --> tests/ui/include.rs:4:28
+  |
+4 |         include!("path/to" what);
+  |                            ^^^^
+
+error: unexpected token
+ --> tests/ui/include.rs:5:28
+  |
+5 |         include!(<path/to> what);
+  |                            ^^^^
+
+error: expected `>`
+ --> tests/ui/include.rs:6:26
+  |
+6 |         include!(<path/to);
+  |                          ^
+
+error: unexpected token in include path
+ --> tests/ui/include.rs:7:23
+  |
+7 |         include!(<path[to]>);
+  |                       ^^^^
+
+error: expected "quoted/path/to" or <bracketed/path/to>
+ --> tests/ui/include.rs:8:18
+  |
+8 |         include!(...);
+  |                  ^
diff --git a/vendor/cxx/tests/ui/lifetime_extern_cxx.rs b/vendor/cxx/tests/ui/lifetime_extern_cxx.rs
new file mode 100644
index 000000000..e85b3392e
--- /dev/null
+++ b/vendor/cxx/tests/ui/lifetime_extern_cxx.rs
@@ -0,0 +1,9 @@
+#[cxx::bridge]
+mod ffi {
+    extern "C++" {
+        type Opaque;
+        unsafe fn f<'a>(&'a self, arg: &str) -> &'a str;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/lifetime_extern_cxx.stderr b/vendor/cxx/tests/ui/lifetime_extern_cxx.stderr
new file mode 100644
index 000000000..a5cc3bdaa
--- /dev/null
+++ b/vendor/cxx/tests/ui/lifetime_extern_cxx.stderr
@@ -0,0 +1,5 @@
+error: extern C++ function with lifetimes must be declared in `unsafe extern "C++"` block
+ --> tests/ui/lifetime_extern_cxx.rs:5:9
+  |
+5 |         unsafe fn f<'a>(&'a self, arg: &str) -> &'a str;
+  |         ^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/lifetime_extern_rust.rs b/vendor/cxx/tests/ui/lifetime_extern_rust.rs
new file mode 100644
index 000000000..72c37cba7
--- /dev/null
+++ b/vendor/cxx/tests/ui/lifetime_extern_rust.rs
@@ -0,0 +1,17 @@
+#[cxx::bridge]
+mod ffi {
+    extern "Rust" {
+        type Opaque;
+        fn f<'a>(&'a self, arg: &str) -> &'a str;
+    }
+}
+
+pub struct Opaque;
+
+impl Opaque {
+    fn f(&self, _arg: &str) -> &str {
+        ""
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/lifetime_extern_rust.stderr b/vendor/cxx/tests/ui/lifetime_extern_rust.stderr
new file mode 100644
index 000000000..b2ca4950b
--- /dev/null
+++ b/vendor/cxx/tests/ui/lifetime_extern_rust.stderr
@@ -0,0 +1,5 @@
+error: must be `unsafe fn f` in order to expose explicit lifetimes to C++
+ --> tests/ui/lifetime_extern_rust.rs:5:9
+  |
+5 |         fn f<'a>(&'a self, arg: &str) -> &'a str;
+  |         ^^^^^^^^
diff --git a/vendor/cxx/tests/ui/missing_unsafe.rs b/vendor/cxx/tests/ui/missing_unsafe.rs
new file mode 100644
index 000000000..d8c0a23a2
--- /dev/null
+++ b/vendor/cxx/tests/ui/missing_unsafe.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+    extern "Rust" {
+        fn f(x: i32);
+    }
+}
+
+unsafe fn f(_x: i32) {}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/missing_unsafe.stderr b/vendor/cxx/tests/ui/missing_unsafe.stderr
new file mode 100644
index 000000000..e7dcba749
--- /dev/null
+++ b/vendor/cxx/tests/ui/missing_unsafe.stderr
@@ -0,0 +1,9 @@
+error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
+ --> tests/ui/missing_unsafe.rs:4:12
+  |
+4 |         fn f(x: i32);
+  |            ^        - items do not inherit unsafety from separate enclosing items
+  |            |
+  |            call to unsafe function
+  |
+  = note: consult the function's documentation for information on how to avoid undefined behavior
diff --git a/vendor/cxx/tests/ui/multiple_parse_error.rs b/vendor/cxx/tests/ui/multiple_parse_error.rs
new file mode 100644
index 000000000..138d6d6c2
--- /dev/null
+++ b/vendor/cxx/tests/ui/multiple_parse_error.rs
@@ -0,0 +1,8 @@
+#[cxx::bridge]
+mod ffi {
+    struct Monad<T>;
+
+    extern "Haskell" {}
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/multiple_parse_error.stderr b/vendor/cxx/tests/ui/multiple_parse_error.stderr
new file mode 100644
index 000000000..32b8e5601
--- /dev/null
+++ b/vendor/cxx/tests/ui/multiple_parse_error.stderr
@@ -0,0 +1,11 @@
+error: unit structs are not supported
+ --> tests/ui/multiple_parse_error.rs:3:5
+  |
+3 |     struct Monad<T>;
+  |     ^^^^^^^^^^^^^^^^
+
+error: unrecognized ABI, requires either "C++" or "Rust"
+ --> tests/ui/multiple_parse_error.rs:5:5
+  |
+5 |     extern "Haskell" {}
+  |     ^^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/mut_return.rs b/vendor/cxx/tests/ui/mut_return.rs
new file mode 100644
index 000000000..f30988b8c
--- /dev/null
+++ b/vendor/cxx/tests/ui/mut_return.rs
@@ -0,0 +1,18 @@
+#[cxx::bridge]
+mod ffi {
+    extern "Rust" {
+        type Mut<'a>;
+    }
+
+    unsafe extern "C++" {
+        type Thing;
+
+        fn f(t: &Thing) -> Pin<&mut CxxString>;
+        unsafe fn g(t: &Thing) -> Pin<&mut CxxString>;
+        fn h(t: Box<Mut>) -> Pin<&mut CxxString>;
+        fn i<'a>(t: Box<Mut<'a>>) -> Pin<&'a mut CxxString>;
+        fn j(t: &Thing) -> &mut [u8];
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/mut_return.stderr b/vendor/cxx/tests/ui/mut_return.stderr
new file mode 100644
index 000000000..37e947a79
--- /dev/null
+++ b/vendor/cxx/tests/ui/mut_return.stderr
@@ -0,0 +1,11 @@
+error: &mut return type is not allowed unless there is a &mut argument
+  --> tests/ui/mut_return.rs:10:9
+   |
+10 |         fn f(t: &Thing) -> Pin<&mut CxxString>;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: &mut return type is not allowed unless there is a &mut argument
+  --> tests/ui/mut_return.rs:14:9
+   |
+14 |         fn j(t: &Thing) -> &mut [u8];
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/non_integer_discriminant_enum.rs b/vendor/cxx/tests/ui/non_integer_discriminant_enum.rs
new file mode 100644
index 000000000..388b46398
--- /dev/null
+++ b/vendor/cxx/tests/ui/non_integer_discriminant_enum.rs
@@ -0,0 +1,8 @@
+#[cxx::bridge]
+mod ffi {
+    enum A {
+        Field = 2020 + 1,
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/non_integer_discriminant_enum.stderr b/vendor/cxx/tests/ui/non_integer_discriminant_enum.stderr
new file mode 100644
index 000000000..aa4388fb9
--- /dev/null
+++ b/vendor/cxx/tests/ui/non_integer_discriminant_enum.stderr
@@ -0,0 +1,5 @@
+error: enums with non-integer literal discriminants are not supported yet
+ --> tests/ui/non_integer_discriminant_enum.rs:4:9
+  |
+4 |         Field = 2020 + 1,
+  |         ^^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/nonempty_impl_block.rs b/vendor/cxx/tests/ui/nonempty_impl_block.rs
new file mode 100644
index 000000000..239d1ece6
--- /dev/null
+++ b/vendor/cxx/tests/ui/nonempty_impl_block.rs
@@ -0,0 +1,12 @@
+#[cxx::bridge]
+mod ffi {
+    struct S {
+        x: u8,
+    }
+
+    impl UniquePtr<S> {
+        fn new() -> Self;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/nonempty_impl_block.stderr b/vendor/cxx/tests/ui/nonempty_impl_block.stderr
new file mode 100644
index 000000000..6f6983053
--- /dev/null
+++ b/vendor/cxx/tests/ui/nonempty_impl_block.stderr
@@ -0,0 +1,8 @@
+error: expected an empty impl block
+ --> tests/ui/nonempty_impl_block.rs:7:23
+  |
+7 |       impl UniquePtr<S> {
+  |  _______________________^
+8 | |         fn new() -> Self;
+9 | |     }
+  | |_____^
diff --git a/vendor/cxx/tests/ui/nonlocal_rust_type.rs b/vendor/cxx/tests/ui/nonlocal_rust_type.rs
new file mode 100644
index 000000000..d8a238aee
--- /dev/null
+++ b/vendor/cxx/tests/ui/nonlocal_rust_type.rs
@@ -0,0 +1,18 @@
+pub struct MyBuilder<'a> {
+    _s: &'a str,
+}
+
+type OptBuilder<'a> = Option<MyBuilder<'a>>;
+
+#[cxx::bridge]
+mod ffi {
+    extern "Rust" {
+        type OptBuilder<'a>;
+    }
+
+    struct MyBuilder<'a> {
+        rs: Box<OptBuilder<'a>>,
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/nonlocal_rust_type.stderr b/vendor/cxx/tests/ui/nonlocal_rust_type.stderr
new file mode 100644
index 000000000..f6cb06cb6
--- /dev/null
+++ b/vendor/cxx/tests/ui/nonlocal_rust_type.stderr
@@ -0,0 +1,21 @@
+error[E0117]: only traits defined in the current crate can be implemented for types defined outside of the crate
+  --> tests/ui/nonlocal_rust_type.rs:10:9
+   |
+10 |         type OptBuilder<'a>;
+   |         ^^^^^--------------
+   |         |    |
+   |         |    `Option` is not defined in the current crate
+   |         impl doesn't use only types from inside the current crate
+   |
+   = note: define and implement a trait or new type instead
+
+error[E0117]: only traits defined in the current crate can be implemented for types defined outside of the crate
+  --> tests/ui/nonlocal_rust_type.rs:14:13
+   |
+14 |         rs: Box<OptBuilder<'a>>,
+   |             ^^^^--------------
+   |             |   |
+   |             |   `Option` is not defined in the current crate
+   |             impl doesn't use only types from inside the current crate
+   |
+   = note: define and implement a trait or new type instead
diff --git a/vendor/cxx/tests/ui/opaque_autotraits.rs b/vendor/cxx/tests/ui/opaque_autotraits.rs
new file mode 100644
index 000000000..99406d74e
--- /dev/null
+++ b/vendor/cxx/tests/ui/opaque_autotraits.rs
@@ -0,0 +1,16 @@
+#[cxx::bridge]
+mod ffi {
+    extern "C++" {
+        type Opaque;
+    }
+}
+
+fn assert_send<T: Send>() {}
+fn assert_sync<T: Sync>() {}
+fn assert_unpin<T: Unpin>() {}
+
+fn main() {
+    assert_send::<ffi::Opaque>();
+    assert_sync::<ffi::Opaque>();
+    assert_unpin::<ffi::Opaque>();
+}
diff --git a/vendor/cxx/tests/ui/opaque_autotraits.stderr b/vendor/cxx/tests/ui/opaque_autotraits.stderr
new file mode 100644
index 000000000..c6447c558
--- /dev/null
+++ b/vendor/cxx/tests/ui/opaque_autotraits.stderr
@@ -0,0 +1,59 @@
+error[E0277]: `*const cxx::void` cannot be sent between threads safely
+  --> tests/ui/opaque_autotraits.rs:13:19
+   |
+13 |     assert_send::<ffi::Opaque>();
+   |                   ^^^^^^^^^^^ `*const cxx::void` cannot be sent between threads safely
+   |
+   = help: within `ffi::Opaque`, the trait `Send` is not implemented for `*const cxx::void`
+   = note: required because it appears within the type `[*const void; 0]`
+   = note: required because it appears within the type `Opaque`
+note: required because it appears within the type `Opaque`
+  --> tests/ui/opaque_autotraits.rs:4:14
+   |
+4  |         type Opaque;
+   |              ^^^^^^
+note: required by a bound in `assert_send`
+  --> tests/ui/opaque_autotraits.rs:8:19
+   |
+8  | fn assert_send<T: Send>() {}
+   |                   ^^^^ required by this bound in `assert_send`
+
+error[E0277]: `*const cxx::void` cannot be shared between threads safely
+  --> tests/ui/opaque_autotraits.rs:14:19
+   |
+14 |     assert_sync::<ffi::Opaque>();
+   |                   ^^^^^^^^^^^ `*const cxx::void` cannot be shared between threads safely
+   |
+   = help: within `ffi::Opaque`, the trait `Sync` is not implemented for `*const cxx::void`
+   = note: required because it appears within the type `[*const void; 0]`
+   = note: required because it appears within the type `Opaque`
+note: required because it appears within the type `Opaque`
+  --> tests/ui/opaque_autotraits.rs:4:14
+   |
+4  |         type Opaque;
+   |              ^^^^^^
+note: required by a bound in `assert_sync`
+  --> tests/ui/opaque_autotraits.rs:9:19
+   |
+9  | fn assert_sync<T: Sync>() {}
+   |                   ^^^^ required by this bound in `assert_sync`
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/opaque_autotraits.rs:15:20
+   |
+15 |     assert_unpin::<ffi::Opaque>();
+   |                    ^^^^^^^^^^^ within `ffi::Opaque`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |
+   = note: consider using `Box::pin`
+   = note: required because it appears within the type `PhantomData<PhantomPinned>`
+   = note: required because it appears within the type `Opaque`
+note: required because it appears within the type `Opaque`
+  --> tests/ui/opaque_autotraits.rs:4:14
+   |
+4  |         type Opaque;
+   |              ^^^^^^
+note: required by a bound in `assert_unpin`
+  --> tests/ui/opaque_autotraits.rs:10:20
+   |
+10 | fn assert_unpin<T: Unpin>() {}
+   |                    ^^^^^ required by this bound in `assert_unpin`
diff --git a/vendor/cxx/tests/ui/opaque_not_sized.rs b/vendor/cxx/tests/ui/opaque_not_sized.rs
new file mode 100644
index 000000000..754e8d36c
--- /dev/null
+++ b/vendor/cxx/tests/ui/opaque_not_sized.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+    extern "Rust" {
+        type TypeR;
+    }
+}
+
+struct TypeR(str);
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/opaque_not_sized.stderr b/vendor/cxx/tests/ui/opaque_not_sized.stderr
new file mode 100644
index 000000000..85be4af3b
--- /dev/null
+++ b/vendor/cxx/tests/ui/opaque_not_sized.stderr
@@ -0,0 +1,17 @@
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+ --> tests/ui/opaque_not_sized.rs:4:14
+  |
+4 |         type TypeR;
+  |              ^^^^^ doesn't have a size known at compile-time
+  |
+  = help: within `TypeR`, the trait `Sized` is not implemented for `str`
+note: required because it appears within the type `TypeR`
+ --> tests/ui/opaque_not_sized.rs:8:8
+  |
+8 | struct TypeR(str);
+  |        ^^^^^
+note: required by a bound in `__AssertSized`
+ --> tests/ui/opaque_not_sized.rs:4:9
+  |
+4 |         type TypeR;
+  |         ^^^^^^^^^^^ required by this bound in `__AssertSized`
diff --git a/vendor/cxx/tests/ui/pin_mut_opaque.rs b/vendor/cxx/tests/ui/pin_mut_opaque.rs
new file mode 100644
index 000000000..ac1ca43af
--- /dev/null
+++ b/vendor/cxx/tests/ui/pin_mut_opaque.rs
@@ -0,0 +1,14 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        type Opaque;
+        fn f(arg: &mut Opaque);
+        fn g(&mut self);
+        fn h(self: &mut Opaque);
+        fn s(s: &mut CxxString);
+        fn v(v: &mut CxxVector<u8>);
+    }
+
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/pin_mut_opaque.stderr b/vendor/cxx/tests/ui/pin_mut_opaque.stderr
new file mode 100644
index 000000000..8a5e019b3
--- /dev/null
+++ b/vendor/cxx/tests/ui/pin_mut_opaque.stderr
@@ -0,0 +1,35 @@
+error: mutable reference to C++ type requires a pin -- use Pin<&mut Opaque>
+ --> tests/ui/pin_mut_opaque.rs:5:19
+  |
+5 |         fn f(arg: &mut Opaque);
+  |                   ^^^^^^^^^^^
+
+error: mutable reference to C++ type requires a pin -- use Pin<&mut CxxString>
+ --> tests/ui/pin_mut_opaque.rs:8:17
+  |
+8 |         fn s(s: &mut CxxString);
+  |                 ^^^^^^^^^^^^^^
+
+error: mutable reference to C++ type requires a pin -- use Pin<&mut CxxVector<...>>
+ --> tests/ui/pin_mut_opaque.rs:9:17
+  |
+9 |         fn v(v: &mut CxxVector<u8>);
+  |                 ^^^^^^^^^^^^^^^^^^
+
+error: needs a cxx::ExternType impl in order to be used as a non-pinned mutable reference in signature of `f`, `g`, `h`
+ --> tests/ui/pin_mut_opaque.rs:4:9
+  |
+4 |         type Opaque;
+  |         ^^^^^^^^^^^
+
+error: mutable reference to opaque C++ type requires a pin -- use `self: Pin<&mut Opaque>`
+ --> tests/ui/pin_mut_opaque.rs:6:14
+  |
+6 |         fn g(&mut self);
+  |              ^^^^^^^^^
+
+error: mutable reference to opaque C++ type requires a pin -- use `self: Pin<&mut Opaque>`
+ --> tests/ui/pin_mut_opaque.rs:7:20
+  |
+7 |         fn h(self: &mut Opaque);
+  |                    ^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/ptr_in_fnptr.rs b/vendor/cxx/tests/ui/ptr_in_fnptr.rs
new file mode 100644
index 000000000..73c97c666
--- /dev/null
+++ b/vendor/cxx/tests/ui/ptr_in_fnptr.rs
@@ -0,0 +1,8 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        fn f(callback: fn(p: *const u8));
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/ptr_in_fnptr.stderr b/vendor/cxx/tests/ui/ptr_in_fnptr.stderr
new file mode 100644
index 000000000..f429b1bd3
--- /dev/null
+++ b/vendor/cxx/tests/ui/ptr_in_fnptr.stderr
@@ -0,0 +1,5 @@
+error: pointer argument requires that the function pointer be marked unsafe
+ --> tests/ui/ptr_in_fnptr.rs:4:27
+  |
+4 |         fn f(callback: fn(p: *const u8));
+  |                           ^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/ptr_missing_unsafe.rs b/vendor/cxx/tests/ui/ptr_missing_unsafe.rs
new file mode 100644
index 000000000..56f0007cb
--- /dev/null
+++ b/vendor/cxx/tests/ui/ptr_missing_unsafe.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        type C;
+
+        fn not_unsafe_ptr(c: *mut C);
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/ptr_missing_unsafe.stderr b/vendor/cxx/tests/ui/ptr_missing_unsafe.stderr
new file mode 100644
index 000000000..d65481bce
--- /dev/null
+++ b/vendor/cxx/tests/ui/ptr_missing_unsafe.stderr
@@ -0,0 +1,5 @@
+error: pointer argument requires that the function be marked unsafe
+ --> tests/ui/ptr_missing_unsafe.rs:6:27
+  |
+6 |         fn not_unsafe_ptr(c: *mut C);
+  |                           ^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/ptr_no_const_mut.rs b/vendor/cxx/tests/ui/ptr_no_const_mut.rs
new file mode 100644
index 000000000..eecec3fb4
--- /dev/null
+++ b/vendor/cxx/tests/ui/ptr_no_const_mut.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        type C;
+
+        fn get_neither_const_nor_mut() -> *C;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/ptr_no_const_mut.stderr b/vendor/cxx/tests/ui/ptr_no_const_mut.stderr
new file mode 100644
index 000000000..4b1bf06fd
--- /dev/null
+++ b/vendor/cxx/tests/ui/ptr_no_const_mut.stderr
@@ -0,0 +1,18 @@
+error: expected `mut` or `const` keyword in raw pointer type
+ --> tests/ui/ptr_no_const_mut.rs:6:43
+  |
+6 |         fn get_neither_const_nor_mut() -> *C;
+  |                                           ^
+  |
+help: add `mut` or `const` here
+  |
+6 |         fn get_neither_const_nor_mut() -> *const C;
+  |                                            +++++
+6 |         fn get_neither_const_nor_mut() -> *mut C;
+  |                                            +++
+
+error: expected `const` or `mut`
+ --> tests/ui/ptr_no_const_mut.rs:6:44
+  |
+6 |         fn get_neither_const_nor_mut() -> *C;
+  |                                            ^
diff --git a/vendor/cxx/tests/ui/ptr_unsupported.rs b/vendor/cxx/tests/ui/ptr_unsupported.rs
new file mode 100644
index 000000000..9d59c0330
--- /dev/null
+++ b/vendor/cxx/tests/ui/ptr_unsupported.rs
@@ -0,0 +1,12 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        type C;
+
+        fn get_ptr_to_reference() -> *mut &C;
+        fn get_uniqueptr_to_ptr() -> UniquePtr<*mut C>;
+        fn get_vector_of_ptr() -> UniquePtr<CxxVector<*mut C>>;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/ptr_unsupported.stderr b/vendor/cxx/tests/ui/ptr_unsupported.stderr
new file mode 100644
index 000000000..ea1dafd86
--- /dev/null
+++ b/vendor/cxx/tests/ui/ptr_unsupported.stderr
@@ -0,0 +1,17 @@
+error: C++ does not allow pointer to reference as a type
+ --> tests/ui/ptr_unsupported.rs:6:38
+  |
+6 |         fn get_ptr_to_reference() -> *mut &C;
+  |                                      ^^^^^^^
+
+error: unsupported unique_ptr target type
+ --> tests/ui/ptr_unsupported.rs:7:38
+  |
+7 |         fn get_uniqueptr_to_ptr() -> UniquePtr<*mut C>;
+  |                                      ^^^^^^^^^^^^^^^^^
+
+error: unsupported vector element type
+ --> tests/ui/ptr_unsupported.rs:8:45
+  |
+8 |         fn get_vector_of_ptr() -> UniquePtr<CxxVector<*mut C>>;
+  |                                             ^^^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/raw_ident_namespace.rs b/vendor/cxx/tests/ui/raw_ident_namespace.rs
new file mode 100644
index 000000000..2c8286c70
--- /dev/null
+++ b/vendor/cxx/tests/ui/raw_ident_namespace.rs
@@ -0,0 +1,53 @@
+use cxx::{type_id, ExternType};
+
+#[repr(transparent)]
+pub struct QuotedRaw(usize);
+
+unsafe impl ExternType for QuotedRaw {
+    type Id = type_id!("org::r#box::implementation::QuotedRaw");
+    type Kind = cxx::kind::Trivial;
+}
+
+#[repr(transparent)]
+pub struct QuotedKeyword(usize);
+
+unsafe impl ExternType for QuotedKeyword {
+    type Id = type_id!("org::box::implementation::QuotedKeyword");
+    type Kind = cxx::kind::Trivial;
+}
+
+#[repr(transparent)]
+pub struct UnquotedRaw(usize);
+
+unsafe impl ExternType for UnquotedRaw {
+    type Id = type_id!(org::r#box::implementation::UnquotedRaw);
+    type Kind = cxx::kind::Trivial;
+}
+
+#[repr(transparent)]
+pub struct UnquotedKeyword(usize);
+
+unsafe impl ExternType for UnquotedKeyword {
+    type Id = type_id!(org::box::implementation::UnquotedKeyword);
+    type Kind = cxx::kind::Trivial;
+}
+
+#[cxx::bridge]
+pub mod ffi {
+    extern "C++" {
+        #[namespace = "org::r#box::implementation"]
+        type QuotedRaw = crate::QuotedRaw;
+
+        #[namespace = "org::box::implementation"]
+        type QuotedKeyword = crate::QuotedKeyword;
+
+        #[namespace = org::r#box::implementation]
+        type UnquotedRaw = crate::UnquotedRaw;
+
+        // Not allowed by rustc (independent of cxx):
+        // #[namespace = org::box::implementation]
+        // type UnquotedKeyword = crate::UnquotedKeyword;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/raw_ident_namespace.stderr b/vendor/cxx/tests/ui/raw_ident_namespace.stderr
new file mode 100644
index 000000000..86c8b6fd6
--- /dev/null
+++ b/vendor/cxx/tests/ui/raw_ident_namespace.stderr
@@ -0,0 +1,11 @@
+error: raw identifier `r#box` is not allowed in a quoted namespace; use `box`, or remove quotes
+ --> tests/ui/raw_ident_namespace.rs:7:24
+  |
+7 |     type Id = type_id!("org::r#box::implementation::QuotedRaw");
+  |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: raw identifier `r#box` is not allowed in a quoted namespace; use `box`, or remove quotes
+  --> tests/ui/raw_ident_namespace.rs:38:23
+   |
+38 |         #[namespace = "org::r#box::implementation"]
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/reference_to_reference.rs b/vendor/cxx/tests/ui/reference_to_reference.rs
new file mode 100644
index 000000000..91fe16003
--- /dev/null
+++ b/vendor/cxx/tests/ui/reference_to_reference.rs
@@ -0,0 +1,13 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        type ThingC;
+        fn repro_c(t: &&ThingC);
+    }
+    extern "Rust" {
+        type ThingR;
+        fn repro_r(t: &&ThingR);
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/reference_to_reference.stderr b/vendor/cxx/tests/ui/reference_to_reference.stderr
new file mode 100644
index 000000000..765e44271
--- /dev/null
+++ b/vendor/cxx/tests/ui/reference_to_reference.stderr
@@ -0,0 +1,11 @@
+error: C++ does not allow references to references
+ --> tests/ui/reference_to_reference.rs:5:23
+  |
+5 |         fn repro_c(t: &&ThingC);
+  |                       ^^^^^^^^
+
+error: C++ does not allow references to references
+ --> tests/ui/reference_to_reference.rs:9:23
+  |
+9 |         fn repro_r(t: &&ThingR);
+  |                       ^^^^^^^^
diff --git a/vendor/cxx/tests/ui/reserved_lifetime.rs b/vendor/cxx/tests/ui/reserved_lifetime.rs
new file mode 100644
index 000000000..179a4db54
--- /dev/null
+++ b/vendor/cxx/tests/ui/reserved_lifetime.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        type Logger;
+
+        fn logger<'static>() -> Pin<&'static Logger>;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/reserved_lifetime.stderr b/vendor/cxx/tests/ui/reserved_lifetime.stderr
new file mode 100644
index 000000000..e95826719
--- /dev/null
+++ b/vendor/cxx/tests/ui/reserved_lifetime.stderr
@@ -0,0 +1,5 @@
+error[E0262]: invalid lifetime parameter name: `'static`
+ --> tests/ui/reserved_lifetime.rs:6:19
+  |
+6 |         fn logger<'static>() -> Pin<&'static Logger>;
+  |                   ^^^^^^^ 'static is a reserved lifetime name
diff --git a/vendor/cxx/tests/ui/reserved_name.rs b/vendor/cxx/tests/ui/reserved_name.rs
new file mode 100644
index 000000000..409e67c0c
--- /dev/null
+++ b/vendor/cxx/tests/ui/reserved_name.rs
@@ -0,0 +1,16 @@
+#[cxx::bridge]
+mod ffi {
+    struct UniquePtr {
+        val: usize,
+    }
+
+    extern "C++" {
+        type Box;
+    }
+
+    extern "Rust" {
+        type String;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/reserved_name.stderr b/vendor/cxx/tests/ui/reserved_name.stderr
new file mode 100644
index 000000000..7636f872b
--- /dev/null
+++ b/vendor/cxx/tests/ui/reserved_name.stderr
@@ -0,0 +1,17 @@
+error: reserved name
+ --> tests/ui/reserved_name.rs:3:12
+  |
+3 |     struct UniquePtr {
+  |            ^^^^^^^^^
+
+error: reserved name
+ --> tests/ui/reserved_name.rs:8:14
+  |
+8 |         type Box;
+  |              ^^^
+
+error: reserved name
+  --> tests/ui/reserved_name.rs:12:14
+   |
+12 |         type String;
+   |              ^^^^^^
diff --git a/vendor/cxx/tests/ui/result_no_display.rs b/vendor/cxx/tests/ui/result_no_display.rs
new file mode 100644
index 000000000..b53567751
--- /dev/null
+++ b/vendor/cxx/tests/ui/result_no_display.rs
@@ -0,0 +1,14 @@
+#[cxx::bridge]
+mod ffi {
+    extern "Rust" {
+        fn f() -> Result<()>;
+    }
+}
+
+pub struct NonError;
+
+fn f() -> Result<(), NonError> {
+    Ok(())
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/result_no_display.stderr b/vendor/cxx/tests/ui/result_no_display.stderr
new file mode 100644
index 000000000..44d4b31da
--- /dev/null
+++ b/vendor/cxx/tests/ui/result_no_display.stderr
@@ -0,0 +1,8 @@
+error[E0277]: `NonError` doesn't implement `std::fmt::Display`
+ --> tests/ui/result_no_display.rs:4:19
+  |
+4 |         fn f() -> Result<()>;
+  |                   ^^^^^^^^^^ `NonError` cannot be formatted with the default formatter
+  |
+  = help: the trait `std::fmt::Display` is not implemented for `NonError`
+  = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
diff --git a/vendor/cxx/tests/ui/root_namespace.rs b/vendor/cxx/tests/ui/root_namespace.rs
new file mode 100644
index 000000000..886fbd946
--- /dev/null
+++ b/vendor/cxx/tests/ui/root_namespace.rs
@@ -0,0 +1,13 @@
+#[cxx::bridge]
+mod ffi {
+    #[namespace = "::"]
+    extern "Rust" {}
+
+    #[namespace = ""]
+    extern "Rust" {}
+
+    #[namespace = ]
+    extern "Rust" {}
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/root_namespace.stderr b/vendor/cxx/tests/ui/root_namespace.stderr
new file mode 100644
index 000000000..b834d91a0
--- /dev/null
+++ b/vendor/cxx/tests/ui/root_namespace.stderr
@@ -0,0 +1,5 @@
+error: expected expression, found `]`
+ --> tests/ui/root_namespace.rs:9:19
+  |
+9 |     #[namespace = ]
+  |                   ^ expected expression
diff --git a/vendor/cxx/tests/ui/rust_pinned.rs b/vendor/cxx/tests/ui/rust_pinned.rs
new file mode 100644
index 000000000..34ca7e331
--- /dev/null
+++ b/vendor/cxx/tests/ui/rust_pinned.rs
@@ -0,0 +1,14 @@
+use std::marker::PhantomPinned;
+
+#[cxx::bridge]
+mod ffi {
+    extern "Rust" {
+        type Pinned;
+    }
+}
+
+pub struct Pinned {
+    _pinned: PhantomPinned,
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/rust_pinned.stderr b/vendor/cxx/tests/ui/rust_pinned.stderr
new file mode 100644
index 000000000..a0fc03382
--- /dev/null
+++ b/vendor/cxx/tests/ui/rust_pinned.stderr
@@ -0,0 +1,17 @@
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/rust_pinned.rs:6:14
+   |
+6  |         type Pinned;
+   |              ^^^^^^ within `Pinned`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |
+   = note: consider using `Box::pin`
+note: required because it appears within the type `Pinned`
+  --> tests/ui/rust_pinned.rs:10:12
+   |
+10 | pub struct Pinned {
+   |            ^^^^^^
+note: required by a bound in `__AssertUnpin`
+  --> tests/ui/rust_pinned.rs:6:9
+   |
+6  |         type Pinned;
+   |         ^^^^^^^^^^^^ required by this bound in `__AssertUnpin`
diff --git a/vendor/cxx/tests/ui/slice_of_type_alias.rs b/vendor/cxx/tests/ui/slice_of_type_alias.rs
new file mode 100644
index 000000000..a7bbc1147
--- /dev/null
+++ b/vendor/cxx/tests/ui/slice_of_type_alias.rs
@@ -0,0 +1,30 @@
+use cxx::{type_id, ExternType};
+
+#[repr(C)]
+struct ElementTrivial(usize);
+
+#[repr(C)]
+struct ElementOpaque(usize);
+
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        type ElementTrivial = crate::ElementTrivial;
+        type ElementOpaque = crate::ElementOpaque;
+
+        fn f(slice: &mut [ElementTrivial]);
+        fn g(slice: &[ElementOpaque]);
+    }
+}
+
+unsafe impl ExternType for ElementTrivial {
+    type Id = type_id!("ElementTrivial");
+    type Kind = cxx::kind::Trivial;
+}
+
+unsafe impl ExternType for ElementOpaque {
+    type Id = type_id!("ElementOpaque");
+    type Kind = cxx::kind::Opaque;
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/slice_of_type_alias.stderr b/vendor/cxx/tests/ui/slice_of_type_alias.stderr
new file mode 100644
index 000000000..9339da37a
--- /dev/null
+++ b/vendor/cxx/tests/ui/slice_of_type_alias.stderr
@@ -0,0 +1,16 @@
+error[E0271]: type mismatch resolving `<ElementOpaque as ExternType>::Kind == Trivial`
+  --> tests/ui/slice_of_type_alias.rs:13:14
+   |
+13 |         type ElementOpaque = crate::ElementOpaque;
+   |              ^^^^^^^^^^^^^ type mismatch resolving `<ElementOpaque as ExternType>::Kind == Trivial`
+   |
+note: expected this to be `Trivial`
+  --> tests/ui/slice_of_type_alias.rs:27:17
+   |
+27 |     type Kind = cxx::kind::Opaque;
+   |                 ^^^^^^^^^^^^^^^^^
+note: required by a bound in `verify_extern_kind`
+  --> src/extern_type.rs
+   |
+   | pub fn verify_extern_kind<T: ExternType<Kind = Kind>, Kind: self::Kind>() {}
+   |                                         ^^^^^^^^^^^ required by this bound in `verify_extern_kind`
diff --git a/vendor/cxx/tests/ui/slice_unsupported.rs b/vendor/cxx/tests/ui/slice_unsupported.rs
new file mode 100644
index 000000000..7a148dd7e
--- /dev/null
+++ b/vendor/cxx/tests/ui/slice_unsupported.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        type Opaque;
+
+        fn f(_: &mut [Opaque]);
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/slice_unsupported.stderr b/vendor/cxx/tests/ui/slice_unsupported.stderr
new file mode 100644
index 000000000..b781bfd46
--- /dev/null
+++ b/vendor/cxx/tests/ui/slice_unsupported.stderr
@@ -0,0 +1,11 @@
+error: unsupported &mut [T] element type: opaque C++ type is not supported yet
+ --> tests/ui/slice_unsupported.rs:6:17
+  |
+6 |         fn f(_: &mut [Opaque]);
+  |                 ^^^^^^^^^^^^^
+
+error: needs a cxx::ExternType impl in order to be used as a slice element in &mut [Opaque]
+ --> tests/ui/slice_unsupported.rs:4:9
+  |
+4 |         type Opaque;
+  |         ^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/struct_cycle.rs b/vendor/cxx/tests/ui/struct_cycle.rs
new file mode 100644
index 000000000..e74c2b1ca
--- /dev/null
+++ b/vendor/cxx/tests/ui/struct_cycle.rs
@@ -0,0 +1,34 @@
+#[cxx::bridge]
+mod ffi {
+    struct Node0 {
+        i: i32,
+    }
+
+    struct Node1 {
+        node2: Node2,
+        vec: Vec<Node3>,
+    }
+
+    struct Node2 {
+        node4: Node4,
+    }
+
+    struct Node3 {
+        node1: Node1,
+    }
+
+    struct Node4 {
+        node0: Node0,
+        node5: Node5,
+    }
+
+    struct Node5 {
+        node2: Node2,
+    }
+
+    struct Node6 {
+        node2: Node2,
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/struct_cycle.stderr b/vendor/cxx/tests/ui/struct_cycle.stderr
new file mode 100644
index 000000000..9ee2d8316
--- /dev/null
+++ b/vendor/cxx/tests/ui/struct_cycle.stderr
@@ -0,0 +1,23 @@
+error: unsupported cyclic data structure
+  --> tests/ui/struct_cycle.rs:26:9
+   |
+26 |         node2: Node2,
+   |         ^^^^^^^^^^^^
+
+error: unsupported cyclic data structure
+  --> tests/ui/struct_cycle.rs:22:9
+   |
+22 |         node5: Node5,
+   |         ^^^^^^^^^^^^
+
+error: unsupported cyclic data structure
+  --> tests/ui/struct_cycle.rs:13:9
+   |
+13 |         node4: Node4,
+   |         ^^^^^^^^^^^^
+
+error: unsupported cyclic data structure
+ --> tests/ui/struct_cycle.rs:8:9
+  |
+8 |         node2: Node2,
+  |         ^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/type_alias_rust.rs b/vendor/cxx/tests/ui/type_alias_rust.rs
new file mode 100644
index 000000000..67df48926
--- /dev/null
+++ b/vendor/cxx/tests/ui/type_alias_rust.rs
@@ -0,0 +1,9 @@
+#[cxx::bridge]
+mod ffi {
+    extern "Rust" {
+        /// Incorrect.
+        type Alias = crate::Type;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/type_alias_rust.stderr b/vendor/cxx/tests/ui/type_alias_rust.stderr
new file mode 100644
index 000000000..8cf9a56fb
--- /dev/null
+++ b/vendor/cxx/tests/ui/type_alias_rust.stderr
@@ -0,0 +1,5 @@
+error: type alias in extern "Rust" block is not supported
+ --> tests/ui/type_alias_rust.rs:5:9
+  |
+5 |         type Alias = crate::Type;
+  |         ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/unique_ptr_as_mut.rs b/vendor/cxx/tests/ui/unique_ptr_as_mut.rs
new file mode 100644
index 000000000..d2c758a9f
--- /dev/null
+++ b/vendor/cxx/tests/ui/unique_ptr_as_mut.rs
@@ -0,0 +1,23 @@
+use cxx::UniquePtr;
+
+#[cxx::bridge]
+mod ffi {
+    struct Shared {
+        x: i32,
+    }
+
+    extern "C++" {
+        type Opaque;
+    }
+
+    impl UniquePtr<Shared> {}
+    impl UniquePtr<Opaque> {}
+}
+
+fn main() {
+    let mut shared = UniquePtr::<ffi::Shared>::null();
+    let _: &mut ffi::Shared = &mut shared;
+
+    let mut opaque = UniquePtr::<ffi::Opaque>::null();
+    let _: &mut ffi::Opaque = &mut opaque;
+}
diff --git a/vendor/cxx/tests/ui/unique_ptr_as_mut.stderr b/vendor/cxx/tests/ui/unique_ptr_as_mut.stderr
new file mode 100644
index 000000000..a8248dbe6
--- /dev/null
+++ b/vendor/cxx/tests/ui/unique_ptr_as_mut.stderr
@@ -0,0 +1,7 @@
+error[E0596]: cannot borrow data in dereference of `UniquePtr<ffi::Opaque>` as mutable
+  --> tests/ui/unique_ptr_as_mut.rs:22:31
+   |
+22 |     let _: &mut ffi::Opaque = &mut opaque;
+   |                               ^^^^^^^^^^^ cannot borrow as mutable
+   |
+   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `UniquePtr<ffi::Opaque>`
diff --git a/vendor/cxx/tests/ui/unique_ptr_to_opaque.rs b/vendor/cxx/tests/ui/unique_ptr_to_opaque.rs
new file mode 100644
index 000000000..5226ca81b
--- /dev/null
+++ b/vendor/cxx/tests/ui/unique_ptr_to_opaque.rs
@@ -0,0 +1,23 @@
+mod outside {
+    #[repr(C)]
+    pub struct C {
+        pub a: u8,
+    }
+    unsafe impl cxx::ExternType for C {
+        type Id = cxx::type_id!("C");
+        type Kind = cxx::kind::Opaque;
+    }
+}
+
+#[cxx::bridge]
+mod ffi {
+    extern "C++" {
+        type C = crate::outside::C;
+    }
+
+    impl UniquePtr<C> {}
+}
+
+fn main() {
+    cxx::UniquePtr::new(outside::C { a: 4 });
+}
diff --git a/vendor/cxx/tests/ui/unique_ptr_to_opaque.stderr b/vendor/cxx/tests/ui/unique_ptr_to_opaque.stderr
new file mode 100644
index 000000000..3c121e54c
--- /dev/null
+++ b/vendor/cxx/tests/ui/unique_ptr_to_opaque.stderr
@@ -0,0 +1,18 @@
+error[E0271]: type mismatch resolving `<C as ExternType>::Kind == Trivial`
+  --> tests/ui/unique_ptr_to_opaque.rs:22:25
+   |
+22 |     cxx::UniquePtr::new(outside::C { a: 4 });
+   |     ------------------- ^^^^^^^^^^^^^^^^^^^ type mismatch resolving `<C as ExternType>::Kind == Trivial`
+   |     |
+   |     required by a bound introduced by this call
+   |
+note: expected this to be `Trivial`
+  --> tests/ui/unique_ptr_to_opaque.rs:8:21
+   |
+8  |         type Kind = cxx::kind::Opaque;
+   |                     ^^^^^^^^^^^^^^^^^
+note: required by a bound in `UniquePtr::<T>::new`
+  --> src/unique_ptr.rs
+   |
+   |         T: ExternType<Kind = Trivial>,
+   |                       ^^^^^^^^^^^^^^ required by this bound in `UniquePtr::<T>::new`
diff --git a/vendor/cxx/tests/ui/unique_ptr_twice.rs b/vendor/cxx/tests/ui/unique_ptr_twice.rs
new file mode 100644
index 000000000..14c6f62a4
--- /dev/null
+++ b/vendor/cxx/tests/ui/unique_ptr_twice.rs
@@ -0,0 +1,19 @@
+#[cxx::bridge]
+mod here {
+    extern "C++" {
+        type C;
+    }
+
+    impl UniquePtr<C> {}
+}
+
+#[cxx::bridge]
+mod there {
+    extern "C++" {
+        type C = crate::here::C;
+    }
+
+    impl UniquePtr<C> {}
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/unique_ptr_twice.stderr b/vendor/cxx/tests/ui/unique_ptr_twice.stderr
new file mode 100644
index 000000000..b21791fbe
--- /dev/null
+++ b/vendor/cxx/tests/ui/unique_ptr_twice.stderr
@@ -0,0 +1,8 @@
+error[E0119]: conflicting implementations of trait `UniquePtrTarget` for type `here::C`
+  --> tests/ui/unique_ptr_twice.rs:16:5
+   |
+7  |     impl UniquePtr<C> {}
+   |     ---------------- first implementation here
+...
+16 |     impl UniquePtr<C> {}
+   |     ^^^^^^^^^^^^^^^^ conflicting implementation for `here::C`
diff --git a/vendor/cxx/tests/ui/unnamed_receiver.rs b/vendor/cxx/tests/ui/unnamed_receiver.rs
new file mode 100644
index 000000000..5f53a0a5f
--- /dev/null
+++ b/vendor/cxx/tests/ui/unnamed_receiver.rs
@@ -0,0 +1,14 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        type One;
+        type Two;
+        fn f(&mut self);
+    }
+
+    extern "Rust" {
+        fn f(self: &Self);
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/unnamed_receiver.stderr b/vendor/cxx/tests/ui/unnamed_receiver.stderr
new file mode 100644
index 000000000..d903b2311
--- /dev/null
+++ b/vendor/cxx/tests/ui/unnamed_receiver.stderr
@@ -0,0 +1,11 @@
+error: unnamed receiver type is only allowed if the surrounding extern block contains exactly one extern type; use `self: &mut TheType`
+ --> tests/ui/unnamed_receiver.rs:6:14
+  |
+6 |         fn f(&mut self);
+  |              ^^^^^^^^^
+
+error: unnamed receiver type is only allowed if the surrounding extern block contains exactly one extern type; use `self: &TheType`
+  --> tests/ui/unnamed_receiver.rs:10:20
+   |
+10 |         fn f(self: &Self);
+   |                    ^^^^^
diff --git a/vendor/cxx/tests/ui/unpin_impl.rs b/vendor/cxx/tests/ui/unpin_impl.rs
new file mode 100644
index 000000000..129fcb11d
--- /dev/null
+++ b/vendor/cxx/tests/ui/unpin_impl.rs
@@ -0,0 +1,10 @@
+#[cxx::bridge]
+mod ffi {
+    extern "C++" {
+        type Opaque;
+    }
+}
+
+impl Unpin for ffi::Opaque {}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/unpin_impl.stderr b/vendor/cxx/tests/ui/unpin_impl.stderr
new file mode 100644
index 000000000..afe5a8066
--- /dev/null
+++ b/vendor/cxx/tests/ui/unpin_impl.stderr
@@ -0,0 +1,18 @@
+error[E0282]: type annotations needed
+ --> tests/ui/unpin_impl.rs:4:14
+  |
+4 |         type Opaque;
+  |              ^^^^^^ cannot infer type
+
+error[E0283]: type annotations needed
+ --> tests/ui/unpin_impl.rs:1:1
+  |
+1 | #[cxx::bridge]
+  | ^^^^^^^^^^^^^^ cannot infer type
+  |
+note: multiple `impl`s satisfying `ffi::Opaque: __AmbiguousIfImpl<_>` found
+ --> tests/ui/unpin_impl.rs:1:1
+  |
+1 | #[cxx::bridge]
+  | ^^^^^^^^^^^^^^
+  = note: this error originates in the attribute macro `cxx::bridge` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/cxx/tests/ui/unrecognized_receiver.rs b/vendor/cxx/tests/ui/unrecognized_receiver.rs
new file mode 100644
index 000000000..eee825932
--- /dev/null
+++ b/vendor/cxx/tests/ui/unrecognized_receiver.rs
@@ -0,0 +1,8 @@
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        fn f(self: &Unrecognized);
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/unrecognized_receiver.stderr b/vendor/cxx/tests/ui/unrecognized_receiver.stderr
new file mode 100644
index 000000000..bc645fec2
--- /dev/null
+++ b/vendor/cxx/tests/ui/unrecognized_receiver.stderr
@@ -0,0 +1,5 @@
+error: unrecognized receiver type
+ --> tests/ui/unrecognized_receiver.rs:4:20
+  |
+4 |         fn f(self: &Unrecognized);
+  |                    ^^^^^^^^^^^^^
diff --git a/vendor/cxx/tests/ui/unsupported_elided.rs b/vendor/cxx/tests/ui/unsupported_elided.rs
new file mode 100644
index 000000000..403331968
--- /dev/null
+++ b/vendor/cxx/tests/ui/unsupported_elided.rs
@@ -0,0 +1,20 @@
+use std::marker::PhantomData;
+
+#[cxx::bridge]
+mod ffi {
+    extern "Rust" {
+        type T;
+
+        fn f(t: &T) -> &str;
+    }
+}
+
+pub struct T<'a> {
+    _lifetime: PhantomData<&'a ()>,
+}
+
+fn f<'a>(_t: &T<'a>) -> &'a str {
+    ""
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/unsupported_elided.stderr b/vendor/cxx/tests/ui/unsupported_elided.stderr
new file mode 100644
index 000000000..4ccac6fb7
--- /dev/null
+++ b/vendor/cxx/tests/ui/unsupported_elided.stderr
@@ -0,0 +1,22 @@
+error[E0726]: implicit elided lifetime not allowed here
+ --> tests/ui/unsupported_elided.rs:6:14
+  |
+6 |         type T;
+  |              ^ expected lifetime parameter
+  |
+help: indicate the anonymous lifetime
+  |
+6 |         type T<'_>;
+  |               ++++
+
+error[E0106]: missing lifetime specifier
+ --> tests/ui/unsupported_elided.rs:8:24
+  |
+8 |         fn f(t: &T) -> &str;
+  |                 --     ^ expected named lifetime parameter
+  |
+  = help: this function's return type contains a borrowed value, but the signature does not say which one of `t`'s 2 lifetimes it is borrowed from
+help: consider introducing a named lifetime parameter
+  |
+8 |         fn f<'a>(t: &'a T<'a>) -> &'a str;
+  |             ++++     ++  ++++      ++
diff --git a/vendor/cxx/tests/ui/vec_opaque.rs b/vendor/cxx/tests/ui/vec_opaque.rs
new file mode 100644
index 000000000..d0b279cf6
--- /dev/null
+++ b/vendor/cxx/tests/ui/vec_opaque.rs
@@ -0,0 +1,34 @@
+#[cxx::bridge]
+mod handle {
+    extern "C++" {
+        type Job;
+    }
+}
+
+#[cxx::bridge]
+mod ffi1 {
+    extern "C++" {
+        type Job;
+    }
+
+    extern "Rust" {
+        fn f() -> Vec<Job>;
+    }
+}
+
+#[cxx::bridge]
+mod ffi2 {
+    extern "C++" {
+        type Job = crate::handle::Job;
+    }
+
+    extern "Rust" {
+        fn f() -> Vec<Job>;
+    }
+}
+
+fn f() -> Vec<handle::Job> {
+    unimplemented!()
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/vec_opaque.stderr b/vendor/cxx/tests/ui/vec_opaque.stderr
new file mode 100644
index 000000000..ae01adfc3
--- /dev/null
+++ b/vendor/cxx/tests/ui/vec_opaque.stderr
@@ -0,0 +1,23 @@
+error: Rust Vec containing C++ type is not supported yet
+  --> tests/ui/vec_opaque.rs:15:19
+   |
+15 |         fn f() -> Vec<Job>;
+   |                   ^^^^^^^^
+
+error: needs a cxx::ExternType impl in order to be used as a vector element in Vec<Job>
+  --> tests/ui/vec_opaque.rs:11:9
+   |
+11 |         type Job;
+   |         ^^^^^^^^
+
+error[E0271]: type mismatch resolving `<Job as ExternType>::Kind == Trivial`
+  --> tests/ui/vec_opaque.rs:22:14
+   |
+22 |         type Job = crate::handle::Job;
+   |              ^^^ expected `Trivial`, found `Opaque`
+   |
+note: required by a bound in `verify_extern_kind`
+  --> src/extern_type.rs
+   |
+   | pub fn verify_extern_kind<T: ExternType<Kind = Kind>, Kind: self::Kind>() {}
+   |                                         ^^^^^^^^^^^ required by this bound in `verify_extern_kind`
diff --git a/vendor/cxx/tests/ui/vector_autotraits.rs b/vendor/cxx/tests/ui/vector_autotraits.rs
new file mode 100644
index 000000000..cc918d58c
--- /dev/null
+++ b/vendor/cxx/tests/ui/vector_autotraits.rs
@@ -0,0 +1,21 @@
+use cxx::CxxVector;
+
+#[cxx::bridge]
+mod ffi {
+    extern "C++" {
+        type ThreadSafe;
+        type NotThreadSafe;
+    }
+
+    impl CxxVector<ThreadSafe> {}
+    impl CxxVector<NotThreadSafe> {}
+}
+
+unsafe impl Send for ffi::ThreadSafe {}
+
+fn assert_send<T: Send>() {}
+
+fn main() {
+    assert_send::<CxxVector<ffi::ThreadSafe>>();
+    assert_send::<CxxVector<ffi::NotThreadSafe>>();
+}
diff --git a/vendor/cxx/tests/ui/vector_autotraits.stderr b/vendor/cxx/tests/ui/vector_autotraits.stderr
new file mode 100644
index 000000000..8851cedc1
--- /dev/null
+++ b/vendor/cxx/tests/ui/vector_autotraits.stderr
@@ -0,0 +1,22 @@
+error[E0277]: `*const cxx::void` cannot be sent between threads safely
+  --> tests/ui/vector_autotraits.rs:20:19
+   |
+20 |     assert_send::<CxxVector<ffi::NotThreadSafe>>();
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `*const cxx::void` cannot be sent between threads safely
+   |
+   = help: within `CxxVector<NotThreadSafe>`, the trait `Send` is not implemented for `*const cxx::void`
+   = note: required because it appears within the type `[*const void; 0]`
+   = note: required because it appears within the type `Opaque`
+note: required because it appears within the type `NotThreadSafe`
+  --> tests/ui/vector_autotraits.rs:7:14
+   |
+7  |         type NotThreadSafe;
+   |              ^^^^^^^^^^^^^
+   = note: required because it appears within the type `[NotThreadSafe]`
+   = note: required because it appears within the type `PhantomData<[NotThreadSafe]>`
+   = note: required because it appears within the type `CxxVector<NotThreadSafe>`
+note: required by a bound in `assert_send`
+  --> tests/ui/vector_autotraits.rs:16:19
+   |
+16 | fn assert_send<T: Send>() {}
+   |                   ^^^^ required by this bound in `assert_send`
diff --git a/vendor/cxx/tests/ui/wrong_type_id.rs b/vendor/cxx/tests/ui/wrong_type_id.rs
new file mode 100644
index 000000000..9137e5166
--- /dev/null
+++ b/vendor/cxx/tests/ui/wrong_type_id.rs
@@ -0,0 +1,15 @@
+#[cxx::bridge(namespace = "folly")]
+mod here {
+    extern "C++" {
+        type StringPiece;
+    }
+}
+
+#[cxx::bridge(namespace = "folly")]
+mod there {
+    extern "C++" {
+        type ByteRange = crate::here::StringPiece;
+    }
+}
+
+fn main() {}
diff --git a/vendor/cxx/tests/ui/wrong_type_id.stderr b/vendor/cxx/tests/ui/wrong_type_id.stderr
new file mode 100644
index 000000000..d3ed3a0c1
--- /dev/null
+++ b/vendor/cxx/tests/ui/wrong_type_id.stderr
@@ -0,0 +1,13 @@
+error[E0271]: type mismatch resolving `<StringPiece as ExternType>::Id == (f, o, l, l, y, (), B, y, t, e, ..., ..., ..., ..., ...)`
+  --> tests/ui/wrong_type_id.rs:11:14
+   |
+11 |         type ByteRange = crate::here::StringPiece;
+   |              ^^^^^^^^^ expected a tuple with 15 elements, found one with 17 elements
+   |
+   = note: expected tuple `(f, o, l, l, y, (), B, y, t, e, R, a, n, g, e)`
+              found tuple `(f, o, l, l, y, (), S, t, r, i, n, g, P, i, e, c, e)`
+note: required by a bound in `verify_extern_type`
+  --> src/extern_type.rs
+   |
+   | pub fn verify_extern_type<T: ExternType<Id = Id>, Id>() {}
+   |                                         ^^^^^^^ required by this bound in `verify_extern_type`
diff --git a/vendor/cxx/tests/unique_ptr.rs b/vendor/cxx/tests/unique_ptr.rs
new file mode 100644
index 000000000..e5eb66bcd
--- /dev/null
+++ b/vendor/cxx/tests/unique_ptr.rs
@@ -0,0 +1,8 @@
+use cxx::{CxxString, UniquePtr};
+
+#[test]
+#[should_panic = "called deref on a null UniquePtr<CxxString>"]
+fn test_deref_null() {
+    let unique_ptr = UniquePtr::<CxxString>::null();
+    let _: &CxxString = &unique_ptr;
+}