Coerce the parameter of the parameter to withoutActuallyEscaping to actually be escaping.

People can call `withoutActuallyEscaping` and give it a `do:` body function
that, well, doesn't actually take an escaping closure argument as in:

```swift
func foo(_ f: (() -> Void) -> Void, _ b: () -> Void) {
    return withoutActuallyEscaping(b, do: f)
}
```

and this wouldn't really work because the did-it-escape checking relies on
having a refcounted object to probe, aside from triggering a bunch of
assertion failures in SILGen which assumed the parameter would be escaping.
Fixes rdar://104477418.

Author: jckarter

lib/Sema/CSApply.cpp

@@ -7844,18 +7844,27 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
         auto *body = args->getExpr(1);
         auto bodyTy = cs.getType(body)->getWithoutSpecifierType();
         auto bodyFnTy = bodyTy->castTo<FunctionType>();
-        auto escapableParams = bodyFnTy->getParams();
         auto resultType = bodyFnTy->getResult();
 
         // The body is immediately called, so is obviously noescape.
+        // Coerce the argument function to be escaping even if it happens to
+        // be nonescaping, since we need the dynamic state of the escaping
+        // closure to do the dynamic noescape check.
+        auto bodyArgFnTy = bodyFnTy->getParams()[0].getPlainType()
+          ->castTo<FunctionType>();
+          
+        bodyArgFnTy = cast<FunctionType>(
+          bodyArgFnTy->withExtInfo(bodyArgFnTy->getExtInfo().withNoEscape(false)));
         bodyFnTy = cast<FunctionType>(
-          bodyFnTy->withExtInfo(bodyFnTy->getExtInfo().withNoEscape()));
+          FunctionType::get(bodyFnTy->getParams()[0].withType(bodyArgFnTy),
+                            bodyFnTy->getResult())
+            ->withExtInfo(bodyFnTy->getExtInfo().withNoEscape()));
         body = coerceToType(body, bodyFnTy, locator);
         assert(body && "can't make nonescaping?!");
 
         auto escapable = new (ctx)
             OpaqueValueExpr(apply->getFn()->getSourceRange(), Type());
-        cs.setType(escapable, escapableParams[0].getOldType());
+        cs.setType(escapable, bodyArgFnTy);
 
         auto *argList = ArgumentList::forImplicitUnlabeled(ctx, {escapable});
         auto callSubExpr = CallExpr::createImplicit(ctx, body, argList);

test/SILGen/without_actually_escaping_that_doesnt_actually_escape.swift

@@ -0,0 +1,5 @@
+// RUN: %target-swift-emit-silgen -verify %s
+
+func foo(_ f: (() -> Void) -> Void, _ b: () -> Void) {
+    return withoutActuallyEscaping(b, do: f)
+}