Method resolution error

[RustyYato]

I tried this code:

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=5ce8c7b1f8fdb39762765a7bf1576cfb

#[derive(Debug)]
pub struct Foo<T>(pub T);

impl<T> Access for T {}
pub trait Access {
    fn field<N, T, Name: 'static>(&self) -> &T {
        todo!()
    }

    fn field_mut<N, T, Name: 'static>(&mut self) -> &mut T {
        todo!()
    }

    fn take_field<N, T, Name>(self) {
        todo!()
    }
}

I expected it to compile, but it doesn't because the Debug macro expands to something like foo.field("field_name", &value), which incorrectly resolves to Access::field instead of DebugTuple::field (which is an inherent method).

error message

error[E0061]: this function takes 0 arguments but 1 argument was supplied
 --> src/lib.rs:1:10
  |
1 | #[derive(Debug)]
  |          ^^^^^ expected 0 arguments
2 | pub struct Foo<T>(pub T);
  |                   ----- supplied 1 argument
  |
note: associated function defined here
 --> src/lib.rs:6:8
  |
6 |     fn field<N, T, Name: 'static>(&self) -> &T {
  |        ^^^^^                      -----
  = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0277]: the size for values of type `Self` cannot be known at compilation time
  --> src/lib.rs:14:31
   |
14 |     fn take_field<N, T, Name>(self) {
   |                               ^^^^ doesn't have a size known at compile-time
   |
   = help: unsized fn params are gated as an unstable feature
help: consider further restricting `Self`
   |
14 |     fn take_field<N, T, Name>(self) where Self: Sized {
   |                                     ^^^^^^^^^^^^^^^^^
help: function arguments must have a statically known size, borrowed types always have a known size
   |
14 |     fn take_field<N, T, Name>(&self) {
   |                               ^

error: aborting due to 2 previous errors

Some errors have detailed explanations: E0061, E0277.
For more information about an error, try `rustc --explain E0061`.
error: could not compile `playground`

To learn more, run the command again with --verbose.

[SNCPlay42]

This works on stable and beta (as in, it compiles without error if you add a : Sized supertrait to Access) , but not on nightly.

@rustbot label regression-from-stable-to-nightly

[SNCPlay42]

searched nightlies: from nightly-2020-12-25 to nightly-2021-01-20
regressed nightly: nightly-2021-01-18
searched commits: from 8a65184 to 4253153
regressed commit: edeb631

bisected with cargo-bisect-rustc v0.6.0

Host triple: x86_64-unknown-linux-gnu
Reproduce with:

cargo bisect-rustc --preserve --start=2020-12-25 

[SNCPlay42]

I think part of the problem is that f.field(...) looks for methods on &DebugTuple and sees the <DebugTuple as Access>::field(&self) before it looks for methods on &mut DebugTuple and finds DebugTuple::field(&mut self, ...). This issue with autoref/autoderef interacting poorly with inherent method's precedence over trait methods has cropped up before, e.g. in #39232 (where the compiler finds <T as BorrowMut>::borrow_mut(self) before trying autoref and finding RefCell::borrow_mut(&self)). But I don't have an explanation for why this started being a problem recently.

On another note, I notice that #[derive(Debug)] appears to be the only built-in derive that ever uses . method calls instead of UFCS with fully qualified paths, is there a reason for that? This issue could be fixed by changing #[derive(Debug)] to not use . calls, but I'm concerned that the root cause might have broken something else.

[SNCPlay42]

Looking at the rollup that this regressed in, #80765 seems like it might be the cause.

cc @petrochenkov

[petrochenkov]

Minimized:

#[derive(Debug)]
struct Foo(u8);

pub trait Access {
    fn field(&self) {}
}

impl<T> Access for T {}

derive(Debug) should certainly use UFCS instead of method calls, regardless of #80765.

If #80765 causes other issues we'll find out sooner or later, in theory it shouldn't change any behavior unless macros 2.0 (which are unstable) or built-in macros (which we can fix) are involved.

[petrochenkov]

(I'll leave the fix itself to someone else, unassigning myself.)