Print command creation and execution location when it fails

This should make it quicker to debug command failures.

Author: Kobzol

src/bootstrap/src/lib.rs

@@ -937,13 +937,19 @@ impl Build {
 
     /// Execute a command and return its output.
     /// This method should be used for all command executions in bootstrap.
+    #[track_caller]
     fn run(&self, command: &mut BootstrapCommand) -> CommandOutput {
         command.mark_as_executed();
         if self.config.dry_run() && !command.run_always {
             return CommandOutput::default();
         }
 
-        self.verbose(|| println!("running: {command:?}"));
+        let created_at = command.get_created_location();
+        let executed_at = std::panic::Location::caller();
+
+        self.verbose(|| {
+            println!("running: {command:?} (created at {created_at}, executed at {executed_at})")
+        });
 
         let stdout = command.stdout.stdio();
         command.as_command_mut().stdout(stdout);
@@ -962,8 +968,11 @@ impl Build {
             Ok(output) => {
                 writeln!(
                     message,
-                    "\n\nCommand {command:?} did not execute successfully.\
-            \nExpected success, got: {}",
+                    r#"
+Command {command:?} did not execute successfully.
+Expected success, got {}
+Created at: {created_at}
+Executed at: {executed_at}"#,
                     output.status,
                 )
                 .unwrap();

src/bootstrap/src/utils/exec.rs

@@ -160,24 +160,31 @@ impl BootstrapCommand {
         &mut self.command
     }
 
-    /// Mark the command as being executd, disarming the drop bomb.
+    /// Mark the command as being executed, disarming the drop bomb.
     /// If this method is not called before the command is dropped, its drop will panic.
     pub fn mark_as_executed(&mut self) {
         self.drop_bomb.defuse();
     }
+
+    /// Returns the source code location where this command was created.
+    pub fn get_created_location(&self) -> std::panic::Location<'static> {
+        self.drop_bomb.get_created_location()
+    }
 }
 
 impl From<Command> for BootstrapCommand {
     #[track_caller]
     fn from(command: Command) -> Self {
         let program = command.get_program().to_owned();
+        let created_at = std::panic::Location::caller();
+
         Self {
             command,
             failure_behavior: BehaviorOnFailure::Exit,
             stdout: OutputMode::Print,
             stderr: OutputMode::Print,
             run_always: false,
-            drop_bomb: DropBomb::arm(program),
+            drop_bomb: DropBomb::arm(program, *created_at),
         }
     }
 }

src/tools/build_helper/src/drop_bomb/mod.rs

@@ -22,13 +22,12 @@ impl DropBomb {
     /// Arm a [`DropBomb`]. If the value is dropped without being [`defused`][Self::defused], then
     /// it will panic. It is expected that the command wrapper uses `#[track_caller]` to help
     /// propagate the caller location.
-    #[track_caller]
-    pub fn arm<S: AsRef<OsStr>>(command: S) -> DropBomb {
-        DropBomb {
-            command: command.as_ref().into(),
-            defused: false,
-            armed_location: *panic::Location::caller(),
-        }
+    pub fn arm<S: AsRef<OsStr>>(command: S, armed_location: panic::Location<'static>) -> DropBomb {
+        DropBomb { command: command.as_ref().into(), defused: false, armed_location }
+    }
+
+    pub fn get_created_location(&self) -> panic::Location<'static> {
+        self.armed_location
     }
 
     /// Defuse the [`DropBomb`]. This will prevent the drop bomb from panicking when dropped.