[rustdoc] Gracefully handle error in case we cannot run the compiler in doctests

src/librustdoc/doctest.rs

@@ -670,7 +670,13 @@ fn run_test(
 
     debug!("compiler invocation for doctest: {compiler:?}");
 
-    let mut child = compiler.spawn().expect("Failed to spawn rustc process");
+    let mut child = match compiler.spawn() {
+        Ok(child) => child,
+        Err(error) => {
+            eprintln!("Failed to spawn {:?}: {error:?}", compiler.get_program());
+            return (Duration::default(), Err(TestFailure::CompileError));
+        }
+    };
     let output = if let Some(merged_test_code) = &doctest.merged_test_code {
         // compile-fail tests never get merged, so this should always pass
         let status = child.wait().expect("Failed to wait");
@@ -732,7 +738,13 @@ fn run_test(
         let status = if !status.success() {
             status
         } else {
-            let mut child_runner = runner_compiler.spawn().expect("Failed to spawn rustc process");
+            let mut child_runner = match runner_compiler.spawn() {
+                Ok(child) => child,
+                Err(error) => {
+                    eprintln!("Failed to spawn {:?}: {error:?}", runner_compiler.get_program());
+                    return (Duration::default(), Err(TestFailure::CompileError));
+                }
+            };
             child_runner.wait().expect("Failed to wait")
         };
 

src/tools/run-make-support/src/command.rs

@@ -387,6 +387,13 @@ impl CompletedProcess {
         self
     }
 
+    /// Checks that `stderr` doesn't contain the Internal Compiler Error message.
+    #[track_caller]
+    pub fn assert_not_ice(&self) -> &Self {
+        self.assert_stderr_not_contains("error: the compiler unexpectedly panicked. this is a bug");
+        self
+    }
+
     /// Checks that `stderr` does not contain the regex pattern `unexpected`.
     #[track_caller]
     pub fn assert_stderr_not_contains_regex<S: AsRef<str>>(&self, unexpected: S) -> &Self {

tests/run-make/diagnostics-traits-from-duplicate-crates/rmake.rs

@@ -43,5 +43,5 @@ fn main() {
         .extern_("minibevy", "libminibevy-b.rmeta")
         .extern_("minirapier", "libminirapier.rmeta")
         .run_fail()
-        .assert_stderr_not_contains("error: the compiler unexpectedly panicked. this is a bug");
+        .assert_not_ice();
 }

tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs

@@ -24,5 +24,5 @@ fn main() {
         .arg(format!("--include-parts-dir={}", parts_out_dir.display()))
         .arg("--merge=finalize")
         .run();
-    output.assert_stderr_not_contains("error: the compiler unexpectedly panicked. this is a bug.");
+    output.assert_not_ice();
 }

tests/run-make/rustdoc-test-builder/foo.rs

@@ -0,0 +1,3 @@
+//! ```
+//! let x = 12;
+//! ```

tests/run-make/rustdoc-test-builder/rmake.rs

@@ -0,0 +1,22 @@
+// This test ensures that if the rustdoc test binary is not executable, it will
+// gracefully fail and not panic.
+
+//@ needs-target-std
+
+use run_make_support::{path, rfs, rustdoc};
+
+fn main() {
+    let absolute_path = path("foo.rs").canonicalize().expect("failed to get absolute path");
+    let output = rustdoc()
+        .input("foo.rs")
+        .arg("--test")
+        .arg("-Zunstable-options")
+        .arg("--test-builder")
+        .arg(&absolute_path)
+        .run_fail();
+
+    // We check that rustdoc outputs the error correctly...
+    output.assert_stdout_contains("Failed to spawn ");
+    // ... and that we didn't panic.
+    output.assert_not_ice();
+}