[CSBindings] Don't favor application result types before application happens

Until `ApplicableFunction` constraint is simplified result type
associated with it cannot be bound because the binding set if
incomplete.

Resolves: rdar://139237088

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -486,6 +486,10 @@ class TypeVariableType::Implementation {
   /// Determine whether this type variable represents a subscript result type.
   bool isSubscriptResultType() const;
 
+  /// Determine whether this type variable represents a result type of an
+  /// application i.e. a call, an operator, or a subscript.
+  bool isApplicationResultType() const;
+
   /// Determine whether this type variable represents an opened
   /// type parameter pack.
   bool isParameterPack() const;

lib/Sema/CSBindings.cpp

@@ -1293,9 +1293,16 @@ bool BindingSet::favoredOverDisjunction(Constraint *disjunction) const {
 
         return !hasConversions(binding.BindingType);
       })) {
-    // Result type of subscript could be l-value so we can't bind it early.
-    if (!TypeVar->getImpl().isSubscriptResultType() &&
-        llvm::none_of(Info.DelayedBy, [](const Constraint *constraint) {
+    bool isApplicationResultType = TypeVar->getImpl().isApplicationResultType();
+    if (llvm::none_of(Info.DelayedBy, [&isApplicationResultType](
+                                          const Constraint *constraint) {
+          // Let's not attempt to bind result type before application
+          // happens. For example because it could be discardable or
+          // l-value (subscript applications).
+          if (isApplicationResultType &&
+              constraint->getKind() == ConstraintKind::ApplicableFunction)
+            return true;
+
           return constraint->getKind() == ConstraintKind::Disjunction ||
                  constraint->getKind() == ConstraintKind::ValueMember;
         }))

lib/Sema/TypeCheckConstraints.cpp

@@ -175,6 +175,16 @@ bool TypeVariableType::Implementation::isSubscriptResultType() const {
              KeyPathExpr::Component::Kind::UnresolvedSubscript;
 }
 
+bool TypeVariableType::Implementation::isApplicationResultType() const {
+  if (!(locator && locator->getAnchor()))
+    return false;
+
+  if (!locator->isLastElement<LocatorPathElt::FunctionResult>())
+    return false;
+
+  return isExpr<ApplyExpr>(locator->getAnchor()) || isSubscriptResultType();
+}
+
 bool TypeVariableType::Implementation::isParameterPack() const {
   return locator
       && locator->isForGenericParameter()

test/Constraints/async.swift

@@ -180,3 +180,20 @@ struct OverloadInImplicitAsyncClosure {
 
   init(int: Int) throws { }
 }
+
+@available(SwiftStdlib 5.5, *)
+func test(_: Int) async throws {}
+
+@discardableResult
+@available(SwiftStdlib 5.5, *)
+func test(_: Int) -> String { "" }
+
+@available(SwiftStdlib 5.5, *)
+func compute(_: @escaping () -> Void) {}
+
+@available(SwiftStdlib 5.5, *)
+func test_sync_in_closure_context() {
+  compute {
+    test(42) // Ok (select sync overloads and discards the result)
+  }
+}