Sema: Fold identical solutions at the end

Author: slavapestov

lib/Sema/AssociatedTypeInference.cpp

@@ -752,6 +752,16 @@ struct InferredTypeWitnessesSolution {
   LLVM_ATTRIBUTE_USED
 #endif
   void dump(llvm::raw_ostream &out) const;
+
+  bool operator==(const InferredTypeWitnessesSolution &other) const {
+    for (const auto &otherTypeWitness : other.TypeWitnesses) {
+      auto typeWitness = TypeWitnesses.find(otherTypeWitness.first);
+      if (!typeWitness->second.first->isEqual(otherTypeWitness.second.first))
+        return false;
+    }
+
+    return true;
+  }
 };
 
 void InferredTypeWitnessesSolution::dump(llvm::raw_ostream &out) const {
@@ -3059,17 +3069,7 @@ void AssociatedTypeInference::findSolutionsRec(
 
     // We fold away non-viable solutions that have the same type witnesses.
     if (invalid) {
-      auto matchesSolution = [&](const InferredTypeWitnessesSolution &other) {
-        for (const auto &otherTypeWitness : other.TypeWitnesses) {
-          auto typeWitness = solution.TypeWitnesses.find(otherTypeWitness.first);
-          if (!typeWitness->second.first->isEqual(otherTypeWitness.second.first))
-            return false;
-        }
-
-        return true;
-      };
-
-      if (llvm::any_of(nonViableSolutions, matchesSolution)) {
+      if (llvm::find(nonViableSolutions, solution) != nonViableSolutions.end()) {
         LLVM_DEBUG(llvm::dbgs() << std::string(valueWitnesses.size(), '+')
                    << "+ Duplicate invalid solution found\n";);
         ++NumDuplicateSolutionStates;
@@ -3871,7 +3871,13 @@ auto AssociatedTypeInference::solve()
     }
   }
 
-  // Happy case: we found exactly one viable solution.
+  // If we still have multiple solutions, they might have identical
+  // type witnesses.
+  while (solutions.size() > 1 && solutions.front() == solutions.back()) {
+    solutions.pop_back();
+  }
+
+  // Happy case: we found exactly one unique viable solution.
   if (solutions.size() == 1) {
     // Form the resulting solution.
     auto &typeWitnesses = solutions.front().TypeWitnesses;

test/decl/protocol/req/identical_solutions.swift

@@ -0,0 +1,31 @@
+// RUN: %target-typecheck-verify-swift
+
+public protocol Q1 {}
+public protocol Q2 {}
+
+protocol P1 {
+    associatedtype A
+    func f<T: Q1>(_: T) -> A
+}
+
+protocol P2 {
+    associatedtype A
+    func f<T: Q2>(_: T) -> A
+}
+
+struct S1 {}
+struct S2 {}
+
+// Associated type inference isn't smart enough to reason about the
+// requirement on `T`, so it considers both overloads of f() as viable
+// witnesses. However, they infer the same binding 'A := S2', so
+// it's fine.
+
+extension S1: P1 {
+    public func f<T: Q1>(_: T) -> S2 {}
+}
+
+extension S1: P2 {
+    public func f<T: Q2>(_: T) -> S2 {}
+}
+