forward_ref_unop!(impl $imp, $method for $t,
#[stable(feature = "rust1", since = "1.0.0")]);
};
+ (impl const $imp:ident, $method:ident for $t:ty) => {
+ forward_ref_unop!(impl const $imp, $method for $t,
+ #[stable(feature = "rust1", since = "1.0.0")]);
+ };
+ // Equivalent to the non-const version, with the addition of `rustc_const_unstable`
+ (impl const $imp:ident, $method:ident for $t:ty, #[$attr:meta]) => {
+ #[$attr]
+ #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+ impl const $imp for &$t {
+ type Output = <$t as $imp>::Output;
+
+ #[inline]
+ fn $method(self) -> <$t as $imp>::Output {
+ $imp::$method(*self)
+ }
+ }
+ };
(impl $imp:ident, $method:ident for $t:ty, #[$attr:meta]) => {
#[$attr]
impl $imp for &$t {
forward_ref_binop!(impl $imp, $method for $t, $u,
#[stable(feature = "rust1", since = "1.0.0")]);
};
+ (impl const $imp:ident, $method:ident for $t:ty, $u:ty) => {
+ forward_ref_binop!(impl const $imp, $method for $t, $u,
+ #[stable(feature = "rust1", since = "1.0.0")]);
+ };
+ // Equivalent to the non-const version, with the addition of `rustc_const_unstable`
+ (impl const $imp:ident, $method:ident for $t:ty, $u:ty, #[$attr:meta]) => {
+ #[$attr]
+ #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+ impl<'a> const $imp<$u> for &'a $t {
+ type Output = <$t as $imp<$u>>::Output;
+
+ #[inline]
+ fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
+ $imp::$method(*self, other)
+ }
+ }
+
+ #[$attr]
+ #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+ impl const $imp<&$u> for $t {
+ type Output = <$t as $imp<$u>>::Output;
+
+ #[inline]
+ fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
+ $imp::$method(self, *other)
+ }
+ }
+
+ #[$attr]
+ #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+ impl const $imp<&$u> for &$t {
+ type Output = <$t as $imp<$u>>::Output;
+
+ #[inline]
+ fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
+ $imp::$method(*self, *other)
+ }
+ }
+ };
(impl $imp:ident, $method:ident for $t:ty, $u:ty, #[$attr:meta]) => {
#[$attr]
impl<'a> $imp<$u> for &'a $t {
forward_ref_op_assign!(impl $imp, $method for $t, $u,
#[stable(feature = "op_assign_builtins_by_ref", since = "1.22.0")]);
};
+ (impl const $imp:ident, $method:ident for $t:ty, $u:ty) => {
+ forward_ref_op_assign!(impl const $imp, $method for $t, $u,
+ #[stable(feature = "op_assign_builtins_by_ref", since = "1.22.0")]);
+ };
+ // Equivalent to the non-const version, with the addition of `rustc_const_unstable`
+ (impl const $imp:ident, $method:ident for $t:ty, $u:ty, #[$attr:meta]) => {
+ #[$attr]
+ #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+ impl const $imp<&$u> for $t {
+ #[inline]
+ fn $method(&mut self, other: &$u) {
+ $imp::$method(self, *other);
+ }
+ }
+ };
(impl $imp:ident, $method:ident for $t:ty, $u:ty, #[$attr:meta]) => {
#[$attr]
impl $imp<&$u> for $t {
)+
}
}
+
+/// A macro for defining `#[cfg]` if-else statements.
+///
+/// `cfg_if` is similar to the `if/elif` C preprocessor macro by allowing definition of a cascade
+/// of `#[cfg]` cases, emitting the implementation which matches first.
+///
+/// This allows you to conveniently provide a long list `#[cfg]`'d blocks of code without having to
+/// rewrite each clause multiple times.
+///
+/// # Example
+///
+/// ```
+/// cfg_if! {
+/// if #[cfg(unix)] {
+/// fn foo() { /* unix specific functionality */ }
+/// } else if #[cfg(target_pointer_width = "32")] {
+/// fn foo() { /* non-unix, 32-bit functionality */ }
+/// } else {
+/// fn foo() { /* fallback implementation */ }
+/// }
+/// }
+///
+/// # fn main() {}
+/// ```
+// This is a copy of `cfg_if!` from the `cfg_if` crate.
+// The recursive invocations should use $crate if this is ever exported.
+macro_rules! cfg_if {
+ // match if/else chains with a final `else`
+ (
+ $(
+ if #[cfg( $i_meta:meta )] { $( $i_tokens:tt )* }
+ ) else+
+ else { $( $e_tokens:tt )* }
+ ) => {
+ cfg_if! {
+ @__items () ;
+ $(
+ (( $i_meta ) ( $( $i_tokens )* )) ,
+ )+
+ (() ( $( $e_tokens )* )) ,
+ }
+ };
+
+ // match if/else chains lacking a final `else`
+ (
+ if #[cfg( $i_meta:meta )] { $( $i_tokens:tt )* }
+ $(
+ else if #[cfg( $e_meta:meta )] { $( $e_tokens:tt )* }
+ )*
+ ) => {
+ cfg_if! {
+ @__items () ;
+ (( $i_meta ) ( $( $i_tokens )* )) ,
+ $(
+ (( $e_meta ) ( $( $e_tokens )* )) ,
+ )*
+ }
+ };
+
+ // Internal and recursive macro to emit all the items
+ //
+ // Collects all the previous cfgs in a list at the beginning, so they can be
+ // negated. After the semicolon is all the remaining items.
+ (@__items ( $( $_:meta , )* ) ; ) => {};
+ (
+ @__items ( $( $no:meta , )* ) ;
+ (( $( $yes:meta )? ) ( $( $tokens:tt )* )) ,
+ $( $rest:tt , )*
+ ) => {
+ // Emit all items within one block, applying an appropriate #[cfg]. The
+ // #[cfg] will require all `$yes` matchers specified and must also negate
+ // all previous matchers.
+ #[cfg(all(
+ $( $yes , )?
+ not(any( $( $no ),* ))
+ ))]
+ cfg_if! { @__identity $( $tokens )* }
+
+ // Recurse to emit all other items in `$rest`, and when we do so add all
+ // our `$yes` matchers to the list of `$no` matchers as future emissions
+ // will have to negate everything we just matched as well.
+ cfg_if! {
+ @__items ( $( $no , )* $( $yes , )? ) ;
+ $( $rest , )*
+ }
+ };
+
+ // Internal macro to make __apply work out right for different match types,
+ // because of how macros match/expand stuff.
+ (@__identity $( $tokens:tt )* ) => {
+ $( $tokens )*
+ };
+}
projects / rust.git / blobdiff