code_ownership 2.1.4 → 2.2.0

data/ext/cargo-vendor/error-stack-0.8.0/src/ext/stream.rs

@@ -0,0 +1,212 @@
+use core::{
+    future::Future,
+    mem,
+    pin::Pin,
+    task::{Context, Poll, ready},
+};
+
+use futures_core::{FusedFuture, FusedStream, TryStream};
+use pin_project_lite::pin_project;
+
+use crate::Report;
+
+pin_project! {
+    /// Future for the [`try_collect_reports`](TryReportStreamExt::try_collect_reports)
+    /// and [`try_collect_reports_bounded`](TryReportStreamExt::try_collect_reports_bounded) methods.
+    #[derive(Debug)]
+    #[must_use = "futures do nothing unless you `.await` or poll them"]
+    pub struct TryCollectReports<S, A, C> {
+        #[pin]
+        stream: S,
+        output: Result<A, Report<[C]>>,
+
+        context_len: usize,
+        context_bound: usize
+    }
+}
+
+impl<S, A, C> TryCollectReports<S, A, C>
+where
+    S: TryStream,
+    A: Default + Extend<S::Ok>,
+{
+    fn new(stream: S, bound: Option<usize>) -> Self {
+        Self {
+            stream,
+            output: Ok(Default::default()),
+            context_len: 0,
+            context_bound: bound.unwrap_or(usize::MAX),
+        }
+    }
+}
+
+impl<S, A, C> FusedFuture for TryCollectReports<S, A, C>
+where
+    S: TryStream<Error: Into<Report<[C]>>> + FusedStream,
+    A: Default + Extend<S::Ok>,
+{
+    fn is_terminated(&self) -> bool {
+        self.stream.is_terminated()
+    }
+}
+
+impl<S, A, C> Future for TryCollectReports<S, A, C>
+where
+    S: TryStream<Error: Into<Report<[C]>>>,
+    A: Default + Extend<S::Ok>,
+{
+    type Output = Result<A, Report<[C]>>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.project();
+
+        let value = loop {
+            if *this.context_len >= *this.context_bound {
+                break mem::replace(this.output, Ok(A::default()));
+            }
+
+            let next = ready!(this.stream.as_mut().try_poll_next(cx));
+            match (next, &mut *this.output) {
+                (Some(Ok(value)), Ok(output)) => {
+                    output.extend(core::iter::once(value));
+                }
+                (Some(Ok(_)), Err(_)) => {
+                    // we're now just consuming the iterator to return all related errors
+                    // so we can just ignore the output
+                }
+                (Some(Err(error)), output @ Ok(_)) => {
+                    *output = Err(error.into());
+                    *this.context_len += 1;
+                }
+                (Some(Err(error)), Err(report)) => {
+                    report.append(error.into());
+                    *this.context_len += 1;
+                }
+                (None, output) => {
+                    break mem::replace(output, Ok(A::default()));
+                }
+            }
+        };
+
+        Poll::Ready(value)
+    }
+}
+
+/// Trait extending [`TryStream`] with methods for collecting error-stack results in a fail-slow
+/// manner.
+///
+/// This trait provides additional functionality to [`TryStream`]s, allowing for the collection of
+/// successful items while accumulating errors. It's particularly useful when you want to continue
+/// processing a stream even after encountering errors, gathering all successful results and errors
+/// until the stream is exhausted or a specified error limit is reached.
+///
+/// The fail-slow approach means that the stream processing continues after encountering errors,
+/// unlike traditional error handling that might stop at the first error.
+///
+/// # Performance Considerations
+///
+/// These methods may have performance implications as they potentially iterate
+/// through the entire stream, even after encountering errors.
+///
+/// # Note
+///
+/// This trait is only available behind the `unstable` flag and is not covered by semver guarantees.
+/// It may be subject to breaking changes in future releases.
+///
+/// [`TryStream`]: futures_core::stream::TryStream
+pub trait TryReportStreamExt<C>: TryStream<Error: Into<Report<[C]>>> {
+    /// Collects all successful items from the stream into a collection, accumulating all errors.
+    ///
+    /// This method will continue processing the stream even after encountering errors, collecting
+    /// all successful items and all errors until the stream is exhausted.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use error_stack::{Report, TryReportStreamExt};
+    /// # use futures_util::stream;
+    ///
+    /// #[derive(Debug, Clone, PartialEq, Eq)]
+    /// pub struct UnknownError;
+    ///
+    /// impl core::fmt::Display for UnknownError {
+    ///     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    ///         f.write_str("UnknownError")
+    ///     }
+    /// }
+    ///
+    /// impl core::error::Error for UnknownError {}
+    ///
+    /// #
+    /// # async fn example() {
+    /// let stream = stream::iter([
+    ///     Ok(1),
+    ///     Err(Report::new(UnknownError)),
+    ///     Ok(2),
+    ///     Err(Report::new(UnknownError)),
+    /// ]);
+    ///
+    /// let result: Result<Vec<i32>, _> = stream.try_collect_reports().await;
+    /// let report = result.expect_err("should have failed twice");
+    ///
+    /// assert_eq!(report.current_contexts().count(), 2);
+    /// # }
+    /// #
+    /// # futures::executor::block_on(example());
+    /// ```
+    fn try_collect_reports<A>(self) -> TryCollectReports<Self, A, C>
+    where
+        A: Default + Extend<Self::Ok>,
+        Self: Sized,
+    {
+        TryCollectReports::new(self, None)
+    }
+
+    /// Collects successful items from the stream into a collection, accumulating errors up to a
+    /// specified bound.
+    ///
+    /// This method will continue processing the stream after encountering errors, but will stop
+    /// once the number of accumulated errors reaches the specified `bound`.
+    ///
+    /// ```
+    /// # use error_stack::{Report, TryReportStreamExt};
+    /// # use futures_util::stream;
+    ///
+    /// #[derive(Debug, Clone, PartialEq, Eq)]
+    /// pub struct UnknownError;
+    ///
+    /// impl core::fmt::Display for UnknownError {
+    ///     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    ///         f.write_str("UnknownError")
+    ///     }
+    /// }
+    ///
+    /// impl core::error::Error for UnknownError {}
+    ///
+    /// #
+    /// # async fn example() {
+    /// let stream = stream::iter([
+    ///     Ok(1),
+    ///     Err(Report::new(UnknownError)),
+    ///     Ok(2),
+    ///     Err(Report::new(UnknownError)),
+    /// ]);
+    ///
+    /// let result: Result<Vec<i32>, _> = stream.try_collect_reports_bounded(1).await;
+    /// let report = result.expect_err("should have failed twice");
+    ///
+    /// assert_eq!(report.current_contexts().count(), 1);
+    /// # }
+    /// #
+    /// # futures::executor::block_on(example());
+    /// ```
+    fn try_collect_reports_bounded<A>(self, bound: usize) -> TryCollectReports<Self, A, C>
+    where
+        A: Default + Extend<Self::Ok>,
+        Self: Sized,
+    {
+        TryCollectReports::new(self, Some(bound))
+    }
+}
+
+impl<S, C> TryReportStreamExt<C> for S where S: TryStream<Error: Into<Report<[C]>>> {}

data/ext/cargo-vendor/error-stack-0.8.0/src/ext/tuple.rs

@@ -0,0 +1,218 @@
+use crate::Report;
+
+/// Extends tuples with error-handling capabilities.
+///
+/// This trait provides a method to collect a tuple of `Result`s into a single `Result`
+/// containing a tuple of the successful values, or an error if any of the results failed.
+///
+/// The trait is implemented for tuples of up to 16 elements.
+///
+/// # Stability
+///
+/// This trait is only available behind the `unstable` feature flag and is not covered by
+/// semver guarantees. It may change or be removed in future versions without notice.
+pub trait TryReportTupleExt<C> {
+    /// The type of the successful output, typically a tuple of the inner types of the `Result`s.
+    type Output;
+
+    /// Attempts to collect all `Result`s in the tuple into a single `Result`.
+    ///
+    /// # Errors
+    ///
+    /// If any element is `Err`, returns the first encountered `Err`, with subsequent errors
+    /// appended to it.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use error_stack::{Report, TryReportTupleExt};
+    ///
+    /// #[derive(Debug)]
+    /// struct CustomError;
+    ///
+    /// impl core::fmt::Display for CustomError {
+    ///     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    ///         write!(f, "Custom error")
+    ///     }
+    /// }
+    ///
+    /// impl core::error::Error for CustomError {}
+    ///
+    /// let result1: Result<i32, Report<CustomError>> = Ok(1);
+    /// let result2: Result<&'static str, Report<CustomError>> = Ok("success");
+    /// let result3: Result<bool, Report<CustomError>> = Ok(true);
+    ///
+    /// let combined = (result1, result2, result3).try_collect();
+    /// assert_eq!(combined.unwrap(), (1, "success", true));
+    ///
+    /// let result1: Result<i32, Report<CustomError>> = Ok(1);
+    /// let result2: Result<&'static str, Report<CustomError>> = Err(Report::new(CustomError));
+    /// let result3: Result<bool, Report<CustomError>> = Err(Report::new(CustomError));
+    /// let combined_with_error = (result1, result2, result3).try_collect();
+    /// assert!(combined_with_error.is_err());
+    /// ```
+    fn try_collect(self) -> Result<Self::Output, Report<[C]>>;
+}
+
+impl<T, R, C> TryReportTupleExt<C> for (core::result::Result<T, R>,)
+where
+    R: Into<Report<[C]>>,
+{
+    type Output = (T,);
+
+    fn try_collect(self) -> Result<Self::Output, Report<[C]>> {
+        let (result,) = self;
+
+        match result {
+            Ok(value) => Ok((value,)),
+            Err(report) => Err(report.into()),
+        }
+    }
+}
+
+#[rustfmt::skip]
+macro_rules! all_the_tuples {
+    ($macro:ident) => {
+        $macro!([A, AO]);
+        $macro!([A, AO], [B, BO]);
+        $macro!([A, AO], [B, BO], [C, CO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO], [K, KO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO], [K, KO], [L, LO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO], [K, KO], [L, LO], [M, MO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO], [K, KO], [L, LO], [M, MO], [N, NO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO], [K, KO], [L, LO], [M, MO], [N, NO], [O, OO]);
+        $macro!([A, AO], [B, BO], [C, CO], [D, DO], [E, EO], [F, FO], [G, GO], [H, HO], [I, IO], [J, JO], [K, KO], [L, LO], [M, MO], [N, NO], [O, OO], [P, PO]);
+    };
+}
+
+macro_rules! impl_ext {
+    ($([$type:ident, $output:ident]),+) => {
+        impl<$($type, $output),*, T, R, Context> TryReportTupleExt<Context> for ($($type),*, core::result::Result<T, R>)
+        where
+            R: Into<Report<[Context]>>,
+            ($($type,)*): TryReportTupleExt<Context, Output = ($($output,)*)>,
+        {
+            type Output = ($($output),*, T);
+
+            #[expect(non_snake_case, clippy::min_ident_chars)]
+            fn try_collect(self) -> Result<Self::Output, Report<[Context]>> {
+                let ($($type),*, result) = self;
+                let prefix = ($($type,)*).try_collect();
+
+                match (prefix, result) {
+                    (Ok(($($type,)*)), Ok(value)) => Ok(($($type),*, value)),
+                    (Err(report), Ok(_)) => Err(report),
+                    (Ok(_), Err(report)) => Err(report.into()),
+                    (Err(mut report), Err(error)) => {
+                        report.append(error.into());
+                        Err(report)
+                    }
+                }
+            }
+        }
+    };
+}
+
+all_the_tuples!(impl_ext);
+
+#[cfg(test)]
+mod test {
+    use alloc::{borrow::ToOwned as _, collections::BTreeSet, string::String};
+    use core::{error::Error, fmt::Display};
+
+    use super::TryReportTupleExt as _;
+    use crate::Report;
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    struct TestError(usize);
+
+    impl Display for TestError {
+        fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            fmt.write_str("TestError")
+        }
+    }
+
+    impl Error for TestError {}
+
+    #[test]
+    fn single_error() {
+        let result1: Result<i32, Report<TestError>> = Ok(1);
+        let result2: Result<String, Report<TestError>> = Ok("test".to_owned());
+        let result3: Result<bool, Report<TestError>> = Err(Report::new(TestError(0)));
+
+        let combined = (result1, result2, result3).try_collect();
+        let report = combined.expect_err("should have error");
+
+        let contexts: BTreeSet<_> = report.current_contexts().collect();
+        assert_eq!(contexts.len(), 1);
+        assert!(contexts.contains(&TestError(0)));
+    }
+
+    #[test]
+    fn no_error() {
+        let result1: Result<i32, Report<TestError>> = Ok(1);
+        let result2: Result<String, Report<TestError>> = Ok("test".to_owned());
+        let result3: Result<bool, Report<TestError>> = Ok(true);
+
+        let combined = (result1, result2, result3).try_collect();
+        let (ok1, ok2, ok3) = combined.expect("should have no error");
+
+        assert_eq!(ok1, 1);
+        assert_eq!(ok2, "test");
+        assert!(ok3);
+    }
+
+    #[test]
+    fn expanded_error() {
+        let result1: Result<i32, Report<[TestError]>> = Ok(1);
+        let result2: Result<String, Report<[TestError]>> = Ok("test".to_owned());
+        let result3: Result<bool, Report<[TestError]>> = Err(Report::new(TestError(0)).expand());
+
+        let combined = (result1, result2, result3).try_collect();
+        let report = combined.expect_err("should have error");
+
+        // order of contexts is not guaranteed
+        let contexts: BTreeSet<_> = report.current_contexts().collect();
+        assert_eq!(contexts.len(), 1);
+        assert!(contexts.contains(&TestError(0)));
+    }
+
+    #[test]
+    fn single_and_expanded_mixed() {
+        let result1: Result<i32, Report<[TestError]>> = Ok(1);
+        let result2: Result<String, Report<TestError>> = Err(Report::new(TestError(0)));
+        let result3: Result<bool, Report<[TestError]>> = Err(Report::new(TestError(1)).expand());
+
+        let combined = (result1, result2, result3).try_collect();
+        let report = combined.expect_err("should have error");
+
+        // order of contexts is not guaranteed
+        let contexts: BTreeSet<_> = report.current_contexts().collect();
+        assert_eq!(contexts.len(), 2);
+        assert!(contexts.contains(&TestError(0)));
+        assert!(contexts.contains(&TestError(1)));
+    }
+
+    #[test]
+    fn multiple_errors() {
+        let result1: Result<i32, Report<TestError>> = Err(Report::new(TestError(0)));
+        let result2: Result<String, Report<TestError>> = Ok("test".to_owned());
+        let result3: Result<bool, Report<TestError>> = Err(Report::new(TestError(1)));
+
+        let combined = (result1, result2, result3).try_collect();
+        let report = combined.expect_err("should have error");
+
+        // order of contexts is not guaranteed
+        let contexts: BTreeSet<_> = report.current_contexts().collect();
+        assert_eq!(contexts.len(), 2);
+        assert!(contexts.contains(&TestError(0)));
+        assert!(contexts.contains(&TestError(1)));
+    }
+}

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

@@ -1,15 +1,15 @@
 use crate::{
-    fmt::r#override::{AtomicOverride, AtomicPreference},
     Report,
+    fmt::r#override::{AtomicOverride, AtomicPreference},
 };
 
-/// The available supported charsets
+/// The available supported charsets.
 ///
 /// Can be accessed through [`crate::fmt::HookContext::charset`], and set via
 /// [`Report::set_charset`].
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
 pub enum Charset {
-    /// Terminal of the user supports utf-8
+    /// Terminal of the user supports UTF-8.
     ///
     /// This is the default if no charset has been explicitly set.
     // we assume that most fonts and terminals nowadays support Utf8, which is why this is
@@ -17,7 +17,7 @@ pub enum Charset {
     #[default]
     Utf8,
 
-    /// Terminal of the user supports ASCII
+    /// Terminal of the user supports ASCII.
     Ascii,
 }
 
@@ -28,10 +28,10 @@ impl Charset {
 }
 
 /// Value layout:
-/// `0x00`: `Charset::Ascii`
-/// `0x01`: `Charset::Utf8`
 ///
-/// all others: default to [`Self::default`]
+/// - `0x00`: `Charset::Ascii`
+/// - `0x01`: `Charset::Utf8`
+/// - all others: default to [`Self::default`]
 impl AtomicPreference for Charset {
     fn from_u8(value: u8) -> Self {
         match value {
@@ -52,7 +52,7 @@ impl AtomicPreference for Charset {
 static CHARSET_OVERRIDE: AtomicOverride<Charset> = AtomicOverride::new();
 
 impl Report<()> {
-    /// Set the charset preference
+    /// Sets the charset preference.
     ///
     /// The value defaults to [`Charset::Utf8`].
     ///
@@ -63,7 +63,7 @@ impl Report<()> {
     /// # #![cfg_attr(not(nightly), allow(dead_code, unused_variables, unused_imports))]
     /// use std::io::{Error, ErrorKind};
     ///
-    /// use error_stack::{report, Report};
+    /// use error_stack::{Report, IntoReport};
     /// use error_stack::fmt::{Charset};
     ///
     /// struct Suggestion(&'static str);
@@ -76,7 +76,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"));
     ///
     /// # fn render(value: String) -> String {
     /// #     let backtrace = regex::Regex::new(r"backtrace no\. (\d+)\n(?:  .*\n)*  .*").unwrap();
@@ -102,11 +102,11 @@ impl Report<()> {
     /// Which will result in something like:
     ///
     /// <pre>
-    #[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__charset_utf8.snap"))]
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__charset_utf8.snap")))]
     /// </pre>
     ///
     /// <pre>
-    #[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__charset_ascii.snap"))]
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__charset_ascii.snap")))]
     /// </pre>
     pub fn set_charset(charset: Charset) {
         CHARSET_OVERRIDE.store(charset);

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

@@ -1,23 +1,23 @@
 use core::fmt::{self, Display, Formatter};
 
 use crate::{
-    fmt::r#override::{AtomicOverride, AtomicPreference},
     Report,
+    fmt::r#override::{AtomicOverride, AtomicPreference},
 };
 
-/// The available modes of color support
+/// The available modes of color support.
 ///
 /// Can be accessed through [`crate::fmt::HookContext::color_mode`], and set via
-/// [`Report::set_color_mode`]
+/// [`Report::set_color_mode`].
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
 pub enum ColorMode {
-    /// User preference to disable all colors
+    /// User preference to disable all colors.
     None,
 
-    /// User preference to enable colors
+    /// User preference to enable colors.
     Color,
 
-    /// User preference to enable styles, but discourage colors
+    /// User preference to enable styles, but discourage colors.
     ///
     /// This is the same as [`ColorMode::Color`], but signals to the user that while colors are
     /// supported, the user prefers instead the use of emphasis, like bold and italic text.
@@ -34,11 +34,11 @@ impl ColorMode {
 }
 
 /// Value layout:
-/// `0x00`: `ColorMode::None`
-/// `0x01`: `ColorMode::Color`
-/// `0x02`: `ColorMode::Emphasis`
 ///
-/// all others: [`Self::default`]
+/// - `0x00`: `ColorMode::None`
+/// - `0x01`: `ColorMode::Color`
+/// - `0x02`: `ColorMode::Emphasis`
+/// - all others: [`Self::default`]
 impl AtomicPreference for ColorMode {
     fn from_u8(value: u8) -> Self {
         match value {
@@ -61,7 +61,7 @@ impl AtomicPreference for ColorMode {
 static COLOR_OVERRIDE: AtomicOverride<ColorMode> = AtomicOverride::new();
 
 impl Report<()> {
-    /// Set the color mode preference
+    /// Sets the color mode preference.
     ///
     /// If no [`ColorMode`] is set, it defaults to [`ColorMode::Emphasis`].
     ///
@@ -73,7 +73,7 @@ impl Report<()> {
     /// use std::io::{Error, ErrorKind};
     /// use owo_colors::OwoColorize;
     ///
-    /// use error_stack::{report, Report};
+    /// use error_stack::{Report, IntoReport};
     /// use error_stack::fmt::ColorMode;
     ///
     /// struct Suggestion(&'static str);
@@ -88,7 +88,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"));
     ///
     /// # fn render(value: String) -> String {
     /// #     let backtrace = regex::Regex::new(r"backtrace no\. (\d+)\n(?:  .*\n)*  .*").unwrap();
@@ -119,15 +119,15 @@ impl Report<()> {
     /// Which will result in something like:
     ///
     /// <pre>
-    #[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__preference_none.snap"))]
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__preference_none.snap")))]
     /// </pre>
     ///
     /// <pre>
-    #[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__preference_emphasis.snap"))]
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__preference_emphasis.snap")))]
     /// </pre>
     ///
     /// <pre>
-    #[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__preference_color.snap"))]
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__preference_color.snap")))]
     /// </pre>
     pub fn set_color_mode(mode: ColorMode) {
         COLOR_OVERRIDE.store(mode);
@@ -177,7 +177,7 @@ struct ControlSequence<'a, 'b> {
 }
 
 impl<'a, 'b> ControlSequence<'a, 'b> {
-    fn new(fmt: &'a mut Formatter<'b>) -> Self {
+    const fn new(fmt: &'a mut Formatter<'b>) -> Self {
         Self { fmt, empty: true }
     }
 
@@ -220,20 +220,20 @@ impl DisplayStyle {
         }
     }
 
-    pub(crate) fn set_bold(&mut self, value: bool) {
+    pub(crate) const fn set_bold(&mut self, value: bool) {
         self.bold = value;
     }
 
-    pub(crate) fn with_bold(mut self, value: bool) -> Self {
+    pub(crate) const fn with_bold(mut self, value: bool) -> Self {
         self.set_bold(value);
         self
     }
 
-    pub(crate) fn set_italic(&mut self, value: bool) {
+    pub(crate) const fn set_italic(&mut self, value: bool) {
         self.italic = value;
     }
 
-    pub(crate) fn with_italic(mut self, value: bool) -> Self {
+    pub(crate) const fn with_italic(mut self, value: bool) -> Self {
         self.set_italic(value);
         self
     }
@@ -279,15 +279,15 @@ impl Style {
         }
     }
 
-    pub(crate) const fn apply<T: Display>(self, value: &T) -> StyleDisplay<T> {
+    pub(crate) const fn apply<T: Display>(self, value: &T) -> StyleDisplay<'_, T> {
         StyleDisplay { style: self, value }
     }
 
-    pub(crate) fn set_foreground(&mut self, color: Color, bright: bool) {
+    pub(crate) const fn set_foreground(&mut self, color: Color, bright: bool) {
         self.foreground = Some(Foreground { color, bright });
     }
 
-    pub(crate) fn set_display(&mut self, style: DisplayStyle) {
+    pub(crate) const fn set_display(&mut self, style: DisplayStyle) {
         self.display = Some(style);
     }
 }
@@ -297,9 +297,9 @@ pub(crate) struct StyleDisplay<'a, T: Display> {
     value: &'a T,
 }
 
-impl<'a, T: Display> Display for StyleDisplay<'a, T> {
-    fn fmt(&self, mut f: &mut Formatter<'_>) -> fmt::Result {
-        let mut sequence = ControlSequence::new(f);
+impl<T: Display> Display for StyleDisplay<'_, T> {
+    fn fmt(&self, mut fmt: &mut Formatter<'_>) -> fmt::Result {
+        let mut sequence = ControlSequence::new(fmt);
 
         if let Some(display) = self.style.display {
             display.start_ansi(&mut sequence)?;
@@ -309,11 +309,11 @@ impl<'a, T: Display> Display for StyleDisplay<'a, T> {
             foreground.start_ansi(&mut sequence)?;
         }
 
-        f = sequence.finish()?;
+        fmt = sequence.finish()?;
 
-        Display::fmt(&self.value, f)?;
+        Display::fmt(&self.value, fmt)?;
 
-        let mut sequence = ControlSequence::new(f);
+        let mut sequence = ControlSequence::new(fmt);
 
         if let Some(display) = self.style.display {
             display.end_ansi(&mut sequence)?;