feat(profile): panic behavior can be specified for custom harness

It's libtest that requires tests to be always unwound.
For custom harnesses they don't need such a requirement.
Cargo relaxes it a bit in profile settings.

Author: weihanglo

src/cargo/core/compiler/unit_dependencies.rs

@@ -213,9 +213,9 @@ fn deps_of_roots(roots: &[Unit], state: &mut State<'_, '_>) -> CargoResult<()> {
             if unit.target.proc_macro() {
                 // Special-case for proc-macros, which are forced to for-host
                 // since they need to link with the proc_macro crate.
-                UnitFor::new_host_test(state.gctx, root_compile_kind)
+                UnitFor::new_host_test(state.gctx, &unit.target, root_compile_kind)
             } else {
-                UnitFor::new_test(state.gctx, root_compile_kind)
+                UnitFor::new_test(state.gctx, &unit.target, root_compile_kind)
             }
         } else if unit.target.is_custom_build() {
             // This normally doesn't happen, except `clean` aggressively

src/cargo/core/profiles.rs

@@ -1109,19 +1109,28 @@ impl UnitFor {
     /// whether `panic=abort` is supported for tests. Historical versions of
     /// rustc did not support this, but newer versions do with an unstable
     /// compiler flag.
-    pub fn new_test(gctx: &GlobalContext, root_compile_kind: CompileKind) -> UnitFor {
+    ///
+    /// Moreover, `target` is taken here for determining whether the test is
+    /// driven by libtest harness. Cargo relaxes the panic behaviour if it is
+    /// a custom harness, which is not required to be always unwound.
+    pub fn new_test(
+        gctx: &GlobalContext,
+        target: &Target,
+        root_compile_kind: CompileKind,
+    ) -> UnitFor {
+        // We're testing out an unstable feature (`-Zpanic-abort-tests`)
+        // which inherits the panic setting from the dev/release profile
+        // (basically avoid recompiles) but historical defaults required
+        // that we always unwound.
+        let panic_setting = if gctx.cli_unstable().panic_abort_tests || !target.harness() {
+            PanicSetting::ReadProfile
+        } else {
+            PanicSetting::AlwaysUnwind
+        };
         UnitFor {
             host: false,
             host_features: false,
-            // We're testing out an unstable feature (`-Zpanic-abort-tests`)
-            // which inherits the panic setting from the dev/release profile
-            // (basically avoid recompiles) but historical defaults required
-            // that we always unwound.
-            panic_setting: if gctx.cli_unstable().panic_abort_tests {
-                PanicSetting::ReadProfile
-            } else {
-                PanicSetting::AlwaysUnwind
-            },
+            panic_setting,
             root_compile_kind,
             artifact_target_for_features: None,
         }
@@ -1130,8 +1139,14 @@ impl UnitFor {
     /// This is a special case for unit tests of a proc-macro.
     ///
     /// Proc-macro unit tests are forced to be run on the host.
-    pub fn new_host_test(gctx: &GlobalContext, root_compile_kind: CompileKind) -> UnitFor {
-        let mut unit_for = UnitFor::new_test(gctx, root_compile_kind);
+    ///
+    /// See [`UnitFor::new_test`] for more.
+    pub fn new_host_test(
+        gctx: &GlobalContext,
+        target: &Target,
+        root_compile_kind: CompileKind,
+    ) -> UnitFor {
+        let mut unit_for = UnitFor::new_test(gctx, target, root_compile_kind);
         unit_for.host = true;
         unit_for.host_features = true;
         unit_for

src/cargo/ops/cargo_compile/unit_generator.rs

@@ -148,7 +148,7 @@ impl<'a> UnitGenerator<'a, '_> {
                     //
                     // Forcing the lib to be compiled three times during `cargo
                     // test` is probably also not desirable.
-                    UnitFor::new_test(self.ws.gctx(), kind)
+                    UnitFor::new_test(self.ws.gctx(), target, kind)
                 } else if target.for_host() {
                     // Proc macro / plugin should not have `panic` set.
                     UnitFor::new_compiler(kind)

tests/testsuite/profiles.rs

@@ -428,22 +428,29 @@ fn profile_panic_test_with_custom_harness() {
         .file("benches/libtest.rs", "")
         .build();
 
+    #[cfg(not(windows))]
+    let exit_code = 101;
+    #[cfg(windows)]
+    let exit_code = winapi::shared::ntstatus::STATUS_STACK_BUFFER_OVERRUN;
+
     // panic abort on custom harness
     p.cargo("test --test custom --verbose")
-        .with_stderr_does_not_contain("[..]panic=abort[..]")
+        .with_stderr_contains("[RUNNING] `rustc --crate-name custom [..]-C panic=abort [..]")
         .with_stderr_contains("[..]thread '[..]' panicked at [..]")
-        .with_stderr_does_not_contain(
+        .with_stderr_contains("[..]abort![..]")
+        .with_stderr_contains(
             "[..]process didn't exit successfully: `[..]/target/debug/deps/custom-[..]",
         )
-        .with_status(101)
+        .with_status(exit_code)
         .run();
     p.cargo("bench --bench custom --verbose")
-        .with_stderr_does_not_contain("[..]panic=abort[..]")
+        .with_stderr_contains("[RUNNING] `rustc --crate-name custom [..]-C panic=abort [..]")
         .with_stderr_contains("[..]thread '[..]' panicked at [..]")
-        .with_stderr_does_not_contain(
+        .with_stderr_contains("[..]abort![..]")
+        .with_stderr_contains(
             "[..]process didn't exit successfully: `[..]/target/release/deps/custom-[..]",
         )
-        .with_status(101)
+        .with_status(exit_code)
         .run();
 
     // panic behaviour of libtest cannot be set as `abort` as of now.