[ConstraintSystem] Handle binding nullability in producer instead of collector

Wrapping bindings into optional type based on presence of
an `ExpressibleByNilLiteral` conformance requirement should
be done after type variable has been selected for attempting.
Otherwise such upfront work would be wasteful since it doesn't
affect binding ranking in any way.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -5817,14 +5817,17 @@ class TypeVarBindingProducer : public BindingProducer<TypeVariableBinding> {
   llvm::SmallPtrSet<CanType, 4> ExploredTypes;
   llvm::SmallPtrSet<TypeBase *, 4> BoundTypes;
 
+  /// Determines whether this type variable has a
+  /// `ExpressibleByNilLiteral` requirement which
+  /// means that bindings have to either conform
+  /// to that protocol or be wrapped in an optional.
+  bool CanBeNil;
+
 public:
   using Element = TypeVariableBinding;
 
   TypeVarBindingProducer(ConstraintSystem &cs,
-                         ConstraintSystem::PotentialBindings &bindings)
-      : BindingProducer(cs, bindings.TypeVar->getImpl().getLocator()),
-        TypeVar(bindings.TypeVar),
-        Bindings(bindings.Bindings.begin(), bindings.Bindings.end()) {}
+                         ConstraintSystem::PotentialBindings &bindings);
 
   /// Retrieve a set of bindings available in the current state.
   ArrayRef<Binding> getCurrentBindings() const { return Bindings; }

lib/Sema/CSBindings.cpp

@@ -547,41 +547,6 @@ void ConstraintSystem::PotentialBindings::finalize(
   inferTransitiveBindings(cs, existingTypes, inferredBindings);
   inferDefaultTypes(cs, existingTypes);
 
-  // Adjust optionality of existing bindings based on presence of
-  // `ExpressibleByNilLiteral` requirement.
-  if (llvm::any_of(Protocols, [](Constraint *constraint) {
-        auto *protocol = constraint->getProtocol();
-        return protocol->isSpecificProtocol(
-            KnownProtocolKind::ExpressibleByNilLiteral);
-      })) {
-    for (auto &binding : Bindings) {
-      bool wrapInOptional = false;
-      if (binding.Kind == AllowedBindingKind::Supertypes) {
-        auto type = binding.BindingType->getRValueType();
-        // If the type doesn't conform to ExpressibleByNilLiteral,
-        // produce an optional of that type as a potential binding. We
-        // overwrite the binding in place because the non-optional type
-        // will fail to type-check against the nil-literal conformance.
-        bool conformsToExprByNilLiteral = false;
-        if (auto *nominalBindingDecl = type->getAnyNominal()) {
-          SmallVector<ProtocolConformance *, 2> conformances;
-          conformsToExprByNilLiteral = nominalBindingDecl->lookupConformance(
-              cs.DC->getParentModule(),
-              cs.getASTContext().getProtocol(
-                  KnownProtocolKind::ExpressibleByNilLiteral),
-              conformances);
-        }
-        wrapInOptional = !conformsToExprByNilLiteral;
-      } else if (binding.isDefaultableBinding() &&
-                 binding.BindingType->isAny()) {
-        wrapInOptional = true;
-      }
-
-      if (wrapInOptional)
-        binding.BindingType = OptionalType::get(binding.BindingType);
-    }
-  }
-
   // If there are no bindings, typeVar may be a hole.
   if (cs.shouldAttemptFixes() && Bindings.empty() &&
       TypeVar->getImpl().canBindToHole()) {

lib/Sema/ConstraintSystem.cpp

@@ -5330,3 +5330,50 @@ bool ConstraintSystem::isReadOnlyKeyPathComponent(
 
   return false;
 }
+
+TypeVarBindingProducer::TypeVarBindingProducer(
+    ConstraintSystem &cs, ConstraintSystem::PotentialBindings &bindings)
+    : BindingProducer(cs, bindings.TypeVar->getImpl().getLocator()),
+      TypeVar(bindings.TypeVar),
+      CanBeNil(llvm::any_of(bindings.Protocols, [](Constraint *constraint) {
+        auto *protocol = constraint->getProtocol();
+        return protocol->isSpecificProtocol(
+            KnownProtocolKind::ExpressibleByNilLiteral);
+      })) {
+  auto requiresOptionalAdjustment =
+      [&cs](const ConstraintSystem::PotentialBinding &binding) {
+        if (binding.Kind == BindingKind::Supertypes) {
+          auto type = binding.BindingType->getRValueType();
+          // If the type doesn't conform to ExpressibleByNilLiteral,
+          // produce an optional of that type as a potential binding. We
+          // overwrite the binding in place because the non-optional type
+          // will fail to type-check against the nil-literal conformance.
+          bool conformsToExprByNilLiteral = false;
+          if (auto *nominalBindingDecl = type->getAnyNominal()) {
+            SmallVector<ProtocolConformance *, 2> conformances;
+            conformsToExprByNilLiteral = nominalBindingDecl->lookupConformance(
+                cs.DC->getParentModule(),
+                cs.getASTContext().getProtocol(
+                    KnownProtocolKind::ExpressibleByNilLiteral),
+                conformances);
+          }
+          return !conformsToExprByNilLiteral;
+        } else if (binding.isDefaultableBinding() &&
+                   binding.BindingType->isAny()) {
+          return true;
+        }
+
+        return false;
+      };
+
+  for (const auto &binding : bindings.Bindings) {
+    // Adjust optionality of existing bindings based on presence of
+    // `ExpressibleByNilLiteral` requirement.
+    if (CanBeNil && requiresOptionalAdjustment(binding)) {
+      Bindings.push_back(
+          binding.withType(OptionalType::get(binding.BindingType)));
+    } else {
+      Bindings.push_back(binding);
+    }
+  }
+}