[Archetype builder] Mark same-type constraints on nested types as redundant.

When a same-type constraint equates a potential archetype with a
same-type constraint, it implies equality of the nested types with the
appropriate witnesses. However, these were getting marked as
"explicit" when they should be "redundant".

Fixes rdar://problem/29295062.

Author: DougGregor

lib/AST/ArchetypeBuilder.cpp

@@ -1275,6 +1275,7 @@ bool ArchetypeBuilder::addSameTypeRequirementToConcrete(
   T->SameTypeSource = Source;
 
   // Recursively resolve the associated types to their concrete types.
+  RequirementSource nestedSource(RequirementSource::Redundant, Source.getLoc());
   for (auto nested : T->getNestedTypes()) {
     AssociatedTypeDecl *assocType
       = nested.second.front()->getResolvedAssociatedType();
@@ -1283,7 +1284,7 @@ bool ArchetypeBuilder::addSameTypeRequirementToConcrete(
           concreteArchetype->getNestedType(nested.first);
       addSameTypeRequirementToConcrete(nested.second.front(),
                                        witnessType.getValue(),
-                                       Source);
+                                       nestedSource);
     } else {
       assert(conformances.count(assocType->getProtocol()) > 0
              && "missing conformance?");
@@ -1293,11 +1294,11 @@ bool ArchetypeBuilder::addSameTypeRequirementToConcrete(
       if (auto witnessPA = resolveArchetype(witnessType)) {
         addSameTypeRequirementBetweenArchetypes(nested.second.front(),
                                                 witnessPA,
-                                                Source);
+                                                nestedSource);
       } else {
         addSameTypeRequirementToConcrete(nested.second.front(),
                                          witnessType,
-                                         Source);
+                                         nestedSource);
       }
     }
   }

test/Generics/requirement_inference.swift

@@ -136,6 +136,20 @@ func inferSameType2<T : P3, U : P4>(_: T) where U.P4Assoc : P2, T.P3Assoc == U.P
 // CHECK-NEXT: Generic signature
 func inferSameType3<T : PCommonAssoc1>(_: T) where T.CommonAssoc : P1, T : PCommonAssoc2 {}
 
+struct X6 : PAssoc {
+  typealias Assoc = X6
+}
+
+// CHECK-LABEL: .inferSameType4@
+// CHECK-NEXT: Requirements:
+// CHECK-NEXT:   T : PAssoc [explicit @
+// CHECK-NEXT:   T[.PAssoc].Assoc == X6 [explicit
+// CHECK-NEXT:   T[.PAssoc].Assoc[.PAssoc].Assoc == X6.Assoc [redundant
+// CHECK-NEXT:   T[.PAssoc].Assoc[.PAssoc].Assoc[.PAssoc].Assoc == X6.Assoc [redundant
+// CHECK-NEXT: Generic signature: <T where T : PAssoc, T.Assoc == X6>
+// CHECK-NEXT: Canonical generic signature: <τ_0_0 where τ_0_0 : PAssoc, τ_0_0.Assoc == X6>
+func inferSameType4<T : PAssoc>(_: T) where T.Assoc : PAssoc, T.Assoc.Assoc : PAssoc, T.Assoc == X6  {}
+
 protocol P5 {
   associatedtype Element
 }