Generic type parameters are flexible even for existential types

Author: oli-obk

src/librustc_typeck/collect.rs

@@ -1346,7 +1346,16 @@ fn find_existential_constraints<'a, 'tcx>(
                 // FIXME(oli-obk): trace the actual span from inference to improve errors
                 let span = self.tcx.def_span(def_id);
                 if let Some((prev_span, prev_ty)) = self.found {
-                    if ty != prev_ty {
+                    let mut ty = ty.walk().fuse();
+                    let mut prev_ty = prev_ty.walk().fuse();
+                    let iter_eq = (&mut ty).zip(&mut prev_ty).all(|(t, p)| match (&t.sty, &p.sty) {
+                        // type parameters are equal to any other type parameter for the purpose of
+                        // concrete type equality, as it is possible to obtain the same type just
+                        // by passing matching parameters to a function.
+                        (ty::Param(_), ty::Param(_)) => true,
+                        _ => t == p,
+                    });
+                    if !iter_eq || ty.next().is_some() || prev_ty.next().is_some() {
                         // found different concrete types for the existential type
                         let mut err = self.tcx.sess.struct_span_err(
                             span,

src/test/ui/existential_types/generic_duplicate_param_use.rs

@@ -1,11 +1,13 @@
 // compile-pass
 #![feature(existential_type)]
 
+use std::fmt::Debug;
+
 fn main() {}
 
 // test that unused generic parameters are ok
-existential type Two<T, U>: 'static;
+existential type Two<T, U>: Debug;
 
-fn one<T: 'static>(t: T) -> Two<T, T> {
+fn one<T: Debug>(t: T) -> Two<T, T> {
     t
 }

src/test/ui/existential_types/generic_duplicate_param_use2.rs

@@ -1,15 +1,17 @@
 // compile-pass
 #![feature(existential_type)]
 
+use std::fmt::Debug;
+
 fn main() {}
 
 // test that unused generic parameters are ok
-existential type Two<T, U>: 'static;
+existential type Two<T, U>: Debug;
 
-fn one<T: 'static>(t: T) -> Two<T, T> {
+fn one<T: Debug>(t: T) -> Two<T, T> {
     t
 }
 
-fn two<T: 'static, U: 'static>(t: T, _: U) -> Two<T, U> {
+fn two<T: Debug, U>(t: T, _: U) -> Two<T, U> {
     t
 }

src/test/ui/existential_types/generic_duplicate_param_use3.rs

@@ -1,19 +1,21 @@
+// compile-pass
 #![feature(existential_type)]
 
+use std::fmt::Debug;
+
 fn main() {}
 
 // test that unused generic parameters are ok
-existential type Two<T, U>: 'static;
+existential type Two<T, U>: Debug;
 
-fn one<T: 'static>(t: T) -> Two<T, T> {
+fn one<T: Debug>(t: T) -> Two<T, T> {
     t
 }
 
-fn two<T: 'static, U: 'static>(t: T, _: U) -> Two<T, U> {
+fn two<T: Debug, U>(t: T, _: U) -> Two<T, U> {
     t
 }
 
-fn three<T: 'static, U: 'static>(_: T, u: U) -> Two<T, U> {
-    //~^ ERROR defining existential type use differs from previous
+fn three<T, U: Debug>(_: T, u: U) -> Two<T, U> {
     u
 }

src/test/ui/existential_types/generic_duplicate_param_use3.stderr

@@ -1,15 +1,17 @@
+// compile-pass
 #![feature(existential_type)]
 
+use std::fmt::Debug;
+
 fn main() {}
 
 // test that unused generic parameters are ok
-existential type Two<T, U>: 'static;
+existential type Two<T, U>: Debug;
 
-fn one<T: 'static>(t: T) -> Two<T, T> {
+fn one<T: Debug>(t: T) -> Two<T, T> {
     t
 }
 
-fn three<T: 'static, U: 'static>(_: T, u: U) -> Two<T, U> {
-//~^ ERROR defining existential type use differs from previous
+fn three<T, U: Debug>(_: T, u: U) -> Two<T, U> {
     u
 }