ci-cargo

cargo.rs (33718B)

---

 use super::{args::Ignored, manifest};
 use std::{
     collections::HashSet,
     io::{Error, StderrLock, Write as _},
     path::{Path, PathBuf},
     process::{Command, Stdio},
 };
 /// Error returned from [`Toolchain::get_version`].
 pub(crate) enum ToolchainErr {
     /// [`Command::output`] erred with the contained `Error` for the contained `Command`.
     CommandFail(Command, Error),
     /// [`Command::output`] was successful for the contained `Command`, but it didn't return a status code.
     ///
     /// The contained `String` is the potentially empty content written to `stderr`.
     CommandNoStatus(Command, String),
     /// [`Command::output`] was successful for the contained `Command`, but it returned an error status code
     /// represented by the contained `i32`.
     ///
     /// The contained `String` is the potentially empty content written to `stderr`.
     CommandErr(Command, String, i32),
     /// [`Command::output`] was successful for the contained `Command`, but the data it wrote to `stdout` was not
     /// valid UTF-8.
     StdoutNotUtf8(Command),
     /// [`Command::output`] was successful for the contained `Command`, but the data it wrote to `stderr` was not
     /// valid UTF-8.
     StderrNotUtf8(Command),
     /// [`Command::output`] was successful for the contained `Command`, but the non-empty data it wrote to
     /// `stdout` was unexpected.
     ///
     /// The contained `String` is the unexpected data.
     UnexpectedOutput(Command, String),
     /// The parsed MSRV value is newer than `stable` or the default toolchain.
     MsrvTooHigh,
     /// Error when `cargo +<MSRV> -V` returns a version not compatible with the defined MSRV.
     ///
     /// The contained `Version` is the installed MSRV.
     MsrvNotCompatibleWithInstalledMsrv(Version),
 }
 impl ToolchainErr {
     /// Writes `self` to `stderr`.
     pub(crate) fn write(self, mut stderr: StderrLock<'_>) -> Result<(), Error> {
         match self {
             Self::CommandFail(cmd, err) => stderr
                 .write_all(cmd.get_program().to_string_lossy().as_bytes())
                 .and_then(|()| {
                     cmd.get_args().try_fold((), |(), arg| {
                         stderr.write_all(b" ").and_then(|()| {
                             stderr
                                 .write_all(arg.to_string_lossy().as_bytes())
                         })
                     }).and_then(|()| writeln!(stderr, " erred: {err}"))
                 }),
             Self::CommandNoStatus(cmd, err) => stderr
                 .write_all(cmd.get_program().to_string_lossy().as_bytes())
                 .and_then(|()| {
                     cmd.get_args().try_fold((), |(), arg| {
                         stderr.write_all(b" ").and_then(|()| {
                             stderr
                                 .write_all(arg.to_string_lossy().as_bytes())
                         })
                     }).and_then(|()| {
                         if err.is_empty() {
                             writeln!(stderr, " did not return a status code and didn't write anything to stderr.")
                         } else {
                             writeln!(stderr, " did not return a status code but wrote the following to stderr: {err}")
                         }
                     })
                 }),
             Self::CommandErr(cmd, err, status) => stderr
                 .write_all(cmd.get_program().to_string_lossy().as_bytes())
                 .and_then(|()| {
                     cmd.get_args().try_fold((), |(), arg| {
                         stderr.write_all(b" ").and_then(|()| {
                             stderr
                                 .write_all(arg.to_string_lossy().as_bytes())
                         })
                     }).and_then(|()| {
                         if err.is_empty() {
                             writeln!(stderr, " returned status code {status} but didn't write anything to stderr.")
                         } else {
                             writeln!(stderr, " returned status code {status} and wrote the following to stderr: {err}")
                         }
                     })
                 }),
             Self::StdoutNotUtf8(cmd) => stderr
                 .write_all(cmd.get_program().to_string_lossy().as_bytes())
                 .and_then(|()| {
                     cmd.get_args().try_fold((), |(), arg| {
                         stderr.write_all(b" ").and_then(|()| {
                             stderr
                                 .write_all(arg.to_string_lossy().as_bytes())
                         })
                     }).and_then(|()| writeln!(stderr, " wrote invalid UTF-8 to stdout."))
                 }),
             Self::StderrNotUtf8(cmd) => stderr
                 .write_all(cmd.get_program().to_string_lossy().as_bytes())
                 .and_then(|()| {
                     cmd.get_args().try_fold((), |(), arg| {
                         stderr.write_all(b" ").and_then(|()| {
                             stderr
                                 .write_all(arg.to_string_lossy().as_bytes())
                         })
                     }).and_then(|()| writeln!(stderr, " wrote invalid UTF-8 to stderr."))
                 }),
             Self::UnexpectedOutput(cmd, output) => stderr
                 .write_all(cmd.get_program().to_string_lossy().as_bytes())
                 .and_then(|()| {
                     cmd.get_args().try_fold((), |(), arg| {
                         stderr.write_all(b" ").and_then(|()| {
                             stderr
                                 .write_all(arg.to_string_lossy().as_bytes())
                         })
                     }).and_then(|()| writeln!(stderr, " wrote the following unexpected data to stdout: {output}"))
                 }),
             Self::MsrvTooHigh => writeln!(stderr, "MSRV is higher than cargo stable."),
             Self::MsrvNotCompatibleWithInstalledMsrv(version)=> writeln!(stderr, "cargo +<MSRV> -V returned '{}.{}.{}' which is inconsistent with the defined MSRV.", version.major, version.minor, version.patch),
         }
     }
 }
 /// Error returned when running any `cargo` command.
 pub(crate) enum CargoErr {
     /// [`Command::output`] erred with the contained `Error` for the contained `Command`.
     CommandFail(Command, Error),
     /// [`Command::output`] was successful for the contained `Command`, but it didn't return a status code.
     ///
     /// The first contained `String` is the potentially empty content written to `stderr`, and the second
     /// `String` is the potentially empty content written to `stdout`.
     CommandNoStatus(Command, String, String),
     /// [`Command::output`] was successful for the contained `Command`, but it returned an error status code.
     ///
     /// The first contained `String` is the potentially empty content written to `stderr`, and the second
     /// `String` is the potentially empty content written to `stdout`.
     CommandErr(Command, String, String),
     /// [`Command::output`] was successful for the contained `Command`, but the data it wrote to `stdout` was not
     /// valid UTF-8.
     StdoutNotUtf8(Command),
     /// [`Command::output`] was successful for the contained `Command`, but the data it wrote to `stderr` was not
     /// valid UTF-8.
     StderrNotUtf8(Command),
     /// [`Command::output`] was successful for the contained `Command`, but a `compile_error` occurred for the
     /// `"default"` feature.
     CompileErrDefault(Command),
     /// [`Command::output`] was successful for the contained `Command`, but a `compile_error` occurred when
     /// no features were enabled and when there isn't a `"default"` feature defined.
     CompileErrNoFeatures(Command),
 }
 impl CargoErr {
     /// Writes `self` to `stderr`.
     pub(crate) fn write(self, mut stderr: StderrLock<'_>) -> Result<(), Error> {
         match self {
             Self::CommandFail(cmd, err) => writeln!(stderr, "{err}").map(|()| cmd),
             Self::CommandNoStatus(cmd, err, out) => if out.is_empty() {
                 Ok(())
             } else {
                 writeln!(stderr, "{out}")
             }
             .and_then(|()| {
                 if err.is_empty() {
                     writeln!(stderr, "Missing status code and nothing written to stderr.")
                 } else {
                     writeln!(
                         stderr,
                         "Missing status code, but the following was written to stderr: {err}"
                     )
                 }
                 .map(|()| cmd)
             }),
             Self::CommandErr(cmd, err, out) => if out.is_empty() {
                 Ok(())
             } else {
                 writeln!(stderr, "{out}")
             }
             .and_then(|()| {
                 if err.is_empty() {
                     Ok(cmd)
                 } else {
                     writeln!(stderr, "{err}").map(|()| cmd)
                 }
             }),
             Self::StdoutNotUtf8(cmd) => {
                 writeln!(stderr, "Invalid UTF-8 written to stdout.").map(|()| cmd)
             }
             Self::StderrNotUtf8(cmd) => {
                 writeln!(stderr, "Invalid UTF-8 written to stderr.").map(|()| cmd)
             }
             Self::CompileErrDefault(cmd) => {
                 writeln!(stderr, "compile_error! raised on default feature.").map(|()| cmd)
             }
             Self::CompileErrNoFeatures(cmd) => writeln!(
                 stderr,
                 "compile_error! raised with no features when a default feature does not exist."
             )
             .map(|()| cmd),
         }
         .and_then(|cmd| {
             stderr
                 .write_all(cmd.get_program().to_string_lossy().as_bytes())
                 .and_then(|()| {
                     cmd.get_args()
                         .try_fold((), |(), arg| {
                             stderr
                                 .write_all(b" ")
                                 .and_then(|()| stderr.write_all(arg.to_string_lossy().as_bytes()))
                         })
                         .and_then(|()| writeln!(stderr))
                 })
         })
     }
 }
 /// Compiler version.
 #[cfg_attr(test, derive(PartialEq))]
 pub(crate) struct Version {
     /// Major version.
     pub major: u64,
     /// Minor version.
     pub minor: u64,
     /// Patch version.
     pub patch: u64,
 }
 /// `"+stable"`.
 const PLUS_STABLE: &str = "+stable";
 /// `"RUSTUP_HOME"`.
 const RUSTUP_HOME: &str = "RUSTUP_HOME";
 /// `"CARGO_HOME"`.
 const CARGO_HOME: &str = "CARGO_HOME";
 /// Toolchain to use.
 #[expect(
     variant_size_differences,
     reason = "fine. This doesn't get triggered if the other variants were unit variants despite Toolchain being the same size."
 )]
 #[derive(Clone, Copy)]
 pub(crate) enum Toolchain<'a> {
     /// `cargo +stable`.
     Stable,
     /// `cargo`.
     ///
     /// Contained `bool` is `true` iff `--ignore-rust-version` should be passed.
     Default(bool),
     /// `cargo +<MSRV>`.
     Msrv(&'a str),
 }
 impl Toolchain<'_> {
     /// Extracts the compiler version from `stdout`
     ///
     /// This must only be called by [`Self::get_version`].
     #[expect(unsafe_code, reason = "comments justify correctness")]
     fn parse_stdout(cmd: Command, stdout: Vec<u8>) -> Result<Version, Box<ToolchainErr>> {
         /// `"cargo "`.
         const CARGO: &[u8; 6] = b"cargo ";
         if let Ok(utf8) = String::from_utf8(stdout) {
             utf8.as_bytes()
                 .split_at_checked(CARGO.len())
                 .and_then(|(pref, rem)| {
                     if pref == CARGO {
                         let mut iter = rem.split(|b| *b == b'.');
                         if let Some(fst) = iter.next()
                             // SAFETY:
                             // Original input was a `str`, and we split on a single-byte
                             // UTF-8 code unit.
                             && let Ok(major) = manifest::parse_int(unsafe {
                                 str::from_utf8_unchecked(fst)
                             })
                             && let Some(snd) = iter.next()
                             // SAFETY:
                             // Original input was a `str`, and we split on a single-byte
                             // UTF-8 code unit.
                             && let Ok(minor) = manifest::parse_int(unsafe {
                                 str::from_utf8_unchecked(snd)
                             })
                             && let Some(lst) = iter.next()
                             && iter.next().is_none()
                             && let Some(lst_fst) = lst.split(|b| *b == b' ').next()
                             // SAFETY:
                             // Original input was a `str`, and we split on a single-byte
                             // UTF-8 code unit.
                             && let Ok(patch) = manifest::parse_int(unsafe {
                                 str::from_utf8_unchecked(lst_fst)
                             })
                         {
                             Some(Version {
                                 major,
                                 minor,
                                 patch,
                             })
                         } else {
                             None
                         }
                     } else {
                         None
                     }
                 })
                 .ok_or_else(|| Box::new(ToolchainErr::UnexpectedOutput(cmd, utf8)))
         } else {
             Err(Box::new(ToolchainErr::StdoutNotUtf8(cmd)))
         }
     }
     /// Returns the version.
     pub(crate) fn get_version(
         self,
         rustup_home: Option<&Path>,
         cargo_path: &Path,
         cargo_home: Option<&Path>,
     ) -> Result<Version, Box<ToolchainErr>> {
         let mut cmd = Command::new(cargo_path);
         if let Some(env) = rustup_home {
             _ = cmd.env(RUSTUP_HOME, env);
         }
         if let Some(env) = cargo_home {
             _ = cmd.env(CARGO_HOME, env);
         }
         match self {
             Self::Stable => {
                 _ = cmd.arg(PLUS_STABLE);
             }
             Self::Default(_) => {}
             Self::Msrv(val) => {
                 _ = cmd.arg(val);
             }
         }
         match cmd
             .arg("-V")
             .stderr(Stdio::piped())
             .stdin(Stdio::null())
             .stdout(Stdio::piped())
             .output()
         {
             Ok(output) => {
                 if let Some(status_code) = output.status.code() {
                     if status_code == 0i32 {
                         Self::parse_stdout(cmd, output.stdout)
                     } else if let Ok(err) = String::from_utf8(output.stderr) {
                         Err(Box::new(ToolchainErr::CommandErr(cmd, err, status_code)))
                     } else {
                         Err(Box::new(ToolchainErr::StderrNotUtf8(cmd)))
                     }
                 } else if let Ok(err) = String::from_utf8(output.stderr) {
                     Err(Box::new(ToolchainErr::CommandNoStatus(cmd, err)))
                 } else {
                     Err(Box::new(ToolchainErr::StderrNotUtf8(cmd)))
                 }
             }
             Err(e) => Err(Box::new(ToolchainErr::CommandFail(cmd, e))),
         }
     }
 }
 /// `"-p"`.
 const DASH_P: &str = "-p";
 /// `"-q"`.
 const DASH_Q: &str = "-q";
 /// `"--color"`.
 const DASH_DASH_COLOR: &str = "--color";
 /// `"always"`.
 const ALWAYS: &str = "always";
 /// `"never"`.
 const NEVER: &str = "never";
 /// `"--no-default-features"`.
 const DASH_DASH_NO_DEFAULT_FEATURES: &str = "--no-default-features";
 /// `"--features"`.
 const DASH_DASH_FEATURES: &str = "--features";
 /// `"--"`.
 const DASH_DASH: &str = "--";
 /// `"default"`.
 const DEFAULT: &str = "default";
 /// `"--ignore-rust-version"`.
 const DASH_DASH_IGNORE_RUST_VERSION: &str = "--ignore-rust-version";
 /// Common options to pass to [`Clippy::run`] and [`Tests::run`].
 pub(crate) struct Options<'toolchain, 'package, 'errs> {
     /// The `cargo` toolchain to use.
     pub toolchain: Toolchain<'toolchain>,
     /// The path to the `rustup` storage directory.
     pub rustup_home: Option<PathBuf>,
     /// The path to `cargo`.
     pub cargo_path: PathBuf,
     /// The path to the `cargo` storage directory.
     pub cargo_home: Option<PathBuf>,
     /// Name of the package.
     pub package_name: &'package str,
     /// `true` iff color should be written to `stdout` and `stderr`.
     pub color: bool,
     /// `true` iff `compile_error`s should be ignored.
     pub ignore_compile_errors: bool,
     /// `true` iff a feature named `"default"` exists.
     pub default_feature_does_not_exist: bool,
     /// Hash set of non-terminating errors to be written at the very end.
     pub non_terminating_errors: &'errs mut HashSet<String>,
 }
 /// Executes `cmd`.
 ///
 /// Returns `true` iff a no-library target error occurred and `doc_only` was `true`.
 fn execute_command(
     mut cmd: Command,
     options: &mut Options<'_, '_, '_>,
     features: &str,
     doc_only: bool,
 ) -> Result<bool, Box<CargoErr>> {
     match cmd.stdout(Stdio::piped()).output() {
         Ok(output) => {
             if let Some(code) = output.status.code() {
                 match code {
                     0i32 => {
                         if !output.stderr.is_empty() {
                             _ = options.non_terminating_errors.insert(
                                 match String::from_utf8(output.stderr) {
                                     Ok(err) => err,
                                     Err(e) => e.to_string(),
                                 },
                             );
                         }
                         Ok(false)
                     }
                     101i32 => {
                         /// `"compile_error!"` as a byte string.
                         const COMPILE_ERROR: &[u8; 14] = b"compile_error!";
                         /// `"no library targets found in package"` as a byte string.
                         const NO_LIB_TARG: &[u8; 35] = b"no library targets found in package";
                         if output
                             .stderr
                             .windows(COMPILE_ERROR.len())
                             .any(|window| window == COMPILE_ERROR)
                         {
                             if options.ignore_compile_errors {
                                 if features == DEFAULT {
                                     Err(Box::new(CargoErr::CompileErrDefault(cmd)))
                                 } else if options.default_feature_does_not_exist
                                     && features.is_empty()
                                 {
                                     Err(Box::new(CargoErr::CompileErrNoFeatures(cmd)))
                                 } else {
                                     Ok(false)
                                 }
                             } else if let Ok(err) = String::from_utf8(output.stderr) {
                                 if let Ok(stdout) = String::from_utf8(output.stdout) {
                                     Err(Box::new(CargoErr::CommandErr(cmd, err, stdout)))
                                 } else {
                                     Err(Box::new(CargoErr::StdoutNotUtf8(cmd)))
                                 }
                             } else {
                                 Err(Box::new(CargoErr::StderrNotUtf8(cmd)))
                             }
                         } else if doc_only
                             && output
                                 .stderr
                                 .windows(NO_LIB_TARG.len())
                                 .any(|window| window == NO_LIB_TARG)
                         {
                             Ok(true)
                         } else if let Ok(err) = String::from_utf8(output.stderr) {
                             if let Ok(stdout) = String::from_utf8(output.stdout) {
                                 Err(Box::new(CargoErr::CommandErr(cmd, err, stdout)))
                             } else {
                                 Err(Box::new(CargoErr::StdoutNotUtf8(cmd)))
                             }
                         } else {
                             Err(Box::new(CargoErr::StderrNotUtf8(cmd)))
                         }
                     }
                     _ => {
                         if let Ok(err) = String::from_utf8(output.stderr) {
                             if let Ok(stdout) = String::from_utf8(output.stdout) {
                                 Err(Box::new(CargoErr::CommandErr(cmd, err, stdout)))
                             } else {
                                 Err(Box::new(CargoErr::StdoutNotUtf8(cmd)))
                             }
                         } else {
                             Err(Box::new(CargoErr::StderrNotUtf8(cmd)))
                         }
                     }
                 }
             } else if let Ok(err) = String::from_utf8(output.stderr) {
                 if let Ok(stdout) = String::from_utf8(output.stdout) {
                     Err(Box::new(CargoErr::CommandNoStatus(cmd, err, stdout)))
                 } else {
                     Err(Box::new(CargoErr::StdoutNotUtf8(cmd)))
                 }
             } else {
                 Err(Box::new(CargoErr::StderrNotUtf8(cmd)))
             }
         }
         Err(e) => Err(Box::new(CargoErr::CommandFail(cmd, e))),
     }
 }
 /// `cargo clippy`.
 pub(crate) struct Clippy;
 impl Clippy {
     /// Execute `cargo clippy`.
     ///
     /// Returns `false` iff the command ran successfully. Note this can only return `true` if
     /// [`Options::ignore_compile_errors`] is `true` since an error would be returned instead.
     #[expect(
         clippy::panic_in_result_fn,
         reason = "want to crash when there is a bug"
     )]
     pub(crate) fn run(
         options: &mut Options<'_, '_, '_>,
         all_targets: bool,
         deny_warnings: bool,
         features: &str,
     ) -> Result<(), Box<CargoErr>> {
         let mut c = Command::new(options.cargo_path.as_path());
         _ = c.stderr(Stdio::piped()).stdin(Stdio::null());
         if let Some(ref env) = options.rustup_home {
             _ = c.env(RUSTUP_HOME, env);
         }
         if let Some(ref env) = options.cargo_home {
             _ = c.env(CARGO_HOME, env);
         }
         let ignore_msrv = match options.toolchain {
             Toolchain::Stable => {
                 _ = c.arg(PLUS_STABLE);
                 false
             }
             Toolchain::Default(ignore_msrv) => ignore_msrv,
             Toolchain::Msrv(ref msrv) => {
                 _ = c.arg(msrv);
                 false
             }
         };
         _ = c
             .arg("clippy")
             .arg(DASH_P)
             .arg(options.package_name)
             .arg(DASH_Q);
         if all_targets {
             _ = c.arg("--all-targets");
         }
         if ignore_msrv {
             _ = c.arg(DASH_DASH_IGNORE_RUST_VERSION);
         }
         _ = c
             .arg(DASH_DASH_COLOR)
             .arg(if options.color { ALWAYS } else { NEVER })
             .arg(DASH_DASH_NO_DEFAULT_FEATURES);
         if !features.is_empty() {
             _ = c.arg(DASH_DASH_FEATURES).arg(features);
         }
         if deny_warnings {
             _ = c.arg(DASH_DASH).arg("-Dwarnings");
         }
         execute_command(c, options, features, false)
             .map(|no_library_target| assert!(!no_library_target, "there is a bug in cargo::execute_command since a no-library target error was returned when running Clippy."))
     }
 }
 /// What kind of test to run.
 #[derive(Clone, Copy)]
 pub(crate) enum TestKind {
     /// Both unit/integration and doc tests.
     All(Ignored),
     /// Only unit/integeration and doc tests.
     Unit(Ignored),
     /// Only doc tests.
     Doc,
 }
 /// `cargo test --tests/--doc`.
 pub(crate) struct Tests;
 impl Tests {
     /// Execute `cargo test`.
     ///
     /// Returns `true` iff only doc tests were run and a no-library error was returned.
     pub(crate) fn run(
         options: &mut Options<'_, '_, '_>,
         kind: TestKind,
         features: &str,
     ) -> Result<bool, Box<CargoErr>> {
         /// `"--ignored"`.
         const DASH_DASH_IGNORED: &str = "--ignored";
         /// `"--include-ignored"`.
         const DASH_DASH_INCLUDE_IGNORED: &str = "--include-ignored";
         let mut c = Command::new(options.cargo_path.as_path());
         _ = c.stderr(Stdio::piped()).stdin(Stdio::null());
         if let Some(ref env) = options.rustup_home {
             _ = c.env(RUSTUP_HOME, env);
         }
         if let Some(ref env) = options.cargo_home {
             _ = c.env(CARGO_HOME, env);
         }
         let ignore_msrv = match options.toolchain {
             Toolchain::Stable => {
                 _ = c.arg(PLUS_STABLE);
                 false
             }
             Toolchain::Default(ignore_msrv) => ignore_msrv,
             Toolchain::Msrv(ref msrv) => {
                 _ = c.arg(msrv);
                 false
             }
         };
         _ = c
             .arg("test")
             .arg(DASH_P)
             .arg(options.package_name)
             .arg(DASH_Q);
         if ignore_msrv {
             _ = c.arg(DASH_DASH_IGNORE_RUST_VERSION);
         }
         _ = c
             .arg(DASH_DASH_COLOR)
             .arg(if options.color { ALWAYS } else { NEVER })
             .arg(DASH_DASH_NO_DEFAULT_FEATURES);
         if !features.is_empty() {
             _ = c.arg(DASH_DASH_FEATURES).arg(features);
         }
         let mut doc_only = false;
         match kind {
             TestKind::All(ignore) => {
                 _ = c.arg(DASH_DASH).arg(DASH_DASH_COLOR).arg(if options.color {
                     ALWAYS
                 } else {
                     NEVER
                 });
                 match ignore {
                     Ignored::None => {}
                     Ignored::Only => {
                         _ = c.arg(DASH_DASH_IGNORED);
                     }
                     Ignored::Include => {
                         _ = c.arg(DASH_DASH_INCLUDE_IGNORED);
                     }
                 }
             }
             TestKind::Unit(ignore) => {
                 _ = c
                     .arg("--tests")
                     .arg(DASH_DASH)
                     .arg(DASH_DASH_COLOR)
                     .arg(if options.color { ALWAYS } else { NEVER });
                 match ignore {
                     Ignored::None => {}
                     Ignored::Only => {
                         _ = c.arg(DASH_DASH_IGNORED);
                     }
                     Ignored::Include => {
                         _ = c.arg(DASH_DASH_INCLUDE_IGNORED);
                     }
                 }
             }
             TestKind::Doc => {
                 doc_only = true;
                 _ = c
                     .arg("--doc")
                     .arg(DASH_DASH)
                     .arg(DASH_DASH_COLOR)
                     .arg(if options.color { ALWAYS } else { NEVER });
             }
         }
         execute_command(c, options, features, doc_only)
     }
 }
 /// `cargo check`.
 pub(crate) struct Check;
 impl Check {
     /// Execute `cargo check`.
     ///
     /// Returns `false` iff the command ran successfully. Note this can only return `true` if
     /// [`Options::ignore_compile_errors`] is `true` since an error would be returned instead.
     #[expect(
         clippy::panic_in_result_fn,
         reason = "want to crash when there is a bug"
     )]
     pub(crate) fn run(
         options: &mut Options<'_, '_, '_>,
         all_targets: bool,
         features: &str,
     ) -> Result<(), Box<CargoErr>> {
         let mut c = Command::new(options.cargo_path.as_path());
         _ = c.stderr(Stdio::piped()).stdin(Stdio::null());
         if let Some(ref env) = options.rustup_home {
             _ = c.env(RUSTUP_HOME, env);
         }
         if let Some(ref env) = options.cargo_home {
             _ = c.env(CARGO_HOME, env);
         }
         let ignore_msrv = match options.toolchain {
             Toolchain::Stable => {
                 _ = c.arg(PLUS_STABLE);
                 false
             }
             Toolchain::Default(ignore_msrv) => ignore_msrv,
             Toolchain::Msrv(ref msrv) => {
                 _ = c.arg(msrv);
                 false
             }
         };
         _ = c
             .arg("check")
             .arg(DASH_P)
             .arg(options.package_name)
             .arg(DASH_Q);
         if all_targets {
             _ = c.arg("--all-targets");
         }
         if ignore_msrv {
             _ = c.arg(DASH_DASH_IGNORE_RUST_VERSION);
         }
         _ = c
             .arg(DASH_DASH_COLOR)
             .arg(if options.color { ALWAYS } else { NEVER })
             .arg(DASH_DASH_NO_DEFAULT_FEATURES);
         if !features.is_empty() {
             _ = c.arg(DASH_DASH_FEATURES).arg(features);
         }
         execute_command(c, options, features, false)
             .map(|no_library_target| assert!(!no_library_target, "there is a bug in cargo::execute_command since a no-library target error was returned when running Check."))
     }
 }
 #[cfg(test)]
 mod tests {
     use super::{Command, Toolchain, ToolchainErr, Version};
     #[expect(clippy::cognitive_complexity, reason = "a lot of tests")]
     #[test]
     fn toolchain_parse() {
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), vec![255]), Err(e) if matches!(*e, ToolchainErr::StdoutNotUtf8(_)))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), Vec::new()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v.is_empty()))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.2".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.2"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.2.3.".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.2.3."))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.2.3a".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.2.3a"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b" cargo 1.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == " cargo 1.2.3"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"Cargo 1.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "Cargo 1.2.3"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.00.0".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.00.0"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.2.03".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.2.03"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo -1.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo -1.2.3"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo1.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo1.2.3"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo  1.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo  1.2.3"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo\t1.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo\t1.2.3"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1..3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1..3"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1."))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 111111111111111111111111.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 111111111111111111111111.2.3"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.2.3.4".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.2.3.4"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.2.3-nightly".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.2.3-nightly"))
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 18446744073709551615.18446744073709551615.18446744073709551615".to_vec()), Ok(v) if v == Version { major: u64::MAX, minor: u64::MAX, patch: u64::MAX, })
         );
         assert!(
             matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 0.0.0 asdflk 0023n0=lk0932(!@#V)\x00".to_vec()), Ok(v) if v == Version { major: 0, minor: 0, patch: 0, })
         );
     }
 }