Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 155 insertions, 0 deletions

diff --git a/third_party/rust/error-support/.cargo-checksum.json b/third_party/rust/error-support/.cargo-checksum.json
new file mode 100644
index 0000000000..85a8105f41
--- /dev/null
+++ b/third_party/rust/error-support/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"8419c1fdf71e30634e2ca9dbbabf0f83fdb7dde6a945060c31a16acdbec6894f","src/lib.rs":"70fa9bba695574d97a6e1add79c400744cbd0d60639cbcdc0121c89fa20f9c81"},"package":null}
\ No newline at end of file
diff --git a/third_party/rust/error-support/Cargo.toml b/third_party/rust/error-support/Cargo.toml
new file mode 100644
index 0000000000..2af9ceda3f
--- /dev/null
+++ b/third_party/rust/error-support/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "error-support"
+version = "0.1.0"
+authors = ["Thom Chiovoloni <tchiovoloni@mozilla.com>"]
+edition = "2018"
+license = "MPL-2.0"
+
+[dependencies]
+thiserror = "1.0"
+
+[dependencies.backtrace]
+optional = true
+version = "0.3"
diff --git a/third_party/rust/error-support/src/lib.rs b/third_party/rust/error-support/src/lib.rs
new file mode 100644
index 0000000000..913837672c
--- /dev/null
+++ b/third_party/rust/error-support/src/lib.rs
@@ -0,0 +1,141 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#[cfg(feature = "backtrace")]
+/// Re-export of the `backtrace` crate for use in macros and
+/// to ensure the needed version is kept in sync in dependents.
+pub use backtrace;
+
+#[cfg(not(feature = "backtrace"))]
+/// A compatibility shim for `backtrace`.
+pub mod backtrace {
+    use std::fmt;
+
+    pub struct Backtrace;
+
+    impl fmt::Debug for Backtrace {
+        #[cold]
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            write!(f, "Not available")
+        }
+    }
+}
+
+/// Define a wrapper around the the provided ErrorKind type.
+/// See also `define_error` which is more likely to be what you want.
+#[macro_export]
+macro_rules! define_error_wrapper {
+    ($Kind:ty) => {
+        pub type Result<T, E = Error> = std::result::Result<T, E>;
+        struct ErrorData {
+            kind: $Kind,
+            backtrace: Option<std::sync::Mutex<$crate::backtrace::Backtrace>>,
+        }
+
+        impl ErrorData {
+            #[cold]
+            fn new(kind: $Kind) -> Self {
+                ErrorData {
+                    kind,
+                    #[cfg(feature = "backtrace")]
+                    backtrace: Some(std::sync::Mutex::new(
+                        $crate::backtrace::Backtrace::new_unresolved(),
+                    )),
+                    #[cfg(not(feature = "backtrace"))]
+                    backtrace: None,
+                }
+            }
+
+            #[cfg(feature = "backtrace")]
+            #[cold]
+            fn get_backtrace(&self) -> Option<&std::sync::Mutex<$crate::backtrace::Backtrace>> {
+                self.backtrace.as_ref().map(|mutex| {
+                    mutex.lock().unwrap().resolve();
+                    mutex
+                })
+            }
+
+            #[cfg(not(feature = "backtrace"))]
+            #[cold]
+            fn get_backtrace(&self) -> Option<&std::sync::Mutex<$crate::backtrace::Backtrace>> {
+                None
+            }
+        }
+
+        impl std::fmt::Debug for ErrorData {
+            #[cfg(feature = "backtrace")]
+            #[cold]
+            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+                let mut bt = self.backtrace.unwrap().lock().unwrap();
+                bt.resolve();
+                write!(f, "{:?}\n\n{}", bt, self.kind)
+            }
+
+            #[cfg(not(feature = "backtrace"))]
+            #[cold]
+            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+                write!(f, "{}", self.kind)
+            }
+        }
+
+        #[derive(Debug, thiserror::Error)]
+        pub struct Error(Box<ErrorData>);
+        impl Error {
+            #[cold]
+            pub fn kind(&self) -> &$Kind {
+                &self.0.kind
+            }
+
+            #[cold]
+            pub fn backtrace(&self) -> Option<&std::sync::Mutex<$crate::backtrace::Backtrace>> {
+                self.0.get_backtrace()
+            }
+        }
+
+        impl std::fmt::Display for Error {
+            #[cold]
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                std::fmt::Display::fmt(self.kind(), f)
+            }
+        }
+
+        impl From<$Kind> for Error {
+            // Cold to optimize in favor of non-error cases.
+            #[cold]
+            fn from(ctx: $Kind) -> Error {
+                Error(Box::new(ErrorData::new(ctx)))
+            }
+        }
+    };
+}
+
+/// Define a set of conversions from external error types into the provided
+/// error kind. Use `define_error` to do this at the same time as
+/// `define_error_wrapper`.
+#[macro_export]
+macro_rules! define_error_conversions {
+    ($Kind:ident { $(($variant:ident, $type:ty)),* $(,)? }) => ($(
+        impl From<$type> for Error {
+            // Cold to optimize in favor of non-error cases.
+            #[cold]
+            fn from(e: $type) -> Self {
+                Error::from($Kind::$variant(e))
+            }
+        }
+    )*);
+}
+
+/// All the error boilerplate (okay, with a couple exceptions in some cases) in
+/// one place.
+#[macro_export]
+macro_rules! define_error {
+    ($Kind:ident { $(($variant:ident, $type:ty)),* $(,)? }) => {
+        $crate::define_error_wrapper!($Kind);
+        $crate::define_error_conversions! {
+            $Kind {
+                $(($variant, $type)),*
+            }
+        }
+    };
+}