Using `type` with local type parameters has confusing error

[bluss]

Using type with local type parameters or Self should have a clearer error.

Reproduce with: (playpen link)

struct Foo;

impl Foo {
    fn method<T>(&self) {
        type X = (Self, T);
    }
}

Current errors have a suggestion ("try..") that doesn't apply.

error[E0401]: can't use type parameters from outer function; try using a local type parameter instead
 --> <anon>:6:19
  |
6 |         type X = (Self, T);
  |                   ^^^^ use of type variable from outer function

error[E0401]: can't use type parameters from outer function; try using a local type parameter instead
 --> <anon>:6:25
  |
6 |         type X = (Self, T);
  |                         ^ use of type variable from outer function

[KalitaAlexey]

Why is this disallowed?

[arielb1]

@KalitaAlexey

Nested items are independent from their parent item for everything except for privacy and name resolution. This includes type parameters.

The suggestion is in fact correct - this can be fixed by something like

struct Foo;

impl Foo {
    fn method<T>(&self) {
        type X<This, T> = (This, T);
    }
}
 
fn main() { }

[bluss]

I don't think the user will understand This in type X<This> to be a "local type parameter"; I didn't. If that's just the issue, it could call it something else.

[KalitaAlexey]

Hi @arielb1,
I meant that I think that type X = (Self, T) in a function's body can be useful.
You said that nested items are independent. What's a reason?

[csmoe]

cc #47574
current error message:

error[E0401]: can't use type parameters from outer function
 --> src/main.rs:6:19
  |
4 | impl Foo {
  | ---- `Self` type implicitly declared here, by this `impl`
5 |     fn method<T>(&self) {
6 |         type X = (Self, T);
  |                   ^^^^
  |                   |
  |                   use of type variable from outer function
  |                   use a type here instead

error[E0401]: can't use type parameters from outer function
 --> src/main.rs:6:25
  |
5 |     fn method<T>(&self) {
  |        ------ - type variable from outer function
  |        |
  |        try adding a local type parameter in this method instead
6 |         type X = (Self, T);
  |                         ^ use of type variable from outer function

error: aborting due to 2 previous errors

[estebank]

It seems to me what this is missing is a note explaining the same thing as #37892 (comment).

[MatrixDev]

Just had the same issue, just a little different implementation:

enum MyEnum {}

impl MyEnum {
    fn do_something(result: impl FnOnce()) {
        result();
    }

    fn do_something_extra() {
        fn inner() {
            Self::do_something(move || {}); // can't use generic parameters from outer function E0401
            MyEnum::do_something(move || {}); // no error
        }
        inner();
    }
}

It seams that accessing Self from inner functions is not allowed. This doesn't seem logical and error is way too confusing (or probably describing something else completely).