Enum rustc_middle::ty::adjustment::PointerCoercion

pub enum PointerCoercion {
    ReifyFnPointer,
    UnsafeFnPointer,
    ClosureFnPointer(Unsafety),
    MutToConstPointer,
    ArrayToPointer,
    Unsize,
}

Variants

ReifyFnPointer

Go from a fn-item type to a fn-pointer type.

UnsafeFnPointer

Go from a safe fn pointer to an unsafe fn pointer.

ClosureFnPointer(Unsafety)

Go from a non-capturing closure to an fn pointer or an unsafe fn pointer. It cannot convert a closure that requires unsafe.

MutToConstPointer

Go from a mut raw pointer to a const raw pointer.

ArrayToPointer

Go from *const [T; N] to *const T

Unsize

Unsize a pointer/reference value, e.g., &[T; n] to &[T]. Note that the source could be a thin or fat pointer. This will do things like convert thin pointers to fat pointers, or convert structs containing thin pointers to structs containing fat pointers, or convert between fat pointers. We don’t store the details of how the transform is done (in fact, we don’t know that, because it might depend on the precise type parameters). We just store the target type. Codegen backends and miri figure out what has to be done based on the precise source/target type at hand.

Trait Implementations

impl Clone for PointerCoercion

fn clone(&self) -> PointerCoercion

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PointerCoercion

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'tcx, __D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<__D> for PointerCoercion

fn decode(__decoder: &mut __D) -> Self

impl<'tcx, __E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<__E> for PointerCoercion

fn encode(&self, __encoder: &mut __E)

impl Hash for PointerCoercion

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for PointerCoercion

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher )

impl PartialEq<PointerCoercion> for PointerCoercion

fn eq(&self, other: &PointerCoercion) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for PointerCoercion

fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, _: &mut F ) -> Result<Self, F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, _: &mut F) -> Self

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for PointerCoercion

fn visit_with<F: TypeVisitor<TyCtxt<'tcx>>>( &self, _: &mut F ) -> ControlFlow<F::BreakTy>

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl Copy for PointerCoercion

impl Eq for PointerCoercion

impl StructuralEq for PointerCoercion

impl StructuralPartialEq for PointerCoercion

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1 byte

Size for each variant:

• ReifyFnPointer: 0 bytes
• UnsafeFnPointer: 0 bytes
• ClosureFnPointer: 1 byte
• MutToConstPointer: 0 bytes
• ArrayToPointer: 0 bytes
• Unsize: 0 bytes