p1689 0.0.0

Data structures for representing p1689 C++ modules dependency files
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

use alloc::string::String;

use proptest::prelude::*;

use crate::{spec::r5, util::proptest::arbitrary::CowUtf8PathHelper};

impl<'a> proptest::arbitrary::Arbitrary for r5::DepFile<'a> {
    type Parameters = ();
    type Strategy = BoxedStrategy<Self>;

    fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
        (
            u32::arbitrary(),
            Option::<u32>::arbitrary(),
            alloc::vec::IntoIter::<r5::DepInfo>::arbitrary(),
        )
            .prop_map(move |(version, revision, rules)| Self {
                version,
                revision,
                rules: rules.collect(),
            })
            .boxed()
    }
}

impl<'a> proptest::arbitrary::Arbitrary for r5::DepInfo<'a> {
    type Parameters = ();
    type Strategy = BoxedStrategy<Self>;

    fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
        (
            Option::<CowUtf8PathHelper>::arbitrary(),
            Option::<CowUtf8PathHelper>::arbitrary(),
            alloc::vec::IntoIter::<CowUtf8PathHelper>::arbitrary(),
            alloc::vec::IntoIter::<r5::ProvidedModuleDesc>::arbitrary(),
            alloc::vec::IntoIter::<r5::RequiredModuleDesc>::arbitrary(),
        )
            .prop_map(
                move |(work_directory, primary_output, outputs, provides, requires)| Self {
                    work_directory: work_directory.map(|helper| helper.inner),
                    primary_output: primary_output.map(|helper| helper.inner),
                    outputs: outputs.map(|helper| helper.inner).collect(),
                    provides: provides.collect(),
                    requires: requires.collect(),
                },
            )
            .boxed()
    }
}

impl<'a> proptest::arbitrary::Arbitrary for r5::ModuleDesc<'a> {
    type Parameters = ();
    type Strategy = BoxedStrategy<Self>;

    fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
        (
            Option::<CowUtf8PathHelper>::arbitrary(),
            Option::<CowUtf8PathHelper>::arbitrary(),
            String::arbitrary(),
            bool::arbitrary(),
            bool::arbitrary(),
        )
            .prop_map(
                move |(
                    source_path,
                    compiled_module_path,
                    logical_name,
                    unique_on_source_path,
                    _unique_on_source_path_some_false,
                )| match source_path {
                    Some(source_path) if unique_on_source_path => Self::BySourcePath {
                        source_path: source_path.inner,
                        compiled_module_path: compiled_module_path.map(|helper| helper.inner),
                        logical_name: logical_name.into(),
                        #[cfg(any(test, feature = "monostate"))]
                        unique_on_source_path: monostate::MustBe!(true),
                    },
                    _ => Self::ByLogicalName {
                        source_path: source_path.map(|helper| helper.inner),
                        compiled_module_path: compiled_module_path.map(|helper| helper.inner),
                        logical_name: logical_name.into(),
                        #[cfg(any(test, feature = "monostate"))]
                        #[allow(clippy::used_underscore_binding)]
                        unique_on_source_path: _unique_on_source_path_some_false.then_some(monostate::MustBe!(false)),
                    },
                },
            )
            .boxed()
    }
}

impl<'a> proptest::arbitrary::Arbitrary for r5::ProvidedModuleDesc<'a> {
    type Parameters = ();
    type Strategy = BoxedStrategy<Self>;

    fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
        (r5::ModuleDesc::arbitrary(), bool::arbitrary())
            .prop_map(move |(desc, is_interface)| Self { desc, is_interface })
            .boxed()
    }
}

impl<'a> proptest::arbitrary::Arbitrary for r5::RequiredModuleDesc<'a> {
    type Parameters = ();
    type Strategy = BoxedStrategy<Self>;

    fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
        (
            r5::ModuleDesc::arbitrary(),
            r5::RequiredModuleDescLookupMethod::arbitrary(),
        )
            .prop_map(move |(desc, lookup_method)| Self { desc, lookup_method })
            .boxed()
    }
}

impl proptest::arbitrary::Arbitrary for r5::RequiredModuleDescLookupMethod {
    type Parameters = ();
    type Strategy = BoxedStrategy<Self>;

    fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
        prop_oneof![Just(Self::ByName), Just(Self::IncludeAngle), Just(Self::IncludeQuote)].boxed()
    }
}