Add trailing newline check for rustc --print in run-make-support

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

@@ -24,18 +24,50 @@ use build_helper::drop_bomb::DropBomb;
 /// [`run`]: Self::run
 /// [`run_fail`]: Self::run_fail
 /// [`run_unchecked`]: Self::run_unchecked
-#[derive(Debug)]
 pub struct Command {
     cmd: StdCommand,
     stdin: Option<Box<[u8]>>,
+    completed_process_checks: Vec<(String, Box<dyn Fn(&CompletedProcess)>)>,
     drop_bomb: DropBomb,
 }
 
+impl std::fmt::Debug for Command {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Command")
+            .field("cmd", &self.cmd)
+            .field("stdin", &self.stdin)
+            .field(
+                "completed_process_checks",
+                &self
+                    .completed_process_checks
+                    .iter()
+                    .map(|(name, _check)| name)
+                    .collect::<Vec<_>>(),
+            )
+            .field("drop_bomb", &self.drop_bomb)
+            .finish()
+    }
+}
+
 impl Command {
     #[track_caller]
     pub fn new<P: AsRef<OsStr>>(program: P) -> Self {
         let program = program.as_ref();
-        Self { cmd: StdCommand::new(program), stdin: None, drop_bomb: DropBomb::arm(program) }
+        Self {
+            cmd: StdCommand::new(program),
+            stdin: None,
+            completed_process_checks: vec![],
+            drop_bomb: DropBomb::arm(program),
+        }
+    }
+
+    /// Adds a `check` to be completed once the `Command` is run.
+    pub(crate) fn add_completed_process_check<F>(&mut self, name: &str, check: F) -> &mut Self
+    where
+        F: Fn(&CompletedProcess) + 'static,
+    {
+        self.completed_process_checks.push((name.to_string(), Box::new(check)));
+        self
     }
 
     /// Specify a stdin input
@@ -151,7 +183,15 @@ impl Command {
         } else {
             self.cmd.output().expect("failed to get output of finished process")
         };
-        output.into()
+
+        let completed_process = CompletedProcess::from(output);
+
+        for (name, check) in self.completed_process_checks.iter() {
+            eprintln!("checking: {name}");
+            check(&completed_process);
+        }
+
+        completed_process
     }
 }
 
@@ -199,6 +239,18 @@ impl CompletedProcess {
         self
     }
 
+    /// Checks that `stdout` ends with a newline if it is not empty.
+    #[track_caller]
+    pub fn assert_stdout_ends_with_newline(&self) -> &Self {
+        if !self.stdout_utf8().is_empty() {
+            assert!(
+                self.stdout_utf8().ends_with(['\r', '\n'].as_slice()),
+                "stdout does not end with newline"
+            );
+        }
+        self
+    }
+
     /// Checks that trimmed `stderr` matches trimmed `expected`.
     #[track_caller]
     pub fn assert_stderr_equals<S: AsRef<str>>(&self, expected: S) -> &Self {

src/tools/run-make-support/src/external_deps/rustc.rs

@@ -272,9 +272,15 @@ impl Rustc {
     }
 
     /// Specify the print request.
+    ///
+    /// Also checks that the [`CompletedProcess`](crate::command::CompletedProcess)
+    /// `stdout` ends with a newline.
     pub fn print(&mut self, request: &str) -> &mut Self {
         self.cmd.arg("--print");
         self.cmd.arg(request);
+        self.cmd.add_completed_process_check("`--print` ends with newline", |completed_process| {
+            completed_process.assert_stdout_ends_with_newline();
+        });
         self
     }
 

tests/run-make/link-arg/rmake.rs

@@ -17,5 +17,4 @@ fn main() {
         .run_unchecked();
     out.assert_stdout_contains("lfoo");
     out.assert_stdout_contains("lbar");
-    assert!(out.stdout_utf8().ends_with('\n'));
 }