Enum rustc_resolve::ty::InstanceDef [−][src]
pub enum InstanceDef<'tcx> {
Item(WithOptConstParam<DefId>),
Intrinsic(DefId),
VtableShim(DefId),
ReifyShim(DefId),
FnPtrShim(DefId, &'tcx TyS<'tcx>),
Virtual(DefId, usize),
ClosureOnceShim {
call_once: DefId,
track_caller: bool,
},
DropGlue(DefId, Option<&'tcx TyS<'tcx>>),
CloneShim(DefId, &'tcx TyS<'tcx>),
}Variants
Item(WithOptConstParam<DefId>)
Tuple Fields
A user-defined callable item.
This includes:
fnitems- closures
- generators
Intrinsic(DefId)
Tuple Fields
0: DefIdAn 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)
Tuple Fields
0: 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)
Tuple Fields
0: DefIdfn() 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, &'tcx TyS<'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
<[FnMut closure] as FnOnce>::call_once.
The DefId is the ID of the call_once method in FnOnce.
DropGlue(DefId, Option<&'tcx TyS<'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, &'tcx TyS<'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.
Auto Trait Implementations
impl<'tcx> !RefUnwindSafe for InstanceDef<'tcx>
impl<'tcx> !Send for InstanceDef<'tcx>
impl<'tcx> !Sync for InstanceDef<'tcx>
impl<'tcx> Unpin for InstanceDef<'tcx>
impl<'tcx> !UnwindSafe for InstanceDef<'tcx>
Blanket Implementations
Mutably borrows from an owned value. Read more
pub fn subst_spanned(
self,
tcx: TyCtxt<'tcx>,
substs: &[GenericArg<'tcx>],
span: Option<Span>
) -> T
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: 24 bytes
Size for each variant:
Item: 19 bytesIntrinsic: 11 bytesVtableShim: 11 bytesReifyShim: 11 bytesFnPtrShim: 23 bytesVirtual: 23 bytesClosureOnceShim: 11 bytesDropGlue: 23 bytesCloneShim: 23 bytes