Merge pull request #2760 from bytecodealliance/pch/wiggle_error_reporting

wiggle: delete GuestErrorConversion, improve some error reporting

Author: Pat Hickey

crates/wasi-common/src/snapshots/preview_0.rs

@@ -24,14 +24,6 @@ impl wiggle::GuestErrorType for types::Errno {
     }
 }
 
-impl types::GuestErrorConversion for WasiCtx {
-    fn into_errno(&self, e: wiggle::GuestError) -> types::Errno {
-        debug!("Guest error: {:?}", e);
-        let snapshot1_errno: snapshot1_types::Errno = e.into();
-        snapshot1_errno.into()
-    }
-}
-
 impl types::UserErrorConversion for WasiCtx {
     fn errno_from_error(&self, e: Error) -> Result<types::Errno, wiggle::Trap> {
         debug!("Error: {:?}", e);

crates/wasi-common/src/snapshots/preview_1.rs

@@ -30,13 +30,6 @@ impl wiggle::GuestErrorType for types::Errno {
     }
 }
 
-impl types::GuestErrorConversion for WasiCtx {
-    fn into_errno(&self, e: wiggle::GuestError) -> types::Errno {
-        debug!("Guest error: {:?}", e);
-        e.into()
-    }
-}
-
 impl types::UserErrorConversion for WasiCtx {
     fn errno_from_error(&self, e: Error) -> Result<types::Errno, wiggle::Trap> {
         debug!("Error: {:?}", e);
@@ -103,7 +96,6 @@ impl From<wiggle::GuestError> for types::Errno {
             InvalidUtf8 { .. } => Self::Ilseq,
             TryFromIntError { .. } => Self::Overflow,
             InFunc { err, .. } => types::Errno::from(*err),
-            InDataField { err, .. } => types::Errno::from(*err),
             SliceLengthsDiffer { .. } => Self::Fault,
             BorrowCheckerOutOfHandles { .. } => Self::Fault,
         }

crates/wasi-crypto/src/wiggle_interfaces/error.rs

@@ -52,13 +52,6 @@ impl<'a> wiggle::GuestErrorType for guest_types::CryptoErrno {
     }
 }
 
-impl guest_types::GuestErrorConversion for WasiCryptoCtx {
-    fn into_crypto_errno(&self, e: wiggle::GuestError) -> guest_types::CryptoErrno {
-        eprintln!("GuestError (witx) {:?}", e);
-        guest_types::CryptoErrno::GuestError
-    }
-}
-
 impl From<wiggle::GuestError> for guest_types::CryptoErrno {
     fn from(e: wiggle::GuestError) -> Self {
         eprintln!("GuestError (impl) {:?}", e);

crates/wasi-nn/src/witx.rs

@@ -10,16 +10,6 @@ wiggle::from_witx!({
 
 use types::NnErrno;
 
-/// Wiggle generates code that performs some input validation on the arguments passed in by users of
-/// wasi-nn. Here we convert the validation error into one (or more, eventually) of the error
-/// variants defined in the witx.
-impl types::GuestErrorConversion for WasiNnCtx {
-    fn into_nn_errno(&self, e: wiggle::GuestError) -> NnErrno {
-        eprintln!("Guest error: {:?}", e);
-        NnErrno::InvalidArgument
-    }
-}
-
 impl<'a> types::UserErrorConversion for WasiNnCtx {
     fn nn_errno_from_wasi_nn_error(&self, e: WasiNnError) -> Result<NnErrno, wiggle::Trap> {
         eprintln!("Host error: {:?}", e);

crates/wiggle/generate/src/funcs.rs

@@ -139,10 +139,12 @@ impl witx::Bindgen for Rust<'_> {
     ) {
         let rt = self.rt;
         let wrap_err = |location: &str| {
+            let modulename = self.module.name.as_str();
             let funcname = self.funcname;
             quote! {
                 |e| {
                     #rt::GuestError::InFunc {
+                        modulename: #modulename,
                         funcname: #funcname,
                         location: #location,
                         err: Box::new(#rt::GuestError::from(e)),

crates/wiggle/generate/src/lib.rs

@@ -38,17 +38,6 @@ pub fn generate(doc: &witx::Document, names: &Names, settings: &CodegenSettings)
         }
     });
 
-    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);
-        quote!(fn #err_method(&self, e: #rt::GuestError) -> #typename;)
-    });
-    let guest_error_conversion = quote! {
-        pub trait GuestErrorConversion {
-            #(#guest_error_methods)*
-        }
-    };
-
     let user_error_methods = settings.errors.iter().map(|errtype| {
         let abi_typename = names.type_ref(&errtype.abi_type(), anon_lifetime());
         let user_typename = errtype.typename();
@@ -82,7 +71,6 @@ pub fn generate(doc: &witx::Document, names: &Names, settings: &CodegenSettings)
 
             #(#types)*
             #(#constants)*
-            #guest_error_conversion
             #user_error_conversion
         }
         #(#modules)*

crates/wiggle/generate/src/names.rs

@@ -196,11 +196,6 @@ impl Names {
         }
     }
 
-    pub fn guest_error_conversion_method(&self, tref: &TypeRef) -> Ident {
-        let suffix = Self::snake_typename(tref);
-        format_ident!("into_{}", suffix)
-    }
-
     pub fn user_error_conversion_method(&self, user_type: &UserErrorType) -> Ident {
         let abi_type = Self::snake_typename(&user_type.abi_type());
         format_ident!(

crates/wiggle/macro/src/lib.rs

@@ -113,17 +113,6 @@ use syn::parse_macro_input;
 ///     }
 /// }
 ///
-/// /// The `types::GuestErrorConversion` trait is also generated with a method for
-/// /// each type used in the `error` position. This trait allows wiggle-generated
-/// /// code to convert a `wiggle::GuestError` into the right error type. The trait
-/// /// must be implemented for the user's ctx type.
-///
-/// impl types::GuestErrorConversion for YourCtxType {
-///     fn into_errno(&self, _e: wiggle::GuestError) -> types::Errno {
-///         unimplemented!()
-///     }
-/// }
-///
 /// /// If you specify a `error` mapping to the macro, you must implement the
 /// /// `types::UserErrorConversion` for your ctx type as well. This trait gives
 /// /// you an opportunity to store or log your rich error type, while returning

crates/wiggle/src/error.rs

@@ -19,20 +19,14 @@ pub enum GuestError {
     BorrowCheckerOutOfHandles,
     #[error("Slice length mismatch")]
     SliceLengthsDiffer,
-    #[error("In func {funcname}:{location}:")]
+    #[error("In func {modulename}::{funcname} at {location}: {err}")]
     InFunc {
+        modulename: &'static str,
         funcname: &'static str,
         location: &'static str,
         #[source]
         err: Box<GuestError>,
     },
-    #[error("In data {typename}.{field}:")]
-    InDataField {
-        typename: String,
-        field: String,
-        #[source]
-        err: Box<GuestError>,
-    },
     #[error("Invalid UTF-8 encountered: {0:?}")]
     InvalidUtf8(#[from] ::std::str::Utf8Error),
     #[error("Int conversion error: {0:?}")]

crates/wiggle/test-helpers/examples/tracing.rs

@@ -27,9 +27,7 @@ witx_literal: "
     errors: { errno => RichError },
 });
 
-// The impl of GuestErrorConversion works just like in every other test where
-// we have a single error type with witx `$errno` with the success called `$ok`
-impl_errno!(types::Errno, types::GuestErrorConversion);
+impl_errno!(types::Errno);
 
 /// When the `errors` mapping in witx is non-empty, we need to impl the
 /// types::UserErrorConversion trait that wiggle generates from that mapping.