ci-cargo

args.rs (94954B)

---

 use super::{
     cargo::{CargoErr, Check, Clippy, Options, Test, Toolchain},
     manifest::PowerSet,
 };
 use core::{
     fmt::{self, Display, Formatter},
     ops::IndexMut as _,
 };
 use std::{
     ffi::OsString,
     io::{self, Error, StderrLock, StdoutLock, Write as _},
     path::PathBuf,
     time::Instant,
 };
 /// Unit tests.
 #[cfg(test)]
 mod tests;
 /// Help message.
 pub(crate) const HELP_MSG: &str = "Continuous integration of all features using cargo
 
 Usage: ci-cargo [COMMAND] [OPTIONS] [COMMAND] [OPTIONS] [COMMAND] [OPTIONS]
 
 Commands:
     check      cargo check
     clippy     cargo clippy
     help       This message
     test       cargo test
     version    Prints version info
 
 Global Options:
   --allow-implied features     Allow implied features from optional dependencies
   --cargo-home <PATH>          Set the storage directory used by cargo
   --cargo-path <PATH>          Set the path cargo is in. Defaults to cargo
   --color                      --color always is passed to each command; otherwise --color never is
   --default-toolchain          cargo is invoked as is (i.e., cargo +stable is never used)
   --dir <PATH>                 Set the working directory
   --ignore-compile-errors      compile_error!s are ignored
   --ignore-features <feats>    Ignore the provided comma-separated features
   --ignore-msrv                --ignore-rust-version is passed to each command for the default toolchain
   --progress                   Writes the progress to stdout
   --rustup-home <PATH>         Set the storage directory used by rustup
   --skip-msrv                  cargo +<MSRV> is not used
   --summary                    Writes the toolchain(s) and combinations of features used to stdout on success
 
 Check Options:
   --all-targets    --all-targets is passed
   --benches        --benches is passed
   --bins           --bins is passed
   --examples       --examples is passed
   --lib            --lib is passed
   --tests          --tests is passed
 
 Clippy Options:
   --all-targets      --all-targets is passed
   --benches          --benches is passed
   --bins             --bins is passed
   --deny-warnings    -- -Dwarnings is passed
   --examples         --examples is passed
   --lib              --lib is passed
   --tests            --tests is passed
 
 Test Options:
   --all-targets        cargo test --all-targets and cargo test --doc are run
   --benches            --benches is passed
   --bins               --bins is passed
   --doc                --doc is passed
   --examples           --examples is passed
   --ignored            -- --ignored is passed
   --include-ignored    -- --include-ignored is passed
   --lib                --lib is passed
   --tests              --tests is passed
 
 The following conditions must be met:
 
 * the help and version commands mustn't be combined with other commands or options
 * any unique combination of check, clippy, and test can be used
 * command-specific options must be unique for a given command
 * global options are allowed after any command but must be unique
 * command-specific options must follow the command
 * the test options --ignored and --include-ignored are mutually exclusive
 * --all-targets mustn't be combined with other targets (e.g., --lib)
 * the test option --doc mustn't be combined with other targets
 * --ignore-msrv is not allowed if the stable toolchain is used
 
 cargo +stable will be used to run the command(s) if all of the following conditions are met:
 
 * --default-toolchain was not passed
 * rust-toolchain.toml does not exist in the package directory nor its ancestor directories
 * --rustup-home was not passed for platforms that don't support rustup
 
 If the above are not met, cargo will be used instead. cargo +<MSRV> will also be used
 if all of the following conditions are met:
 
 * --skip-msrv was not passed
 * package has an MSRV defined via rust-version that is semantically less than the stable or not
   equivalent to the default toolchain used
 * --rustup-home was passed or the platform supports rustup
 
 For the toolchain(s) used, the command(s) are run for each combination of features sans any provided
 with --ignore-features. Features provided with --ignore-features must be unique and represent valid
 features in the package. An empty value is interpreted as the empty set of features.
 ";
 /// `"help"`.
 const HELP: &str = "help";
 /// `"version"`.
 const VERSION: &str = "version";
 /// `"check"`.
 const CHECK: &str = "check";
 /// `"clippy"`.
 const CLIPPY: &str = "clippy";
 /// `"test"`.
 const TEST: &str = "test";
 /// `"--all-targets"`.
 const ALL_TARGETS: &str = "--all-targets";
 /// `"--allow-implied-features"`.
 const ALLOW_IMPLIED_FEATURES: &str = "--allow-implied-features";
 /// `"--benches"`.
 const BENCHES: &str = "--benches";
 /// `"--bins"`.
 const BINS: &str = "--bins";
 /// `"--cargo-home"`.
 const CARGO_HOME: &str = "--cargo-home";
 /// `"--cargo-path"`.
 const CARGO_PATH: &str = "--cargo-path";
 /// `"--color"`.
 const COLOR: &str = "--color";
 /// `"--default-toolchain"`.
 const DEFAULT_TOOLCHAIN: &str = "--default-toolchain";
 /// `"--deny-warnings"`.
 const DENY_WARNINGS: &str = "--deny-warnings";
 /// `"--dir"`.
 const DIR: &str = "--dir";
 /// `"--doc"`.
 const DOC: &str = "--doc";
 /// `"--examples"`.
 const EXAMPLES: &str = "--examples";
 /// `"--ignore-compile-errors"`.
 const IGNORE_COMPILE_ERRORS: &str = "--ignore-compile-errors";
 /// `"--ignore-features"`.
 const IGNORE_FEATURES: &str = "--ignore-features";
 /// `"--ignore-msrv"`.
 const IGNORE_MSRV: &str = "--ignore-msrv";
 /// `"--ignored"`.
 const IGNORED: &str = "--ignored";
 /// `"--include-ignored"`.
 const INCLUDE_IGNORED: &str = "--include-ignored";
 /// `"--lib"`.
 const LIB: &str = "--lib";
 /// `"--progress"`.
 const PROGRESS: &str = "--progress";
 /// `"--rustup-home"`.
 const RUSTUP_HOME: &str = "--rustup-home";
 /// `"--skip-msrv"`.
 const SKIP_MSRV: &str = "--skip-msrv";
 /// `"--summary"`.
 const SUMMARY: &str = "--summary";
 /// `"--tests"`.
 const TESTS: &str = "--tests";
 /// `"cargo"`.
 const CARGO: &str = "cargo";
 /// `"test --doc"`.
 const TEST_DOC: &str = "test --doc";
 /// `"test --all-targets"`.
 const TEST_ALL_TARGETS: &str = "test --all-targets";
 /// `"1"`.
 const ONE: &str = "1";
 /// `"2"`.
 const TWO: &str = "2";
 /// `"3"`.
 const THREE: &str = "3";
 /// `"4"`.
 const FOUR: &str = "4";
 /// `"cargo "`.
 const CARGO_SPACE: &str = "cargo ";
 /// Error returned when parsing arguments passed to the application.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) enum ArgsErr {
     /// Error when no arguments exist.
     NoArgs,
     /// Error when no command was passed.
     NoCommand,
     /// Error when an unknown argument is passed. The contained [`OsString`] is the value of the unknown command
     /// or option.
     UnknownArg(OsString),
     /// Error when an option is passed more than once. The contained [`OsString`] is the duplicate argument.
     DuplicateOption(OsString),
     /// Error when `help` is passed followed by a non-empty sequence of arguments.
     HelpWithArgs,
     /// Error when `version` is passed followed by a non-empty sequence of arguments.
     VersionWithArgs,
     /// Error when `--dir` is passed with no file path to the directory `ci-cargo` should run in.
     MissingDirPath,
     /// Error when `--cargo-path` is passed with no file path to the directory `cargo` should be located in.
     MissingCargoPath,
     /// Error when `--cargo-home` is passed with no file path to the storage directory `cargo` uses.
     MissingCargoHome,
     /// Error when `--rustup-home` is passed with no file path to the storage directory `rustup` uses.
     MissingRustupHome,
     /// Error when `--all-targets` is passed with other targets.
     AllTargets,
     /// Error when `--doc` is passed with other targets with the `test` command.
     Doc,
     /// Error when `--ignored` and `--include-ignored` are passed with the `test` command.
     IgnoredIncludeIgnored,
     /// Error when `--ignore-features` was not passed any features.
     ///
     /// Note to _only_ pass in the empty set in an interactive terminal,
     /// you likely will need to use quotes.
     MissingIgnoredFeatures,
     /// Error when `--ignore-features` is passed duplicate features.
     DuplicateIgnoredFeatures(OsString),
 }
 impl ArgsErr {
     /// Writes `self` to `stderr`.
     pub(crate) fn write(self, mut stderr: StderrLock<'_>) -> Result<(), Error> {
         const FINAL_SENTENCE: &str = " See ci-cargo help for more information.";
         match self {
             Self::NoArgs => writeln!(
                 stderr,
                 "No arguments exist including the name of the process itself.{FINAL_SENTENCE}"
             ),
             Self::NoCommand => writeln!(
                 stderr,
                 "A command was not passed as the first argument.{FINAL_SENTENCE}"
             ),
             Self::UnknownArg(arg) => {
                 writeln!(
                     stderr,
                     "{} is an unknown argument.{FINAL_SENTENCE}",
                     arg.display()
                 )
             }
             Self::DuplicateOption(arg) => {
                 writeln!(
                     stderr,
                     "{} was passed more than once.{FINAL_SENTENCE}",
                     arg.display()
                 )
             }
             Self::HelpWithArgs => {
                 writeln!(
                     stderr,
                     "{HELP} was passed with one or more arguments.{FINAL_SENTENCE}",
                 )
             }
             Self::VersionWithArgs => {
                 writeln!(
                     stderr,
                     "{VERSION} was passed with one or more arguments.{FINAL_SENTENCE}",
                 )
             }
             Self::MissingDirPath => {
                 writeln!(
                     stderr,
                     "{DIR} was passed without a path to the directory ci-cargo should run in.{FINAL_SENTENCE}"
                 )
             }
             Self::MissingCargoPath => {
                 writeln!(
                     stderr,
                     "{CARGO_PATH} was passed without a path to the directory cargo is located in.{FINAL_SENTENCE}"
                 )
             }
             Self::MissingCargoHome => {
                 writeln!(
                     stderr,
                     "{CARGO_HOME} was passed without a path to the cargo storage directory.{FINAL_SENTENCE}"
                 )
             }
             Self::MissingRustupHome => {
                 writeln!(
                     stderr,
                     "{RUSTUP_HOME} was passed without a path to the rustup storage directory.{FINAL_SENTENCE}"
                 )
             }
             Self::AllTargets => {
                 writeln!(
                     stderr,
                     "{ALL_TARGETS} was passed with other targets.{FINAL_SENTENCE}"
                 )
             }
             Self::Doc => {
                 writeln!(
                     stderr,
                     "{DOC} was passed with other targets.{FINAL_SENTENCE}"
                 )
             }
             Self::IgnoredIncludeIgnored => {
                 writeln!(
                     stderr,
                     "{IGNORED} and {INCLUDE_IGNORED} were both passed.{FINAL_SENTENCE}"
                 )
             }
             Self::MissingIgnoredFeatures => {
                 writeln!(
                     stderr,
                     "{IGNORE_FEATURES} was passed without any features to ignore.{FINAL_SENTENCE}"
                 )
             }
             Self::DuplicateIgnoredFeatures(feats) => {
                 writeln!(
                     stderr,
                     "{IGNORE_FEATURES} was passed {} which contains at least one duplicate feature.{FINAL_SENTENCE}",
                     feats.display()
                 )
             }
         }
     }
 }
 /// Options to use for `cargo`.
 #[expect(
     clippy::struct_excessive_bools,
     reason = "not a problem. arguable false positive based on its use"
 )]
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) struct Opts {
     /// The directory to run `ci-cargo` in.
     pub exec_dir: Option<PathBuf>,
     /// Storage directory for `rustup`.
     pub rustup_home: Option<PathBuf>,
     /// Path to `cargo`.
     pub cargo_path: PathBuf,
     /// Storage directory for `cargo`.
     pub cargo_home: Option<PathBuf>,
     /// `true` iff color should be outputted.
     pub color: bool,
     /// `true` iff `cargo` should be used instead of `cargo +stable`.
     pub default_toolchain: bool,
     /// `true` iff implied features should be allowed an tested.
     pub allow_implied_features: bool,
     /// `true` iff `compile_error`s should be ignored.
     pub ignore_compile_errors: bool,
     /// `true` iff `--ignore-rust-version` should be passed.
     pub ignore_msrv: bool,
     /// `true` iff progress should be written to `stdout`.
     pub progress: bool,
     /// `true` iff the MSRV toolchain should not be used.
     pub skip_msrv: bool,
     /// `true` iff the toolchains used and combinations of features run on should be written
     /// to `stdout` upon success.
     pub summary: bool,
     /// The features to ignore.
     ///
     /// Note this is empty iff there are no features to ignore. The contained features
     /// are distinct. The empty `String` corresponds to the empty set of features to
     /// ignore (i.e., --no-default-features).
     pub ignore_features: Vec<String>,
 }
 impl Default for Opts {
     fn default() -> Self {
         Self {
             exec_dir: None,
             rustup_home: None,
             cargo_path: cargo_path(),
             cargo_home: None,
             color: false,
             default_toolchain: false,
             allow_implied_features: false,
             ignore_compile_errors: false,
             ignore_msrv: false,
             progress: false,
             skip_msrv: false,
             summary: false,
             ignore_features: Vec::new(),
         }
     }
 }
 /// Controls if `cargo test -- --ignored` or `cargo test --include-ignored` should be run.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 #[derive(Clone, Copy, Default)]
 pub(crate) enum Ignored {
     /// Don't run any `ignore` tests.
     #[default]
     None,
     /// Only run `ignore` tests.
     Only,
     /// Run all tests.
     Include,
 }
 /// Positive `usize` or `usize::MAX + 1`.
 ///
 /// Since we don't use 0, it's repurposed as `usize::MAX + 1`.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 #[derive(Clone, Copy)]
 pub(crate) struct NonZeroUsizePlus1(usize);
 impl NonZeroUsizePlus1 {
     /// Returns `Self` containing `val`.
     ///
     /// Note calling code must know that `0` is treated liked
     /// `usize::MAX + 1`.
     pub(crate) const fn new(val: usize) -> Self {
         Self(val)
     }
 }
 impl Display for NonZeroUsizePlus1 {
     #[expect(unsafe_code, reason = "comment justifies correctness")]
     #[expect(
         clippy::arithmetic_side_effects,
         reason = "comment justifies correctness"
     )]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         /// Helper for `unlikely`.
         #[inline(always)]
         #[cold]
         const fn cold_path() {}
         /// Hint that a branch is unlikely.
         #[expect(
             clippy::inline_always,
             reason = "purpose is for the compiler to not optimize"
         )]
         #[inline(always)]
         const fn unlikely(b: bool) -> bool {
             if b {
                 cold_path();
                 true
             } else {
                 false
             }
         }
         if unlikely(self.0 == 0) {
             let mut val = usize::MAX.to_string();
             // This won't underflow since the length is at least 1.
             let idx = val.len() - 1;
             // SAFETY:
             // 2^n is even for all n != 0. When n = 0, 2^n = 1. This means we can always increment the last
             // digit without carrying.
             // We only mutate the last digit which is guaranteed to be valid ASCII; thus we can increment
             // the `u8` since digits are consecutive in ASCII.
             *unsafe { val.as_bytes_mut() }.index_mut(idx) += 1;
             write!(f, "{val}")
         } else {
             write!(f, "{}", self.0)
         }
     }
 }
 /// Progress tracker for when `--progress` was passed.
 struct Progress<'package, 'toolchain> {
     /// The name of the package.
     package: &'package str,
     /// The current toolchain counter.
     toolchain_counter: &'static str,
     /// The total toolchains that will be used.
     toolchain_total: &'static str,
     /// `"cargo"` or `"cargo "`.
     ///
     /// Exists for consistent formatting with [`Self::toolchain`].
     cargo_cmd: &'toolchain str,
     /// The current toolchain.
     toolchain: &'toolchain str,
     /// The current command counter.
     cmd_counter: &'static str,
     /// The total commands that will be used.
     cmd_total: &'static str,
     /// The current command.
     cmd: &'static str,
     /// The total number of features in the power set.
     features_total: String,
     /// The time in which we started.
     time_started: Instant,
     /// `stdout` stream.
     ///
     /// None iff we encountered any error when writing
     /// to it.
     stdout: Option<StdoutLock<'static>>,
 }
 impl<'package> Progress<'package, '_> {
     /// Returns `Self` based on running check.
     fn check(
         package: &'package str,
         toolchain: Toolchain<'_>,
         use_msrv: bool,
         features_total: NonZeroUsizePlus1,
     ) -> Self {
         Self::inner_new(package, CHECK, ONE, toolchain, use_msrv, features_total)
     }
     /// Returns `Self` based on running clippy.
     fn clippy(
         package: &'package str,
         toolchain: Toolchain<'_>,
         use_msrv: bool,
         features_total: NonZeroUsizePlus1,
     ) -> Self {
         Self::inner_new(package, CLIPPY, ONE, toolchain, use_msrv, features_total)
     }
     /// Returns `Self` based on running test.
     fn test(
         package: &'package str,
         toolchain: Toolchain<'_>,
         use_msrv: bool,
         features_total: NonZeroUsizePlus1,
         all_targets: bool,
     ) -> Self {
         if all_targets {
             Self::inner_new(
                 package,
                 TEST_ALL_TARGETS,
                 TWO,
                 toolchain,
                 use_msrv,
                 features_total,
             )
         } else {
             Self::inner_new(package, TEST, ONE, toolchain, use_msrv, features_total)
         }
     }
     /// Returns `Self` based on running both check and clippy.
     fn check_clippy(
         package: &'package str,
         toolchain: Toolchain<'_>,
         use_msrv: bool,
         features_total: NonZeroUsizePlus1,
     ) -> Self {
         Self::inner_new(package, CHECK, TWO, toolchain, use_msrv, features_total)
     }
     /// Returns `Self` based on running both check and test.
     fn check_test(
         package: &'package str,
         toolchain: Toolchain<'_>,
         use_msrv: bool,
         features_total: NonZeroUsizePlus1,
         test_all_targets: bool,
     ) -> Self {
         if test_all_targets {
             Self::inner_new(package, CHECK, THREE, toolchain, use_msrv, features_total)
         } else {
             Self::inner_new(package, CHECK, TWO, toolchain, use_msrv, features_total)
         }
     }
     /// Returns `Self` based on running both clippy and test.
     fn clippy_test(
         package: &'package str,
         toolchain: Toolchain<'_>,
         use_msrv: bool,
         features_total: NonZeroUsizePlus1,
         test_all_targets: bool,
     ) -> Self {
         if test_all_targets {
             Self::inner_new(package, CLIPPY, THREE, toolchain, use_msrv, features_total)
         } else {
             Self::inner_new(package, CLIPPY, TWO, toolchain, use_msrv, features_total)
         }
     }
     /// Returns `Self` based on running check, clippy, and test.
     fn check_clippy_test(
         package: &'package str,
         toolchain: Toolchain<'_>,
         use_msrv: bool,
         features_total: NonZeroUsizePlus1,
         test_all_targets: bool,
     ) -> Self {
         if test_all_targets {
             Self::inner_new(package, CHECK, FOUR, toolchain, use_msrv, features_total)
         } else {
             Self::inner_new(package, CHECK, THREE, toolchain, use_msrv, features_total)
         }
     }
     /// Returns `Self` based on the passed arguments.
     fn inner_new(
         package: &'package str,
         cmd: &'static str,
         cmd_total: &'static str,
         tool: Toolchain<'_>,
         use_msrv: bool,
         features_total: NonZeroUsizePlus1,
     ) -> Self {
         let (cargo_cmd, toolchain) = if matches!(tool, Toolchain::Stable) {
             (CARGO_SPACE, "+stable")
         } else {
             (CARGO, "")
         };
         Self {
             package,
             toolchain_counter: ONE,
             toolchain_total: if use_msrv { TWO } else { ONE },
             cargo_cmd,
             toolchain,
             cmd_counter: ONE,
             cmd_total,
             cmd,
             features_total: features_total.to_string(),
             time_started: Instant::now(),
             stdout: Some(io::stdout().lock()),
         }
     }
     /// Writes the progress so far to `stdout`.
     ///
     /// If writing to `stdout` errors, then `stdout` will never be written to.
     fn write_to_stdout(
         &mut self,
         features: &str,
         features_counter: usize,
         features_skipped: usize,
     ) {
         if let Some(ref mut std) = self.stdout {
             // Example:
             // "Package: foo. Toolchain (1/2): cargo +stable. Features (18/128, 3 skipped): foo,bar. Command (1/2): clippy. Time running: 49 s.");
             // Note `features_skipped` maxes at `usize::MAX` since the empty set is never skipped.
             if writeln!(std, "Package: {}. Toolchain ({}/{}): {}{}. Features ({}/{}, {} skipped): {}. Command ({}/{}): {}. Time running: {} s.", self.package, self.toolchain_counter, self.toolchain_total, self.cargo_cmd, self.toolchain, NonZeroUsizePlus1(features_counter), self.features_total, features_skipped, if features.is_empty() { "<none>" } else { features }, self.cmd_counter, self.cmd_total, self.cmd, self.time_started.elapsed().as_secs()).is_err() {
                 drop(self.stdout.take());
             }
         }
     }
 }
 /// Target selection.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 #[derive(Clone, Copy)]
 pub(crate) enum Target {
     /// `--benches`.
     Benches,
     /// `--bins`.
     Bins,
     /// `--examples`.
     Examples,
     /// `--lib`.
     Lib,
     /// `--tests`.
     Tests,
 }
 impl Target {
     /// Transfoms `self` into a `u8`.
     const fn to_u8(self) -> u8 {
         match self {
             Self::Benches => 1,
             Self::Bins => 2,
             Self::Examples => 4,
             Self::Lib => 8,
             Self::Tests => 16,
         }
     }
     /// Returns `self` as an `OsString`.
     fn to_os_string(self) -> OsString {
         match match self {
             Self::Benches => BENCHES,
             Self::Bins => BINS,
             Self::Examples => EXAMPLES,
             Self::Lib => LIB,
             Self::Tests => TESTS,
         }
         .parse()
         {
             Ok(val) => val,
             Err(e) => match e {},
         }
     }
 }
 /// Combination of targets to select.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 #[derive(Clone, Copy, Default)]
 pub(crate) struct Targets(u8);
 impl Targets {
     /// Returns `Self` only containing `target`.
     const fn new(target: Target) -> Self {
         Self(target.to_u8())
     }
     /// Adds `target` to `self` returning `true` iff `target` wasn't added before.
     const fn add(&mut self, target: Target) -> bool {
         let this = self.0 | target.to_u8();
         if this == self.0 {
             false
         } else {
             self.0 = this;
             true
         }
     }
     /// Returns `true` iff `self` contains `target`.
     pub(super) const fn contains(self, target: Target) -> bool {
         let val = target.to_u8();
         self.0 & val == val
     }
 }
 /// Test targets to select.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 #[derive(Clone, Copy)]
 pub(crate) enum CheckClippyTargets {
     /// Use the default targets.
     Default,
     /// `--all-targets`.
     All,
     /// All targets.
     Targets(Targets),
 }
 /// Test targets to select.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 #[derive(Clone, Copy)]
 pub(crate) enum TestTargets {
     /// Use the default targets.
     Default,
     /// `--all-targets`.
     ///
     /// This causes all non-`doc` targets to be run and the `--doc` target/mode to be run as well.
     All,
     /// Non-`doc` targets.
     Targets(Targets),
     /// `--doc`.
     Doc,
 }
 /// `cargo` command(s) we should run.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 #[derive(Clone, Copy)]
 pub(crate) enum Cmd {
     /// `cargo check`.
     Check(CheckClippyTargets),
     /// `cargo clippy`.
     ///
     /// The contained `bool` is `true` iff `--deny-warnings` was passed.
     Clippy(CheckClippyTargets, bool),
     /// `cargo test`.
     Test(TestTargets, Ignored),
     /// [`Self::Check`] and [`Self::Clippy`].
     CheckClippy(CheckClippyTargets, CheckClippyTargets, bool),
     /// [`Self::Check`] and [`Self::Test`].
     CheckTest(CheckClippyTargets, TestTargets, Ignored),
     /// [`Self::Clippy`] and [`Self::Test`].
     ClippyTest(CheckClippyTargets, bool, TestTargets, Ignored),
     /// [`Self::Check`], [`Self::Clippy`], and [`Self::Test`].
     CheckClippyTest(
         CheckClippyTargets,
         CheckClippyTargets,
         bool,
         TestTargets,
         Ignored,
     ),
 }
 impl Cmd {
     /// Runs the appropriate `cargo` command(s) for all features in `power_set`.
     ///
     /// Note the [`Toolchain`] in `options` is first used; and if `msrv.is_some()`, then [`Toolchain::Msrv`] is
     /// later used.
     #[expect(clippy::too_many_lines, reason = "long match expression")]
     pub(crate) fn run<'a>(
         self,
         options: Options<'a, '_, '_>,
         msrv: Option<&'a str>,
         power_set: &mut PowerSet<'_>,
         progress: bool,
     ) -> Result<(), Box<CargoErr>> {
         match self {
             Self::Check(targets) => Self::run_check(
                 progress.then(|| {
                     Progress::check(
                         options.package_name,
                         options.toolchain,
                         msrv.is_some(),
                         power_set.len(),
                     )
                 }),
                 msrv,
                 options,
                 targets,
                 power_set,
             ),
             Self::Clippy(targets, deny_warnings) => Self::run_clippy(
                 progress.then(|| {
                     Progress::clippy(
                         options.package_name,
                         options.toolchain,
                         msrv.is_some(),
                         power_set.len(),
                     )
                 }),
                 msrv,
                 options,
                 targets,
                 deny_warnings,
                 power_set,
             ),
             Self::Test(targets, ignored) => {
                 if matches!(targets, TestTargets::All) {
                     Self::run_test_all_targets(
                         progress.then(|| {
                             Progress::test(
                                 options.package_name,
                                 options.toolchain,
                                 msrv.is_some(),
                                 power_set.len(),
                                 true,
                             )
                         }),
                         msrv,
                         options,
                         ignored,
                         power_set,
                     )
                 } else {
                     Self::run_test(
                         progress.then(|| {
                             Progress::test(
                                 options.package_name,
                                 options.toolchain,
                                 msrv.is_some(),
                                 power_set.len(),
                                 false,
                             )
                         }),
                         msrv,
                         options,
                         targets,
                         ignored,
                         power_set,
                     )
                 }
             }
             Self::CheckClippy(check_targets, clippy_targets, deny_warnings) => {
                 Self::run_check_clippy(
                     progress.then(|| {
                         Progress::check_clippy(
                             options.package_name,
                             options.toolchain,
                             msrv.is_some(),
                             power_set.len(),
                         )
                     }),
                     msrv,
                     options,
                     check_targets,
                     (clippy_targets, deny_warnings),
                     power_set,
                 )
             }
             Self::CheckTest(check_targets, test_targets, ignored) => {
                 if matches!(test_targets, TestTargets::All) {
                     Self::run_check_test_all_targets(
                         progress.then(|| {
                             Progress::check_test(
                                 options.package_name,
                                 options.toolchain,
                                 msrv.is_some(),
                                 power_set.len(),
                                 true,
                             )
                         }),
                         msrv,
                         options,
                         check_targets,
                         ignored,
                         power_set,
                     )
                 } else {
                     Self::run_check_test(
                         progress.then(|| {
                             Progress::check_test(
                                 options.package_name,
                                 options.toolchain,
                                 msrv.is_some(),
                                 power_set.len(),
                                 false,
                             )
                         }),
                         msrv,
                         options,
                         check_targets,
                         (test_targets, ignored),
                         power_set,
                     )
                 }
             }
             Self::ClippyTest(clippy_targets, deny_warnings, test_targets, ignored) => {
                 if matches!(test_targets, TestTargets::All) {
                     Self::run_clippy_test_all_targets(
                         progress.then(|| {
                             Progress::clippy_test(
                                 options.package_name,
                                 options.toolchain,
                                 msrv.is_some(),
                                 power_set.len(),
                                 true,
                             )
                         }),
                         msrv,
                         options,
                         (clippy_targets, deny_warnings),
                         ignored,
                         power_set,
                     )
                 } else {
                     Self::run_clippy_test(
                         progress.then(|| {
                             Progress::clippy_test(
                                 options.package_name,
                                 options.toolchain,
                                 msrv.is_some(),
                                 power_set.len(),
                                 false,
                             )
                         }),
                         msrv,
                         options,
                         (clippy_targets, deny_warnings),
                         (test_targets, ignored),
                         power_set,
                     )
                 }
             }
             Self::CheckClippyTest(
                 check_targets,
                 clippy_targets,
                 deny_warnings,
                 test_targets,
                 ignored,
             ) => {
                 if matches!(test_targets, TestTargets::All) {
                     Self::run_check_clippy_test_all_targets(
                         progress.then(|| {
                             Progress::check_clippy_test(
                                 options.package_name,
                                 options.toolchain,
                                 msrv.is_some(),
                                 power_set.len(),
                                 true,
                             )
                         }),
                         msrv,
                         options,
                         check_targets,
                         (clippy_targets, deny_warnings),
                         ignored,
                         power_set,
                     )
                 } else {
                     Self::run_check_clippy_test(
                         progress.then(|| {
                             Progress::check_clippy_test(
                                 options.package_name,
                                 options.toolchain,
                                 msrv.is_some(),
                                 power_set.len(),
                                 false,
                             )
                         }),
                         msrv,
                         options,
                         check_targets,
                         (clippy_targets, deny_warnings),
                         (test_targets, ignored),
                         power_set,
                     )
                 }
             }
         }
     }
     /// Runs `cargo check` for all features in `power_set`.
     ///
     /// Note the [`Toolchain`] in `options` is first used; and if `msrv.is_some()`, then [`Toolchain::Msrv`] is
     /// later used.
     fn run_check<'a>(
         mut progress: Option<Progress<'_, 'a>>,
         msrv: Option<&'a str>,
         mut options: Options<'a, '_, '_>,
         targets: CheckClippyTargets,
         power_set: &mut PowerSet<'_>,
     ) -> Result<(), Box<CargoErr>> {
         /// Runs the commands for each feature combination.
         fn run_loop<'a>(
             progress: &mut Option<Progress<'_, 'a>>,
             options: &mut Options<'a, '_, '_>,
             targets: CheckClippyTargets,
             power_set: &mut PowerSet<'_>,
         ) -> Result<(), Box<CargoErr>> {
             let mut feat_counter = 1usize;
             // We have two loops instead of one to avoid repeated and unnecessary if branches. This does
             // cause some bloat though.
             if let Some(ref mut prog) = *progress {
                 while let Some((set, skip_count)) = power_set.next_set_with_skip_count() {
                     prog.cmd_counter = ONE;
                     prog.cmd = CHECK;
                     prog.write_to_stdout(set, feat_counter, skip_count);
                     Check::run(options, targets, set)?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             } else {
                 while let Some(set) = power_set.next_set() {
                     Check::run(options, targets, set)?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             }
             Ok(())
         }
         run_loop(&mut progress, &mut options, targets, power_set).and_then(|()| {
             if let Some(msrv_val) = msrv {
                 if let Some(ref mut prog) = progress {
                     prog.toolchain_counter = TWO;
                     prog.cargo_cmd = CARGO_SPACE;
                     prog.toolchain = msrv_val;
                 }
                 options.toolchain = Toolchain::Msrv(msrv_val);
                 power_set.reset();
                 run_loop(&mut progress, &mut options, targets, power_set)
             } else {
                 Ok(())
             }
         })
     }
     /// Runs `cargo clippy` for all features in `power_set`.
     ///
     /// Note the [`Toolchain`] in `options` is first used; and if `msrv.is_some()`, then [`Toolchain::Msrv`] is
     /// later used.
     fn run_clippy<'a>(
         mut progress: Option<Progress<'_, 'a>>,
         msrv: Option<&'a str>,
         mut options: Options<'a, '_, '_>,
         targets: CheckClippyTargets,
         deny_warnings: bool,
         power_set: &mut PowerSet<'_>,
     ) -> Result<(), Box<CargoErr>> {
         /// Runs the commands for each feature combination.
         fn run_loop<'a>(
             progress: &mut Option<Progress<'_, 'a>>,
             options: &mut Options<'a, '_, '_>,
             targets: CheckClippyTargets,
             deny_warnings: bool,
             power_set: &mut PowerSet<'_>,
         ) -> Result<(), Box<CargoErr>> {
             let mut feat_counter = 1usize;
             // We have two loops instead of one to avoid repeated and unnecessary if branches. This does
             // cause some bloat though.
             if let Some(ref mut prog) = *progress {
                 while let Some((set, skip_count)) = power_set.next_set_with_skip_count() {
                     prog.cmd_counter = ONE;
                     prog.cmd = CLIPPY;
                     prog.write_to_stdout(set, feat_counter, skip_count);
                     Clippy::run(options, targets, deny_warnings, set)?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             } else {
                 while let Some(set) = power_set.next_set() {
                     Clippy::run(options, targets, deny_warnings, set)?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             }
             Ok(())
         }
         run_loop(
             &mut progress,
             &mut options,
             targets,
             deny_warnings,
             power_set,
         )
         .and_then(|()| {
             if let Some(msrv_val) = msrv {
                 if let Some(ref mut prog) = progress {
                     prog.toolchain_counter = TWO;
                     prog.cargo_cmd = CARGO_SPACE;
                     prog.toolchain = msrv_val;
                 }
                 options.toolchain = Toolchain::Msrv(msrv_val);
                 power_set.reset();
                 run_loop(
                     &mut progress,
                     &mut options,
                     targets,
                     deny_warnings,
                     power_set,
                 )
             } else {
                 Ok(())
             }
         })
     }
     /// Runs `cargo test` for all features in `power_set`.
     ///
     /// Note the [`Toolchain`] in `options` is first used; and if `msrv.is_some()`, then [`Toolchain::Msrv`] is
     /// later used.
     fn run_test<'a>(
         mut progress: Option<Progress<'_, 'a>>,
         msrv: Option<&'a str>,
         mut options: Options<'a, '_, '_>,
         targets: TestTargets,
         ignored: Ignored,
         power_set: &mut PowerSet<'_>,
     ) -> Result<(), Box<CargoErr>> {
         /// Runs the commands for each feature combination.
         fn run_loop<'a>(
             progress: &mut Option<Progress<'_, 'a>>,
             options: &mut Options<'a, '_, '_>,
             targets: TestTargets,
             ignored: Ignored,
             power_set: &mut PowerSet<'_>,
         ) -> Result<(), Box<CargoErr>> {
             let mut feat_counter = 1usize;
             // We have two loops instead of one to avoid repeated and unnecessary if branches. This does
             // cause some bloat though.
             if let Some(ref mut prog) = *progress {
                 while let Some((set, skip_count)) = power_set.next_set_with_skip_count() {
                     prog.cmd_counter = ONE;
                     prog.cmd = TEST;
                     prog.write_to_stdout(set, feat_counter, skip_count);
                     Test::run(options, targets, ignored, set)?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             } else {
                 while let Some(set) = power_set.next_set() {
                     Test::run(options, targets, ignored, set)?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             }
             Ok(())
         }
         run_loop(&mut progress, &mut options, targets, ignored, power_set).and_then(|()| {
             if let Some(msrv_val) = msrv {
                 if let Some(ref mut prog) = progress {
                     prog.toolchain_counter = TWO;
                     prog.cargo_cmd = CARGO_SPACE;
                     prog.toolchain = msrv_val;
                 }
                 options.toolchain = Toolchain::Msrv(msrv_val);
                 power_set.reset();
                 run_loop(&mut progress, &mut options, targets, ignored, power_set)
             } else {
                 Ok(())
             }
         })
     }
     /// Runs `cargo test --all-targets` and `cargo test --doc` for all features in `power_set`.
     ///
     /// Note the [`Toolchain`] in `options` is first used; and if `msrv.is_some()`, then [`Toolchain::Msrv`] is
     /// later used.
     fn run_test_all_targets<'a>(
         mut progress: Option<Progress<'_, 'a>>,
         msrv: Option<&'a str>,
         mut options: Options<'a, '_, '_>,
         ignored: Ignored,
         power_set: &mut PowerSet<'_>,
     ) -> Result<(), Box<CargoErr>> {
         /// Runs the commands for each feature combination.
         fn run_loop<'a>(
             progress: &mut Option<Progress<'_, 'a>>,
             options: &mut Options<'a, '_, '_>,
             ignored: Ignored,
             power_set: &mut PowerSet<'_>,
         ) -> Result<(), Box<CargoErr>> {
             let mut feat_counter = 1usize;
             // We have two loops instead of one to avoid repeated and unnecessary if branches. This does
             // cause some bloat though.
             if let Some(ref mut prog) = *progress {
                 while let Some((set, skip_count)) = power_set.next_set_with_skip_count() {
                     prog.cmd_counter = ONE;
                     prog.cmd = TEST_ALL_TARGETS;
                     prog.write_to_stdout(set, feat_counter, skip_count);
                     Test::run(options, TestTargets::All, ignored, set).and_then(|()| {
                         prog.cmd_counter = TWO;
                         prog.cmd = TEST_DOC;
                         prog.write_to_stdout(set, feat_counter, skip_count);
                         Test::run(options, TestTargets::Doc, ignored, set)
                     })?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             } else {
                 while let Some(set) = power_set.next_set() {
                     Test::run(options, TestTargets::All, ignored, set)
                         .and_then(|()| Test::run(options, TestTargets::Doc, ignored, set))?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             }
             Ok(())
         }
         run_loop(&mut progress, &mut options, ignored, power_set).and_then(|()| {
             if let Some(msrv_val) = msrv {
                 if let Some(ref mut prog) = progress {
                     prog.toolchain_counter = TWO;
                     prog.cargo_cmd = CARGO_SPACE;
                     prog.toolchain = msrv_val;
                 }
                 options.toolchain = Toolchain::Msrv(msrv_val);
                 power_set.reset();
                 run_loop(&mut progress, &mut options, ignored, power_set)
             } else {
                 Ok(())
             }
         })
     }
     /// Runs `cargo check` and `cargo clippy` for all features in `power_set`.
     ///
     /// Note the [`Toolchain`] in `options` is first used; and if `msrv.is_some()`, then [`Toolchain::Msrv`] is
     /// later used.
     fn run_check_clippy<'a>(
         mut progress: Option<Progress<'_, 'a>>,
         msrv: Option<&'a str>,
         mut options: Options<'a, '_, '_>,
         check_targets: CheckClippyTargets,
         clippy_info: (CheckClippyTargets, bool),
         power_set: &mut PowerSet<'_>,
     ) -> Result<(), Box<CargoErr>> {
         /// Runs the commands for each feature combination.
         fn run_loop<'a>(
             progress: &mut Option<Progress<'_, 'a>>,
             options: &mut Options<'a, '_, '_>,
             check_targets: CheckClippyTargets,
             (clippy_targets, deny_warnings): (CheckClippyTargets, bool),
             power_set: &mut PowerSet<'_>,
         ) -> Result<(), Box<CargoErr>> {
             let mut feat_counter = 1usize;
             // We have two loops instead of one to avoid repeated and unnecessary if branches. This does
             // cause some bloat though.
             if let Some(ref mut prog) = *progress {
                 while let Some((set, skip_count)) = power_set.next_set_with_skip_count() {
                     prog.cmd_counter = ONE;
                     prog.cmd = CHECK;
                     prog.write_to_stdout(set, feat_counter, skip_count);
                     Check::run(options, check_targets, set).and_then(|()| {
                         prog.cmd_counter = TWO;
                         prog.cmd = CLIPPY;
                         prog.write_to_stdout(set, feat_counter, skip_count);
                         Clippy::run(options, clippy_targets, deny_warnings, set)
                     })?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             } else {
                 while let Some(set) = power_set.next_set() {
                     Check::run(options, check_targets, set)
                         .and_then(|()| Clippy::run(options, clippy_targets, deny_warnings, set))?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             }
             Ok(())
         }
         run_loop(
             &mut progress,
             &mut options,
             check_targets,
             clippy_info,
             power_set,
         )
         .and_then(|()| {
             if let Some(msrv_val) = msrv {
                 if let Some(ref mut prog) = progress {
                     prog.toolchain_counter = TWO;
                     prog.cargo_cmd = CARGO_SPACE;
                     prog.toolchain = msrv_val;
                 }
                 options.toolchain = Toolchain::Msrv(msrv_val);
                 power_set.reset();
                 run_loop(
                     &mut progress,
                     &mut options,
                     check_targets,
                     clippy_info,
                     power_set,
                 )
             } else {
                 Ok(())
             }
         })
     }
     /// Runs `cargo check` and `cargo test` for all features in `power_set`.
     ///
     /// Note the [`Toolchain`] in `options` is first used; and if `msrv.is_some()`, then [`Toolchain::Msrv`] is
     /// later used.
     fn run_check_test<'a>(
         mut progress: Option<Progress<'_, 'a>>,
         msrv: Option<&'a str>,
         mut options: Options<'a, '_, '_>,
         check_targets: CheckClippyTargets,
         test_info: (TestTargets, Ignored),
         power_set: &mut PowerSet<'_>,
     ) -> Result<(), Box<CargoErr>> {
         /// Runs the commands for each feature combination.
         fn run_loop<'a>(
             progress: &mut Option<Progress<'_, 'a>>,
             options: &mut Options<'a, '_, '_>,
             check_targets: CheckClippyTargets,
             (test_targets, ignored): (TestTargets, Ignored),
             power_set: &mut PowerSet<'_>,
         ) -> Result<(), Box<CargoErr>> {
             let mut feat_counter = 1usize;
             // We have two loops instead of one to avoid repeated and unnecessary if branches. This does
             // cause some bloat though.
             if let Some(ref mut prog) = *progress {
                 while let Some((set, skip_count)) = power_set.next_set_with_skip_count() {
                     prog.cmd_counter = ONE;
                     prog.cmd = CHECK;
                     prog.write_to_stdout(set, feat_counter, skip_count);
                     Check::run(options, check_targets, set).and_then(|()| {
                         prog.cmd_counter = TWO;
                         prog.cmd = TEST;
                         prog.write_to_stdout(set, feat_counter, skip_count);
                         Test::run(options, test_targets, ignored, set)
                     })?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             } else {
                 while let Some(set) = power_set.next_set() {
                     Check::run(options, check_targets, set)
                         .and_then(|()| Test::run(options, test_targets, ignored, set))?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             }
             Ok(())
         }
         run_loop(
             &mut progress,
             &mut options,
             check_targets,
             test_info,
             power_set,
         )
         .and_then(|()| {
             if let Some(msrv_val) = msrv {
                 if let Some(ref mut prog) = progress {
                     prog.toolchain_counter = TWO;
                     prog.cargo_cmd = CARGO_SPACE;
                     prog.toolchain = msrv_val;
                 }
                 options.toolchain = Toolchain::Msrv(msrv_val);
                 power_set.reset();
                 run_loop(
                     &mut progress,
                     &mut options,
                     check_targets,
                     test_info,
                     power_set,
                 )
             } else {
                 Ok(())
             }
         })
     }
     /// Runs `cargo check`, `cargo test --all-targets`, and `cargo test --doc` for all features in `power_set`.
     ///
     /// Note the [`Toolchain`] in `options` is first used; and if `msrv.is_some()`, then [`Toolchain::Msrv`] is
     /// later used.
     fn run_check_test_all_targets<'a>(
         mut progress: Option<Progress<'_, 'a>>,
         msrv: Option<&'a str>,
         mut options: Options<'a, '_, '_>,
         check_targets: CheckClippyTargets,
         ignored: Ignored,
         power_set: &mut PowerSet<'_>,
     ) -> Result<(), Box<CargoErr>> {
         /// Runs the commands for each feature combination.
         fn run_loop<'a>(
             progress: &mut Option<Progress<'_, 'a>>,
             options: &mut Options<'a, '_, '_>,
             check_targets: CheckClippyTargets,
             ignored: Ignored,
             power_set: &mut PowerSet<'_>,
         ) -> Result<(), Box<CargoErr>> {
             let mut feat_counter = 1usize;
             // We have two loops instead of one to avoid repeated and unnecessary if branches. This does
             // cause some bloat though.
             if let Some(ref mut prog) = *progress {
                 while let Some((set, skip_count)) = power_set.next_set_with_skip_count() {
                     prog.cmd_counter = ONE;
                     prog.cmd = CHECK;
                     prog.write_to_stdout(set, feat_counter, skip_count);
                     Check::run(options, check_targets, set).and_then(|()| {
                         prog.cmd_counter = TWO;
                         prog.cmd = TEST_ALL_TARGETS;
                         prog.write_to_stdout(set, feat_counter, skip_count);
                         Test::run(options, TestTargets::All, ignored, set).and_then(|()| {
                             prog.cmd_counter = THREE;
                             prog.cmd = TEST_DOC;
                             prog.write_to_stdout(set, feat_counter, skip_count);
                             Test::run(options, TestTargets::Doc, ignored, set)
                         })
                     })?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             } else {
                 while let Some(set) = power_set.next_set() {
                     Check::run(options, check_targets, set).and_then(|()| {
                         Test::run(options, TestTargets::All, ignored, set)
                             .and_then(|()| Test::run(options, TestTargets::Doc, ignored, set))
                     })?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             }
             Ok(())
         }
         run_loop(
             &mut progress,
             &mut options,
             check_targets,
             ignored,
             power_set,
         )
         .and_then(|()| {
             if let Some(msrv_val) = msrv {
                 if let Some(ref mut prog) = progress {
                     prog.toolchain_counter = TWO;
                     prog.cargo_cmd = CARGO_SPACE;
                     prog.toolchain = msrv_val;
                 }
                 options.toolchain = Toolchain::Msrv(msrv_val);
                 power_set.reset();
                 run_loop(
                     &mut progress,
                     &mut options,
                     check_targets,
                     ignored,
                     power_set,
                 )
             } else {
                 Ok(())
             }
         })
     }
     /// Runs `cargo clippy` and `cargo test` for all features in `power_set`.
     ///
     /// Note the [`Toolchain`] in `options` is first used; and if `msrv.is_some()`, then [`Toolchain::Msrv`] is
     /// later used.
     fn run_clippy_test<'a>(
         mut progress: Option<Progress<'_, 'a>>,
         msrv: Option<&'a str>,
         mut options: Options<'a, '_, '_>,
         clippy_info: (CheckClippyTargets, bool),
         test_info: (TestTargets, Ignored),
         power_set: &mut PowerSet<'_>,
     ) -> Result<(), Box<CargoErr>> {
         /// Runs the commands for each feature combination.
         fn run_loop<'a>(
             progress: &mut Option<Progress<'_, 'a>>,
             options: &mut Options<'a, '_, '_>,
             (clippy_targets, deny_warnings): (CheckClippyTargets, bool),
             (test_targets, ignored): (TestTargets, Ignored),
             power_set: &mut PowerSet<'_>,
         ) -> Result<(), Box<CargoErr>> {
             let mut feat_counter = 1usize;
             // We have two loops instead of one to avoid repeated and unnecessary if branches. This does
             // cause some bloat though.
             if let Some(ref mut prog) = *progress {
                 while let Some((set, skip_count)) = power_set.next_set_with_skip_count() {
                     prog.cmd_counter = ONE;
                     prog.cmd = CLIPPY;
                     prog.write_to_stdout(set, feat_counter, skip_count);
                     Clippy::run(options, clippy_targets, deny_warnings, set).and_then(|()| {
                         prog.cmd_counter = TWO;
                         prog.cmd = TEST;
                         prog.write_to_stdout(set, feat_counter, skip_count);
                         Test::run(options, test_targets, ignored, set)
                     })?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             } else {
                 while let Some(set) = power_set.next_set() {
                     Clippy::run(options, clippy_targets, deny_warnings, set)
                         .and_then(|()| Test::run(options, test_targets, ignored, set))?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             }
             Ok(())
         }
         run_loop(
             &mut progress,
             &mut options,
             clippy_info,
             test_info,
             power_set,
         )
         .and_then(|()| {
             if let Some(msrv_val) = msrv {
                 if let Some(ref mut prog) = progress {
                     prog.toolchain_counter = TWO;
                     prog.cargo_cmd = CARGO_SPACE;
                     prog.toolchain = msrv_val;
                 }
                 options.toolchain = Toolchain::Msrv(msrv_val);
                 power_set.reset();
                 run_loop(
                     &mut progress,
                     &mut options,
                     clippy_info,
                     test_info,
                     power_set,
                 )
             } else {
                 Ok(())
             }
         })
     }
     /// Runs `cargo clippy`, `cargo test --all-targets`, and `cargo test --doc` for all features in `power_set`.
     ///
     /// Note the [`Toolchain`] in `options` is first used; and if `msrv.is_some()`, then [`Toolchain::Msrv`] is
     /// later used.
     fn run_clippy_test_all_targets<'a>(
         mut progress: Option<Progress<'_, 'a>>,
         msrv: Option<&'a str>,
         mut options: Options<'a, '_, '_>,
         clippy_info: (CheckClippyTargets, bool),
         ignored: Ignored,
         power_set: &mut PowerSet<'_>,
     ) -> Result<(), Box<CargoErr>> {
         /// Runs the commands for each feature combination.
         fn run_loop<'a>(
             progress: &mut Option<Progress<'_, 'a>>,
             options: &mut Options<'a, '_, '_>,
             (clippy_targets, deny_warnings): (CheckClippyTargets, bool),
             ignored: Ignored,
             power_set: &mut PowerSet<'_>,
         ) -> Result<(), Box<CargoErr>> {
             let mut feat_counter = 1usize;
             // We have two loops instead of one to avoid repeated and unnecessary if branches. This does
             // cause some bloat though.
             if let Some(ref mut prog) = *progress {
                 while let Some((set, skip_count)) = power_set.next_set_with_skip_count() {
                     prog.cmd_counter = ONE;
                     prog.cmd = CLIPPY;
                     prog.write_to_stdout(set, feat_counter, skip_count);
                     Clippy::run(options, clippy_targets, deny_warnings, set).and_then(|()| {
                         prog.cmd_counter = TWO;
                         prog.cmd = TEST_ALL_TARGETS;
                         prog.write_to_stdout(set, feat_counter, skip_count);
                         Test::run(options, TestTargets::All, ignored, set).and_then(|()| {
                             prog.cmd_counter = THREE;
                             prog.cmd = TEST_DOC;
                             prog.write_to_stdout(set, feat_counter, skip_count);
                             Test::run(options, TestTargets::Doc, ignored, set)
                         })
                     })?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             } else {
                 while let Some(set) = power_set.next_set() {
                     Clippy::run(options, clippy_targets, deny_warnings, set).and_then(|()| {
                         Test::run(options, TestTargets::All, ignored, set)
                             .and_then(|()| Test::run(options, TestTargets::Doc, ignored, set))
                     })?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             }
             Ok(())
         }
         run_loop(&mut progress, &mut options, clippy_info, ignored, power_set).and_then(|()| {
             if let Some(msrv_val) = msrv {
                 if let Some(ref mut prog) = progress {
                     prog.toolchain_counter = TWO;
                     prog.cargo_cmd = CARGO_SPACE;
                     prog.toolchain = msrv_val;
                 }
                 options.toolchain = Toolchain::Msrv(msrv_val);
                 power_set.reset();
                 run_loop(&mut progress, &mut options, clippy_info, ignored, power_set)
             } else {
                 Ok(())
             }
         })
     }
     /// Runs `cargo check`, `cargo clippy`, and `cargo test` for all features in `power_set`.
     ///
     /// Note the [`Toolchain`] in `options` is first used; and if `msrv.is_some()`, then [`Toolchain::Msrv`] is
     /// later used.
     fn run_check_clippy_test<'a>(
         mut progress: Option<Progress<'_, 'a>>,
         msrv: Option<&'a str>,
         mut options: Options<'a, '_, '_>,
         check_targets: CheckClippyTargets,
         clippy_info: (CheckClippyTargets, bool),
         test_info: (TestTargets, Ignored),
         power_set: &mut PowerSet<'_>,
     ) -> Result<(), Box<CargoErr>> {
         /// Runs the commands for each feature combination.
         fn run_loop<'a>(
             progress: &mut Option<Progress<'_, 'a>>,
             options: &mut Options<'a, '_, '_>,
             check_targets: CheckClippyTargets,
             (clippy_targets, deny_warnings): (CheckClippyTargets, bool),
             (test_targets, ignored): (TestTargets, Ignored),
             power_set: &mut PowerSet<'_>,
         ) -> Result<(), Box<CargoErr>> {
             let mut feat_counter = 1usize;
             // We have two loops instead of one to avoid repeated and unnecessary if branches. This does
             // cause some bloat though.
             if let Some(ref mut prog) = *progress {
                 while let Some((set, skip_count)) = power_set.next_set_with_skip_count() {
                     prog.cmd_counter = ONE;
                     prog.cmd = CHECK;
                     prog.write_to_stdout(set, feat_counter, skip_count);
                     Check::run(options, check_targets, set).and_then(|()| {
                         prog.cmd_counter = TWO;
                         prog.cmd = CLIPPY;
                         prog.write_to_stdout(set, feat_counter, skip_count);
                         Clippy::run(options, clippy_targets, deny_warnings, set).and_then(|()| {
                             prog.cmd_counter = THREE;
                             prog.cmd = TEST;
                             prog.write_to_stdout(set, feat_counter, skip_count);
                             Test::run(options, test_targets, ignored, set)
                         })
                     })?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             } else {
                 while let Some(set) = power_set.next_set() {
                     Check::run(options, check_targets, set).and_then(|()| {
                         Clippy::run(options, clippy_targets, deny_warnings, set)
                             .and_then(|()| Test::run(options, test_targets, ignored, set))
                     })?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             }
             Ok(())
         }
         run_loop(
             &mut progress,
             &mut options,
             check_targets,
             clippy_info,
             test_info,
             power_set,
         )
         .and_then(|()| {
             if let Some(msrv_val) = msrv {
                 if let Some(ref mut prog) = progress {
                     prog.toolchain_counter = TWO;
                     prog.cargo_cmd = CARGO_SPACE;
                     prog.toolchain = msrv_val;
                 }
                 options.toolchain = Toolchain::Msrv(msrv_val);
                 power_set.reset();
                 run_loop(
                     &mut progress,
                     &mut options,
                     check_targets,
                     clippy_info,
                     test_info,
                     power_set,
                 )
             } else {
                 Ok(())
             }
         })
     }
     /// Runs `cargo check`, `cargo clippy`, `cargo test --all-targets`, and `cargo test --doc` for all features
     /// in `power_set`.
     ///
     /// Note the [`Toolchain`] in `options` is first used; and if `msrv.is_some()`, then [`Toolchain::Msrv`] is
     /// later used.
     fn run_check_clippy_test_all_targets<'a>(
         mut progress: Option<Progress<'_, 'a>>,
         msrv: Option<&'a str>,
         mut options: Options<'a, '_, '_>,
         check_targets: CheckClippyTargets,
         clippy_info: (CheckClippyTargets, bool),
         ignored: Ignored,
         power_set: &mut PowerSet<'_>,
     ) -> Result<(), Box<CargoErr>> {
         /// Runs the commands for each feature combination.
         fn run_loop<'a>(
             progress: &mut Option<Progress<'_, 'a>>,
             options: &mut Options<'a, '_, '_>,
             check_targets: CheckClippyTargets,
             (clippy_targets, deny_warnings): (CheckClippyTargets, bool),
             ignored: Ignored,
             power_set: &mut PowerSet<'_>,
         ) -> Result<(), Box<CargoErr>> {
             let mut feat_counter = 1usize;
             // We have two loops instead of one to avoid repeated and unnecessary if branches. This does
             // cause some bloat though.
             if let Some(ref mut prog) = *progress {
                 while let Some((set, skip_count)) = power_set.next_set_with_skip_count() {
                     prog.cmd_counter = ONE;
                     prog.cmd = CHECK;
                     prog.write_to_stdout(set, feat_counter, skip_count);
                     Check::run(options, check_targets, set).and_then(|()| {
                         prog.cmd_counter = TWO;
                         prog.cmd = CLIPPY;
                         prog.write_to_stdout(set, feat_counter, skip_count);
                         Clippy::run(options, clippy_targets, deny_warnings, set).and_then(|()| {
                             prog.cmd_counter = THREE;
                             prog.cmd = TEST_ALL_TARGETS;
                             prog.write_to_stdout(set, feat_counter, skip_count);
                             Test::run(options, TestTargets::All, ignored, set).and_then(|()| {
                                 prog.cmd_counter = FOUR;
                                 prog.cmd = TEST_DOC;
                                 prog.write_to_stdout(set, feat_counter, skip_count);
                                 Test::run(options, TestTargets::Doc, ignored, set)
                             })
                         })
                     })?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             } else {
                 while let Some(set) = power_set.next_set() {
                     Check::run(options, check_targets, set).and_then(|()| {
                         Clippy::run(options, clippy_targets, deny_warnings, set).and_then(|()| {
                             Test::run(options, TestTargets::All, ignored, set)
                                 .and_then(|()| Test::run(options, TestTargets::Doc, ignored, set))
                         })
                     })?;
                     // The maximum number possible is `usize::MAX + 1`; however that can only happen at the very
                     // last item. Since we never display 0, we treat 0 as `usize::MAX + 1` when we display it via
                     // [`NonZeroUsizePlus1::fmt`].
                     feat_counter = feat_counter.wrapping_add(1);
                 }
             }
             Ok(())
         }
         run_loop(
             &mut progress,
             &mut options,
             check_targets,
             clippy_info,
             ignored,
             power_set,
         )
         .and_then(|()| {
             if let Some(msrv_val) = msrv {
                 if let Some(ref mut prog) = progress {
                     prog.toolchain_counter = TWO;
                     prog.cargo_cmd = CARGO_SPACE;
                     prog.toolchain = msrv_val;
                 }
                 options.toolchain = Toolchain::Msrv(msrv_val);
                 power_set.reset();
                 run_loop(
                     &mut progress,
                     &mut options,
                     check_targets,
                     clippy_info,
                     ignored,
                     power_set,
                 )
             } else {
                 Ok(())
             }
         })
     }
 }
 /// `cargo` command passed.
 enum CargoCmd<'a> {
     /// check.
     Check(&'a mut CheckClippyTargets),
     /// clippy.
     Clippy(&'a mut (CheckClippyTargets, bool)),
     /// test.
     Test(&'a mut (TestTargets, Ignored)),
 }
 impl CargoCmd<'_> {
     /// Adds the `--all-targets` target to `self`.
     fn add_all_targets(&mut self) -> Result<(), ArgsErr> {
         match *self {
             Self::Check(ref mut check_targets) => match **check_targets {
                 CheckClippyTargets::Default => {
                     **check_targets = CheckClippyTargets::All;
                     Ok(())
                 }
                 CheckClippyTargets::All => {
                     Err(ArgsErr::DuplicateOption(match ALL_TARGETS.parse() {
                         Ok(arg) => arg,
                         Err(e) => match e {},
                     }))
                 }
                 CheckClippyTargets::Targets(_) => Err(ArgsErr::AllTargets),
             },
             Self::Clippy(&mut (ref mut clippy_targets, _)) => match *clippy_targets {
                 CheckClippyTargets::Default => {
                     *clippy_targets = CheckClippyTargets::All;
                     Ok(())
                 }
                 CheckClippyTargets::All => {
                     Err(ArgsErr::DuplicateOption(match ALL_TARGETS.parse() {
                         Ok(arg) => arg,
                         Err(e) => match e {},
                     }))
                 }
                 CheckClippyTargets::Targets(_) => Err(ArgsErr::AllTargets),
             },
             Self::Test(&mut (ref mut test_targets, _)) => match *test_targets {
                 TestTargets::Default => {
                     *test_targets = TestTargets::All;
                     Ok(())
                 }
                 TestTargets::All => Err(ArgsErr::DuplicateOption(match ALL_TARGETS.parse() {
                     Ok(arg) => arg,
                     Err(e) => match e {},
                 })),
                 TestTargets::Targets(_) | TestTargets::Doc => Err(ArgsErr::AllTargets),
             },
         }
     }
     /// Adds the `target` to `self`.
     fn add_target(&mut self, target: Target) -> Result<(), ArgsErr> {
         match *self {
             Self::Check(ref mut check_targets) => match **check_targets {
                 CheckClippyTargets::Default => {
                     **check_targets = CheckClippyTargets::Targets(Targets::new(target));
                     Ok(())
                 }
                 CheckClippyTargets::All => Err(ArgsErr::AllTargets),
                 CheckClippyTargets::Targets(ref mut targets) => {
                     if targets.add(target) {
                         Ok(())
                     } else {
                         Err(ArgsErr::DuplicateOption(target.to_os_string()))
                     }
                 }
             },
             Self::Clippy(&mut (ref mut clippy_targets, _)) => match *clippy_targets {
                 CheckClippyTargets::Default => {
                     *clippy_targets = CheckClippyTargets::Targets(Targets::new(target));
                     Ok(())
                 }
                 CheckClippyTargets::All => Err(ArgsErr::AllTargets),
                 CheckClippyTargets::Targets(ref mut targets) => {
                     if targets.add(target) {
                         Ok(())
                     } else {
                         Err(ArgsErr::DuplicateOption(target.to_os_string()))
                     }
                 }
             },
             Self::Test(&mut (ref mut test_targets, _)) => match *test_targets {
                 TestTargets::Default => {
                     *test_targets = TestTargets::Targets(Targets::new(target));
                     Ok(())
                 }
                 TestTargets::All => Err(ArgsErr::AllTargets),
                 TestTargets::Targets(ref mut targets) => {
                     if targets.add(target) {
                         Ok(())
                     } else {
                         Err(ArgsErr::DuplicateOption(target.to_os_string()))
                     }
                 }
                 TestTargets::Doc => Err(ArgsErr::Doc),
             },
         }
     }
 }
 /// Helper to store options from the command line.
 #[expect(
     clippy::struct_excessive_bools,
     reason = "used exclusively in the recursive function MetaCmd::from_args::extract_options"
 )]
 #[derive(Default)]
 struct ArgOpts {
     /// `--allow-implied-features`.
     allow_implied_features: bool,
     /// `--cargo-home` along with the path.
     cargo_home: Option<PathBuf>,
     /// `--cargo-path` along with the path.
     cargo_path: Option<PathBuf>,
     /// `--color`.
     color: bool,
     /// `--default-toolchain`.
     default_toolchain: bool,
     /// `--dir` along with the path.
     dir: Option<PathBuf>,
     /// `--ignore-compile-errors`.
     ignore_compile_errors: bool,
     /// `--ignore-msrv`.
     ignore_msrv: bool,
     /// `--ignore-features` along with the features to ignore.
     ignore_features: Vec<String>,
     /// `--progress`.
     progress: bool,
     /// `--rustup-home` along with the path.
     rustup_home: Option<PathBuf>,
     /// `--skip-msrv`.
     skip_msrv: bool,
     /// `--summary`.
     summary: bool,
 }
 /// Returns `"cargo"`.
 fn cargo_path() -> PathBuf {
     CARGO.to_owned().into()
 }
 impl From<ArgOpts> for Opts {
     fn from(value: ArgOpts) -> Self {
         Self {
             exec_dir: value.dir,
             rustup_home: value.rustup_home,
             cargo_path: value.cargo_path.unwrap_or_else(cargo_path),
             cargo_home: value.cargo_home,
             color: value.color,
             default_toolchain: value.default_toolchain,
             allow_implied_features: value.allow_implied_features,
             ignore_compile_errors: value.ignore_compile_errors,
             ignore_msrv: value.ignore_msrv,
             progress: value.progress,
             skip_msrv: value.skip_msrv,
             summary: value.summary,
             ignore_features: value.ignore_features,
         }
     }
 }
 /// `ci-cargo` command to run.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) enum MetaCmd {
     /// Run the `cargo` command(s).
     Cargo(Cmd, Opts),
     /// Write help message to stdout.
     Help,
     /// Write version info to stdout.
     Version,
 }
 impl MetaCmd {
     /// Extracts options from `args`.
     ///
     /// This must only be called from [`Self::from_args`]. `cmd` is the current command command-specific
     /// options apply to.
     ///
     /// Returns the next `CargoCmd`.
     #[expect(unsafe_code, reason = "comment justifies correctness")]
     #[expect(
         clippy::arithmetic_side_effects,
         reason = "comment justifies correctness"
     )]
     #[expect(
         clippy::too_many_lines,
         reason = "expected since we need to extract all the passed options"
     )]
     fn extract_options<T: Iterator<Item = OsString>>(
         cmd: &mut CargoCmd<'_>,
         opts: &mut ArgOpts,
         mut args: T,
     ) -> Result<Option<OsString>, ArgsErr> {
         while let Some(arg) = args.next() {
             if let Some(arg_str) = arg.to_str() {
                 match arg_str {
                     ALL_TARGETS => cmd.add_all_targets(),
                     ALLOW_IMPLIED_FEATURES => {
                         if opts.allow_implied_features {
                             Err(ArgsErr::DuplicateOption(arg))
                         } else {
                             opts.allow_implied_features = true;
                             Ok(())
                         }
                     }
                     BENCHES => cmd.add_target(Target::Benches),
                     BINS => cmd.add_target(Target::Bins),
                     CARGO_HOME => args.next().map_or(Err(ArgsErr::MissingCargoHome), |path| {
                         opts.cargo_home
                             .replace(path.into())
                             .map_or(Ok(()), |_| Err(ArgsErr::DuplicateOption(arg)))
                     }),
                     CARGO_PATH => args.next().map_or(Err(ArgsErr::MissingCargoPath), |p| {
                         // This won't overflow since `p.len() + 6 < usize::MAX` since
                         // `p.len() <= isize::MAX`, `usize::MAX >= u16::MAX`, and
                         // `i16::MAX + 6 < u16::MAX`.
                         let mut path = PathBuf::with_capacity(CARGO.len() + 1 + p.len());
                         path.push(p);
                         path.push(CARGO);
                         opts.cargo_path
                             .replace(path)
                             .map_or(Ok(()), |_| Err(ArgsErr::DuplicateOption(arg)))
                     }),
                     COLOR => {
                         if opts.color {
                             Err(ArgsErr::DuplicateOption(arg))
                         } else {
                             opts.color = true;
                             Ok(())
                         }
                     }
                     DEFAULT_TOOLCHAIN => {
                         if opts.default_toolchain {
                             Err(ArgsErr::DuplicateOption(arg))
                         } else {
                             opts.default_toolchain = true;
                             Ok(())
                         }
                     }
                     DENY_WARNINGS => match *cmd {
                         CargoCmd::Clippy(&mut (_, ref mut deny_warnings)) => {
                             if *deny_warnings {
                                 Err(ArgsErr::DuplicateOption(arg))
                             } else {
                                 *deny_warnings = true;
                                 Ok(())
                             }
                         }
                         CargoCmd::Check(_) | CargoCmd::Test(_) => Err(ArgsErr::UnknownArg(arg)),
                     },
                     DIR => args.next().map_or(Err(ArgsErr::MissingDirPath), |path| {
                         opts.dir
                             .replace(path.into())
                             .map_or(Ok(()), |_| Err(ArgsErr::DuplicateOption(arg)))
                     }),
                     DOC => match *cmd {
                         CargoCmd::Test(&mut (ref mut test_targets, _)) => match *test_targets {
                             TestTargets::Default => {
                                 *test_targets = TestTargets::Doc;
                                 Ok(())
                             }
                             TestTargets::All | TestTargets::Targets(_) => Err(ArgsErr::Doc),
                             TestTargets::Doc => Err(ArgsErr::DuplicateOption(arg)),
                         },
                         CargoCmd::Check(_) | CargoCmd::Clippy(_) => Err(ArgsErr::UnknownArg(arg)),
                     },
                     EXAMPLES => cmd.add_target(Target::Examples),
                     IGNORE_COMPILE_ERRORS => {
                         if opts.ignore_compile_errors {
                             Err(ArgsErr::DuplicateOption(arg))
                         } else {
                             opts.ignore_compile_errors = true;
                             Ok(())
                         }
                     }
                     IGNORE_FEATURES => {
                         if opts.ignore_features.is_empty() {
                             args.next()
                                 .map_or(Err(ArgsErr::MissingIgnoredFeatures), |feats_os| {
                                     if let Some(feats) = feats_os.to_str() {
                                         feats
                                             .as_bytes()
                                             .split(|b| *b == b',')
                                             .try_fold((), |(), feat| {
                                                 if opts
                                                     .ignore_features
                                                     .iter()
                                                     .any(|f| f.as_bytes() == feat)
                                                 {
                                                     Err(())
                                                 } else {
                                                     let utf8 = feat.to_owned();
                                                     // SAFETY:
                                                     // `feats` is a valid `str` and was split by
                                                     // a single UTF-8 code unit; thus `utf8` is also
                                                     // valid UTF-8.
                                                     opts.ignore_features.push(unsafe {
                                                         String::from_utf8_unchecked(utf8)
                                                     });
                                                     Ok(())
                                                 }
                                             })
                                             .map_err(|()| {
                                                 ArgsErr::DuplicateIgnoredFeatures(feats_os)
                                             })
                                     } else {
                                         Err(ArgsErr::UnknownArg(feats_os))
                                     }
                                 })
                         } else {
                             Err(ArgsErr::DuplicateOption(arg))
                         }
                     }
                     IGNORE_MSRV => {
                         if opts.ignore_msrv {
                             Err(ArgsErr::DuplicateOption(arg))
                         } else {
                             opts.ignore_msrv = true;
                             Ok(())
                         }
                     }
                     IGNORED => match *cmd {
                         CargoCmd::Test(&mut (_, ref mut ignored)) => match *ignored {
                             Ignored::None => {
                                 *ignored = Ignored::Only;
                                 Ok(())
                             }
                             Ignored::Only => Err(ArgsErr::DuplicateOption(arg)),
                             Ignored::Include => Err(ArgsErr::IgnoredIncludeIgnored),
                         },
                         CargoCmd::Check(_) | CargoCmd::Clippy(_) => Err(ArgsErr::UnknownArg(arg)),
                     },
                     INCLUDE_IGNORED => match *cmd {
                         CargoCmd::Test(&mut (_, ref mut ignored)) => match *ignored {
                             Ignored::None => {
                                 *ignored = Ignored::Include;
                                 Ok(())
                             }
                             Ignored::Only => Err(ArgsErr::IgnoredIncludeIgnored),
                             Ignored::Include => Err(ArgsErr::DuplicateOption(arg)),
                         },
                         CargoCmd::Check(_) | CargoCmd::Clippy(_) => Err(ArgsErr::UnknownArg(arg)),
                     },
                     LIB => cmd.add_target(Target::Lib),
                     PROGRESS => {
                         if opts.progress {
                             Err(ArgsErr::DuplicateOption(arg))
                         } else {
                             opts.progress = true;
                             Ok(())
                         }
                     }
                     RUSTUP_HOME => args.next().map_or(Err(ArgsErr::MissingRustupHome), |path| {
                         opts.rustup_home
                             .replace(path.into())
                             .map_or(Ok(()), |_| Err(ArgsErr::DuplicateOption(arg)))
                     }),
                     SKIP_MSRV => {
                         if opts.skip_msrv {
                             Err(ArgsErr::DuplicateOption(arg))
                         } else {
                             opts.skip_msrv = true;
                             Ok(())
                         }
                     }
                     SUMMARY => {
                         if opts.summary {
                             Err(ArgsErr::DuplicateOption(arg))
                         } else {
                             opts.summary = true;
                             Ok(())
                         }
                     }
                     TESTS => cmd.add_target(Target::Tests),
                     _ => return Ok(Some(arg)),
                 }
             } else {
                 Err(ArgsErr::UnknownArg(arg))
             }?;
         }
         Ok(None)
     }
     /// Returns data we need by reading the supplied CLI arguments.
     #[expect(clippy::unreachable, reason = "want to crash when there is a bug")]
     pub(crate) fn from_args<T: Iterator<Item = OsString>>(mut args: T) -> Result<Self, ArgsErr> {
         args.next().ok_or(ArgsErr::NoArgs).and_then(|_| {
             args.next().ok_or(ArgsErr::NoCommand).and_then(|fst_cmd| {
                 if let Some(fst_cmd_str) = fst_cmd.to_str() {
                     let mut opts = ArgOpts::default();
                     let mut check_targets = None;
                     let mut clippy_info: Option<(CheckClippyTargets, bool)> = None;
                     let mut test_info: Option<(TestTargets, Ignored)> = None;
                     let mut cargo_cmd = match fst_cmd_str {
                         CHECK => CargoCmd::Check(check_targets.insert(CheckClippyTargets::Default)),
                         CLIPPY => CargoCmd::Clippy(
                             clippy_info.insert((CheckClippyTargets::Default, false)),
                         ),
                         HELP => {
                             return args
                                 .next()
                                 .map_or_else(|| Ok(Self::Help), |_| Err(ArgsErr::HelpWithArgs));
                         }
                         TEST => {
                             CargoCmd::Test(test_info.insert((TestTargets::Default, Ignored::None)))
                         }
                         VERSION => {
                             return args.next().map_or_else(
                                 || Ok(Self::Version),
                                 |_| Err(ArgsErr::VersionWithArgs),
                             );
                         }
                         _ => return Err(ArgsErr::NoCommand),
                     };
                     while let Some(arg) =
                         Self::extract_options(&mut cargo_cmd, &mut opts, &mut args)?
                     {
                         match arg.to_str().unwrap_or_else(|| {
                             unreachable!("there is a bug in args::MetaCmd::extract_options")
                         }) {
                             CHECK => {
                                 if check_targets.is_some() {
                                     return Err(ArgsErr::DuplicateOption(arg));
                                 }
                                 cargo_cmd = CargoCmd::Check(
                                     check_targets.insert(CheckClippyTargets::Default),
                                 );
                             }
                             CLIPPY => {
                                 if clippy_info.is_some() {
                                     return Err(ArgsErr::DuplicateOption(arg));
                                 }
                                 cargo_cmd = CargoCmd::Clippy(
                                     clippy_info.insert((CheckClippyTargets::Default, false)),
                                 );
                             }
                             TEST => {
                                 if test_info.is_some() {
                                     return Err(ArgsErr::DuplicateOption(arg));
                                 }
                                 cargo_cmd = CargoCmd::Test(
                                     test_info.insert((TestTargets::Default, Ignored::None)),
                                 );
                             }
                             _ => return Err(ArgsErr::UnknownArg(arg)),
                         }
                     }
                     if let Some(check) = check_targets {
                         Ok(Self::Cargo(
                             clippy_info.map_or_else(
                                 || {
                                     test_info.map_or(Cmd::Check(check), |test| {
                                         Cmd::CheckTest(check, test.0, test.1)
                                     })
                                 },
                                 |clippy| {
                                     test_info.map_or(
                                         Cmd::CheckClippy(check, clippy.0, clippy.1),
                                         |test| {
                                             Cmd::CheckClippyTest(
                                                 check, clippy.0, clippy.1, test.0, test.1,
                                             )
                                         },
                                     )
                                 },
                             ),
                             opts.into(),
                         ))
                     } else if let Some(clippy) = clippy_info {
                         Ok(Self::Cargo(
                             test_info.map_or(Cmd::Clippy(clippy.0, clippy.1), |test| {
                                 Cmd::ClippyTest(clippy.0, clippy.1, test.0, test.1)
                             }),
                             opts.into(),
                         ))
                     } else if let Some(test) = test_info {
                         Ok(Self::Cargo(Cmd::Test(test.0, test.1), opts.into()))
                     } else {
                         Err(ArgsErr::NoCommand)
                     }
                 } else {
                     Err(ArgsErr::UnknownArg(fst_cmd))
                 }
             })
         })
     }
 }