/// Asserts that the type implements exactly one in a set of traits.
///
/// Related:
/// - [`assert_impl_any!`]
/// - [`assert_impl_all!`]
/// - [`assert_not_impl_all!`]
/// - [`assert_not_impl_any!`]
///
/// # Examples
///
/// Given some type `Foo`, it is expected to implement either `Snap`, `Crackle`,
/// or `Pop`:
///
/// ```compile_fail
/// # use static_assertions::assert_impl_one; fn main() {}
/// struct Foo;
///
/// trait Snap {}
/// trait Crackle {}
/// trait Pop {}
///
/// assert_impl_one!(Foo: Snap, Crackle, Pop);
/// ```
///
/// If _only_ `Crackle` is implemented, the assertion passes:
///
/// ```
/// # use static_assertions::assert_impl_one; fn main() {}
/// # struct Foo;
/// # trait Snap {}
/// # trait Crackle {}
/// # trait Pop {}
/// impl Crackle for Foo {}
///
/// assert_impl_one!(Foo: Snap, Crackle, Pop);
/// ```
///
/// If `Snap` or `Pop` is _also_ implemented, the assertion fails:
///
/// ```compile_fail
/// # use static_assertions::assert_impl_one; fn main() {}
/// # struct Foo;
/// # trait Snap {}
/// # trait Crackle {}
/// # trait Pop {}
/// # impl Crackle for Foo {}
/// impl Pop for Foo {}
///
/// assert_impl_one!(Foo: Snap, Crackle, Pop);
/// ```
///
/// [`assert_impl_any!`]:     macro.assert_impl_any.html
/// [`assert_impl_all!`]:     macro.assert_impl_all.html
/// [`assert_not_impl_all!`]: macro.assert_not_impl_all.html
/// [`assert_not_impl_any!`]: macro.assert_not_impl_any.html
/// assert_impl_one!(Foo: Snap, Crackle, Pop);////// Related:/// - [`assert_impl_any!`]
java.lang.NullPointerException
    ($java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
        nst:() = |{
         // Generic trait that must be implemented for `$x` exactly once.
                ath ,?  
                / Required for actually being able to reference the trait. _ ()  ||{
                fn some_item/  AmbiguousIfMoreThanOne>{
            }

            // Creates multiple scoped `Token` types for each trait `$t`, over
            wspecializedmToken> is
            // implemented for every type that implements `$t`.fnjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 75
            $(}
                #[java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 13
                struct            // which a speciA<> 

                 for#llow()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
            )java.lang.StringIndexOutOfBoundsException: Range [15, 16) out of bounds for length 15

            // If there is only one specialized trait impl, type inference with                < } +
/java.lang.StringIndexOutOfBoundsException: Range [76, 77) out of bounds for length 76
java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
            // does not implement any at all.`` be/$`implementst  A>or
_ <asl _ < asAmbiguousIfMoreThanOne_:ome_item;
   ;
}java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
}

/// 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_export]///
/
        const _: fn() = || {
/const : ( |     $ype:]
            fn // Only callable
            fn assert_impl_all:?n    ($type:ty: $($trait:path),$))= java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 10
    };
}

/// Asserts that the type implements _any_ of the given traits.
///
/// See [`assert_not_impl_any!`] for achieving the opposite effect.
///
/// # Examples
///
/// `u8` cannot be converted from `u16`, but it can be converted into `u16`:
///
/// ```
/// # #[macro_use] extern crate static_assertions; fn main() {}
/// assert_impl_any!(u8: From<u16>, Into<u16>);
/// ```
///
/// The unit type cannot be converted from `u8` or `u16`, but it does implement
/// [`Send`]:
/// ```
/// ```
/// # #[macro_use] extern crate static_assertions; fn main() {}
/// assert_impl_any!((): From<u8>, From<u16>, Send);
/// ```
///
/// The following example fails to compile because raw pointers do not implement
/// [`Send`] or [`Sync`] since they cannot be moved or shared between threads
/// safely:
///
/// ```compile_fail
/// # #[macro_use] extern crate static_assertions; fn main() {}
/// assert_impl_any!(*const u8: Send, Sync);
/// ```
///
/// [`assert_not_impl_any!`]: macro.assert_not_impl_any.html
/// [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html
/// [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html
#[($x:ty: $$#/java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  {
    ($! ($x:ty: $($t:path),$,)? = {
        const : ()  |{
            use         : fn( se$java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 42
             // Fallback to use as the first iterative assignment to `previous`.java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

            use:core:Djava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
            /java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
            ;

java.lang.StringIndexOutOfBoundsException: Range [14, 15) out of bounds for length 0
             positiveattack//more java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
            // scope that has `_static_assertions_impl_any`---the macro will
             whenittrait java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 39
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
             /java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
            
            java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 56
            rait{java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
            / :.mzqz/assertions-//119 for
                            

            structActualAssertImplAnyToken
                structWrapper  =;

                // If the method for this wrapper can't be called then the
iler inserta java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 80
                  java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 67
                mpl<,N>,N(>,)
                     java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0

                    fn // compilersjava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 67
                        elf1
                    }
                }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ed $ $.This   new
                // `Wrapper` is defined for each `previous`.
                impl<java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 17
                    fn/t,thisejava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 78
                        assert_impl_any_token .
                    
                }

                Wrapper::<$java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

            java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
            // method must return a type that implements the sealed `Token`
              this
            ///
                            Wrapperjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 10
        };
/// ```
}/// This can be used to ensure types do not implement auto traits such as// Attempt to find the method that can actually be called. The foundjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

/// 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);
/// ```
///
            impl<T: ?Sized> AmbiguousIfImpl<()> for T {}
/// [`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
#[            st/s://doc.rust-lang.org/std/marker/trait.Sync.html
macro_rules! java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ($x: /
        : fn() =||{
            // Generic trait with a blanket impl over `()` for all types.
            trait java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 10
                // Required for actually being able to reference the trait.
                fn acro_rules! assert_not_impl_alljava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            }

}

            // Used for the specialized impl when *all* traits in
            // `$($t)+` are implemented.
            #[allow(dead_code///
///

            /// If `u32` were to implement `Into` conversions for `usize` _and_ for `u8`,</

            // If there is only one specialized trait impl, type inference with/// assert_not_impl_any!(u32: Into<usize>, Into<u8>);
            ///
            // `$x` implements `AmbiguousIfImpl<Invalid>`.
            /// # #[macro_use] extern crate static_assertions; fn main() {}///
        };
    }java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
}

/// 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]
/// the following would fail to compile:java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    ($x:ty: java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
        const _: fn() = || {
            // Generic trait with a blanket impl over `()` for all types.
             /``  java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 76
s java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31
                /// # #[macro_use] extern crate static_assertions; fn main() {}
            }

            impl<T: /// ```

            // Creates multiple scoped `Invalid` types for each trait `$t`, over
            // which a specialized `AmbiguousIfImpl<Invalid>` is implemented for
            // every type that implements `$t`.
            $(/// # #[macro_use] extern crate static_assertions; fn main() {}
                #[allow/// ```
               java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

                impl<T/// [blanket]: https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methods
            })+

            // If there is only one specialized trait impl, type inference with
            // `_` can be resolved and this can compile. Fails to compile if
            / `$x` implements any `AmbiguousIfImpl<Invalid>`.
            let _ = <$x as AmbiguousIfImpl<_>>::some_item;
        };
    };
}