html-to-markdown 2.25.1 → 2.26.2

data/rust-vendor/anyhow/src/backtrace.rs

@@ -1,34 +1,17 @@
-#[cfg(std_backtrace)]
-pub(crate) use std::backtrace::{Backtrace, BacktraceStatus};
+#[cfg(feature = "std")]
+pub(crate) use std::backtrace::Backtrace;
 
-#[cfg(all(not(std_backtrace), feature = "backtrace"))]
-pub(crate) use self::capture::{Backtrace, BacktraceStatus};
-
-#[cfg(not(any(std_backtrace, feature = "backtrace")))]
+#[cfg(not(feature = "std"))]
 pub(crate) enum Backtrace {}
 
-#[cfg(std_backtrace)]
-macro_rules! impl_backtrace {
-    () => {
-        std::backtrace::Backtrace
-    };
-}
-
-#[cfg(all(not(std_backtrace), feature = "backtrace"))]
-macro_rules! impl_backtrace {
-    () => {
-        impl core::fmt::Debug + core::fmt::Display
-    };
-}
-
-#[cfg(any(std_backtrace, feature = "backtrace"))]
+#[cfg(feature = "std")]
 macro_rules! backtrace {
     () => {
-        Some(crate::backtrace::Backtrace::capture())
+        Some(std::backtrace::Backtrace::capture())
     };
 }
 
-#[cfg(not(any(std_backtrace, feature = "backtrace")))]
+#[cfg(not(feature = "std"))]
 macro_rules! backtrace {
     () => {
         None
@@ -45,365 +28,20 @@ macro_rules! backtrace_if_absent {
     };
 }
 
-#[cfg(all(
-    any(feature = "std", not(anyhow_no_core_error)),
-    not(error_generic_member_access),
-    any(std_backtrace, feature = "backtrace")
-))]
+#[cfg(all(not(error_generic_member_access), feature = "std"))]
 macro_rules! backtrace_if_absent {
     ($err:expr) => {
         backtrace!()
     };
 }
 
-#[cfg(all(
-    any(feature = "std", not(anyhow_no_core_error)),
-    not(std_backtrace),
-    not(feature = "backtrace"),
-))]
+#[cfg(all(not(anyhow_no_core_error), not(feature = "std")))]
 macro_rules! backtrace_if_absent {
     ($err:expr) => {
         None
     };
 }
 
-#[cfg(all(not(std_backtrace), feature = "backtrace"))]
-mod capture {
-    use alloc::borrow::{Cow, ToOwned as _};
-    use alloc::vec::Vec;
-    use backtrace::{BacktraceFmt, BytesOrWideString, Frame, PrintFmt, SymbolName};
-    use core::cell::UnsafeCell;
-    use core::fmt::{self, Debug, Display};
-    use core::sync::atomic::{AtomicUsize, Ordering};
-    use std::env;
-    use std::path::{self, Path, PathBuf};
-    use std::sync::Once;
-
-    pub(crate) struct Backtrace {
-        inner: Inner,
-    }
-
-    pub(crate) enum BacktraceStatus {
-        Unsupported,
-        Disabled,
-        Captured,
-    }
-
-    enum Inner {
-        Unsupported,
-        Disabled,
-        Captured(LazilyResolvedCapture),
-    }
-
-    struct Capture {
-        actual_start: usize,
-        resolved: bool,
-        frames: Vec<BacktraceFrame>,
-    }
-
-    struct BacktraceFrame {
-        frame: Frame,
-        symbols: Vec<BacktraceSymbol>,
-    }
-
-    struct BacktraceSymbol {
-        name: Option<Vec<u8>>,
-        filename: Option<BytesOrWide>,
-        lineno: Option<u32>,
-        colno: Option<u32>,
-    }
-
-    enum BytesOrWide {
-        Bytes(Vec<u8>),
-        Wide(Vec<u16>),
-    }
-
-    impl Debug for Backtrace {
-        fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-            let capture = match &self.inner {
-                Inner::Unsupported => return fmt.write_str("<unsupported>"),
-                Inner::Disabled => return fmt.write_str("<disabled>"),
-                Inner::Captured(c) => c.force(),
-            };
-
-            let frames = &capture.frames[capture.actual_start..];
-
-            write!(fmt, "Backtrace ")?;
-
-            let mut dbg = fmt.debug_list();
-
-            for frame in frames {
-                if frame.frame.ip().is_null() {
-                    continue;
-                }
-
-                dbg.entries(&frame.symbols);
-            }
-
-            dbg.finish()
-        }
-    }
-
-    impl Debug for BacktraceFrame {
-        fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-            let mut dbg = fmt.debug_list();
-            dbg.entries(&self.symbols);
-            dbg.finish()
-        }
-    }
-
-    impl Debug for BacktraceSymbol {
-        fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-            write!(fmt, "{{ ")?;
-
-            if let Some(fn_name) = self.name.as_ref().map(|b| SymbolName::new(b)) {
-                write!(fmt, "fn: \"{:#}\"", fn_name)?;
-            } else {
-                write!(fmt, "fn: <unknown>")?;
-            }
-
-            if let Some(fname) = self.filename.as_ref() {
-                write!(fmt, ", file: \"{:?}\"", fname)?;
-            }
-
-            if let Some(line) = self.lineno {
-                write!(fmt, ", line: {:?}", line)?;
-            }
-
-            write!(fmt, " }}")
-        }
-    }
-
-    impl Debug for BytesOrWide {
-        fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-            output_filename(
-                fmt,
-                match self {
-                    BytesOrWide::Bytes(w) => BytesOrWideString::Bytes(w),
-                    BytesOrWide::Wide(w) => BytesOrWideString::Wide(w),
-                },
-                PrintFmt::Short,
-                env::current_dir().as_ref().ok(),
-            )
-        }
-    }
-
-    impl Backtrace {
-        fn enabled() -> bool {
-            static ENABLED: AtomicUsize = AtomicUsize::new(0);
-            match ENABLED.load(Ordering::Relaxed) {
-                0 => {}
-                1 => return false,
-                _ => return true,
-            }
-            let enabled = match env::var_os("RUST_LIB_BACKTRACE") {
-                Some(s) => s != "0",
-                None => match env::var_os("RUST_BACKTRACE") {
-                    Some(s) => s != "0",
-                    None => false,
-                },
-            };
-            ENABLED.store(enabled as usize + 1, Ordering::Relaxed);
-            enabled
-        }
-
-        #[inline(never)] // want to make sure there's a frame here to remove
-        pub(crate) fn capture() -> Backtrace {
-            if Backtrace::enabled() {
-                Backtrace::create(Backtrace::capture as usize)
-            } else {
-                let inner = Inner::Disabled;
-                Backtrace { inner }
-            }
-        }
-
-        // Capture a backtrace which starts just before the function addressed
-        // by `ip`
-        fn create(ip: usize) -> Backtrace {
-            let mut frames = Vec::new();
-            let mut actual_start = None;
-            backtrace::trace(|frame| {
-                frames.push(BacktraceFrame {
-                    frame: frame.clone(),
-                    symbols: Vec::new(),
-                });
-                if frame.symbol_address() as usize == ip && actual_start.is_none() {
-                    actual_start = Some(frames.len() + 1);
-                }
-                true
-            });
-
-            // If no frames came out, assume that this is an unsupported platform
-            // since `backtrace` doesn't provide a way of learning this right
-            // now, and this should be a good enough approximation.
-            let inner = if frames.is_empty() {
-                Inner::Unsupported
-            } else {
-                Inner::Captured(LazilyResolvedCapture::new(Capture {
-                    actual_start: actual_start.unwrap_or(0),
-                    frames,
-                    resolved: false,
-                }))
-            };
-
-            Backtrace { inner }
-        }
-
-        pub(crate) fn status(&self) -> BacktraceStatus {
-            match self.inner {
-                Inner::Unsupported => BacktraceStatus::Unsupported,
-                Inner::Disabled => BacktraceStatus::Disabled,
-                Inner::Captured(_) => BacktraceStatus::Captured,
-            }
-        }
-    }
-
-    impl Display for Backtrace {
-        fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-            let capture = match &self.inner {
-                Inner::Unsupported => return fmt.write_str("unsupported backtrace"),
-                Inner::Disabled => return fmt.write_str("disabled backtrace"),
-                Inner::Captured(c) => c.force(),
-            };
-
-            let full = fmt.alternate();
-            let (frames, style) = if full {
-                (&capture.frames[..], PrintFmt::Full)
-            } else {
-                (&capture.frames[capture.actual_start..], PrintFmt::Short)
-            };
-
-            // When printing paths we try to strip the cwd if it exists,
-            // otherwise we just print the path as-is. Note that we also only do
-            // this for the short format, because if it's full we presumably
-            // want to print everything.
-            let cwd = env::current_dir();
-            let mut print_path = move |fmt: &mut fmt::Formatter, path: BytesOrWideString| {
-                output_filename(fmt, path, style, cwd.as_ref().ok())
-            };
-
-            let mut f = BacktraceFmt::new(fmt, style, &mut print_path);
-            f.add_context()?;
-            for frame in frames {
-                let mut f = f.frame();
-                if frame.symbols.is_empty() {
-                    f.print_raw(frame.frame.ip(), None, None, None)?;
-                } else {
-                    for symbol in frame.symbols.iter() {
-                        f.print_raw_with_column(
-                            frame.frame.ip(),
-                            symbol.name.as_ref().map(|b| SymbolName::new(b)),
-                            symbol.filename.as_ref().map(|b| match b {
-                                BytesOrWide::Bytes(w) => BytesOrWideString::Bytes(w),
-                                BytesOrWide::Wide(w) => BytesOrWideString::Wide(w),
-                            }),
-                            symbol.lineno,
-                            symbol.colno,
-                        )?;
-                    }
-                }
-            }
-            f.finish()?;
-            Ok(())
-        }
-    }
-
-    struct LazilyResolvedCapture {
-        sync: Once,
-        capture: UnsafeCell<Capture>,
-    }
-
-    impl LazilyResolvedCapture {
-        fn new(capture: Capture) -> Self {
-            LazilyResolvedCapture {
-                sync: Once::new(),
-                capture: UnsafeCell::new(capture),
-            }
-        }
-
-        fn force(&self) -> &Capture {
-            self.sync.call_once(|| {
-                // Safety: This exclusive reference can't overlap with any
-                // others. `Once` guarantees callers will block until this
-                // closure returns. `Once` also guarantees only a single caller
-                // will enter this closure.
-                unsafe { &mut *self.capture.get() }.resolve();
-            });
-
-            // Safety: This shared reference can't overlap with the exclusive
-            // reference above.
-            unsafe { &*self.capture.get() }
-        }
-    }
-
-    // Safety: Access to the inner value is synchronized using a thread-safe
-    // `Once`. So long as `Capture` is `Sync`, `LazilyResolvedCapture` is too
-    unsafe impl Sync for LazilyResolvedCapture where Capture: Sync {}
-
-    impl Capture {
-        fn resolve(&mut self) {
-            // If we're already resolved, nothing to do!
-            if self.resolved {
-                return;
-            }
-            self.resolved = true;
-
-            for frame in self.frames.iter_mut() {
-                let symbols = &mut frame.symbols;
-                let frame = &frame.frame;
-                backtrace::resolve_frame(frame, |symbol| {
-                    symbols.push(BacktraceSymbol {
-                        name: symbol.name().map(|m| m.as_bytes().to_vec()),
-                        filename: symbol.filename_raw().map(|b| match b {
-                            BytesOrWideString::Bytes(b) => BytesOrWide::Bytes(b.to_owned()),
-                            BytesOrWideString::Wide(b) => BytesOrWide::Wide(b.to_owned()),
-                        }),
-                        lineno: symbol.lineno(),
-                        colno: symbol.colno(),
-                    });
-                });
-            }
-        }
-    }
-
-    // Prints the filename of the backtrace frame.
-    fn output_filename(
-        fmt: &mut fmt::Formatter,
-        bows: BytesOrWideString,
-        print_fmt: PrintFmt,
-        cwd: Option<&PathBuf>,
-    ) -> fmt::Result {
-        let file: Cow<Path> = match bows {
-            #[cfg(unix)]
-            BytesOrWideString::Bytes(bytes) => {
-                use std::os::unix::ffi::OsStrExt;
-                Path::new(std::ffi::OsStr::from_bytes(bytes)).into()
-            }
-            #[cfg(not(unix))]
-            BytesOrWideString::Bytes(bytes) => {
-                Path::new(std::str::from_utf8(bytes).unwrap_or("<unknown>")).into()
-            }
-            #[cfg(windows)]
-            BytesOrWideString::Wide(wide) => {
-                use std::os::windows::ffi::OsStringExt;
-                Cow::Owned(std::ffi::OsString::from_wide(wide).into())
-            }
-            #[cfg(not(windows))]
-            BytesOrWideString::Wide(_wide) => Path::new("<unknown>").into(),
-        };
-        if print_fmt == PrintFmt::Short && file.is_absolute() {
-            if let Some(cwd) = cwd {
-                if let Ok(stripped) = file.strip_prefix(&cwd) {
-                    if let Some(s) = stripped.to_str() {
-                        return write!(fmt, ".{}{}", path::MAIN_SEPARATOR, s);
-                    }
-                }
-            }
-        }
-        Display::fmt(&file.display(), fmt)
-    }
-}
-
 fn _assert_send_sync() {
     fn assert<T: Send + Sync>() {}
     assert::<Backtrace>();

data/rust-vendor/anyhow/src/error.rs

@@ -155,10 +155,7 @@ impl Error {
             object_reallocate_boxed: object_reallocate_boxed::<E>,
             object_downcast: object_downcast::<E>,
             object_drop_rest: object_drop_front::<E>,
-            #[cfg(all(
-                not(error_generic_member_access),
-                any(std_backtrace, feature = "backtrace")
-            ))]
+            #[cfg(all(not(error_generic_member_access), feature = "std"))]
             object_backtrace: no_backtrace,
         };
 
@@ -182,10 +179,7 @@ impl Error {
             object_reallocate_boxed: object_reallocate_boxed::<MessageError<M>>,
             object_downcast: object_downcast::<M>,
             object_drop_rest: object_drop_front::<M>,
-            #[cfg(all(
-                not(error_generic_member_access),
-                any(std_backtrace, feature = "backtrace")
-            ))]
+            #[cfg(all(not(error_generic_member_access), feature = "std"))]
             object_backtrace: no_backtrace,
         };
 
@@ -210,10 +204,7 @@ impl Error {
             object_reallocate_boxed: object_reallocate_boxed::<DisplayError<M>>,
             object_downcast: object_downcast::<M>,
             object_drop_rest: object_drop_front::<M>,
-            #[cfg(all(
-                not(error_generic_member_access),
-                any(std_backtrace, feature = "backtrace")
-            ))]
+            #[cfg(all(not(error_generic_member_access), feature = "std"))]
             object_backtrace: no_backtrace,
         };
 
@@ -244,10 +235,7 @@ impl Error {
             object_reallocate_boxed: object_reallocate_boxed::<ContextError<C, E>>,
             object_downcast: context_downcast::<C, E>,
             object_drop_rest: context_drop_rest::<C, E>,
-            #[cfg(all(
-                not(error_generic_member_access),
-                any(std_backtrace, feature = "backtrace")
-            ))]
+            #[cfg(all(not(error_generic_member_access), feature = "std"))]
             object_backtrace: no_backtrace,
         };
 
@@ -272,10 +260,7 @@ impl Error {
             object_reallocate_boxed: object_reallocate_boxed::<BoxedError>,
             object_downcast: object_downcast::<Box<dyn StdError + Send + Sync>>,
             object_drop_rest: object_drop_front::<Box<dyn StdError + Send + Sync>>,
-            #[cfg(all(
-                not(error_generic_member_access),
-                any(std_backtrace, feature = "backtrace")
-            ))]
+            #[cfg(all(not(error_generic_member_access), feature = "std"))]
             object_backtrace: no_backtrace,
         };
 
@@ -387,10 +372,7 @@ impl Error {
             object_reallocate_boxed: object_reallocate_boxed::<ContextError<C, Error>>,
             object_downcast: context_chain_downcast::<C>,
             object_drop_rest: context_chain_drop_rest::<C>,
-            #[cfg(all(
-                not(error_generic_member_access),
-                any(std_backtrace, feature = "backtrace")
-            ))]
+            #[cfg(all(not(error_generic_member_access), feature = "std"))]
             object_backtrace: context_backtrace::<C>,
         };
 
@@ -428,8 +410,8 @@ impl Error {
     /// [dependencies]
     /// anyhow = { version = "1.0", features = ["backtrace"] }
     /// ```
-    #[cfg(any(std_backtrace, feature = "backtrace"))]
-    pub fn backtrace(&self) -> &impl_backtrace!() {
+    #[cfg(feature = "std")]
+    pub fn backtrace(&self) -> &Backtrace {
         unsafe { ErrorImpl::backtrace(self.inner.by_ref()) }
     }
 
@@ -746,10 +728,7 @@ struct ErrorVTable {
     object_reallocate_boxed: unsafe fn(Own<ErrorImpl>) -> Box<dyn StdError + Send + Sync + 'static>,
     object_downcast: unsafe fn(Ref<ErrorImpl>, TypeId) -> Option<Ref<()>>,
     object_drop_rest: unsafe fn(Own<ErrorImpl>, TypeId),
-    #[cfg(all(
-        not(error_generic_member_access),
-        any(std_backtrace, feature = "backtrace")
-    ))]
+    #[cfg(all(not(error_generic_member_access), feature = "std"))]
     object_backtrace: unsafe fn(Ref<ErrorImpl>) -> Option<&Backtrace>,
 }
 
@@ -825,10 +804,7 @@ where
     }
 }
 
-#[cfg(all(
-    not(error_generic_member_access),
-    any(std_backtrace, feature = "backtrace")
-))]
+#[cfg(all(not(error_generic_member_access), feature = "std"))]
 fn no_backtrace(e: Ref<ErrorImpl>) -> Option<&Backtrace> {
     let _ = e;
     None
@@ -912,10 +888,7 @@ where
 }
 
 // Safety: requires layout of *e to match ErrorImpl<ContextError<C, Error>>.
-#[cfg(all(
-    not(error_generic_member_access),
-    any(std_backtrace, feature = "backtrace")
-))]
+#[cfg(all(not(error_generic_member_access), feature = "std"))]
 #[allow(clippy::unnecessary_wraps)]
 unsafe fn context_backtrace<C>(e: Ref<ErrorImpl>) -> Option<&Backtrace>
 where
@@ -981,7 +954,7 @@ impl ErrorImpl {
         }
     }
 
-    #[cfg(any(std_backtrace, feature = "backtrace"))]
+    #[cfg(feature = "std")]
     pub(crate) unsafe fn backtrace(this: Ref<Self>) -> &Backtrace {
         // This unwrap can only panic if the underlying error's backtrace method
         // is nondeterministic, which would only happen in maliciously

data/rust-vendor/anyhow/src/fmt.rs

@@ -40,10 +40,10 @@ impl ErrorImpl {
             }
         }
 
-        #[cfg(any(std_backtrace, feature = "backtrace"))]
+        #[cfg(feature = "std")]
         {
-            use crate::backtrace::BacktraceStatus;
             use alloc::string::ToString;
+            use std::backtrace::BacktraceStatus;
 
             let backtrace = unsafe { Self::backtrace(this) };
             if let BacktraceStatus::Captured = backtrace.status() {

data/rust-vendor/anyhow/src/lib.rs

@@ -206,7 +206,7 @@
 //! function that returns Anyhow's error type, as the trait that `?`-based error
 //! conversions are defined by is only available in std in those old versions.
 
-#![doc(html_root_url = "https://docs.rs/anyhow/1.0.101")]
+#![doc(html_root_url = "https://docs.rs/anyhow/1.0.102")]
 #![cfg_attr(error_generic_member_access, feature(error_generic_member_access))]
 #![no_std]
 #![deny(dead_code, unsafe_op_in_unsafe_fn, unused_imports, unused_mut)]

data/rust-vendor/async-trait/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{".cargo_vcs_info.json":"73d57bc9f6a7d63bbc63993269785444b608991fd6a08fdb5e20c4b780f3e65d",".github/FUNDING.yml":"b017158736b3c9751a2d21edfce7fe61c8954e2fced8da8dd3013c2f3e295bd9",".github/workflows/ci.yml":"a49d60764a01678b40cd55745947222949895247683a27e093353b1a253c918f","Cargo.lock":"66adf37f3b62f46f3779a6ae44caed7b4d3e5c013f833c6b4c4ccc037c4b6b2e","Cargo.toml":"3109343dbc19339c104e8bd8f983003b45a2c2bde157a69f99d807e8b860f720","Cargo.toml.orig":"8ba64c46891e406fe599b51a28eb8ee487063132941d9a2bb73227b7b6e856d7","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"14f782ff6a20c3eae705b59f8c04f0e9a5d2e096ab47d20b28b315d7cbbbcd3b","src/args.rs":"6eed5497db91752b3aae597943c39e769f60406b37055304e69e4699f1f87b15","src/bound.rs":"90e3075543faca8a88eedca185f0999cc7b5a57a015142fa0464df8023733c27","src/expand.rs":"6d0bd9cef4923fe8291378080ff5cee2966093c9a470d303cc2f9e137126ba2a","src/lib.rs":"ccd68ebca4cece451d1b55a13de1aeed4a3695c0abcfe03ab79a659ef2c64689","src/lifetime.rs":"cfa429d66627720557a00a0bc5cfaffd6d50e350d5db3eab955c5c4f6300f82d","src/parse.rs":"cd9032fe2c6dcf41050b3a59b9fb98eb9700a29bbe2fa011ee2854014c1666b7","src/receiver.rs":"9d4c3decf31d3b8e33c5473e05e977cf0424920b47a9b636854c0e053a21306d","src/verbatim.rs":"45d0b691fab21f20d3414733f00d82845442d23b6f2547f8d6880a709d0d3b2a","tests/compiletest.rs":"4e381aa8ca3eabb7ac14d1e0c3700b3223e47640547a6988cfa13ad68255f60f","tests/executor/mod.rs":"3cf48614288715f625514a73ae642f649c2635a402a3ad90278bbee116a7234c","tests/test.rs":"8a55e7685e813bdeb2cb9d254dd8b8e97370afa20d8fb1af45acf866978a5f6a","tests/ui/arg-implementation-detail.rs":"7199aba887dd0a8a14c86ec16542a73a70244930f8202940f43e40a62f72d200","tests/ui/arg-implementation-detail.stderr":"c3ff1a2a9a9ca4368cb8719e2a035a6d2d45b367212bec2b1fe2712fcfbbbe5d","tests/ui/bare-trait-object.rs":"4546e8bd6682de11920fa4c768295fed61954484ef0550dfadbc5677b77f29a5","tests/ui/bare-trait-object.stderr":"c2917683f37e46bed7575742d0fc099af40a1c2c92110e467675ec62dad4819b","tests/ui/consider-restricting.rs":"7851551849d8aa5aa97316e309f25cbb3992969f80c76b44aa8acdbfb867fe6b","tests/ui/consider-restricting.stderr":"16248d6fc7b9d2a8c5344cb60c7add5db508bd7c4f1e9bb93a96e579513b9abb","tests/ui/delimiter-span.rs":"f4fd804223ce3be0d4eecdfd222afdd835c5393e2473ff4932116163943c0bc9","tests/ui/delimiter-span.stderr":"9da83381b7977ca3049377344a0fa32d005d67e1611fd350d254428741db05df","tests/ui/lifetime-defined-here.rs":"3139a3d92cf787c43afd93da2d967ee80d114ee3a0b9c924da9601b5c6614ef5","tests/ui/lifetime-defined-here.stderr":"0d4236821e0f43e5ae38a99319a64020576e78a49a71d8c94eb8a486d384308c","tests/ui/lifetime-span.rs":"bbcaa92c2bc08e18cf0c7e9ca1f0bd8080772ebde8b067d819eb2fd662e47b3b","tests/ui/lifetime-span.stderr":"6896c95b0196ddd6a6aa6aa35f676684300eee7c252c1d8e4748710200e374c1","tests/ui/missing-async-in-impl.rs":"5a5538d08d11c145211a92af0d8973eee8b21f33b90adda85430805bd3dbbc83","tests/ui/missing-async-in-impl.stderr":"75ff8947e6d6838bd70f5c6d98d49a9f05d7b7fdb4c5dc8d7061a0a8dc40d2ee","tests/ui/missing-async-in-trait.rs":"dc67241593f270233ba885df92e59164126416e68d49d8d62edc251666b5db6e","tests/ui/missing-async-in-trait.stderr":"896fa6ed48b690d98121eb70489d31a1b4ba87aea7291e1e9a34425ec24e44e4","tests/ui/missing-body.rs":"d06c0da8c6044e7c790b924136f167e2edc0d0d3fa01f23521f3f08ca605929b","tests/ui/missing-body.stderr":"e5ee994398bf8294324d61df02467a4229f68f4113bf5acc004851c03d66ec6a","tests/ui/must-use.rs":"75090c7df984df0996464337f60371d198bd0caf3f9f44b10d1e131f15fd4fca","tests/ui/must-use.stderr":"9f4b2d5f2df97257123ebe1f326f84f8eab3811254a104e23db1fd8b6029164a","tests/ui/no-attribute-macro.rs":"99aaad298a8ef366029e53b6d320b14f18e04057a117ff58a0aebad65f01e22f","tests/ui/no-attribute-macro.stderr":"89aef81cc3529a1b4cd44bea78340197fb27798ecd22e16665197cea7f6467c6","tests/ui/self-span.rs":"67ddde05907d7014bfb3f2c63d427b1d72d6c4369a9108a4335dac6bee5832b2","tests/ui/self-span.stderr":"3d932050d36b4fa4b2ce9a9b9f96417f8cbd8924f845a035192fd01b05f6fe21","tests/ui/send-not-implemented.rs":"affbbe8bc9c3501d3db3a024e06daa9d076f1d142dba290c7aa1ea119daebd19","tests/ui/send-not-implemented.stderr":"f16d2faf6a87f2a20c7f9c5c357b47daa3d0f30449930b7f31ca23a750435441","tests/ui/type-mismatch.rs":"b4561a7dc2608e559fc7c6e8e5f7575914731a81f1ac3762ffbb5ec2a40dea90","tests/ui/type-mismatch.stderr":"f7a6a0404cd50c043e4d8725094e29873d60ea3a524c18ebb3fdc599a70a2232","tests/ui/unreachable.rs":"be0aa7cc129fe42a1fbd85e36b3f08c6a2bd16c90ed2e33fc4c50e40ce085bcd","tests/ui/unreachable.stderr":"c1c832bb728b58f3a17a153bb356339699a15a99415ffbeff2ac297252a2714a","tests/ui/unsupported-self.rs":"f7855bc39dab1fd2f533fb2e873a27c3757dcb9fb57001e4b19f58d3dda36d01","tests/ui/unsupported-self.stderr":"64fc5d45cb51330f0a1e85e69a28b69ddda12a109aa6a8ba3eaee1ac58d93b5f"},"package":"9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"}

data/rust-vendor/async-trait/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "a7e91e98a5d2de2ceae52d9459eed309939a98bf"
+  },
+  "path_in_vcs": ""
+}

data/rust-vendor/async-trait/.github/FUNDING.yml

@@ -0,0 +1 @@
+github: dtolnay

data/rust-vendor/async-trait/.github/workflows/ci.yml

@@ -0,0 +1,109 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+  schedule: [cron: "40 1 * * *"]
+
+permissions:
+  contents: read
+
+env:
+  RUSTFLAGS: -Dwarnings
+
+jobs:
+  pre_ci:
+    uses: dtolnay/.github/.github/workflows/pre_ci.yml@master
+
+  test:
+    name: Rust ${{matrix.rust}}
+    needs: pre_ci
+    if: needs.pre_ci.outputs.continue
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust: [nightly, beta, stable, 1.75.0, 1.70.0, 1.56.0]
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{matrix.rust}}
+      - name: Enable type layout randomization
+        run: echo RUSTFLAGS=${RUSTFLAGS}\ -Zrandomize-layout >> $GITHUB_ENV
+        if: matrix.rust == 'nightly'
+      - name: Enable nightly-only tests
+        run: echo RUSTFLAGS=${RUSTFLAGS}\ --cfg=async_trait_nightly_testing >> $GITHUB_ENV
+        if: matrix.rust == 'nightly'
+      - run: cargo check
+      - run: cargo test
+        if: matrix.rust != '1.56.0'
+      - uses: actions/upload-artifact@v4
+        if: matrix.rust == 'nightly' && always()
+        with:
+          name: Cargo.lock
+          path: Cargo.lock
+        continue-on-error: true
+
+  minimal:
+    name: Minimal versions
+    needs: pre_ci
+    if: needs.pre_ci.outputs.continue
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
+      - run: cargo generate-lockfile -Z minimal-versions
+      - run: cargo check --locked
+
+  doc:
+    name: Documentation
+    needs: pre_ci
+    if: needs.pre_ci.outputs.continue
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    env:
+      RUSTDOCFLAGS: -Dwarnings
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
+      - uses: dtolnay/install@cargo-docs-rs
+      - run: cargo docs-rs
+
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request'
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@clippy
+      - run: cargo clippy --tests -- -Dclippy::all -Dclippy::pedantic
+
+  miri:
+    name: Miri
+    needs: pre_ci
+    if: needs.pre_ci.outputs.continue
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@miri
+      - run: cargo miri setup
+      - run: cargo miri test
+        env:
+          MIRIFLAGS: -Zmiri-strict-provenance
+
+  outdated:
+    name: Outdated
+    runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request'
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: dtolnay/install@cargo-outdated
+      - run: cargo outdated --workspace --exit-code 1