Enum TraitRefKind

pub enum TraitRefKind {
    TraitImpl(TraitImplId, GenericArgs),
    Clause(TraitClauseId),
    ParentClause(Box<TraitRefKind>, TraitDeclId, TraitClauseId),
    ItemClause(Box<TraitRefKind>, TraitDeclId, TraitItemName, TraitClauseId),
    SelfId,
    BuiltinOrAuto(PolyTraitDeclRef),
    Dyn(PolyTraitDeclRef),
    Unknown(String),
}

Identifier of a trait instance. This is derived from the trait resolution.

Should be read as a path inside the trait clauses which apply to the current definition. Note that every path designated by [TraitInstanceId] refers to a trait instance, which is why the [Clause] variant may seem redundant with some of the other variants.

Variants

TraitImpl(TraitImplId, GenericArgs)

A specific top-level implementation item.

Clause(TraitClauseId)

One of the local clauses.

Example:

fn f<T>(...) where T : Foo
                   ^^^^^^^
                   Clause(0)

ParentClause(Box<TraitRefKind>, TraitDeclId, TraitClauseId)

A parent clause

Remark: the TraitDeclId gives the trait declaration which is implemented by the instance id from which we take the parent clause (see example below). It is not necessary and included for convenience.

Remark: Ideally we should store a full TraitRef instead, but hax does not give us enough information to get the right generic args.

Example:

trait Foo1 {}
trait Foo2 { fn f(); }

trait Bar : Foo1 + Foo2 {}
            ^^^^   ^^^^
                   parent clause 1
    parent clause 0

fn g<T : Bar>(x : T) {
  x.f()
  ^^^^^
  Parent(Clause(0), Bar, 1)::f(x)
                         ^
                         parent clause 1 of clause 0
                    ^^^
             clause 0 implements Bar
}

ItemClause(Box<TraitRefKind>, TraitDeclId, TraitItemName, TraitClauseId)

A clause defined on an associated type. This variant is only used during translation; after the lift_associated_item_clauses pass, clauses on items become ParentClauses.

Remark: the TraitDeclId gives the trait declaration which is implemented by the trait implementation from which we take the item (see below). It is not necessary and provided for convenience.

Example:

trait Foo {
  type W: Bar0 + Bar1 // Bar1 contains a method bar1
                 ^^^^
              this is the clause 1 applying to W
}

fn f<T : Foo>(x : T::W) {
  x.bar1();
  ^^^^^^^
  ItemClause(Clause(0), Foo, W, 1)
                             ^^^^
                             clause 1 from item W (from local clause 0)
                        ^^^
               local clause 0 implements Foo
}

SelfId

Self, in case of trait declarations/implementations.

Putting Self at the end on purpose, so that when ordering the clauses we start with the other clauses (in particular, the local clauses). It is useful to give priority to the local clauses when solving the trait obligations which are fullfilled by the trait parameters.

BuiltinOrAuto(PolyTraitDeclRef)

A specific builtin trait implementation like core::marker::Sized or auto trait implementation like [core::marker::Syn].

Dyn(PolyTraitDeclRef)

The automatically-generated implementation for dyn Trait.

Unknown(String)

For error reporting.

Trait Implementations

impl Clone for TraitRefKind

fn clone(&self) -> TraitRefKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TraitRefKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TraitRefKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Drive for TraitRefKind

fn drive<V: Visitor>(&self, visitor: &mut V)

impl DriveMut for TraitRefKind

fn drive_mut<V: VisitorMut>(&mut self, visitor: &mut V)

impl<C: AstFormatter> FmtWithCtx<C> for TraitRefKind

fn fmt_with_ctx(&self, ctx: &C) -> String

fn fmt_with_ctx_and_indent(&self, _tab: &str, _ctx: &C) -> String

fn with_ctx<'a>(&'a self, ctx: &'a C) -> impl Display + 'a

Returns a struct that implements Display. This allows the following:

impl Hash for TraitRefKind

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 TraitRefKind

fn eq(&self, other: &TraitRefKind) -> 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 Serialize for TraitRefKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TraitRefKind

impl StructuralPartialEq for TraitRefKind