Constraint does not match because where clause hides blanket impl

[cristicbz]

playground

Sorry about the title gore, but I don't really know how to describe this:

pub trait ProxiedBy<T> {}
impl<T> ProxiedBy<T> for T {}

pub trait SomeConstraint {}

struct Performer<OnT>(OnT);

impl<OnT> Performer<OnT> {
    fn perform<QueryT, ProxyT>(&self, query: QueryT)
        where QueryT: ProxiedBy<ProxyT>,
              OnT: ProxiedBy<ProxyT>,
              ProxyT: SomeConstraint {}
}

fn good<OnT, IrrelevantT>(performer: Performer<OnT>, on: OnT)
        where OnT: SomeConstraint
{
    performer.perform(on);
}

fn bad<OnT, IrrelevantT>(performer: Performer<OnT>, on: OnT)
        where OnT: SomeConstraint + ProxiedBy<IrrelevantT>
{
    performer.perform(on);
}

fn main() {}

Fails with (on both stable & nightliy):

error[E0277]: the trait bound `IrrelevantT: SomeConstraint` is not satisfied
  --> y.rs:17:15
   |
17 |     performer.perform(on);
   |               ^^^^^^^ trait `IrrelevantT: SomeConstraint` not satisfied
   |
   = help: consider adding a `where IrrelevantT: SomeConstraint` bound

error: aborting due to previous error

The ProxiedBy<IrrelevantT> constraint is the only difference between good and bad. But OnT: ProxiedBy<OnT> + HasConstraint, therefore ProxyT = OnT should still be a valid substitution.

Since IrrelevantT: !SomeConstraint (as rustc helpfully explains) there also should be no problem.

[cristicbz]

Changing the QueryT constraint to a subtrait of ProxiedBy, we can fix bad by adding the superfluous OnT: ProxiedBy<OnT> constraint (playground):

pub trait ProxiedBy<T> {}
impl<T> ProxiedBy<T> for T {}

// New subtrait:
pub trait ProxiedBySubtrait<T>: ProxiedBy<T> {}
impl<T> ProxiedBySubtrait<T> for T {}

pub trait SomeConstraint {}

struct Performer<OnT>(OnT);

impl<OnT> Performer<OnT> {
    fn perform<QueryT, ProxyT>(&self, query: QueryT)
        where QueryT: ProxiedBySubtrait<ProxyT>,  // Was QueryT: ProxiedBy<ProxyT>
              OnT: ProxiedBy<ProxyT>,
              ProxyT: SomeConstraint {}
}

fn good_again<OnT, IrrelevantT>(performer: Performer<OnT>, on: OnT)
        where OnT: SomeConstraint + ProxiedBy<IrrelevantT>,
              OnT: ProxiedBy<OnT>  // This constraint should be unnecessary!
{
    performer.perform(on);
}