diff options
Diffstat (limited to 'vendor/cxx/tests')
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; +} |