Enum rustc_middle::ty::InstanceDef[−][src]

pub enum InstanceDef<'tcx> {
    Item(WithOptConstParam<DefId>),
    Intrinsic(DefId),
    VtableShim(DefId),
    ReifyShim(DefId),
    FnPtrShim(DefId, Ty<'tcx>),
    Virtual(DefId, usize),
    ClosureOnceShim {
        call_once: DefId,
        track_caller: bool,
    },
    DropGlue(DefId, Option<Ty<'tcx>>),
    CloneShim(DefId, Ty<'tcx>),
}

Variants

Item(WithOptConstParam<DefId>)

A user-defined callable item.

This includes:

fn items
closures
generators

Tuple Fields of Item

0: WithOptConstParam<DefId>

Intrinsic(DefId)

An intrinsic fn item (with "rust-intrinsic" or "platform-intrinsic" ABI).

Alongside Virtual, this is the only InstanceDef that does not have its own callable MIR. Instead, codegen and const eval “magically” evaluate calls to intrinsics purely in the caller.

Tuple Fields of Intrinsic

0: DefId

VtableShim(DefId)

<T as Trait>::method where method receives unsizeable self: Self (part of the unsized_locals feature).

The generated shim will take Self via *mut Self - conceptually this is &owned Self - and dereference the argument to call the original function.

Tuple Fields of VtableShim

0: DefId

ReifyShim(DefId)

fn() pointer where the function itself cannot be turned into a pointer.

One example is <dyn Trait as Trait>::fn, where the shim contains a virtual call, which codegen supports only via a direct call to the <dyn Trait as Trait>::fn instance (an InstanceDef::Virtual).

Another example is functions annotated with #[track_caller], which must have their implicit caller location argument populated for a call. Because this is a required part of the function’s ABI but can’t be tracked as a property of the function pointer, we use a single “caller location” (the definition of the function itself).

Tuple Fields of ReifyShim

0: DefId

FnPtrShim(DefId, Ty<'tcx>)

<fn() as FnTrait>::call_* (generated FnTrait implementation for fn() pointers).

DefId is FnTrait::call_*.

Tuple Fields of FnPtrShim

0: DefId1: Ty<'tcx>

Virtual(DefId, usize)

Dynamic dispatch to <dyn Trait as Trait>::fn.

This InstanceDef does not have callable MIR. Calls to Virtual instances must be codegen’d as virtual calls through the vtable.

If this is reified to a fn pointer, a ReifyShim is used (see ReifyShim above for more details on that).

Tuple Fields of Virtual

0: DefId1: usize

ClosureOnceShim

<[FnMut closure] as FnOnce>::call_once.

The DefId is the ID of the call_once method in FnOnce.

Fields of ClosureOnceShim

call_once: DefIdtrack_caller: bool

DropGlue(DefId, Option<Ty<'tcx>>)

core::ptr::drop_in_place::<T>.

The DefId is for core::ptr::drop_in_place. The Option<Ty<'tcx>> is either Some(T), or None for empty drop glue.

Tuple Fields of DropGlue

0: DefId1: Option<Ty<'tcx>>

CloneShim(DefId, Ty<'tcx>)

Compiler-generated <T as Clone>::clone implementation.

For all types that automatically implement Copy, a trivial Clone impl is provided too. Additionally, arrays, tuples, and closures get a Clone shim even if they aren’t Copy.

The DefId is for Clone::clone, the Ty is the type T with the builtin Clone impl.

Tuple Fields of CloneShim

0: DefId1: Ty<'tcx>

Enum rustc_middle::ty::InstanceDef[−][src]

Variants

Tuple Fields of Item

Tuple Fields of Intrinsic

Tuple Fields of VtableShim

Tuple Fields of ReifyShim

Tuple Fields of FnPtrShim

Tuple Fields of Virtual

Fields of ClosureOnceShim

Tuple Fields of DropGlue

Tuple Fields of CloneShim

Implementations

impl<'tcx> InstanceDef<'tcx>

pub fn def_id(self) -> DefId

pub fn def_id_if_not_guaranteed_local_codegen(self) -> Option<DefId>

pub fn with_opt_param(self) -> WithOptConstParam<DefId>

pub fn attrs(&self, tcx: TyCtxt<'tcx>) -> Attributes<'tcx>

pub fn requires_inline(&self, tcx: TyCtxt<'tcx>) -> bool

pub fn generates_cgu_internal_copy(&self, tcx: TyCtxt<'tcx>) -> bool

pub fn requires_caller_location(&self, tcx: TyCtxt<'_>) -> bool

pub fn has_polymorphic_mir_body(&self) -> bool

Trait Implementations

impl<'tcx> Clone for InstanceDef<'tcx>

fn clone(&self) -> InstanceDef<'tcx>

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

impl<'tcx> Debug for InstanceDef<'tcx>

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

impl<'tcx, __D: TyDecoder<'tcx>> Decodable<__D> for InstanceDef<'tcx>

fn decode(__decoder: &mut __D) -> Result<Self, <__D as Decoder>::Error>

impl<'tcx, __E: TyEncoder<'tcx>> Encodable<__E> for InstanceDef<'tcx>

fn encode(&self, __encoder: &mut __E) -> Result<(), <__E as Encoder>::Error>

impl<'tcx> Hash for InstanceDef<'tcx>

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

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

impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for InstanceDef<'tcx>

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

impl<'a, 'tcx> Lift<'tcx> for InstanceDef<'a>

type Lifted = InstanceDef<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'tcx> Ord for InstanceDef<'tcx>

fn cmp(&self, other: &InstanceDef<'tcx>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

fn clamp(self, min: Self, max: Self) -> Self

impl<'tcx> PartialEq<InstanceDef<'tcx>> for InstanceDef<'tcx>

fn eq(&self, other: &InstanceDef<'tcx>) -> bool

fn ne(&self, other: &InstanceDef<'tcx>) -> bool

impl<'tcx> PartialOrd<InstanceDef<'tcx>> for InstanceDef<'tcx>

fn partial_cmp(&self, other: &InstanceDef<'tcx>) -> Option<Ordering>

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

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

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

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

impl<'tcx> TypeFoldable<'tcx> for InstanceDef<'tcx>

fn super_fold_with<__F: TypeFolder<'tcx>>(self, __folder: &mut __F) -> Self

fn super_visit_with<__F: TypeVisitor<'tcx>>( &self, __folder: &mut __F) -> ControlFlow<__F::BreakTy>

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

fn visit_with<V: TypeVisitor<'tcx>>( &self, visitor: &mut V) -> ControlFlow<V::BreakTy>

fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool

fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool

fn has_escaping_bound_vars(&self) -> bool

fn definitely_has_type_flags(&self, tcx: TyCtxt<'tcx>, flags: TypeFlags) -> bool

fn has_type_flags(&self, flags: TypeFlags) -> bool

fn has_projections(&self) -> bool

fn has_opaque_types(&self) -> bool

fn references_error(&self) -> bool

fn potentially_has_param_types_or_consts(&self) -> bool

fn definitely_has_param_types_or_consts(&self, tcx: TyCtxt<'tcx>) -> bool

fn has_infer_regions(&self) -> bool

fn has_infer_types(&self) -> bool

fn has_infer_types_or_consts(&self) -> bool

fn needs_infer(&self) -> bool

fn has_placeholders(&self) -> bool

fn potentially_needs_subst(&self) -> bool

fn definitely_needs_subst(&self, tcx: TyCtxt<'tcx>) -> bool

fn has_free_regions(&self, tcx: TyCtxt<'tcx>) -> bool

fn has_erased_regions(&self) -> bool

fn has_erasable_regions(&self, tcx: TyCtxt<'tcx>) -> bool

fn is_known_global(&self) -> bool

fn is_global(&self, tcx: TyCtxt<'tcx>) -> bool

impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for InstanceDef<'tcx>

fn decode(decoder: &mut D) -> Result<Self, <__D as Decoder>::Error>

impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for InstanceDef<'tcx>

fn encode(&self, encoder: &mut E) -> Result<(), <__E as Encoder>::Error>

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

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

impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for InstanceDef<'tcx>

fn hash_stable(
&self,
hcx: &mut StableHashingContext<'ctx>,
__hasher: &mut StableHasher
)

fn super_fold_with<F: TypeFolder<'tcx>>(self, folder: &mut __F) -> Self

fn super_visit_with<F: TypeVisitor<'tcx>>(
&self,
folder: &mut F
) -> ControlFlow<F::BreakTy>

fn visit_with<V: TypeVisitor<'tcx>>(
&self,
visitor: &mut V
) -> ControlFlow<V::BreakTy>

impl<T> Any for T where
T: 'static + ?Sized,

impl<'tcx, T> ArenaAllocatable<'tcx, ()> for T where
T: Copy,

pub fn allocate_from_iter(
&'a Arena<'tcx>,
impl IntoIterator<Item = T>
) -> &'a mut [T]

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<Ctxt, T> DepNodeParams<Ctxt> for T where
Ctxt: DepContext,
T: for<'a> HashStable<StableHashingContext<'a>> + Debug,

pub default fn recover(
Ctxt,
&DepNode<<Ctxt as DepContext>::DepKind>
) -> Option<T>

impl<T, U> Into<U> for T where
U: From<T>,

impl<'tcx, T> Subst<'tcx> for T where
T: TypeFoldable<'tcx>,

impl<T> ToOwned for T where
T: Clone,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

impl<'a, T> Captures<'a> for T where
T: ?Sized,