Get the Pin thing working

engine/src/conversion/codegen_rs/mod.rs

@@ -190,20 +190,21 @@ fn get_cppref_items() -> Vec<Item> {
             }
         }),
         Item::Struct(parse_quote! {
-            /// "Pins" an object so that C++-compatible references can be created.
+            /// "Pins" a `UniquePtr` to an object, so that C++-compatible references can be created.
             #[repr(transparent)]
-            pub struct CppPin<T>(T);
+            pub struct CppUniquePtrPin<T: ::cxx::private::UniquePtrTarget>(::cxx::UniquePtr<T>);
         }),
         Item::Impl(parse_quote! {
-            impl<'a, T: 'a> autocxx::CppPin<'a, T> for CppPin<T>
+            impl<'a, T: 'a + ::cxx::private::UniquePtrTarget> autocxx::CppPin<'a, T> for CppUniquePtrPin<T>
             {
                 type CppRef = CppRef<'a, T>;
                 type CppMutRef = CppMutRef<'a, T>;
                 fn as_ptr(&self) -> *const T {
-                    ::std::ptr::addr_of!(self.0)
+                    // TODO add as_ptr to cxx to avoid the ephemeral reference
+                    self.0.as_ref().unwrap() as *const T
                 }
                 fn as_mut_ptr(&mut self) -> *mut T {
-                    ::std::ptr::addr_of_mut!(self.0)
+                    unsafe { ::std::pin::Pin::into_inner_unchecked(self.0.as_mut().unwrap()) as *mut T  }
                 }
                 fn as_cpp_ref(&self) -> Self::CppRef {
                     CppRef(self.as_ptr(), ::std::marker::PhantomData)
@@ -214,13 +215,13 @@ fn get_cppref_items() -> Vec<Item> {
             }
         }),
         Item::Impl(parse_quote! {
-            impl<T> CppPin<T> {
+            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: T) -> CppPin<T> {
+                pub fn new(item: ::cxx::UniquePtr<T>) -> Self {
                     Self(item)
                 }
             }

examples/reference-wrappers/src/main.rs

@@ -16,33 +16,8 @@ include_cpp! {
 }
 
 fn main() {
-    let mut goat = ffi::Goat::new().within_box();
-    let mut goat = ffi::CppMutRef::from_box(&mut goat);
-    goat.add_a_horn();
-    goat.add_a_horn();
-    assert_eq!(
-        goat.as_cpp_ref()
-            .describe()
-            .as_ref()
-            .unwrap()
-            .to_string_lossy(),
-        "This goat has 2 horns."
-    );
-    let mut field = ffi::Field::new().within_box();
-    let field = ffi::CppMutRef::from_box(&mut field);
-    let another_goat = field.as_cpp_ref().get_goat();
-    assert_eq!(
-        another_goat
-            .describe()
-            .as_ref()
-            .unwrap()
-            .to_string_lossy(),
-        "This goat has 0 horns."
-    );
-
-
     let field = ffi::Field::new().within_unique_ptr();
-    let field = ffi::CppPin::new(field);
+    let field = ffi::CppUniquePtrPin::new(field);
     let another_goat = field.as_cpp_ref().get_goat();
     assert_eq!(
         another_goat

src/lib.rs

@@ -616,16 +616,16 @@ pub mod prelude {
     pub use crate::c_void;
     pub use crate::cpp_semantics;
     pub use crate::include_cpp;
+    pub use crate::CppMutRef;
+    pub use crate::CppPin;
+    pub use crate::CppRef;
     pub use crate::PinMut;
     pub use crate::RValueParam;
     pub use crate::ValueParam;
     pub use crate::WithinBox;
     pub use crate::WithinBoxTrivial;
     pub use crate::WithinUniquePtr;
     pub use crate::WithinUniquePtrTrivial;
-    pub use crate::CppMutRef;
-    pub use crate::CppRef;
-    pub use crate::CppPin;
     pub use cxx::UniquePtr;
     pub use moveit::moveit;
     pub use moveit::new::New;