cargo-config2 0.1.44

Load and resolve Cargo configuration.
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238

// SPDX-License-Identifier: Apache-2.0 OR MIT

use crate::{cfg_expr::expr::Expression, resolve::CfgMap};

#[test]
#[cfg_attr(miri, ignore)] // Miri doesn't support std::process::Command: https://github.com/rust-lang/miri/issues/3374
fn target_family() {
    let matches_any_family =
        Expression::parse("any(unix, target_family = \"windows\", target_family = \"wasm\")")
            .unwrap();
    let impossible = Expression::parse("all(windows, target_family = \"unix\")").unwrap();

    let mut map = CfgMap::default();
    let rustc = &|| cmd!("rustc");
    for target in [
        "aarch64-apple-darwin",
        "x86_64-pc-windows-msvc",
        "wasm32-unknown-unknown",
        "thumbv7m-none-eabi",
    ] {
        let t = map.eval_cfg(&matches_any_family, &target.into(), rustc).unwrap();
        if target.contains("-none") {
            assert!(!t, "{target}");
        } else {
            assert!(t, "{target}");
        }
        assert!(!map.eval_cfg(&impossible, &target.into(), rustc).unwrap());
    }
}

#[test]
fn tiny() {
    assert!(Expression::parse("all()").unwrap().eval(|_| false));
    assert!(!Expression::parse("any()").unwrap().eval(|_| true));
    assert!(!Expression::parse("not(all())").unwrap().eval(|_| false));
    assert!(Expression::parse("not(any())").unwrap().eval(|_| true));
    assert!(Expression::parse("all(not(blah))").unwrap().eval(|_| false));
    assert!(!Expression::parse("any(not(blah))").unwrap().eval(|_| true));
}

#[test]
#[cfg_attr(miri, ignore)] // Miri doesn't support std::process::Command: https://github.com/rust-lang/miri/issues/3374
fn very_specific() {
    let specific = Expression::parse(
        r#"all(
            target_os = "windows",
            target_arch = "x86",
            windows,
            target_env = "msvc",
            target_feature = "fxsr",
            target_feature = "sse",
            target_feature = "sse2",
            target_pointer_width = "32",
            target_endian = "little",
            not(target_vendor = "uwp"),
            target_has_atomic = "8",
            target_has_atomic = "16",
            target_has_atomic = "32",
            target_has_atomic = "64",
            not(target_has_atomic = "128"),
            target_has_atomic = "ptr",
            panic = "unwind",
            not(panic = "abort"),
        )"#,
    )
    .unwrap();

    let mut map = CfgMap::default();
    let rustc = &|| cmd!("rustc");
    for target in ["i686-pc-windows-msvc", "i686-pc-windows-gnu"] {
        let t = map.eval_cfg(&specific, &target.into(), rustc).unwrap();
        assert_eq!(
            target == "i686-pc-windows-msvc",
            t,
            "expected true for i686-pc-windows-msvc, but got true for {target}",
        );
    }

    // for target in all {
    //     let expr = format!(
    //         r#"cfg(
    //         all(
    //             target_arch = "{}",
    //             {}
    //             {}
    //             target_env = "{}"
    //         )
    //     )"#,
    //         target.arch.0,
    //         if let Some(v) = &target.vendor {
    //             format!(r#"target_vendor = "{}","#, v.0)
    //         } else {
    //             "".to_owned()
    //         },
    //         if let Some(v) = &target.os {
    //             format!(r#"target_os = "{}","#, v.0)
    //         } else {
    //             "".to_owned()
    //         },
    //         target.env.as_ref().map_or("", |e| e.as_str()),
    //     );

    //     let specific = Expression::parse(&expr).unwrap();

    //     let t = Target::make(target.triple.as_str());
    //     assert!(
    //         specific.eval(|pred| {
    //             if target.triple.as_str() == "mips64-openwrt-linux-musl" {
    //                 if let Predicate::Target(TargetPredicate::Vendor(vendor)) = pred {
    //                     // This is a special predicate that doesn't follow the usual rules for
    //                     // target-lexicon.
    //                     return t.builtin.matches(&TargetPredicate::Vendor(vendor.clone()));
    //                 }
    //             }
    //             tg_match!(pred, t)
    //         }),
    //         "failed expression '{}' for {:#?}",
    //         expr,
    //         t.builtin,
    //     );
    // }
}

#[test]
#[cfg_attr(miri, ignore)] // Miri doesn't support std::process::Command: https://github.com/rust-lang/miri/issues/3374
fn complex() {
    let complex = Expression::parse(r#"cfg(all(unix, not(any(target_os="macos", target_os="android", target_os="emscripten"))))"#).unwrap();

    let mut map = CfgMap::default();
    let rustc = &|| cmd!("rustc");

    // Should match linuxes
    assert!(map.eval_cfg(&complex, &"x86_64-unknown-linux-gnu".into(), rustc).unwrap());
    assert!(map.eval_cfg(&complex, &"x86_64-unknown-linux-musl".into(), rustc).unwrap());

    // Should *not* match windows or mac or android
    assert!(!map.eval_cfg(&complex, &"x86_64-pc-windows-msvc".into(), rustc).unwrap());
    assert!(!map.eval_cfg(&complex, &"x86_64-apple-darwin".into(), rustc).unwrap());
    assert!(!map.eval_cfg(&complex, &"aarch64-linux-android".into(), rustc).unwrap());

    let complex =
        Expression::parse(r#"all(not(target_os = "ios"), not(target_os = "android"))"#).unwrap();

    assert!(map.eval_cfg(&complex, &"x86_64-unknown-linux-gnu".into(), rustc).unwrap());
    assert!(map.eval_cfg(&complex, &"x86_64-unknown-linux-musl".into(), rustc).unwrap());
    assert!(map.eval_cfg(&complex, &"x86_64-pc-windows-msvc".into(), rustc).unwrap());
    assert!(map.eval_cfg(&complex, &"x86_64-apple-darwin".into(), rustc).unwrap());
    assert!(!map.eval_cfg(&complex, &"aarch64-linux-android".into(), rustc).unwrap());

    let complex = Expression::parse(r#"all(any(unix, target_arch="x86"), not(any(target_os="android", target_os="emscripten")))"#).unwrap();

    // Should match linuxes and mac
    assert!(map.eval_cfg(&complex, &"x86_64-unknown-linux-gnu".into(), rustc).unwrap());
    assert!(map.eval_cfg(&complex, &"x86_64-unknown-linux-musl".into(), rustc).unwrap());
    assert!(map.eval_cfg(&complex, &"x86_64-apple-darwin".into(), rustc).unwrap());

    // Should *not* match x86_64 windows or android
    assert!(!map.eval_cfg(&complex, &"x86_64-pc-windows-msvc".into(), rustc).unwrap());
    assert!(!map.eval_cfg(&complex, &"aarch64-linux-android".into(), rustc).unwrap());

    // Ensure that target_os = "none" matches against Os == None.
    let complex = Expression::parse(r#"all(target_os="none")"#).unwrap();
    assert!(!map.eval_cfg(&complex, &"x86_64-unknown-linux-gnu".into(), rustc).unwrap());
    assert!(map.eval_cfg(&complex, &"armebv7r-none-eabi".into(), rustc).unwrap());
}

// #[test]
// fn unstable_target_abi() {
//     let linux_gnu = Target::make("x86_64-unknown-linux-gnu");
//     let linux_musl = Target::make("x86_64-unknown-linux-musl");
//     let windows_msvc = Target::make("x86_64-pc-windows-msvc");
//     let mac = Target::make("x86_64-apple-darwin");
//     let android = Target::make("aarch64-linux-android");

//     let target_with_abi_that_matches = cfg_expr::targets::TargetInfo {
//         triple: cfg_expr::targets::Triple::new_const("aarch64-apple-darwin"),
//         os: None,
//         abi: Some(cfg_expr::targets::Abi::new_const("eabihf")),
//         arch: cfg_expr::targets::Arch::aarch64,
//         env: None,
//         vendor: None,
//         families: cfg_expr::targets::Families::unix,
//         pointer_width: 64,
//         endian: cfg_expr::targets::Endian::little,
//         has_atomics: cfg_expr::targets::HasAtomics::atomic_8_16_32_64_128_ptr,
//         panic: cfg_expr::targets::Panic::unwind,
//     };

//     let target_with_abi_that_does_not_match = cfg_expr::targets::TargetInfo {
//         abi: Some(cfg_expr::targets::Abi::new_const("ilp32")),
//         ..target_with_abi_that_matches.clone()
//     };

//     let abi_pred =
//         Expression::parse(r#"cfg(any(target_arch = "wasm32", target_abi = "eabihf"))"#).unwrap();

//     // Should match a specified target_abi that's the same
//     assert!(abi_pred.eval(|pred| {
//         match pred {
//             Predicate::Target(tp) => tp.matches(&target_with_abi_that_matches),
//             _ => false,
//         }
//     }));

//     // Should *not* match a specified target_abi that isn't the same
//     assert!(!abi_pred.eval(|pred| {
//         match pred {
//             Predicate::Target(tp) => tp.matches(&target_with_abi_that_does_not_match),
//             _ => false,
//         }
//     }));

//     // Should *not* match any builtins at this point because target_abi isn't stable
//     assert!(!abi_pred.eval(|pred| tg_match!(pred, linux_gnu)));
//     assert!(!abi_pred.eval(|pred| tg_match!(pred, linux_musl)));
//     assert!(!abi_pred.eval(|pred| tg_match!(pred, mac)));
//     assert!(!abi_pred.eval(|pred| tg_match!(pred, windows_msvc)));
//     assert!(!abi_pred.eval(|pred| tg_match!(pred, android)));
// }

#[test]
#[cfg_attr(miri, ignore)] // Miri doesn't support std::process::Command: https://github.com/rust-lang/miri/issues/3374
fn wasm_family() {
    let wasm = Expression::parse(r#"cfg(target_family = "wasm")"#).unwrap();

    let mut map = CfgMap::default();
    let rustc = &|| cmd!("rustc");

    // All of the above targets match.
    for target in [
        "wasm32-unknown-unknown",
        "wasm32-unknown-emscripten",
        "wasm32-wasip1",
        "wasm64-unknown-unknown",
    ] {
        assert!(map.eval_cfg(&wasm, &target.into(), rustc).unwrap(), "{target}");
    }
}