Revert "[move-only] Ensure that we treat captured escaping closure arguments as such even if the closure doesn't actually escape"

This reverts commit 224674c.

Originally, I made this change since we were going to follow the AST in a strict
way in terms of what closures are considered escaping or not from a diagnostics
perspective. Upon further investigation I found that we actually do something
different for inout escaping semantics and by treating the AST as the one point
of truth, we are being inconsistent with the rest of the compiler. As an
example, the following code is considered by the compiler to not be an invalid
escaping use of an inout implying that we do not consider the closure to be
escaping:

```
func f(_ x: inout Int) {
  let g = {
    _ = x
  }
}
```

in contrast, a var is always considered to be an escape:

```
func f(_ x: inout Int) {
  var g = {
    _ = x
  }
}

test2.swift:3:13: error: escaping closure captures 'inout' parameter 'x'
    var g = {
            ^
test2.swift:2:10: note: parameter 'x' is declared 'inout'
func f(_ x: inout Int) {
         ^
test2.swift:4:11: note: captured here
        _ = x
          ^
```

Of course, if we store the let into memory, we get the error one would expect:

```
var global: () -> () = {}
func f(_ x: inout Int) {
  let g = {
    _ = x
  }
  global = g
}

test2.swift:4:11: error: escaping closure captures 'inout' parameter 'x'
  let g = {
          ^
test2.swift:3:10: note: parameter 'x' is declared 'inout'
func f(_ x: inout Int) {
         ^
test2.swift:5:7: note: captured here
    _ = x
      ^
```

By reverting to the old behavior where allocbox to stack ran early, noncopyable
types now have the same sort of semantics: let closures that capture a
noncopyable type that do not on the face of it escape are considered
non-escaping, while if the closure is ever stored into memory (e.x.: store into
a global, into a local var) or escapes, we get the appropriate escaping
diagnostics. E.x.:

```
public struct E : ~Copyable {}
public func borrowVal(_ e: borrowing E) {}
public func consumeVal(_ e: consuming E) {}

func f1() {
  var e = E()

  // Mutable borrowing use of e. We can consume e as long as we reinit at end
  // of function. We don't here, so we get an error.
  let c1: () -> () = {
    borrowVal(e)
    consumeVal(e)
  }

  // Mutable borrowing use of e. We can consume e as long as we reinit at end
  // of function. We do do that here, so no error.
  let c2: () -> () = {
    borrowVal(e)
    consumeVal(e)
    e = E()
  }
}

```

Author: gottesmm

include/swift/SILOptimizer/PassManager/Passes.def

@@ -112,9 +112,6 @@ PASS(AccessMarkerElimination, "access-marker-elim",
      "Access Marker Elimination.")
 PASS(AddressLowering, "address-lowering",
      "SIL Address Lowering")
-PASS(EarlyAllocBoxToStack, "early-allocbox-to-stack",
-     "Stack Promotion of Box Objects. Doesn't attempt to promote noncopyable "
-     "types captured by escaping closures")
 PASS(AllocBoxToStack, "allocbox-to-stack",
      "Stack Promotion of Box Objects")
 IRGEN_PASS(AllocStackHoisting, "alloc-stack-hoisting",

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -125,7 +125,7 @@ static void addMandatoryDiagnosticOptPipeline(SILPassPipelinePlan &P) {
   // This guarantees that stack-promotable boxes have [static] enforcement.
   P.addAccessEnforcementSelection();
 
-  P.addEarlyAllocBoxToStack();
+  P.addAllocBoxToStack();
   P.addNoReturnFolding();
   addDefiniteInitialization(P);
 
@@ -169,11 +169,6 @@ static void addMandatoryDiagnosticOptPipeline(SILPassPipelinePlan &P) {
   // End Ownership Optimizations
   //===---
 
-  // Now that we have finished checking noncopyable types, run later alloc box
-  // to stack, so that we promote to the stack any heap boxes that are captured
-  // by escaping closures where the closure does not actually escape.
-  P.addAllocBoxToStack();
-
 #ifndef NDEBUG
   // Add a verification pass to check our work when skipping
   // function bodies.

lib/SILOptimizer/Transforms/AllocBoxToStack.cpp

@@ -16,7 +16,6 @@
 #include "swift/AST/SemanticAttrs.h"
 #include "swift/Basic/BlotMapVector.h"
 #include "swift/Basic/GraphNodeWorklist.h"
-#include "swift/Basic/OptionSet.h"
 #include "swift/SIL/ApplySite.h"
 #include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SIL/Dominance.h"
@@ -88,18 +87,6 @@ static bool useCaptured(Operand *UI) {
   return true;
 }
 
-namespace {
-
-enum class AllocBoxToStackFlags {
-  InAppliedFunction = 0x1,
-  CanPromoteNonCopyableCapturedByEscapingClosure = 0x2,
-  HasMoveOnlyBox = 0x4,
-};
-
-using AllocBoxToStackOptions = OptionSet<AllocBoxToStackFlags>;
-
-} // namespace
-
 //===----------------------------------------------------------------------===//
 //                 Liveness for alloc_box Promotion
 //===----------------------------------------------------------------------===//
@@ -314,7 +301,7 @@ static bool partialApplyEscapes(SILValue V, bool examineApply) {
 }
 
 static SILInstruction *recursivelyFindBoxOperandsPromotableToAddress(
-    SILValue Box, AllocBoxToStackOptions Options, SmallVectorImpl<Operand *> &,
+    SILValue Box, bool inAppliedFunction, SmallVectorImpl<Operand *> &,
     SmallPtrSetImpl<SILFunction *> &, unsigned CurrentRecurDepth);
 
 /// checkLocalApplyBody - Check the body of an apply's callee to see
@@ -324,8 +311,7 @@ static SILInstruction *recursivelyFindBoxOperandsPromotableToAddress(
 static bool checkLocalApplyBody(Operand *O,
                                 SmallVectorImpl<Operand *> &PromotedOperands,
                                 SmallPtrSetImpl<SILFunction *> &VisitedCallees,
-                                unsigned CurrentRecurDepth,
-                                AllocBoxToStackOptions Options) {
+                                unsigned CurrentRecurDepth) {
   SILFunction *F = ApplySite(O->getUser()).getReferencedFunctionOrNull();
   // If we cannot examine the function body, assume the worst.
   if (!F || F->empty())
@@ -337,11 +323,10 @@ static bool checkLocalApplyBody(Operand *O,
   if (!iter.second)
     return false;
 
-  Options |= {AllocBoxToStackFlags::InAppliedFunction};
-
   auto calleeArg = F->getArgument(ApplySite(O->getUser()).getCalleeArgIndex(*O));
   auto res = !recursivelyFindBoxOperandsPromotableToAddress(
-      calleeArg, Options, PromotedOperands, VisitedCallees,
+      calleeArg,
+      /* inAppliedFunction = */ true, PromotedOperands, VisitedCallees,
       CurrentRecurDepth + 1);
   return res;
 }
@@ -385,7 +370,7 @@ static bool isOptimizableApplySite(ApplySite Apply) {
 /// box is passed don't have any unexpected uses, `PromotedOperands` will be
 /// populated with the box arguments in DFS order.
 static SILInstruction *recursivelyFindBoxOperandsPromotableToAddress(
-    SILValue Box, AllocBoxToStackOptions Options,
+    SILValue Box, bool inAppliedFunction,
     SmallVectorImpl<Operand *> &PromotedOperands,
     SmallPtrSetImpl<SILFunction *> &VisitedCallees,
     unsigned CurrentRecurDepth = 0) {
@@ -409,8 +394,7 @@ static SILInstruction *recursivelyFindBoxOperandsPromotableToAddress(
     // Projections are fine as well.
     if (isa<StrongRetainInst>(User) || isa<StrongReleaseInst>(User) ||
         isa<ProjectBoxInst>(User) || isa<DestroyValueInst>(User) ||
-        (!Options.contains(AllocBoxToStackFlags::InAppliedFunction) &&
-         isa<DeallocBoxInst>(User)) ||
+        (!inAppliedFunction && isa<DeallocBoxInst>(User)) ||
         isa<EndBorrowInst>(User))
       continue;
 
@@ -429,17 +413,8 @@ static SILInstruction *recursivelyFindBoxOperandsPromotableToAddress(
       }
       switch (Apply.getKind()) {
       case ApplySiteKind::PartialApplyInst: {
-        // If we have a noncopyable type in a box and we were passed in the
-        // option that tells us that we should not promote any boxes that are
-        // captured by an escaping closure (even if we can prove the closure
-        // does not escape), treat the partial apply use as an escape.
-        if (Box->getType().isBoxedNonCopyableType(Box->getFunction()) &&
-            !Options.contains(
-                AllocBoxToStackFlags::
-                    CanPromoteNonCopyableCapturedByEscapingClosure))
-          break;
         if (checkLocalApplyBody(Op, LocalPromotedOperands, VisitedCallees,
-                                CurrentRecurDepth, Options) &&
+                                CurrentRecurDepth) &&
             !partialApplyEscapes(cast<PartialApplyInst>(User),
                                  /* examineApply = */ true)) {
           LocalPromotedOperands.push_back(Op);
@@ -452,7 +427,7 @@ static SILInstruction *recursivelyFindBoxOperandsPromotableToAddress(
       case ApplySiteKind::TryApplyInst:
         if (isOptimizableApplySite(Apply) &&
             checkLocalApplyBody(Op, LocalPromotedOperands, VisitedCallees,
-                                CurrentRecurDepth, Options)) {
+                                CurrentRecurDepth)) {
           LocalPromotedOperands.push_back(Op);
           continue;
         }
@@ -475,13 +450,13 @@ static InFlightDiagnostic diagnose(ASTContext &Context, SourceLoc loc,
 
 /// canPromoteAllocBox - Can we promote this alloc_box to an alloc_stack?
 static bool canPromoteAllocBox(AllocBoxInst *ABI,
-                               SmallVectorImpl<Operand *> &PromotedOperands,
-                               AllocBoxToStackOptions Options) {
+                               SmallVectorImpl<Operand *> &PromotedOperands) {
   SmallPtrSet<SILFunction *, 8> VisitedCallees;
   // Scan all of the uses of the address of the box to see if any
   // disqualifies the box from being promoted to the stack.
   if (auto *User = recursivelyFindBoxOperandsPromotableToAddress(
-          ABI, Options, PromotedOperands, VisitedCallees,
+          ABI,
+          /* inAppliedFunction = */ false, PromotedOperands, VisitedCallees,
           /* CurrentRecurDepth = */ 0)) {
     (void)User;
     // Otherwise, we have an unexpected use.
@@ -1246,8 +1221,6 @@ static unsigned rewritePromotedBoxes(AllocBoxToStackState &pass) {
 }
 
 namespace {
-
-template <bool CanPromoteMoveOnlyCapturedByEscapingClosure>
 class AllocBoxToStack : public SILFunctionTransform {
   /// The entry point to the transformation.
   void run() override {
@@ -1256,16 +1229,10 @@ class AllocBoxToStack : public SILFunctionTransform {
       return;
 
     AllocBoxToStackState pass(this);
-
-    AllocBoxToStackOptions Options;
-    if (CanPromoteMoveOnlyCapturedByEscapingClosure)
-      Options |=
-          AllocBoxToStackFlags::CanPromoteNonCopyableCapturedByEscapingClosure;
-
     for (auto &BB : *getFunction()) {
       for (auto &I : BB)
         if (auto *ABI = dyn_cast<AllocBoxInst>(&I))
-          if (canPromoteAllocBox(ABI, pass.PromotedOperands, Options))
+          if (canPromoteAllocBox(ABI, pass.PromotedOperands))
             pass.Promotable.push_back(ABI);
     }
 
@@ -1284,13 +1251,8 @@ class AllocBoxToStack : public SILFunctionTransform {
     }
   }
 };
-
 } // end anonymous namespace
 
 SILTransform *swift::createAllocBoxToStack() {
-  return new AllocBoxToStack<true>();
-}
-
-SILTransform *swift::createEarlyAllocBoxToStack() {
-  return new AllocBoxToStack<false>();
+  return new AllocBoxToStack();
 }