From 4b57d2228b4f00e647efb10b0f874dd1fa9baefd Mon Sep 17 00:00:00 2001
From: Aaron Hill <aa1ronham@gmail.com>
Date: Wed, 6 Nov 2019 21:26:40 -0500
Subject: Fix opaque types resulting from projections in function signature

When we normalize the types in a function signature, we may end up
resolving a projection to an opaque type (e.g. `Self::MyType` when
we have `type MyType = impl SomeTrait`). When the projection is
resolved, we will instantiate the generic parameters into fresh
inference variables.

While we do want to normalize projections to opaque types, we don't want
to replace the explicit generic parameters (e.g. `T` in `impl
MyTrait<T>`) with inference variables. We want the opaque type in the
function signature to be eligible to be a defining use of that opaque
type - adding inference variables prevents this, since the opaque type
substs now appears to refer to some specific type, rather than a generic
type.

To resolve this issue, we inspect the opaque types in the function
signature after normalization. Any inference variables in the substs are
replaced with the corresponding generic parameter in the identity substs
(e.g. `T` in `impl MyTrait<T>`). Note that normalization is the only way
that we can end up with inference variables in opaque substs in a
function signature - users have no way of getting inference variables
into a function signature.

Note that all of this refers to the opaque type (ty::Opaque) and its
subst - *not* to the underlying type.

Fixes #59342
---
 src/test/ui/impl-trait/type-alias-generic-param.rs | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 src/test/ui/impl-trait/type-alias-generic-param.rs

(limited to 'src/test/ui/impl-trait')

diff --git a/src/test/ui/impl-trait/type-alias-generic-param.rs b/src/test/ui/impl-trait/type-alias-generic-param.rs
new file mode 100644
index 00000000000..d834d9bb112
--- /dev/null
+++ b/src/test/ui/impl-trait/type-alias-generic-param.rs
@@ -0,0 +1,22 @@
+// Regression test for issue #59342
+// Checks that we properly detect defining uses of opaque
+// types in 'item' position when generic parameters are involved
+//
+// run-pass
+#![feature(type_alias_impl_trait)]
+
+trait Meow {
+    type MeowType;
+    fn meow(self) -> Self::MeowType;
+}
+
+impl<T, I> Meow for I
+    where I: Iterator<Item = T>
+{
+    type MeowType = impl Iterator<Item = T>;
+    fn meow(self) -> Self::MeowType {
+        self
+    }
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5