Enum rustc_trait_selection::traits::wf::Elaborate

pub(in traits::wf) enum Elaborate {
    All,
    None,
}

Controls whether we "elaborate" supertraits and so forth on the WF predicates. This is a kind of hack to address #43784. The underlying problem in that issue was a trait structure like:

trait Foo: Copy { }
trait Bar: Foo { }
impl<T: Bar> Foo for T { }
impl<T> Bar for T { }

Here, in the Foo impl, we will check that T: Copy holds -- but we decide that this is true because T: Bar is in the where-clauses (and we can elaborate that to include T: Copy). This wouldn't be a problem, except that when we check the Bar impl, we decide that T: Foo must hold because of the Foo impl. And so nowhere did we check that T: Copy holds!

To resolve this, we elaborate the WF requirements that must be proven when checking impls. This means that (e.g.) the impl Bar for T will be forced to prove not only that T: Foo but also T: Copy (which it won't be able to do, because there is no Copy impl for T).

Variants

All

None

Trait Implementations

impl Clone for Elaborate

pub fn clone(&self) -> Elaborate

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Elaborate

impl Debug for Elaborate

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

Formats the value using the given formatter.

impl Eq for Elaborate

impl PartialEq<Elaborate> for Elaborate

pub fn eq(&self, other: &Elaborate) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl StructuralEq for Elaborate

impl StructuralPartialEq for Elaborate