Append Windows bin directory to PATH

Author: ChrisDenton

src/env_var.rs

@@ -7,14 +7,15 @@ use crate::process::Process;
 
 pub const RUST_RECURSION_COUNT_MAX: u32 = 20;
 
-pub(crate) fn prepend_path(
+pub(crate) fn insert_path(
     name: &str,
     prepend: Vec<PathBuf>,
+    append: Option<PathBuf>,
     cmd: &mut Command,
     process: &Process,
 ) {
     let old_value = process.var_os(name);
-    let parts = if let Some(ref v) = old_value {
+    let mut parts = if let Some(ref v) = old_value {
         let mut tail = env::split_paths(v).collect::<VecDeque<_>>();
         for path in prepend.into_iter().rev() {
             if !tail.contains(&path) {
@@ -26,6 +27,12 @@ pub(crate) fn prepend_path(
         prepend.into()
     };
 
+    if let Some(path) = append {
+        if !parts.contains(&path) {
+            parts.push_back(path);
+        }
+    }
+
     if let Ok(new_value) = env::join_paths(parts) {
         cmd.env(name, new_value);
     }
@@ -77,7 +84,7 @@ mod tests {
         let path_z = PathBuf::from(z);
         path_entries.push(path_z);
 
-        prepend_path("PATH", path_entries, &mut cmd, &tp.process);
+        insert_path("PATH", path_entries, None, &mut cmd, &tp.process);
         let envs: Vec<_> = cmd.get_envs().collect();
 
         assert_eq!(
@@ -99,4 +106,82 @@ mod tests {
             ),]
         );
     }
+
+    #[test]
+    fn append_unique_path() {
+        let mut vars = HashMap::new();
+        vars.env(
+            "PATH",
+            env::join_paths(["/home/a/.cargo/bin", "/home/b/.cargo/bin"].iter()).unwrap(),
+        );
+        let tp = TestProcess::with_vars(vars);
+        #[cfg(windows)]
+        let _path_guard = RegistryGuard::new(&USER_PATH).unwrap();
+
+        #[track_caller]
+        fn check(tp: &TestProcess, path_entries: Vec<PathBuf>, append: &str, expected: &[&str]) {
+            let mut cmd = Command::new("test");
+
+            insert_path(
+                "PATH",
+                path_entries,
+                Some(append.into()),
+                &mut cmd,
+                &tp.process,
+            );
+            let envs: Vec<_> = cmd.get_envs().collect();
+
+            assert_eq!(
+                envs,
+                &[(
+                    OsStr::new("PATH"),
+                    Some(env::join_paths(expected.iter()).unwrap().as_os_str())
+                ),]
+            );
+        }
+
+        check(
+            &tp,
+            Vec::new(),
+            "/home/z/.cargo/bin",
+            &[
+                "/home/a/.cargo/bin",
+                "/home/b/.cargo/bin",
+                "/home/z/.cargo/bin",
+            ],
+        );
+        check(
+            &tp,
+            Vec::new(),
+            "/home/a/.cargo/bin",
+            &["/home/a/.cargo/bin", "/home/b/.cargo/bin"],
+        );
+        check(
+            &tp,
+            Vec::new(),
+            "/home/b/.cargo/bin",
+            &["/home/a/.cargo/bin", "/home/b/.cargo/bin"],
+        );
+        check(
+            &tp,
+            Vec::from(["/home/c/.cargo/bin".into()]),
+            "/home/c/.cargo/bin",
+            &[
+                "/home/c/.cargo/bin",
+                "/home/a/.cargo/bin",
+                "/home/b/.cargo/bin",
+            ],
+        );
+        check(
+            &tp,
+            Vec::from(["/home/c/.cargo/bin".into()]),
+            "/home/z/.cargo/bin",
+            &[
+                "/home/c/.cargo/bin",
+                "/home/a/.cargo/bin",
+                "/home/b/.cargo/bin",
+                "/home/z/.cargo/bin",
+            ],
+        );
+    }
 }

src/toolchain.rs

@@ -217,7 +217,7 @@ impl<'a> Toolchain<'a> {
             new_path.push(PathBuf::from("/usr/lib"));
         }
 
-        env_var::prepend_path(sysenv::LOADER_PATH, new_path, cmd, self.cfg.process);
+        env_var::insert_path(sysenv::LOADER_PATH, new_path, None, cmd, self.cfg.process);
 
         // Prepend CARGO_HOME/bin to the PATH variable so that we're sure to run
         // cargo/rustc via the proxy bins. There is no fallback case for if the
@@ -251,7 +251,14 @@ impl<'a> Toolchain<'a> {
             path_entries.push(self.path.join("bin"));
         }
 
-        env_var::prepend_path("PATH", path_entries, cmd, self.cfg.process);
+        // On Windows, we append the "bin" directory to PATH.
+        // Windows loads DLLs from PATH and the "bin" directory contains DLLs
+        // that proc macros and other tools not in the sysroot use.
+        // It's appended rather than prepended so that the exe files in "bin"
+        // do not take precedence over anything else in PATH.
+        let append = cfg!(target_os = "windows").then_some(self.path.join("bin"));
+
+        env_var::insert_path("PATH", path_entries, append, cmd, self.cfg.process);
     }
 
     /// Infallible function that describes the version of rustc in an installed distribution