Enum SelectionCandidate

pub enum SelectionCandidate<'tcx> {
    BuiltinCandidate {
        has_nested: bool,
    },
    TransmutabilityCandidate,
    ParamCandidate(PolyTraitPredicate<'tcx>),
    ImplCandidate(DefId),
    AutoImplCandidate,
    ProjectionCandidate(usize),
    ClosureCandidate {
        is_const: bool,
    },
    AsyncClosureCandidate,
    AsyncFnKindHelperCandidate,
    CoroutineCandidate,
    FutureCandidate,
    IteratorCandidate,
    AsyncIteratorCandidate,
    FnPointerCandidate,
    TraitAliasCandidate,
    ObjectCandidate(usize),
    TraitUpcastingUnsizeCandidate(usize),
    BuiltinObjectCandidate,
    BuiltinUnsizeCandidate,
}

The selection process begins by considering all impls, where clauses, and so forth that might resolve an obligation. Sometimes we’ll be able to say definitively that (e.g.) an impl does not apply to the obligation: perhaps it is defined for usize but the obligation is for i32. In that case, we drop the impl out of the list. But the other cases are considered candidates.

For selection to succeed, there must be exactly one matching candidate. If the obligation is fully known, this is guaranteed by coherence. However, if the obligation contains type parameters or variables, there may be multiple such impls.

It is not a real problem if multiple matching impls exist because of type variables - it just means the obligation isn’t sufficiently elaborated. In that case we report an ambiguity, and the caller can try again after more type information has been gathered or report a “type annotations needed” error.

However, with type parameters, this can be a real problem - type parameters don’t unify with regular types, but they can unify with variables from blanket impls, and (unless we know its bounds will always be satisfied) picking the blanket impl will be wrong for at least some generic parameters. To make this concrete, if we have

trait AsDebug { type Out: fmt::Debug; fn debug(self) -> Self::Out; }
impl<T: fmt::Debug> AsDebug for T {
    type Out = T;
    fn debug(self) -> fmt::Debug { self }
}
fn foo<T: AsDebug>(t: T) { println!("{:?}", <T as AsDebug>::debug(t)); }

we can’t just use the impl to resolve the <T as AsDebug> obligation – a type from another crate (that doesn’t implement fmt::Debug) could implement AsDebug.

Because where-clauses match the type exactly, multiple clauses can only match if there are unresolved variables, and we can mostly just report this ambiguity in that case. This is still a problem - we can’t do anything with ambiguities that involve only regions. This is issue #21974.

If a single where-clause matches and there are no inference variables left, then it definitely matches and we can just select it.

In fact, we even select the where-clause when the obligation contains inference variables. The can lead to inference making “leaps of logic”, for example in this situation:

pub trait Foo<T> { fn foo(&self) -> T; }
impl<T> Foo<()> for T { fn foo(&self) { } }
impl Foo<bool> for bool { fn foo(&self) -> bool { *self } }

pub fn foo<T>(t: T) where T: Foo<bool> {
    println!("{:?}", <T as Foo<_>>::foo(&t));
}
fn main() { foo(false); }

Here the obligation <T as Foo<$0>> can be matched by both the blanket impl and the where-clause. We select the where-clause and unify $0=bool, so the program prints “false”. However, if the where-clause is omitted, the blanket impl is selected, we unify $0=(), and the program prints “()”.

Exactly the same issues apply to projection and object candidates, except that we can have both a projection candidate and a where-clause candidate for the same obligation. In that case either would do (except that different “leaps of logic” would occur if inference variables are present), and we just pick the where-clause. This is, for example, required for associated types to work in default impls, as the bounds are visible both as projection bounds and as where-clauses from the parameter environment.

Variants

BuiltinCandidate

A builtin implementation for some specific traits, used in cases where we cannot rely an ordinary library implementations.

The most notable examples are sized, Copy and Clone. This is also used for the DiscriminantKind and Pointee trait, both of which have an associated type.

Fields

has_nested: bool

false if there are no further obligations.

TransmutabilityCandidate

Implementation of transmutability trait.

ParamCandidate(PolyTraitPredicate<'tcx>)

ImplCandidate(DefId)

AutoImplCandidate

ProjectionCandidate(usize)

This is a trait matching with a projected type as Self, and we found an applicable bound in the trait definition. The usize is an index into the list returned by tcx.item_bounds.

ClosureCandidate

Implementation of a Fn-family trait by one of the anonymous types generated for an || expression.

Fields

is_const: bool

AsyncClosureCandidate

Implementation of an AsyncFn-family trait by one of the anonymous types generated for an async || expression.

AsyncFnKindHelperCandidate

Implementation of the AsyncFnKindHelper helper trait, which is used internally to delay computation for async closures until after upvar analysis is performed in HIR typeck.

CoroutineCandidate

Implementation of a Coroutine trait by one of the anonymous types generated for a coroutine.

FutureCandidate

Implementation of a Future trait by one of the coroutine types generated for an async construct.

IteratorCandidate

Implementation of an Iterator trait by one of the coroutine types generated for a gen construct.

AsyncIteratorCandidate

Implementation of an AsyncIterator trait by one of the coroutine types generated for a async gen construct.

FnPointerCandidate

Implementation of a Fn-family trait by one of the anonymous types generated for a fn pointer type (e.g., fn(int) -> int)

TraitAliasCandidate

ObjectCandidate(usize)

Matching dyn Trait with a supertrait of Trait. The index is the position in the iterator returned by rustc_infer::traits::util::supertraits.

TraitUpcastingUnsizeCandidate(usize)

Perform trait upcasting coercion of dyn Trait to a supertrait of Trait. The index is the position in the iterator returned by rustc_infer::traits::util::supertraits.

BuiltinObjectCandidate

BuiltinUnsizeCandidate

Trait Implementations

impl<'tcx> Clone for SelectionCandidate<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for SelectionCandidate<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> PartialEq for SelectionCandidate<'tcx>

fn eq(&self, other: &SelectionCandidate<'tcx>) -> 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> TypeVisitable<TyCtxt<'tcx>> for SelectionCandidate<'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> Eq for SelectionCandidate<'tcx>

impl<'tcx> StructuralPartialEq for SelectionCandidate<'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: 32 bytes

Size for each variant:

• BuiltinCandidate: 5 bytes
• TransmutabilityCandidate: 0 bytes
• ParamCandidate: 32 bytes
• ImplCandidate: 12 bytes
• AutoImplCandidate: 0 bytes
• ProjectionCandidate: 16 bytes
• ClosureCandidate: 5 bytes
• AsyncClosureCandidate: 0 bytes
• AsyncFnKindHelperCandidate: 0 bytes
• CoroutineCandidate: 0 bytes
• FutureCandidate: 0 bytes
• IteratorCandidate: 0 bytes
• AsyncIteratorCandidate: 0 bytes
• FnPointerCandidate: 0 bytes
• TraitAliasCandidate: 0 bytes
• ObjectCandidate: 16 bytes
• TraitUpcastingUnsizeCandidate: 16 bytes
• BuiltinObjectCandidate: 0 bytes
• BuiltinUnsizeCandidate: 0 bytes