Enum rustc_middle::ty::instance::InstanceDef

source · [−]

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

`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.

`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.

`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).

`FnPtrShim(DefId, Ty<'tcx>)`

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

DefId is FnTrait::call_*.

`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).

`ClosureOnceShim`

Fields

call_once: DefId

track_caller: bool

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

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

`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.

`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.

Enum rustc_middle::ty::instance::InstanceDef

Variants

Item(WithOptConstParam<DefId>)

Intrinsic(DefId)

VtableShim(DefId)

ReifyShim(DefId)

FnPtrShim(DefId, Ty<'tcx>)

Virtual(DefId, usize)

ClosureOnceShim

Fields

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

CloneShim(DefId, Ty<'tcx>)

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) -> Self

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 try_super_fold_with<__F: FallibleTypeFolder<'tcx>>( self, __folder: &mut __F) -> Result<Self, __F::Error>

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

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

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

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

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 has_type_flags(&self, flags: TypeFlags) -> bool

fn has_projections(&self) -> bool

fn has_opaque_types(&self) -> bool

fn references_error(&self) -> bool

fn has_param_types_or_consts(&self) -> 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 needs_subst(&self) -> bool

fn has_free_regions(&self) -> bool

fn has_erased_regions(&self) -> bool

fn has_erasable_regions(&self) -> bool

fn is_global(&self) -> bool

fn has_late_bound_regions(&self) -> bool

`Item(WithOptConstParam<DefId>)`

`Intrinsic(DefId)`

`VtableShim(DefId)`

`ReifyShim(DefId)`

`FnPtrShim(DefId, Ty<'tcx>)`

`Virtual(DefId, usize)`

`ClosureOnceShim`

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

`CloneShim(DefId, Ty<'tcx>)`

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

fn decode(decoder: &mut D) -> Self

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 try_super_fold_with<F: FallibleTypeFolder<'tcx>>(
self,
folder: &mut F
) -> Result<Self, F::Error>

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

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

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, IsCopy> for T where
T: Copy,

fn allocate_from_iter<'a>(
arena: &'a Arena<'tcx>,
iter: impl IntoIterator<Item = Self>
) -> &'a mut [Self]ⓘNotable traits for &'_ [u8 ]`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`

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>,

fn subst_spanned(
self,
tcx: TyCtxt<'tcx>,
substs: &[GenericArg<'tcx>],
span: Option<Span>
) -> T

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,