Handles (#22)

* test coverage: make sure aliases to builtins get tested

* trivial support for handles

* add tests for handles

crates/generate/src/funcs.rs

@@ -308,6 +308,11 @@ fn marshal_arg(
             }
         }
         witx::Type::Union(_u) => read_conversion,
+        witx::Type::Handle(_h) => {
+            let name = names.func_param(&param.name);
+            let handle_type = names.type_ref(tref, anon_lifetime());
+            quote!( let #name = #handle_type::from(#name); )
+        }
         _ => unimplemented!("argument type marshalling"),
     }
 }

crates/generate/src/types.rs

@@ -21,7 +21,7 @@ pub fn define_datatype(names: &Names, namedtype: &witx::NamedType) -> TokenStrea
                 }
             }
             witx::Type::Union(u) => define_union(names, &namedtype.name, &u),
-            witx::Type::Handle(_h) => unimplemented!("handle types"),
+            witx::Type::Handle(h) => define_handle(names, &namedtype.name, &h),
             witx::Type::Builtin(b) => define_builtin(names, &namedtype.name, *b),
             witx::Type::Pointer(p) => define_witx_pointer(
                 names,
@@ -398,10 +398,73 @@ fn define_enum(names: &Names, name: &witx::Id, e: &witx::EnumDatatype) -> TokenS
     }
 }
 
+fn define_handle(names: &Names, name: &witx::Id, h: &witx::HandleDatatype) -> TokenStream {
+    let ident = names.type_(name);
+    let size = h.mem_size_align().size as u32;
+    let align = h.mem_size_align().align as u32;
+    quote! {
+        #[derive(Copy, Clone, Debug, ::std::hash::Hash, Eq, PartialEq)]
+        pub struct #ident(u32);
+
+        impl From<#ident> for u32 {
+            fn from(e: #ident) -> u32 {
+                e.0
+            }
+        }
+
+        impl From<#ident> for i32 {
+            fn from(e: #ident) -> i32 {
+                e.0 as i32
+            }
+        }
+
+        impl From<u32> for #ident {
+            fn from(e: u32) -> #ident {
+                #ident(e)
+            }
+        }
+        impl From<i32> for #ident {
+            fn from(e: i32) -> #ident {
+                #ident(e as u32)
+            }
+        }
+
+        impl ::std::fmt::Display for #ident {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+                write!(f, "{}({})", stringify!(#ident), self.0)
+            }
+        }
+        impl wiggle_runtime::GuestType for #ident {
+            fn size() -> u32 {
+                #size
+            }
+            fn align() -> u32 {
+                #align
+            }
+            fn name() -> String {
+                stringify!(#ident).to_owned()
+            }
+            fn validate(ptr: &wiggle_runtime::GuestPtr<#ident>) -> Result<(), wiggle_runtime::GuestError> {
+                Ok(())
+            }
+        }
+        impl<'a> wiggle_runtime::GuestTypeClone<'a> for #ident {
+            fn read_from_guest(location: &wiggle_runtime::GuestPtr<'a, #ident>) -> Result<#ident, wiggle_runtime::GuestError> {
+                let r = location.as_ref()?;
+                Ok(*r)
+            }
+            fn write_to_guest(&self, location: &wiggle_runtime::GuestPtrMut<'a, Self>) {
+                unsafe { (location.as_raw() as *mut #ident).write(*self) };
+            }
+        }
+        impl<'a> wiggle_runtime::GuestTypeCopy<'a> for #ident {}
+    }
+}
+
 fn define_builtin(names: &Names, name: &witx::Id, builtin: witx::BuiltinType) -> TokenStream {
     let ident = names.type_(name);
     let built = names.builtin_type(builtin, quote!('a));
-    if let witx::BuiltinType::String = builtin {
+    if builtin.needs_lifetime() {
         quote!(pub type #ident<'a> = #built;)
     } else {
         quote!(pub type #ident = #built;)