Enum rustc_middle::ty::InstanceDef

pub enum InstanceDef<'tcx> {
    Item(WithOptConstParam<DefId>),
    Intrinsic(DefId),
    VtableShim(DefId),
    ReifyShim(DefId),
    FnPtrShim(DefId, Ty<'tcx>),
    Virtual(DefId, usize),
    ClosureOnceShim {
        call_once: DefId,
    },
    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_*.

NB: the (fn pointer) type must currently be monomorphic to avoid double substitution problems with the MIR shim bodies. Instance::resolve enforces this.

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.

Fields of ClosureOnceShim

call_once: DefId

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.

NB: the type must currently be monomorphic to avoid double substitution problems with the MIR shim bodies. Instance::resolve enforces this.

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.

NB: the type must currently be monomorphic to avoid double substitution problems with the MIR shim bodies. Instance::resolve enforces this.

Implementations

impl<'tcx> InstanceDef<'tcx>

pub fn def_id(self) -> 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

Returns true if the LLVM version of this instance is unconditionally marked with inline. This implies that a copy of this instance is generated in every codegen unit. Note that this is only a hint. See the documentation for generates_cgu_internal_copy for more information.

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

Returns true if the machine code for this instance is instantiated in each codegen unit that references it. Note that this is only a hint! The compiler can globally decide to not do this in order to speed up compilation. CGU-internal copies are only exist to enable inlining. If inlining is not performed (e.g. at -Copt-level=0) then the time for generating them is wasted and it's better to create a single copy with external linkage.

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

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Copy for InstanceDef<'tcx>

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

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

Formats the value using the given formatter.

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> Eq for InstanceDef<'tcx>

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

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, 

Feeds a slice of this type into the given [Hasher].

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

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

impl<'tcx> Key for InstanceDef<'tcx>

type CacheSelector = DefaultCacheSelector

fn query_crate(&self) -> CrateNum

Given an instance of this key, what crate is it referring to? This is used to find the provider.

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

In the event that a cycle occurs, if no explicit span has been given for a query with key self, what span should we use?

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> PartialEq<InstanceDef<'tcx>> for InstanceDef<'tcx>

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

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

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

This method tests for !=.

impl<'tcx> StructuralEq for InstanceDef<'tcx>

impl<'tcx> StructuralPartialEq for InstanceDef<'tcx>