Auto merge of #375 - pietroalbini:taskctx, r=pietroalbini

Create TaskCtx to avoid passing repeated args in the runner

Author: bors

src/runner/tasks.rs

@@ -11,6 +11,35 @@ use std::fmt;
 use toolchain::Toolchain;
 use utils;
 
+pub(super) struct TaskCtx<'ctx, DB: WriteResults + 'ctx> {
+    pub(super) config: &'ctx Config,
+    pub(super) db: &'ctx DB,
+    pub(super) experiment: &'ctx Experiment,
+    pub(super) toolchain: &'ctx Toolchain,
+    pub(super) krate: &'ctx Crate,
+    pub(super) quiet: bool,
+}
+
+impl<'ctx, DB: WriteResults + 'ctx> TaskCtx<'ctx, DB> {
+    fn new(
+        config: &'ctx Config,
+        db: &'ctx DB,
+        experiment: &'ctx Experiment,
+        toolchain: &'ctx Toolchain,
+        krate: &'ctx Crate,
+        quiet: bool,
+    ) -> Self {
+        TaskCtx {
+            config,
+            db,
+            experiment,
+            toolchain,
+            krate,
+            quiet,
+        }
+    }
+}
+
 pub(super) enum TaskStep {
     Prepare,
     Cleanup,
@@ -127,123 +156,37 @@ impl Task {
                 for tc in &ex.toolchains {
                     let _ = utils::fs::remove_dir_all(&dirs::crate_source_dir(ex, tc, &self.krate));
                 }
-                Ok(())
             }
             TaskStep::Prepare => {
                 let prepare = PrepareCrate::new(ex, &self.krate, config, db);
-                prepare.prepare()
+                prepare.prepare()?;
             }
             TaskStep::BuildAndTest { ref tc, quiet } => {
-                self.run_build_and_test(config, ex, tc, db, quiet)
+                let ctx = TaskCtx::new(config, db, ex, tc, &self.krate, quiet);
+                test::run_test("testing", &ctx, test::test_build_and_test)?;
+            }
+            TaskStep::BuildOnly { ref tc, quiet } => {
+                let ctx = TaskCtx::new(config, db, ex, tc, &self.krate, quiet);
+                test::run_test("building", &ctx, test::test_build_only)?;
+            }
+            TaskStep::CheckOnly { ref tc, quiet } => {
+                let ctx = TaskCtx::new(config, db, ex, tc, &self.krate, quiet);
+                test::run_test("checking", &ctx, test::test_check_only)?;
+            }
+            TaskStep::Rustdoc { ref tc, quiet } => {
+                let ctx = TaskCtx::new(config, db, ex, tc, &self.krate, quiet);
+                test::run_test("documenting", &ctx, test::test_rustdoc)?;
+            }
+            TaskStep::UnstableFeatures { ref tc } => {
+                let ctx = TaskCtx::new(config, db, ex, tc, &self.krate, false);
+                test::run_test(
+                    "checking unstable",
+                    &ctx,
+                    ::runner::unstable_features::find_unstable_features,
+                )?;
             }
-            TaskStep::BuildOnly { ref tc, quiet } => self.run_build_only(config, ex, tc, db, quiet),
-            TaskStep::CheckOnly { ref tc, quiet } => self.run_check_only(config, ex, tc, db, quiet),
-            TaskStep::Rustdoc { ref tc, quiet } => self.run_rustdoc(config, ex, tc, db, quiet),
-            TaskStep::UnstableFeatures { ref tc } => self.run_unstable_features(config, ex, db, tc),
         }
-    }
-
-    fn run_build_and_test<DB: WriteResults>(
-        &self,
-        config: &Config,
-        ex: &Experiment,
-        tc: &Toolchain,
-        db: &DB,
-        quiet: bool,
-    ) -> Fallible<()> {
-        test::run_test(
-            config,
-            "testing",
-            ex,
-            tc,
-            &self.krate,
-            db,
-            quiet,
-            test::test_build_and_test,
-        )
-        .map(|_| ())
-    }
 
-    fn run_build_only<DB: WriteResults>(
-        &self,
-        config: &Config,
-        ex: &Experiment,
-        tc: &Toolchain,
-        db: &DB,
-        quiet: bool,
-    ) -> Fallible<()> {
-        test::run_test(
-            config,
-            "testing",
-            ex,
-            tc,
-            &self.krate,
-            db,
-            quiet,
-            test::test_build_only,
-        )
-        .map(|_| ())
-    }
-
-    fn run_check_only<DB: WriteResults>(
-        &self,
-        config: &Config,
-        ex: &Experiment,
-        tc: &Toolchain,
-        db: &DB,
-        quiet: bool,
-    ) -> Fallible<()> {
-        test::run_test(
-            config,
-            "checking",
-            ex,
-            tc,
-            &self.krate,
-            db,
-            quiet,
-            test::test_check_only,
-        )
-        .map(|_| ())
-    }
-
-    fn run_rustdoc<DB: WriteResults>(
-        &self,
-        config: &Config,
-        ex: &Experiment,
-        tc: &Toolchain,
-        db: &DB,
-        quiet: bool,
-    ) -> Fallible<()> {
-        test::run_test(
-            config,
-            "documenting",
-            ex,
-            tc,
-            &self.krate,
-            db,
-            quiet,
-            test::test_rustdoc,
-        )
-        .map(|_| ())
-    }
-
-    fn run_unstable_features<DB: WriteResults>(
-        &self,
-        config: &Config,
-        ex: &Experiment,
-        db: &DB,
-        tc: &Toolchain,
-    ) -> Fallible<()> {
-        test::run_test(
-            config,
-            "checking",
-            ex,
-            tc,
-            &self.krate,
-            db,
-            false,
-            ::runner::unstable_features::find_unstable_features,
-        )
-        .map(|_| ())
+        Ok(())
     }
 }