`mismatched types` instead of "type does not implement required traits"

[Danvil]

Code

struct Foo;

impl Foo {
    fn heck<T>(&self, rel: T)
    where
        Lock: Key<T>,
    {
        self.with(Junk);
    }

    fn with<T>(&self, _id: T)
    where
        Lock: Key<T>,
    {
        todo!()
    }
}

struct Junk;

trait Key<T> {}

struct Lock {}

impl<T> Key<T> for Lock {}

Current output

error[E0308]: mismatched types
  --> toybox\src\mismatched_types.rs:8:19
   |
4  |     fn heck<T>(&self, rel: T)
   |             - expected this type parameter
...
8  |         self.with(Junk);
   |              ---- ^^^^ expected type parameter `T`, found `Junk`
   |              |
   |              arguments to this method are incorrect
   |
   = note: expected type parameter `T`
                      found struct `Junk`
note: method defined here
  --> toybox\src\mismatched_types.rs:11:8
   |
11 |     fn with<T>(&self, _id: T)
   |        ^^^^           ------

Desired output

The error message should state that `with` cannot be called because `Lock: Key<Junk>` is not satisfied.

Rationale and extra context

I was stuck on this error message for a long time.. The compiler seems to determine that the only possible type which satisfies all constraints is T and then quite determined states to change Junk to T. This feels backwards as usually error messages indicate that a function cannot be called because required traits are not implemented. At the very least it should be a suggestion: "Did you mean "T" as it is the only type which works here? Otherwise you have to add more trait bounds."

Other cases

Rust Version

rustc 1.88.0 (6b00bc388 2025-06-23)
binary: rustc
commit-hash: 6b00bc3880198600130e1cf62b8f8a93494488cc
commit-date: 2025-06-23
host: x86_64-pc-windows-msvc
release: 1.88.0
LLVM version: 20.1.5

Anything else?

No response

[lqd]

With a blanket Key impl, Lock: Key<Junk> holds, so this looks more like inference failing rather than the type not implementing the required traits.

Turbofishing your call like self.with::<Junk>(Junk); should work.

[Danvil]

@lqd You are right: self.with::<Junk>(Junk); works, too.

I assumed the fix would be to add: Lock: Key<Junk> to the trait bounds of heck.

Is this a compiler bug then?

Btw in the case from which I condensed this minimal reproducible example there was no blanket implementation for Lock, but impl Key<Junk> for Lock {} was specified specifically. This shouldn't really change anything though.