Add clippy task

This commit also adds a method, `Toolchain::install_rustup_component` to
install a rustup componenet on the given toolchain.

Author: ecstatic-morse

src/experiments.rs

@@ -21,6 +21,7 @@ string_enum!(pub enum Mode {
     BuildAndTest => "build-and-test",
     BuildOnly => "build-only",
     CheckOnly => "check-only",
+    Clippy => "clippy",
     Rustdoc => "rustdoc",
     UnstableFeatures => "unstable-features",
 });

src/runner/graph.rs

@@ -266,6 +266,10 @@ pub(super) fn build_graph(ex: &Experiment, config: &Config) -> TasksGraph {
                             tc: tc.clone(),
                             quiet,
                         },
+                        Mode::Clippy => TaskStep::Clippy {
+                            tc: tc.clone(),
+                            quiet,
+                        },
                         Mode::Rustdoc => TaskStep::Rustdoc {
                             tc: tc.clone(),
                             quiet,

src/runner/mod.rs

@@ -8,7 +8,7 @@ mod unstable_features;
 use crate::config::Config;
 use crate::crates::Crate;
 use crate::docker::DockerEnv;
-use crate::experiments::Experiment;
+use crate::experiments::{Experiment, Mode};
 use crate::logs::LogStorage;
 use crate::prelude::*;
 use crate::results::{FailureReason, TestResult, WriteResults};
@@ -87,6 +87,9 @@ fn run_ex_inner<DB: WriteResults + Sync>(
     info!("preparing the execution...");
     for tc in &ex.toolchains {
         tc.prepare()?;
+        if ex.mode == Mode::Clippy {
+            tc.install_rustup_component("clippy")?;
+        }
     }
 
     info!("running tasks in {} threads...", threads_count);

src/runner/tasks.rs

@@ -54,42 +54,30 @@ pub(super) enum TaskStep {
     BuildAndTest { tc: Toolchain, quiet: bool },
     BuildOnly { tc: Toolchain, quiet: bool },
     CheckOnly { tc: Toolchain, quiet: bool },
+    Clippy { tc: Toolchain, quiet: bool },
     Rustdoc { tc: Toolchain, quiet: bool },
     UnstableFeatures { tc: Toolchain },
 }
 
 impl fmt::Debug for TaskStep {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            TaskStep::Prepare => write!(f, "prepare")?,
-            TaskStep::Cleanup => write!(f, "cleanup")?,
-            TaskStep::BuildAndTest { ref tc, quiet } => {
-                write!(f, "build and test {}", tc.to_string())?;
-                if quiet {
-                    write!(f, " (quiet)")?;
-                }
-            }
-            TaskStep::BuildOnly { ref tc, quiet } => {
-                write!(f, "build {}", tc.to_string())?;
-                if quiet {
-                    write!(f, " (quiet)")?;
-                }
-            }
-            TaskStep::CheckOnly { ref tc, quiet } => {
-                write!(f, "check {}", tc.to_string())?;
-                if quiet {
-                    write!(f, " (quiet)")?;
-                }
-            }
-            TaskStep::Rustdoc { ref tc, quiet } => {
-                write!(f, "doc {}", tc.to_string())?;
-                if quiet {
-                    write!(f, " (quiet)")?;
-                }
-            }
-            TaskStep::UnstableFeatures { ref tc } => {
-                write!(f, "find unstable features on {}", tc.to_string())?;
-            }
+        let (name, quiet, tc) = match *self {
+            TaskStep::Prepare => ("prepare", false, None),
+            TaskStep::Cleanup => ("cleanup", false, None),
+            TaskStep::BuildAndTest { ref tc, quiet } => ("build and test", quiet, Some(tc)),
+            TaskStep::BuildOnly { ref tc, quiet } => ("build", quiet, Some(tc)),
+            TaskStep::CheckOnly { ref tc, quiet } => ("check", quiet, Some(tc)),
+            TaskStep::Clippy { ref tc, quiet } => ("clippy", quiet, Some(tc)),
+            TaskStep::Rustdoc { ref tc, quiet } => ("doc", quiet, Some(tc)),
+            TaskStep::UnstableFeatures { ref tc } => ("find unstable features on", false, Some(tc)),
+        };
+
+        write!(f, "{}", name)?;
+        if let Some(tc) = tc {
+            write!(f, " {}", tc.to_string())?;
+        }
+        if quiet {
+            write!(f, " (quiet)")?;
         }
         Ok(())
     }
@@ -120,6 +108,7 @@ impl Task {
             TaskStep::BuildAndTest { ref tc, .. }
             | TaskStep::BuildOnly { ref tc, .. }
             | TaskStep::CheckOnly { ref tc, .. }
+            | TaskStep::Clippy { ref tc, .. }
             | TaskStep::Rustdoc { ref tc, .. }
             | TaskStep::UnstableFeatures { ref tc } => {
                 db.get_result(ex, tc, &self.krate).unwrap_or(None).is_none()
@@ -141,6 +130,7 @@ impl Task {
             TaskStep::BuildAndTest { ref tc, .. }
             | TaskStep::BuildOnly { ref tc, .. }
             | TaskStep::CheckOnly { ref tc, .. }
+            | TaskStep::Clippy { ref tc, .. }
             | TaskStep::Rustdoc { ref tc, .. }
             | TaskStep::UnstableFeatures { ref tc } => {
                 let log_storage = state
@@ -199,6 +189,10 @@ impl Task {
                 let ctx = TaskCtx::new(config, db, ex, tc, &self.krate, docker_env, state, quiet);
                 test::run_test("checking", &ctx, test::test_check_only)?;
             }
+            TaskStep::Clippy { ref tc, quiet } => {
+                let ctx = TaskCtx::new(config, db, ex, tc, &self.krate, docker_env, state, quiet);
+                test::run_test("linting", &ctx, test::test_clippy_only)?;
+            }
             TaskStep::Rustdoc { ref tc, quiet } => {
                 let ctx = TaskCtx::new(config, db, ex, tc, &self.krate, docker_env, state, quiet);
                 test::run_test("documenting", &ctx, test::test_rustdoc)?;

src/runner/test.rs

@@ -151,6 +151,21 @@ pub(super) fn test_check_only<DB: WriteResults>(
     }
 }
 
+pub(super) fn test_clippy_only<DB: WriteResults>(
+    ctx: &TaskCtx<DB>,
+    source_path: &Path,
+) -> Fallible<TestResult> {
+    if let Err(err) = run_cargo(
+        ctx,
+        source_path,
+        &["clippy", "--frozen", "--all", "--all-targets"],
+    ) {
+        Ok(TestResult::BuildFail(failure_reason(&err)))
+    } else {
+        Ok(TestResult::TestPass)
+    }
+}
+
 pub(super) fn test_rustdoc<DB: WriteResults>(
     ctx: &TaskCtx<DB>,
     source_path: &Path,

src/server/routes/ui/experiments.rs

@@ -38,6 +38,7 @@ impl ExperimentData {
                 Mode::BuildAndTest => "cargo test",
                 Mode::BuildOnly => "cargo build",
                 Mode::CheckOnly => "cargo check",
+                Mode::Clippy => "cargo clippy",
                 Mode::Rustdoc => "cargo doc",
                 Mode::UnstableFeatures => "unstable features",
             },

src/toolchain.rs

@@ -71,6 +71,27 @@ impl Toolchain {
         }
     }
 
+    pub fn install_rustup_component(&self, component: &str) -> Fallible<()> {
+        let toolchain_name = &self.rustup_name();
+        info!(
+            "installing component {} for toolchain {}",
+            component, toolchain_name
+        );
+
+        utils::try_hard(|| {
+            RunCommand::new(&RUSTUP)
+                .args(&["component", "add", "--toolchain", toolchain_name, component])
+                .run()
+                .with_context(|_| {
+                    format!(
+                        "unable to install component {} for toolchain {} via rustup",
+                        component, toolchain_name,
+                    )
+                })
+        })?;
+        Ok(())
+    }
+
     pub fn target_dir(&self, ex_name: &str) -> PathBuf {
         let mut dir = ex_target_dir(ex_name);