Append Windows bin directory to PATH

Author: ChrisDenton

src/env_var.rs

@@ -7,9 +7,10 @@ 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,
 ) {
@@ -21,6 +22,11 @@ pub(crate) fn prepend_path(
                 tail.push_front(path);
             }
         }
+        if let Some(path) = append {
+            if !tail.contains(&path) {
+                tail.push_back(path);
+            }
+        }
         tail
     } else {
         prepend.into()
@@ -77,7 +83,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 +105,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,18 @@ 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 = if cfg!(target_os = "windows") {
+            Some(self.path.join("bin"))
+        } else {
+            None
+        };
+
+        env_var::insert_path("PATH", path_entries, append, cmd, self.cfg.process);
     }
 
     /// Infallible function that describes the version of rustc in an installed distribution