GAT & TAIT with lifetime type parameters fail std::marker::Sized requirement

[rustrial]

Playing around with (the not yet stable) GAT and TAIT features I stumbled over the below problem, where type parameters to nested TAIT/GAT with lifetime parameters cause a "this type parameter needs to be std::marker::Sized" compiler error.

The following code fails to compile with below compiler error (Playground):

#![feature(type_alias_impl_trait)]
#![feature(generic_associated_types)]

extern crate futures;
use futures::Stream;
use std::future::Future;

trait X {
    type LineStream<'a, Repr>: Stream<Item = Repr> where Self: 'a;

    type LineStreamFut<'a,Repr>: Future<Output = Self::LineStream<'a, Repr>> where Self: 'a;

    fn line_stream<'a,Repr>(&'a self) -> Self::LineStreamFut<'a,Repr>;
}

struct Y;

impl X for Y {
    type LineStream<'a, Repr> = impl Stream<Item = Repr>;

    type LineStreamFut<'a, Repr> = impl Future<Output = Self::LineStream<'a, Repr>> ;

    fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr> {
        async {futures::stream::empty()}
    }
}

fn main() {}

warning: the cargo feature `edition2021` has been stabilized in the 1.56 release and is no longer necessary to be listed in the manifest
  See https://doc.rust-lang.org/nightly/cargo/reference/manifest.html#the-edition-field for more information about using this feature.
   Compiling playground v0.0.1 (/playground)
error[E0277]: the size for values of type `Repr` cannot be known at compilation time
  --> src/main.rs:23:43
   |
23 |     fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr> {
   |                        ----               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
   |                        |
   |                        this type parameter needs to be `std::marker::Sized`

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

In contrast, the following code, without lifetime type parameters compiles without any error.

#![feature(type_alias_impl_trait)]
#![feature(generic_associated_types)]

extern crate futures;
use futures::Stream;
use std::future::Future;

trait X {
    type LineStream<Repr>: Stream<Item = Repr>;

    type LineStreamFut<Repr>: Future<Output = Self::LineStream<Repr>>;

    fn line_stream<Repr>(&self) -> Self::LineStreamFut<Repr>;
}

struct Y;

impl X for Y {
    type LineStream<Repr> = impl Stream<Item = Repr>;

    type LineStreamFut<Repr> = impl Future<Output = Self::LineStream<Repr>> ;

    fn line_stream<Repr>(&self) -> Self::LineStreamFut<Repr> {
        async {futures::stream::empty()}
    }
}

fn main() {}

---

Meta

cargo version --verbose:

cargo 1.56.0-nightly (e515c3277 2021-09-08)
release: 1.56.0
commit-hash: e515c3277bf0681bfc79a9e763861bfe26bb05db
commit-date: 2021-09-08

[jackh726]

This gives a different error. Minimized:

#![feature(type_alias_impl_trait)]
#![feature(generic_associated_types)]

use std::future::Future;
use std::marker::PhantomData;

pub trait Stream {
    type Item;
}

trait X {
    type LineStream<'a, Repr>: Stream<Item = Repr> where Self: 'a;
    type LineStreamFut<'a, Repr>: Future<Output = Self::LineStream<'a, Repr>> where Self: 'a;
    fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr>;
}

struct Y;

impl X for Y {
    type LineStream<'a, Repr> = impl Stream<Item = Repr>;
    type LineStreamFut<'a, Repr> = impl Future<Output = Self::LineStream<'a, Repr>>;
    fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr> {
        async { Empty { _phantom: PhantomData } }
    }
}

pub struct Empty<T> {
    _phantom: PhantomData<T>,
}

impl<T> Stream for Empty<T> {
    type Item = T;
}

fn main() {}

error[E0271]: type mismatch resolving `<impl Future as Future>::Output == impl Stream`
  --> src/main.rs:22:43
   |
20 |     type LineStream<'a, Repr> = impl Stream<Item = Repr>;
   |                                 ------------------------ the expected opaque type
21 |     type LineStreamFut<'a, Repr> = impl Future<Output = Self::LineStream<'a, Repr>>;
22 |     fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr> {
   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected opaque type, found struct `Empty`
   |
   = note: expected opaque type `impl Stream`
                   found struct `Empty<_>`

[jackh726]

GATs issue triage: not blocking. Seems like a TAITs bug; not sure there's anything for GATs to change here.

[oli-obk]

Compiles just fine now.

[oli-obk]

@jackh726 I guess this issue can just be closed if there's a test already?

[jackh726]

I think test needs to be moved to correct place?

[SarthakSingh31]

Hello, first time contributing to rust. I was trying to resolve this issue and after looking at the test I am a little confused. To me it looks like the test code is failing correctly and I can't understand where the TAIT bug is.

rust/src/test/ui/generic-associated-types/bugs/issue-89008.rs

Lines 1 to 43 in ebdde35

	// check-fail
	// edition:2021
	// known-bug: #88908
	// This should pass, but seems to run into a TAIT bug.
	#![feature(type_alias_impl_trait)]
	use std::future::Future;
	trait Stream {
	type Item;
	}
	struct Empty<T>(T);
	impl<T> Stream for Empty<T> {
	type Item = ();
	}
	fn empty<T>() -> Empty<T> {
	todo!()
	}
	trait X {
	type LineStream<'a, Repr>: Stream<Item = Repr> where Self: 'a;
	type LineStreamFut<'a,Repr>: Future<Output = Self::LineStream<'a, Repr>> where Self: 'a;
	fn line_stream<'a,Repr>(&'a self) -> Self::LineStreamFut<'a,Repr>;
	}
	struct Y;
	impl X for Y {
	type LineStream<'a, Repr> = impl Stream<Item = Repr>;
	type LineStreamFut<'a, Repr> = impl Future<Output = Self::LineStream<'a, Repr>> ;
	fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr> {
	async {empty()}
	}
	}
	fn main() {}

<Empty<T> as Steam>::Item has a concrete type () whereas the line_stream function is generic over Steam::Item. So to me it looks like the raised error is correct.

rust/src/test/ui/generic-associated-types/bugs/issue-89008.stderr

Lines 1 to 15 in ebdde35

	error[E0271]: type mismatch resolving `<Empty<_> as Stream>::Item == Repr`
	--> $DIR/issue-89008.rs:38:43
	|
	LL | fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr> {
	| ---- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type mismatch resolving `<Empty<_> as Stream>::Item == Repr`
	| |
	| this type parameter
	|
	note: expected this to be `()`
	--> $DIR/issue-89008.rs:17:17
	|
	LL | type Item = ();
	| ^^
	= note: expected unit type `()`
	found type parameter `Repr`

Changing the Stream implementation to

impl<T> Stream for Empty<T> {
    type Item = T;
}

makes the code compile.

I am sorry if I am missing something here. If the test is correct then would moving the test to src/test/ui/type-alias-impl-trait resolve this issue? @jackh726

I also don't think #88908 relates to this test.

[jackh726]

Yeah, I messed up my minimization. The test should just use the original MCVE in the OP. And that is indeed fixed.

[jackh726]

For clarity: this can be closed when the current known-bug test is moved to the main directory for GAT tests and changed to use the OP MCVE.