Trait method has higher precedence than inherent method if autoref is required for the inherent method

[jplatte]

I was very surprised when I found the following outputs "trait method" (playground):

struct Struct;

impl Struct {
    fn foo(&self) {
        println!("inherent method")
    }
}

pub trait Foo {
    fn foo(self);
}

impl Foo for Struct {
    fn foo(self) {
        println!("trait method")
    }
}

fn main() {
    Struct.foo();
}

Up until now I always thought that an inherent method always takes precedence over a trait method of the same name. Is that not true in this case / is this behaviour intended?

This came up in yew, which defined an inherent try_into (now renamed) with a type parameter that would start producing errors about unexpected type parameters when TryInto (or stdweb::unstable::TryInto) was brought into scope.

[nikomatsakis]

This is the current behavior. It can indeed be surprising but making changes here would have pretty dramatic effects and would require us to invest a lot of effort into the transition (definitely this would require an edition change). I'm going to go ahead and close this issue -- if we wanted to pursue it, the right thing to do would be to file a lang team project proposal, but I can say now that I would be somewhat reluctant to start in on this work.

[jplatte]

I saw this came up again with TryInto entering the prelude (#86657 fixes the lint to behave correctly around autoref). Is there some documentation for the current behavior somewhere? If not, should I open a new issue about that or can we reopen this one to track documentation of this?