Miss Dada  🏳️‍⚧️

What's happening is that for x it's managing to find a single impl that doesn't require coercion. it's done! it's able to coerce for y because there's a single impl, so all the expected types are known

Right, which is my point. It's willing to try coercing y, it's not willing to try coercing x. It's a special case for `Self`. I'm not saying it's bad, I'm saying it's arbitrary

I think my issue is with the term "special case" here, because the underlying reason here is that trait search fundamentally works off of self, and this isn't the only way that manifests. this isn't specific to deref coercions.

Sure, but what is self other than the first argument? re-rebalancing coherence was literally about changing the trait system to stop treating self as different, and instead just treating it as the leftmost argument, and applying the same rules left to right

self isn't always the first argument, though It's not for foo<T: Trait<U>, U>(x: bool, y: T, z: U), and you'll have similar problems here the UFCS call is basically eq<T: PartialEq<U>, U>(&T, &U)

Right, which is why I wouldn't want to treat `self` as special at all, rules for dispatching both are the same. Fewest derefs left to right. (don't deref T, try derefing U repeatedly, if you find an impl stop, deref T once, ...)

"left to right" assumes that there's a function here *at all*, though

i guess you can special case for deref coercions that are happening in function call arguments only