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,
};
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.
";
const HELP: &str = "help";
const VERSION: &str = "version";
const CHECK: &str = "check";
const CLIPPY: &str = "clippy";
const TEST: &str = "test";
const ALL_TARGETS: &str = "--all-targets";
const ALLOW_IMPLIED_FEATURES: &str = "--allow-implied-features";
const BENCHES: &str = "--benches";
const BINS: &str = "--bins";
const CARGO_HOME: &str = "--cargo-home";
const CARGO_PATH: &str = "--cargo-path";
const COLOR: &str = "--color";
const DEFAULT_TOOLCHAIN: &str = "--default-toolchain";
const DENY_WARNINGS: &str = "--deny-warnings";
const DIR: &str = "--dir";
const DOC: &str = "--doc";
const EXAMPLES: &str = "--examples";
const IGNORE_COMPILE_ERRORS: &str = "--ignore-compile-errors";
const IGNORE_FEATURES: &str = "--ignore-features";
const IGNORE_MSRV: &str = "--ignore-msrv";
const IGNORED: &str = "--ignored";
const INCLUDE_IGNORED: &str = "--include-ignored";
const LIB: &str = "--lib";
const PROGRESS: &str = "--progress";
const RUSTUP_HOME: &str = "--rustup-home";
const SKIP_MSRV: &str = "--skip-msrv";
const SUMMARY: &str = "--summary";
const TESTS: &str = "--tests";
const CARGO: &str = "cargo";
const TEST_DOC: &str = "test --doc";
const TEST_ALL_TARGETS: &str = "test --all-targets";
const ONE: &str = "1";
const TWO: &str = "2";
const THREE: &str = "3";
const FOUR: &str = "4";
const CARGO_SPACE: &str = "cargo ";
#[cfg_attr(test, derive(Debug, PartialEq))]
pub(crate) enum ArgsErr {
NoArgs,
NoCommand,
UnknownArg(OsString),
DuplicateOption(OsString),
HelpWithArgs,
VersionWithArgs,
MissingDirPath,
MissingCargoPath,
MissingCargoHome,
MissingRustupHome,
AllTargets,
Doc,
IgnoredIncludeIgnored,
MissingIgnoredFeatures,
DuplicateIgnoredFeatures(OsString),
}
impl ArgsErr {
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()
)
}
}
}
}
#[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 {
pub exec_dir: Option<PathBuf>,
pub rustup_home: Option<PathBuf>,
pub cargo_path: PathBuf,
pub cargo_home: Option<PathBuf>,
pub color: bool,
pub default_toolchain: bool,
pub allow_implied_features: bool,
pub ignore_compile_errors: bool,
pub ignore_msrv: bool,
pub progress: bool,
pub skip_msrv: bool,
pub summary: bool,
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(),
}
}
}
#[cfg_attr(test, derive(Debug, PartialEq))]
#[derive(Clone, Copy, Default)]
pub(crate) enum Ignored {
#[default]
None,
Only,
Include,
}
#[cfg_attr(test, derive(Debug, PartialEq))]
#[derive(Clone, Copy)]
pub(crate) struct NonZeroUsizePlus1(usize);
impl NonZeroUsizePlus1 {
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 {
#[inline(always)]
#[cold]
const fn cold_path() {}
#[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();
let idx = val.len() - 1;
*unsafe { val.as_bytes_mut() }.index_mut(idx) += 1;
write!(f, "{val}")
} else {
write!(f, "{}", self.0)
}
}
}
struct Progress<'package, 'toolchain> {
package: &'package str,
toolchain_counter: &'static str,
toolchain_total: &'static str,
cargo_cmd: &'toolchain str,
toolchain: &'toolchain str,
cmd_counter: &'static str,
cmd_total: &'static str,
cmd: &'static str,
features_total: String,
time_started: Instant,
stdout: Option<StdoutLock<'static>>,
}
impl<'package> Progress<'package, '_> {
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)
}
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)
}
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)
}
}
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)
}
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)
}
}
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)
}
}
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)
}
}
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()),
}
}
fn write_to_stdout(
&mut self,
features: &str,
features_counter: usize,
features_skipped: usize,
) {
if let Some(ref mut std) = self.stdout {
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());
}
}
}
}
#[cfg_attr(test, derive(Debug, PartialEq))]
#[derive(Clone, Copy)]
pub(crate) enum Target {
Benches,
Bins,
Examples,
Lib,
Tests,
}
impl Target {
const fn to_u8(self) -> u8 {
match self {
Self::Benches => 1,
Self::Bins => 2,
Self::Examples => 4,
Self::Lib => 8,
Self::Tests => 16,
}
}
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 {},
}
}
}
#[cfg_attr(test, derive(Debug, PartialEq))]
#[derive(Clone, Copy, Default)]
pub(crate) struct Targets(u8);
impl Targets {
const fn new(target: Target) -> Self {
Self(target.to_u8())
}
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
}
}
pub(super) const fn contains(self, target: Target) -> bool {
let val = target.to_u8();
self.0 & val == val
}
}
#[cfg_attr(test, derive(Debug, PartialEq))]
#[derive(Clone, Copy)]
pub(crate) enum CheckClippyTargets {
Default,
All,
Targets(Targets),
}
#[cfg_attr(test, derive(Debug, PartialEq))]
#[derive(Clone, Copy)]
pub(crate) enum TestTargets {
Default,
All,
Targets(Targets),
Doc,
}
#[cfg_attr(test, derive(Debug, PartialEq))]
#[derive(Clone, Copy)]
pub(crate) enum Cmd {
Check(CheckClippyTargets),
Clippy(CheckClippyTargets, bool),
Test(TestTargets, Ignored),
CheckClippy(CheckClippyTargets, CheckClippyTargets, bool),
CheckTest(CheckClippyTargets, TestTargets, Ignored),
ClippyTest(CheckClippyTargets, bool, TestTargets, Ignored),
CheckClippyTest(
CheckClippyTargets,
CheckClippyTargets,
bool,
TestTargets,
Ignored,
),
}
impl Cmd {
#[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,
)
}
}
}
}
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>> {
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;
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)?;
feat_counter = feat_counter.wrapping_add(1);
}
} else {
while let Some(set) = power_set.next_set() {
Check::run(options, targets, set)?;
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(())
}
})
}
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>> {
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;
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)?;
feat_counter = feat_counter.wrapping_add(1);
}
} else {
while let Some(set) = power_set.next_set() {
Clippy::run(options, targets, deny_warnings, set)?;
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(())
}
})
}
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>> {
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;
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)?;
feat_counter = feat_counter.wrapping_add(1);
}
} else {
while let Some(set) = power_set.next_set() {
Test::run(options, targets, ignored, set)?;
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(())
}
})
}
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>> {
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;
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)
})?;
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))?;
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(())
}
})
}
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>> {
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;
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)
})?;
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))?;
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(())
}
})
}
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>> {
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;
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)
})?;
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))?;
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(())
}
})
}
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>> {
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;
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)
})
})?;
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))
})?;
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(())
}
})
}
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>> {
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;
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)
})?;
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))?;
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(())
}
})
}
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>> {
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;
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)
})
})?;
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))
})?;
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(())
}
})
}
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>> {
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;
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)
})
})?;
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))
})?;
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(())
}
})
}
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>> {
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;
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)
})
})
})?;
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))
})
})?;
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(())
}
})
}
}
enum CargoCmd<'a> {
Check(&'a mut CheckClippyTargets),
Clippy(&'a mut (CheckClippyTargets, bool)),
Test(&'a mut (TestTargets, Ignored)),
}
impl CargoCmd<'_> {
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),
},
}
}
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),
},
}
}
}
#[expect(
clippy::struct_excessive_bools,
reason = "used exclusively in the recursive function MetaCmd::from_args::extract_options"
)]
#[derive(Default)]
struct ArgOpts {
allow_implied_features: bool,
cargo_home: Option<PathBuf>,
cargo_path: Option<PathBuf>,
color: bool,
default_toolchain: bool,
dir: Option<PathBuf>,
ignore_compile_errors: bool,
ignore_msrv: bool,
ignore_features: Vec<String>,
progress: bool,
rustup_home: Option<PathBuf>,
skip_msrv: bool,
summary: bool,
}
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,
}
}
}
#[cfg_attr(test, derive(Debug, PartialEq))]
pub(crate) enum MetaCmd {
Cargo(Cmd, Opts),
Help,
Version,
}
impl MetaCmd {
#[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| {
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();
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)
}
#[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))
}
})
})
}
}
#[cfg(test)]
mod tests {
use super::{
ArgsErr, CheckClippyTargets, Cmd, Ignored, MetaCmd, NonZeroUsizePlus1, Opts, OsString,
PathBuf, Target, Targets, TestTargets,
};
use core::iter;
#[cfg(unix)]
use std::os::unix::ffi::OsStringExt as _;
#[expect(
clippy::cognitive_complexity,
clippy::too_many_lines,
reason = "want to test for a lot of things"
)]
#[test]
fn arg_parsing() {
assert_eq!(MetaCmd::from_args(iter::empty()), Err(ArgsErr::NoArgs));
assert_eq!(
MetaCmd::from_args(iter::once(OsString::new())),
Err(ArgsErr::NoCommand)
);
assert_eq!(
MetaCmd::from_args([OsString::new(), OsString::new()].into_iter()),
Err(ArgsErr::NoCommand)
);
#[cfg(unix)]
assert_eq!(
MetaCmd::from_args([OsString::new(), OsString::from_vec(vec![255])].into_iter()),
Err(ArgsErr::UnknownArg(OsString::from_vec(vec![255])))
);
assert_eq!(
MetaCmd::from_args([OsString::new(), " clippy".to_owned().into()].into_iter()),
Err(ArgsErr::NoCommand)
);
assert_eq!(
MetaCmd::from_args([OsString::new(), "Clippy".to_owned().into()].into_iter()),
Err(ArgsErr::NoCommand)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"--summary".to_owned().into(),
"clippy".to_owned().into()
]
.into_iter()
),
Err(ArgsErr::NoCommand)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"help".to_owned().into(),
"--summary".to_owned().into()
]
.into_iter()
),
Err(ArgsErr::HelpWithArgs)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"version".to_owned().into(),
"foo".to_owned().into()
]
.into_iter()
),
Err(ArgsErr::VersionWithArgs)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--cargo-path".to_owned().into()
]
.into_iter()
),
Err(ArgsErr::MissingCargoPath)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--cargo-home".to_owned().into()
]
.into_iter()
),
Err(ArgsErr::MissingCargoHome)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--rustup-home".to_owned().into()
]
.into_iter()
),
Err(ArgsErr::MissingRustupHome)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"test".to_owned().into(),
"--deny-warnings".to_owned().into()
]
.into_iter()
),
Err(ArgsErr::UnknownArg("--deny-warnings".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--deny-warnings".to_owned().into()
]
.into_iter()
),
Err(ArgsErr::UnknownArg("--deny-warnings".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"clippy".to_owned().into(),
"--ignored".to_owned().into()
]
.into_iter()
),
Err(ArgsErr::UnknownArg("--ignored".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--ignored".to_owned().into()
]
.into_iter()
),
Err(ArgsErr::UnknownArg("--ignored".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"clippy".to_owned().into(),
"--include-ignored".to_owned().into()
]
.into_iter()
),
Err(ArgsErr::UnknownArg("--include-ignored".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--include-ignored".to_owned().into()
]
.into_iter()
),
Err(ArgsErr::UnknownArg("--include-ignored".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"test".to_owned().into(),
"--ignored".to_owned().into(),
"--include-ignored".to_owned().into()
]
.into_iter()
),
Err(ArgsErr::IgnoredIncludeIgnored)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"test".to_owned().into(),
"--ignore-features".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::MissingIgnoredFeatures)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"clippy".to_owned().into(),
"--ignore-features".to_owned().into(),
",".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::DuplicateIgnoredFeatures(",".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--ignore-features".to_owned().into(),
"a,,a".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::DuplicateIgnoredFeatures("a,,a".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--ignore-features".to_owned().into(),
",a,b,".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::DuplicateIgnoredFeatures(",a,b,".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"clippy".to_owned().into(),
"--ignore-features".to_owned().into(),
",a,,b".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::DuplicateIgnoredFeatures(",a,,b".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"clippy".to_owned().into(),
"--ignore-features".to_owned().into(),
"a,b,,".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::DuplicateIgnoredFeatures("a,b,,".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"clippy".to_owned().into(),
"--lib".to_owned().into(),
"--all-targets".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::AllTargets)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--lib".to_owned().into(),
"--all-targets".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::AllTargets)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--all-targets".to_owned().into(),
"test".to_owned().into(),
"--doc".to_owned().into(),
"--all-targets".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::AllTargets)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"test".to_owned().into(),
"--all-targets".to_owned().into(),
"--doc".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::Doc)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"test".to_owned().into(),
"--doc".to_owned().into(),
"--lib".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::Doc)
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"clippy".to_owned().into(),
"--doc".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::UnknownArg("--doc".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--color".to_owned().into(),
"clippy".to_owned().into(),
"--color".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::DuplicateOption("--color".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"test".to_owned().into(),
"--ignored".to_owned().into(),
"--ignored".to_owned().into(),
]
.into_iter()
),
Err(ArgsErr::DuplicateOption("--ignored".to_owned().into()))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"clippy".to_owned().into(),
"--all-targets".to_owned().into(),
"--allow-implied-features".to_owned().into(),
"--cargo-home".to_owned().into(),
"--ignored".to_owned().into(),
"--cargo-path".to_owned().into(),
"cargo".to_owned().into(),
"--color".to_owned().into(),
"--default-toolchain".to_owned().into(),
"--deny-warnings".to_owned().into(),
"--dir".to_owned().into(),
OsString::new(),
"--ignore-compile-errors".to_owned().into(),
"--ignore-features".to_owned().into(),
",a".to_owned().into(),
"--ignore-msrv".to_owned().into(),
"--rustup-home".to_owned().into(),
"a".to_owned().into(),
"--progress".to_owned().into(),
"--skip-msrv".to_owned().into(),
"--summary".to_owned().into(),
]
.into_iter()
),
Ok(MetaCmd::Cargo(
Cmd::Clippy(CheckClippyTargets::All, true,),
Opts {
exec_dir: Some(PathBuf::new()),
rustup_home: Some("a".to_owned().into()),
cargo_home: Some("--ignored".to_owned().into()),
cargo_path: "cargo/cargo".to_owned().into(),
color: true,
default_toolchain: true,
allow_implied_features: true,
ignore_compile_errors: true,
ignore_msrv: true,
progress: true,
skip_msrv: true,
summary: true,
ignore_features: vec![String::new(), "a".to_owned()],
}
))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"clippy".to_owned().into(),
"--all-targets".to_owned().into(),
"--deny-warnings".to_owned().into(),
]
.into_iter()
),
Ok(MetaCmd::Cargo(
Cmd::Clippy(CheckClippyTargets::All, true,),
Opts {
exec_dir: None,
rustup_home: None,
cargo_home: None,
cargo_path: "cargo".to_owned().into(),
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(),
}
))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"test".to_owned().into(),
"--allow-implied-features".to_owned().into(),
"--cargo-home".to_owned().into(),
"--ignored".to_owned().into(),
"--cargo-path".to_owned().into(),
"cargo".to_owned().into(),
"--color".to_owned().into(),
"--default-toolchain".to_owned().into(),
"--dir".to_owned().into(),
OsString::new(),
"--ignore-compile-errors".to_owned().into(),
"--ignore-features".to_owned().into(),
OsString::new(),
"--ignore-msrv".to_owned().into(),
"--ignored".to_owned().into(),
"--rustup-home".to_owned().into(),
OsString::new(),
"--progress".to_owned().into(),
"--skip-msrv".to_owned().into(),
"--summary".to_owned().into(),
]
.into_iter()
),
Ok(MetaCmd::Cargo(
Cmd::Test(TestTargets::Default, Ignored::Only),
Opts {
exec_dir: Some(PathBuf::new()),
rustup_home: Some(PathBuf::new()),
cargo_home: Some("--ignored".to_owned().into()),
cargo_path: "cargo/cargo".to_owned().into(),
color: true,
default_toolchain: true,
allow_implied_features: true,
ignore_compile_errors: true,
ignore_msrv: true,
progress: true,
skip_msrv: true,
summary: true,
ignore_features: vec![String::new()],
}
))
);
assert_eq!(
MetaCmd::from_args([OsString::new(), "test".to_owned().into(),].into_iter()),
Ok(MetaCmd::Cargo(
Cmd::Test(TestTargets::Default, Ignored::None),
Opts {
exec_dir: None,
rustup_home: None,
cargo_home: None,
cargo_path: "cargo".to_owned().into(),
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(),
}
))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"test".to_owned().into(),
"--include-ignored".to_owned().into()
]
.into_iter()
),
Ok(MetaCmd::Cargo(
Cmd::Test(TestTargets::Default, Ignored::Include),
Opts {
exec_dir: None,
rustup_home: None,
cargo_home: None,
cargo_path: "cargo".to_owned().into(),
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(),
}
))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--all-targets".to_owned().into(),
"--allow-implied-features".to_owned().into(),
"--cargo-home".to_owned().into(),
"--ignored".to_owned().into(),
"--cargo-path".to_owned().into(),
"cargo".to_owned().into(),
"--color".to_owned().into(),
"--default-toolchain".to_owned().into(),
"--dir".to_owned().into(),
OsString::new(),
"--ignore-compile-errors".to_owned().into(),
"--ignore-features".to_owned().into(),
"a,".to_owned().into(),
"--ignore-msrv".to_owned().into(),
"--rustup-home".to_owned().into(),
OsString::new(),
"--progress".to_owned().into(),
"--skip-msrv".to_owned().into(),
"--summary".to_owned().into(),
]
.into_iter()
),
Ok(MetaCmd::Cargo(
Cmd::Check(CheckClippyTargets::All),
Opts {
exec_dir: Some(PathBuf::new()),
rustup_home: Some(PathBuf::new()),
cargo_home: Some("--ignored".to_owned().into()),
cargo_path: "cargo/cargo".to_owned().into(),
color: true,
default_toolchain: true,
allow_implied_features: true,
ignore_compile_errors: true,
ignore_msrv: true,
progress: true,
skip_msrv: true,
summary: true,
ignore_features: vec!["a".to_owned(), String::new()],
}
))
);
assert_eq!(
MetaCmd::from_args([OsString::new(), "check".to_owned().into(),].into_iter()),
Ok(MetaCmd::Cargo(
Cmd::Check(CheckClippyTargets::Default),
Opts {
exec_dir: None,
rustup_home: None,
cargo_home: None,
cargo_path: "cargo".to_owned().into(),
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(),
}
))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--ignore-features".to_owned().into(),
"a,,b".to_owned().into(),
]
.into_iter()
),
Ok(MetaCmd::Cargo(
Cmd::Check(CheckClippyTargets::Default),
Opts {
exec_dir: None,
rustup_home: None,
cargo_home: None,
cargo_path: "cargo".to_owned().into(),
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!["a".to_owned(), String::new(), "b".to_owned()],
}
))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--ignore-features".to_owned().into(),
"a,b,".to_owned().into(),
]
.into_iter()
),
Ok(MetaCmd::Cargo(
Cmd::Check(CheckClippyTargets::Default),
Opts {
exec_dir: None,
rustup_home: None,
cargo_home: None,
cargo_path: "cargo".to_owned().into(),
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!["a".to_owned(), "b".to_owned(), String::new()],
}
))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--ignore-features".to_owned().into(),
"a,b".to_owned().into(),
]
.into_iter()
),
Ok(MetaCmd::Cargo(
Cmd::Check(CheckClippyTargets::Default),
Opts {
exec_dir: None,
rustup_home: None,
cargo_home: None,
cargo_path: "cargo".to_owned().into(),
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!["a".to_owned(), "b".to_owned()],
}
))
);
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"check".to_owned().into(),
"--ignore-features".to_owned().into(),
"a , , b, ".to_owned().into(),
]
.into_iter()
),
Ok(MetaCmd::Cargo(
Cmd::Check(CheckClippyTargets::Default),
Opts {
exec_dir: None,
rustup_home: None,
cargo_home: None,
cargo_path: "cargo".to_owned().into(),
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![
"a ".to_owned(),
" ".to_owned(),
" b".to_owned(),
" ".to_owned()
],
}
))
);
assert_eq!(
MetaCmd::from_args([OsString::new(), "help".to_owned().into(),].into_iter()),
Ok(MetaCmd::Help)
);
assert_eq!(
MetaCmd::from_args([OsString::new(), "version".to_owned().into(),].into_iter()),
Ok(MetaCmd::Version)
);
let mut check_targets = Targets::new(Target::Examples);
assert!(check_targets.add(Target::Tests));
assert!(!check_targets.add(Target::Examples));
let mut test_targets = Targets::new(Target::Benches);
assert!(test_targets.add(Target::Bins));
assert!(!test_targets.add(Target::Bins));
assert!(test_targets.add(Target::Examples));
assert!(test_targets.add(Target::Lib));
assert!(test_targets.add(Target::Tests));
assert_eq!(
MetaCmd::from_args(
[
OsString::new(),
"clippy".to_owned().into(),
"--all-targets".to_owned().into(),
"--allow-implied-features".to_owned().into(),
"--cargo-home".to_owned().into(),
"--ignored".to_owned().into(),
"--cargo-path".to_owned().into(),
"cargo".to_owned().into(),
"--color".to_owned().into(),
"--default-toolchain".to_owned().into(),
"--deny-warnings".to_owned().into(),
"--dir".to_owned().into(),
OsString::new(),
"--ignore-compile-errors".to_owned().into(),
"--ignore-features".to_owned().into(),
",a".to_owned().into(),
"--ignore-msrv".to_owned().into(),
"--rustup-home".to_owned().into(),
"a".to_owned().into(),
"test".to_owned().into(),
"--benches".to_owned().into(),
"--bins".to_owned().into(),
"--examples".to_owned().into(),
"--include-ignored".to_owned().into(),
"--lib".to_owned().into(),
"--tests".to_owned().into(),
"--progress".to_owned().into(),
"--skip-msrv".to_owned().into(),
"check".to_owned().into(),
"--tests".to_owned().into(),
"--examples".to_owned().into(),
"--summary".to_owned().into(),
]
.into_iter()
),
Ok(MetaCmd::Cargo(
Cmd::CheckClippyTest(
CheckClippyTargets::Targets(check_targets),
CheckClippyTargets::All,
true,
TestTargets::Targets(test_targets),
Ignored::Include,
),
Opts {
exec_dir: Some(PathBuf::new()),
rustup_home: Some("a".to_owned().into()),
cargo_home: Some("--ignored".to_owned().into()),
cargo_path: "cargo/cargo".to_owned().into(),
color: true,
default_toolchain: true,
allow_implied_features: true,
ignore_compile_errors: true,
ignore_msrv: true,
progress: true,
skip_msrv: true,
summary: true,
ignore_features: vec![String::new(), "a".to_owned()],
}
))
);
}
#[test]
fn non_zero_usize_plus_1() {
#[cfg(target_pointer_width = "64")]
assert_eq!(NonZeroUsizePlus1(0).to_string(), "18446744073709551616");
#[cfg(target_pointer_width = "64")]
assert_eq!(
NonZeroUsizePlus1(usize::MAX).to_string(),
"18446744073709551615"
);
#[cfg(target_pointer_width = "32")]
assert_eq!(NonZeroUsizePlus1(0).to_string(), "4294967296");
#[cfg(target_pointer_width = "32")]
assert_eq!(NonZeroUsizePlus1(usize::MAX).to_string(), "4294967295");
#[cfg(target_pointer_width = "16")]
assert_eq!(NonZeroUsizePlus1(0).to_string(), "65536");
#[cfg(target_pointer_width = "16")]
assert_eq!(NonZeroUsizePlus1(usize::MAX).to_string(), "65535");
assert_eq!(NonZeroUsizePlus1(1).to_string(), "1");
assert_eq!(NonZeroUsizePlus1(2).to_string(), "2");
assert_eq!(NonZeroUsizePlus1(10).to_string(), "10");
}
}