Enum rustc_middle::ty::instance::InstanceDef

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

Variants

Item(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.

ThreadLocalShim(DefId)

Compiler-generated accessor for thread locals which returns a reference to the thread local the DefId defines. This is used to export thread locals from dylibs on platforms lacking native support.

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.

FnPtrAddrShim(DefId, Ty<'tcx>)

Compiler-generated <T as FnPtr>::addr implementation.

Automatically generated for all potentially higher-ranked fn(I) -> R types.

The DefId is for FnPtr::addr, the Ty is the type T.

Implementations

impl<'tcx> InstanceDef<'tcx>

pub fn def_id(self) -> DefId

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

Returns the DefId of instances which might not require codegen locally.

pub fn get_attrs( &self, tcx: TyCtxt<'tcx>, attr: Symbol ) -> impl Iterator<Item = &'tcx Attribute>

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

pub fn has_polymorphic_mir_body(&self) -> bool

Returns true when the MIR body associated with this instance should be monomorphized by its users (e.g. codegen or miri) by substituting the args from Instance (see Instance::args_for_mir_body).

Otherwise, returns false only for some kinds of shims where the construction of the MIR body should perform necessary substitutions.

Trait Implementations

impl<'tcx> AsLocalKey for InstanceDef<'tcx>

type LocalKey = InstanceDef<'tcx>

fn as_local_key(&self) -> Option<Self::LocalKey>

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

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

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

Formats the value using the given formatter.

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

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

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

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

impl<'tcx> EraseType for InstanceDef<'tcx>

type Result = [u8; 24]

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, Self: Sized,

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

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?

fn key_as_def_id(&self) -> Option<DefId>

If the key is a DefId or DefId–equivalent, return that DefId. Otherwise, return None.

fn ty_adt_id(&self) -> Option<DefId>

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

type Lifted = InstanceDef<'__lifted>

fn lift_to_tcx(self, __tcx: TyCtxt<'__lifted>) -> Option<InstanceDef<'__lifted>>

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

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

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: &Rhs) -> bool

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

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

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

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

fn try_fold_with<__F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, __folder: &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>(self, folder: &mut F) -> Selfwhere F: TypeFolder<I>,

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

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

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

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

impl<'tcx> Eq for InstanceDef<'tcx>

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

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

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: 11 bytes
• Intrinsic: 11 bytes
• VTableShim: 11 bytes
• ReifyShim: 11 bytes
• FnPtrShim: 23 bytes
• Virtual: 23 bytes
• ClosureOnceShim: 11 bytes
• ThreadLocalShim: 11 bytes
• DropGlue: 23 bytes
• CloneShim: 23 bytes
• FnPtrAddrShim: 23 bytes