fix failure errors in executable

Author: Mark-Simulacrum

Cargo.lock

@@ -8,6 +8,7 @@ edition = '2018'
 clap = "2.25"
 env_logger = "0.7"
 anyhow = "1"
+thiserror = "1"
 log = "0.4"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

collector/Cargo.toml

@@ -1,3 +1,4 @@
+use anyhow::bail;
 use collector::api::collected;
 use crossbeam_channel::{unbounded, Receiver, Sender};
 use log::warn;
@@ -10,7 +11,7 @@ lazy_static::lazy_static! {
         RwLock::new(Some(start_bg_thread()));
 }
 
-fn call_home(client: &reqwest::Client, request: &collected::Request) -> Result<(), failure::Error> {
+fn call_home(client: &reqwest::Client, request: &collected::Request) -> anyhow::Result<()> {
     let resp = client
         .post(&format!(
             "{}/perf/collected",

collector/src/bin/rustc-perf-collector/background_worker.rs

@@ -11,11 +11,11 @@ use tempfile::TempDir;
 
 use collector::{command_output, BenchmarkState, Patch, Run, SelfProfile, StatId, Stats};
 
-use failure::{err_msg, Error, ResultExt};
+use anyhow::{bail, Context};
 
 use crate::{BuildKind, Compiler, RunKind};
 
-fn touch_all(path: &Path) -> Result<(), Error> {
+fn touch_all(path: &Path) -> anyhow::Result<()> {
     let mut cmd = Command::new("bash");
     cmd.current_dir(path)
         .args(&["-c", "find . -name '*.rs' | xargs touch"]);
@@ -83,11 +83,11 @@ pub enum Profiler {
     Eprintln,
 }
 
-#[derive(Fail, PartialEq, Eq, Debug)]
+#[derive(thiserror::Error, PartialEq, Eq, Debug)]
 pub enum FromNameError {
-    #[fail(display = "'perf-stat' cannot be used as the profiler")]
+    #[error("'perf-stat' cannot be used as the profiler")]
     PerfStat,
-    #[fail(display = "'{:?}' is not a known profiler", _0)]
+    #[error("'{:?}' is not a known profiler", .0)]
     UnknownProfiler(String),
 }
 
@@ -196,7 +196,7 @@ impl<'a> CargoProcess<'a> {
         package_id.trim().to_string()
     }
 
-    fn run_rustc(&mut self) -> Result<(), Error> {
+    fn run_rustc(&mut self) -> anyhow::Result<()> {
         loop {
             let mut cmd = self.base_command(self.cwd, "rustc");
             cmd.arg("-p").arg(self.get_pkgid(self.cwd));
@@ -284,7 +284,7 @@ pub trait Processor {
         &mut self,
         data: &ProcessOutputData<'_>,
         output: process::Output,
-    ) -> Result<Retry, Error>;
+    ) -> anyhow::Result<Retry>;
 
     /// Provided to permit switching on more expensive profiling if it's needed
     /// for the "first" run for any given benchmark (we reuse the processor),
@@ -356,7 +356,7 @@ impl Processor for MeasureProcessor {
         &mut self,
         data: &ProcessOutputData<'_>,
         output: process::Output,
-    ) -> Result<Retry, Error> {
+    ) -> anyhow::Result<Retry> {
         match process_perf_stat_output(output) {
             Ok((stats, profile)) => {
                 match data.run_kind {
@@ -480,7 +480,7 @@ impl<'a> Processor for ProfileProcessor<'a> {
         &mut self,
         data: &ProcessOutputData<'_>,
         output: process::Output,
-    ) -> Result<Retry, Error> {
+    ) -> anyhow::Result<Retry> {
         // Produce a name of the form $PREFIX-$ID-$BENCHMARK-$BUILDKIND-$RUNKIND.
         let out_file = |prefix: &str| -> String {
             format!(
@@ -640,7 +640,7 @@ impl<'a> Processor for ProfileProcessor<'a> {
 }
 
 impl Benchmark {
-    pub fn new(name: String, path: PathBuf) -> Result<Self, Error> {
+    pub fn new(name: String, path: PathBuf) -> anyhow::Result<Self> {
         let mut patches = vec![];
         for entry in fs::read_dir(&path)? {
             let entry = entry?;
@@ -660,9 +660,9 @@ impl Benchmark {
         let config: BenchmarkConfig = if config_path.exists() {
             serde_json::from_reader(
                 File::open(&config_path)
-                    .with_context(|_| format!("failed to open {:?}", config_path))?,
+                    .with_context(|| format!("failed to open {:?}", config_path))?,
             )
-            .with_context(|_| format!("failed to parse {:?}", config_path))?
+            .with_context(|| format!("failed to parse {:?}", config_path))?
         } else {
             BenchmarkConfig::default()
         };
@@ -679,15 +679,15 @@ impl Benchmark {
         self.config.supports_stable
     }
 
-    fn make_temp_dir(&self, base: &Path) -> Result<TempDir, Error> {
+    fn make_temp_dir(&self, base: &Path) -> anyhow::Result<TempDir> {
         // Appending `.` means we copy just the contents of `base` into
         // `tmp_dir`, rather than `base` itself.
         let mut base_dot = base.to_path_buf();
         base_dot.push(".");
         let tmp_dir = TempDir::new()?;
         let mut cmd = Command::new("cp");
         cmd.arg("-R").arg(base_dot).arg(tmp_dir.path());
-        command_output(&mut cmd).with_context(|_| format!("copying {} to tmp dir", self.name))?;
+        command_output(&mut cmd).with_context(|| format!("copying {} to tmp dir", self.name))?;
         Ok(tmp_dir)
     }
 
@@ -744,7 +744,7 @@ impl Benchmark {
         run_kinds: &[RunKind],
         compiler: Compiler<'_>,
         iterations: usize,
-    ) -> Result<Vec<Run>, Error> {
+    ) -> anyhow::Result<Vec<Run>> {
         let iterations = cmp::min(iterations, self.config.runs);
 
         if self.config.disabled {
@@ -811,7 +811,7 @@ impl Benchmark {
                 if run_kinds.contains(&RunKind::PatchedIncrs) {
                     for (i, patch) in self.patches.iter().enumerate() {
                         log::debug!("applying patch {}", patch.name);
-                        patch.apply(cwd).map_err(|s| err_msg(s))?;
+                        patch.apply(cwd).map_err(|s| anyhow::anyhow!("{}", s))?;
 
                         // An incremental build with some changes (realistic
                         // incremental case).
@@ -836,15 +836,12 @@ impl Benchmark {
     }
 }
 
-#[derive(Fail, PartialEq, Eq, Debug)]
+#[derive(thiserror::Error, PartialEq, Eq, Debug)]
 enum DeserializeStatError {
-    #[fail(
-        display = "could not deserialize empty output to stats, output: {:?}",
-        _0
-    )]
+    #[error("could not deserialize empty output to stats, output: {:?}", .0)]
     NoOutput(process::Output),
-    #[fail(display = "could not parse `{}` as a float", _0)]
-    ParseError(String, #[fail(cause)] ::std::num::ParseFloatError),
+    #[error("could not parse `{}` as a float", .0)]
+    ParseError(String, #[source] ::std::num::ParseFloatError),
 }
 
 fn process_perf_stat_output(

collector/src/bin/rustc-perf-collector/execute.rs

@@ -1,16 +1,14 @@
 #![recursion_limit = "1024"]
 
-#[macro_use]
-extern crate failure;
 #[macro_use]
 extern crate clap;
 
+use anyhow::{bail, Context};
 use chrono::{Timelike, Utc};
 use collector::api::collected;
 use collector::git::get_commit_or_fake_it;
 use collector::git::get_rust_commits as get_commits;
 use collector::{ArtifactData, Commit, CommitData, Date};
-use failure::{Error, ResultExt, SyncFailure};
 use log::{debug, error, info, warn};
 use std::collections::BTreeMap;
 use std::collections::HashSet;
@@ -82,9 +80,9 @@ impl RunKind {
     }
 }
 
-#[derive(Fail, PartialEq, Eq, Debug)]
+#[derive(thiserror::Error, PartialEq, Eq, Debug)]
 pub enum KindError {
-    #[fail(display = "'{:?}' is not a known {} kind", _1, _0)]
+    #[error("'{:?}' is not a known {} kind", .1, .0)]
     UnknownKind(&'static str, String),
 }
 
@@ -153,7 +151,7 @@ fn process_commits(
     out_repo: outrepo::Repo,
     benchmarks: &[Benchmark],
     collect_self_profile: bool,
-) -> Result<(), Error> {
+) -> anyhow::Result<()> {
     println!("processing commits");
     let client = reqwest::Client::new();
     let commit: Option<String> = client
@@ -200,18 +198,18 @@ fn bench_published(
     id: &str,
     repo: outrepo::Repo,
     mut benchmarks: Vec<Benchmark>,
-) -> Result<(), Error> {
+) -> anyhow::Result<()> {
     let commit = Commit {
         sha: String::from("<none>"),
         date: Date::ymd_hms(2010, 01, 01, 0, 0, 0),
     };
-    let cfg = rustup::Cfg::from_env(Arc::new(|_| {})).map_err(SyncFailure::new)?;
+    let cfg = rustup::Cfg::from_env(Arc::new(|_| {})).map_err(|e| anyhow::anyhow!("{:?}", e))?;
     let toolchain = rustup::Toolchain::from(&cfg, id)
-        .map_err(SyncFailure::new)
-        .with_context(|_| format!("creating toolchain for id: {}", id))?;
+        .map_err(|e| anyhow::anyhow!("{:?}", e))
+        .with_context(|| format!("creating toolchain for id: {}", id))?;
     toolchain
         .install_from_dist_if_not_installed()
-        .map_err(SyncFailure::new)?;
+        .map_err(|e| anyhow::anyhow!("{:?}", e))?;
 
     // Remove benchmarks that don't work with a stable compiler.
     benchmarks.retain(|b| b.supports_stable());
@@ -337,7 +335,7 @@ fn get_benchmarks(
     benchmark_dir: &Path,
     filter: Option<&str>,
     exclude: Option<&str>,
-) -> Result<Vec<Benchmark>, Error> {
+) -> anyhow::Result<Vec<Benchmark>> {
     let mut benchmarks = Vec::new();
     'outer: for entry in fs::read_dir(benchmark_dir).context("failed to list benchmarks")? {
         let entry = entry?;
@@ -388,7 +386,7 @@ fn main() {
     }
 }
 
-fn main_result() -> Result<i32, Error> {
+fn main_result() -> anyhow::Result<i32> {
     env_logger::init();
 
     let matches = clap_app!(rustc_perf_collector =>

collector/src/bin/rustc-perf-collector/main.rs

@@ -1,7 +1,7 @@
 //! Write benchmark information to the output repository
 
+use anyhow::{anyhow, Context};
 use collector::{ArtifactData, Commit, CommitData};
-use failure::{Error, ResultExt};
 use log::{debug, info, trace, warn};
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -16,15 +16,15 @@ pub struct Repo {
 }
 
 impl Repo {
-    fn git(&self, args: &[&str]) -> Result<(), Error> {
+    fn git(&self, args: &[&str]) -> anyhow::Result<()> {
         for iteration in 0..5 {
             let mut command = Command::new("git");
             command.current_dir(&self.path);
             info!("[{}/5]: git {:?}", iteration, args);
             command.args(args);
             let mut child = command
                 .spawn()
-                .with_context(|_| format!("could not spawn git {:?}", args))?;
+                .with_context(|| format!("could not spawn git {:?}", args))?;
             let start_time = Instant::now();
             loop {
                 if start_time.elapsed().as_secs() > 30 {
@@ -38,41 +38,45 @@ impl Repo {
                         if status.success() {
                             return Ok(());
                         } else {
-                            bail!(
+                            return Err(anyhow!(
                                 "command `git {:?}` failed in `{}`",
                                 args,
                                 self.path.display()
-                            );
+                            ));
                         }
                     }
                     Ok(None) => {
                         debug!("waiting 250ms...");
                         thread::sleep(time::Duration::from_millis(250));
                     }
-                    Err(err) => bail!(
-                        "command `git {:?}` failed to try_wait in {:?}: {:?}",
-                        args,
-                        self.path.display(),
-                        err
-                    ),
+                    Err(err) => {
+                        return Err(anyhow!(
+                            "command `git {:?}` failed to try_wait in {:?}: {:?}",
+                            args,
+                            self.path.display(),
+                            err
+                        ))
+                    }
                 }
             }
         }
-        bail!("failed to run git command, timed out too many times")
+        Err(anyhow!(
+            "failed to run git command, timed out too many times"
+        ))
     }
 
-    pub fn open(path: PathBuf, allow_new_dir: bool, use_remote: bool) -> Result<Self, Error> {
+    pub fn open(path: PathBuf, allow_new_dir: bool, use_remote: bool) -> anyhow::Result<Self> {
         let result = Repo {
             path: path,
             use_remote,
         };
 
         // Don't nuke random repositories, unless specifically requested.
         if !allow_new_dir && !result.perf_file().exists() {
-            bail!(
+            return Err(anyhow!(
                 "`{}` file not present, refusing to run",
                 result.perf_file().display()
-            );
+            ));
         }
 
         if result.use_remote && result.path.join(".git").exists() {
@@ -85,13 +89,13 @@ impl Repo {
         Ok(result)
     }
 
-    pub fn success(&self, data: &CommitData) -> Result<(), Error> {
+    pub fn success(&self, data: &CommitData) -> anyhow::Result<()> {
         self.add_commit_data(data)?;
         self.commit_and_push(&format!("{} - success", data.commit.sha))?;
         Ok(())
     }
 
-    pub fn success_artifact(&self, data: &ArtifactData) -> Result<(), Error> {
+    pub fn success_artifact(&self, data: &ArtifactData) -> anyhow::Result<()> {
         let filepath = self.times().join(format!("artifact-{}.json", data.id));
         info!("creating file {}", filepath.display());
         let serialized = serde_json::to_string(&data)?;
@@ -100,7 +104,7 @@ impl Repo {
         Ok(())
     }
 
-    fn commit_and_push(&self, message: &str) -> Result<(), Error> {
+    fn commit_and_push(&self, message: &str) -> anyhow::Result<()> {
         self.git(&["add", "times"])?;
 
         // dirty index
@@ -115,16 +119,16 @@ impl Repo {
         Ok(())
     }
 
-    fn load_commit_data_file(&self, filepath: &Path) -> Result<CommitData, Error> {
+    fn load_commit_data_file(&self, filepath: &Path) -> anyhow::Result<CommitData> {
         trace!("loading file {}", filepath.display());
         let contents =
-            fs::read(&filepath).with_context(|_| format!("failed to read {:?}", filepath))?;
+            fs::read(&filepath).with_context(|| format!("failed to read {:?}", filepath))?;
         let data = serde_json::from_slice(&contents)
-            .with_context(|_| format!("failed to read JSON from {:?}", filepath))?;
+            .with_context(|| format!("failed to read JSON from {:?}", filepath))?;
         Ok(data)
     }
 
-    pub fn load_commit_data(&self, commit: &Commit, triple: &str) -> Result<CommitData, Error> {
+    pub fn load_commit_data(&self, commit: &Commit, triple: &str) -> anyhow::Result<CommitData> {
         let filepath = self.times().join(format!(
             "{}-{}-{}.json",
             commit.date.0.to_rfc3339(),
@@ -141,7 +145,7 @@ impl Repo {
         }
     }
 
-    pub fn add_commit_data(&self, data: &CommitData) -> Result<(), Error> {
+    pub fn add_commit_data(&self, data: &CommitData) -> anyhow::Result<()> {
         let commit = &data.commit;
         let filepath = self
             .times()