conflicting 0.1.0

A library to generate compile time errors for mutually exclusive feature flags.
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

use proc_macro::TokenStream;

mod input;

/// The conflicting macro lets you pass a set of feature gated expressions that transitively conflict with
/// each other. (ie. a feature conflicts with the powerset of all other features in the block)
///
/// You may have expressions gated by features a, b, and c, but theyre all mutually
/// exclusive. To handle this macro will throw an error at compile time. 
///
/// # Example
///
/// ```ignore
///     fn new() -> &'static str {
///         conflicting! {
///             a => {
///                 "a"
///             },
///             b => {
///                 "b"
///             },
///             c => {
///                 "c"
///             },
///         }
///     }
/// ```
///
/// This will generate something like:
/// ```ignore
///     fn new() -> &'static str {
///         #[cfg(feature = "a")]
///         {
///             "a"
///             
///             #[cfg(feature = "b")]
///             compile_error!("a conflicts with b");
///
///             #[cfg(feature = "c")]
///             compile_error!("a conflicts with c");
///         }
///
///         #[cfg(feature = "b")]
///         {
///             "b"

///             #[cfg(feature = "a")]
///             compile_error!("b conflicts with a");
///
///             #[cfg(feature = "c")]
///             compile_error!("b conflicts with c");
///         }
///
///         #[cfg(feature = "c")]
///         {
///             "c"
///
///             #[cfg(feature = "a")]
///             compile_error!("c conflicts with a");
///
///             #[cfg(feature = "b")]
///             compile_error!("c conflicts with b");
///         }
///     }
/// ```   
#[proc_macro]
pub fn conflicting(input: TokenStream) -> TokenStream {
    let input = syn::parse_macro_input!(input as input::ConflictingInput);

    let out: proc_macro2::TokenStream = input.0.iter().map(|gated_expr| {
        let feature = &gated_expr.feature;
        let expr = &gated_expr.expr;

        let conflicting_cases = input.0.iter()
            .filter(|other| other.feature != *feature)
            .map(|other| {
                let other_feature = &other.feature;
                quote::quote! {
                    #[cfg(feature = #other_feature)]
                    {
                        compile_error!(concat!(stringify!(#feature), " conflicts with ", stringify!(#other_feature)));
                    }
                }
            });

        quote::quote! {
            #[cfg(feature = #feature)]
            {
                #(#conflicting_cases)*

                #expr 
            }
        }
    })
    .collect();

    out.into()
}