zccache 1.11.20

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Include search path types and resolution order.

use std::path::Path;

use crate::core::NormalizedPath;

/// Ordered include search paths, preserving -I/-isystem/-iquote/-idirafter.
///
/// Resolution order for `#include "foo.h"` (quoted):
///   1. Directory of the including file
///   2. `-iquote` dirs
///   3. `-I` dirs
///   4. `-isystem` dirs + compiler defaults
///   5. `-idirafter` dirs
///
/// Resolution order for `#include <foo.h>` (angle bracket):
///   1. `-I` dirs
///   2. `-isystem` dirs + compiler defaults
///   3. `-idirafter` dirs
#[derive(Debug, Clone, Default)]
pub struct IncludeSearchPaths {
    /// `-iquote` paths — searched only for quoted includes, before `-I`.
    pub iquote: Vec<NormalizedPath>,
    /// `-I` paths — user include paths (order matters!).
    pub user: Vec<NormalizedPath>,
    /// `-isystem` paths + compiler default system dirs.
    pub system: Vec<NormalizedPath>,
    /// `-idirafter` paths — searched last.
    pub after: Vec<NormalizedPath>,
}

impl IncludeSearchPaths {
    /// Iterate search dirs for a quoted include (`#include "foo.h"`),
    /// starting after the including file's own directory.
    pub fn quoted_search_dirs(&self) -> impl Iterator<Item = &Path> {
        self.iquote
            .iter()
            .chain(self.user.iter())
            .chain(self.system.iter())
            .chain(self.after.iter())
            .map(|p| p.as_path())
    }

    /// Iterate search dirs for an angle-bracket include (`#include <foo.h>`).
    pub fn angle_search_dirs(&self) -> impl Iterator<Item = &Path> {
        self.user
            .iter()
            .chain(self.system.iter())
            .chain(self.after.iter())
            .map(|p| p.as_path())
    }

    /// Iterate all search dirs in priority order (iquote → user → system → after).
    /// This is the superset of both quoted and angle-bracket search orders.
    pub fn all_search_dirs(&self) -> impl Iterator<Item = &Path> {
        self.iquote
            .iter()
            .chain(self.user.iter())
            .chain(self.system.iter())
            .chain(self.after.iter())
            .map(|p| p.as_path())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn quoted_search_includes_iquote_first() {
        let paths = IncludeSearchPaths {
            iquote: vec!["/q".into()],
            user: vec!["/u".into()],
            system: vec!["/s".into()],
            after: vec!["/a".into()],
        };
        let dirs: Vec<&Path> = paths.quoted_search_dirs().collect();
        assert_eq!(
            dirs,
            vec![
                Path::new("/q"),
                Path::new("/u"),
                Path::new("/s"),
                Path::new("/a"),
            ]
        );
    }

    #[test]
    fn angle_search_skips_iquote() {
        let paths = IncludeSearchPaths {
            iquote: vec!["/q".into()],
            user: vec!["/u".into()],
            system: vec!["/s".into()],
            after: vec!["/a".into()],
        };
        let dirs: Vec<&Path> = paths.angle_search_dirs().collect();
        assert_eq!(
            dirs,
            vec![Path::new("/u"), Path::new("/s"), Path::new("/a"),]
        );
    }

    #[test]
    fn empty_paths_produce_empty_iterators() {
        let paths = IncludeSearchPaths::default();
        assert_eq!(paths.quoted_search_dirs().count(), 0);
        assert_eq!(paths.angle_search_dirs().count(), 0);
    }

    #[test]
    fn user_dir_order_preserved() {
        let paths = IncludeSearchPaths {
            user: vec!["/first".into(), "/second".into(), "/third".into()],
            ..Default::default()
        };
        let dirs: Vec<&Path> = paths.angle_search_dirs().collect();
        assert_eq!(
            dirs,
            vec![
                Path::new("/first"),
                Path::new("/second"),
                Path::new("/third")
            ]
        );
    }
}