Type Alias rustc_middle::query::queries::unused_generic_params::LocalKey

pub type LocalKey<'tcx> = InstanceDef<'tcx>;

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