[GSB] When adding same-type requirements pick representative based on canonical order

Instead of trying to order based on the "nested depth", let's
always prefer canonical ordering of type parameters when it comes
to picking representative equivalence class.

Resolves: rdar://problem/45957015

Author: xedin

lib/AST/GenericSignatureBuilder.cpp

@@ -4889,15 +4889,12 @@ GenericSignatureBuilder::addSameTypeRequirementBetweenTypeParameters(
   auto T1 = OrigT1->getRepresentative();
   auto T2 = OrigT2->getRepresentative();
 
-  // Decide which potential archetype is to be considered the representative.
-  // We prefer potential archetypes with lower nesting depths, because it
-  // prevents us from unnecessarily building deeply nested potential archetypes.
-  unsigned nestingDepth1 = T1->getNestingDepth();
-  unsigned nestingDepth2 = T2->getNestingDepth();
-  if (nestingDepth2 < nestingDepth1) {
+  // Pick representative based on the canonical ordering of the type parameters.
+  if (compareDependentTypes(depType2, depType1) < 0) {
     std::swap(T1, T2);
     std::swap(OrigT1, OrigT2);
     std::swap(equivClass, equivClass2);
+    std::swap(depType1, depType2);
   }
 
   // T1 must have an equivalence class; create one if we don't already have

test/Generics/rdar45957015.swift

@@ -0,0 +1,17 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol C {
+  associatedtype T : Collection where T.Element == Self
+}
+
+protocol V : C, RawRepresentable where RawValue == String {}
+
+protocol P {
+  associatedtype A: V
+}
+
+extension P {
+  func foo<U: Collection>(_ args: U) -> String where U.Element == A {
+    return args.reduce("", { $1.rawValue }) // Ok
+  }
+}

test/Generics/same_type_constraints.swift

@@ -351,11 +351,11 @@ func intercomponentSameComponents<T: P10>(_: T)
         T.B == T.A { } // expected-note{{previous same-type constraint 'T.B' == 'T.A' written here}}
 
 func intercomponentMoreThanSpanningTree<T: P10>(_: T)
-  where T.A == T.B,
+  where T.A == T.B, // expected-note {{previous same-type constraint 'T.A' == 'T.B' written here}}
         T.B == T.C,
-        T.D == T.E, // expected-note{{previous same-type constraint 'T.D' == 'T.E' written here}}
+        T.D == T.E, // expected-warning {{redundant same-type constraint 'T.D' == 'T.E'}}
         T.D == T.B,
-        T.E == T.B  // expected-warning{{redundant same-type constraint 'T.E' == 'T.B'}}
+        T.E == T.B
         { }
 
 func trivialRedundancy<T: P10>(_: T) where T.A == T.A { } // expected-warning{{redundant same-type constraint 'T.A' == 'T.A'}}

test/decl/protocol/req/associated_type_ambiguity.swift

@@ -15,7 +15,7 @@ protocol P1 {
 }
 
 protocol P2 {
-  associatedtype T // expected-note {{found this candidate}}
+  associatedtype T // expected-note 2 {{found this candidate}}
 }
 
 // FIXME: This extension's generic signature is still minimized differently from
@@ -36,7 +36,7 @@ extension P1 where Self : P2 {
 // Same as above, but now we have two visible associated types with the same
 // name.
 protocol P3 {
-  associatedtype T
+  associatedtype T // expected-note {{found this candidate}}
 }
 
 // FIXME: This extension's generic signature is still minimized differently from
@@ -48,7 +48,7 @@ extension P2 where Self : P3, T == Int {
 }
 
 extension P2 where Self : P3 {
-  func takeT1(_: T) {}
+  func takeT1(_: T) {} // expected-error {{'T' is ambiguous for type lookup in this context}}
   func takeT2(_: Self.T) {}
 }