flesh out the guest type traits a bit further

crates/generate/src/names.rs

@@ -41,6 +41,7 @@ impl Names {
         }
     }
 
+    #[allow(unused)]
     pub fn type_ref(&self, tref: &TypeRef) -> TokenStream {
         match tref {
             TypeRef::Name(nt) => {

crates/generate/src/types.rs

@@ -36,15 +36,61 @@ fn define_enum(names: &Names, name: &witx::Id, e: &witx::EnumDatatype) -> TokenS
     output.extend(quote!(#[repr(#repr)]));
     output.extend(quote!(#[derive(Copy, Clone, Debug, std::hash::Hash, Eq, PartialEq)]));
 
-    let mut inner = TokenStream::new();
-    for variant in &e.variants {
+    let mut variants = TokenStream::new();
+    let mut to_repr_cases = TokenStream::new();
+    let mut tryfrom_repr_cases = TokenStream::new();
+    for (n, variant) in e.variants.iter().enumerate() {
+        let n = n as u32;
         let variant_name = names.enum_variant(&variant.name);
-        inner.extend(quote!(#variant_name,));
+        variants.extend(quote!(#variant_name,));
+        tryfrom_repr_cases.extend(quote!(#n => Ok(#ident::#variant_name),));
+        to_repr_cases.extend(quote!(#ident::#variant_name => #n,));
     }
 
+    tryfrom_repr_cases
+        .extend(quote!(_ => Err(::memory::GuestValueError::InvalidEnum(stringify!(#ident)))));
+
     output.extend(quote!(pub enum #ident {
-        #inner
-    }));
+        #variants
+    }
+
+    impl ::std::convert::TryFrom<#repr> for #ident {
+        type Error = ::memory::GuestValueError;
+        fn try_from(value: #repr) -> Result<#ident, ::memory::GuestValueError> {
+            match value {
+                #tryfrom_repr_cases
+            }
+        }
+    }
+
+    impl From<#ident> for #repr {
+        fn from(e: #ident) -> #repr {
+            match e {
+                #to_repr_cases
+            }
+        }
+    }
+
+    impl ::memory::GuestType for #ident {
+        fn size() -> u32 {
+            ::std::mem::size_of::<#repr>() as u32
+        }
+        fn name() -> &'static str {
+            stringify!(#ident)
+        }
+    }
+
+    impl ::memory::GuestTypeCopy for #ident {
+        fn read_val(src: ::memory::GuestPtr<#ident>) -> Result<#ident, ::memory::GuestValueError> {
+            // Get the pointer to memory, cast it to *const #repr, read_unaligned, then use the tryinto
+            unimplemented!()
+        }
+        fn write_val(val: #ident, dest: ::memory::GuestPtrMut<#ident>) {
+            // use the into<#repr>, get pointer to memory, write_unaligned
+            unimplemented!()
+        }
+    }
+    ));
 
     output
 }