Merge pull request 1670 from anforowicz/test-that-original-lifetimes-are-used-in-impls

Author: dtolnay

macro/src/tests.rs

@@ -7,7 +7,14 @@ use syn::File;
 fn bridge(cxx_bridge: TokenStream) -> String {
     let module = syn::parse2::<Module>(cxx_bridge).unwrap();
     let tokens = expand::bridge(module).unwrap();
-    let file = syn::parse2::<File>(tokens).unwrap();
+    let file = match syn::parse2::<File>(tokens.clone()) {
+        Ok(file) => file,
+        Err(err) => {
+            eprintln!("The code below is syntactically invalid: {err}:");
+            eprintln!("{tokens}");
+            panic!("`expand::bridge` should generate syntactically valid code");
+        }
+    };
     let pretty = prettyplease::unparse(&file);
     eprintln!("{0:/<80}\n{pretty}{0:/<80}", "");
     pretty
@@ -84,3 +91,68 @@ 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>)"));
 }
+
+#[test]
+fn test_mangling_covers_cpp_namespace_of_vec_elements() {
+    let rs = bridge(quote! {
+        mod ffi {
+            #[namespace = "test_namespace"]
+            struct Context { x: i32 }
+            impl Vec<Context> {}
+        }
+    });
+
+    // Mangling must include Context's C++ namespace to avoid colliding the
+    // symbol names for two identically named structs in different namespaces.
+    assert!(rs.contains("export_name = \"cxxbridge1$rust_vec$test_namespace$Context$set_len\""));
+}
+
+#[test]
+fn test_struct_with_lifetime() {
+    let rs = bridge(quote! {
+        mod ffi {
+            struct StructWithLifetime<'a> {
+                s: &'a str,
+            }
+            extern "Rust" {
+                fn f(_: UniquePtr<StructWithLifetime<>>);
+            }
+        }
+    });
+
+    // Regression test for <https://github.com/dtolnay/cxx/pull/1658#discussion_r2529463814>
+    // which generated this invalid code:
+    //
+    //     impl<'a> ::cxx::memory::UniquePtrTarget for StructWithLifetime < > < 'a > {
+    //
+    // Invalid syntax in the output code would already have caused the test
+    // helper `bridge` to panic above. But for completeness this assertion
+    // verifies the intended code has been generated.
+    assert!(rs.contains("impl<'a> ::cxx::memory::UniquePtrTarget for StructWithLifetime<'a> {"));
+
+    // Assertions for other places that refer to `StructWithLifetime`.
+    assert!(rs.contains("pub struct StructWithLifetime<'a> {"));
+    assert!(rs.contains("cast::<StructWithLifetime<'a>>()"));
+    assert!(rs.contains("fn __f(arg0: ::cxx::UniquePtr<StructWithLifetime>) {"));
+    assert!(rs.contains("impl<'a> self::Drop for super::StructWithLifetime<'a>"));
+}
+
+#[test]
+fn test_original_lifetimes_used_in_impls() {
+    let rs = bridge(quote! {
+        mod ffi {
+            struct Context<'sess> {
+                session: &'sess str,
+            }
+            struct Server<'srv> {
+                ctx: UniquePtr<Context<'srv>>,
+            }
+            struct Client<'clt> {
+                ctx: UniquePtr<Context<'clt>>,
+            }
+        }
+    });
+
+    // Verify which lifetime name ('sess, 'srv, 'clt) gets used for this impl.
+    assert!(rs.contains("impl<'sess> ::cxx::memory::UniquePtrTarget for Context<'sess> {"));
+}

tests/ffi/lib.rs

@@ -388,6 +388,19 @@ pub mod ffi {
     impl UniquePtr<Array> {}
 }
 
+#[rustfmt::skip]
+#[cxx::bridge(namespace = "tests")]
+pub mod ffi_no_rustfmt {
+    // Rustfmt would replace `StructWithLifetime2<>` by `StructWithLifetime2`,
+    // but the test is meant to cover specifically the former spelling.
+    pub struct StructWithLifetime2<'a> {
+        s: &'a str,
+    }
+    extern "Rust" {
+        fn r_take_unique_ptr_of_struct_with_lifetime2(_: UniquePtr<StructWithLifetime2<>>);
+    }
+}
+
 mod other {
     use cxx::kind::{Opaque, Trivial};
     use cxx::{type_id, CxxString, ExternType};
@@ -691,6 +704,11 @@ fn r_take_enum(e: ffi::Enum) {
     let _ = e;
 }
 
+fn r_take_unique_ptr_of_struct_with_lifetime2(
+    _: cxx::UniquePtr<ffi_no_rustfmt::StructWithLifetime2>,
+) {
+}
+
 fn r_try_return_void() -> Result<(), Error> {
     Ok(())
 }