method selection considers nested deref steps without applying the constrains from computing them

[lcnr]

#![feature(arbitrary_self_types)]
struct Foo<T>(T);
struct Bar;

impl std::ops::Deref for Foo<u32> {
    type Target = Bar;
    fn deref(&self) -> &Self::Target {
        &Bar
    }
}
impl Foo<i32> {
    fn call_me(self) {
        println!("Foo");
    }
    
    fn call_me_receiver(&self) {
        println!("Foo");
    }
}
impl Bar {
    fn call_me(self) {
        println!("Bar");
    }
    
    fn call_me_receiver(self: Foo<u32>) {
        println!("Bar");
    }
}

fn main() {
    let x = Foo(Default::default());
    x.call_me(); // Foo
    
    let x = Foo(Default::default());
    x.call_me_receiver(); // Bar
}

[lcnr]

use std::pin::Pin;
use std::ops::Deref;

struct Foo;
impl Foo {
    fn pinned(self: Pin<&mut Self>) {}
}
fn yikes<T>()
where
    Pin<T>: Deref<Target = Foo>,
{
    let mut x = None::<Pin<_>>;
    while let Some(x) = x.take() {
        x.pinned();
    }
    println!("{}", std::any::type_name_of_val(&x)); // core::option::Option<core::pin::Pin<&mut playground::Foo>>
}

fn main() {
    yikes::<Pin<&Foo>>();
}

and

#![feature(arbitrary_self_types)]
use std::marker::PhantomData;
use std::ops::Deref;
struct Foo<T>(PhantomData<T>);
struct Bar;
struct Qux;
impl Deref for Foo<u32> {
    type Target = Bar;
    fn deref(&self) -> &Self::Target {
        &Bar
    }
}
impl Deref for Foo<u64> {
    type Target = Qux;
    fn deref(&self) -> &Self::Target {
        &Qux
    }
}

impl Bar {
    fn gamer(self: Foo<u32>) {
        println!("Bar");
    }
}
impl Qux {
    fn gamer(self: Foo<u64>) {
        println!("Qux");
    }
}

fn generic<T>()
where
    Foo<T>: Deref<Target = Bar>,
{
    let x = Foo(PhantomData);
    println!("{}", std::any::type_name_of_val(&x)); // Foo<u32>
    x.gamer(); // Bar
}

fn main() {
    generic::<u32>();
}

[lcnr]

use std::rc::Rc;
use std::ops::Deref;

#[derive(Default)]
struct Foo;
impl Foo {
    fn call_me(self: Rc<Self>) {}
}

#[derive(Default)]
struct Bar;
impl Bar {
    fn call_me(self: Rc<Self>) {}
}

fn yikes<T>()
where
    Rc<T>: Deref<Target: Deref<Target = Foo>>, // ok
{
    let x = Rc::new(Default::default());
    println!("{}", std::any::type_name_of_val(&x)); // Rc<Foo>,
    x.call_me();
}

fn main() {
    yikes::<Box<Foo>>();
}

explanation:
computing the autoderef steps for Rc<?infer> uses the where-bound, constrains ?infer to T and has Foo as the next step.

We then look at candidates for Foo without applying the constraints necessary to get to it in the autoderef chain. This then uses Foo::call_me for the Rc<?infer> self type, constraining ?infer to Foo, ignoring the fact that we've previously had to constrain it to T to get to Foo in the first place.