Add some TAIT-related tests

src/test/ui/type-alias-impl-trait/issue-53398-cyclic-types.rs

@@ -0,0 +1,9 @@
+#![feature(type_alias_impl_trait)]
+
+type Foo = impl Fn() -> Foo;
+
+fn foo() -> Foo {
+    foo //~ ERROR: overflow evaluating the requirement `fn() -> Foo {foo}: Sized`
+}
+
+fn main() {}

src/test/ui/type-alias-impl-trait/issue-53398-cyclic-types.stderr

@@ -0,0 +1,11 @@
+error[E0275]: overflow evaluating the requirement `fn() -> Foo {foo}: Sized`
+  --> $DIR/issue-53398-cyclic-types.rs:6:5
+   |
+LL |     foo
+   |     ^^^
+   |
+   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`issue_53398_cyclic_types`)
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0275`.

src/test/ui/type-alias-impl-trait/issue-58662-generator-with-lifetime.rs

@@ -0,0 +1,39 @@
+// check-pass
+
+#![feature(generators, generator_trait)]
+#![feature(type_alias_impl_trait)]
+
+use std::ops::{Generator, GeneratorState};
+use std::pin::Pin;
+
+type RandGenerator<'a> = impl Generator<Return = (), Yield = u64> + 'a;
+fn rand_generator<'a>(rng: &'a ()) -> RandGenerator<'a> {
+    move || {
+        let _rng = rng;
+        loop {
+            yield 0;
+        }
+    }
+}
+
+pub type RandGeneratorWithIndirection<'a> = impl Generator<Return = (), Yield = u64> + 'a;
+pub fn rand_generator_with_indirection<'a>(rng: &'a ()) -> RandGeneratorWithIndirection<'a> {
+    fn helper<'b>(rng: &'b ()) -> impl 'b + Generator<Return = (), Yield = u64> {
+        move || {
+            let _rng = rng;
+            loop {
+                yield 0;
+            }
+        }
+    }
+
+    helper(rng)
+}
+
+fn main() {
+    let mut gen = rand_generator(&());
+    match unsafe { Pin::new_unchecked(&mut gen) }.resume(()) {
+        GeneratorState::Yielded(_) => {}
+        GeneratorState::Complete(_) => {}
+    };
+}

src/test/ui/type-alias-impl-trait/issue-89952.rs

@@ -0,0 +1,31 @@
+// check-pass
+
+#![feature(type_alias_impl_trait)]
+
+trait SomeTrait {}
+impl SomeTrait for () {}
+
+trait MyFuture {
+    type Output;
+}
+impl<T> MyFuture for T {
+    type Output = T;
+}
+
+trait ReturnsFuture {
+    type Output: SomeTrait;
+    type Future: MyFuture<Output = Result<Self::Output, ()>>;
+    fn func() -> Self::Future;
+}
+
+struct Foo;
+
+impl ReturnsFuture for Foo {
+    type Output = impl SomeTrait;
+    type Future = impl MyFuture<Output = Result<Self::Output, ()>>;
+    fn func() -> Self::Future {
+        Result::<(), ()>::Err(())
+    }
+}
+
+fn main() {}

src/test/ui/type-alias-impl-trait/issue-94429.rs

@@ -0,0 +1,22 @@
+#![feature(type_alias_impl_trait, generator_trait, generators)]
+use std::ops::Generator;
+
+trait Runnable {
+    type Gen: Generator<Yield = (), Return = ()>;
+
+    fn run(&mut self) -> Self::Gen;
+}
+
+struct Implementor {}
+
+impl Runnable for Implementor {
+    type Gen = impl Generator<Yield = (), Return = ()>;
+
+    fn run(&mut self) -> Self::Gen {
+        move || { //~ ERROR: type mismatch resolving
+            yield 1;
+        }
+    }
+}
+
+fn main() {}

src/test/ui/type-alias-impl-trait/issue-94429.stderr

@@ -0,0 +1,11 @@
+error[E0271]: type mismatch resolving `<[generator@$DIR/issue-94429.rs:16:9: 18:10] as Generator>::Yield == ()`
+  --> $DIR/issue-94429.rs:16:9
+   |
+LL | /         move || {
+LL | |             yield 1;
+LL | |         }
+   | |_________^ expected integer, found `()`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0271`.