[GenericSig Builder] Track and canonicalize same-type-to-concrete constraints.

Track each same-type-to-concrete constraint on the potential archetype
against which it was written, and ensure that the requirement sources
for such same-type constraints stay with the potential archetypes on
which they were described. This is similar to the way we track
same-type constraints among potential archetypes.

Use this information to canonicalize same-type-to-concrete constraints
appropriately. For each connected component within an equivalence
class of potential archetypes, select the best requirement source to
the concrete type, or substitute in an abstract requirement source if
none exists. This approach ensures that components that would be
equivalent to that concrete type anyway get a derived source, while
components that get the concrete-type equivalence by being tied to
another

To get here, we also needed to change the notion of the archetype
anchor so that potential archetypes with no same-type constraints
directly in their path are preferred over potential archetypes that do
have a same-type constraint in their path. Otherwise, the anchor might
be something that is always concrete and is, therefore, not terribly
interesting.

Fixes the new case that popped up in rdar://problem/30478915.

Author: DougGregor

include/swift/AST/GenericSignatureBuilder.h

@@ -296,6 +296,11 @@ class RequirementSource : public llvm::FoldingSetNode {
   /// path.
   bool isDerivedRequirement() const;
 
+  /// Whether the requirement is derived via some concrete conformance, e.g.,
+  /// a concrete type's conformance to a protocol or a superclass's conformance
+  /// to a protocol.
+  bool isDerivedViaConcreteConformance() const;
+
   /// Retrieve a source location that corresponds to the requirement.
   SourceLoc getLoc() const;
 
@@ -712,7 +717,8 @@ class GenericSignatureBuilder::PotentialArchetype {
   /// constrained.
   Type ConcreteType;
 
-  /// The source of the concrete type requirement.
+  /// The source of the concrete type requirement, if one was written
+  /// on this potential archetype.
   const RequirementSource *ConcreteTypeSource = nullptr;
 
   /// Whether this is an unresolved nested type.
@@ -936,15 +942,16 @@ class GenericSignatureBuilder::PotentialArchetype {
                             SameTypeConstraints.end());
   }
 
-  /// Retrieve the source of the same-type constraint that maps this potential
-  /// archetype to a concrete type.
-  const RequirementSource *getConcreteTypeSource() const {
-    if (Representative != this)
-      return Representative->getConcreteTypeSource();
-
+  /// Retrieve the concrete type source as written on this potential archetype.
+  const RequirementSource *getConcreteTypeSourceAsWritten() const {
     return ConcreteTypeSource;
   }
 
+  /// Find a source of the same-type constraint that maps this potential
+  /// archetype to a concrete type somewhere in the equivalence class of this
+  /// type.
+  const RequirementSource *findAnyConcreteTypeSourceAsWritten() const;
+
   /// \brief Retrieve (or create) a nested type with the given name.
   PotentialArchetype *getNestedType(Identifier Name,
                                     GenericSignatureBuilder &builder);