SelectionCandidate in rustc_trait_selection::traits::select - Rust
Description: 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.

Skip to main content

## SelectionCandidate

# Enum SelectionCandidate

Source

    pub enum SelectionCandidate<'tcx> {
    Show 21 variants    SizedCandidate,
        BuiltinCandidate,
        TransmutabilityCandidate,
        ParamCandidate(Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>),
        ImplCandidate(DefId),
        AutoImplCandidate,
        ProjectionCandidate {
            idx: usize,
            kind: AliasBoundKind,
        },
        ClosureCandidate {
            is_const: bool,
        },
        AsyncClosureCandidate,
        AsyncFnKindHelperCandidate,
        CoroutineCandidate,
        FutureCandidate,
        IteratorCandidate,
        AsyncIteratorCandidate,
        FnPointerCandidate,
        TraitAliasCandidate,
        ObjectCandidate(usize),
        TraitUpcastingUnsizeCandidate(usize),
        BuiltinObjectCandidate,
        BuiltinUnsizeCandidate,
        BikeshedGuaranteedNoDropCandidate,
    }

Expand description

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§

§

### SizedCandidate

A built-in implementation for the `Sized` trait. This is preferred over all other candidates.

§

### BuiltinCandidate

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

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

§

### TransmutabilityCandidate

Implementation of transmutability trait.

§

### ParamCandidate(Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>)

§

### ImplCandidate(DefId)

§

### AutoImplCandidate

§

### ProjectionCandidate

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` and the `AliasBoundKind` is whether this is candidate from recursion on the self type of a projection.

#### Fields

§`idx: usize`
§`kind: AliasBoundKind`
§

### 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

§

### BikeshedGuaranteedNoDropCandidate

## Trait Implementations§

Source§

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

Source§

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

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from `source`. Read more
Source§

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

Source§

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

Formats the value using the given formatter. Read more
Source§

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

Source§

#### fn eq(&self, other: &SelectionCandidate<'tcx>) -> bool

Tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · Source§

#### fn ne(&self, other: &Rhs) -> bool

Tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

### impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for SelectionCandidate<'tcx>

Source§

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

The entry point for visiting. To visit a value `t` with a visitor `v` call: `t.visit_with(v)`. Read more
Source§

### impl<'tcx> Eq for SelectionCandidate<'tcx>

Source§

### impl<'tcx> StructuralPartialEq for SelectionCandidate<'tcx>

## Auto Trait Implementations§

§

### impl<'tcx> DynSend for SelectionCandidate<'tcx>

§

### impl<'tcx> DynSync for SelectionCandidate<'tcx>

§

### impl<'tcx> Freeze for SelectionCandidate<'tcx>

§

### impl<'tcx> !RefUnwindSafe for SelectionCandidate<'tcx>

§

### impl<'tcx> Send for SelectionCandidate<'tcx>

§

### impl<'tcx> Sync for SelectionCandidate<'tcx>

§

### impl<'tcx> Unpin for SelectionCandidate<'tcx>

§

### impl<'tcx> UnsafeUnpin for SelectionCandidate<'tcx>

§

### impl<'tcx> !UnwindSafe for SelectionCandidate<'tcx>

## Blanket Implementations§

Source§

### impl<T> Aligned for T

Source§

#### const ALIGN: Alignment

Alignment of `Self`.
Source§

### impl<T> Any for T
where T: 'static + ?Sized,

Source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
Source§

### impl<T> AnyEq for T
where T: Any + PartialEq,

Source§

#### fn equals(&self, other: &(dyn Any + 'static)) -> bool

Source§

#### fn as_any(&self) -> &(dyn Any + 'static)

Source§

### impl<T> Borrow<T> for T
where T: ?Sized,

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

### impl<T> CloneToUninit for T
where T: Clone,

Source§

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`. Read more
Source§

### impl<T, R> CollectAndApply<T, R> for T

Source§

#### fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to `f(&iter.collect::<Vec<_>>())`.

Source§

#### type Output = R

Source§

### impl<T> DynClone for T
where T: Clone,

Source§

#### fn __clone_box(&self, _: Private) -> *mut ()

Source§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
Source§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
Source§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

#### fn equivalent(&self, key: &K) -> bool

Compare self to `key` and return `true` if they are equal.
Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

Source§

### impl<T> Instrument for T

Source§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
Source§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
Source§

### impl<T, U> Into<U> for T
where U: From<T>,

Source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

Source§

### impl<T> IntoEither for T

Source§

#### fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left` is `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
Source§

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left(&self)` returns `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
Source§

### impl<K> IntoQueryKey<K> for K

Source§

#### fn into_query_key(self) -> K

Argument conversion from `Self` to `K`. This should always be a very cheap conversion, e.g. `LocalDefId::to_def_id`.
Source§

### impl<T> MaybeResult<T> for T

Source§

#### type Error = !

Source§

#### fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

Source§

#### fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

Source§

### impl<T> Pointable for T

Source§

#### const ALIGN: usize

The alignment of pointer.
Source§

#### type Init = T

The type for initializers.
Source§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

### impl<T> Same for T

Source§

#### type Output = T

Should always be `Self`
Source§

### impl<T> ToOwned for T
where T: Clone,

Source§

#### type Owned = T

The resulting type after obtaining ownership.
Source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

#### type Error = Infallible

The type returned in the event of a conversion error.
Source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

### impl<I, T> TypeVisitableExt<I> for T
where I: Interner, T: TypeVisitable<I>,

Source§

#### fn has_type_flags(&self, flags: TypeFlags) -> bool

Source§

#### fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool

Returns `true` if `self` has any late-bound regions that are either bound by `binder` or bound by some binder outside of `binder`. If `binder` is `ty::INNERMOST`, this indicates whether there are any late-bound regions that appear free.
Source§

#### fn error_reported(&self) -> Result<(), <I as Interner>::ErrorGuaranteed>

Source§

#### fn non_region_error_reported( &self, ) -> Result<(), <I as Interner>::ErrorGuaranteed>

Source§

#### fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool

Returns `true` if this type has any regions that escape `binder` (and hence are not bound by it).
Source§

#### fn has_escaping_bound_vars(&self) -> bool

Return `true` if this type has regions that are not a part of the type. For example, `for<'a> fn(&'a i32)` return `false`, while `fn(&'a i32)` would return `true`. The latter can occur when traversing through the former. Read more
Source§

#### fn has_aliases(&self) -> bool

Source§

#### fn has_opaque_types(&self) -> bool

Source§

#### fn has_coroutines(&self) -> bool

Source§

#### fn references_error(&self) -> bool

Source§

#### fn has_non_region_param(&self) -> bool

Source§

#### fn has_infer_regions(&self) -> bool

Source§

#### fn has_infer_types(&self) -> bool

Source§

#### fn has_non_region_infer(&self) -> bool

Source§

#### fn has_infer(&self) -> bool

Source§

#### fn has_placeholders(&self) -> bool

Source§

#### fn has_non_region_placeholders(&self) -> bool

Source§

#### fn has_param(&self) -> bool

Source§

#### fn has_free_regions(&self) -> bool

“Free” regions in this context means that it has any region that is not (a) erased or (b) late-bound.
Source§

#### fn has_erased_regions(&self) -> bool

Source§

#### fn has_erasable_regions(&self) -> bool

True if there are any un-erased free regions.
Source§

#### fn is_global(&self) -> bool

Indicates whether this value references only ‘global’ generic parameters that are the same regardless of what fn we are in. This is used for caching.
Source§

#### fn has_bound_regions(&self) -> bool

True if there are any late-bound regions
Source§

#### fn has_non_region_bound_vars(&self) -> bool

True if there are any late-bound non-region variables
Source§

#### fn has_bound_vars(&self) -> bool

True if there are any bound variables
Source§

#### fn still_further_specializable(&self) -> bool

Indicates whether this value still has parameters/placeholders/inference variables which could be replaced later, in a way that would change the results of `impl` specialization.
Source§

#### fn has_non_region_error(&self) -> bool

True if a type or const error is reachable
Source§

### impl<I, T, U> Upcast<I, U> for T
where U: UpcastFrom<I, T>,

Source§

#### fn upcast(self, interner: I) -> U

Source§

### impl<I, T> UpcastFrom<I, T> for T

Source§

#### fn upcast_from(from: T, _tcx: I) -> T

Source§

### impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

#### fn vzip(self) -> V

Source§

### impl<T> WithSubscriber for T

Source§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
Source§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
Source§

### impl<T> ErasedDestructor for T
where T: 'static,

## 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:

- `SizedCandidate`: 0 bytes
- `BuiltinCandidate`: 0 bytes
- `TransmutabilityCandidate`: 0 bytes
- `ParamCandidate`: 32 bytes
- `ImplCandidate`: 12 bytes
- `AutoImplCandidate`: 0 bytes
- `ProjectionCandidate`: 24 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
- `BikeshedGuaranteedNoDropCandidate`: 0 bytes