summaryrefslogtreecommitdiffstats
path: root/third_party/rust/anyhow/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--third_party/rust/anyhow/src/backtrace.rs36
-rw-r--r--third_party/rust/anyhow/src/chain.rs101
-rw-r--r--third_party/rust/anyhow/src/context.rs177
-rw-r--r--third_party/rust/anyhow/src/error.rs802
-rw-r--r--third_party/rust/anyhow/src/fmt.rs149
-rw-r--r--third_party/rust/anyhow/src/kind.rs116
-rw-r--r--third_party/rust/anyhow/src/lib.rs603
-rw-r--r--third_party/rust/anyhow/src/macros.rs163
-rw-r--r--third_party/rust/anyhow/src/wrapper.rs78
9 files changed, 2225 insertions, 0 deletions
diff --git a/third_party/rust/anyhow/src/backtrace.rs b/third_party/rust/anyhow/src/backtrace.rs
new file mode 100644
index 0000000000..01e33cb237
--- /dev/null
+++ b/third_party/rust/anyhow/src/backtrace.rs
@@ -0,0 +1,36 @@
+#[cfg(backtrace)]
+pub(crate) use std::backtrace::Backtrace;
+
+#[cfg(not(backtrace))]
+pub(crate) enum Backtrace {}
+
+#[cfg(backtrace)]
+macro_rules! backtrace {
+ () => {
+ Some(Backtrace::capture())
+ };
+}
+
+#[cfg(not(backtrace))]
+macro_rules! backtrace {
+ () => {
+ None
+ };
+}
+
+#[cfg(backtrace)]
+macro_rules! backtrace_if_absent {
+ ($err:expr) => {
+ match $err.backtrace() {
+ Some(_) => None,
+ None => Some(Backtrace::capture()),
+ }
+ };
+}
+
+#[cfg(all(feature = "std", not(backtrace)))]
+macro_rules! backtrace_if_absent {
+ ($err:expr) => {
+ None
+ };
+}
diff --git a/third_party/rust/anyhow/src/chain.rs b/third_party/rust/anyhow/src/chain.rs
new file mode 100644
index 0000000000..207e4f0ca9
--- /dev/null
+++ b/third_party/rust/anyhow/src/chain.rs
@@ -0,0 +1,101 @@
+use self::ChainState::*;
+use crate::StdError;
+
+#[cfg(feature = "std")]
+use std::vec;
+
+#[cfg(feature = "std")]
+pub(crate) use crate::Chain;
+
+#[cfg(not(feature = "std"))]
+pub(crate) struct Chain<'a> {
+ state: ChainState<'a>,
+}
+
+#[derive(Clone)]
+pub(crate) enum ChainState<'a> {
+ Linked {
+ next: Option<&'a (dyn StdError + 'static)>,
+ },
+ #[cfg(feature = "std")]
+ Buffered {
+ rest: vec::IntoIter<&'a (dyn StdError + 'static)>,
+ },
+}
+
+impl<'a> Chain<'a> {
+ pub fn new(head: &'a (dyn StdError + 'static)) -> Self {
+ Chain {
+ state: ChainState::Linked { next: Some(head) },
+ }
+ }
+}
+
+impl<'a> Iterator for Chain<'a> {
+ type Item = &'a (dyn StdError + 'static);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ match &mut self.state {
+ Linked { next } => {
+ let error = (*next)?;
+ *next = error.source();
+ Some(error)
+ }
+ #[cfg(feature = "std")]
+ Buffered { rest } => rest.next(),
+ }
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ let len = self.len();
+ (len, Some(len))
+ }
+}
+
+#[cfg(feature = "std")]
+impl DoubleEndedIterator for Chain<'_> {
+ fn next_back(&mut self) -> Option<Self::Item> {
+ match &mut self.state {
+ Linked { mut next } => {
+ let mut rest = Vec::new();
+ while let Some(cause) = next {
+ next = cause.source();
+ rest.push(cause);
+ }
+ let mut rest = rest.into_iter();
+ let last = rest.next_back();
+ self.state = Buffered { rest };
+ last
+ }
+ Buffered { rest } => rest.next_back(),
+ }
+ }
+}
+
+impl ExactSizeIterator for Chain<'_> {
+ fn len(&self) -> usize {
+ match &self.state {
+ Linked { mut next } => {
+ let mut len = 0;
+ while let Some(cause) = next {
+ next = cause.source();
+ len += 1;
+ }
+ len
+ }
+ #[cfg(feature = "std")]
+ Buffered { rest } => rest.len(),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl Default for Chain<'_> {
+ fn default() -> Self {
+ Chain {
+ state: ChainState::Buffered {
+ rest: Vec::new().into_iter(),
+ },
+ }
+ }
+}
diff --git a/third_party/rust/anyhow/src/context.rs b/third_party/rust/anyhow/src/context.rs
new file mode 100644
index 0000000000..25d34114c1
--- /dev/null
+++ b/third_party/rust/anyhow/src/context.rs
@@ -0,0 +1,177 @@
+use crate::error::ContextError;
+use crate::{Context, Error, StdError};
+use core::convert::Infallible;
+use core::fmt::{self, Debug, Display, Write};
+
+#[cfg(backtrace)]
+use std::backtrace::Backtrace;
+
+mod ext {
+ use super::*;
+
+ pub trait StdError {
+ fn ext_context<C>(self, context: C) -> Error
+ where
+ C: Display + Send + Sync + 'static;
+ }
+
+ #[cfg(feature = "std")]
+ impl<E> StdError for E
+ where
+ E: std::error::Error + Send + Sync + 'static,
+ {
+ fn ext_context<C>(self, context: C) -> Error
+ where
+ C: Display + Send + Sync + 'static,
+ {
+ let backtrace = backtrace_if_absent!(self);
+ Error::from_context(context, self, backtrace)
+ }
+ }
+
+ impl StdError for Error {
+ fn ext_context<C>(self, context: C) -> Error
+ where
+ C: Display + Send + Sync + 'static,
+ {
+ self.context(context)
+ }
+ }
+}
+
+impl<T, E> Context<T, E> for Result<T, E>
+where
+ E: ext::StdError + Send + Sync + 'static,
+{
+ fn context<C>(self, context: C) -> Result<T, Error>
+ where
+ C: Display + Send + Sync + 'static,
+ {
+ self.map_err(|error| error.ext_context(context))
+ }
+
+ fn with_context<C, F>(self, context: F) -> Result<T, Error>
+ where
+ C: Display + Send + Sync + 'static,
+ F: FnOnce() -> C,
+ {
+ self.map_err(|error| error.ext_context(context()))
+ }
+}
+
+/// ```
+/// # type T = ();
+/// #
+/// use anyhow::{Context, Result};
+///
+/// fn maybe_get() -> Option<T> {
+/// # const IGNORE: &str = stringify! {
+/// ...
+/// # };
+/// # unimplemented!()
+/// }
+///
+/// fn demo() -> Result<()> {
+/// let t = maybe_get().context("there is no T")?;
+/// # const IGNORE: &str = stringify! {
+/// ...
+/// # };
+/// # unimplemented!()
+/// }
+/// ```
+impl<T> Context<T, Infallible> for Option<T> {
+ fn context<C>(self, context: C) -> Result<T, Error>
+ where
+ C: Display + Send + Sync + 'static,
+ {
+ self.ok_or_else(|| Error::from_display(context, backtrace!()))
+ }
+
+ fn with_context<C, F>(self, context: F) -> Result<T, Error>
+ where
+ C: Display + Send + Sync + 'static,
+ F: FnOnce() -> C,
+ {
+ self.ok_or_else(|| Error::from_display(context(), backtrace!()))
+ }
+}
+
+impl<C, E> Debug for ContextError<C, E>
+where
+ C: Display,
+ E: Debug,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_struct("Error")
+ .field("context", &Quoted(&self.context))
+ .field("source", &self.error)
+ .finish()
+ }
+}
+
+impl<C, E> Display for ContextError<C, E>
+where
+ C: Display,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ Display::fmt(&self.context, f)
+ }
+}
+
+impl<C, E> StdError for ContextError<C, E>
+where
+ C: Display,
+ E: StdError + 'static,
+{
+ #[cfg(backtrace)]
+ fn backtrace(&self) -> Option<&Backtrace> {
+ self.error.backtrace()
+ }
+
+ fn source(&self) -> Option<&(dyn StdError + 'static)> {
+ Some(&self.error)
+ }
+}
+
+impl<C> StdError for ContextError<C, Error>
+where
+ C: Display,
+{
+ #[cfg(backtrace)]
+ fn backtrace(&self) -> Option<&Backtrace> {
+ Some(self.error.backtrace())
+ }
+
+ fn source(&self) -> Option<&(dyn StdError + 'static)> {
+ Some(self.error.inner.error())
+ }
+}
+
+struct Quoted<C>(C);
+
+impl<C> Debug for Quoted<C>
+where
+ C: Display,
+{
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_char('"')?;
+ Quoted(&mut *formatter).write_fmt(format_args!("{}", self.0))?;
+ formatter.write_char('"')?;
+ Ok(())
+ }
+}
+
+impl Write for Quoted<&mut fmt::Formatter<'_>> {
+ fn write_str(&mut self, s: &str) -> fmt::Result {
+ Display::fmt(&s.escape_debug(), self.0)
+ }
+}
+
+pub(crate) mod private {
+ use super::*;
+
+ pub trait Sealed {}
+
+ impl<T, E> Sealed for Result<T, E> where E: ext::StdError {}
+ impl<T> Sealed for Option<T> {}
+}
diff --git a/third_party/rust/anyhow/src/error.rs b/third_party/rust/anyhow/src/error.rs
new file mode 100644
index 0000000000..80d879f84e
--- /dev/null
+++ b/third_party/rust/anyhow/src/error.rs
@@ -0,0 +1,802 @@
+use crate::alloc::Box;
+use crate::backtrace::Backtrace;
+use crate::chain::Chain;
+use crate::{Error, StdError};
+use core::any::TypeId;
+use core::fmt::{self, Debug, Display};
+use core::mem::{self, ManuallyDrop};
+use core::ptr::{self, NonNull};
+
+#[cfg(feature = "std")]
+use core::ops::{Deref, DerefMut};
+
+impl Error {
+ /// 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.
+ #[cfg(feature = "std")]
+ #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+ pub fn new<E>(error: E) -> Self
+ where
+ E: StdError + Send + Sync + 'static,
+ {
+ let backtrace = backtrace_if_absent!(error);
+ Error::from_std(error, backtrace)
+ }
+
+ /// 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:
+ ///
+ /// ```
+ /// # mod ffi {
+ /// # pub struct Input;
+ /// # pub struct Output;
+ /// # pub async fn do_some_work(_: Input) -> Result<Output, &'static str> {
+ /// # unimplemented!()
+ /// # }
+ /// # }
+ /// #
+ /// # use ffi::{Input, Output};
+ /// #
+ /// 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 msg<M>(message: M) -> Self
+ where
+ M: Display + Debug + Send + Sync + 'static,
+ {
+ Error::from_adhoc(message, backtrace!())
+ }
+
+ #[cfg(feature = "std")]
+ pub(crate) fn from_std<E>(error: E, backtrace: Option<Backtrace>) -> Self
+ where
+ E: StdError + Send + Sync + 'static,
+ {
+ let vtable = &ErrorVTable {
+ object_drop: object_drop::<E>,
+ object_ref: object_ref::<E>,
+ #[cfg(feature = "std")]
+ object_mut: object_mut::<E>,
+ object_boxed: object_boxed::<E>,
+ object_downcast: object_downcast::<E>,
+ object_drop_rest: object_drop_front::<E>,
+ };
+
+ // Safety: passing vtable that operates on the right type E.
+ unsafe { Error::construct(error, vtable, backtrace) }
+ }
+
+ pub(crate) fn from_adhoc<M>(message: M, backtrace: Option<Backtrace>) -> Self
+ where
+ M: Display + Debug + Send + Sync + 'static,
+ {
+ use crate::wrapper::MessageError;
+ let error: MessageError<M> = MessageError(message);
+ let vtable = &ErrorVTable {
+ object_drop: object_drop::<MessageError<M>>,
+ object_ref: object_ref::<MessageError<M>>,
+ #[cfg(feature = "std")]
+ object_mut: object_mut::<MessageError<M>>,
+ object_boxed: object_boxed::<MessageError<M>>,
+ object_downcast: object_downcast::<M>,
+ object_drop_rest: object_drop_front::<M>,
+ };
+
+ // Safety: MessageError is repr(transparent) so it is okay for the
+ // vtable to allow casting the MessageError<M> to M.
+ unsafe { Error::construct(error, vtable, backtrace) }
+ }
+
+ pub(crate) fn from_display<M>(message: M, backtrace: Option<Backtrace>) -> Self
+ where
+ M: Display + Send + Sync + 'static,
+ {
+ use crate::wrapper::DisplayError;
+ let error: DisplayError<M> = DisplayError(message);
+ let vtable = &ErrorVTable {
+ object_drop: object_drop::<DisplayError<M>>,
+ object_ref: object_ref::<DisplayError<M>>,
+ #[cfg(feature = "std")]
+ object_mut: object_mut::<DisplayError<M>>,
+ object_boxed: object_boxed::<DisplayError<M>>,
+ object_downcast: object_downcast::<M>,
+ object_drop_rest: object_drop_front::<M>,
+ };
+
+ // Safety: DisplayError is repr(transparent) so it is okay for the
+ // vtable to allow casting the DisplayError<M> to M.
+ unsafe { Error::construct(error, vtable, backtrace) }
+ }
+
+ #[cfg(feature = "std")]
+ pub(crate) fn from_context<C, E>(context: C, error: E, backtrace: Option<Backtrace>) -> Self
+ where
+ C: Display + Send + Sync + 'static,
+ E: StdError + Send + Sync + 'static,
+ {
+ let error: ContextError<C, E> = ContextError { context, error };
+
+ let vtable = &ErrorVTable {
+ object_drop: object_drop::<ContextError<C, E>>,
+ object_ref: object_ref::<ContextError<C, E>>,
+ #[cfg(feature = "std")]
+ object_mut: object_mut::<ContextError<C, E>>,
+ object_boxed: object_boxed::<ContextError<C, E>>,
+ object_downcast: context_downcast::<C, E>,
+ object_drop_rest: context_drop_rest::<C, E>,
+ };
+
+ // Safety: passing vtable that operates on the right type.
+ unsafe { Error::construct(error, vtable, backtrace) }
+ }
+
+ #[cfg(feature = "std")]
+ pub(crate) fn from_boxed(
+ error: Box<dyn StdError + Send + Sync>,
+ backtrace: Option<Backtrace>,
+ ) -> Self {
+ use crate::wrapper::BoxedError;
+ let error = BoxedError(error);
+ let vtable = &ErrorVTable {
+ object_drop: object_drop::<BoxedError>,
+ object_ref: object_ref::<BoxedError>,
+ #[cfg(feature = "std")]
+ object_mut: object_mut::<BoxedError>,
+ object_boxed: object_boxed::<BoxedError>,
+ object_downcast: object_downcast::<Box<dyn StdError + Send + Sync>>,
+ object_drop_rest: object_drop_front::<Box<dyn StdError + Send + Sync>>,
+ };
+
+ // Safety: BoxedError is repr(transparent) so it is okay for the vtable
+ // to allow casting to Box<dyn StdError + Send + Sync>.
+ unsafe { Error::construct(error, vtable, backtrace) }
+ }
+
+ // Takes backtrace as argument rather than capturing it here so that the
+ // user sees one fewer layer of wrapping noise in the backtrace.
+ //
+ // Unsafe because the given vtable must have sensible behavior on the error
+ // value of type E.
+ unsafe fn construct<E>(
+ error: E,
+ vtable: &'static ErrorVTable,
+ backtrace: Option<Backtrace>,
+ ) -> Self
+ where
+ E: StdError + Send + Sync + 'static,
+ {
+ let inner = Box::new(ErrorImpl {
+ vtable,
+ backtrace,
+ _object: error,
+ });
+ // Erase the concrete type of E from the compile-time type system. This
+ // is equivalent to the safe unsize coersion from Box<ErrorImpl<E>> to
+ // Box<ErrorImpl<dyn StdError + Send + Sync + 'static>> except that the
+ // result is a thin pointer. The necessary behavior for manipulating the
+ // underlying ErrorImpl<E> is preserved in the vtable provided by the
+ // caller rather than a builtin fat pointer vtable.
+ let erased = mem::transmute::<Box<ErrorImpl<E>>, Box<ErrorImpl<()>>>(inner);
+ let inner = ManuallyDrop::new(erased);
+ Error { inner }
+ }
+
+ /// Wrap the error value with additional context.
+ ///
+ /// For attaching context to a `Result` as it is propagated, the
+ /// [`Context`][crate::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 std::fmt::{self, Debug, Display};
+ /// #
+ /// # type T = ();
+ /// #
+ /// # impl std::error::Error for ParseError {}
+ /// # impl Debug for ParseError {
+ /// # fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ /// # unimplemented!()
+ /// # }
+ /// # }
+ /// # impl Display for ParseError {
+ /// # fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ /// # unimplemented!()
+ /// # }
+ /// # }
+ /// #
+ /// 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> {
+ /// # const IGNORE: &str = stringify! {
+ /// ...
+ /// # };
+ /// # unimplemented!()
+ /// }
+ ///
+ /// 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 context<C>(self, context: C) -> Self
+ where
+ C: Display + Send + Sync + 'static,
+ {
+ let error: ContextError<C, Error> = ContextError {
+ context,
+ error: self,
+ };
+
+ let vtable = &ErrorVTable {
+ object_drop: object_drop::<ContextError<C, Error>>,
+ object_ref: object_ref::<ContextError<C, Error>>,
+ #[cfg(feature = "std")]
+ object_mut: object_mut::<ContextError<C, Error>>,
+ object_boxed: object_boxed::<ContextError<C, Error>>,
+ object_downcast: context_chain_downcast::<C>,
+ object_drop_rest: context_chain_drop_rest::<C>,
+ };
+
+ // As the cause is anyhow::Error, we already have a backtrace for it.
+ let backtrace = None;
+
+ // Safety: passing vtable that operates on the right type.
+ unsafe { Error::construct(error, vtable, backtrace) }
+ }
+
+ /// Get the backtrace for this Error.
+ ///
+ /// Backtraces are only available on the nightly channel. Tracking issue:
+ /// [rust-lang/rust#53487][tracking].
+ ///
+ /// 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`.
+ ///
+ /// [tracking]: https://github.com/rust-lang/rust/issues/53487
+ #[cfg(backtrace)]
+ pub fn backtrace(&self) -> &Backtrace {
+ self.inner.backtrace()
+ }
+
+ /// 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
+ /// }
+ /// ```
+ #[cfg(feature = "std")]
+ pub fn chain(&self) -> Chain {
+ self.inner.chain()
+ }
+
+ /// The lowest level cause of this error &mdash; this error's cause's
+ /// cause's cause etc.
+ ///
+ /// The root cause is the last error in the iterator produced by
+ /// [`chain()`][Error::chain].
+ #[cfg(feature = "std")]
+ pub fn root_cause(&self) -> &(dyn StdError + 'static) {
+ let mut chain = self.chain();
+ let mut root_cause = chain.next().unwrap();
+ for cause in chain {
+ root_cause = cause;
+ }
+ root_cause
+ }
+
+ /// 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].
+ ///
+ /// [see here]: trait.Context.html#effect-on-downcasting
+ pub fn is<E>(&self) -> bool
+ where
+ E: Display + Debug + Send + Sync + 'static,
+ {
+ self.downcast_ref::<E>().is_some()
+ }
+
+ /// Attempt to downcast the error object to a concrete type.
+ pub fn downcast<E>(self) -> Result<E, Self>
+ where
+ E: Display + Debug + Send + Sync + 'static,
+ {
+ let target = TypeId::of::<E>();
+ unsafe {
+ // Use vtable to find NonNull<()> which points to a value of type E
+ // somewhere inside the data structure.
+ let addr = match (self.inner.vtable.object_downcast)(&self.inner, target) {
+ Some(addr) => addr,
+ None => return Err(self),
+ };
+
+ // Prepare to read E out of the data structure. We'll drop the rest
+ // of the data structure separately so that E is not dropped.
+ let outer = ManuallyDrop::new(self);
+
+ // Read E from where the vtable found it.
+ let error = ptr::read(addr.cast::<E>().as_ptr());
+
+ // Read Box<ErrorImpl<()>> from self. Can't move it out because
+ // Error has a Drop impl which we want to not run.
+ let inner = ptr::read(&outer.inner);
+ let erased = ManuallyDrop::into_inner(inner);
+
+ // Drop rest of the data structure outside of E.
+ (erased.vtable.object_drop_rest)(erased, target);
+
+ Ok(error)
+ }
+ }
+
+ /// Downcast this error object by reference.
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use anyhow::anyhow;
+ /// # use std::fmt::{self, Display};
+ /// # use std::task::Poll;
+ /// #
+ /// # #[derive(Debug)]
+ /// # enum DataStoreError {
+ /// # Censored(()),
+ /// # }
+ /// #
+ /// # impl Display for DataStoreError {
+ /// # fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ /// # unimplemented!()
+ /// # }
+ /// # }
+ /// #
+ /// # impl std::error::Error for DataStoreError {}
+ /// #
+ /// # const REDACTED_CONTENT: () = ();
+ /// #
+ /// # let error = anyhow!("...");
+ /// # let root_cause = &error;
+ /// #
+ /// # let ret =
+ /// // 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_ref<E>(&self) -> Option<&E>
+ where
+ E: Display + Debug + Send + Sync + 'static,
+ {
+ let target = TypeId::of::<E>();
+ unsafe {
+ // Use vtable to find NonNull<()> which points to a value of type E
+ // somewhere inside the data structure.
+ let addr = (self.inner.vtable.object_downcast)(&self.inner, target)?;
+ Some(&*addr.cast::<E>().as_ptr())
+ }
+ }
+
+ /// Downcast this error object by mutable reference.
+ pub fn downcast_mut<E>(&mut self) -> Option<&mut E>
+ where
+ E: Display + Debug + Send + Sync + 'static,
+ {
+ let target = TypeId::of::<E>();
+ unsafe {
+ // Use vtable to find NonNull<()> which points to a value of type E
+ // somewhere inside the data structure.
+ let addr = (self.inner.vtable.object_downcast)(&self.inner, target)?;
+ Some(&mut *addr.cast::<E>().as_ptr())
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl<E> From<E> for Error
+where
+ E: StdError + Send + Sync + 'static,
+{
+ fn from(error: E) -> Self {
+ let backtrace = backtrace_if_absent!(error);
+ Error::from_std(error, backtrace)
+ }
+}
+
+#[cfg(feature = "std")]
+impl Deref for Error {
+ type Target = dyn StdError + Send + Sync + 'static;
+
+ fn deref(&self) -> &Self::Target {
+ self.inner.error()
+ }
+}
+
+#[cfg(feature = "std")]
+impl DerefMut for Error {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ self.inner.error_mut()
+ }
+}
+
+impl Display for Error {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ self.inner.display(formatter)
+ }
+}
+
+impl Debug for Error {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ self.inner.debug(formatter)
+ }
+}
+
+impl Drop for Error {
+ fn drop(&mut self) {
+ unsafe {
+ // Read Box<ErrorImpl<()>> from self.
+ let inner = ptr::read(&self.inner);
+ let erased = ManuallyDrop::into_inner(inner);
+
+ // Invoke the vtable's drop behavior.
+ (erased.vtable.object_drop)(erased);
+ }
+ }
+}
+
+struct ErrorVTable {
+ object_drop: unsafe fn(Box<ErrorImpl<()>>),
+ object_ref: unsafe fn(&ErrorImpl<()>) -> &(dyn StdError + Send + Sync + 'static),
+ #[cfg(feature = "std")]
+ object_mut: unsafe fn(&mut ErrorImpl<()>) -> &mut (dyn StdError + Send + Sync + 'static),
+ object_boxed: unsafe fn(Box<ErrorImpl<()>>) -> Box<dyn StdError + Send + Sync + 'static>,
+ object_downcast: unsafe fn(&ErrorImpl<()>, TypeId) -> Option<NonNull<()>>,
+ object_drop_rest: unsafe fn(Box<ErrorImpl<()>>, TypeId),
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_drop<E>(e: Box<ErrorImpl<()>>) {
+ // Cast back to ErrorImpl<E> so that the allocator receives the correct
+ // Layout to deallocate the Box's memory.
+ let unerased = mem::transmute::<Box<ErrorImpl<()>>, Box<ErrorImpl<E>>>(e);
+ drop(unerased);
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_drop_front<E>(e: Box<ErrorImpl<()>>, target: TypeId) {
+ // Drop the fields of ErrorImpl other than E as well as the Box allocation,
+ // without dropping E itself. This is used by downcast after doing a
+ // ptr::read to take ownership of the E.
+ let _ = target;
+ let unerased = mem::transmute::<Box<ErrorImpl<()>>, Box<ErrorImpl<ManuallyDrop<E>>>>(e);
+ drop(unerased);
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_ref<E>(e: &ErrorImpl<()>) -> &(dyn StdError + Send + Sync + 'static)
+where
+ E: StdError + Send + Sync + 'static,
+{
+ // Attach E's native StdError vtable onto a pointer to self._object.
+ &(*(e as *const ErrorImpl<()> as *const ErrorImpl<E>))._object
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+#[cfg(feature = "std")]
+unsafe fn object_mut<E>(e: &mut ErrorImpl<()>) -> &mut (dyn StdError + Send + Sync + 'static)
+where
+ E: StdError + Send + Sync + 'static,
+{
+ // Attach E's native StdError vtable onto a pointer to self._object.
+ &mut (*(e as *mut ErrorImpl<()> as *mut ErrorImpl<E>))._object
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_boxed<E>(e: Box<ErrorImpl<()>>) -> Box<dyn StdError + Send + Sync + 'static>
+where
+ E: StdError + Send + Sync + 'static,
+{
+ // Attach ErrorImpl<E>'s native StdError vtable. The StdError impl is below.
+ mem::transmute::<Box<ErrorImpl<()>>, Box<ErrorImpl<E>>>(e)
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_downcast<E>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>
+where
+ E: 'static,
+{
+ if TypeId::of::<E>() == target {
+ // Caller is looking for an E pointer and e is ErrorImpl<E>, take a
+ // pointer to its E field.
+ let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<E>;
+ let addr = &(*unerased)._object as *const E as *mut ();
+ Some(NonNull::new_unchecked(addr))
+ } else {
+ None
+ }
+}
+
+// Safety: requires layout of *e to match ErrorImpl<ContextError<C, E>>.
+#[cfg(feature = "std")]
+unsafe fn context_downcast<C, E>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>
+where
+ C: 'static,
+ E: 'static,
+{
+ if TypeId::of::<C>() == target {
+ let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, E>>;
+ let addr = &(*unerased)._object.context as *const C as *mut ();
+ Some(NonNull::new_unchecked(addr))
+ } else if TypeId::of::<E>() == target {
+ let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, E>>;
+ let addr = &(*unerased)._object.error as *const E as *mut ();
+ Some(NonNull::new_unchecked(addr))
+ } else {
+ None
+ }
+}
+
+// Safety: requires layout of *e to match ErrorImpl<ContextError<C, E>>.
+#[cfg(feature = "std")]
+unsafe fn context_drop_rest<C, E>(e: Box<ErrorImpl<()>>, target: TypeId)
+where
+ C: 'static,
+ E: 'static,
+{
+ // Called after downcasting by value to either the C or the E and doing a
+ // ptr::read to take ownership of that value.
+ if TypeId::of::<C>() == target {
+ let unerased = mem::transmute::<
+ Box<ErrorImpl<()>>,
+ Box<ErrorImpl<ContextError<ManuallyDrop<C>, E>>>,
+ >(e);
+ drop(unerased);
+ } else {
+ let unerased = mem::transmute::<
+ Box<ErrorImpl<()>>,
+ Box<ErrorImpl<ContextError<C, ManuallyDrop<E>>>>,
+ >(e);
+ drop(unerased);
+ }
+}
+
+// Safety: requires layout of *e to match ErrorImpl<ContextError<C, Error>>.
+unsafe fn context_chain_downcast<C>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>
+where
+ C: 'static,
+{
+ if TypeId::of::<C>() == target {
+ let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, Error>>;
+ let addr = &(*unerased)._object.context as *const C as *mut ();
+ Some(NonNull::new_unchecked(addr))
+ } else {
+ // Recurse down the context chain per the inner error's vtable.
+ let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, Error>>;
+ let source = &(*unerased)._object.error;
+ (source.inner.vtable.object_downcast)(&source.inner, target)
+ }
+}
+
+// Safety: requires layout of *e to match ErrorImpl<ContextError<C, Error>>.
+unsafe fn context_chain_drop_rest<C>(e: Box<ErrorImpl<()>>, target: TypeId)
+where
+ C: 'static,
+{
+ // Called after downcasting by value to either the C or one of the causes
+ // and doing a ptr::read to take ownership of that value.
+ if TypeId::of::<C>() == target {
+ let unerased = mem::transmute::<
+ Box<ErrorImpl<()>>,
+ Box<ErrorImpl<ContextError<ManuallyDrop<C>, Error>>>,
+ >(e);
+ // Drop the entire rest of the data structure rooted in the next Error.
+ drop(unerased);
+ } else {
+ let unerased = mem::transmute::<
+ Box<ErrorImpl<()>>,
+ Box<ErrorImpl<ContextError<C, ManuallyDrop<Error>>>>,
+ >(e);
+ // Read out a ManuallyDrop<Box<ErrorImpl<()>>> from the next error.
+ let inner = ptr::read(&unerased._object.error.inner);
+ drop(unerased);
+ let erased = ManuallyDrop::into_inner(inner);
+ // Recursively drop the next error using the same target typeid.
+ (erased.vtable.object_drop_rest)(erased, target);
+ }
+}
+
+// repr C to ensure that E remains in the final position.
+#[repr(C)]
+pub(crate) struct ErrorImpl<E> {
+ vtable: &'static ErrorVTable,
+ backtrace: Option<Backtrace>,
+ // NOTE: Don't use directly. Use only through vtable. Erased type may have
+ // different alignment.
+ _object: E,
+}
+
+// repr C to ensure that ContextError<C, E> has the same layout as
+// ContextError<ManuallyDrop<C>, E> and ContextError<C, ManuallyDrop<E>>.
+#[repr(C)]
+pub(crate) struct ContextError<C, E> {
+ pub context: C,
+ pub error: E,
+}
+
+impl<E> ErrorImpl<E> {
+ fn erase(&self) -> &ErrorImpl<()> {
+ // Erase the concrete type of E but preserve the vtable in self.vtable
+ // for manipulating the resulting thin pointer. This is analogous to an
+ // unsize coersion.
+ unsafe { &*(self as *const ErrorImpl<E> as *const ErrorImpl<()>) }
+ }
+}
+
+impl ErrorImpl<()> {
+ pub(crate) fn error(&self) -> &(dyn StdError + Send + Sync + 'static) {
+ // Use vtable to attach E's native StdError vtable for the right
+ // original type E.
+ unsafe { &*(self.vtable.object_ref)(self) }
+ }
+
+ #[cfg(feature = "std")]
+ pub(crate) fn error_mut(&mut self) -> &mut (dyn StdError + Send + Sync + 'static) {
+ // Use vtable to attach E's native StdError vtable for the right
+ // original type E.
+ unsafe { &mut *(self.vtable.object_mut)(self) }
+ }
+
+ #[cfg(backtrace)]
+ pub(crate) fn backtrace(&self) -> &Backtrace {
+ // This unwrap can only panic if the underlying error's backtrace method
+ // is nondeterministic, which would only happen in maliciously
+ // constructed code.
+ self.backtrace
+ .as_ref()
+ .or_else(|| self.error().backtrace())
+ .expect("backtrace capture failed")
+ }
+
+ pub(crate) fn chain(&self) -> Chain {
+ Chain::new(self.error())
+ }
+}
+
+impl<E> StdError for ErrorImpl<E>
+where
+ E: StdError,
+{
+ #[cfg(backtrace)]
+ fn backtrace(&self) -> Option<&Backtrace> {
+ Some(self.erase().backtrace())
+ }
+
+ fn source(&self) -> Option<&(dyn StdError + 'static)> {
+ self.erase().error().source()
+ }
+}
+
+impl<E> Debug for ErrorImpl<E>
+where
+ E: Debug,
+{
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ self.erase().debug(formatter)
+ }
+}
+
+impl<E> Display for ErrorImpl<E>
+where
+ E: Display,
+{
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ Display::fmt(&self.erase().error(), formatter)
+ }
+}
+
+impl From<Error> for Box<dyn StdError + Send + Sync + 'static> {
+ fn from(error: Error) -> Self {
+ let outer = ManuallyDrop::new(error);
+ unsafe {
+ // Read Box<ErrorImpl<()>> from error. Can't move it out because
+ // Error has a Drop impl which we want to not run.
+ let inner = ptr::read(&outer.inner);
+ let erased = ManuallyDrop::into_inner(inner);
+
+ // Use vtable to attach ErrorImpl<E>'s native StdError vtable for
+ // the right original type E.
+ (erased.vtable.object_boxed)(erased)
+ }
+ }
+}
+
+impl From<Error> for Box<dyn StdError + 'static> {
+ fn from(error: Error) -> Self {
+ Box::<dyn StdError + Send + Sync>::from(error)
+ }
+}
+
+#[cfg(feature = "std")]
+impl AsRef<dyn StdError + Send + Sync> for Error {
+ fn as_ref(&self) -> &(dyn StdError + Send + Sync + 'static) {
+ &**self
+ }
+}
+
+#[cfg(feature = "std")]
+impl AsRef<dyn StdError> for Error {
+ fn as_ref(&self) -> &(dyn StdError + 'static) {
+ &**self
+ }
+}
diff --git a/third_party/rust/anyhow/src/fmt.rs b/third_party/rust/anyhow/src/fmt.rs
new file mode 100644
index 0000000000..16a82ba8d8
--- /dev/null
+++ b/third_party/rust/anyhow/src/fmt.rs
@@ -0,0 +1,149 @@
+use crate::chain::Chain;
+use crate::error::ErrorImpl;
+use core::fmt::{self, Debug, Write};
+
+impl ErrorImpl<()> {
+ pub(crate) fn display(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{}", self.error())?;
+
+ if f.alternate() {
+ for cause in self.chain().skip(1) {
+ write!(f, ": {}", cause)?;
+ }
+ }
+
+ Ok(())
+ }
+
+ pub(crate) fn debug(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let error = self.error();
+
+ if f.alternate() {
+ return Debug::fmt(error, f);
+ }
+
+ write!(f, "{}", error)?;
+
+ if let Some(cause) = error.source() {
+ write!(f, "\n\nCaused by:")?;
+ let multiple = cause.source().is_some();
+ for (n, error) in Chain::new(cause).enumerate() {
+ writeln!(f)?;
+ let mut indented = Indented {
+ inner: f,
+ number: if multiple { Some(n) } else { None },
+ started: false,
+ };
+ write!(indented, "{}", error)?;
+ }
+ }
+
+ #[cfg(backtrace)]
+ {
+ use std::backtrace::BacktraceStatus;
+
+ let backtrace = self.backtrace();
+ if let BacktraceStatus::Captured = backtrace.status() {
+ let mut backtrace = backtrace.to_string();
+ if backtrace.starts_with("stack backtrace:") {
+ // Capitalize to match "Caused by:"
+ backtrace.replace_range(0..1, "S");
+ }
+ backtrace.truncate(backtrace.trim_end().len());
+ write!(f, "\n\n{}", backtrace)?;
+ }
+ }
+
+ Ok(())
+ }
+}
+
+struct Indented<'a, D> {
+ inner: &'a mut D,
+ number: Option<usize>,
+ started: bool,
+}
+
+impl<T> Write for Indented<'_, T>
+where
+ T: Write,
+{
+ fn write_str(&mut self, s: &str) -> fmt::Result {
+ for (i, line) in s.split('\n').enumerate() {
+ if !self.started {
+ self.started = true;
+ match self.number {
+ Some(number) => write!(self.inner, "{: >5}: ", number)?,
+ None => self.inner.write_str(" ")?,
+ }
+ } else if i > 0 {
+ self.inner.write_char('\n')?;
+ if self.number.is_some() {
+ self.inner.write_str(" ")?;
+ } else {
+ self.inner.write_str(" ")?;
+ }
+ }
+
+ self.inner.write_str(line)?;
+ }
+
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn one_digit() {
+ let input = "verify\nthis";
+ let expected = " 2: verify\n this";
+ let mut output = String::new();
+
+ Indented {
+ inner: &mut output,
+ number: Some(2),
+ started: false,
+ }
+ .write_str(input)
+ .unwrap();
+
+ assert_eq!(expected, output);
+ }
+
+ #[test]
+ fn two_digits() {
+ let input = "verify\nthis";
+ let expected = " 12: verify\n this";
+ let mut output = String::new();
+
+ Indented {
+ inner: &mut output,
+ number: Some(12),
+ started: false,
+ }
+ .write_str(input)
+ .unwrap();
+
+ assert_eq!(expected, output);
+ }
+
+ #[test]
+ fn no_digits() {
+ let input = "verify\nthis";
+ let expected = " verify\n this";
+ let mut output = String::new();
+
+ Indented {
+ inner: &mut output,
+ number: None,
+ started: false,
+ }
+ .write_str(input)
+ .unwrap();
+
+ assert_eq!(expected, output);
+ }
+}
diff --git a/third_party/rust/anyhow/src/kind.rs b/third_party/rust/anyhow/src/kind.rs
new file mode 100644
index 0000000000..fdeb060ad8
--- /dev/null
+++ b/third_party/rust/anyhow/src/kind.rs
@@ -0,0 +1,116 @@
+// Tagged dispatch mechanism for resolving the behavior of `anyhow!($expr)`.
+//
+// When anyhow! is given a single expr argument to turn into anyhow::Error, we
+// want the resulting Error to pick up the input's implementation of source()
+// and backtrace() if it has a std::error::Error impl, otherwise require nothing
+// more than Display and Debug.
+//
+// Expressed in terms of specialization, we want something like:
+//
+// trait AnyhowNew {
+// fn new(self) -> Error;
+// }
+//
+// impl<T> AnyhowNew for T
+// where
+// T: Display + Debug + Send + Sync + 'static,
+// {
+// default fn new(self) -> Error {
+// /* no std error impl */
+// }
+// }
+//
+// impl<T> AnyhowNew for T
+// where
+// T: std::error::Error + Send + Sync + 'static,
+// {
+// fn new(self) -> Error {
+// /* use std error's source() and backtrace() */
+// }
+// }
+//
+// Since specialization is not stable yet, instead we rely on autoref behavior
+// of method resolution to perform tagged dispatch. Here we have two traits
+// AdhocKind and TraitKind that both have an anyhow_kind() method. AdhocKind is
+// implemented whether or not the caller's type has a std error impl, while
+// TraitKind is implemented only when a std error impl does exist. The ambiguity
+// is resolved by AdhocKind requiring an extra autoref so that it has lower
+// precedence.
+//
+// The anyhow! macro will set up the call in this form:
+//
+// #[allow(unused_imports)]
+// use $crate::private::{AdhocKind, TraitKind};
+// let error = $msg;
+// (&error).anyhow_kind().new(error)
+
+use crate::Error;
+use core::fmt::{Debug, Display};
+
+#[cfg(feature = "std")]
+use crate::StdError;
+
+#[cfg(backtrace)]
+use std::backtrace::Backtrace;
+
+pub struct Adhoc;
+
+pub trait AdhocKind: Sized {
+ #[inline]
+ fn anyhow_kind(&self) -> Adhoc {
+ Adhoc
+ }
+}
+
+impl<T> AdhocKind for &T where T: ?Sized + Display + Debug + Send + Sync + 'static {}
+
+impl Adhoc {
+ pub fn new<M>(self, message: M) -> Error
+ where
+ M: Display + Debug + Send + Sync + 'static,
+ {
+ Error::from_adhoc(message, backtrace!())
+ }
+}
+
+pub struct Trait;
+
+pub trait TraitKind: Sized {
+ #[inline]
+ fn anyhow_kind(&self) -> Trait {
+ Trait
+ }
+}
+
+impl<E> TraitKind for E where E: Into<Error> {}
+
+impl Trait {
+ pub fn new<E>(self, error: E) -> Error
+ where
+ E: Into<Error>,
+ {
+ error.into()
+ }
+}
+
+#[cfg(feature = "std")]
+pub struct Boxed;
+
+#[cfg(feature = "std")]
+pub trait BoxedKind: Sized {
+ #[inline]
+ fn anyhow_kind(&self) -> Boxed {
+ Boxed
+ }
+}
+
+#[cfg(feature = "std")]
+impl BoxedKind for Box<dyn StdError + Send + Sync> {}
+
+#[cfg(feature = "std")]
+impl Boxed {
+ pub fn new(self, error: Box<dyn StdError + Send + Sync>) -> Error {
+ let backtrace = backtrace_if_absent!(error);
+ Error::from_boxed(error, backtrace)
+ }
+}
diff --git a/third_party/rust/anyhow/src/lib.rs b/third_party/rust/anyhow/src/lib.rs
new file mode 100644
index 0000000000..91d4c4652e
--- /dev/null
+++ b/third_party/rust/anyhow/src/lib.rs
@@ -0,0 +1,603 @@
+//! [![github]](https://github.com/dtolnay/anyhow)&ensp;[![crates-io]](https://crates.io/crates/anyhow)&ensp;[![docs-rs]](https://docs.rs/anyhow)
+//!
+//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
+//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K
+//!
+//! <br>
+//!
+//! This library provides [`anyhow::Error`][Error], a trait object based error
+//! type for easy idiomatic error handling in Rust applications.
+//!
+//! <br>
+//!
+//! # Details
+//!
+//! - Use `Result<T, anyhow::Error>`, or equivalently `anyhow::Result<T>`, as
+//! the return type of any fallible function.
+//!
+//! Within the function, use `?` to easily propagate any error that implements
+//! the `std::error::Error` trait.
+//!
+//! ```
+//! # pub trait Deserialize {}
+//! #
+//! # mod serde_json {
+//! # use super::Deserialize;
+//! # use std::io;
+//! #
+//! # pub fn from_str<T: Deserialize>(json: &str) -> io::Result<T> {
+//! # unimplemented!()
+//! # }
+//! # }
+//! #
+//! # struct ClusterMap;
+//! #
+//! # impl Deserialize for ClusterMap {}
+//! #
+//! use anyhow::Result;
+//!
+//! fn get_cluster_info() -> Result<ClusterMap> {
+//! let config = std::fs::read_to_string("cluster.json")?;
+//! let map: ClusterMap = serde_json::from_str(&config)?;
+//! Ok(map)
+//! }
+//! #
+//! # fn main() {}
+//! ```
+//!
+//! - Attach context to help the person troubleshooting the error understand
+//! where things went wrong. A low-level error like "No such file or
+//! directory" can be annoying to debug without more context about what higher
+//! level step the application was in the middle of.
+//!
+//! ```
+//! # struct It;
+//! #
+//! # impl It {
+//! # fn detach(&self) -> Result<()> {
+//! # unimplemented!()
+//! # }
+//! # }
+//! #
+//! use anyhow::{Context, Result};
+//!
+//! fn main() -> Result<()> {
+//! # return Ok(());
+//! #
+//! # const _: &str = stringify! {
+//! ...
+//! # };
+//! #
+//! # let it = It;
+//! # let path = "./path/to/instrs.json";
+//! #
+//! it.detach().context("Failed to detach the important thing")?;
+//!
+//! let content = std::fs::read(path)
+//! .with_context(|| format!("Failed to read instrs from {}", path))?;
+//! #
+//! # const _: &str = stringify! {
+//! ...
+//! # };
+//! #
+//! # Ok(())
+//! }
+//! ```
+//!
+//! ```console
+//! Error: Failed to read instrs from ./path/to/instrs.json
+//!
+//! Caused by:
+//! No such file or directory (os error 2)
+//! ```
+//!
+//! - Downcasting is supported and can be by value, by shared reference, or by
+//! mutable reference as needed.
+//!
+//! ```
+//! # use anyhow::anyhow;
+//! # use std::fmt::{self, Display};
+//! # use std::task::Poll;
+//! #
+//! # #[derive(Debug)]
+//! # enum DataStoreError {
+//! # Censored(()),
+//! # }
+//! #
+//! # impl Display for DataStoreError {
+//! # fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+//! # unimplemented!()
+//! # }
+//! # }
+//! #
+//! # impl std::error::Error for DataStoreError {}
+//! #
+//! # const REDACTED_CONTENT: () = ();
+//! #
+//! # let error = anyhow!("...");
+//! # let root_cause = &error;
+//! #
+//! # let ret =
+//! // 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),
+//! }
+//! # ;
+//! ```
+//!
+//! - If using the nightly channel, a backtrace is captured and printed with the
+//! error if the underlying error type does not already provide its own. In
+//! order to see backtraces, they must be enabled through the environment
+//! variables described in [`std::backtrace`]:
+//!
+//! - 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`.
+//!
+//! The tracking issue for this feature is [rust-lang/rust#53487].
+//!
+//! [`std::backtrace`]: https://doc.rust-lang.org/std/backtrace/index.html#environment-variables
+//! [rust-lang/rust#53487]: https://github.com/rust-lang/rust/issues/53487
+//!
+//! - Anyhow works with any error type that has an impl of `std::error::Error`,
+//! including ones defined in your crate. We do not bundle a `derive(Error)`
+//! macro but you can write the impls yourself or use a standalone macro like
+//! [thiserror].
+//!
+//! [thiserror]: https://github.com/dtolnay/thiserror
+//!
+//! ```
+//! use thiserror::Error;
+//!
+//! #[derive(Error, Debug)]
+//! pub enum FormatError {
+//! #[error("Invalid header (expected {expected:?}, got {found:?})")]
+//! InvalidHeader {
+//! expected: String,
+//! found: String,
+//! },
+//! #[error("Missing attribute: {0}")]
+//! MissingAttribute(String),
+//! }
+//! ```
+//!
+//! - One-off error messages can be constructed using the `anyhow!` macro, which
+//! supports string interpolation and produces an `anyhow::Error`.
+//!
+//! ```
+//! # use anyhow::{anyhow, Result};
+//! #
+//! # fn demo() -> Result<()> {
+//! # let missing = "...";
+//! return Err(anyhow!("Missing attribute: {}", missing));
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! <br>
+//!
+//! # No-std support
+//!
+//! In no_std mode, the same API is almost all available and works the same way.
+//! To depend on Anyhow in no_std mode, disable our default enabled "std"
+//! feature in Cargo.toml. A global allocator is required.
+//!
+//! ```toml
+//! [dependencies]
+//! anyhow = { version = "1.0", default-features = false }
+//! ```
+//!
+//! Since the `?`-based error conversions would normally rely on the
+//! `std::error::Error` trait which is only available through std, no_std mode
+//! will require an explicit `.map_err(Error::msg)` when working with a
+//! non-Anyhow error type inside a function that returns Anyhow's error type.
+
+#![doc(html_root_url = "https://docs.rs/anyhow/1.0.30")]
+#![cfg_attr(backtrace, feature(backtrace))]
+#![cfg_attr(doc_cfg, feature(doc_cfg))]
+#![cfg_attr(not(feature = "std"), no_std)]
+#![allow(
+ clippy::needless_doctest_main,
+ clippy::new_ret_no_self,
+ clippy::wrong_self_convention
+)]
+
+mod alloc {
+ #[cfg(not(feature = "std"))]
+ extern crate alloc;
+
+ #[cfg(not(feature = "std"))]
+ pub use alloc::boxed::Box;
+
+ #[cfg(feature = "std")]
+ pub use std::boxed::Box;
+}
+
+#[macro_use]
+mod backtrace;
+mod chain;
+mod context;
+mod error;
+mod fmt;
+mod kind;
+mod macros;
+mod wrapper;
+
+use crate::alloc::Box;
+use crate::error::ErrorImpl;
+use core::fmt::Display;
+use core::mem::ManuallyDrop;
+
+#[cfg(not(feature = "std"))]
+use core::fmt::Debug;
+
+#[cfg(feature = "std")]
+use std::error::Error as StdError;
+
+#[cfg(not(feature = "std"))]
+trait StdError: Debug + Display {
+ fn source(&self) -> Option<&(dyn StdError + 'static)> {
+ None
+ }
+}
+
+pub use anyhow as format_err;
+
+/// 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 &mdash; exactly one word in
+/// size instead of two.
+///
+/// <br>
+///
+/// # 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.
+///
+/// ```console
+/// 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 "{:#}".
+///
+/// ```console
+/// 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.
+///
+/// ```console
+/// 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 "{:#?}".
+///
+/// ```console
+/// 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<()> {
+/// # const IGNORE: &str = stringify! {
+/// ...
+/// # };
+/// # Ok(())
+/// }
+/// ```
+pub struct Error {
+ inner: ManuallyDrop<Box<ErrorImpl<()>>>,
+}
+
+/// Iterator of a chain of source errors.
+///
+/// This type is the iterator returned by [`Error::chain`].
+///
+/// # 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
+/// }
+/// ```
+#[cfg(feature = "std")]
+#[derive(Clone)]
+pub struct Chain<'a> {
+ state: crate::chain::ChainState<'a>,
+}
+
+/// `Result<T, Error>`
+///
+/// This is a reasonable return type to use throughout your application but also
+/// for `fn main`; if you do, failures will be printed along with any
+/// [context][Context] and a backtrace if one was captured.
+///
+/// `anyhow::Result` may be used with one *or* two type parameters.
+///
+/// ```rust
+/// use anyhow::Result;
+///
+/// # const IGNORE: &str = stringify! {
+/// fn demo1() -> Result<T> {...}
+/// // ^ equivalent to std::result::Result<T, anyhow::Error>
+///
+/// fn demo2() -> Result<T, OtherError> {...}
+/// // ^ equivalent to std::result::Result<T, OtherError>
+/// # };
+/// ```
+///
+/// # Example
+///
+/// ```
+/// # pub trait Deserialize {}
+/// #
+/// # mod serde_json {
+/// # use super::Deserialize;
+/// # use std::io;
+/// #
+/// # pub fn from_str<T: Deserialize>(json: &str) -> io::Result<T> {
+/// # unimplemented!()
+/// # }
+/// # }
+/// #
+/// # #[derive(Debug)]
+/// # struct ClusterMap;
+/// #
+/// # impl Deserialize for ClusterMap {}
+/// #
+/// use anyhow::Result;
+///
+/// fn main() -> Result<()> {
+/// # return Ok(());
+/// let config = std::fs::read_to_string("cluster.json")?;
+/// let map: ClusterMap = serde_json::from_str(&config)?;
+/// println!("cluster info: {:#?}", map);
+/// Ok(())
+/// }
+/// ```
+pub type Result<T, E = Error> = core::result::Result<T, E>;
+
+/// Provides the `context` method for `Result`.
+///
+/// This trait is sealed and cannot be implemented for types outside of
+/// `anyhow`.
+///
+/// <br>
+///
+/// # Example
+///
+/// ```
+/// use anyhow::{Context, Result};
+/// use std::fs;
+/// use std::path::PathBuf;
+///
+/// pub struct ImportantThing {
+/// path: PathBuf,
+/// }
+///
+/// impl ImportantThing {
+/// # const IGNORE: &'static str = stringify! {
+/// pub fn detach(&mut self) -> Result<()> {...}
+/// # };
+/// # fn detach(&mut self) -> Result<()> {
+/// # unimplemented!()
+/// # }
+/// }
+///
+/// pub fn do_it(mut it: ImportantThing) -> Result<Vec<u8>> {
+/// it.detach().context("Failed to detach the important thing")?;
+///
+/// let path = &it.path;
+/// let content = fs::read(path)
+/// .with_context(|| format!("Failed to read instrs from {}", path.display()))?;
+///
+/// Ok(content)
+/// }
+/// ```
+///
+/// When printed, the outermost context would be printed first and the lower
+/// level underlying causes would be enumerated below.
+///
+/// ```console
+/// Error: Failed to read instrs from ./path/to/instrs.json
+///
+/// Caused by:
+/// No such file or directory (os error 2)
+/// ```
+///
+/// <br>
+///
+/// # Effect on downcasting
+///
+/// After attaching context of type `C` onto an error of type `E`, the resulting
+/// `anyhow::Error` may be downcast to `C` **or** to `E`.
+///
+/// That is, in codebases that rely on downcasting, Anyhow's context supports
+/// both of the following use cases:
+///
+/// - **Attaching context whose type is insignificant onto errors whose type
+/// is used in downcasts.**
+///
+/// In other error libraries whose context is not designed this way, it can
+/// be risky to introduce context to existing code because new context might
+/// break existing working downcasts. In Anyhow, any downcast that worked
+/// before adding context will continue to work after you add a context, so
+/// you should freely add human-readable context to errors wherever it would
+/// be helpful.
+///
+/// ```
+/// # use anyhow::bail;
+/// # use thiserror::Error;
+/// #
+/// # #[derive(Error, Debug)]
+/// # #[error("???")]
+/// # struct SuspiciousError;
+/// #
+/// # fn helper() -> Result<()> {
+/// # bail!(SuspiciousError);
+/// # }
+/// #
+/// use anyhow::{Context, Result};
+///
+/// fn do_it() -> Result<()> {
+/// helper().context("Failed to complete the work")?;
+/// # const IGNORE: &str = stringify! {
+/// ...
+/// # };
+/// # unreachable!()
+/// }
+///
+/// fn main() {
+/// let err = do_it().unwrap_err();
+/// if let Some(e) = err.downcast_ref::<SuspiciousError>() {
+/// // If helper() returned SuspiciousError, this downcast will
+/// // correctly succeed even with the context in between.
+/// # return;
+/// }
+/// # panic!("expected downcast to succeed");
+/// }
+/// ```
+///
+/// - **Attaching context whose type is used in downcasts onto errors whose
+/// type is insignificant.**
+///
+/// Some codebases prefer to use machine-readable context to categorize
+/// lower level errors in a way that will be actionable to higher levels of
+/// the application.
+///
+/// ```
+/// # use anyhow::bail;
+/// # use thiserror::Error;
+/// #
+/// # #[derive(Error, Debug)]
+/// # #[error("???")]
+/// # struct HelperFailed;
+/// #
+/// # fn helper() -> Result<()> {
+/// # bail!("no such file or directory");
+/// # }
+/// #
+/// use anyhow::{Context, Result};
+///
+/// fn do_it() -> Result<()> {
+/// helper().context(HelperFailed)?;
+/// # const IGNORE: &str = stringify! {
+/// ...
+/// # };
+/// # unreachable!()
+/// }
+///
+/// fn main() {
+/// let err = do_it().unwrap_err();
+/// if let Some(e) = err.downcast_ref::<HelperFailed>() {
+/// // If helper failed, this downcast will succeed because
+/// // HelperFailed is the context that has been attached to
+/// // that error.
+/// # return;
+/// }
+/// # panic!("expected downcast to succeed");
+/// }
+/// ```
+pub trait Context<T, E>: context::private::Sealed {
+ /// Wrap the error value with additional context.
+ fn context<C>(self, context: C) -> Result<T, Error>
+ where
+ C: Display + Send + Sync + 'static;
+
+ /// Wrap the error value with additional context that is evaluated lazily
+ /// only once an error does occur.
+ fn with_context<C, F>(self, f: F) -> Result<T, Error>
+ where
+ C: Display + Send + Sync + 'static,
+ F: FnOnce() -> C;
+}
+
+// Not public API. Referenced by macro-generated code.
+#[doc(hidden)]
+pub mod private {
+ use crate::Error;
+ use core::fmt::{Debug, Display};
+
+ #[cfg(backtrace)]
+ use std::backtrace::Backtrace;
+
+ pub use core::result::Result::Err;
+
+ #[doc(hidden)]
+ pub mod kind {
+ pub use crate::kind::{AdhocKind, TraitKind};
+
+ #[cfg(feature = "std")]
+ pub use crate::kind::BoxedKind;
+ }
+
+ pub fn new_adhoc<M>(message: M) -> Error
+ where
+ M: Display + Debug + Send + Sync + 'static,
+ {
+ Error::from_adhoc(message, backtrace!())
+ }
+}
diff --git a/third_party/rust/anyhow/src/macros.rs b/third_party/rust/anyhow/src/macros.rs
new file mode 100644
index 0000000000..15a920810c
--- /dev/null
+++ b/third_party/rust/anyhow/src/macros.rs
@@ -0,0 +1,163 @@
+/// Return early with an error.
+///
+/// This macro is equivalent to `return Err(From::from($err))`.
+///
+/// # Example
+///
+/// ```
+/// # use anyhow::{bail, Result};
+/// #
+/// # fn has_permission(user: usize, resource: usize) -> bool {
+/// # true
+/// # }
+/// #
+/// # fn main() -> Result<()> {
+/// # let user = 0;
+/// # let resource = 0;
+/// #
+/// if !has_permission(user, resource) {
+/// bail!("permission denied for accessing {}", resource);
+/// }
+/// # Ok(())
+/// # }
+/// ```
+///
+/// ```
+/// # use anyhow::{bail, Result};
+/// # use thiserror::Error;
+/// #
+/// # const MAX_DEPTH: usize = 1;
+/// #
+/// #[derive(Error, Debug)]
+/// enum ScienceError {
+/// #[error("recursion limit exceeded")]
+/// RecursionLimitExceeded,
+/// # #[error("...")]
+/// # More = (stringify! {
+/// ...
+/// # }, 1).1,
+/// }
+///
+/// # fn main() -> Result<()> {
+/// # let depth = 0;
+/// #
+/// if depth > MAX_DEPTH {
+/// bail!(ScienceError::RecursionLimitExceeded);
+/// }
+/// # Ok(())
+/// # }
+/// ```
+#[macro_export]
+macro_rules! bail {
+ ($msg:literal $(,)?) => {
+ return $crate::private::Err($crate::anyhow!($msg));
+ };
+ ($err:expr $(,)?) => {
+ return $crate::private::Err($crate::anyhow!($err));
+ };
+ ($fmt:expr, $($arg:tt)*) => {
+ return $crate::private::Err($crate::anyhow!($fmt, $($arg)*));
+ };
+}
+
+/// Return early with an error if a condition is not satisfied.
+///
+/// This macro is equivalent to `if !$cond { return Err(From::from($err)); }`.
+///
+/// Analogously to `assert!`, `ensure!` takes a condition and exits the function
+/// if the condition fails. Unlike `assert!`, `ensure!` returns an `Error`
+/// rather than panicking.
+///
+/// # Example
+///
+/// ```
+/// # use anyhow::{ensure, Result};
+/// #
+/// # fn main() -> Result<()> {
+/// # let user = 0;
+/// #
+/// ensure!(user == 0, "only user 0 is allowed");
+/// # Ok(())
+/// # }
+/// ```
+///
+/// ```
+/// # use anyhow::{ensure, Result};
+/// # use thiserror::Error;
+/// #
+/// # const MAX_DEPTH: usize = 1;
+/// #
+/// #[derive(Error, Debug)]
+/// enum ScienceError {
+/// #[error("recursion limit exceeded")]
+/// RecursionLimitExceeded,
+/// # #[error("...")]
+/// # More = (stringify! {
+/// ...
+/// # }, 1).1,
+/// }
+///
+/// # fn main() -> Result<()> {
+/// # let depth = 0;
+/// #
+/// ensure!(depth <= MAX_DEPTH, ScienceError::RecursionLimitExceeded);
+/// # Ok(())
+/// # }
+/// ```
+#[macro_export]
+macro_rules! ensure {
+ ($cond:expr, $msg:literal $(,)?) => {
+ if !$cond {
+ return $crate::private::Err($crate::anyhow!($msg));
+ }
+ };
+ ($cond:expr, $err:expr $(,)?) => {
+ if !$cond {
+ return $crate::private::Err($crate::anyhow!($err));
+ }
+ };
+ ($cond:expr, $fmt:expr, $($arg:tt)*) => {
+ if !$cond {
+ return $crate::private::Err($crate::anyhow!($fmt, $($arg)*));
+ }
+ };
+}
+
+/// Construct an ad-hoc error from a string.
+///
+/// This evaluates to an `Error`. It can take either just a string, or a format
+/// string with arguments. It also can take any custom type which implements
+/// `Debug` and `Display`.
+///
+/// # Example
+///
+/// ```
+/// # type V = ();
+/// #
+/// use anyhow::{anyhow, Result};
+///
+/// fn lookup(key: &str) -> Result<V> {
+/// if key.len() != 16 {
+/// return Err(anyhow!("key length must be 16 characters, got {:?}", key));
+/// }
+///
+/// // ...
+/// # Ok(())
+/// }
+/// ```
+#[macro_export]
+macro_rules! anyhow {
+ ($msg:literal $(,)?) => {
+ // Handle $:literal as a special case to make cargo-expanded code more
+ // concise in the common case.
+ $crate::private::new_adhoc($msg)
+ };
+ ($err:expr $(,)?) => ({
+ use $crate::private::kind::*;
+ let error = $err;
+ (&error).anyhow_kind().new(error)
+ });
+ ($fmt:expr, $($arg:tt)*) => {
+ $crate::private::new_adhoc(format!($fmt, $($arg)*))
+ };
+}
diff --git a/third_party/rust/anyhow/src/wrapper.rs b/third_party/rust/anyhow/src/wrapper.rs
new file mode 100644
index 0000000000..3ebe51a883
--- /dev/null
+++ b/third_party/rust/anyhow/src/wrapper.rs
@@ -0,0 +1,78 @@
+use crate::StdError;
+use core::fmt::{self, Debug, Display};
+
+#[repr(transparent)]
+pub struct MessageError<M>(pub M);
+
+impl<M> Debug for MessageError<M>
+where
+ M: Display + Debug,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ Debug::fmt(&self.0, f)
+ }
+}
+
+impl<M> Display for MessageError<M>
+where
+ M: Display + Debug,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ Display::fmt(&self.0, f)
+ }
+}
+
+impl<M> StdError for MessageError<M> where M: Display + Debug + 'static {}
+
+#[repr(transparent)]
+pub struct DisplayError<M>(pub M);
+
+impl<M> Debug for DisplayError<M>
+where
+ M: Display,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ Display::fmt(&self.0, f)
+ }
+}
+
+impl<M> Display for DisplayError<M>
+where
+ M: Display,
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ Display::fmt(&self.0, f)
+ }
+}
+
+impl<M> StdError for DisplayError<M> where M: Display + 'static {}
+
+#[cfg(feature = "std")]
+#[repr(transparent)]
+pub struct BoxedError(pub Box<dyn StdError + Send + Sync>);
+
+#[cfg(feature = "std")]
+impl Debug for BoxedError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ Debug::fmt(&self.0, f)
+ }
+}
+
+#[cfg(feature = "std")]
+impl Display for BoxedError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ Display::fmt(&self.0, f)
+ }
+}
+
+#[cfg(feature = "std")]
+impl StdError for BoxedError {
+ #[cfg(backtrace)]
+ fn backtrace(&self) -> Option<&crate::backtrace::Backtrace> {
+ self.0.backtrace()
+ }
+
+ fn source(&self) -> Option<&(dyn StdError + 'static)> {
+ self.0.source()
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-02-10 15:25:19 +0000