Fix wiggle tests

crates/wiggle/generate/src/funcs.rs

@@ -55,6 +55,7 @@ pub fn define_func(
     let mod_name = &module.name.as_str();
     let func_name = &func.name.as_str();
     quote! {
+        #[allow(unreachable_code)] // deals with warnings in noreturn functions
         pub fn #ident(
             ctx: &#ctx_type,
             memory: &dyn #rt::GuestMemory,
@@ -215,7 +216,7 @@ impl witx::Bindgen for Rust<'_> {
                 if func.results.len() > 0 {
                     results.push(quote!(ret));
                 } else if func.noreturn {
-                    self.src.extend(quote!(return Err(ret)));
+                    self.src.extend(quote!(return Err(ret);));
                 }
             }
 
@@ -250,7 +251,9 @@ impl witx::Bindgen for Rust<'_> {
 
             Instruction::VariantPayload => results.push(quote!(e)),
 
-            Instruction::Return { amt: 0 } => {}
+            Instruction::Return { amt: 0 } => {
+                self.src.extend(quote!(return Ok(())));
+            }
             Instruction::Return { amt: 1 } => {
                 let val = operands.pop().unwrap();
                 self.src.extend(quote!(return Ok(#val)));
@@ -278,6 +281,17 @@ impl witx::Bindgen for Rust<'_> {
                 });
             }
 
+            Instruction::Load { ty } => {
+                let ptr = operands.pop().unwrap();
+                let wrap_err = wrap_err(&format!("read {}", ty.name.as_str()));
+                let pointee_type = self.names.type_(&ty.name);
+                results.push(quote! {
+                    #rt::GuestPtr::<#pointee_type>::new(memory, #ptr as u32)
+                        .read()
+                        .map_err(#wrap_err)?
+                });
+            }
+
             Instruction::HandleFromI32 { ty } => {
                 let val = operands.pop().unwrap();
                 let ty = self.names.type_(&ty.name);
@@ -294,7 +308,7 @@ impl witx::Bindgen for Rust<'_> {
 
             // Conversions with matching bit-widths but different signededness
             // use `as` since we're basically just reinterpreting the bits.
-            Instruction::U32FromI32 => {
+            Instruction::U32FromI32 | Instruction::UsizeFromI32 => {
                 let val = operands.pop().unwrap();
                 results.push(quote!(#val as u32));
             }

crates/wiggle/generate/src/lib.rs

@@ -6,8 +6,9 @@ mod module_trait;
 mod names;
 mod types;
 
+use heck::ShoutySnakeCase;
 use lifetimes::anon_lifetime;
-use proc_macro2::TokenStream;
+use proc_macro2::{Literal, TokenStream};
 use quote::quote;
 
 pub use config::Config;
@@ -24,6 +25,19 @@ pub fn generate(doc: &witx::Document, names: &Names, errs: &ErrorTransform) -> T
 
     let types = doc.typenames().map(|t| define_datatype(&names, &t));
 
+    let constants = doc.constants().map(|c| {
+        let name = quote::format_ident!(
+            "{}_{}",
+            c.ty.as_str().to_shouty_snake_case(),
+            c.name.as_str().to_shouty_snake_case()
+        );
+        let ty = names.type_(&c.ty);
+        let value = Literal::u64_unsuffixed(c.value);
+        quote! {
+            pub const #name: #ty = #value;
+        }
+    });
+
     let guest_error_methods = doc.error_types().map(|t| {
         let typename = names.type_ref(&t, anon_lifetime());
         let err_method = names.guest_error_conversion_method(&t);
@@ -69,6 +83,7 @@ pub fn generate(doc: &witx::Document, names: &Names, errs: &ErrorTransform) -> T
             use std::convert::TryFrom;
 
             #(#types)*
+            #(#constants)*
             #guest_error_conversion
             #user_error_conversion
         }

crates/wiggle/generate/src/module_trait.rs

@@ -9,6 +9,8 @@ use witx::Module;
 pub fn passed_by_reference(ty: &witx::Type) -> bool {
     match ty {
         witx::Type::Pointer(_) | witx::Type::ConstPointer(_) | witx::Type::List(_) => true,
+        witx::Type::Record(r) => r.bitflags_repr().is_none(),
+        witx::Type::Variant(v) => !v.is_enum(),
         _ => false,
     }
 }

crates/wiggle/generate/src/types/variant.rs

@@ -65,6 +65,7 @@ pub(super) fn define_variant(names: &Names, name: &witx::Id, v: &witx::Variant)
         }
     });
 
+    let mut extra_derive = quote!();
     let enum_try_from = if v.cases.iter().all(|c| c.tref.is_none()) {
         let tryfrom_repr_cases = v.cases.iter().enumerate().map(|(i, c)| {
             let variant_name = names.enum_variant(&c.name);
@@ -72,6 +73,7 @@ pub(super) fn define_variant(names: &Names, name: &witx::Id, v: &witx::Variant)
             quote!(#n => Ok(#ident::#variant_name))
         });
         let abi_ty = names.wasm_type(v.tag_repr.into());
+        extra_derive = quote!(, Copy);
         quote! {
             impl TryFrom<#tag_ty> for #ident {
                 type Error = #rt::GuestError;
@@ -97,7 +99,7 @@ pub(super) fn define_variant(names: &Names, name: &witx::Id, v: &witx::Variant)
     let (enum_lifetime, extra_derive) = if v.needs_lifetime() {
         (quote!(<'a>), quote!())
     } else {
-        (quote!(), quote!(, PartialEq))
+        (quote!(), quote!(, PartialEq #extra_derive))
     };
 
     quote! {