1 //! A macro for defining `#[cfg]` if-else statements. 2 //! 3 //! The macro provided by this crate, `cfg_if`, is similar to the `if/elif` C 4 //! preprocessor macro by allowing definition of a cascade of `#[cfg]` cases, 5 //! emitting the implementation which matches first. 6 //! 7 //! This allows you to conveniently provide a long list `#[cfg]`'d blocks of code 8 //! without having to rewrite each clause multiple times. 9 //! 10 //! # Example 11 //! 12 //! ``` 13 //! cfg_if::cfg_if! { 14 //! if #[cfg(unix)] { 15 //! fn foo() { /* unix specific functionality */ } 16 //! } else if #[cfg(target_pointer_width = "32")] { 17 //! fn foo() { /* non-unix, 32-bit functionality */ } 18 //! } else { 19 //! fn foo() { /* fallback implementation */ } 20 //! } 21 //! } 22 //! 23 //! # fn main() {} 24 //! ``` 25 26 #![no_std] 27 #![doc(html_root_url = "https://docs.rs/cfg-if")] 28 #![deny(missing_docs)] 29 #![cfg_attr(test, deny(warnings))] 30 31 /// The main macro provided by this crate. See crate documentation for more 32 /// information. 33 #[macro_export] 34 macro_rules! cfg_if { 35 // match if/else chains with a final `else` 36 ($( 37 if #[cfg($meta:meta)] { $($tokens:tt)* } 38 ) else * else { 39 $($tokens2:tt)* 40 }) => { 41 $crate::cfg_if! { 42 @__items 43 () ; 44 $( ( ($meta) ($($tokens)*) ), )* 45 ( () ($($tokens2)*) ), 46 } 47 }; 48 49 // match if/else chains lacking a final `else` 50 ( 51 if #[cfg($i_met:meta)] { $($i_tokens:tt)* } 52 $( 53 else if #[cfg($e_met:meta)] { $($e_tokens:tt)* } 54 )* 55 ) => { 56 $crate::cfg_if! { 57 @__items 58 () ; 59 ( ($i_met) ($($i_tokens)*) ), 60 $( ( ($e_met) ($($e_tokens)*) ), )* 61 ( () () ), 62 } 63 }; 64 65 // Internal and recursive macro to emit all the items 66 // 67 // Collects all the negated cfgs in a list at the beginning and after the 68 // semicolon is all the remaining items 69 (@__items ($($not:meta,)*) ; ) => {}; 70 (@__items ($($not:meta,)*) ; ( ($($m:meta),*) ($($tokens:tt)*) ), $($rest:tt)*) => { 71 // Emit all items within one block, applying an appropriate #[cfg]. The 72 // #[cfg] will require all `$m` matchers specified and must also negate 73 // all previous matchers. 74 #[cfg(all($($m,)* not(any($($not),*))))] $crate::cfg_if! { @__identity $($tokens)* } 75 76 // Recurse to emit all other items in `$rest`, and when we do so add all 77 // our `$m` matchers to the list of `$not` matchers as future emissions 78 // will have to negate everything we just matched as well. 79 $crate::cfg_if! { @__items ($($not,)* $($m,)*) ; $($rest)* } 80 }; 81 82 // Internal macro to make __apply work out right for different match types, 83 // because of how macros matching/expand stuff. 84 (@__identity $($tokens:tt)*) => { 85 $($tokens)* 86 }; 87 } 88 89 #[cfg(test)] 90 mod tests { 91 cfg_if! { 92 if #[cfg(test)] { 93 use core::option::Option as Option2; 94 fn works1() -> Option2<u32> { Some(1) } 95 } else { 96 fn works1() -> Option<u32> { None } 97 } 98 } 99 100 cfg_if! { 101 if #[cfg(foo)] { 102 fn works2() -> bool { false } 103 } else if #[cfg(test)] { 104 fn works2() -> bool { true } 105 } else { 106 fn works2() -> bool { false } 107 } 108 } 109 110 cfg_if! { 111 if #[cfg(foo)] { 112 fn works3() -> bool { false } 113 } else { 114 fn works3() -> bool { true } 115 } 116 } 117 118 cfg_if! { 119 if #[cfg(test)] { 120 use core::option::Option as Option3; 121 fn works4() -> Option3<u32> { Some(1) } 122 } 123 } 124 125 cfg_if! { 126 if #[cfg(foo)] { 127 fn works5() -> bool { false } 128 } else if #[cfg(test)] { 129 fn works5() -> bool { true } 130 } 131 } 132 133 #[test] it_works()134 fn it_works() { 135 assert!(works1().is_some()); 136 assert!(works2()); 137 assert!(works3()); 138 assert!(works4().is_some()); 139 assert!(works5()); 140 } 141 142 #[test] 143 #[allow(clippy::assertions_on_constants)] test_usage_within_a_function()144 fn test_usage_within_a_function() { 145 cfg_if! {if #[cfg(debug_assertions)] { 146 // we want to put more than one thing here to make sure that they 147 // all get configured properly. 148 assert!(cfg!(debug_assertions)); 149 assert_eq!(4, 2+2); 150 } else { 151 assert!(works1().is_some()); 152 assert_eq!(10, 5+5); 153 }} 154 } 155 156 trait Trait { blah(&self)157 fn blah(&self); 158 } 159 160 #[allow(dead_code)] 161 struct Struct; 162 163 impl Trait for Struct { 164 cfg_if! { 165 if #[cfg(feature = "blah")] { 166 fn blah(&self) { 167 unimplemented!(); 168 } 169 } else { 170 fn blah(&self) { 171 unimplemented!(); 172 } 173 } 174 } 175 } 176 } 177