Small mistake in method call expressions explanation?

[LukasKalbertodt]

Here it says:

Then, for each candidate type T, search for a visible method with a receiver of that type in the following places:

1. T's inherent methods (methods implemented directly on T).
2. [...]

The part "methods implemented directly on T" is not completely correct, I think. As first sentence already says, we are searching for methods with the receiver type T, not methods in an impl block for T. And those two types can obviously be different.

impl Foo {
    fn by_ref(&self) {}
}

Suppose our candidate type T is &Foo, then by_ref would be a "visible method with a receiver of that type". However, the method by_ref is not implemented on &Foo, but on Foo. In other words: Self in that method is Foo, not &Foo.

To fix this, I would replace "methods implemented directly on T" with: "methods that belong to a type and not to a trait". Or something like that.

Am I correct that the current phrasing is wrong/very misleading? Or am I missing something?

[Havvy]

Edit: I misunderstood this issue.

From two paragraphs back:

"The first step is to build a list of candidate receiver types. Obtain these by repeatedly dereferencing the receiver expression's type, adding each type encountered to the list, then finally attempting an unsized coercion at the end, and adding the result type if that is successful. Then, for each candidate T, add &T and &mut T to the list immediately after T."

I wonder if there's a way to make the entire section of the algorithm more clear?

[LukasKalbertodt]

@Havvy I actually found the general explanation pretty good! I mean sure, more examples probably always help, but actually just wanted to mention this single mistake.

[Havvy]

Oh, I see. I was mistaken on what you meant. The real question is what does "methods implemented directly on T" mean? It could be taken in two ways:

1. The way you're doing it and applying it to what is the type after the impl.
2. The way the author intended it and applying it to the receiver of the method (e.g. fn (&self) is a method directly implemented for &T)

[LukasKalbertodt]

Yes, exactly. I assume the author just wanted to explain that "inherent method" means that the method does not belong to a trait but is implemented on a type directly. But using T in that explanation is confusing I think (because, as you said, one could interpret this in two ways).