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
/// Asserts that the type implements _all_ of the given traits. /// /// See [`assert_not_impl_all!`] for achieving the opposite effect. /// /// # Examples /// /// This can be used to ensure types implement auto traits such as [`Send`] and /// [`Sync`], as well as traits with [blanket `impl`s][blanket]. /// /// ``` /// # #[macro_use] extern crate static_assertions; fn main() {} /// assert_impl_all!(u32: Copy, Send); /// assert_impl_all!(&str: Into<String>); /// ``` /// /// The following example fails to compile because raw pointers do not implement /// [`Send`] since they cannot be moved between threads safely: /// /// ```compile_fail /// # #[macro_use] extern crate static_assertions; fn main() {} /// assert_impl_all!(*const u8: Send); /// ``` /// /// [`assert_not_impl_all!`]: macro.assert_not_impl_all.html /// [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html /// [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html /// [blanket]: https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methods #[macro_export] macro_rules! assert_impl_all { ($type:ty: $($trait:path),+ $(,)?) => { const _: fn() = || { fn assert_impl_all<T: ?Sized $(+ $trait)+>() {} assert_impl_all::<$type>(); }; }; } /// Asserts that the type does **not** implement _all_ of the given traits. /// /// This can be used to ensure types do not implement auto traits such as /// [`Send`] and [`Sync`], as well as traits with [blanket `impl`s][blanket]. /// /// Note that the combination of all provided traits is required to not be /// implemented. If you want to check that none of multiple traits are /// implemented you should invoke [`assert_not_impl_any!`] instead. /// /// # Examples /// /// Although `u32` implements `From<u16>`, it does not implement `Into<usize>`: /// /// ``` /// # #[macro_use] extern crate static_assertions; fn main() {} /// assert_not_impl_all!(u32: From<u16>, Into<usize>); /// ``` /// /// The following example fails to compile since `u32` can be converted into /// `u64`. /// /// ```compile_fail /// # #[macro_use] extern crate static_assertions; fn main() {} /// assert_not_impl_all!(u32: Into<u64>); /// ``` /// /// The following compiles because [`Cell`] is not both [`Sync`] _and_ [`Send`]: /// /// ``` /// # #[macro_use] extern crate static_assertions; fn main() {} /// use std::cell::Cell; /// /// assert_not_impl_all!(Cell<u32>: Sync, Send); /// ``` /// /// But it is [`Send`], so this fails to compile: /// /// ```compile_fail /// # #[macro_use] extern crate static_assertions; fn main() {} /// # std::cell::Cell; /// assert_not_impl_all!(Cell<u32>: Send); /// ``` /// /// [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html /// [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html /// [`assert_not_impl_any!`]: macro.assert_not_impl_any.html /// [`Cell`]: https://doc.rust-lang.org/std/cell/struct.Cell.html /// [blanket]: https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methods #[macro_export] macro_rules! assert_not_impl_all { ($x:ty: $($t:path),+ $(,)?) => { const _: fn() = || { #[allow(dead_code)] struct Invalid; trait AmbiguousIfImpl<A> { fn some_item() {} } impl<T: ?Sized> AmbiguousIfImpl<()> for T {} impl<T: ?Sized $(+ $t)+> AmbiguousIfImpl<Invalid> for T {} let _ = <$x as AmbiguousIfImpl<_>>::some_item; }; }; } /// Asserts that the type does **not** implement _any_ of the given traits. /// /// This can be used to ensure types do not implement auto traits such as /// [`Send`] and [`Sync`], as well as traits with [blanket `impl`s][blanket]. /// /// This macro causes a compilation failure if any of the provided individual /// traits are implemented for the type. If you want to check that a combination /// of traits is not implemented you should invoke [`assert_not_impl_all!`] /// instead. For single traits both macros behave the same. /// /// # Examples /// /// If `u32` were to implement `Into` conversions for `usize` _and_ for `u8`, /// the following would fail to compile: /// /// ``` /// # #[macro_use] extern crate static_assertions; fn main() {} /// assert_not_impl_any!(u32: Into<usize>, Into<u8>); /// ``` /// /// This is also good for simple one-off cases: /// /// ``` /// # #[macro_use] extern crate static_assertions; fn main() {} /// assert_not_impl_any!(&'static mut u8: Copy); /// ``` /// /// The following example fails to compile since `u32` can be converted into /// `u64` even though it can not be converted into a `u16`: /// /// ```compile_fail /// # #[macro_use] extern crate static_assertions; fn main() {} /// assert_not_impl_any!(u32: Into<u64>, Into<u16>); /// ``` /// /// [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html /// [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html /// [`assert_not_impl_all!`]: macro.assert_not_impl_all.html /// [blanket]: https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methods #[macro_export] macro_rules! assert_not_impl_any { ($x:ty: $($t:path),+ $(,)?) => { const _: fn() = || { trait AmbiguousIfImpl<A> { fn some_item() {} } impl<T: ?Sized> AmbiguousIfImpl<()> for T {} $({ #[allow(dead_code)] struct Invalid; impl<T: ?Sized + $t> AmbiguousIfImpl<Invalid> for T {} })+ let _ = <$x as AmbiguousIfImpl<_>>::some_item; }; }; }