fix checking git submodules during a commit hook

Author: RalfJung

src/bootstrap/src/core/config/config.rs

@@ -2095,7 +2095,7 @@ impl Config {
     /// Use this rather than `Command::new("git")` in order to support out-of-tree builds.
     pub(crate) fn git(&self) -> Command {
         let mut git = Command::new("git");
-        git.current_dir(&self.src);
+        git.arg("--git-dir").arg(self.src.join(".git"));
         git
     }
 

src/bootstrap/src/lib.rs

@@ -520,34 +520,34 @@ impl Build {
             return;
         }
 
-        // check_submodule
-        let checked_out_hash =
-            output(Command::new("git").args(["rev-parse", "HEAD"]).current_dir(&absolute_path));
-        // update_submodules
-        let recorded = output(
-            Command::new("git")
-                .args(["ls-tree", "HEAD"])
-                .arg(relative_path)
-                .current_dir(&self.config.src),
-        );
+        let mut submodule_git = absolute_path;
+        submodule_git.push(".git");
+        let submodule_git = move || {
+            let mut cmd = Command::new("git");
+            // We use `--git-dir` instead of `current_dir` since in a commit hook,
+            // some env var is set that makes `current_dir` not have any effect.
+            // See <https://github.com/rust-lang/rust/issues/125954>.
+            cmd.arg("--git-dir").arg(&submodule_git);
+            cmd
+        };
+
+        // Determine commit checked out in submodule.
+        let checked_out_hash = output(submodule_git().args(["rev-parse", "HEAD"]));
+        let checked_out_hash = checked_out_hash.trim_end();
+        // Determine commit that the submodule *should* have.
+        let recorded = output(self.config.git().args(["ls-tree", "HEAD"]).arg(relative_path));
         let actual_hash = recorded
             .split_whitespace()
             .nth(2)
             .unwrap_or_else(|| panic!("unexpected output `{}`", recorded));
 
-        // update_submodule
-        if actual_hash == checked_out_hash.trim_end() {
+        if actual_hash == checked_out_hash {
             // already checked out
             return;
         }
 
         println!("Updating submodule {}", relative_path.display());
-        self.run(
-            Command::new("git")
-                .args(["submodule", "-q", "sync"])
-                .arg(relative_path)
-                .current_dir(&self.config.src),
-        );
+        self.run(self.config.git().args(["submodule", "-q", "sync"]).arg(relative_path));
 
         // Try passing `--progress` to start, then run git again without if that fails.
         let update = |progress: bool| {
@@ -590,26 +590,22 @@ impl Build {
         // Save any local changes, but avoid running `git stash pop` if there are none (since it will exit with an error).
         // diff-index reports the modifications through the exit status
         let has_local_modifications = !self.run_cmd(
-            BootstrapCommand::from(
-                Command::new("git")
-                    .args(["diff-index", "--quiet", "HEAD"])
-                    .current_dir(&absolute_path),
-            )
-            .allow_failure()
-            .output_mode(match self.is_verbose() {
-                true => OutputMode::PrintAll,
-                false => OutputMode::PrintOutput,
-            }),
+            BootstrapCommand::from(submodule_git().args(["diff-index", "--quiet", "HEAD"]))
+                .allow_failure()
+                .output_mode(match self.is_verbose() {
+                    true => OutputMode::PrintAll,
+                    false => OutputMode::PrintOutput,
+                }),
         );
         if has_local_modifications {
-            self.run(Command::new("git").args(["stash", "push"]).current_dir(&absolute_path));
+            self.run(submodule_git().args(["stash", "push"]));
         }
 
-        self.run(Command::new("git").args(["reset", "-q", "--hard"]).current_dir(&absolute_path));
-        self.run(Command::new("git").args(["clean", "-qdfx"]).current_dir(&absolute_path));
+        self.run(submodule_git().args(["reset", "-q", "--hard"]));
+        self.run(submodule_git().args(["clean", "-qdfx"]));
 
         if has_local_modifications {
-            self.run(Command::new("git").args(["stash", "pop"]).current_dir(absolute_path));
+            self.run(submodule_git().args(["stash", "pop"]));
         }
     }
 

src/bootstrap/src/utils/channel.rs

@@ -35,16 +35,22 @@ pub struct Info {
 
 impl GitInfo {
     pub fn new(omit_git_hash: bool, dir: &Path) -> GitInfo {
+        let git_dir = dir.join(".git");
         // See if this even begins to look like a git dir
-        if !dir.join(".git").exists() {
+        if !git_dir.exists() {
             match read_commit_info_file(dir) {
                 Some(info) => return GitInfo::RecordedForTarball(info),
                 None => return GitInfo::Absent,
             }
         }
+        let git = || {
+            let mut cmd = Command::new("git");
+            cmd.arg("--git-dir").arg(&git_dir);
+            cmd
+        };
 
         // Make sure git commands work
-        match Command::new("git").arg("rev-parse").current_dir(dir).output() {
+        match git().arg("rev-parse").output() {
             Ok(ref out) if out.status.success() => {}
             _ => return GitInfo::Absent,
         }
@@ -56,18 +62,10 @@ impl GitInfo {
         }
 
         // Ok, let's scrape some info
-        let ver_date = output(
-            Command::new("git")
-                .current_dir(dir)
-                .arg("log")
-                .arg("-1")
-                .arg("--date=short")
-                .arg("--pretty=format:%cd"),
-        );
-        let ver_hash = output(Command::new("git").current_dir(dir).arg("rev-parse").arg("HEAD"));
-        let short_ver_hash = output(
-            Command::new("git").current_dir(dir).arg("rev-parse").arg("--short=9").arg("HEAD"),
-        );
+        let ver_date =
+            output(git().arg("log").arg("-1").arg("--date=short").arg("--pretty=format:%cd"));
+        let ver_hash = output(git().arg("rev-parse").arg("HEAD"));
+        let short_ver_hash = output(git().arg("rev-parse").arg("--short=9").arg("HEAD"));
         GitInfo::Present(Some(Info {
             commit_date: ver_date.trim().to_string(),
             sha: ver_hash.trim().to_string(),