Struct ItemRef 

pub struct ItemRef {
    pub(crate) contents: HashConsed<ItemRefContents>,
}

Reference to an item, with generics. Basically any mention of an item (function, type, etc) uses this.

This can refer to a top-level item or to a trait associated item. Example:

trait MyTrait<TraitType, const TraitConst: usize> {
  fn meth<MethType>(...) {...}
}
fn example_call<TraitType, SelfType: MyTrait<TraitType, 12>>(x: SelfType) {
  x.meth::<String>(...)
}

Here, in the call x.meth::<String>(...) we will build an ItemRef that looks like:

ItemRef {
    def_id = MyTrait::meth,
    generic_args = [String],
    impl_exprs = [<proof of `String: Sized`>],
    in_trait = Some(<proof of `SelfType: MyTrait<TraitType, 12>`>,
}

The in_trait ImplExpr will have in its trait field a representation of the SelfType: MyTrait<TraitType, 12> predicate, which looks like:

ItemRef {
    def_id = MyTrait,
    generic_args = [SelfType, TraitType, 12],
    impl_exprs = [],
    in_trait = None,
}

Fields

contents: HashConsed<ItemRefContents>

Implementations

impl ItemRef

pub fn instantiated_full_def<'tcx, S>(&self, s: &S) -> Arc<FullDef>

where S: BaseState<'tcx>,

Get the full definition of the item, instantiated with the provided generics.

pub fn drop_glue_shim<'tcx, S>(&self, s: &S) -> Body<'tcx>

where S: BaseState<'tcx>,

Get the drop glue shim for this. Panics if the DefKind isn’t appropriate. Drop glue shims are normally translated by hax when safe to do so (i.e. for mono types). This method can be used if you know what you’re doing and want drop glue for a poly type. This may cause ICEs.

pub fn closure_once_shim<'tcx, S>(&self, s: &S) -> Option<Body<'tcx>>

where S: BaseState<'tcx>,

For FnMut&Fn closures: the MIR for the call_once method; it simply calls call_mut.

impl ItemRef

pub fn translate<'tcx, S: UnderOwnerState<'tcx>>( s: &S, def_id: RDefId, generics: GenericArgsRef<'tcx>, ) -> ItemRef

The main way to obtain an ItemRef: from a def_id and generics.

pub fn translate_from_hax_def_id<'tcx, S: UnderOwnerState<'tcx>>( s: &S, def_id: DefId, generics: GenericArgsRef<'tcx>, ) -> ItemRef

pub fn translate_maybe_resolve_impl<'tcx, S: UnderOwnerState<'tcx>>( s: &S, resolve_trait_ref: bool, hax_def_id: DefId, generics: GenericArgsRef<'tcx>, ) -> ItemRef

Makes a ItemRef from a def_id and generics.

If resolve_trait_ref == true and (def_id, generics) points to a trait item that can be resolved to a specific impl, translate rewrites def_id to the concrete associated item from that impl and re-bases the generics.

For instance, [<u32 as From<u8>>::from] produces a ItemRef with a DefId looking like core::convert::num::Impl#42::from when resolve_impl is true, core::convert::From::from otherwise.

pub fn dummy_without_generics<'tcx, S: BaseState<'tcx>>( s: &S, def_id: DefId, ) -> ItemRef

Construct an ItemRef for items that can’t have generics (e.g. modules).

pub fn trait_associated_types<'tcx, S: UnderOwnerState<'tcx>>( &self, s: &S, ) -> Vec<Ty>

For an ItemRef that refers to a trait, this returns values for each of the non-gat associated types of this trait and its parents, in a fixed order.

pub fn erase<'tcx, S: UnderOwnerState<'tcx>>(&self, s: &S) -> Self

Erase lifetimes from the generic arguments of this item.

pub fn contents(&self) -> &ItemRefContents

pub fn rustc_args<'tcx, S: BaseState<'tcx>>( &self, s: &S, ) -> GenericArgsRef<'tcx>

Recover the original rustc args that generated this ItemRef. Will panic if the ItemRef was built by hand instead of using translate_item_ref.

pub fn mutate_def_id<'tcx, S: BaseState<'tcx>>( &self, s: &S, f: impl FnOnce(&mut DefId), ) -> Self

Mutate the DefId, keeping the same generic args.

pub fn with_def_id<'tcx, S: BaseState<'tcx>>( &self, s: &S, def_id: &DefId, ) -> Self

Set the DefId, keeping the same generic args.

impl ItemRef

pub fn translate_synthetic<'tcx, S: UnderOwnerState<'tcx>>( s: &S, synthetic: SyntheticItem, generics: GenericArgsRef<'tcx>, ) -> ItemRef

Trait Implementations

impl Clone for ItemRef

fn clone(&self) -> ItemRef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ItemRef

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

Formats the value using the given formatter.

impl Deref for ItemRef

type Target = ItemRefContents

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Hash for ItemRef

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 PartialEq for ItemRef

fn eq(&self, other: &ItemRef) -> 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, S: UnderOwnerState<'tcx>> SInto<S, ItemRef> for TraitRef<'tcx>

fn sinto(&self, s: &S) -> TraitRef

impl Eq for ItemRef

impl StructuralPartialEq for ItemRef