[CSBindings] Attempt Void fallback for closure result only when other choices have failed

Since there is a conversion from `() -> T` to `() -> Void` for closures,
solver has to attempt a `Void` when other bindings (inferred from the body)
have failed.

Let's try it post factum instead of adding `Void` fallback to the
binding set after every discovered supertype binding. Old scheme
wouldn't work in incremental mode anyway because it's possible to
find a subtype binding (which makes it clear that body has to have
a result type) after a supertype and end up attempting `Void` although
it would be incorrect.

Author: xedin

lib/Sema/CSBindings.cpp

@@ -1106,18 +1106,6 @@ void PotentialBindings::infer(Constraint *constraint) {
           (void)addPotentialBinding(binding->withType(LValueType::get(type)));
           DelayedBy.push_back(constraint);
         }
-
-        // If this is a type variable representing closure result,
-        // which is on the right-side of some relational constraint
-        // let's have it try `Void` as well because there is an
-        // implicit conversion `() -> T` to `() -> Void` and this
-        // helps to avoid creating a thunk to support it.
-        auto voidType = CS.getASTContext().TheEmptyTupleType;
-        if (locator->isLastElement<LocatorPathElt::ClosureResult>() &&
-            binding->Kind == AllowedBindingKind::Supertypes) {
-          (void)addPotentialBinding({voidType, binding->Kind, constraint},
-                                    /*allowJoinMeet=*/false);
-        }
       }
     }
     break;
@@ -1476,6 +1464,17 @@ bool TypeVarBindingProducer::computeNext() {
     }
 
     if (binding.Kind == BindingKind::Supertypes) {
+      // If this is a type variable representing closure result,
+      // which is on the right-side of some relational constraint
+      // let's have it try `Void` as well because there is an
+      // implicit conversion `() -> T` to `() -> Void` and this
+      // helps to avoid creating a thunk to support it.
+      if (getLocator()->isLastElement<LocatorPathElt::ClosureResult>() &&
+          binding.Kind == AllowedBindingKind::Supertypes) {
+        auto voidType = CS.getASTContext().TheEmptyTupleType;
+        addNewBinding(binding.withSameSource(voidType, BindingKind::Exact));
+      }
+
       for (auto supertype : enumerateDirectSupertypes(type)) {
         // If we're not allowed to try this binding, skip it.
         if (auto simplifiedSuper = checkTypeOfBinding(TypeVar, supertype))