code_ownership 2.1.4 → 2.2.0

data/ext/cargo-vendor/{error-stack-0.5.0 → error-stack-0.8.0}/src/future.rs

@@ -6,13 +6,13 @@
 //! [`poll`]: Future::poll
 
 use core::{
-    fmt::{Debug, Display},
+    error::Error,
     future::Future,
     pin::Pin,
     task::{Context as TaskContext, Poll},
 };
 
-use crate::{Context, Result, ResultExt};
+use crate::{Attachment, OpaqueAttachment, Report, ResultExt};
 
 macro_rules! implement_future_adaptor {
     ($future:ident, $method:ident, $bound:ident $(+ $bounds:ident)* $(+ $lifetime:lifetime)*, $output:ty) => {
@@ -100,53 +100,54 @@ macro_rules! implement_lazy_future_adaptor {
 implement_future_adaptor!(
     FutureWithAttachment,
     attach,
-    Send + Sync + 'static,
-    Result<<Fut::Output as ResultExt>::Ok, <Fut::Output as ResultExt>::Context>
+    Attachment,
+    Result<<Fut::Output as ResultExt>::Ok, Report<<Fut::Output as ResultExt>::Context>>
 );
 
 implement_lazy_future_adaptor!(
     FutureWithLazyAttachment,
-    attach_lazy,
-    Send + Sync + 'static,
-    Result<<Fut::Output as ResultExt>::Ok, <Fut::Output as ResultExt>::Context>
+    attach_with,
+    Attachment,
+    Result<<Fut::Output as ResultExt>::Ok, Report<<Fut::Output as ResultExt>::Context>>
 );
 
 implement_future_adaptor!(
-    FutureWithPrintableAttachment,
-    attach_printable,
-    Display + Debug + Send + Sync + 'static,
-    Result<<Fut::Output as ResultExt>::Ok, <Fut::Output as ResultExt>::Context>
+    FutureWithOpaqueAttachment,
+    attach_opaque,
+    OpaqueAttachment,
+    Result<<Fut::Output as ResultExt>::Ok, Report<<Fut::Output as ResultExt>::Context>>
 );
 
 implement_lazy_future_adaptor!(
-    FutureWithLazyPrintableAttachment,
-    attach_printable_lazy,
-    Display + Debug + Send + Sync + 'static,
-    Result<<Fut::Output as ResultExt>::Ok, <Fut::Output as ResultExt>::Context>
+    FutureWithLazyOpaqueAttachment,
+    attach_opaque_with,
+    OpaqueAttachment,
+    Result<<Fut::Output as ResultExt>::Ok, Report<<Fut::Output as ResultExt>::Context>>
 );
 
 implement_future_adaptor!(
     FutureWithContext,
     change_context,
-    Context,
-    Result<<Fut::Output as ResultExt>::Ok, T>
+    Error + Send + Sync + 'static,
+    Result<<Fut::Output as ResultExt>::Ok, Report<T>>
 );
 
 implement_lazy_future_adaptor!(
     FutureWithLazyContext,
     change_context_lazy,
-    Context,
-    Result<<Fut::Output as ResultExt>::Ok, T>
+    Error + Send + Sync + 'static,
+    Result<<Fut::Output as ResultExt>::Ok, Report<T>>
 );
 
 /// Extension trait for [`Future`] to provide contextual information on [`Report`]s.
 ///
 /// [`Report`]: crate::Report
 pub trait FutureExt: Future + Sized {
-    /// Adds a new attachment to the [`Report`] inside the [`Result`] when [`poll`]ing the
+    /// Adds a new printable attachment to the [`Report`] inside the [`Result`] when [`poll`]ing the
     /// [`Future`].
     ///
-    /// Applies [`Report::attach`] on the [`Err`] variant, refer to it for more information.
+    /// Applies [`Report::attach`] on the [`Err`] variant, refer to it for more
+    /// information.
     ///
     /// [`Report`]: crate::Report
     /// [`Report::attach`]: crate::Report::attach
@@ -154,55 +155,51 @@ pub trait FutureExt: Future + Sized {
     #[track_caller]
     fn attach<A>(self, attachment: A) -> FutureWithAttachment<Self, A>
     where
-        A: Send + Sync + 'static;
+        A: Attachment;
 
-    /// Lazily adds a new attachment to the [`Report`] inside the [`Result`] when [`poll`]ing the
-    /// [`Future`].
+    /// Lazily adds a new printable attachment to the [`Report`] inside the [`Result`] when
+    /// [`poll`]ing the [`Future`].
     ///
-    /// Applies [`Report::attach`] on the [`Err`] variant, refer to it for more information.
+    /// Applies [`Report::attach`] on the [`Err`] variant, refer to it for more
+    /// information.
     ///
     /// [`Report`]: crate::Report
     /// [`Report::attach`]: crate::Report::attach
     /// [`poll`]: Future::poll
     #[track_caller]
-    fn attach_lazy<A, F>(self, attachment: F) -> FutureWithLazyAttachment<Self, F>
+    fn attach_with<A, F>(self, attachment: F) -> FutureWithLazyAttachment<Self, F>
     where
-        A: Send + Sync + 'static,
+        A: Attachment,
         F: FnOnce() -> A;
 
-    /// Adds a new printable attachment to the [`Report`] inside the [`Result`] when [`poll`]ing the
+    /// Adds a new attachment to the [`Report`] inside the [`Result`] when [`poll`]ing the
     /// [`Future`].
     ///
-    /// Applies [`Report::attach_printable`] on the [`Err`] variant, refer to it for more
-    /// information.
+    /// Applies [`Report::attach_opaque`] on the [`Err`] variant, refer to it for more information.
     ///
     /// [`Report`]: crate::Report
-    /// [`Report::attach_printable`]: crate::Report::attach_printable
+    /// [`Report::attach_opaque`]: crate::Report::attach_opaque
     /// [`poll`]: Future::poll
     #[track_caller]
-    fn attach_printable<A>(self, attachment: A) -> FutureWithPrintableAttachment<Self, A>
+    fn attach_opaque<A>(self, attachment: A) -> FutureWithOpaqueAttachment<Self, A>
     where
-        A: Display + Debug + Send + Sync + 'static;
+        A: OpaqueAttachment;
 
-    /// Lazily adds a new printable attachment to the [`Report`] inside the [`Result`] when
-    /// [`poll`]ing the [`Future`].
+    /// Lazily adds a new attachment to the [`Report`] inside the [`Result`] when [`poll`]ing the
+    /// [`Future`].
     ///
-    /// Applies [`Report::attach_printable`] on the [`Err`] variant, refer to it for more
-    /// information.
+    /// Applies [`Report::attach_opaque`] on the [`Err`] variant, refer to it for more information.
     ///
     /// [`Report`]: crate::Report
-    /// [`Report::attach_printable`]: crate::Report::attach_printable
+    /// [`Report::attach_opaque`]: crate::Report::attach_opaque
     /// [`poll`]: Future::poll
     #[track_caller]
-    fn attach_printable_lazy<A, F>(
-        self,
-        attachment: F,
-    ) -> FutureWithLazyPrintableAttachment<Self, F>
+    fn attach_opaque_with<A, F>(self, attachment: F) -> FutureWithLazyOpaqueAttachment<Self, F>
     where
-        A: Display + Debug + Send + Sync + 'static,
+        A: OpaqueAttachment,
         F: FnOnce() -> A;
 
-    /// Changes the [`Context`] of the [`Report`] inside the [`Result`] when [`poll`]ing the
+    /// Changes the [`Error`] context of the [`Report`] inside the [`Result`] when [`poll`]ing the
     /// [`Future`].
     ///
     /// Applies [`Report::change_context`] on the [`Err`] variant, refer to it for more information.
@@ -213,10 +210,10 @@ pub trait FutureExt: Future + Sized {
     #[track_caller]
     fn change_context<C>(self, context: C) -> FutureWithContext<Self, C>
     where
-        C: Context;
+        C: Error + Send + Sync + 'static;
 
-    /// Lazily changes the [`Context`] of the [`Report`] inside the [`Result`] when [`poll`]ing the
-    /// [`Future`].
+    /// Lazily changes the [`Error`] context of the [`Report`] inside the [`Result`] when
+    /// [`poll`]ing the [`Future`].
     ///
     /// Applies [`Report::change_context`] on the [`Err`] variant, refer to it for more information.
     ///
@@ -226,7 +223,7 @@ pub trait FutureExt: Future + Sized {
     #[track_caller]
     fn change_context_lazy<C, F>(self, context: F) -> FutureWithLazyContext<Self, F>
     where
-        C: Context,
+        C: Error + Send + Sync + 'static,
         F: FnOnce() -> C;
 }
 
@@ -234,9 +231,10 @@ impl<Fut: Future> FutureExt for Fut
 where
     Fut::Output: ResultExt,
 {
+    #[track_caller]
     fn attach<A>(self, attachment: A) -> FutureWithAttachment<Self, A>
     where
-        A: Send + Sync + 'static,
+        A: Attachment,
     {
         FutureWithAttachment {
             future: self,
@@ -245,9 +243,9 @@ where
     }
 
     #[track_caller]
-    fn attach_lazy<A, F>(self, attachment: F) -> FutureWithLazyAttachment<Self, F>
+    fn attach_with<A, F>(self, attachment: F) -> FutureWithLazyAttachment<Self, F>
     where
-        A: Send + Sync + 'static,
+        A: Attachment,
         F: FnOnce() -> A,
     {
         FutureWithLazyAttachment {
@@ -256,27 +254,23 @@ where
         }
     }
 
-    #[track_caller]
-    fn attach_printable<A>(self, attachment: A) -> FutureWithPrintableAttachment<Self, A>
+    fn attach_opaque<A>(self, attachment: A) -> FutureWithOpaqueAttachment<Self, A>
     where
-        A: Display + Debug + Send + Sync + 'static,
+        A: OpaqueAttachment,
     {
-        FutureWithPrintableAttachment {
+        FutureWithOpaqueAttachment {
             future: self,
             inner: Some(attachment),
         }
     }
 
     #[track_caller]
-    fn attach_printable_lazy<A, F>(
-        self,
-        attachment: F,
-    ) -> FutureWithLazyPrintableAttachment<Self, F>
+    fn attach_opaque_with<A, F>(self, attachment: F) -> FutureWithLazyOpaqueAttachment<Self, F>
     where
-        A: Display + Debug + Send + Sync + 'static,
+        A: OpaqueAttachment,
         F: FnOnce() -> A,
     {
-        FutureWithLazyPrintableAttachment {
+        FutureWithLazyOpaqueAttachment {
             future: self,
             inner: Some(attachment),
         }
@@ -285,7 +279,7 @@ where
     #[track_caller]
     fn change_context<C>(self, context: C) -> FutureWithContext<Self, C>
     where
-        C: Context,
+        C: Error + Send + Sync + 'static,
     {
         FutureWithContext {
             future: self,
@@ -296,7 +290,7 @@ where
     #[track_caller]
     fn change_context_lazy<C, F>(self, context: F) -> FutureWithLazyContext<Self, F>
     where
-        C: Context,
+        C: Error + Send + Sync + 'static,
         F: FnOnce() -> C,
     {
         FutureWithLazyContext {

data/ext/cargo-vendor/{error-stack-0.5.0 → error-stack-0.8.0}/src/hook/context.rs

@@ -1,6 +1,4 @@
-#[cfg_attr(feature = "std", allow(unused_imports))]
-use alloc::boxed::Box;
-use alloc::collections::BTreeMap;
+use alloc::{boxed::Box, collections::BTreeMap};
 use core::any::{Any, TypeId};
 
 pub(crate) type Storage = BTreeMap<TypeId, BTreeMap<TypeId, Box<dyn Any>>>;
@@ -19,11 +17,11 @@ impl Counter {
         self.0
     }
 
-    pub(crate) fn increment(&mut self) {
+    pub(crate) const fn increment(&mut self) {
         self.0 += 1;
     }
 
-    pub(crate) fn decrement(&mut self) {
+    pub(crate) const fn decrement(&mut self) {
         self.0 -= 1;
     }
 }
@@ -34,7 +32,7 @@ pub(crate) struct Inner<T> {
 }
 
 impl<T> Inner<T> {
-    pub(crate) fn new(extra: T) -> Self {
+    pub(crate) const fn new(extra: T) -> Self {
         Self {
             storage: Storage::new(),
             extra,
@@ -47,7 +45,7 @@ impl<T> Inner<T> {
         &self.storage
     }
 
-    pub(crate) fn storage_mut(&mut self) -> &mut Storage {
+    pub(crate) const fn storage_mut(&mut self) -> &mut Storage {
         &mut self.storage
     }
 
@@ -55,7 +53,7 @@ impl<T> Inner<T> {
         &self.extra
     }
 
-    pub(crate) fn extra_mut(&mut self) -> &mut T {
+    pub(crate) const fn extra_mut(&mut self) -> &mut T {
         &mut self.extra
     }
 }
@@ -75,7 +73,7 @@ $vis struct HookContext<T> {
 }
 
 impl HookContext<()> {
-    pub(crate) fn new(extra: $extra) -> Self {
+    pub(crate) const fn new(extra: $extra) -> Self {
         Self {
             inner: $crate::hook::context::Inner::new(extra),
             _marker: core::marker::PhantomData,
@@ -88,15 +86,15 @@ impl<T> HookContext<T> {
         &self.inner
     }
 
-    pub(crate) fn inner_mut(&mut self) -> &mut $crate::hook::context::Inner<$extra> {
+    pub(crate) const fn inner_mut(&mut self) -> &mut $crate::hook::context::Inner<$extra> {
         &mut self.inner
     }
 
-    fn storage(&self) -> &$crate::hook::context::Storage {
+    const fn storage(&self) -> &$crate::hook::context::Storage {
         self.inner().storage()
     }
 
-    fn storage_mut(&mut self) -> &mut $crate::hook::context::Storage {
+    const fn storage_mut(&mut self) -> &mut $crate::hook::context::Storage {
         self.inner_mut().storage_mut()
     }
 }
@@ -140,9 +138,9 @@ impl<T> HookContext<T> {
     /// });
     ///
     /// let report = Report::new(std::io::Error::from(ErrorKind::InvalidInput))
-    ///     .attach(Error("unable to reach remote host"))
-    ///     .attach(Warning("disk nearly full"))
-    ///     .attach(Error("cannot resolve example.com: unknown host"));
+    ///     .attach_opaque(Error("unable to reach remote host"))
+    ///     .attach_opaque(Warning("disk nearly full"))
+    ///     .attach_opaque(Error("cannot resolve example.com: unknown host"));
     ///
     /// # Report::set_color_mode(error_stack::fmt::ColorMode::Emphasis);
     /// # fn render(value: String) -> String {
@@ -168,7 +166,7 @@ impl<T> HookContext<T> {
     pub fn cast<U>(&mut self) -> &mut HookContext<U> {
         // SAFETY: `HookContext` is marked as repr(transparent) and the changed generic is only used
         // inside of the `PhantomData`
-        unsafe { &mut *(self as *mut Self).cast::<HookContext<U>>() }
+        unsafe { &mut *core::ptr::from_mut(self).cast::<HookContext<U>>() }
     }
 }
 
@@ -251,8 +249,8 @@ impl<T: 'static> HookContext<T> {
     /// });
     ///
     /// let report = Report::new(std::io::Error::from(ErrorKind::InvalidInput))
-    ///     .attach(Suggestion("use a file you can read next time!"))
-    ///     .attach(Suggestion("don't press any random keys!"));
+    ///     .attach_opaque(Suggestion("use a file you can read next time!"))
+    ///     .attach_opaque(Suggestion("don't press any random keys!"));
     ///
     /// # Report::set_color_mode(error_stack::fmt::ColorMode::Emphasis);
     /// # fn render(value: String) -> String {
@@ -316,8 +314,8 @@ impl<T: 'static> HookContext<T> {
     /// });
     ///
     /// let report = Report::new(std::io::Error::from(ErrorKind::InvalidInput))
-    ///     .attach(Suggestion("use a file you can read next time!"))
-    ///     .attach(Suggestion("don't press any random keys!"));
+    ///     .attach_opaque(Suggestion("use a file you can read next time!"))
+    ///     .attach_opaque(Suggestion("don't press any random keys!"));
     ///
     /// # Report::set_color_mode(error_stack::fmt::ColorMode::Emphasis);
     /// # fn render(value: String) -> String {

data/ext/cargo-vendor/{error-stack-0.5.0 → error-stack-0.8.0}/src/hook/mod.rs

@@ -1,11 +1,10 @@
 pub(crate) mod context;
 
-#[cfg_attr(feature = "std", allow(unused_imports))]
 use alloc::vec::Vec;
 
 use crate::{
-    fmt::{install_builtin_hooks, Hooks},
     Report,
+    fmt::{Hooks, install_builtin_hooks},
 };
 
 #[cfg(feature = "std")]
@@ -34,7 +33,7 @@ impl Report<()> {
     /// use std::io::{Error, ErrorKind};
     ///
     /// use error_stack::{
-    ///     report, Report,
+    ///     Report, IntoReport,
     /// };
     ///
     /// struct Suggestion(&'static str);
@@ -44,7 +43,7 @@ impl Report<()> {
     /// });
     ///
     /// let report =
-    ///     report!(Error::from(ErrorKind::InvalidInput)).attach(Suggestion("oh no, try again"));
+    ///     Error::from(ErrorKind::InvalidInput).into_report().attach_opaque(Suggestion("oh no, try again"));
     ///
     /// # Report::set_color_mode(error_stack::fmt::ColorMode::Emphasis);
     /// # fn render(value: String) -> String {
@@ -66,7 +65,7 @@ impl Report<()> {
     /// Which will result in something like:
     ///
     /// <pre>
-    #[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/hook__debug_hook.snap"))]
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/hook__debug_hook.snap")))]
     /// </pre>
     ///
     /// This example showcases the ability of hooks to be invoked for values provided via the
@@ -83,8 +82,8 @@ impl Report<()> {
     /// # #[cfg(nightly)]
     /// # mod nightly {
     /// use core::error::{Request, Error};
-    /// use core::fmt::{Display, Formatter};
-    /// use error_stack::{Report, report};
+    /// use core::fmt;
+    /// use error_stack::{Report, IntoReport};
     ///
     /// struct Suggestion(&'static str);
     ///
@@ -97,9 +96,9 @@ impl Report<()> {
     ///     code: ErrorCode
     /// }
     ///
-    /// impl Display for UserError {
-    ///     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-    ///         f.write_str("invalid user input")
+    /// impl fmt::Display for UserError {
+    ///     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         fmt.write_str("invalid user input")
     ///     }
     /// }
     ///
@@ -118,7 +117,7 @@ impl Report<()> {
     ///     context.push_body(format!("error code: {value}"));
     /// });
     ///
-    /// let report = report!(UserError {code: ErrorCode(420)});
+    /// let report = UserError {code: ErrorCode(420)}.into_report();
     ///
     /// # Report::set_color_mode(error_stack::fmt::ColorMode::Emphasis);
     /// # fn render(value: String) -> String {
@@ -145,7 +144,7 @@ impl Report<()> {
     /// Which will result in something like:
     ///
     /// <pre>
-    #[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/hook__debug_hook_provide.snap"))]
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/hook__debug_hook_provide.snap")))]
     /// </pre>
     ///
     /// `error-stack` comes with some built-in hooks which can be overwritten. This is useful if you
@@ -161,11 +160,13 @@ impl Report<()> {
     ///     panic::Location,
     /// };
     ///
+    /// use error_stack::IntoReport;
+    ///
     /// error_stack::Report::install_debug_hook::<Location>(|_location, _context| {
     ///     // Intentionally left empty so nothing will be printed
     /// });
     ///
-    /// let report = error_stack::report!(Error::from(ErrorKind::InvalidInput));
+    /// let report = Error::from(ErrorKind::InvalidInput).into_report();
     ///
     /// # error_stack::Report::set_color_mode(error_stack::fmt::ColorMode::Emphasis);
     /// # fn render(value: String) -> String {
@@ -187,7 +188,7 @@ impl Report<()> {
     /// Which will result in something like:
     ///
     /// <pre>
-    #[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/hook__location_hook.snap"))]
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/hook__location_hook.snap")))]
     /// </pre>
     ///
     /// [`Location`]: std::panic::Location
@@ -214,7 +215,7 @@ impl Report<()> {
         lock.insert(hook);
     }
 
-    /// Returns the hook that was previously set by [`install_debug_hook`]
+    /// Returns the hook that was previously set by [`install_debug_hook`].
     ///
     /// [`install_debug_hook`]: Self::install_debug_hook
     #[cfg(any(feature = "std", feature = "hooks"))]

data/ext/cargo-vendor/{error-stack-0.5.0 → error-stack-0.8.0}/src/iter.rs

@@ -1,18 +1,16 @@
 //! Iterators over [`Frame`]s.
 
-#[cfg_attr(feature = "std", allow(unused_imports))]
 use alloc::{vec, vec::Vec};
 #[cfg(nightly)]
 use core::marker::PhantomData;
-use core::{
-    fmt,
-    iter::FusedIterator,
-    slice::{Iter, IterMut},
-};
+use core::{fmt, iter::FusedIterator, slice::Iter};
 
 use crate::Frame;
 
-/// Helper function, which is used in both [`Frames`] and [`FramesMut`].
+/// Helper function, which is used in both [`Frames`] and the mutable frame traversals on
+/// [`Report`].
+///
+/// [`Report`]: crate::Report
 ///
 /// To traverse the frames, the following algorithm is used:
 /// Given a list of iterators, take the last iterator, and use items from it until the iterator has
@@ -32,7 +30,7 @@ use crate::Frame;
 /// 7) Out: G Stack: [H]
 /// 8) Out: H Stack: -
 /// ```
-fn next<I: Iterator<Item = T>, T>(iter: &mut Vec<I>) -> Option<T> {
+pub(crate) fn next<I: Iterator<Item = T>, T>(iter: &mut Vec<I>) -> Option<T> {
     let out;
     loop {
         let last = iter.last_mut()?;
@@ -101,7 +99,7 @@ impl<'r> Iterator for Frames<'r> {
     }
 }
 
-impl<'r> FusedIterator for Frames<'r> {}
+impl FusedIterator for Frames<'_> {}
 
 impl fmt::Debug for Frames<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -109,49 +107,6 @@ impl fmt::Debug for Frames<'_> {
     }
 }
 
-/// Iterator over the mutable [`Frame`] stack of a [`Report`].
-///
-/// Use [`Report::frames_mut()`] to create this iterator.
-///
-/// [`Report`]: crate::Report
-/// [`Report::frames_mut()`]: crate::Report::frames_mut
-#[must_use]
-pub struct FramesMut<'r> {
-    stack: Vec<IterMut<'r, Frame>>,
-}
-
-impl<'r> FramesMut<'r> {
-    pub(crate) fn new(frames: &'r mut [Frame]) -> Self {
-        Self {
-            stack: vec![frames.iter_mut()],
-        }
-    }
-}
-
-impl<'r> Iterator for FramesMut<'r> {
-    type Item = &'r mut Frame;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let frame = next(&mut self.stack)?;
-        let frame: *mut Frame = frame;
-
-        // SAFETY:
-        // We require both mutable access to the frame for all sources (as a mutable iterator) and
-        // we need to return the mutable frame itself. We will never access the same value twice,
-        // and only store their mutable iterator until the next `next()` call. This function acts
-        // like a dynamic chain of multiple `IterMut`. The borrow checker is unable to prove that
-        // subsequent calls to `next()` won't access the same data.
-        // NB: It's almost never possible to implement a mutable iterator without `unsafe`.
-        unsafe {
-            self.stack.push((*frame).sources_mut().iter_mut());
-
-            Some(&mut *frame)
-        }
-    }
-}
-
-impl<'r> FusedIterator for FramesMut<'r> {}
-
 /// Iterator over requested references in the [`Frame`] stack of a [`Report`].
 ///
 /// Use [`Report::request_ref()`] to create this iterator.
@@ -188,7 +143,7 @@ where
 }
 
 #[cfg(nightly)]
-impl<'r, T> FusedIterator for RequestRef<'r, T> where T: ?Sized + 'static {}
+impl<T> FusedIterator for RequestRef<'_, T> where T: ?Sized + 'static {}
 
 #[cfg(nightly)]
 impl<T: ?Sized> Clone for RequestRef<'_, T> {
@@ -201,7 +156,7 @@ impl<T: ?Sized> Clone for RequestRef<'_, T> {
 }
 
 #[cfg(nightly)]
-impl<'r, T> fmt::Debug for RequestRef<'r, T>
+impl<T> fmt::Debug for RequestRef<'_, T>
 where
     T: ?Sized + fmt::Debug + 'static,
 {
@@ -234,7 +189,7 @@ impl<'r, T> RequestValue<'r, T> {
 }
 
 #[cfg(nightly)]
-impl<'r, T> Iterator for RequestValue<'r, T>
+impl<T> Iterator for RequestValue<'_, T>
 where
     T: 'static,
 {
@@ -246,7 +201,7 @@ where
 }
 
 #[cfg(nightly)]
-impl<'r, T> FusedIterator for RequestValue<'r, T> where T: 'static {}
+impl<T> FusedIterator for RequestValue<'_, T> where T: 'static {}
 
 #[cfg(nightly)]
 impl<T> Clone for RequestValue<'_, T> {
@@ -259,7 +214,7 @@ impl<T> Clone for RequestValue<'_, T> {
 }
 
 #[cfg(nightly)]
-impl<'r, T> fmt::Debug for RequestValue<'r, T>
+impl<T> fmt::Debug for RequestValue<'_, T>
 where
     T: fmt::Debug + 'static,
 {