Implement compiletest --new-output-capture, in stable Rust

Author: Zalathar

src/tools/compiletest/src/executor.rs

@@ -168,12 +168,17 @@ enum CaptureKind {
     /// Use the old output-capture implementation, which relies on the unstable
     /// library feature `#![feature(internal_output_capture)]`.
     Old { buf: Arc<Mutex<Vec<u8>>> },
+
+    /// Use the new output-capture implementation, which only uses stable Rust.
+    New { buf: output_capture::CaptureBuf },
 }
 
 impl CaptureKind {
     fn for_config(config: &Config) -> Self {
         if config.nocapture {
             Self::None
+        } else if config.new_output_capture {
+            Self::New { buf: output_capture::CaptureBuf::new() }
         } else {
             // Create a capure buffer for `io::set_output_capture`.
             Self::Old { buf: Default::default() }
@@ -184,21 +189,30 @@ impl CaptureKind {
         match self {
             Self::None => false,
             Self::Old { .. } => true,
+            Self::New { .. } => true,
         }
     }
 
     fn stdout(&self) -> &dyn ConsoleOut {
-        &output_capture::Stdout
+        self.capture_buf_or(&output_capture::Stdout)
     }
 
     fn stderr(&self) -> &dyn ConsoleOut {
-        &output_capture::Stderr
+        self.capture_buf_or(&output_capture::Stderr)
+    }
+
+    fn capture_buf_or<'a>(&'a self, fallback: &'a dyn ConsoleOut) -> &'a dyn ConsoleOut {
+        match self {
+            Self::None | Self::Old { .. } => fallback,
+            Self::New { buf } => buf,
+        }
     }
 
     fn into_inner(self) -> Option<Vec<u8>> {
         match self {
             Self::None => None,
             Self::Old { buf } => Some(buf.lock().unwrap_or_else(|e| e.into_inner()).to_vec()),
+            Self::New { buf } => Some(buf.into_inner().into()),
         }
     }
 }

src/tools/compiletest/src/output_capture.rs

@@ -1,5 +1,6 @@
 use std::fmt;
 use std::panic::RefUnwindSafe;
+use std::sync::Mutex;
 
 pub trait ConsoleOut: fmt::Debug + RefUnwindSafe {
     fn write_fmt(&self, args: fmt::Arguments<'_>);
@@ -22,3 +23,30 @@ impl ConsoleOut for Stderr {
         eprint!("{args}");
     }
 }
+
+pub(crate) struct CaptureBuf {
+    inner: Mutex<String>,
+}
+
+impl CaptureBuf {
+    pub(crate) fn new() -> Self {
+        Self { inner: Mutex::new(String::new()) }
+    }
+
+    pub(crate) fn into_inner(self) -> String {
+        self.inner.into_inner().unwrap_or_else(|e| e.into_inner())
+    }
+}
+
+impl fmt::Debug for CaptureBuf {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("CaptureBuf").finish_non_exhaustive()
+    }
+}
+
+impl ConsoleOut for CaptureBuf {
+    fn write_fmt(&self, args: fmt::Arguments<'_>) {
+        let mut s = self.inner.lock().unwrap_or_else(|e| e.into_inner());
+        <String as fmt::Write>::write_fmt(&mut s, args).unwrap();
+    }
+}