fix: remove profile arg, exe check, add rustup check

Author: yaahc

src/bin/cargo/commands/clippy.rs

@@ -4,8 +4,6 @@ use cargo::ops;
 
 pub fn cli() -> App {
     subcommand("clippy-preview")
-        // subcommand aliases are handled in aliased_command()
-        // .alias("c")
         .about("Checks a package to catch common mistakes and improve your Rust code.")
         .arg_package_spec(
             "Package(s) to check",
@@ -26,7 +24,6 @@ pub fn cli() -> App {
             "Check all targets",
         )
         .arg_release("Check artifacts in release mode, with optimizations")
-        .arg(opt("profile", "Profile to build the selected target for").value_name("PROFILE"))
         .arg_features()
         .arg_target_triple("Check for the target triple")
         .arg_target_dir()
@@ -43,13 +40,6 @@ All packages in the workspace are checked if the `--all` flag is supplied. The
 `--all` flag is automatically assumed for a virtual manifest.
 Note that `--exclude` has to be specified in conjunction with the `--all` flag.
 
-Compilation can be configured via the use of profiles which are configured in
-the manifest. The default profile for this command is `dev`, but passing
-the `--release` flag will use the `release` profile instead.
-
-The `--profile test` flag can be used to check unit tests with the
-`#[cfg(test)]` attribute.
-
 To allow or deny a lint from the command line you can use `cargo clippy --`
 with:
 
@@ -68,20 +58,8 @@ You can use tool lints to allow or deny lints from your code, eg.:
 pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
     config.set_clippy_override(true);
     let ws = args.workspace(config)?;
-    let test = match args.value_of("profile") {
-        Some("test") => true,
-        None => false,
-        Some(profile) => {
-            let err = failure::format_err!(
-                "unknown profile: `{}`, only `test` is \
-                 currently supported",
-                profile
-            );
-            return Err(CliError::new(err, 101));
-        }
-    };
 
-    let mode = CompileMode::Check { test };
+    let mode = CompileMode::Check { test: false };
     let compile_opts = args.compile_options(config, mode, Some(&ws))?;
 
     if !config.cli_unstable().unstable_options {

src/bin/cargo/main.rs

@@ -7,10 +7,9 @@
 use std::collections::BTreeSet;
 use std::env;
 use std::fs;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use cargo::core::shell::Shell;
-use cargo::util::paths::is_executable;
 use cargo::util::{self, command_prelude, lev_distance, CargoResult, CliResult, Config};
 use cargo::util::{CliError, ProcessError};
 
@@ -165,6 +164,20 @@ fn execute_external_subcommand(config: &Config, cmd: &str, args: &[&str]) -> Cli
     Err(CliError::new(err, 101))
 }
 
+#[cfg(unix)]
+fn is_executable<P: AsRef<Path>>(path: P) -> bool {
+    use std::os::unix::prelude::*;
+    fs::metadata(path)
+        .map(|metadata| metadata.is_file() && metadata.permissions().mode() & 0o111 != 0)
+        .unwrap_or(false)
+}
+#[cfg(windows)]
+fn is_executable<P: AsRef<Path>>(path: P) -> bool {
+    fs::metadata(path)
+        .map(|metadata| metadata.is_file())
+        .unwrap_or(false)
+}
+
 fn search_directories(config: &Config) -> Vec<PathBuf> {
     let mut dirs = vec![config.home().clone().into_path_unlocked().join("bin")];
     if let Some(val) = env::var_os("PATH") {

src/cargo/util/config.rs

@@ -208,13 +208,17 @@ impl Config {
         let wrapper = if self.clippy_override {
             let tool = self.get_tool("clippy-driver")?;
             let tool = paths::resolve_executable(&tool).map_err(|e| {
-                failure::format_err!("{}: please run `rustup component add clippy`", e)
+                let rustup_in_path = self
+                    .get_tool("rustup")
+                    .and_then(|tool| paths::resolve_executable(&tool))
+                    .is_ok();
+                let has_rustup_env = std::env::var("RUSTUP_TOOLCHAIN").is_ok();
+                if dbg!(rustup_in_path) || dbg!(has_rustup_env) {
+                    failure::format_err!("{}: please run `rustup component add clippy`", e)
+                } else {
+                    failure::format_err!("{}: please install clippy component", e)
+                }
             })?;
-            if !paths::is_executable(&tool) {
-                return Err(failure::format_err!(
-                    "found file for `clippy-driver` but its not an executable. what the heck is going on !? please run `rustup component add clippy`"
-                ));
-            }
             Some(tool)
         } else {
             self.maybe_get_tool("rustc-wrapper")?

src/cargo/util/paths.rs

@@ -89,20 +89,6 @@ pub fn normalize_path(path: &Path) -> PathBuf {
     ret
 }
 
-#[cfg(unix)]
-pub fn is_executable<P: AsRef<Path>>(path: P) -> bool {
-    use std::os::unix::prelude::*;
-    fs::metadata(path)
-        .map(|metadata| metadata.is_file() && metadata.permissions().mode() & 0o111 != 0)
-        .unwrap_or(false)
-}
-#[cfg(windows)]
-pub fn is_executable<P: AsRef<Path>>(path: P) -> bool {
-    fs::metadata(path)
-        .map(|metadata| metadata.is_file())
-        .unwrap_or(false)
-}
-
 pub fn resolve_executable(exec: &Path) -> CargoResult<PathBuf> {
     if exec.components().count() == 1 {
         let paths = env::var_os("PATH").ok_or_else(|| failure::format_err!("no PATH"))?;