[Associated type inference] De-duplicate solutions as early as possible.

Associated type inference can end up visiting a large number of potential
solution states, which it ends up having to deduplicate. Perform the
de-duplication step earlier, before we do extensive checking of the
solution itself, to eliminate a bunch of extra work.

Addresses the compile-time regression in rdar://problem/37165620.

(cherry picked from commit a57f306)

Author: DougGregor

lib/Sema/TypeCheckProtocolInference.cpp

@@ -25,11 +25,22 @@
 #include "swift/AST/Types.h"
 #include "swift/Basic/Defer.h"
 #include "swift/ClangImporter/ClangModule.h"
+#include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/TinyPtrVector.h"
 
 #define DEBUG_TYPE "Associated type inference"
 #include "llvm/Support/Debug.h"
 
+STATISTIC(NumSolutionStates, "# of solution states visited");
+STATISTIC(NumSolutionStatesFailedCheck,
+          "# of solution states that failed constraints check");
+STATISTIC(NumConstrainedExtensionChecks,
+          "# of constrained extension checks");
+STATISTIC(NumConstrainedExtensionChecksFailed,
+          "# of constrained extension checks failed");
+STATISTIC(NumDuplicateSolutionStates,
+          "# of duplicate solution states ");
+
 using namespace swift;
 
 void InferredAssociatedTypesByWitness::dump() const {
@@ -1042,26 +1053,6 @@ AssociatedTypeInference::getSubstOptionsWithCurrentTypeWitnesses() {
 bool AssociatedTypeInference::checkCurrentTypeWitnesses(
        const SmallVectorImpl<std::pair<ValueDecl *, ValueDecl *>>
          &valueWitnesses) {
-  // Fold the dependent member types within this type.
-  for (auto assocType : proto->getAssociatedTypeMembers()) {
-    if (conformance->hasTypeWitness(assocType))
-      continue;
-
-    // If the type binding does not have a type parameter, there's nothing
-    // to do.
-    auto known = typeWitnesses.begin(assocType);
-    assert(known != typeWitnesses.end());
-    if (!known->first->hasTypeParameter() &&
-        !known->first->hasDependentMember())
-      continue;
-
-    Type replaced = substCurrentTypeWitnesses(known->first);
-    if (replaced.isNull())
-      return true;
-
-    known->first = replaced;
-  }
-
   // If we don't have a requirement signature for this protocol, bail out.
   // FIXME: We should never get to this point. Or we should always fail.
   if (!proto->isRequirementSignatureComputed()) return false;
@@ -1090,6 +1081,7 @@ bool AssociatedTypeInference::checkCurrentTypeWitnesses(
   switch (result) {
   case RequirementCheckResult::Failure:
   case RequirementCheckResult::UnsatisfiedDependency:
+    ++NumSolutionStatesFailedCheck;
     return true;
 
   case RequirementCheckResult::Success:
@@ -1113,7 +1105,11 @@ bool AssociatedTypeInference::checkCurrentTypeWitnesses(
     if (!ext->isConstrainedExtension()) continue;
     if (!checkedExtensions.insert(ext).second) continue;
 
-    if (checkConstrainedExtension(ext)) return true;
+    ++NumConstrainedExtensionChecks;
+    if (checkConstrainedExtension(ext)) {
+      ++NumConstrainedExtensionChecksFailed;
+      return true;
+    }
   }
 
   return false;
@@ -1204,27 +1200,54 @@ void AssociatedTypeInference::findSolutionsRec(
       return;
     }
 
-    /// Check the current set of type witnesses.
-    bool invalid = checkCurrentTypeWitnesses(valueWitnesses);
+    ++NumSolutionStates;
+
+    // Fold the dependent member types within this type.
+    for (auto assocType : proto->getAssociatedTypeMembers()) {
+      if (conformance->hasTypeWitness(assocType))
+        continue;
 
-    // Determine whether there is already a solution with the same
-    // bindings.
-    for (const auto &solution : solutions) {
-      bool sameSolution = true;
+      // If the type binding does not have a type parameter, there's nothing
+      // to do.
+      auto known = typeWitnesses.begin(assocType);
+      assert(known != typeWitnesses.end());
+      if (!known->first->hasTypeParameter() &&
+          !known->first->hasDependentMember())
+        continue;
+
+      Type replaced = substCurrentTypeWitnesses(known->first);
+      if (replaced.isNull())
+        return;
+
+      known->first = replaced;
+    }
+
+    // Check whether our current solution matches the given solution.
+    auto matchesSolution =
+        [&](const InferredTypeWitnessesSolution &solution) {
       for (const auto &existingTypeWitness : solution.TypeWitnesses) {
         auto typeWitness = typeWitnesses.begin(existingTypeWitness.first);
-        if (!typeWitness->first->isEqual(existingTypeWitness.second.first)) {
-          sameSolution = false;
-          break;
-        }
+        if (!typeWitness->first->isEqual(existingTypeWitness.second.first))
+          return false;
       }
 
-      // We found the same solution. There is no point in recording
-      // a new one.
-      if (sameSolution)
-        return;
+      return true;
+    };
+
+    // If we've seen this solution already, bail out; there's no point in
+    // checking further.
+    if (std::find_if(solutions.begin(), solutions.end(), matchesSolution)
+          != solutions.end() ||
+        std::find_if(nonViableSolutions.begin(), nonViableSolutions.end(),
+                     matchesSolution)
+          != nonViableSolutions.end()) {
+      ++NumDuplicateSolutionStates;
+      return;
     }
 
+    /// Check the current set of type witnesses.
+    bool invalid = checkCurrentTypeWitnesses(valueWitnesses);
+
     auto &solutionList = invalid ? nonViableSolutions : solutions;
     solutionList.push_back(InferredTypeWitnessesSolution());
     auto &solution = solutionList.back();