Enum rustc_middle::ty::instance::InstanceDef[][src]

pub enum InstanceDef<'tcx> {
    Item(WithOptConstParam<DefId>),
    Intrinsic(DefId),
    VtableShim(DefId),
    ReifyShim(DefId),
    FnPtrShim(DefIdTy<'tcx>),
    Virtual(DefIdusize),
    ClosureOnceShim {
        call_once: DefId,
    },
    DropGlue(DefIdOption<Ty<'tcx>>),
    CloneShim(DefIdTy<'tcx>),
}

Variants

Item(WithOptConstParam<DefId>)

A user-defined callable item.

This includes:

Tuple Fields of Item

0: WithOptConstParam<DefId>
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.

Tuple Fields of Intrinsic

0: DefId
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.

Tuple Fields of VtableShim

0: DefId
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).

Tuple Fields of ReifyShim

0: DefId
FnPtrShim(DefIdTy<'tcx>)

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

DefId is FnTrait::call_*.

Tuple Fields of FnPtrShim

0: DefId1: Ty<'tcx>
Virtual(DefIdusize)

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

Tuple Fields of Virtual

0: DefId1: usize
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(DefIdOption<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.

Tuple Fields of DropGlue

0: DefId1: Option<Ty<'tcx>>
CloneShim(DefIdTy<'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.

Tuple Fields of CloneShim

0: DefId1: Ty<'tcx>

Implementations

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.

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.

Returns true when the MIR body associated with this instance should be monomorphized by its users (e.g. codegen or miri) by substituting the substs from Instance (see Instance::substs_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

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Feeds this value into the given Hasher. Read more

Feeds a slice of this type into the given Hasher. Read more

This method returns an Ordering between self and other. Read more

Compares and returns the maximum of two values. Read more

Compares and returns the minimum of two values. Read more

Restrict a value to a certain interval. Read more

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

This method tests for !=.

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

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

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

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

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

Returns true if self has any late-bound regions that are either bound by binder or bound by some binder outside of binder. If binder is ty::INNERMOST, this indicates whether there are any late-bound regions that appear free. Read more

Returns true if this self has any regions that escape binder (and hence are not bound by it). Read more

“Free” regions in this context means that it has any region that is not (a) erased or (b) late-bound. Read more

True if there are any un-erased free regions.

Indicates whether this value definitely references only ‘global’ generic parameters that are the same regardless of what fn we are in. This is used for caching. Read more

Indicates whether this value references only ‘global’ generic parameters that are the same regardless of what fn we are in. This is used for caching. Read more

True if there are any late-bound regions

Indicates whether this value still has parameters/placeholders/inference variables which could be replaced later, in a way that would change the results of impl specialization. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Performs the conversion.

Performs the conversion.

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

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: