[CSBindings] Shrink binding "sources" to supertype and equivalence only

Instead of recording all of the binding "sources" let's only record
subtype, supertype and equivalence relationships which didn't materialize
as bindings (because other side is a type variable).

This is the only information necessary to infer transitive bindings
and protocol requirements.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -4741,15 +4741,13 @@ class ConstraintSystem {
     /// Tracks the position of the last known supertype in the group.
     Optional<unsigned> lastSupertypeIndex;
 
-    /// A set of all constraints which contribute to pontential bindings.
-    llvm::SmallPtrSet<Constraint *, 8> Sources;
-
     /// A set of all not-yet-resolved type variables this type variable
-    /// is a subtype of. This is used to determine ordering inside a
-    /// chain of subtypes because binding inference algorithm can't,
-    /// at the moment, determine bindings transitively through supertype
-    /// type variables.
-    llvm::SmallDenseMap<TypeVariableType *, Constraint *, 4> SubtypeOf;
+    /// is a subtype of, supertype of or is equivalent to. This is used
+    /// to determine ordering inside of a chain of subtypes to help infer
+    /// transitive bindings  and protocol requirements.
+    llvm::SmallMapVector<TypeVariableType *, Constraint *, 4> SubtypeOf;
+    llvm::SmallMapVector<TypeVariableType *, Constraint *, 4> SupertypeOf;
+    llvm::SmallMapVector<TypeVariableType *, Constraint *, 4> EquivalentTo;
 
     PotentialBindings(TypeVariableType *typeVar)
         : TypeVar(typeVar), PotentiallyIncomplete(isGenericParameter()) {}

lib/Sema/CSBindings.cpp

@@ -29,29 +29,8 @@ void ConstraintSystem::PotentialBindings::inferTransitiveBindings(
         &inferredBindings) {
   using BindingKind = ConstraintSystem::AllowedBindingKind;
 
-  llvm::SmallVector<Constraint *, 4> conversions;
-  // First, let's collect all of the conversions associated
-  // with this type variable.
-  llvm::copy_if(
-      Sources, std::back_inserter(conversions),
-      [&](const Constraint *constraint) -> bool {
-        if (constraint->getKind() != ConstraintKind::Subtype &&
-            constraint->getKind() != ConstraintKind::Conversion &&
-            constraint->getKind() != ConstraintKind::ArgumentConversion &&
-            constraint->getKind() != ConstraintKind::OperatorArgumentConversion)
-          return false;
-
-        auto rhs = cs.simplifyType(constraint->getSecondType());
-        return rhs->getAs<TypeVariableType>() == TypeVar;
-      });
-
-  for (auto *constraint : conversions) {
-    auto *tv =
-        cs.simplifyType(constraint->getFirstType())->getAs<TypeVariableType>();
-    if (!tv || tv == TypeVar)
-      continue;
-
-    auto relatedBindings = inferredBindings.find(tv);
+  for (const auto &entry : SupertypeOf) {
+    auto relatedBindings = inferredBindings.find(entry.first);
     if (relatedBindings == inferredBindings.end())
       continue;
 
@@ -89,7 +68,7 @@ void ConstraintSystem::PotentialBindings::inferTransitiveBindings(
     llvm::copy(bindings.Defaults, std::back_inserter(Defaults));
 
     // TODO: We shouldn't need this in the future.
-    if (constraint->getKind() != ConstraintKind::Subtype)
+    if (entry.second->getKind() != ConstraintKind::Subtype)
       continue;
 
     for (auto &binding : bindings.Bindings) {
@@ -670,10 +649,6 @@ ConstraintSystem::getPotentialBindingForRelationalConstraint(
 
   auto *typeVar = result.TypeVar;
 
-  // Record constraint which contributes to the
-  // finding of potential bindings.
-  result.Sources.insert(constraint);
-
   auto first = simplifyType(constraint->getFirstType());
   auto second = simplifyType(constraint->getSecondType());
 
@@ -798,15 +773,16 @@ ConstraintSystem::getPotentialBindingForRelationalConstraint(
       if (kind == AllowedBindingKind::Subtypes) {
         result.SubtypeOf.insert({bindingTypeVar, constraint});
       } else {
-        // TODO: record this type variable as a `supertypeOf`
+        assert(kind == AllowedBindingKind::Supertypes);
+        result.SupertypeOf.insert({bindingTypeVar, constraint});
       }
       break;
     }
 
     case ConstraintKind::Bind:
     case ConstraintKind::BindParam:
     case ConstraintKind::Equal: {
-      // TODO: record this type variable as being equal to other type variable.
+      result.EquivalentTo.insert({bindingTypeVar, constraint});
       break;
     }