Allow returning structs if copy (#19)

* Allow returning structs if copy

This commit does three things:
1. enables marshalling of structs as return args from interface funcs
   but so far *only* for the case when the struct itself is copy
2. puts bits that use `std::convert::TryInto` in a local scope to avoid
   multiple reimports
3. for added clarity, we now print for which `tref` type the marshalling
   of results is unimplemented

The first case (1.) is required to make `fd_fdstat_get` WASI interface
func work which returns `Fdstat` struct (which is copy). The second
case (2.) caused me some grief somewhere along the lines when I was
playing with snapshot1. Putting the code that requires it inside a local
scope fixed all the issues

* Add proptests for returing struct if copyable

* Use write_ptr_to_guest to marshal value to guest

* Successfully return non-copy struct

crates/generate/src/funcs.rs

@@ -141,11 +141,13 @@ fn marshal_arg(
     let try_into_conversion = {
         let name = names.func_param(&param.name);
         quote! {
-            use ::std::convert::TryInto;
-            let #name: #interface_typename = match #name.try_into() {
-                Ok(a) => a,
-                Err(e) => {
-                    #error_handling
+            let #name: #interface_typename = {
+                use ::std::convert::TryInto;
+                match #name.try_into() {
+                    Ok(a) => a,
+                    Err(e) => {
+                        #error_handling
+                    }
                 }
             };
         }
@@ -322,15 +324,9 @@ where
         // core type is given func_ptr_binding name.
         let ptr_name = names.func_ptr_binding(&result.name);
         let ptr_err_handling = error_handling(&format!("{}:result_ptr_mut", result.name.as_str()));
-        let ref_err_handling = error_handling(&format!("{}:result_ref_mut", result.name.as_str()));
         let pre = quote! {
             let mut #ptr_name = match memory.ptr_mut::<#pointee_type>(#ptr_name as u32) {
-                Ok(p) => match p.as_ref_mut() {
-                    Ok(r) => r,
-                    Err(e) => {
-                        #ref_err_handling
-                    }
-                },
+                Ok(p) => p,
                 Err(e) => {
                     #ptr_err_handling
                 }
@@ -339,7 +335,7 @@ where
         // trait binding returns func_param name.
         let val_name = names.func_param(&result.name);
         let post = quote! {
-            *#ptr_name = #val_name;
+            #ptr_name.write_ptr_to_guest(&#val_name);
         };
         (pre, post)
     };
@@ -361,6 +357,7 @@ where
             witx::BuiltinType::String => unimplemented!("string types"),
         },
         witx::Type::Enum(_) | witx::Type::Flags(_) | witx::Type::Int(_) => write_val_to_ptr,
-        _ => unimplemented!("marshal result"),
+        witx::Type::Struct(_) => write_val_to_ptr,
+        _ => unimplemented!("missing marshalling result for {:?}", &*tref.type_()),
     }
 }

crates/generate/src/module_trait.rs

@@ -2,16 +2,25 @@ use proc_macro2::TokenStream;
 use quote::quote;
 
 use crate::names::Names;
-use crate::types::anon_lifetime;
+use crate::types::{anon_lifetime, type_needs_lifetime};
 use witx::Module;
 
 pub fn define_module_trait(names: &Names, m: &Module) -> TokenStream {
     let traitname = names.trait_name(&m.name);
     let traitmethods = m.funcs().map(|f| {
+        // Check if we're returning an entity anotated with a lifetime,
+        // in which case, we'll need to annotate the function itself, and
+        // hence will need an explicit lifetime (rather than anonymous)
+        let (lifetime, is_anonymous) = if f.results.iter().any(|ret| type_needs_lifetime(&ret.tref))
+        {
+            (quote!('a), false)
+        } else {
+            (anon_lifetime(), true)
+        };
         let funcname = names.func(&f.name);
         let args = f.params.iter().map(|arg| {
             let arg_name = names.func_param(&arg.name);
-            let arg_typename = names.type_ref(&arg.tref, anon_lifetime());
+            let arg_typename = names.type_ref(&arg.tref, lifetime.clone());
             let arg_type = match arg.tref.type_().passed_by() {
                 witx::TypePassedBy::Value { .. } => quote!(#arg_typename),
                 witx::TypePassedBy::Pointer { .. } => quote!(&#arg_typename),
@@ -23,13 +32,18 @@ pub fn define_module_trait(names: &Names, m: &Module) -> TokenStream {
             .results
             .iter()
             .skip(1)
-            .map(|ret| names.type_ref(&ret.tref, anon_lifetime()));
+            .map(|ret| names.type_ref(&ret.tref, lifetime.clone()));
         let err = f
             .results
             .get(0)
-            .map(|err_result| names.type_ref(&err_result.tref, anon_lifetime()))
+            .map(|err_result| names.type_ref(&err_result.tref, lifetime.clone()))
             .unwrap_or(quote!(()));
-        quote!(fn #funcname(&mut self, #(#args),*) -> Result<(#(#rets),*), #err>;)
+
+        if is_anonymous {
+            quote!(fn #funcname(&mut self, #(#args),*) -> Result<(#(#rets),*), #err>;)
+        } else {
+            quote!(fn #funcname<#lifetime>(&mut self, #(#args),*) -> Result<(#(#rets),*), #err>;)
+        }
     });
     quote! {
         pub trait #traitname {