[ConstraintSystem] NFC: Extract requiresOptionalAdjustment so it could be used for default bindings

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -5852,6 +5852,10 @@ class TypeVarBindingProducer : public BindingProducer<TypeVariableBinding> {
   /// \returns true if some new bindings were sucessfully computed,
   /// false otherwise.
   bool computeNext();
+
+  /// Check whether binding type is required to either conform to
+  /// `ExpressibleByNilLiteral` protocol or be wrapped into an optional type.
+  bool requiresOptionalAdjustment(const Binding &binding) const;
 };
 
 /// Iterator over disjunction choices, makes it

lib/Sema/ConstraintSystem.cpp

@@ -5340,47 +5340,18 @@ TypeVarBindingProducer::TypeVarBindingProducer(
         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;
-      };
-
   // A binding to `Any` which should always be considered as a last resort.
   Optional<Binding> Any;
 
   for (const auto &binding : bindings.Bindings) {
     auto type = binding.BindingType;
 
-    if (!CanBeNil && type->isAny()) {
-      Any.emplace(binding);
-      continue;
-    }
-
     // Adjust optionality of existing bindings based on presence of
     // `ExpressibleByNilLiteral` requirement.
-    if (CanBeNil && requiresOptionalAdjustment(binding)) {
+    if (requiresOptionalAdjustment(binding)) {
       Bindings.push_back(binding.withType(OptionalType::get(type)));
+    } else if (type->isAny()) {
+      Any.emplace(binding);
     } else {
       Bindings.push_back(binding);
     }
@@ -5393,3 +5364,33 @@ TypeVarBindingProducer::TypeVarBindingProducer(
     Bindings.push_back(*Any);
   }
 }
+
+bool TypeVarBindingProducer::requiresOptionalAdjustment(
+    const Binding &binding) const {
+  // If type variable can't be `nil` then adjustment is
+  // not required.
+  if (!CanBeNil)
+    return false;
+
+  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;
+}