Avoid double-caching when ccache is installed in PATH

On Linux, ccache is typically installed in $PATH as /usr/lib64/ccache/g++
or similar. If we keep it there, all compilations will be cached by both
ccache and sccache.

While the user could easily disable ccache with CCACHE_DISABLE, it's
reasonable to assume many will forget and will have their disk space
doubly consumed by both caches. Better to recognize this and disable
ccache under sccache.

This patch does this by removing the ccache binary paths from $PATH.

Fixes #2519

Author: avikivity

src/compiler/compiler.rs

@@ -35,7 +35,7 @@ use crate::dist::pkg;
 use crate::lru_disk_cache;
 use crate::mock_command::{CommandChild, CommandCreatorSync, RunCommand, exit_status};
 use crate::server;
-use crate::util::{fmt_duration_as_secs, run_input_output};
+use crate::util::{filter_ccache_from_path, fmt_duration_as_secs, run_input_output};
 use crate::{counted_array, dist};
 use async_trait::async_trait;
 use filetime::FileTime;
@@ -194,10 +194,13 @@ impl CompileCommandImpl for SingleCompileCommand {
             env_vars,
             cwd,
         } = self;
+        // Filter out ccache directories from PATH to avoid double-caching
+        // when ccache is also installed on the system.
+        let env_vars = filter_ccache_from_path(env_vars.to_vec());
         let mut cmd = creator.clone().new_command_sync(executable);
         cmd.args(arguments)
             .env_clear()
-            .envs(env_vars.to_vec())
+            .envs(env_vars)
             .current_dir(cwd);
         run_input_output(cmd, None).await
     }

src/util.rs

@@ -1015,11 +1015,106 @@ pub fn num_cpus() -> usize {
     std::thread::available_parallelism().map_or(1, std::num::NonZeroUsize::get)
 }
 
+/// Filter out ccache directories from PATH environment variable.
+///
+/// This prevents double-caching when ccache is installed and has
+/// /usr/lib/ccache or /usr/lib64/ccache in PATH, since those directories
+/// contain wrapper scripts that would call ccache.
+pub fn filter_ccache_from_path(env_vars: Vec<(OsString, OsString)>) -> Vec<(OsString, OsString)> {
+    use std::env;
+    use std::path::Path;
+
+    const CCACHE_DIRS: &[&str] = &["/usr/lib/ccache", "/usr/lib64/ccache"];
+
+    env_vars
+        .into_iter()
+        .map(|(key, value)| {
+            if key == "PATH" {
+                let filtered_path = env::split_paths(&value)
+                    .filter(|p| !CCACHE_DIRS.iter().any(|dir| p == Path::new(dir)))
+                    .collect::<Vec<_>>();
+                let new_value = env::join_paths(filtered_path).unwrap_or(value.clone());
+                (key, new_value)
+            } else {
+                (key, value)
+            }
+        })
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{OsStrExt, TimeMacroFinder};
+    use super::{OsStrExt, TimeMacroFinder, filter_ccache_from_path};
     use std::ffi::{OsStr, OsString};
 
+    #[test]
+    fn test_filter_ccache_from_path() {
+        use std::env;
+
+        // Create a PATH with ccache directories
+        let path_with_ccache = env::join_paths([
+            "/usr/bin",
+            "/usr/lib64/ccache",
+            "/usr/local/bin",
+            "/usr/lib/ccache",
+            "/home/user/bin",
+        ])
+        .unwrap();
+
+        let env_vars = vec![
+            (OsString::from("HOME"), OsString::from("/home/user")),
+            (OsString::from("PATH"), path_with_ccache),
+            (OsString::from("LANG"), OsString::from("en_US.UTF-8")),
+        ];
+
+        let filtered = filter_ccache_from_path(env_vars);
+
+        // Other env vars should be unchanged
+        assert_eq!(filtered.len(), 3);
+        assert_eq!(
+            filtered.iter().find(|(k, _)| k == "HOME").unwrap().1,
+            OsString::from("/home/user")
+        );
+        assert_eq!(
+            filtered.iter().find(|(k, _)| k == "LANG").unwrap().1,
+            OsString::from("en_US.UTF-8")
+        );
+
+        // PATH should have ccache directories removed
+        let new_path = &filtered.iter().find(|(k, _)| k == "PATH").unwrap().1;
+        let expected_path =
+            env::join_paths(["/usr/bin", "/usr/local/bin", "/home/user/bin"]).unwrap();
+        assert_eq!(new_path, &expected_path);
+    }
+
+    #[test]
+    fn test_filter_ccache_from_path_no_ccache() {
+        use std::env;
+
+        // Create a PATH without ccache directories
+        let path_without_ccache = env::join_paths(["/usr/bin", "/usr/local/bin"]).unwrap();
+
+        let env_vars = vec![(OsString::from("PATH"), path_without_ccache.clone())];
+
+        let filtered = filter_ccache_from_path(env_vars);
+
+        assert_eq!(filtered.len(), 1);
+        assert_eq!(filtered[0].1, path_without_ccache);
+    }
+
+    #[test]
+    fn test_filter_ccache_from_path_no_path() {
+        // No PATH variable at all
+        let env_vars = vec![
+            (OsString::from("HOME"), OsString::from("/home/user")),
+            (OsString::from("LANG"), OsString::from("en_US.UTF-8")),
+        ];
+
+        let filtered = filter_ccache_from_path(env_vars.clone());
+
+        assert_eq!(filtered, env_vars);
+    }
+
     #[test]
     fn simple_starts_with() {
         let a: &OsStr = "foo".as_ref();