Test that opaque types can't have themselves as a hidden type with incompatible lifetimes

tests/ui/type-alias-impl-trait/different_args_considered_equal.rs

@@ -0,0 +1,14 @@
+#![feature(type_alias_impl_trait)]
+
+pub type Opaque<'a> = impl Sized;
+
+fn get_one<'a>(a: *mut &'a str) -> Opaque<'a> {
+ a
+}
+
+fn get_iter<'a>() -> impl IntoIterator<Item = Opaque<'a>> {
+ //~^ ERROR: item does not constrain
+ None::<Opaque<'static>>
+}
+
+fn main() {}

tests/ui/type-alias-impl-trait/different_args_considered_equal.stderr

@@ -0,0 +1,15 @@
+error: item does not constrain `Opaque::{opaque#0}`, but has it in its signature
+ --> $DIR/different_args_considered_equal.rs:9:4
+ |
+LL | fn get_iter<'a>() -> impl IntoIterator<Item = Opaque<'a>> {
+ | ^^^^^^^^
+ |
+ = note: consider moving the opaque type's declaration and defining uses into a separate module
+note: this opaque type is in the signature
+ --> $DIR/different_args_considered_equal.rs:3:23
+ |
+LL | pub type Opaque<'a> = impl Sized;
+ | ^^^^^^^^^^
+
+error: aborting due to 1 previous error
+

tests/ui/type-alias-impl-trait/different_args_considered_equal2.rs

@@ -0,0 +1,14 @@
+#![feature(type_alias_impl_trait)]
+
+pub type Opaque<'a> = impl Sized;
+
+fn get_one<'a>(a: *mut &'a str) -> impl IntoIterator<Item = Opaque<'a>> {
+ if a.is_null() {
+ Some(a)
+ } else {
+ None::<Opaque<'static>>
+ //~^ ERROR hidden type for `Opaque<'static>` captures lifetime that does not appear in bounds
+ }
+}
+
+fn main() {}

tests/ui/type-alias-impl-trait/different_args_considered_equal2.stderr

@@ -0,0 +1,20 @@
+error[E0700]: hidden type for `Opaque<'static>` captures lifetime that does not appear in bounds
+ --> $DIR/different_args_considered_equal2.rs:9:9
+ |
+LL | pub type Opaque<'a> = impl Sized;
+ | ---------- opaque type defined here
+LL |
+LL | fn get_one<'a>(a: *mut &'a str) -> impl IntoIterator<Item = Opaque<'a>> {
+ | -- hidden type `*mut &'a str` captures the lifetime `'a` as defined here
+...
+LL | None::<Opaque<'static>>
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: to declare that `impl IntoIterator<Item = Opaque<'a>>` captures `'a`, you can add an explicit `'a` lifetime bound
+ |
+LL | fn get_one<'a>(a: *mut &'a str) -> impl IntoIterator<Item = Opaque<'a>> + 'a {
+ | ++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0700`.

tests/ui/type-alias-impl-trait/different_args_considered_equal3.rs

@@ -0,0 +1,22 @@
+//! Test that we don't allow coercing an opaque type with a non-static
+//! lifetime to one with a static lifetime. While `get_iter` looks like
+//! it would be doing the opposite, the way we're handling projections
+//! makes `Opaque<'a>` the hidden type of `Opaque<'static>`.
+
+#![feature(type_alias_impl_trait)]
+
+mod defining_scope {
+ pub type Opaque<'a> = impl Sized;
+
+ fn get_one<'a>(a: *mut &'a str) -> Opaque<'a> {
+ a
+ }
+}
+use defining_scope::Opaque;
+
+fn get_iter<'a>() -> impl IntoIterator<Item = Opaque<'a>> {
+ None::<Opaque<'static>>
+ //~^ ERROR lifetime may not live long enough
+}
+
+fn main() {}

tests/ui/type-alias-impl-trait/different_args_considered_equal3.stderr

@@ -0,0 +1,10 @@
+error: lifetime may not live long enough
+ --> $DIR/different_args_considered_equal3.rs:18:5
+ |
+LL | fn get_iter<'a>() -> impl IntoIterator<Item = Opaque<'a>> {
+ | -- lifetime `'a` defined here
+LL | None::<Opaque<'static>>
+ | ^^^^^^^^^^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
+
+error: aborting due to 1 previous error
+