Struct rustc_middle::ty::predicate::TraitRef

pub struct TraitRef<'tcx> {
    pub def_id: DefId,
    pub args: GenericArgsRef<'tcx>,
    pub(super) _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: DefId

args: GenericArgsRef<'tcx>

_use_trait_ref_new_instead: ()

This field exists to prevent the creation of TraitRef without calling TraitRef::new.

Implementations

impl<'tcx> TraitRef<'tcx>

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

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

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

impl<'tcx> TraitRef<'tcx>

pub fn new( tcx: TyCtxt<'tcx>, trait_def_id: DefId, args: impl IntoIterator<Item: Into<GenericArg<'tcx>>> ) -> Self

pub fn from_lang_item( tcx: TyCtxt<'tcx>, trait_lang_item: LangItem, span: Span, args: impl IntoIterator<Item: Into<GenericArg<'tcx>>> ) -> Self

pub fn from_method( tcx: TyCtxt<'tcx>, trait_id: DefId, args: GenericArgsRef<'tcx> ) -> TraitRef<'tcx>

pub fn identity(tcx: TyCtxt<'tcx>, def_id: DefId) -> TraitRef<'tcx>

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

pub fn with_self_ty(self, tcx: TyCtxt<'tcx>, self_ty: Ty<'tcx>) -> Self

pub fn self_ty(&self) -> Ty<'tcx>

Trait Implementations

impl<'tcx> Clone for TraitRef<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for TraitRef<'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 TraitRef<'tcx>

fn decode(__decoder: &mut __D) -> Self

impl<'tcx> Display for TraitRef<'tcx>

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

Formats the value using the given formatter.

impl<'tcx, __E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<__E> for TraitRef<'tcx>

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

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

type Result = [u8; 16]

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

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

impl<'tcx> IntoDiagArg for TraitRef<'tcx>

fn into_diag_arg(self) -> DiagArgValue

impl<'tcx, '__lifted> Lift<'__lifted> for TraitRef<'tcx>

type Lifted = TraitRef<'__lifted>

fn lift_to_tcx(self, __tcx: TyCtxt<'__lifted>) -> Option<TraitRef<'__lifted>>

impl<'tcx> Ord for TraitRef<'tcx>

fn cmp(&self, other: &TraitRef<'tcx>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl ParameterizedOverTcx for TraitRef<'static>

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

impl<'tcx> PartialEq for TraitRef<'tcx>

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

fn partial_cmp(&self, other: &TraitRef<'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, P: PrettyPrinter<'tcx>> Print<'tcx, P> for TraitRef<'tcx>

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

impl<'tcx> Relate<'tcx> for TraitRef<'tcx>

fn relate<R: TypeRelation<'tcx>>( relation: &mut R, a: TraitRef<'tcx>, b: TraitRef<'tcx> ) -> RelateResult<'tcx, TraitRef<'tcx>>

impl<'tcx> ToPredicate<'tcx> for TraitRef<'tcx>

fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx>

impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for TraitRef<'tcx>

fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Clause<'tcx>

impl<'tcx> ToPredicate<'tcx, TraitPredicate<'tcx>> for TraitRef<'tcx>

fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> TraitPredicate<'tcx>

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for TraitRef<'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) -> 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<'tcx> TypeVisitable<TyCtxt<'tcx>> for TraitRef<'tcx>

fn visit_with<__V: TypeVisitor<TyCtxt<'tcx>>>( &self, __visitor: &mut __V ) -> __V::Result

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

impl<'tcx> Copy for TraitRef<'tcx>

impl<'tcx> Eq for TraitRef<'tcx>

impl<'tcx> StructuralPartialEq for TraitRef<'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: 16 bytes