Typecheck fails when providing explicit types instead of GAT

[ear7h]

I tried to compile this code:

#![feature(generic_associated_types)]

trait Scanner {
    type Input<'a>;
    type Token<'a>;
    
    fn scan<'a>(&mut self, i : Self::Input<'a>) -> Self::Token<'a>;
}

struct IdScanner();

impl Scanner for IdScanner {
    type Input<'a> = &'a str;
    type Token<'a> = &'a str;
    
    fn scan<'a>(&mut self, s : &'a str) -> &'a str {
        s
    }
}

I expected to see this happen:
The code compile successfully

Instead, this happened:
Rust could not match the lifetimes.

error[E0195]: lifetime parameters or bounds on method `scan` do not match the trait declaration
  --> src/lib.rs:16:12
   |
7  |     fn scan<'a>(&mut self, i : Self::Input<'a>) -> Self::Token<'a>;
   |            ---- lifetimes in impl do not match this method in trait
...
16 |     fn scan<'a>(&mut self, s : &'a str) -> &'a str {
   |            ^^^^ lifetimes do not match method in trait

For more information about this error, try `rustc --explain E0195`.

Changing the impl method to:

fn scan<'a>(&mut self, s : Self::Input<'a>) -> Self::Token<'a> {

Does compile successfully.

This seems somewhat related to #79207 and possibly in scope of #85499

Meta

I tried this on nightly as well as with the latest code from #85499 this commit
nightly:

rustc 1.56.0-nightly (492723897 2021-07-29)                                           
binary: rustc                                                                         
commit-hash: 492723897e9b4db6701b3a75b72618d08a7d5319                                 
commit-date: 2021-07-29                                                               
host: x86_64-apple-darwin                                                             
release: 1.56.0-nightly                                                               
LLVM version: 12.0.1

from jackh726:

rustc 1.55.0-dev                                                                      
binary: rustc                                                                         
commit-hash: unknown                                                                  
commit-date: unknown                                                                  
host: x86_64-apple-darwin                                                             
release: 1.55.0-dev                                                                   
LLVM version: 12.0.1

[jackh726]

Interestingly, I wonder if this is caused be the same underlying issue as #85533 (though I haven't actually looked into this).

[jackh726]

Yes, this is basically a duplicate of #85533. This is "intended behavior" as far as the rules around early/late bound regions are concerned. But we probably want to change this at some point.

In the trait, 'a is assigned early bound (because projections don't constrain the lifetime, so 'a doesn't appear constrained in input types). In the impl, 'a is assigned late bound (because &'a is constrained, so it does appear constrained in input types).

[jackh726]

GATs issue triage: not blocking. See #85333 for why.

[ilslv]

Stumbled into this issue and wanted to clarify some things for someone struggling with that issue:

1. This errors in the opposite case, when regular arguments are replaced with GATs:

trait Test {
    fn test(arg: &str) -> &str;
}

trait Lookup {
    type Arg<'a>;
}

impl<T: ?Sized> Lookup for T {
    type Arg<'a> = &'a str;
}

// errors
impl Test for () {
    fn test(arg: <Self as Lookup>::Arg<'_>) -> <Self as Lookup>::Arg<'_> {
        arg
    }
}

2. This is a problem only for function signatures, that have non-receiving argument (not self) containing the same lifetime, as the return type. In case lifetime appears only in argument, only in return type or in &self and return type, this works just fine.

3. To hack around this we can transform late-bounded lifetime into an early-bounded one with useless 'a: 'a bound:

trait Test {
    fn test<'a: 'a>(arg: &'a str) -> &'a str;
}

trait Lookup {
    type Arg<'a>;
}

impl<T: ?Sized> Lookup for T {
    type Arg<'a> = &'a str;
}

impl Test for () {
    fn test(arg: <Self as Lookup>::Arg<'_>) -> <Self as Lookup>::Arg<'_> {
        arg
    }
}

[QuineDot]

This also comes up with refined RPITs (URLO thread) on stable.

#![allow(refining_impl_trait)]

pub trait Trait {
    type Gat<'a>;
    fn example(&self, _: Self::Gat<'_>) -> impl Sized;
}

impl Trait for () {
    type Gat<'a> = ();

    // This works
    fn example(&self, _: Self::Gat<'_>) -> impl Sized {}

    // These all fail with E0195
    // fn example(&self, _: ()) {} // 1
    // fn example(&self, _: Self::Gat<'_>) {} // 2
    // fn example(&self, _: ()) -> Self::Gat<'_> {} // 3
}

And with precise capturing (unstable).

#![feature(precise_capturing_in_traits)]
#![allow(refining_impl_trait)]

pub trait Trait {
    type Gat<'a>;
    fn example(&self, _: Self::Gat<'_>) -> impl Sized;
}

impl Trait for () {
    type Gat<'a> = ();

    // E0195
    fn example<'this>(&'this self, _: Self::Gat<'_>) -> impl Sized + use<'this> {}
}

Issue #109476 is related.