Struct TraitRef

pub struct TraitRef<I>
where
    I: Interner,
{
    pub def_id: <I as Interner>::DefId,
    pub args: <I as Interner>::GenericArgs,
    _use_trait_ref_new_instead: (),
}

A complete reference to a trait. These take numerous guises in syntax, but perhaps the most recognizable form is in a where-clause:

T: Foo<U>

This would be represented by a trait-reference where the DefId is the DefId for the trait Foo and the args define T as parameter 0, and U as parameter 1.

Trait references also appear in object types like Foo<U>, but in that case the Self parameter is absent from the generic parameters.

Fields

def_id: <I as Interner>::DefId

args: <I as Interner>::GenericArgs

_use_trait_ref_new_instead: ()

Implementations

impl<I> TraitRef<I>

where I: Interner,

pub fn new_from_args( interner: I, trait_def_id: <I as Interner>::DefId, args: <I as Interner>::GenericArgs, ) -> TraitRef<I>

pub fn new( interner: I, trait_def_id: <I as Interner>::DefId, args: impl IntoIterator>, ) -> TraitRef<I>

where <impl IntoIterator as IntoIterator>::Item: Into<<I as Interner>::GenericArg>,

pub fn from_method( interner: I, trait_id: <I as Interner>::DefId, args: <I as Interner>::GenericArgs, ) -> TraitRef<I>

pub fn identity(interner: I, def_id: <I as Interner>::DefId) -> TraitRef<I>

Returns a TraitRef of the form P0: Foo<P1..Pn> where Pi are the parameters defined on trait.

pub fn with_self_ty( self, interner: I, self_ty: <I as Interner>::Ty, ) -> TraitRef<I>

pub fn self_ty(&self) -> <I as Interner>::Ty

Trait Implementations

impl<I> Clone for TraitRef<I>

where I: Interner,

fn clone(&self) -> TraitRef<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I> Debug for TraitRef<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I, __D> Decodable<__D> for TraitRef<I>

where I: Interner, __D: TyDecoder<I = I>, <I as Interner>::DefId: Decodable<__D>, <I as Interner>::GenericArgs: Decodable<__D>,

fn decode(__decoder: &mut __D) -> TraitRef<I>

impl<I> Display for TraitRef<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I, __E> Encodable<__E> for TraitRef<I>

where I: Interner, __E: TyEncoder<I = I>, <I as Interner>::DefId: Encodable<__E>, <I as Interner>::GenericArgs: Encodable<__E>,

fn encode(&self, __encoder: &mut __E)

impl<'tcx> EraseType for TraitRef<TyCtxt<'tcx>>

type Result = [u8; 16]

impl<I> Hash for TraitRef<I>

where I: Interner,

fn hash<__H>(&self, __state: &mut __H)

where __H: Hasher,

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<I, __CTX> HashStable<__CTX> for TraitRef<I>

where I: Interner, <I as Interner>::DefId: HashStable<__CTX>, <I as Interner>::GenericArgs: HashStable<__CTX>,

fn hash_stable( &self, __hcx: &mut __CTX, __hasher: &mut StableHasher<SipHasher128>, )

impl<I> IntoDiagArg for TraitRef<I>

where I: Interner,

fn into_diag_arg(self) -> DiagArgValue

impl<'tcx> Key for TraitRef<TyCtxt<'tcx>>

type Cache<V> = DefaultCache<TraitRef<TyCtxt<'tcx>>, V>

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_def_id(&self) -> Option<DefId>

impl<I, J> Lift<J> for TraitRef<I>

where I: Interner, J: Interner, <I as Interner>::DefId: Lift<J, Lifted = <J as Interner>::DefId>, <I as Interner>::GenericArgs: Lift<J, Lifted = <J as Interner>::GenericArgs>, (): Lift<J, Lifted = ()>,

type Lifted = TraitRef<J>

fn lift_to_interner(self, interner: J) -> Option<TraitRef<J>>

impl ParameterizedOverTcx for TraitRef<TyCtxt<'static>>

type Value<'tcx> = TraitRef<TyCtxt<'tcx>>

impl<I> PartialEq for TraitRef<I>

where I: Interner,

fn eq(&self, __other: &TraitRef<I>) -> 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, P> Print<'tcx, P> for TraitRef<TyCtxt<'tcx>>

where P: PrettyPrinter<'tcx>,

fn print(&self, cx: &mut P) -> Result<(), Error>

impl<'tcx> PrintTraitRefExt<'tcx> for TraitRef<TyCtxt<'tcx>>

fn print_only_trait_path(self) -> TraitRefPrintOnlyTraitPath<'tcx>

fn print_trait_sugared(self) -> TraitRefPrintSugared<'tcx>

fn print_only_trait_name(self) -> TraitRefPrintOnlyTraitName<'tcx>

impl<I> Relate<I> for TraitRef<I>

where I: Interner,

fn relate<R>( relation: &mut R, a: TraitRef<I>, b: TraitRef<I>, ) -> Result<TraitRef<I>, TypeError<I>>

where R: TypeRelation<I>,

impl<I> TypeFoldable<I> for TraitRef<I>

where I: Interner, <I as Interner>::DefId: TypeFoldable<I>, <I as Interner>::GenericArgs: TypeFoldable<I>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<TraitRef<I>, <__F as FallibleTypeFolder<I>>::Error>

where __F: FallibleTypeFolder<I>,

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

where 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<I> TypeVisitable<I> for TraitRef<I>

where I: Interner, <I as Interner>::DefId: TypeVisitable<I>, <I as Interner>::GenericArgs: TypeVisitable<I>,

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<I>>::Result

where __V: TypeVisitor<I>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<I> UpcastFrom<I, TraitRef<I>> for TraitPredicate<I>

where I: Interner,

fn upcast_from(from: TraitRef<I>, _tcx: I) -> TraitPredicate<I>

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>> for Clause<'tcx>

fn upcast_from(from: TraitRef<TyCtxt<'tcx>>, tcx: TyCtxt<'tcx>) -> Clause<'tcx>

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>> for Predicate<'tcx>

fn upcast_from( from: TraitRef<TyCtxt<'tcx>>, tcx: TyCtxt<'tcx>, ) -> Predicate<'tcx>

impl<I> Copy for TraitRef<I>

where I: Interner,

impl<I> Eq for TraitRef<I>

where I: Interner,

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.