[Sema]Set isAsync only when it is in async context

Author: stzn

lib/Sema/CSApply.cpp

@@ -8217,6 +8217,16 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
         // Resolve into a MakeTemporarilyEscapableExpr.
         auto *args = apply->getArgs();
         assert(args->size() == 2 && "should have two arguments");
+        auto appliedWrappers =
+            solution.getAppliedPropertyWrappers(calleeLocator.getAnchor());
+        auto fnType = cs.getType(fn)->getAs<FunctionType>();
+        args = coerceCallArguments(
+            args, fnType, declRef, apply,
+            locator.withPathElement(ConstraintLocator::ApplyArgument),
+            appliedWrappers);
+        if (!args)
+          return nullptr;
+
         auto *nonescaping = cs.coerceToRValue(args->getExpr(0));
         auto *body = args->getExpr(1);
         auto bodyTy = cs.getType(body)->getWithoutSpecifierType();

lib/Sema/TypeOfReference.cpp

@@ -2214,7 +2214,7 @@ isInvalidPartialApplication(ConstraintSystem &cs,
 /// the full opened type and the reference's type.
 static DeclReferenceType getTypeOfReferenceWithSpecialTypeCheckingSemantics(
     ConstraintSystem &CS, ConstraintLocator *locator,
-    DeclTypeCheckingSemantics semantics) {
+    DeclTypeCheckingSemantics semantics, DeclContext *useDC) {
   switch (semantics) {
   case DeclTypeCheckingSemantics::Normal:
     llvm_unreachable("Decl does not have special type checking semantics!");
@@ -2261,10 +2261,11 @@ static DeclReferenceType getTypeOfReferenceWithSpecialTypeCheckingSemantics(
         CS.getConstraintLocator(locator, ConstraintLocator::ThrownErrorType),
         0);
     FunctionType::Param arg(escapeClosure);
+    bool isAsync = CS.isAsynchronousContext(useDC);
     auto bodyClosure = FunctionType::get(arg, result,
                                          FunctionType::ExtInfoBuilder()
                                              .withNoEscape(true)
-                                             .withAsync(true)
+                                             .withAsync(isAsync)
                                              .withThrows(true, thrownError)
                                              .build());
     FunctionType::Param args[] = {
@@ -2275,7 +2276,7 @@ static DeclReferenceType getTypeOfReferenceWithSpecialTypeCheckingSemantics(
     auto refType = FunctionType::get(args, result,
                                      FunctionType::ExtInfoBuilder()
                                          .withNoEscape(false)
-                                         .withAsync(true)
+                                         .withAsync(isAsync)
                                          .withThrows(true, thrownError)
                                          .build());
     return {refType, refType, refType, refType, Type()};
@@ -2370,7 +2371,7 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
     DeclReferenceType declRefType;
     if (semantics != DeclTypeCheckingSemantics::Normal) {
       declRefType = getTypeOfReferenceWithSpecialTypeCheckingSemantics(
-          *this, locator, semantics);
+          *this, locator, semantics, useDC);
     } else if (auto baseTy = choice.getBaseType()) {
       // Retrieve the type of a reference to the specific declaration choice.
       assert(!baseTy->hasTypeParameter());