Enum rustc_middle::mir::mono::MonoItem

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

Variants

Fn(Instance<'tcx>)

Static(DefId)

GlobalAsm(HirId)

Implementations

impl<'tcx> MonoItem<'tcx>

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

pub fn is_generic_fn(&self) -> 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>

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

impl<'tcx> Hash for MonoItem<'tcx>

pub fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for MonoItem<'tcx>

pub fn hash_stable(
    &self,
    hcx: &mut StableHashingContext<'a>,
    hasher: &mut StableHasher
)

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

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

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

pub fn ne(&self, other: &MonoItem<'tcx>) -> bool

This method tests for !=.

impl<'tcx> StructuralEq for MonoItem<'tcx>

impl<'tcx> StructuralPartialEq for MonoItem<'tcx>