Fix lifetimes in CppRef<'a, T> return types.

Previously these types did contain a lifetime, but we didn't parameterize the
function by a lifetime.

Author: adetaylor

engine/src/conversion/codegen_rs/fun_codegen.rs

@@ -133,6 +133,7 @@ pub(super) fn gen_function(
         params,
         Cow::Borrowed(&ret_type),
         non_pod_types,
+        &ret_conversion,
     );
 
     if analysis.rust_wrapper_needed {
@@ -308,6 +309,7 @@ impl<'a> FnGenerator<'a> {
             wrapper_params,
             ret_type,
             self.non_pod_types,
+            self.ret_conversion,
         );
 
         let cxxbridge_name = self.cxxbridge_name;

engine/src/conversion/codegen_rs/lifetime.rs

@@ -7,7 +7,8 @@
 // except according to those terms.
 use crate::{
     conversion::analysis::fun::{
-        function_wrapper::RustConversionType, ArgumentAnalysis, ReceiverMutability,
+        function_wrapper::{RustConversionType, TypeConversionPolicy},
+        ArgumentAnalysis, ReceiverMutability,
     },
     types::QualifiedName,
 };
@@ -22,7 +23,7 @@ use syn::{
 
 /// Function which can add explicit lifetime parameters to function signatures
 /// where necessary, based on analysis of parameters and return types.
-/// This is necessary in three cases:
+/// This is necessary in four cases:
 /// 1) where the parameter is a Pin<&mut T>
 ///    and the return type is some kind of reference - because lifetime elision
 ///    is not smart enough to see inside a Pin.
@@ -31,11 +32,13 @@ use syn::{
 ///    built-in type
 /// 3) Any parameter is any form of reference, and we're returning an `impl New`
 ///    3a) an 'impl ValueParam' counts as a reference.
+/// 4) If we're using CppRef<'a, T> as a return type
 pub(crate) fn add_explicit_lifetime_if_necessary<'r>(
     param_details: &[ArgumentAnalysis],
     mut params: Punctuated<FnArg, Comma>,
     ret_type: Cow<'r, ReturnType>,
     non_pod_types: &HashSet<QualifiedName>,
+    ret_conversion: &Option<TypeConversionPolicy>,
 ) -> (
     Option<TokenStream>,
     Punctuated<FnArg, Comma>,
@@ -54,11 +57,22 @@ pub(crate) fn add_explicit_lifetime_if_necessary<'r>(
             )
     });
     let return_type_is_impl = return_type_is_impl(&ret_type);
+    let return_type_is_cppref = matches!(
+        ret_conversion,
+        Some(TypeConversionPolicy {
+            rust_conversion: RustConversionType::FromPointerToReferenceWrapper,
+            ..
+        })
+    );
     let non_pod_ref_param = reference_parameter_is_non_pod_reference(&params, non_pod_types);
     let ret_type_pod = return_type_is_pod_or_known_type_reference(&ret_type, non_pod_types);
     let returning_impl_with_a_reference_param = return_type_is_impl && any_param_is_reference;
     let hits_1024_bug = non_pod_ref_param && ret_type_pod;
-    if !(has_mutable_receiver || hits_1024_bug || returning_impl_with_a_reference_param) {
+    if !(has_mutable_receiver
+        || hits_1024_bug
+        || returning_impl_with_a_reference_param
+        || return_type_is_cppref)
+    {
         return (None, params, ret_type);
     }
     let new_return_type = match ret_type.as_ref() {
@@ -83,6 +97,12 @@ pub(crate) fn add_explicit_lifetime_if_necessary<'r>(
                     #rarrow #old_tyit + 'a
                 })
             }
+            Type::Ptr(_) if return_type_is_cppref => {
+                // The ptr will be converted to CppRef<'a, T> elsewhere, so we
+                // just need to return the return type as-is such that the
+                // next match statement adds <'a> to the function.
+                Some(ret_type.clone().into_owned())
+            }
             _ => None,
         },
         _ => None,

integration-tests/tests/cpprefs_test.rs

@@ -124,8 +124,11 @@ fn test_return_reference_cpprefs() {
         const Bob& give_bob(const Bob& input_bob);
     "};
     let rs = quote! {
-        let b = ffi::Bob { a: 3, b: 4 };
-        assert_eq!(ffi::give_bob(&b).b, 4);
+        let b = CppPin::new(ffi::Bob { a: 3, b: 4 });
+        let b_ref = b.as_cpp_ref();
+        let bob = ffi::give_bob(&b_ref);
+        let val = unsafe { bob.as_ref() };
+        assert_eq!(val.b, 4);
     };
     run_cpprefs_test(cxx, hdr, rs, &["give_bob"], &["Bob"]);
-}
+}