Don't generate Vec/Box impls for aliases

sbrocket · sbrocket · commit f21cea8b0641 · 2020-10-02T13:28:15.000-07:00
diff --git a/gen/src/write.rs b/gen/src/write.rs
@@ -1007,12 +1007,14 @@ fn write_generic_instantiations(out: &mut OutFile, types: &Types) {
     for ty in types {
         if let Type::RustBox(ty) = ty {
             if let Type::Ident(inner) = &ty.inner {
-                out.next_section();
-                write_rust_box_extern(out, inner);
+                if Atom::from(inner).is_none() && !types.aliases.contains_key(inner) {
+                    out.next_section();
+                    write_rust_box_extern(out, inner);
+                }
             }
         } else if let Type::RustVec(ty) = ty {
             if let Type::Ident(inner) = &ty.inner {
-                if Atom::from(inner).is_none() {
+                if Atom::from(inner).is_none() && !types.aliases.contains_key(inner) {
                     out.next_section();
                     write_rust_vec_extern(out, inner);
                 }
@@ -1040,11 +1042,13 @@ fn write_generic_instantiations(out: &mut OutFile, types: &Types) {
     for ty in types {
         if let Type::RustBox(ty) = ty {
             if let Type::Ident(inner) = &ty.inner {
-                write_rust_box_impl(out, inner);
+                if Atom::from(inner).is_none() && !types.aliases.contains_key(inner) {
+                    write_rust_box_impl(out, inner);
+                }
             }
         } else if let Type::RustVec(ty) = ty {
             if let Type::Ident(inner) = &ty.inner {
-                if Atom::from(inner).is_none() {
+                if Atom::from(inner).is_none() && !types.aliases.contains_key(inner) {
                     write_rust_vec_impl(out, inner);
                 }
             }
diff --git a/macro/src/expand.rs b/macro/src/expand.rs
@@ -65,13 +65,13 @@ fn expand(ffi: Module, apis: &[Api], types: &Types) -> TokenStream {
     for ty in types {
         if let Type::RustBox(ty) = ty {
             if let Type::Ident(ident) = &ty.inner {
-                if Atom::from(ident).is_none() {
+                if Atom::from(ident).is_none() && !types.aliases.contains_key(ident) {
                     hidden.extend(expand_rust_box(namespace, ident));
                 }
             }
         } else if let Type::RustVec(ty) = ty {
             if let Type::Ident(ident) = &ty.inner {
-                if Atom::from(ident).is_none() {
+                if Atom::from(ident).is_none() && !types.aliases.contains_key(ident) {
                     hidden.extend(expand_rust_vec(namespace, ident));
                 }
             }
diff --git a/tests/ffi/alias.rs b/tests/ffi/alias.rs
@@ -13,29 +13,28 @@ pub mod ffi {
 
         type C = crate::ffi::C;
 
-        // TODO: The alias prefix can be removed once these are in their own namespace.
+        // TODO(https://github.com/dtolnay/cxx/pull/298): The alias prefix can be removed once these
+        // are in their own namespace.
         fn alias_c_return_shared() -> Shared;
+        fn alias_c_return_unique_ptr() -> UniquePtr<C>;
         fn alias_c_return_ref(shared: &Shared) -> &usize;
         fn alias_c_return_mut(shared: &mut Shared) -> &mut usize;
         fn alias_c_return_enum(n: u16) -> Enum;
+        fn alias_c_return_unique_ptr_shared() -> UniquePtr<Shared>;
         fn alias_c_return_unique_ptr_vector_shared() -> UniquePtr<CxxVector<Shared>>;
 
         fn alias_c_take_shared(shared: Shared);
-        // TODO: This don't work yet because both bridges try to emit the rust_vec$tests$Shared
-        // functions. Need the remote bridge to always emit if this is gonna work. Or can we work
-        // around ODR by making the rust_vec functions inline?
-        //fn alias_c_take_rust_vec_shared(v: Vec<Shared>);
-        // TODO: Box<Shared> probably has the same problem, not currently tested
-        // TODO: Same for UniquePtr<Shared>, not currently tested
-        // TODO: Below probably doesn't work if the remote bridge doesn't use CxxVector<Shared>
+        fn alias_c_take_box_shared(shared: Box<Shared>);
+        fn alias_c_take_unique_ptr(c: UniquePtr<C>);
+        fn alias_c_take_unique_ptr_shared(s: UniquePtr<Shared>);
         fn alias_c_take_unique_ptr_vector_shared(v: UniquePtr<CxxVector<Shared>>);
+        fn alias_c_take_rust_vec_shared(v: Vec<Shared>);
         fn alias_c_take_enum(e: Enum);
-
-        fn c_take_unique_ptr(c: UniquePtr<C>);
     }
 
     extern "Rust" {
-        // TODO: The alias prefix can be removed once these are in their own namespace.
+        // TODO(https://github.com/dtolnay/cxx/pull/298): The alias prefix can be removed once these
+        // are in their own namespace.
         fn alias_r_return_shared() -> Shared;
         fn alias_r_return_ref(shared: &Shared) -> &usize;
         fn alias_r_return_mut(shared: &mut Shared) -> &mut usize;
diff --git a/tests/ffi/lib.rs b/tests/ffi/lib.rs
@@ -31,6 +31,7 @@ pub mod ffi {
         fn c_return_shared() -> Shared;
         fn c_return_box() -> Box<R>;
         fn c_return_unique_ptr() -> UniquePtr<C>;
+        fn c_return_unique_ptr_shared() -> UniquePtr<Shared>;
         fn c_return_ref(shared: &Shared) -> &usize;
         fn c_return_mut(shared: &mut Shared) -> &mut usize;
         fn c_return_str(shared: &Shared) -> &str;
@@ -55,6 +56,9 @@ pub mod ffi {
         fn c_take_primitive(n: usize);
         fn c_take_shared(shared: Shared);
         fn c_take_box(r: Box<R>);
+        fn c_take_box_shared(shared: Box<Shared>);
+        fn c_take_unique_ptr(c: UniquePtr<C>);
+        fn c_take_unique_ptr_shared(s: UniquePtr<Shared>);
         fn c_take_ref_r(r: &R);
         fn c_take_ref_c(c: &C);
         fn c_take_str(s: &str);
diff --git a/tests/ffi/tests.cc b/tests/ffi/tests.cc
@@ -67,6 +67,10 @@ rust::Slice<uint8_t> c_return_sliceu8(const Shared &shared) {
 
 rust::String c_return_rust_string() { return "2020"; }
 
+std::unique_ptr<Shared> c_return_unique_ptr_shared() {
+  return std::unique_ptr<Shared>(new Shared{2020});
+}
+
 std::unique_ptr<std::string> c_return_unique_ptr_string() {
   return std::unique_ptr<std::string>(new std::string("2020"));
 }
@@ -161,12 +165,24 @@ void c_take_box(rust::Box<R> r) {
   }
 }
 
+void c_take_box_shared(rust::Box<Shared> shared) {
+  if (shared->z == 2020) {
+    cxx_test_suite_set_correct();
+  }
+}
+
 void c_take_unique_ptr(std::unique_ptr<C> c) {
   if (c->get() == 2020) {
     cxx_test_suite_set_correct();
   }
 }
 
+void c_take_unique_ptr_shared(std::unique_ptr<Shared> shared) {
+  if (shared->z == 2020) {
+    cxx_test_suite_set_correct();
+  }
+}
+
 void c_take_ref_r(const R &r) {
   if (cxx_test_suite_r_is_correct(&r)) {
     cxx_test_suite_set_correct();
diff --git a/tests/ffi/tests.h b/tests/ffi/tests.h
@@ -40,6 +40,7 @@ size_t &c_return_mut(Shared &shared);
 rust::Str c_return_str(const Shared &shared);
 rust::Slice<uint8_t> c_return_sliceu8(const Shared &shared);
 rust::String c_return_rust_string();
+std::unique_ptr<Shared> c_return_unique_ptr_shared();
 std::unique_ptr<std::string> c_return_unique_ptr_string();
 std::unique_ptr<std::vector<uint8_t>> c_return_unique_ptr_vector_u8();
 std::unique_ptr<std::vector<double>> c_return_unique_ptr_vector_f64();
@@ -59,7 +60,9 @@ Enum c_return_enum(uint16_t n);
 void c_take_primitive(size_t n);
 void c_take_shared(Shared shared);
 void c_take_box(rust::Box<R> r);
+void c_take_box_shared(rust::Box<Shared> shared);
 void c_take_unique_ptr(std::unique_ptr<C> c);
+void c_take_unique_ptr_shared(std::unique_ptr<Shared> shared);
 void c_take_ref_r(const R &r);
 void c_take_ref_c(const C &c);
 void c_take_str(rust::Str s);
@@ -102,14 +105,21 @@ rust::Vec<rust::String> c_try_return_rust_vec_string();
 const rust::Vec<uint8_t> &c_try_return_ref_rust_vec(const C &c);
 
 const auto alias_c_return_shared = c_return_shared;
+const auto alias_c_return_unique_ptr = c_return_unique_ptr;
 const auto alias_c_return_ref = c_return_ref;
 const auto alias_c_return_mut = c_return_mut;
 const auto alias_c_return_enum = c_return_enum;
+const auto alias_c_return_unique_ptr_shared = c_return_unique_ptr_shared;
 const auto alias_c_return_unique_ptr_vector_shared =
     c_return_unique_ptr_vector_shared;
+
+const auto alias_c_take_shared = c_take_shared;
+const auto alias_c_take_box_shared = c_take_box_shared;
+const auto alias_c_take_unique_ptr = c_take_unique_ptr;
+const auto alias_c_take_unique_ptr_shared = c_take_unique_ptr_shared;
 const auto alias_c_take_unique_ptr_vector_shared =
     c_take_unique_ptr_vector_shared;
-const auto alias_c_take_shared = c_take_shared;
+const auto alias_c_take_rust_vec_shared = c_take_rust_vec_shared;
 const auto alias_c_take_enum = c_take_enum;
 
 } // namespace tests
diff --git a/tests/test.rs b/tests/test.rs
@@ -116,8 +116,12 @@ fn test_c_take() {
     check!(ffi::c_take_primitive(2020));
     check!(ffi::c_take_shared(ffi::Shared { z: 2020 }));
     check!(ffi::c_take_box(Box::new(2020)));
+    check!(ffi::c_take_box_shared(Box::new(ffi::Shared { z: 2020 })));
     check!(ffi::c_take_ref_c(&unique_ptr));
-    check!(alias::ffi::c_take_unique_ptr(unique_ptr));
+    check!(ffi::c_take_unique_ptr(unique_ptr));
+    check!(ffi::c_take_unique_ptr_shared(
+        ffi::c_return_unique_ptr_shared()
+    ));
     check!(ffi::c_take_str("2020"));
     check!(ffi::c_take_sliceu8(b"2020"));
     check!(ffi::c_take_rust_string("2020".to_owned()));
@@ -151,11 +155,24 @@ fn test_c_take() {
 
 #[test]
 fn test_alias_c_take() {
+    let unique_ptr = alias::ffi::alias_c_return_unique_ptr();
+
     check!(alias::ffi::alias_c_take_shared(ffi::Shared { z: 2020 }));
-    check!(alias::ffi::alias_c_take_enum(ffi::Enum::AVal));
+    check!(alias::ffi::alias_c_take_box_shared(Box::new(ffi::Shared {
+        z: 2020
+    })));
+    check!(alias::ffi::alias_c_take_unique_ptr(unique_ptr));
+    check!(alias::ffi::alias_c_take_unique_ptr_shared(
+        alias::ffi::alias_c_return_unique_ptr_shared()
+    ));
     check!(alias::ffi::alias_c_take_unique_ptr_vector_shared(
         alias::ffi::alias_c_return_unique_ptr_vector_shared()
     ));
+    let shared_test_vec = vec![ffi::Shared { z: 1010 }, ffi::Shared { z: 1011 }];
+    check!(alias::ffi::alias_c_take_rust_vec_shared(
+        shared_test_vec.clone()
+    ));
+    check!(alias::ffi::alias_c_take_enum(ffi::Enum::AVal));
 }
 
 /*

Original file line number	Diff line number	Diff line change
`@@ -65,13 +65,13 @@ fn expand(ffi: Module, apis: &[Api], types: &Types) -> TokenStream {`
`65`	`65`	`for ty in types {`
`66`	`66`	`if let Type::RustBox(ty) = ty {`
`67`	`67`	`if let Type::Ident(ident) = &ty.inner {`
`68`		`- if Atom::from(ident).is_none() {`
	`68`	`+ if Atom::from(ident).is_none() && !types.aliases.contains_key(ident) {`
`69`	`69`	`hidden.extend(expand_rust_box(namespace, ident));`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`	`} else if let Type::RustVec(ty) = ty {`
`73`	`73`	`if let Type::Ident(ident) = &ty.inner {`
`74`		`- if Atom::from(ident).is_none() {`
	`74`	`+ if Atom::from(ident).is_none() && !types.aliases.contains_key(ident) {`
`75`	`75`	`hidden.extend(expand_rust_vec(namespace, ident));`
`76`	`76`	`}`
`77`	`77`	`}`