zccache 1.12.17

Local-first compiler cache for C/C++/Rust/Emscripten
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

//! Merge independently collected dependency scans.

use std::collections::HashSet;

use crate::core::NormalizedPath;

use crate::depgraph::scanner::ScanResult;

/// Union the exact user-header depfile with a conservative static include scan.
#[must_use]
pub fn merge_scan_results(mut depfile: ScanResult, static_scan: ScanResult) -> ScanResult {
    let mut seen: HashSet<NormalizedPath> = depfile.resolved.iter().cloned().collect();
    depfile.resolved.extend(
        static_scan
            .resolved
            .into_iter()
            .filter(|path| seen.insert(path.clone())),
    );
    let mut unresolved: HashSet<String> = depfile.unresolved.iter().cloned().collect();
    depfile.unresolved.extend(
        static_scan
            .unresolved
            .into_iter()
            .filter(|path| unresolved.insert(path.clone())),
    );
    depfile.has_computed |= static_scan.has_computed;
    depfile
}

#[cfg(test)]
mod tests {
    use super::merge_scan_results;
    use crate::depgraph::scanner::ScanResult;
    use crate::core::NormalizedPath;

    #[test]
    fn merges_mmd_user_headers_with_static_system_headers_without_duplicates() {
        let source = NormalizedPath::from("/src/main.c");
        let user = NormalizedPath::from("/src/user.h");
        let system = NormalizedPath::from("/usr/include/stdio.h");
        let merged = merge_scan_results(
            ScanResult {
                resolved: vec![source, user.clone()],
                unresolved: vec!["missing.h".into()],
                has_computed: false,
            },
            ScanResult {
                resolved: vec![user, system.clone()],
                unresolved: Vec::new(),
                has_computed: false,
            },
        );

        assert_eq!(merged.resolved.len(), 3);
        assert!(merged.resolved.contains(&system));
        assert_eq!(merged.unresolved, vec!["missing.h"]);
        assert!(!merged.has_computed);
    }
}