Add support for Vec<Box<T>>.

Author: anforowicz

macro/src/generics.rs

@@ -58,7 +58,7 @@ pub(crate) fn get_impl_and_ty_generics<'a>(
 fn get_generic_lifetimes<'a>(ty: &'a Type) -> &'a Lifetimes {
     match ty {
         Type::Ident(named_type) => &named_type.generics,
-        Type::CxxVector(ty1) => get_generic_lifetimes(&ty1.inner),
+        Type::RustBox(ty1) | Type::CxxVector(ty1) => get_generic_lifetimes(&ty1.inner),
         _ => unreachable!("syntax/check.rs should reject other types"),
     }
 }
@@ -78,7 +78,7 @@ fn get_generic_lifetimes<'a>(ty: &'a Type) -> &'a Lifetimes {
 fn resolve_generic_lifetimes<'a>(ty: &'a Type, types: &'a Types) -> &'a Lifetimes {
     match ty {
         Type::Ident(named_type) => types.resolve(&named_type.rust).generics,
-        Type::CxxVector(ty1) => resolve_generic_lifetimes(&ty1.inner, types),
+        Type::RustBox(ty1) | Type::CxxVector(ty1) => resolve_generic_lifetimes(&ty1.inner, types),
         _ => unreachable!("syntax/check.rs should reject other types"),
     }
 }

macro/src/tests.rs

@@ -84,3 +84,27 @@ fn test_vec_string() {
     assert!(rs.contains("v: &::cxx::private::RustVec<::cxx::alloc::string::String>"));
     assert!(rs.contains("fn __foo(v: &::cxx::alloc::vec::Vec<::cxx::alloc::string::String>)"));
 }
+
+/// This test covers implicit impl of `Vec<Box<T>>`.
+#[test]
+fn test_vec_of_box() {
+    let rs = bridge(quote! {
+        mod ffi {
+            extern "Rust" {
+                type R;
+                fn foo() -> Vec<Box<R>>;
+            }
+        }
+    })
+    .unwrap();
+    assert!(rs.contains("unsafe impl ::cxx::private::ImplBox for R {}"));
+    assert!(rs.contains("export_name = \"cxxbridge1$box$R$drop\""));
+
+    assert!(rs.contains("unsafe impl ::cxx::private::ImplVec for ::cxx::alloc::boxed::Box<R> {}"),);
+    assert!(rs.contains("export_name = \"cxxbridge1$rust_vec$box$R$set_len\""));
+
+    // Covering these lines, because an early WIP incorrectly said`RustVec<*mut R>`
+    // instead of `RustVec<Box<R>>` in *some* of these lines.
+    assert!(rs.contains("__return: *mut ::cxx::private::RustVec<::cxx::alloc::boxed::Box<R>>"));
+    assert!(rs.contains("fn __foo() -> ::cxx::alloc::vec::Vec<::cxx::alloc::boxed::Box<R>>"));
+}

syntax/check.rs

@@ -133,6 +133,10 @@ fn check_type_rust_vec(cx: &mut Check, ty: &Ty1) {
             }
         }
         Type::Str(_) => return,
+        Type::RustBox(ty1) => {
+            check_type_box(cx, ty1);
+            return;
+        }
         _ => {}
     }
 

syntax/types.rs

@@ -358,10 +358,10 @@ impl<'a> Types<'a> {
             Type::Ident(ident) => {
                 Atom::from(&ident.rust).is_none() && !self.aliases.contains_key(&ident.rust)
             }
-            Type::RustBox(_) => {
-                // TODO: We should treat Box<LocalType> as local to match
+            Type::RustBox(ty1) => {
+                // Treating Box<LocalType> as local to match
                 // https://doc.rust-lang.org/reference/items/implementations.html#r-items.impl.trait.fundamental
-                false
+                self.is_local(&ty1.inner)
             }
             Type::Array(_)
             | Type::CxxVector(_)

tests/ffi/lib.rs

@@ -306,6 +306,7 @@ pub mod ffi {
         fn r_return_rust_vec() -> Vec<u8>;
         fn r_return_rust_vec_string() -> Vec<String>;
         fn r_return_rust_vec_extern_struct() -> Vec<Job>;
+        fn r_return_rust_vec_box() -> Vec<Box<R>>;
         fn r_return_ref_rust_vec(shared: &Shared) -> &Vec<u8>;
         fn r_return_mut_rust_vec(shared: &mut Shared) -> &mut Vec<u8>;
         fn r_return_identity(_: usize) -> usize;
@@ -587,6 +588,10 @@ fn r_return_rust_vec_extern_struct() -> Vec<ffi::Job> {
     Vec::new()
 }
 
+fn r_return_rust_vec_box() -> Vec<Box<R>> {
+    vec![Box::new(R(2020))]
+}
+
 fn r_return_ref_rust_vec(shared: &ffi::Shared) -> &Vec<u8> {
     let _ = shared;
     unimplemented!()

tests/ffi/tests.cc

@@ -812,6 +812,7 @@ extern "C" const char *cxx_run_test() noexcept {
   ASSERT(r_return_enum(2021) == Enum::CVal);
   ASSERT(Shared::r_static_method_on_shared() == 2023);
   ASSERT(R::r_static_method() == 2024);
+  ASSERT(r_return_rust_vec_box()[0]->get() == 2020);
 
   r_take_primitive(2020);
   r_take_shared(Shared{2020});