An error reporter that prints an error and its sources.

Report also exposes configuration options for formatting the error sources, either entirely on a single line, or in multi-line format with each source on a new line.

Report only requires that the wrapped error implement Error. It doesn't require that the wrapped error be Send, Sync, or 'static.

Examples

#![feature(error_reporter)]
use std::error::{Error, Report};
use std::fmt;

#[derive(Debug)]
struct SuperError {
    source: SuperErrorSideKick,
}

impl fmt::Display for SuperError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "SuperError is here!")
    }
}

impl Error for SuperError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        Some(&self.source)
    }
}

#[derive(Debug)]
struct SuperErrorSideKick;

impl fmt::Display for SuperErrorSideKick {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "SuperErrorSideKick is here!")
    }
}

impl Error for SuperErrorSideKick {}

fn get_super_error() -> Result<(), SuperError> {
    Err(SuperError { source: SuperErrorSideKick })
}

fn main() {
    match get_super_error() {
        Err(e) => println!("Error: {}", Report::new(e)),
        _ => println!("No error"),
    }
}

This example produces the following output:

Error: SuperError is here!: SuperErrorSideKick is here!

Output consistency

Report prints the same output via Display and Debug, so it works well with Result::unwrap/Result::expect which print their Err variant via Debug:

#![feature(error_reporter)]
use std::error::Report;
# use std::error::Error;
# use std::fmt;
# #[derive(Debug)]
# struct SuperError {
#     source: SuperErrorSideKick,
# }
# impl fmt::Display for SuperError {
#     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
#         write!(f, "SuperError is here!")
#     }
# }
# impl Error for SuperError {
#     fn source(&self) -> Option<&(dyn Error + 'static)> {
#         Some(&self.source)
#     }
# }
# #[derive(Debug)]
# struct SuperErrorSideKick;
# impl fmt::Display for SuperErrorSideKick {
#     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
#         write!(f, "SuperErrorSideKick is here!")
#     }
# }
# impl Error for SuperErrorSideKick {}
# fn get_super_error() -> Result<(), SuperError> {
#     Err(SuperError { source: SuperErrorSideKick })
# }

get_super_error().map_err(Report::new).unwrap();

This example produces the following output:

thread 'main' panicked at src/error.rs:34:40:
called `Result::unwrap()` on an `Err` value: SuperError is here!: SuperErrorSideKick is here!
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Return from main

Report also implements From for all types that implement Error; this when combined with the Debug output means Report is an ideal starting place for formatting errors returned from main.

#![feature(error_reporter)]
use std::error::Report;
# use std::error::Error;
# use std::fmt;
# #[derive(Debug)]
# struct SuperError {
#     source: SuperErrorSideKick,
# }
# impl fmt::Display for SuperError {
#     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
#         write!(f, "SuperError is here!")
#     }
# }
# impl Error for SuperError {
#     fn source(&self) -> Option<&(dyn Error + 'static)> {
#         Some(&self.source)
#     }
# }
# #[derive(Debug)]
# struct SuperErrorSideKick;
# impl fmt::Display for SuperErrorSideKick {
#     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
#         write!(f, "SuperErrorSideKick is here!")
#     }
# }
# impl Error for SuperErrorSideKick {}
# fn get_super_error() -> Result<(), SuperError> {
#     Err(SuperError { source: SuperErrorSideKick })
# }

fn main() -> Result<(), Report<SuperError>> {
    get_super_error()?;
    Ok(())
}

This example produces the following output:

Error: SuperError is here!: SuperErrorSideKick is here!

Note: Reports constructed via ? and From will be configured to use the single line output format. If you want to make sure your Reports are pretty printed and include backtrace you will need to manually convert and enable those flags.

#![feature(error_reporter)]
use std::error::Report;
# use std::error::Error;
# use std::fmt;
# #[derive(Debug)]
# struct SuperError {
#     source: SuperErrorSideKick,
# }
# impl fmt::Display for SuperError {
#     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
#         write!(f, "SuperError is here!")
#     }
# }
# impl Error for SuperError {
#     fn source(&self) -> Option<&(dyn Error + 'static)> {
#         Some(&self.source)
#     }
# }
# #[derive(Debug)]
# struct SuperErrorSideKick;
# impl fmt::Display for SuperErrorSideKick {
#     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
#         write!(f, "SuperErrorSideKick is here!")
#     }
# }
# impl Error for SuperErrorSideKick {}
# fn get_super_error() -> Result<(), SuperError> {
#     Err(SuperError { source: SuperErrorSideKick })
# }

fn main() -> Result<(), Report<SuperError>> {
    get_super_error()
        .map_err(Report::from)
        .map_err(|r| r.pretty(true).show_backtrace(true))?;
    Ok(())
}

This example produces the following output:

Error: SuperError is here!

Caused by:
      SuperErrorSideKick is here!