Struct TraitDatum

pub struct TraitDatum<I: Interner> {
    pub id: TraitId<I>,
    pub binders: Binders<TraitDatumBound<I>>,
    pub flags: TraitFlags,
    pub associated_ty_ids: Vec<AssocTypeId<I>>,
    pub well_known: Option<WellKnownTrait>,
}

A rust intermediate representation (rust_ir) of a Trait Definition. For example, given the following rust code:

use std::fmt::Debug;

trait Foo<T>
where
    T: Debug,
{
    type Bar<U>;
}

This would represent the trait Foo declaration. Note that the details of the trait members (e.g., the associated type declaration (type Bar<U>) are not contained in this type, and are represented separately (e.g., in AssociatedTyDatum).

Not to be confused with the rust_ir for a Trait Implementation, which is represented by ImplDatum

Fields

id: TraitId<I>

binders: Binders<TraitDatumBound<I>>

flags: TraitFlags

“Flags” indicate special kinds of traits, like auto traits. In Rust syntax these are represented in different ways, but in chalk we add annotations like #[auto].

associated_ty_ids: Vec<AssocTypeId<I>>

well_known: Option<WellKnownTrait>

If this is a well-known trait, which one? If None, this is a regular, user-defined trait.

Implementations

impl<I: Interner> TraitDatum<I>

pub fn is_auto_trait(&self) -> bool

pub fn is_non_enumerable_trait(&self) -> bool

pub fn is_coinductive_trait(&self) -> bool

Trait Implementations

impl<I: Clone + Interner> Clone for TraitDatum<I>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug + Interner> Debug for TraitDatum<I>

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

Formats the value using the given formatter.

impl<I: Hash + Interner> Hash for TraitDatum<I>

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<I: PartialEq + Interner> PartialEq for TraitDatum<I>

fn eq(&self, other: &TraitDatum<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<I: Eq + Interner> Eq for TraitDatum<I>

impl<I: Interner> StructuralPartialEq for TraitDatum<I>