Clippy locally

Author: blyxyas

collector/src/bin/collector.rs

@@ -375,6 +375,10 @@ struct CompileTimeOptions {
     /// The path to the local rustdoc to measure
     #[arg(long)]
     rustdoc: Option<PathBuf>,
+
+    /// The path to the local clippy to measure
+    #[arg(long)]
+    clippy: Option<PathBuf>
 }
 
 #[derive(Debug, clap::Args)]
@@ -663,6 +667,7 @@ fn main_result() -> anyhow::Result<i32> {
                     None,
                     None,
                     None,
+                    None,
                     id,
                     target_triple.clone(),
                 )?;
@@ -721,6 +726,7 @@ fn main_result() -> anyhow::Result<i32> {
                     None,
                     None,
                     None,
+                    None,
                     id,
                     target_triple.clone(),
                 )?;
@@ -757,6 +763,7 @@ fn main_result() -> anyhow::Result<i32> {
                 &profiles,
                 &local.rustc,
                 opts.rustdoc.as_deref(),
+                opts.clippy.as_deref(),
                 local.cargo.as_deref(),
                 local.id.as_deref(),
                 "",
@@ -949,6 +956,7 @@ fn main_result() -> anyhow::Result<i32> {
                         profiles,
                         rustc,
                         opts.rustdoc.as_deref(),
+                        opts.clippy.as_deref(),
                         local.cargo.as_deref(),
                         local.id.as_deref(),
                         suffix,
@@ -1063,6 +1071,7 @@ fn get_local_toolchain_for_runtime_benchmarks(
         &[Profile::Opt],
         &local.rustc,
         None,
+        None,
         local.cargo.as_deref(),
         local.id.as_deref(),
         "",

collector/src/bin/rustc-fake.rs

@@ -35,8 +35,11 @@ fn main() {
     let mut args = args_os.collect::<Vec<_>>();
     let rustc = env::var_os("RUSTC_REAL").unwrap();
     let actually_rustdoc = name.ends_with("rustdoc-fake");
+    let actually_clippy = name.ends_with("clippy-fake");
     let tool = if actually_rustdoc {
         env::var_os("RUSTDOC_REAL").unwrap()
+    } else if actually_clippy {
+        env::var_os("CLIPPY_REAL").unwrap()
     } else {
         rustc
     };

collector/src/compile/benchmark/profile.rs

@@ -12,13 +12,15 @@ pub enum Profile {
     Debug,
     Doc,
     Opt,
+    Clippy,
 }
 
 impl Profile {
     pub fn all() -> Vec<Self> {
-        vec![Profile::Check, Profile::Debug, Profile::Doc, Profile::Opt]
+        vec![Profile::Check, Profile::Debug, Profile::Doc, Profile::Opt, Profile::Clippy]
     }
 
+    // This also leaves Clippy out
     pub fn all_non_doc() -> Vec<Self> {
         vec![Profile::Check, Profile::Debug, Profile::Opt]
     }

collector/src/compile/execute/bencher.rs

@@ -87,6 +87,7 @@ impl<'a> BenchProcessor<'a> {
             Profile::Debug => database::Profile::Debug,
             Profile::Doc => database::Profile::Doc,
             Profile::Opt => database::Profile::Opt,
+            Profile::Clippy => database::Profile::Clippy,
         };
 
         if let Some(files) = stats.2 {

collector/src/compile/execute/mod.rs

@@ -72,7 +72,7 @@ impl PerfTool {
             }
             ProfileTool(LlvmLines) => match profile {
                 Profile::Debug | Profile::Opt => Some("llvm-lines"),
-                Profile::Check | Profile::Doc => None,
+                Profile::Check | Profile::Doc | Profile::Clippy => None,
             },
         }
     }
@@ -168,6 +168,10 @@ impl<'a> CargoProcess<'a> {
 
         if let Some(r) = &self.toolchain.components.rustdoc {
             cmd.env("RUSTDOC", &*FAKE_RUSTDOC).env("RUSTDOC_REAL", r);
+        };
+
+        if let Some(c) = &self.toolchain.components.clippy {
+            cmd.env("CLIPPY", &*FAKE_CLIPPY).env("CLIPPY_REAL", c);
         }
         cmd
     }
@@ -236,6 +240,7 @@ impl<'a> CargoProcess<'a> {
                 }
                 Profile::Debug => {}
                 Profile::Doc => {}
+                Profile::Clippy => {}
                 Profile::Opt => {
                     cmd.arg("--release");
                 }
@@ -354,6 +359,21 @@ lazy_static::lazy_static! {
         }
         fake_rustdoc
     };
+    static ref FAKE_CLIPPY: PathBuf = {
+        let mut fake_clippy = env::current_exe().unwrap();
+        fake_clippy.pop();
+        fake_clippy.push("clippy-fake");
+        // link from rustc-fake to rustdoc-fake
+        if !fake_clippy.exists() {
+            #[cfg(unix)]
+            use std::os::unix::fs::symlink;
+            #[cfg(windows)]
+            use std::os::windows::fs::symlink_file as symlink;
+
+            symlink(&*FAKE_RUSTC, &fake_clippy).expect("failed to make symbolic link");
+        }
+        fake_clippy
+    };
 }
 
 /// Used to indicate if we need to retry a run.

collector/src/toolchain.rs

@@ -123,6 +123,7 @@ impl SysrootDownload {
         let components = ToolchainComponents::from_binaries_and_libdir(
             sysroot_bin("rustc")?,
             Some(sysroot_bin("rustdoc")?),
+            Some(sysroot_bin("clippy")?),
             sysroot_bin("cargo")?,
             &self.directory.join(&self.rust_sha).join("lib"),
         )?;
@@ -241,6 +242,7 @@ impl Toolchain {
 pub struct ToolchainComponents {
     pub rustc: PathBuf,
     pub rustdoc: Option<PathBuf>,
+    pub clippy: Option<PathBuf>,
     pub cargo: PathBuf,
     pub lib_rustc: Option<PathBuf>,
     pub lib_std: Option<PathBuf>,
@@ -252,12 +254,14 @@ impl ToolchainComponents {
     fn from_binaries_and_libdir(
         rustc: PathBuf,
         rustdoc: Option<PathBuf>,
+        clippy: Option<PathBuf>,
         cargo: PathBuf,
         libdir: &Path,
     ) -> anyhow::Result<Self> {
         let mut component = ToolchainComponents {
             rustc,
             rustdoc,
+            clippy,
             cargo,
             ..Default::default()
         };
@@ -298,6 +302,7 @@ pub fn get_local_toolchain(
     profiles: &[Profile],
     rustc: &str,
     rustdoc: Option<&Path>,
+    clippy: Option<&Path>,
     cargo: Option<&Path>,
     id: Option<&str>,
     id_suffix: &str,
@@ -400,6 +405,26 @@ pub fn get_local_toolchain(
             None
         };
 
+        let clippy =
+        if let Some(clippy) = &clippy {
+            Some(clippy.canonicalize().with_context(|| {
+                format!("failed to canonicalize clippy executable {:?}", clippy)
+            })?)
+        } else if profiles.contains(&Profile::Clippy) {
+            // We need a `clippy`. Look for one next to `rustc`.
+            if let Ok(clippy) = rustc.with_file_name("cargo-clippy").canonicalize() {
+                debug!("found clippy: {:?}", &clippy);
+                Some(clippy)
+            } else {
+                anyhow::bail!(
+                    "'Clippy' build specified but '--clippy' not specified and no 'cargo-clippy' found \
+                    next to 'rustc'"
+                );
+            }
+        } else {
+            // No `clippy` provided, but none needed.
+            None
+        };
     let cargo = if let Some(cargo) = &cargo {
         cargo
             .canonicalize()
@@ -428,7 +453,7 @@ pub fn get_local_toolchain(
     let lib_dir = get_lib_dir_from_rustc(&rustc).context("Cannot find libdir for rustc")?;
 
     Ok(Toolchain {
-        components: ToolchainComponents::from_binaries_and_libdir(rustc, rustdoc, cargo, &lib_dir)?,
+        components: ToolchainComponents::from_binaries_and_libdir(rustc, rustdoc, clippy, cargo, &lib_dir)?,
         id,
         triple: target_triple,
     })
@@ -465,16 +490,18 @@ pub fn create_toolchain_from_published_version(
     };
     let rustc = which("rustc")?;
     let rustdoc = which("rustdoc")?;
+    let clippy = which("clippy")?;
     let cargo = which("cargo")?;
 
     debug!("Found rustc: {}", rustc.display());
     debug!("Found rustdoc: {}", rustdoc.display());
+    debug!("Found clippy: {}", clippy.display());
     debug!("Found cargo: {}", cargo.display());
 
     let lib_dir = get_lib_dir_from_rustc(&rustc)?;
 
     let components =
-        ToolchainComponents::from_binaries_and_libdir(rustc, Some(rustdoc), cargo, &lib_dir)?;
+        ToolchainComponents::from_binaries_and_libdir(rustc, Some(rustdoc), Some(clippy), cargo, &lib_dir)?;
 
     Ok(Toolchain {
         components,

database/src/lib.rs

@@ -224,6 +224,8 @@ pub enum Profile {
     Doc,
     /// An optimized "release" build
     Opt,
+    /// A Clippy run
+    Clippy
 }
 
 impl Profile {
@@ -233,6 +235,7 @@ impl Profile {
             Profile::Opt => "opt",
             Profile::Debug => "debug",
             Profile::Doc => "doc",
+            Profile::Clippy => "clippy"
         }
     }
 }
@@ -245,6 +248,7 @@ impl std::str::FromStr for Profile {
             "debug" => Profile::Debug,
             "doc" => Profile::Doc,
             "opt" => Profile::Opt,
+            "clippy" => Profile::Clippy,
             _ => return Err(format!("{} is not a profile", s)),
         })
     }

site/src/request_handlers/dashboard.rs

@@ -150,6 +150,7 @@ pub struct ByProfile<T> {
     pub debug: T,
     pub doc: T,
     pub opt: T,
+    pub clippy: T
 }
 
 impl<T> ByProfile<T> {
@@ -163,6 +164,7 @@ impl<T> ByProfile<T> {
             debug: f(Profile::Debug).await?,
             doc: f(Profile::Doc).await?,
             opt: f(Profile::Opt).await?,
+            clippy: f(Profile::Clippy).await?,
         })
     }
 }
@@ -175,6 +177,7 @@ impl<T> std::ops::Index<Profile> for ByProfile<T> {
             Profile::Debug => &self.debug,
             Profile::Doc => &self.doc,
             Profile::Opt => &self.opt,
+            Profile::Clippy => &self.clippy
         }
     }
 }