Enum InstanceKind 

pub enum InstanceKind<'tcx> {
    Item(DefId),
    Intrinsic(DefId),
    Virtual(DefId, usize),
    Shim(ShimKind<'tcx>),
}

Variants

Item(DefId)

A user-defined callable item.

This includes:

• fn items
• closures
• coroutines

Intrinsic(DefId)

An intrinsic fn item (with#[rustc_intrinsic]).

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

Virtual(DefId, usize)

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

This InstanceKind may have a callable MIR as the default implementation. Calls to Virtual instances must be codegen’d as virtual calls through the vtable. This means we might not know exactly what is being called.

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

Shim(ShimKind<'tcx>)

Implementations

impl<'tcx> InstanceKind<'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 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 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 instantiating 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 instantiations.

Trait Implementations

impl<'tcx> Clone for InstanceKind<'tcx>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'tcx> Copy for InstanceKind<'tcx>

impl<'tcx> Debug for InstanceKind<'tcx>

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

Formats the value using the given formatter.

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

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

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

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

impl<'tcx> Eq for InstanceKind<'tcx>

impl<'tcx> Hash for InstanceKind<'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, '__lifted> Lift<TyCtxt<'__lifted>> for InstanceKind<'tcx>

type Lifted = InstanceKind<'__lifted>

fn lift_to_interner(self, __tcx: TyCtxt<'__lifted>) -> InstanceKind<'__lifted>

impl<'tcx> PartialEq for InstanceKind<'tcx>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'tcx> QueryKey for InstanceKind<'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?

type Cache<V> = DefaultCache<Self, V>

The type of in-memory cache to use for queries with this key type.

type LocalQueryKey = !

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

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

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

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

impl<'tcx> StableHash for InstanceKind<'tcx>

fn stable_hash<__Hcx: StableHashCtxt>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher, )

impl<'tcx> StructuralPartialEq for InstanceKind<'tcx>

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for InstanceKind<'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: TypeFolder<TyCtxt<'tcx>>>(self, __folder: &mut __F) -> Self

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for InstanceKind<'tcx>

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

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

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: 12 bytes
• Intrinsic: 12 bytes
• Virtual: 24 bytes
• Shim: 24 bytes