Introduce cpp_pin_uniqueptr to allow swapping impls later

engine/src/conversion/codegen_rs/mod.rs

@@ -204,16 +204,19 @@ fn get_cppref_items() -> Vec<Item> {
         }),
         Item::Impl(parse_quote! {
             impl<T: ::cxx::private::UniquePtrTarget> CppUniquePtrPin<T> {
-                /// Make this object available to C++ by reference.
-                /// This takes ownership of the object, thus proving you
-                /// have no existing Rust references. Any reference to this
-                /// object from Rust after this point is unsafe, since Rust
-                /// and C++ reference semantics are incompatible.
                 pub fn new(item: ::cxx::UniquePtr<T>) -> Self {
                     Self(item)
                 }
             }
         }),
+        Item::Fn(parse_quote! {
+            /// Pin this item so that we can create C++ references to it.
+            /// This makes it impossible to hold Rust references because Rust
+            /// references are fundamentally incompatible with C++ references.
+            pub fn cpp_pin_uniqueptr<T: ::cxx::private::UniquePtrTarget> (item: ::cxx::UniquePtr<T>) -> CppUniquePtrPin<T> {
+                CppUniquePtrPin::new(item)
+            }
+        })
     ]
     .to_vec()
 }

examples/reference-wrappers/src/main.rs

@@ -17,7 +17,7 @@ include_cpp! {
 
 fn main() {
     let field = ffi::Field::new().within_unique_ptr();
-    let field = ffi::CppUniquePtrPin::new(field);
+    let field = ffi::cpp_pin_uniqueptr(field);
     let another_goat = field.as_cpp_ref().get_goat();
     assert_eq!(
         another_goat

integration-tests/tests/cpprefs_test.rs

@@ -87,7 +87,7 @@ fn test_method_call_const() {
     "},
         quote! {
             let goat = ffi::Goat::new().within_unique_ptr();
-            let goat = ffi::CppUniquePtrPin::new(goat);
+            let goat = ffi::cpp_pin_uniqueptr(goat);
             goat.as_cpp_ref().describe();
         },
         &["Goat"],