Struct wasmtime_wasi::Error

#[repr(transparent)]
pub struct Error { /* private fields */ }

The Error type, a wrapper around a dynamic error type.

Error works a lot like Box<dyn std::error::Error>, but with these differences:

• Error requires that the error is Send, Sync, and 'static.
• Error guarantees that a backtrace is available, even if the underlying error type does not provide one.
• Error is represented as a narrow pointer — exactly one word in size instead of two.

Display representations

When you print an error object using “{}” or to_string(), only the outermost underlying error or context is printed, not any of the lower level causes. This is exactly as if you had called the Display impl of the error from which you constructed your anyhow::Error.

Failed to read instrs from ./path/to/instrs.json

To print causes as well using anyhow’s default formatting of causes, use the alternate selector “{:#}”.

Failed to read instrs from ./path/to/instrs.json: No such file or directory (os error 2)

The Debug format “{:?}” includes your backtrace if one was captured. Note that this is the representation you get by default if you return an error from fn main instead of printing it explicitly yourself.

Error: Failed to read instrs from ./path/to/instrs.json

Caused by:
    No such file or directory (os error 2)

and if there is a backtrace available:

Error: Failed to read instrs from ./path/to/instrs.json

Caused by:
    No such file or directory (os error 2)

Stack backtrace:
   0: <E as anyhow::context::ext::StdError>::ext_context
             at /git/anyhow/src/backtrace.rs:26
   1: core::result::Result<T,E>::map_err
             at /git/rustc/src/libcore/result.rs:596
   2: anyhow::context::<impl anyhow::Context<T,E> for core::result::Result<T,E>>::with_context
             at /git/anyhow/src/context.rs:58
   3: testing::main
             at src/main.rs:5
   4: std::rt::lang_start
             at /git/rustc/src/libstd/rt.rs:61
   5: main
   6: __libc_start_main
   7: _start

To see a conventional struct-style Debug representation, use “{:#?}”.

Error {
    context: "Failed to read instrs from ./path/to/instrs.json",
    source: Os {
        code: 2,
        kind: NotFound,
        message: "No such file or directory",
    },
}

If none of the built-in representations are appropriate and you would prefer to render the error and its cause chain yourself, it can be done something like this:

use anyhow::{Context, Result};

fn main() {
    if let Err(err) = try_main() {
        eprintln!("ERROR: {}", err);
        err.chain().skip(1).for_each(|cause| eprintln!("because: {}", cause));
        std::process::exit(1);
    }
}

fn try_main() -> Result<()> {
    ...
}

Implementations

impl Error

pub fn new<E>(error: E) -> Error where
    E: 'static + Error + Send + Sync, 

Create a new error object from any error type.

The error type must be threadsafe and 'static, so that the Error will be as well.

If the error type does not provide a backtrace, a backtrace will be created here to ensure that a backtrace exists.

pub fn msg<M>(message: M) -> Error where
    M: 'static + Display + Debug + Send + Sync, 

Create a new error object from a printable error message.

If the argument implements std::error::Error, prefer Error::new instead which preserves the underlying error’s cause chain and backtrace. If the argument may or may not implement std::error::Error now or in the future, use anyhow!(err) which handles either way correctly.

Error::msg("...") is equivalent to anyhow!("...") but occasionally convenient in places where a function is preferable over a macro, such as iterator or stream combinators:

use anyhow::{Error, Result};
use futures::stream::{Stream, StreamExt, TryStreamExt};

async fn demo<S>(stream: S) -> Result<Vec<Output>>
where
    S: Stream<Item = Input>,
{
    stream
        .then(ffi::do_some_work) // returns Result<Output, &str>
        .map_err(Error::msg)
        .try_collect()
        .await
}

pub fn context<C>(self, context: C) -> Error where
    C: 'static + Display + Send + Sync, 

Wrap the error value with additional context.

For attaching context to a Result as it is propagated, the Context extension trait may be more convenient than this function.

The primary reason to use error.context(...) instead of result.context(...) via the Context trait would be if the context needs to depend on some data held by the underlying error:

use anyhow::Result;
use std::fs::File;
use std::path::Path;

struct ParseError {
    line: usize,
    column: usize,
}

fn parse_impl(file: File) -> Result<T, ParseError> {
    ...
}

pub fn parse(path: impl AsRef<Path>) -> Result<T> {
    let file = File::open(&path)?;
    parse_impl(file).map_err(|error| {
        let context = format!(
            "only the first {} lines of {} are valid",
            error.line, path.as_ref().display(),
        );
        anyhow::Error::new(error).context(context)
    })
}

pub fn backtrace(&self) -> &Backtrace

Get the backtrace for this Error.

In order for the backtrace to be meaningful, one of the two environment variables RUST_LIB_BACKTRACE=1 or RUST_BACKTRACE=1 must be defined and RUST_LIB_BACKTRACE must not be 0. Backtraces are somewhat expensive to capture in Rust, so we don’t necessarily want to be capturing them all over the place all the time.

• If you want panics and errors to both have backtraces, set RUST_BACKTRACE=1;
• If you want only errors to have backtraces, set RUST_LIB_BACKTRACE=1;
• If you want only panics to have backtraces, set RUST_BACKTRACE=1 and RUST_LIB_BACKTRACE=0.

Stability

Standard library backtraces are only available on the nightly channel. Tracking issue: rust-lang/rust#53487.

On stable compilers, this function is only available if the crate’s “backtrace” feature is enabled, and will use the backtrace crate as the underlying backtrace implementation.

[dependencies]
anyhow = { version = "1.0", features = ["backtrace"] }

pub fn chain(&self) -> Chain<'_>

An iterator of the chain of source errors contained by this Error.

This iterator will visit every error in the cause chain of this error object, beginning with the error that this error object was created from.

Example

use anyhow::Error;
use std::io;

pub fn underlying_io_error_kind(error: &Error) -> Option<io::ErrorKind> {
    for cause in error.chain() {
        if let Some(io_error) = cause.downcast_ref::<io::Error>() {
            return Some(io_error.kind());
        }
    }
    None
}

pub fn root_cause(&self) -> &(dyn Error + 'static)

The lowest level cause of this error — this error’s cause’s cause’s cause etc.

The root cause is the last error in the iterator produced by chain().

pub fn is<E>(&self) -> bool where
    E: 'static + Display + Debug + Send + Sync, 

Returns true if E is the type held by this error object.

For errors with context, this method returns true if E matches the type of the context C or the type of the error on which the context has been attached. For details about the interaction between context and downcasting, see here.

pub fn downcast<E>(self) -> Result<E, Error> where
    E: 'static + Display + Debug + Send + Sync, 

Attempt to downcast the error object to a concrete type.

pub fn downcast_ref<E>(&self) -> Option<&E> where
    E: 'static + Display + Debug + Send + Sync, 

Downcast this error object by reference.

Example

// If the error was caused by redaction, then return a tombstone instead
// of the content.
match root_cause.downcast_ref::<DataStoreError>() {
    Some(DataStoreError::Censored(_)) => Ok(Poll::Ready(REDACTED_CONTENT)),
    None => Err(error),
}

pub fn downcast_mut<E>(&mut self) -> Option<&mut E> where
    E: 'static + Display + Debug + Send + Sync, 

Downcast this error object by mutable reference.

Trait Implementations

impl AsRef<dyn Error + 'static> for Error

fn as_ref(&self) -> &(dyn Error + 'static)

Performs the conversion.

impl AsRef<dyn Error + Send + Sync + 'static> for Error

fn as_ref(&self) -> &(dyn Error + Send + Sync + 'static)

Performs the conversion.

impl Debug for Error

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Deref for Error

type Target = dyn Error + Send + Sync + 'static

The resulting type after dereferencing.

fn deref(&self) -> &<Error as Deref>::Target

Dereferences the value.

impl DerefMut for Error

fn deref_mut(&mut self) -> &mut <Error as Deref>::Target

Mutably dereferences the value.

impl Display for Error

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Drop for Error

fn drop(&mut self)

Executes the destructor for this type.

impl ErrorExt for Error

fn trap(msg: impl Into<String>) -> Error

fn not_found() -> Error

fn too_big() -> Error

fn badf() -> Error

fn exist() -> Error

fn illegal_byte_sequence() -> Error

fn invalid_argument() -> Error

fn io() -> Error

fn name_too_long() -> Error

fn not_dir() -> Error

fn not_supported() -> Error

fn overflow() -> Error

fn range() -> Error

fn seek_pipe() -> Error

fn perm() -> Error

impl<E> From<E> for Error where
    E: 'static + Error + Send + Sync, 

fn from(error: E) -> Error

Performs the conversion.