Return values work

engine/src/conversion/analysis/fun/mod.rs

@@ -183,7 +183,7 @@ pub(crate) struct ArgumentAnalysis {
     pub(crate) is_placement_return_destination: bool,
 }
 
-struct ReturnTypeAnalysis {
+pub(crate) struct ReturnTypeAnalysis {
     rt: ReturnType,
     conversion: Option<TypeConversionPolicy>,
     was_reference: bool,
@@ -1213,6 +1213,7 @@ impl<'a> FnAnalyzer<'a> {
         let ret_type_conversion_needed = ret_type_conversion
             .as_ref()
             .map_or(false, |x| x.cpp_work_needed());
+        let return_needs_rust_conversion = ret_type_conversion.as_ref().map(|ra| ra.rust_work_needed()).unwrap_or_default();
 
         // See https://github.com/dtolnay/cxx/issues/878 for the reason for this next line.
         let effective_cpp_name = cpp_name.as_ref().unwrap_or(&rust_name);
@@ -1351,9 +1352,10 @@ impl<'a> FnAnalyzer<'a> {
             .any(|pd| pd.conversion.rust_work_needed());
 
         let rust_wrapper_needed = match kind {
+            _ if any_param_needs_rust_conversion || return_needs_rust_conversion => true,
             FnKind::TraitMethod { .. } => true,
-            FnKind::Method { .. } => any_param_needs_rust_conversion || cxxbridge_name != rust_name,
-            _ => any_param_needs_rust_conversion,
+            FnKind::Method { .. } => cxxbridge_name != rust_name,
+            _ => false,
         };
 
         // Naming, part two.
@@ -1929,13 +1931,15 @@ impl<'a> FnAnalyzer<'a> {
                     }
                     _ => {
                         let was_reference = references.ref_return;
+                        log::info!("ADE FOO wr={}", was_reference);
                         let conversion = Some(
                             if was_reference
                                 && matches!(
                                     self.config.unsafe_policy,
                                     UnsafePolicy::ReferencesWrappedAllFunctionsSafe
                                 )
                             {
+                                log::info!("ADE FOO@");
                                 TypeConversionPolicy::return_reference_into_wrapper(ty.clone())
                             } else {
                                 TypeConversionPolicy::new_unconverted(ty.clone())

engine/src/conversion/codegen_rs/fun_codegen.rs

@@ -29,7 +29,7 @@ use crate::{
     conversion::{
         analysis::fun::{
             ArgumentAnalysis, FnAnalysis, FnKind, MethodKind, RustRenameStrategy,
-            TraitMethodDetails,
+            TraitMethodDetails, function_wrapper::TypeConversionPolicy,
         },
         api::{Pointerness, UnsafetyNeeded},
     },
@@ -96,6 +96,7 @@ pub(super) fn gen_function(
     let cxxbridge_name = analysis.cxxbridge_name;
     let rust_name = &analysis.rust_name;
     let ret_type = analysis.ret_type;
+    let ret_conversion = analysis.ret_conversion;
     let param_details = analysis.param_details;
     let wrapper_function_needed = analysis.cpp_wrapper.is_some();
     let params = analysis.params;
@@ -119,6 +120,8 @@ pub(super) fn gen_function(
         always_unsafe_due_to_trait_definition,
         doc_attrs: &doc_attrs,
         non_pod_types,
+        ret_type: &ret_type,
+        ret_conversion: &ret_conversion,
     };
     // In rare occasions, we might need to give an explicit lifetime.
     let (lifetime_tokens, params, ret_type) = add_explicit_lifetime_if_necessary(
@@ -148,15 +151,14 @@ pub(super) fn gen_function(
                 impl_entry = Some(fn_generator.generate_method_impl(
                     matches!(method_kind, MethodKind::Constructor { .. }),
                     impl_for,
-                    &ret_type,
                 ));
             }
             FnKind::TraitMethod { ref details, .. } => {
-                trait_impl_entry = Some(fn_generator.generate_trait_impl(details, &ret_type));
+                trait_impl_entry = Some(fn_generator.generate_trait_impl(details));
             }
             _ => {
                 // Generate plain old function
-                bindgen_mod_items.push(fn_generator.generate_function_impl(&ret_type));
+                bindgen_mod_items.push(fn_generator.generate_function_impl());
             }
         }
     }
@@ -225,6 +227,8 @@ pub(super) fn gen_function(
 #[derive(Clone)]
 struct FnGenerator<'a> {
     param_details: &'a [ArgumentAnalysis],
+    ret_conversion: &'a Option<TypeConversionPolicy>,
+    ret_type: &'a ReturnType,
     cxxbridge_name: &'a Ident,
     rust_name: &'a str,
     unsafety: &'a UnsafetyNeeded,
@@ -235,10 +239,10 @@ struct FnGenerator<'a> {
 
 impl<'a> FnGenerator<'a> {
     fn common_parts<'b>(
-        &self,
+        &'b self,
         avoid_self: bool,
         parameter_reordering: &Option<Vec<usize>>,
-        ret_type: &'b ReturnType,
+        ret_type: Option<ReturnType>,
     ) -> (
         Option<TokenStream>,
         Punctuated<FnArg, Comma>,
@@ -249,15 +253,15 @@ impl<'a> FnGenerator<'a> {
         let mut local_variables = Vec::new();
         let mut arg_list = Vec::new();
         let mut ptr_arg_name = None;
-        let mut ret_type = Cow::Borrowed(ret_type);
+        let mut ret_type: Cow<'a,_> = ret_type.map(Cow::Owned).unwrap_or(Cow::Borrowed(self.ret_type));
         let mut any_conversion_requires_unsafe = false;
         for pd in self.param_details {
             let wrapper_arg_name = if pd.self_type.is_some() && !avoid_self {
                 parse_quote!(self)
             } else {
                 pd.name.clone()
             };
-            let rust_for_param = pd.conversion.rust_conversion(wrapper_arg_name.clone());
+            let rust_for_param = pd.conversion.rust_conversion(parse_quote! { #wrapper_arg_name });
             match rust_for_param {
                 RustParamConversion::Param {
                     ty,
@@ -305,6 +309,26 @@ impl<'a> FnGenerator<'a> {
             },
             any_conversion_requires_unsafe || matches!(self.unsafety, UnsafetyNeeded::JustBridge),
         );
+        let context_is_unsafe = matches!(self.unsafety, UnsafetyNeeded::Always)
+            || self.always_unsafe_due_to_trait_definition;
+        let (call_body, ret_type) = match self.ret_conversion {
+            Some(ret_conversion) if ret_conversion.rust_work_needed() => {
+                let expr = maybe_unsafes_to_tokens(vec![call_body], context_is_unsafe);
+                let conv = ret_conversion.rust_conversion(parse_quote! { #expr });
+                let (conversion, requires_unsafe, ty) = match conv {
+                    RustParamConversion::Param { local_variables, .. } if !local_variables.is_empty() => panic!("return type required variables"),
+                    RustParamConversion::Param { conversion, conversion_requires_unsafe, ty, .. } => (conversion, conversion_requires_unsafe, ty),
+                    _ => panic!("Unexpected - return type is supposed to be converted to a return type")
+                };
+                (if requires_unsafe {
+                    MaybeUnsafeStmt::NeedsUnsafe(conversion)
+                } else {
+                    MaybeUnsafeStmt::Normal(conversion)
+                }, Cow::Owned(parse_quote! { -> #ty }))
+            },
+            _ => (call_body, ret_type),
+        };
+
         let call_stmts = if let Some(ptr_arg_name) = ptr_arg_name {
             let mut closure_stmts = local_variables;
             closure_stmts.push(MaybeUnsafeStmt::binary(
@@ -323,8 +347,6 @@ impl<'a> FnGenerator<'a> {
             call_stmts.push(call_body);
             call_stmts
         };
-        let context_is_unsafe = matches!(self.unsafety, UnsafetyNeeded::Always)
-            || self.always_unsafe_due_to_trait_definition;
         let call_body = maybe_unsafes_to_tokens(call_stmts, context_is_unsafe);
         (lifetime_tokens, wrapper_params, ret_type, call_body)
     }
@@ -334,10 +356,9 @@ impl<'a> FnGenerator<'a> {
         &self,
         avoid_self: bool,
         impl_block_type_name: &QualifiedName,
-        ret_type: &ReturnType,
     ) -> Box<ImplBlockDetails> {
         let (lifetime_tokens, wrapper_params, ret_type, call_body) =
-            self.common_parts(avoid_self, &None, ret_type);
+            self.common_parts(avoid_self, &None, None);
         let rust_name = make_ident(self.rust_name);
         let unsafety = self.unsafety.wrapper_token();
         let doc_attrs = self.doc_attrs;
@@ -381,10 +402,9 @@ impl<'a> FnGenerator<'a> {
     fn generate_trait_impl(
         &self,
         details: &TraitMethodDetails,
-        ret_type: &ReturnType,
     ) -> Box<TraitImplBlockDetails> {
         let (lifetime_tokens, wrapper_params, ret_type, call_body) =
-            self.common_parts(details.avoid_self, &details.parameter_reordering, ret_type);
+            self.common_parts(details.avoid_self, &details.parameter_reordering, None);
         let doc_attrs = self.doc_attrs;
         let unsafety = self.unsafety.wrapper_token();
         let key = details.trt.clone();
@@ -406,7 +426,7 @@ impl<'a> FnGenerator<'a> {
     ) -> Box<ImplBlockDetails> {
         let ret_type: ReturnType = parse_quote! { -> impl autocxx::moveit::new::New<Output=Self> };
         let (lifetime_tokens, wrapper_params, ret_type, call_body) =
-            self.common_parts(true, &None, &ret_type);
+            self.common_parts(true, &None, Some(ret_type));
         let rust_name = make_ident(&self.rust_name);
         let doc_attrs = self.doc_attrs;
         let unsafety = self.unsafety.wrapper_token();
@@ -425,9 +445,9 @@ impl<'a> FnGenerator<'a> {
     }
 
     /// Generate a function call wrapper
-    fn generate_function_impl(&self, ret_type: &ReturnType) -> Item {
+    fn generate_function_impl(&self) -> Item {
         let (lifetime_tokens, wrapper_params, ret_type, call_body) =
-            self.common_parts(false, &None, ret_type);
+            self.common_parts(false, &None, None);
         let rust_name = make_ident(self.rust_name);
         let doc_attrs = self.doc_attrs;
         let unsafety = self.unsafety.wrapper_token();

engine/src/conversion/codegen_rs/function_wrapper_rs.rs

@@ -7,7 +7,7 @@
 // except according to those terms.
 
 use proc_macro2::TokenStream;
-use syn::{Pat, Type, TypePtr};
+use syn::{Type, TypePtr, Expr};
 
 use crate::{
     conversion::analysis::fun::function_wrapper::{RustConversionType, TypeConversionPolicy},
@@ -32,8 +32,7 @@ pub(super) enum RustParamConversion {
 }
 
 impl TypeConversionPolicy {
-    /// If returns `None` then this parameter should be omitted entirely.
-    pub(super) fn rust_conversion(&self, var: Pat) -> RustParamConversion {
+    pub(super) fn rust_conversion(&self, var: Expr) -> RustParamConversion {
         match self.rust_conversion {
             RustConversionType::None => RustParamConversion::Param {
                 ty: self.converted_rust_type(),
@@ -123,12 +122,7 @@ impl TypeConversionPolicy {
                 };
                 let handler_type = make_ident(handler_type);
                 let param_trait = make_ident(param_trait);
-                let var_name = if let Pat::Ident(pti) = &var {
-                    &pti.ident
-                } else {
-                    panic!("Unexpected non-ident parameter name");
-                };
-                let space_var_name = make_ident(format!("{}_space", var_name));
+                let space_var_name = make_ident("foo_space"); // TODO
                 let ty = &self.unwrapped_type;
                 let ty = parse_quote! { impl autocxx::#param_trait<#ty> };
                 // This is the usual trick to put something on the stack, then
@@ -148,7 +142,7 @@ impl TypeConversionPolicy {
                             },
                         ),
                         MaybeUnsafeStmt::needs_unsafe(
-                            quote! { #space_var_name.as_mut().populate(#var_name); },
+                            quote! { #space_var_name.as_mut().populate(#var); },
                         ),
                     ],
                     conversion: quote! {
@@ -177,16 +171,16 @@ impl TypeConversionPolicy {
                     _ => panic!("Not a pointer")
                 };
                 let (ty, wrapper_name) = if is_mut {
-                    (parse_quote! { &mut CppMutRef<'a, #ty> }, "CppMutRef")
+                    (parse_quote! { CppMutRef<'a, #ty> }, "CppMutRef")
                 } else {
-                    (parse_quote! { &CppRef<'a, #ty> }, "CppRef")
+                    (parse_quote! { CppRef<'a, #ty> }, "CppRef")
                 };
                 let wrapper_name = make_ident(wrapper_name);
                 RustParamConversion::Param {
                     ty,
                     local_variables: Vec::new(),
                     conversion: quote! {
-                        #wrapper_name (#var)
+                        #wrapper_name (#var, std::marker::PhantomData)
                     },
                     conversion_requires_unsafe: false,
                 }

examples/reference-wrappers/src/main.rs

@@ -28,10 +28,10 @@ fn main() {
         "This goat has 2 horns."
     );
     let mut field = ffi::Field::new().within_box();
-    let mut field = ffi::CppMutRef::from_box(&mut field);
+    let field = ffi::CppMutRef::from_box(&mut field);
     let another_goat = field.as_cpp_ref().get_goat();
     assert_eq!(
-        another_goat.as_cpp_ref()
+        another_goat
             .describe()
             .as_ref()
             .unwrap()