[CSBindings] Determine literal coverage during binding set finalization

Author: xedin

include/swift/Sema/CSBindings.h

@@ -206,11 +206,6 @@ struct LiteralRequirement {
                                     bool canBeNil,
                                     DeclContext *useDC) const;
 
-  void resetCoverage() {
-    assert(isCovered() && "literal requirement is uncovered");
-    CoveredBy = nullptr;
-  }
-
   /// Determines whether literal protocol associated with this
   /// meta-information is viable for inclusion as a defaultable binding.
   bool viableAsBinding() const { return !isCovered() && hasDefaultType(); }
@@ -326,12 +321,12 @@ class BindingSet {
 
   BindingSet(const PotentialBindings &info)
       : CS(info.CS), TypeVar(info.TypeVar), Info(info) {
-    for (auto *literal : info.Literals)
-      addLiteralRequirement(literal);
-
     for (const auto &binding : info.Bindings)
       addBinding(binding);
 
+    for (auto *literal : info.Literals)
+      addLiteralRequirement(literal);
+
     for (auto *constraint : info.Defaults)
       addDefault(constraint);
 
@@ -512,7 +507,6 @@ class BindingSet {
 
   /// Finalize binding computation for this type variable by
   /// inferring bindings from context e.g. transitive bindings.
-
   void finalize(
       llvm::SmallDenseMap<TypeVariableType *, BindingSet> &inferredBindings);
 
@@ -574,6 +568,10 @@ class BindingSet {
     auto defaultTy = constraint->getSecondType();
     Defaults.insert({defaultTy->getCanonicalType(), constraint});
   }
+
+  /// Check whether the given binding set covers any of the
+  /// literal protocols associated with this type variable.
+  void determineLiteralCoverage();
 };
 
 } // end namespace inference

lib/Sema/CSBindings.cpp

@@ -436,6 +436,8 @@ void BindingSet::finalize(
   inferTransitiveProtocolRequirements(inferredBindings);
   inferTransitiveBindings(inferredBindings);
 
+  determineLiteralCoverage();
+
   if (auto *locator = TypeVar->getImpl().getLocator()) {
     if (locator->isLastElement<LocatorPathElt::MemberRefBase>()) {
       // If this is a base of an unresolved member chain, as a last
@@ -546,43 +548,67 @@ void BindingSet::addBinding(PotentialBinding binding) {
       return;
   }
 
-  // Check whether the given binding covers any of the literal protocols
-  // associated with this type variable.
-  {
-    bool allowsNil = canBeNil();
+  for (auto *adjacentVar : referencedTypeVars)
+    AdjacentVars.insert(adjacentVar);
 
-    for (auto &literal : Literals) {
-      auto *protocol = literal.first;
+  (void)Bindings.insert(std::move(binding));
+}
 
-      // Skip conformance to `nil` protocol since it doesn't
-      // have a default type and can't affect binding set.
-      if (protocol->isSpecificProtocol(
-              KnownProtocolKind::ExpressibleByNilLiteral))
-        continue;
+void BindingSet::determineLiteralCoverage() {
+  if (Literals.empty())
+    return;
 
-      auto &info = literal.second;
+  SmallVector<PotentialBinding, 4> adjustedBindings;
 
-      if (!info.viableAsBinding())
-        continue;
+  bool allowsNil = canBeNil();
 
-      bool isCovered = false;
-      Type adjustedTy;
+  for (auto binding = Bindings.begin(); binding != Bindings.end();) {
+    bool isCovered = false;
+    Type adjustedTy;
 
-      std::tie(isCovered, adjustedTy) =
-          isLiteralCoveredBy(info, binding, allowsNil);
+    // Tracks the number of covered literal requirements,
+    // so checking could be stopped as soon as all of the
+    // requirements are satisfied.
+    unsigned numCoveredRequirements = 0;
+    for (auto &literalRequirement : Literals) {
+      auto &literalInfo = literalRequirement.second;
 
-      if (!isCovered)
+      if (!literalInfo.viableAsBinding()) {
+        ++numCoveredRequirements;
         continue;
+      }
+
+      std::tie(isCovered, adjustedTy) =
+          literalInfo.isCoveredBy(*binding, CS.DC, allowsNil);
 
-      binding = binding.withType(adjustedTy);
-      info.setCoveredBy(binding.getSource());
+      if (isCovered) {
+        literalInfo.setCoveredBy(binding->getSource());
+        ++numCoveredRequirements;
+        break;
+      }
     }
-  }
 
-  for (auto *adjacentVar : referencedTypeVars)
-    AdjacentVars.insert(adjacentVar);
+    // If the type has been adjusted, we need to re-insert
+    // the binding but skip all of the previous checks.
+    //
+    // It's okay to do this here since iteration stops after
+    // first covering binding has been found.
+    if (isCovered && adjustedTy) {
+      binding = Bindings.erase(binding);
+      adjustedBindings.push_back(binding->withType(adjustedTy));
+      continue;
+    }
 
-  (void)Bindings.insert(std::move(binding));
+    // If all of the literal requirements are now covered
+    // by existing bindings, there is nothing left to do.
+    if (numCoveredRequirements == Literals.size())
+      break;
+
+    ++binding;
+  }
+
+  for (auto &newBinding : adjustedBindings)
+    (void)Bindings.insert(std::move(newBinding));
 }
 
 void BindingSet::addLiteralRequirement(Constraint *constraint) {
@@ -637,36 +663,6 @@ void BindingSet::addLiteralRequirement(Constraint *constraint) {
   LiteralRequirement literal(
       constraint, TypeChecker::getDefaultType(protocol, CS.DC), isDirect);
 
-  if (literal.viableAsBinding()) {
-    bool allowsNil = canBeNil();
-
-    for (auto binding = Bindings.begin(); binding != Bindings.end();
-         ++binding) {
-      bool isCovered = false;
-      Type adjustedTy;
-
-      std::tie(isCovered, adjustedTy) =
-          isLiteralCoveredBy(literal, *binding, allowsNil);
-
-      // No luck here, let's try next literal requirement.
-      if (!isCovered)
-        continue;
-
-      // If the type has been adjusted, we need to re-insert
-      // the binding but skip all of the previous checks.
-      //
-      // It's okay to do this here since iteration stops after
-      // first covering binding has been found.
-      if (adjustedTy) {
-        Bindings.erase(binding);
-        Bindings.insert(binding->withType(adjustedTy));
-      }
-
-      literal.setCoveredBy(binding->getSource());
-      break;
-    }
-  }
-
   Literals.insert({protocol, std::move(literal)});
 }