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

tests/structs.rs

@@ -1,5 +1,5 @@
 use proptest::prelude::*;
-use wiggle_runtime::GuestError;
+use wiggle_runtime::{GuestError, GuestPtr};
 use wiggle_test::{impl_errno, HostMemory, MemArea, WasiCtx};
 
 wiggle_generate::from_witx!({
@@ -34,6 +34,21 @@ impl structs::Structs for WasiCtx {
         let second = an_pair.second as i64;
         Ok(first as i64 + second)
     }
+
+    fn return_pair_ints(&mut self) -> Result<types::PairInts, types::Errno> {
+        Ok(types::PairInts {
+            first: 10,
+            second: 20,
+        })
+    }
+
+    fn return_pair_of_ptrs<'a>(
+        &mut self,
+        first: GuestPtr<'a, i32>,
+        second: GuestPtr<'a, i32>,
+    ) -> Result<types::PairIntPtrs<'a>, types::Errno> {
+        Ok(types::PairIntPtrs { first, second })
+    }
 }
 
 #[derive(Debug)]
@@ -297,3 +312,146 @@ proptest! {
         e.test()
     }
 }
+
+#[derive(Debug)]
+struct ReturnPairInts {
+    pub return_loc: MemArea,
+}
+
+impl ReturnPairInts {
+    pub fn strat() -> BoxedStrategy<Self> {
+        HostMemory::mem_area_strat(8)
+            .prop_map(|return_loc| ReturnPairInts { return_loc })
+            .boxed()
+    }
+
+    pub fn test(&self) {
+        let mut ctx = WasiCtx::new();
+        let mut host_memory = HostMemory::new();
+        let mut guest_memory = host_memory.guest_memory();
+
+        let err =
+            structs::return_pair_ints(&mut ctx, &mut guest_memory, self.return_loc.ptr as i32);
+
+        assert_eq!(err, types::Errno::Ok.into(), "return struct errno");
+
+        let return_struct: types::PairInts = *guest_memory
+            .ptr(self.return_loc.ptr)
+            .expect("return ptr")
+            .as_ref()
+            .expect("return ref");
+
+        assert_eq!(
+            return_struct,
+            types::PairInts {
+                first: 10,
+                second: 20
+            },
+            "return_pair_ints return value"
+        );
+    }
+}
+
+proptest! {
+    #[test]
+    fn return_pair_ints(e in ReturnPairInts::strat()) {
+        e.test();
+    }
+}
+
+#[derive(Debug)]
+struct ReturnPairPtrsExercise {
+    input_first: i32,
+    input_second: i32,
+    input_first_loc: MemArea,
+    input_second_loc: MemArea,
+    return_loc: MemArea,
+}
+
+impl ReturnPairPtrsExercise {
+    pub fn strat() -> BoxedStrategy<Self> {
+        (
+            prop::num::i32::ANY,
+            prop::num::i32::ANY,
+            HostMemory::mem_area_strat(4),
+            HostMemory::mem_area_strat(4),
+            HostMemory::mem_area_strat(8),
+        )
+            .prop_map(
+                |(input_first, input_second, input_first_loc, input_second_loc, return_loc)| {
+                    ReturnPairPtrsExercise {
+                        input_first,
+                        input_second,
+                        input_first_loc,
+                        input_second_loc,
+                        return_loc,
+                    }
+                },
+            )
+            .prop_filter("non-overlapping pointers", |e| {
+                MemArea::non_overlapping_set(&[
+                    &e.input_first_loc,
+                    &e.input_second_loc,
+                    &e.return_loc,
+                ])
+            })
+            .boxed()
+    }
+    pub fn test(&self) {
+        let mut ctx = WasiCtx::new();
+        let mut host_memory = HostMemory::new();
+        let mut guest_memory = host_memory.guest_memory();
+
+        *guest_memory
+            .ptr_mut(self.input_first_loc.ptr)
+            .expect("input_first ptr")
+            .as_ref_mut()
+            .expect("input_first ref") = self.input_first;
+        *guest_memory
+            .ptr_mut(self.input_second_loc.ptr)
+            .expect("input_second ptr")
+            .as_ref_mut()
+            .expect("input_second ref") = self.input_second;
+
+        let res = structs::return_pair_of_ptrs(
+            &mut ctx,
+            &mut guest_memory,
+            self.input_first_loc.ptr as i32,
+            self.input_second_loc.ptr as i32,
+            self.return_loc.ptr as i32,
+        );
+
+        assert_eq!(res, types::Errno::Ok.into(), "return pair of ptrs errno");
+
+        let ptr_pair_int_ptrs: GuestPtr<types::PairIntPtrs<'_>> =
+            guest_memory.ptr(self.return_loc.ptr).expect("return ptr");
+        let ret_first_ptr: GuestPtr<i32> = ptr_pair_int_ptrs
+            .cast::<GuestPtr<i32>>(0u32)
+            .expect("extract ptr to first element in struct")
+            .clone_from_guest()
+            .expect("read ptr to first element in struct");
+        let ret_second_ptr: GuestPtr<i32> = ptr_pair_int_ptrs
+            .cast::<GuestPtr<i32>>(4u32)
+            .expect("extract ptr to second element in struct")
+            .clone_from_guest()
+            .expect("read ptr to second element in struct");
+        assert_eq!(
+            self.input_first,
+            *ret_first_ptr
+                .as_ref()
+                .expect("deref extracted ptr to first element")
+        );
+        assert_eq!(
+            self.input_second,
+            *ret_second_ptr
+                .as_ref()
+                .expect("deref extracted ptr to second element")
+        );
+    }
+}
+proptest! {
+    #[test]
+    fn return_pair_of_ptrs(e in ReturnPairPtrsExercise::strat()) {
+        e.test()
+    }
+}

tests/structs.witx

@@ -29,4 +29,12 @@
     (param $an_pair $pair_int_and_ptr)
     (result $error $errno)
     (result $double s64))
+  (@interface func (export "return_pair_ints")
+    (result $error $errno)
+    (result $an_pair $pair_ints))
+  (@interface func (export "return_pair_of_ptrs")
+    (param $first (@witx const_pointer s32))
+    (param $second (@witx const_pointer s32))
+    (result $error $errno)
+    (result $an_pair $pair_int_ptrs))
 )