Enum rustc_middle::mir::mono::MonoItem

pub enum MonoItem<'tcx> {
    Fn(Instance<'tcx>),
    Static(DefId),
    GlobalAsm(ItemId),
}

Variants

Fn(Instance<'tcx>)

Static(DefId)

GlobalAsm(ItemId)

Implementations

impl<'tcx> MonoItem<'tcx>

pub fn is_user_defined(&self) -> bool

Returns true if the mono item is user-defined (i.e. not compiler-generated, like shims).

pub fn size_estimate(&self, tcx: TyCtxt<'tcx>) -> usize

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

pub fn symbol_name(&self, tcx: TyCtxt<'tcx>) -> SymbolName<'tcx>

pub fn instantiation_mode(&self, tcx: TyCtxt<'tcx>) -> InstantiationMode

pub fn explicit_linkage(&self, tcx: TyCtxt<'tcx>) -> Option<Linkage>

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

Returns true if this instance is instantiable - whether it has no unsatisfied predicates.

In order to codegen an item, all of its predicates must hold, because otherwise the item does not make sense. Type-checking ensures that the predicates of every item that is used by a valid item do hold, so we can rely on that.

However, we codegen collector roots (reachable items) and functions in vtables when they are seen, even if they are not used, and so they might not be instantiable. For example, a programmer can define this public function:

pub fn foo<'a>(s: &'a mut ()) where &'a mut (): Clone {
    <&mut () as Clone>::clone(&s);
}

That function can’t be codegened, because the method <&mut () as Clone>::clone does not exist. Luckily for us, that function can’t ever be used, because that would require for &'a mut (): Clone to hold, so we can just not emit any code, or even a linker reference for it.

Similarly, if a vtable method has such a signature, and therefore can’t be used, we can just not emit it and have a placeholder (a null pointer, which will never be accessed) in its place.

pub fn local_span(&self, tcx: TyCtxt<'tcx>) -> Option<Span>

pub fn codegen_dep_node(&self, tcx: TyCtxt<'tcx>) -> DepNode

pub fn krate(&self) -> CrateNum

Returns the item’s CrateNum

pub fn def_id(&self) -> DefId

Returns the item’s DefId

Trait Implementations

impl<'tcx> Clone for MonoItem<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for MonoItem<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> Display for MonoItem<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> Hash for MonoItem<'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 MonoItem<'tcx>

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

impl<'tcx> PartialEq for MonoItem<'tcx>

fn eq(&self, other: &MonoItem<'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 ToStableHashKey<StableHashingContext<'_>> for MonoItem<'_>

type KeyType = Fingerprint

fn to_stable_hash_key(&self, hcx: &StableHashingContext<'_>) -> Self::KeyType

impl<'tcx> Copy for MonoItem<'tcx>

impl<'tcx> Eq for MonoItem<'tcx>

impl<'tcx> StructuralPartialEq for MonoItem<'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: 32 bytes

Size for each variant:

• Fn: 32 bytes
• Static: 12 bytes
• GlobalAsm: 8 bytes