Only spawn subprocesses when panic=abort

Author: tmandry

src/librustc_interface/passes.rs

@@ -446,6 +446,7 @@ fn configure_and_expand_inner<'a>(
             &mut krate,
             sess.diagnostic(),
             &sess.features_untracked(),
+            sess.panic_strategy(),
         )
     });
 

src/libsyntax_ext/test_harness.rs

@@ -2,6 +2,7 @@
 
 use log::debug;
 use smallvec::{smallvec, SmallVec};
+use rustc_target::spec::PanicStrategy;
 use syntax::ast::{self, Ident};
 use syntax::attr;
 use syntax::entry::{self, EntryPointType};
@@ -25,6 +26,7 @@ struct Test {
 
 struct TestCtxt<'a> {
     ext_cx: ExtCtxt<'a>,
+    panic_strategy: PanicStrategy,
     def_site: Span,
     test_cases: Vec<Test>,
     reexport_test_harness_main: Option<Symbol>,
@@ -40,6 +42,7 @@ pub fn inject(
     krate: &mut ast::Crate,
     span_diagnostic: &errors::Handler,
     features: &Features,
+    panic_strategy: PanicStrategy,
 ) {
     // Check for #![reexport_test_harness_main = "some_name"] which gives the
     // main test function the name `some_name` without hygiene. This needs to be
@@ -54,7 +57,7 @@ pub fn inject(
 
     if should_test {
         generate_test_harness(sess, resolver, reexport_test_harness_main,
-                              krate, features, test_runner)
+                              krate, features, panic_strategy, test_runner)
     }
 }
 
@@ -183,6 +186,7 @@ fn generate_test_harness(sess: &ParseSess,
                          reexport_test_harness_main: Option<Symbol>,
                          krate: &mut ast::Crate,
                          features: &Features,
+                         panic_strategy: PanicStrategy,
                          test_runner: Option<ast::Path>) {
     let mut econfig = ExpansionConfig::default("test".to_string());
     econfig.features = Some(features);
@@ -203,6 +207,7 @@ fn generate_test_harness(sess: &ParseSess,
 
     let cx = TestCtxt {
         ext_cx,
+        panic_strategy,
         def_site,
         test_cases: Vec::new(),
         reexport_test_harness_main,
@@ -248,9 +253,14 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
     let ecx = &cx.ext_cx;
     let test_id = Ident::new(sym::test, sp);
 
+    let runner_name = match cx.panic_strategy {
+        PanicStrategy::Unwind => "test_main_static",
+        PanicStrategy::Abort => "test_main_static_abort",
+    };
+
     // test::test_main_static(...)
     let mut test_runner = cx.test_runner.clone().unwrap_or(
-        ecx.path(sp, vec![test_id, ecx.ident_of("test_main_static", sp)]));
+        ecx.path(sp, vec![test_id, ecx.ident_of(runner_name, sp)]));
 
     test_runner.span = sp;
 

src/libtest/lib.rs

@@ -261,37 +261,31 @@ impl Metric {
 #[derive(Copy, Clone, Debug)]
 pub struct Options {
     display_output: bool,
+    panic_abort: bool,
 }
 
 impl Options {
     pub fn new() -> Options {
         Options {
             display_output: false,
+            panic_abort: false,
         }
     }
 
     pub fn display_output(mut self, display_output: bool) -> Options {
         self.display_output = display_output;
         self
     }
+
+    pub fn panic_abort(mut self, panic_abort: bool) -> Options {
+        self.panic_abort = panic_abort;
+        self
+    }
 }
 
 // The default console test runner. It accepts the command line
 // arguments and a vector of test_descs.
 pub fn test_main(args: &[String], tests: Vec<TestDescAndFn>, options: Option<Options>) {
-    // If we're being run in SpawnedSecondary mode, run the test here. run_test
-    // will then exit the process.
-    if let Ok(name) = env::var(SECONDARY_TEST_INVOKER_VAR) {
-        let test = tests
-            .into_iter()
-            .filter(|test| test.desc.name.as_slice() == name)
-            .next()
-            .expect("couldn't find a test with the provided name");
-        let opts = parse_opts(&[]).unwrap().unwrap();
-        run_test(&opts, false, test, RunStrategy::SpawnedSecondary, Concurrent::No);
-        unreachable!();
-    }
-
     let mut opts = match parse_opts(args) {
         Some(Ok(o)) => o,
         Some(Err(msg)) => {
@@ -320,32 +314,63 @@ pub fn test_main(args: &[String], tests: Vec<TestDescAndFn>, options: Option<Opt
     }
 }
 
-// A variant optimized for invocation with a static test vector.
-// This will panic (intentionally) when fed any dynamic tests, because
-// it is copying the static values out into a dynamic vector and cannot
-// copy dynamic values. It is doing this because from this point on
-// a Vec<TestDescAndFn> is used in order to effect ownership-transfer
-// semantics into parallel test runners, which in turn requires a Vec<>
-// rather than a &[].
+/// A variant optimized for invocation with a static test vector.
+/// This will panic (intentionally) when fed any dynamic tests.
+///
+/// This is the entry point for the main function generated by `rustc --test`
+/// when panic=unwind.
 pub fn test_main_static(tests: &[&TestDescAndFn]) {
     let args = env::args().collect::<Vec<_>>();
-    let owned_tests = tests
-        .iter()
-        .map(|t| match t.testfn {
-            StaticTestFn(f) => TestDescAndFn {
-                testfn: StaticTestFn(f),
-                desc: t.desc.clone(),
-            },
-            StaticBenchFn(f) => TestDescAndFn {
-                testfn: StaticBenchFn(f),
-                desc: t.desc.clone(),
-            },
-            _ => panic!("non-static tests passed to test::test_main_static"),
-        })
-        .collect();
+    let owned_tests: Vec<_> = tests.iter().map(make_owned_test).collect();
     test_main(&args, owned_tests, None)
 }
 
+/// A variant optimized for invocation with a static test vector.
+/// This will panic (intentionally) when fed any dynamic tests.
+///
+/// Runs tests in panic=abort mode, which involves spawning subprocesses for
+/// tests.
+///
+/// This is the entry point for the main function generated by `rustc --test`
+/// when panic=abort.
+pub fn test_main_static_abort(tests: &[&TestDescAndFn]) {
+    // If we're being run in SpawnedSecondary mode, run the test here. run_test
+    // will then exit the process.
+    if let Ok(name) = env::var(SECONDARY_TEST_INVOKER_VAR) {
+        let test = tests
+            .iter()
+            .filter(|test| test.desc.name.as_slice() == name)
+            .map(make_owned_test)
+            .next()
+            .expect("couldn't find a test with the provided name");
+        let opts = parse_opts(&[]).unwrap().unwrap();
+        run_test(&opts, false, test, RunStrategy::SpawnedSecondary, Concurrent::No);
+        unreachable!();
+    }
+
+    let args = env::args().collect::<Vec<_>>();
+    let owned_tests: Vec<_> = tests.iter().map(make_owned_test).collect();
+    test_main(&args, owned_tests, Some(Options::new().panic_abort(true)))
+}
+
+/// Clones static values for putting into a dynamic vector, which test_main()
+/// needs to hand out ownership of tests to parallel test runners.
+///
+/// This will panic when fed any dynamic tests, because they cannot be cloned.
+fn make_owned_test(test: &&TestDescAndFn) -> TestDescAndFn {
+    match test.testfn {
+        StaticTestFn(f) => TestDescAndFn {
+            testfn: StaticTestFn(f),
+            desc: test.desc.clone(),
+        },
+        StaticBenchFn(f) => TestDescAndFn {
+            testfn: StaticBenchFn(f),
+            desc: test.desc.clone(),
+        },
+        _ => panic!("non-static tests passed to test::test_main_static"),
+    }
+}
+
 /// Invoked when unit tests terminate. Should panic if the unit
 /// Tests is considered a failure. By default, invokes `report()`
 /// and checks for a `0` result.
@@ -1147,8 +1172,7 @@ where
     let mut pending = 0;
 
     let (tx, rx) = channel::<MonitorMsg>();
-    // TODO
-    let run_strategy = if true {
+    let run_strategy = if opts.options.panic_abort {
         RunStrategy::SpawnPrimary(tx)
     } else {
         RunStrategy::InProcess(tx)