Enum TraitRefKind

pub enum TraitRefKind {
    TraitImpl(TraitImplId, GenericArgs),
    Clause(ClauseDbVar),
    ParentClause(Box<TraitRefKind>, TraitDeclId, TraitClauseId),
    ItemClause(Box<TraitRefKind>, TraitDeclId, TraitItemName, TraitClauseId),
    SelfId,
    BuiltinOrAuto {
        trait_decl_ref: PolyTraitDeclRef,
        parent_trait_refs: Vector<TraitClauseId, TraitRef>,
        types: Vec<(TraitItemName, Ty)>,
    },
    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(ClauseDbVar)

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

The implicit Self: Trait clause. Present inside trait declarations, including trait method declarations. Not present in trait implementations as we can use TraitImpl intead.

BuiltinOrAuto

A trait implementation that is computed by the compiler, such as for built-in traits Sized or FnMut. This morally points to an invisible impl block; as such it contains the information we may need from one.

Fields

trait_decl_ref: PolyTraitDeclRef

parent_trait_refs: Vector<TraitClauseId, TraitRef>

The ImplExprs required to satisfy the implied predicates on the trait declaration. E.g. since FnMut: FnOnce, a built-in T: FnMut impl would have an ImplExpr for T: FnOnce.

types: Vec<(TraitItemName, Ty)>

The values of the associated types for this trait.

Dyn(PolyTraitDeclRef)

The automatically-generated implementation for dyn Trait.

Unknown(String)

For error reporting.

Implementations

impl TraitRefKind

pub fn to_path(&self) -> Option<TraitRefPath>

Trait Implementations

impl AstVisitable for TraitRefKind

fn drive<V: VisitAst>(&self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn drive_mut<V: VisitAstMut>(&mut self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn name(&self) -> &'static str

The name of the type, used for debug logging.

fn dyn_visit<T: AstVisitable>(&self, f: impl FnMut(&T))

Visit all occurrences of that type inside self, in pre-order traversal.

fn dyn_visit_mut<T: AstVisitable>(&mut self, f: impl FnMut(&mut T))

Visit all occurrences of that type inside self, in pre-order traversal.

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<'s, V> Drive<'s, V> for TraitRefKind

where V: Visitor + Visit<'s, TraitImplId> + Visit<'s, GenericArgs> + Visit<'s, ClauseDbVar> + Visit<'s, Box<TraitRefKind>> + Visit<'s, TraitDeclId> + Visit<'s, TraitClauseId> + Visit<'s, TraitItemName> + Visit<'s, PolyTraitDeclRef> + Visit<'s, Vector<TraitClauseId, TraitRef>> + Visit<'s, Vec<(TraitItemName, Ty)>>,

fn drive_inner(&'s self, visitor: &mut V) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self.

impl<'s, V> DriveMut<'s, V> for TraitRefKind

where V: Visitor + VisitMut<'s, TraitImplId> + VisitMut<'s, GenericArgs> + VisitMut<'s, ClauseDbVar> + VisitMut<'s, Box<TraitRefKind>> + VisitMut<'s, TraitDeclId> + VisitMut<'s, TraitClauseId> + VisitMut<'s, TraitItemName> + VisitMut<'s, PolyTraitDeclRef> + VisitMut<'s, Vector<TraitClauseId, TraitRef>> + VisitMut<'s, Vec<(TraitItemName, Ty)>>,

fn drive_inner_mut(&'s mut self, visitor: &mut V) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self.

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