[CSBindings] Record constraint associated with a subtype relationship

While inferring bindings, let's record not only the fact that current
type variable is a subtype of some other type variable but track
constraint which establishes this relationship.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -4749,7 +4749,7 @@ class ConstraintSystem {
     /// chain of subtypes because binding inference algorithm can't,
     /// at the moment, determine bindings transitively through supertype
     /// type variables.
-    llvm::SmallPtrSet<TypeVariableType *, 4> SubtypeOf;
+    llvm::SmallDenseMap<TypeVariableType *, Constraint *, 4> SubtypeOf;
 
     PotentialBindings(TypeVariableType *typeVar)
         : TypeVar(typeVar), PotentiallyIncomplete(isGenericParameter()) {}
@@ -4794,10 +4794,10 @@ class ConstraintSystem {
       // This is required because algorithm can't currently infer
       // bindings for subtype transitively through superclass ones.
       if (!(x.IsHole && y.IsHole)) {
-        if (x.SubtypeOf.count(y.TypeVar))
+        if (x.isSubtypeOf(y.TypeVar))
           return false;
 
-        if (y.SubtypeOf.count(x.TypeVar))
+        if (y.isSubtypeOf(x.TypeVar))
           return true;
       }
 
@@ -4843,6 +4843,15 @@ class ConstraintSystem {
       return false;
     }
 
+    bool isSubtypeOf(TypeVariableType *typeVar) const {
+      auto result = SubtypeOf.find(typeVar);
+      if (result == SubtypeOf.end())
+        return false;
+
+      auto *constraint = result->second;
+      return constraint->getKind() == ConstraintKind::Subtype;
+    }
+
     /// Check if this binding is favored over a disjunction e.g.
     /// if it has only concrete types or would resolve a closure.
     bool favoredOverDisjunction(Constraint *disjunction) const;

lib/Sema/CSBindings.cpp

@@ -790,9 +790,28 @@ ConstraintSystem::getPotentialBindingForRelationalConstraint(
       }
     }
 
-    if (constraint->getKind() == ConstraintKind::Subtype &&
-        kind == AllowedBindingKind::Subtypes) {
-      result.SubtypeOf.insert(bindingTypeVar);
+    switch (constraint->getKind()) {
+    case ConstraintKind::Subtype:
+    case ConstraintKind::Conversion:
+    case ConstraintKind::ArgumentConversion:
+    case ConstraintKind::OperatorArgumentConversion: {
+      if (kind == AllowedBindingKind::Subtypes) {
+        result.SubtypeOf.insert({bindingTypeVar, constraint});
+      } else {
+        // TODO: record this type variable as a `supertypeOf`
+      }
+      break;
+    }
+
+    case ConstraintKind::Bind:
+    case ConstraintKind::BindParam:
+    case ConstraintKind::Equal: {
+      // TODO: record this type variable as being equal to other type variable.
+      break;
+    }
+
+    default:
+      break;
     }
 
     return None;