[CSBindings] Implement transtive protocol requirement inference

Implements iterative protocol requirement inference through
subtype, conversion and equivalence relationships.

This algorithm doesn't depend on a type variable finalization
order (which is currently the order of type variable introduction).

If a given type variable doesn't yet have its transitive protocol
requirements inferred, algorithm would use iterative depth-first
walk through its supertypes and equivalences and incrementally
infer transitive protocols for each type variable involved,
transferring new information down the chain e.g.

  T1   T3
   \   /
    T4    T5
     \    /
       T2

Here `T1`, `T3` are supertypes of `T4`, `T4` and `T5`
are supertypes of `T2`.

Let's assume that algorithm starts at `T2` and none of the involved
type variables have their protocol requirements inferred yet.

First, it would consider supertypes of `T2` which are `T4` and `T5`,
since `T5` is the last in the chain algorithm would transfer its
direct protocol requirements to `T2`. `T4` has supertypes `T1` and
`T3` - they transfer their direct protocol requirements to `T4`
and `T4` transfers its direct and transitive (from `T1` and `T3`)
protocol requirements to `T2`. At this point all the type variables
in subtype chain have their transitive protocol requirements resolved
and cached so they don't have to be re-inferred later.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -4708,6 +4708,10 @@ class ConstraintSystem {
     /// The set of protocol requirements placed on this type variable.
     llvm::SmallVector<Constraint *, 4> Protocols;
 
+    /// The set of transitive protocol requirements inferred through
+    /// subtype/conversion/equivalence relations with other type variables.
+    Optional<llvm::SmallPtrSet<Constraint *, 4>> TransitiveProtocols;
+
     /// The set of constraints which would be used to infer default types.
     llvm::TinyPtrVector<Constraint *> Defaults;
 
@@ -4873,6 +4877,15 @@ class ConstraintSystem {
                                   ConstraintSystem::PotentialBindings>
             &inferredBindings);
 
+    /// Detect subtype, conversion or equivalence relationship
+    /// between two type variables and attempt to propagate protocol
+    /// requirements down the subtype or equivalence chain.
+    void inferTransitiveProtocolRequirements(
+        const ConstraintSystem &cs,
+        llvm::SmallDenseMap<TypeVariableType *,
+                            ConstraintSystem::PotentialBindings>
+            &inferredBindings);
+
     /// Infer bindings based on any protocol conformances that have default
     /// types.
     void inferDefaultTypes(ConstraintSystem &cs,
@@ -4886,8 +4899,8 @@ class ConstraintSystem {
     /// Finalize binding computation for this type variable by
     /// inferring bindings from context e.g. transitive bindings.
     void finalize(ConstraintSystem &cs,
-                  const llvm::SmallDenseMap<TypeVariableType *,
-                                            ConstraintSystem::PotentialBindings>
+                  llvm::SmallDenseMap<TypeVariableType *,
+                                      ConstraintSystem::PotentialBindings>
                       &inferredBindings);
 
     void dump(llvm::raw_ostream &out,

lib/Sema/CSBindings.cpp

@@ -22,6 +22,90 @@
 using namespace swift;
 using namespace constraints;
 
+void ConstraintSystem::PotentialBindings::inferTransitiveProtocolRequirements(
+    const ConstraintSystem &cs,
+    llvm::SmallDenseMap<TypeVariableType *, ConstraintSystem::PotentialBindings>
+        &inferredBindings) {
+  if (TransitiveProtocols)
+    return;
+
+  llvm::SmallVector<std::pair<TypeVariableType *, TypeVariableType *>, 4>
+      workList;
+  llvm::SmallPtrSet<TypeVariableType *, 4> visitedRelations;
+
+  llvm::SmallDenseMap<TypeVariableType *, SmallPtrSet<Constraint *, 4>, 4>
+      protocols;
+
+  auto addToWorkList = [&](TypeVariableType *parent,
+                           TypeVariableType *typeVar) {
+    if (visitedRelations.insert(typeVar).second)
+      workList.push_back({parent, typeVar});
+  };
+
+  auto propagateProtocolsTo =
+      [&protocols](TypeVariableType *dstVar,
+                   const SmallVectorImpl<Constraint *> &direct,
+                   const SmallPtrSetImpl<Constraint *> &transitive) {
+        auto &destination = protocols[dstVar];
+
+        for (auto *protocol : direct)
+          destination.insert(protocol);
+
+        for (auto *protocol : transitive)
+          destination.insert(protocol);
+      };
+
+  addToWorkList(nullptr, TypeVar);
+
+  do {
+    auto *currentVar = workList.back().second;
+
+    auto cachedBindings = inferredBindings.find(currentVar);
+    if (cachedBindings == inferredBindings.end()) {
+      workList.pop_back();
+      continue;
+    }
+
+    auto &bindings = cachedBindings->getSecond();
+
+    // If current variable already has transitive protocol
+    // conformances inferred, there is no need to look deeper
+    // into subtype/equivalence chain.
+    if (bindings.TransitiveProtocols) {
+      TypeVariableType *parent = nullptr;
+      std::tie(parent, currentVar) = workList.pop_back_val();
+      assert(parent);
+      propagateProtocolsTo(parent, bindings.Protocols,
+                           *bindings.TransitiveProtocols);
+      continue;
+    }
+
+    for (const auto &entry : bindings.SubtypeOf)
+      addToWorkList(currentVar, entry.first);
+
+    for (const auto &entry : bindings.EquivalentTo)
+      addToWorkList(currentVar, entry.first);
+
+    // More subtype/equivalences relations have been added.
+    if (workList.back().second != currentVar)
+      continue;
+
+    TypeVariableType *parent = nullptr;
+    std::tie(parent, currentVar) = workList.pop_back_val();
+
+    // At all of the protocols associated with current type variable
+    // are transitive to its parent, propogate them down the subtype/equivalence
+    // chain.
+    if (parent) {
+      propagateProtocolsTo(parent, bindings.Protocols, protocols[currentVar]);
+    }
+
+    // Update the bindings associated with current type variable,
+    // to avoid repeating this inference process.
+    bindings.TransitiveProtocols.emplace(std::move(protocols[currentVar]));
+  } while (!workList.empty());
+}
+
 void ConstraintSystem::PotentialBindings::inferTransitiveBindings(
     ConstraintSystem &cs, llvm::SmallPtrSetImpl<CanType> &existingTypes,
     const llvm::SmallDenseMap<TypeVariableType *,
@@ -281,17 +365,16 @@ void ConstraintSystem::PotentialBindings::inferDefaultTypes(
 
 void ConstraintSystem::PotentialBindings::finalize(
     ConstraintSystem &cs,
-    const llvm::SmallDenseMap<TypeVariableType *,
-                              ConstraintSystem::PotentialBindings>
+    llvm::SmallDenseMap<TypeVariableType *, ConstraintSystem::PotentialBindings>
         &inferredBindings) {
   // We need to make sure that there are no duplicate bindings in the
   // set, otherwise solver would produce multiple identical solutions.
   llvm::SmallPtrSet<CanType, 4> existingTypes;
   for (const auto &binding : Bindings)
     existingTypes.insert(binding.BindingType->getCanonicalType());
 
+  inferTransitiveProtocolRequirements(cs, inferredBindings);
   inferTransitiveBindings(cs, existingTypes, inferredBindings);
-
   inferDefaultTypes(cs, existingTypes);
 
   // Adjust optionality of existing bindings based on presence of