// Language features:

// tidy-alphabetical-start

#![cfg_attr(bootstrap, feature(asm_const))]

#![cfg_attr(bootstrap, feature(const_fn_floating_point_arithmetic))]

#![cfg_attr(bootstrap, feature(min_exhaustive_patterns))]

#![feature(abi_unadjusted)]

#![feature(adt_const_params)]

#![feature(cfg_sanitize)]

#![feature(cfg_target_has_atomic)]

#![feature(cfg_target_has_atomic_equal_alignment)]

#![feature(const_fn_floating_point_arithmetic)]

#![feature(const_for)]

#![feature(const_mut_refs)]

#![feature(const_precise_live_drops)]

pub trait TyCompat<T: ?Sized> {}

impl<T: ?Sized> TyCompat<T> for T {}

impl<T: ?Sized> TyCompat<T> for Maybe {}

impl<T: ?Sized> TyCompat<Maybe> for T {}

#[lang = "EffectsIntersection"]

(p as *const ()) == (q as *const ())

}

/// Compares the *addresses* of the two function pointers for equality.

///

/// Function pointers comparisons can have surprising results since

/// they are never guaranteed to be unique and could vary between different

/// code generation units. Furthermore, different functions could have the

/// same address after being merged together.

///

/// This is the same as `f == g` but using this function makes clear

/// that you are aware of these potentially surprising semantics.

///

/// # Examples

///

/// ```

/// #![feature(ptr_fn_addr_eq)]

/// use std::ptr;

///

/// fn a() { println!("a"); }

/// fn b() { println!("b"); }

/// assert!(!ptr::fn_addr_eq(a as fn(), b as fn()));

/// ```

#[unstable(feature = "ptr_fn_addr_eq", issue = "129322")]

#[inline(always)]

#[must_use = "function pointer comparison produces a value"]

pub fn fn_addr_eq<T: FnPtr, U: FnPtr>(f: T, g: U) -> bool {

f.addr() == g.addr()

}

/// Hash a raw pointer.

///

/// This can be used to hash a `&T` reference (which coerces to `*const T` implicitly)

if cfg!(miri) {

let _ = writeln!(

err,

"note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` \

"note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` \

for the environment variable to have an effect"

);

}