Error in trait resolution on traits with associated types with generic lifetimes

[zommiommy]

Hi! I think I've found an error in the type system.

I think the following code should compile (Link to rust playground):

pub trait Base {
    type Item<'a> where Self: 'a;
}

pub trait ClonableBase: Base
where
    for<'a> Self::Item<'a>: Clone
{}
impl<T: Base> ClonableBase for T
where
    for<'a> Self::Item<'a>: Clone
{}

fn test<G: ClonableBase>(g: G) 
where
    for<'a> G::Item<'a>: Clone
{
    todo!()
}

pub fn main() {
    struct Data;
    
    impl Base for Data {
        type Item<'a> = usize where Self: 'a;
    }
    
    test(Data)
}

I expected this to compile as usize does implement Clone so ClonableBase is satisfied

Instead, rust refuse to compile as it can't infer that Item is usize which implements Clone.

Compiling playground v0.0.1 (/playground)
error[[E0277]](https://doc.rust-lang.org/stable/error_codes/E0277.html): the trait bound `for<'a> <_ as Base>::Item<'a>: Clone` is not satisfied
  --> src/main.rs:29:10
   |
29 |     test(Data)
   |     ---- ^^^^ the trait `for<'a> Clone` is not implemented for `<_ as Base>::Item<'a>`
   |     |
   |     required by a bound introduced by this call
   |
note: required by a bound in `test`
  --> src/main.rs:17:26
   |
15 | fn test<G: ClonableBase>(g: G) 
   |    ---- required by a bound in this function
16 | where
17 |     for<'a> G::Item<'a>: Clone
   |                          ^^^^^ required by this bound in `test`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `playground` (bin "playground") due to previous error

Also, weirdly, test requires:

where
    for<'a> G::Item<'a>: Clone

As it is a constrait already specified by ClonableBase

[zommiommy]

Note that removing the generic lifetime it compiles

pub trait Base {
    type Item;
}

pub trait ClonableBase: Base
where
    Self::Item: Clone
{}

impl<T: Base> ClonableBase for T
where
    Self::Item: Clone
{}

fn test<G: ClonableBase>(g: G) 
where
    G::Item: Clone
{
    todo!()
}

pub fn main() {
    struct Data;
    
    impl Base for Data {
        type Item = usize;
    }
    
    test(Data)
}

[zommiommy]

An alternative we found is this, but it's generally more messy:

pub trait Base<'a> where Self: 'a {
    type Item<'b> where Self: 'b;
    
    fn get_item(&'a self) -> Self::Item<'a>;
}

pub trait ClonableBase<'a>: Base<'a>
where
    Self::Item<'a>: Clone,
{}
impl<'a, T: Base<'a>> ClonableBase<'a> for T
where
    Self::Item<'a>: Clone
{}

fn test<'a, G: ClonableBase<'a>>(g: G) 
where
    G::Item<'a>: Clone
{
    todo!()
}

pub fn main() {
    struct Data(usize);
    
    impl<'a> Base<'a> for Data {
        type Item<'b> = &'b usize where Self: 'b;
        fn get_item(&'a self) -> Self::Item<'a> {
            &self.0
        }
    }
    
    test(Data(10))
}

[jieyouxu]

Current stable 1.76.0 output:

error[E0277]: the trait bound `for<'a> <_ as Base>::Item<'a>: Clone` is not satisfied
  --> src/main.rs:29:10
   |
29 |     test(Data)
   |     ---- ^^^^ the trait `for<'a> Clone` is not implemented for `<_ as Base>::Item<'a>`
   |     |
   |     required by a bound introduced by this call
   |
note: this is a known limitation of the trait solver that will be lifted in the future
  --> src/main.rs:29:10
   |
29 |     test(Data)
   |     -----^^^^-
   |     |    |
   |     |    the trait solver is unable to infer the generic types that should be inferred from this argument
   |     add turbofish arguments to this call to specify the types manually, even if it's redundant
note: required by a bound in `test`
  --> src/main.rs:17:26
   |
15 | fn test<G: ClonableBase>(g: G) 
   |    ---- required by a bound in this function
16 | where
17 |     for<'a> G::Item<'a>: Clone
   |                          ^^^^^ required by this bound in `test`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `playground` (bin "playground") due to 1 previous error

And is resolved in nightly: https://godbolt.org/z/hP58rGTMz.