[Sema]Coerce to rvalue when withoutActuallyEscaping receives an lvalue argument

lib/Sema/CSApply.cpp

@@ -8217,6 +8217,17 @@ 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 = 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());

test/Constraints/without_actually_escaping.swift

@@ -61,7 +61,7 @@ func rethrowThroughWAE(_ zz: (Int, Int, Int) throws -> Int, _ value: Int) throws
 }
 
 let _: ((Int) -> Int, (@escaping (Int) -> Int) -> ()) -> () = withoutActuallyEscaping(_:do:)
-// expected-error@-1 {{invalid conversion from 'async' function of type '((Int) -> Int, (@escaping (Int) -> Int) async -> ()) async -> ()' to synchronous function type '((Int) -> Int, (@escaping (Int) -> Int) -> ()) -> ()'}}
+// expected-error@-1 {{cannot convert value of type '((Swift.Int) -> Swift.Int, (@escaping (Swift.Int) -> Swift.Int) -> ()) -> ()' to specified type '((Swift.Int) -> Swift.Int, (@escaping (Swift.Int) -> Swift.Int) -> ()) -> ()'}}
 
 
 // Failing to propagate @noescape into non-single-expression

test/Sema/without_actually_escaping.swift

@@ -0,0 +1,71 @@
+// RUN: %target-typecheck-verify-swift
+
+func noEscapeWAE(f: () -> Void) {
+  withoutActuallyEscaping(f) { $0() }  
+}
+
+func escapingWAE(f: @escaping () -> Void) {
+  withoutActuallyEscaping(f) { $0() }  
+}
+
+func inoutWAE(f: inout () -> Void) {
+  withoutActuallyEscaping(f) { $0() }  
+}
+
+func rethrowThroughInoutWAE(f: inout () throws -> Void) throws {
+  try withoutActuallyEscaping(f) { try $0() }  
+}
+
+func consumingWAE(f: consuming @escaping () -> Void) {
+  withoutActuallyEscaping(f) { $0() }  
+}
+
+func rethrowThroughConsumingWAE(f: consuming @escaping () throws -> Void) throws {
+  try withoutActuallyEscaping(f) { try $0() }  
+}
+
+func sendingEscapingAsyncWAE(f: sending @escaping () async -> Void) async {
+  await withoutActuallyEscaping(f) { await $0() }  
+}
+
+func rethrowThroughSendingEscapingAsyncWAE(f: sending @escaping () async throws -> Void) async throws {
+  try await withoutActuallyEscaping(f) { try await $0() }  
+}
+
+func sendingNoEscapeAsyncWAE(f: sending () async -> Void) async {
+  await withoutActuallyEscaping(f) { await $0() }  
+}
+
+func rethrowThroughSendingNoEscapeAsyncWAE(f: sending () async throws -> Void) async throws {
+  try await withoutActuallyEscaping(f) { try await $0() }  
+}
+
+func passNoEscapeClosureViaVarWAE(f: () -> Void) {
+  var x = f
+  withoutActuallyEscaping(x) { $0() }
+  x = {}
+}
+
+func passEscapingClosureViaVarWAE(f: @escaping () -> Void) {
+  var x = f
+  withoutActuallyEscaping(x) { $0() }
+  x = {}
+}
+
+func passInoutClosureViaVarWAE(f: inout () -> Void) {
+  var x = f
+  withoutActuallyEscaping(x) { $0() }
+  x = {}
+}
+
+func passConsumingClosureViaVarWAE(f: consuming @escaping () -> Void) {
+  var x = f
+  withoutActuallyEscaping(x) { $0() }
+  x = {}
+}
+
+func passSendingClosureViaVarWAE(f: consuming @escaping () -> Void) {
+  var x = f
+  withoutActuallyEscaping(x) { $0() }
+  x = {}
+}