[LifetimeCompletion] Removed "with leaks" mode.

Now that the two known issues which resulted in invalid SIL being
provided to lifetime completion have been addressed, tighten up the
completion done on the availability boundary not to allow leaks.

Author: nate-chandler

include/swift/SIL/OSSALifetimeCompletion.h

@@ -57,19 +57,13 @@ class OSSALifetimeCompletion {
   // Availability: "As late as possible."  Consume the value in the last blocks
   //               beyond the non-consuming uses in which the value has been
   //               consumed on no incoming paths.
-  // AvailabilityWithLeaks: "As late as possible or later."  Consume the value
-  //                        in the last blocks beyond the non-consuming uses in
-  //                        which the value has been consumed on no incoming
-  //                        paths, unless that block's terminator isn't an
-  //                        unreachable, in which case, don't consume it there.
   //
   //                        This boundary works around bugs where SILGen emits
   //                        illegal OSSA lifetimes.
   struct Boundary {
     enum Value : uint8_t {
       Liveness,
       Availability,
-      AvailabilityWithLeaks,
     };
     Value value;
 
@@ -115,11 +109,6 @@ class OSSALifetimeCompletion {
                : LifetimeCompletion::AlreadyComplete;
   }
 
-  enum AllowLeaks_t : bool {
-    AllowLeaks = true,
-    DoNotAllowLeaks = false,
-  };
-
   enum class LifetimeEnd : uint8_t {
     /// The lifetime ends at the boundary.
     Boundary,
@@ -128,8 +117,7 @@ class OSSALifetimeCompletion {
   };
 
   static void visitAvailabilityBoundary(
-      SILValue value, AllowLeaks_t allowLeaks,
-      const SSAPrunedLiveness &liveness,
+      SILValue value, const SSAPrunedLiveness &liveness,
       llvm::function_ref<void(SILInstruction *, LifetimeEnd end)> visit);
 
 protected:
@@ -187,9 +175,6 @@ operator<<(llvm::raw_ostream &OS, OSSALifetimeCompletion::Boundary boundary) {
   case OSSALifetimeCompletion::Boundary::Availability:
     OS << "availability";
     break;
-  case OSSALifetimeCompletion::Boundary::AvailabilityWithLeaks:
-    OS << "availability_with_leaks";
-    break;
   }
   return OS;
 }

lib/SIL/Utils/OSSALifetimeCompletion.cpp

@@ -168,21 +168,14 @@ class AvailabilityBoundaryVisitor {
   /// The value whose dead-end block lifetime ends are to be visited.
   SILValue value;
 
-  /// Whether to allow leaks.
-  ///
-  /// Here, that entails allowing walks to reach non-unreachable terminators and
-  /// not creating lifetime ends before them.
-  OSSALifetimeCompletion::AllowLeaks_t allowLeaks;
-
   /// The non-lifetime-ending boundary of `value`.
   BasicBlockSet starts;
   /// The region between (inclusive) the `starts` and the unreachable blocks.
   BasicBlockSetVector region;
 
 public:
-  AvailabilityBoundaryVisitor(SILValue value,
-                              OSSALifetimeCompletion::AllowLeaks_t allowLeaks)
-      : value(value), allowLeaks(allowLeaks), starts(value->getFunction()),
+  AvailabilityBoundaryVisitor(SILValue value)
+      : value(value), starts(value->getFunction()),
         region(value->getFunction()) {}
 
   using Visit = llvm::function_ref<void(SILInstruction *,
@@ -307,10 +300,7 @@ void AvailabilityBoundaryVisitor::computeRegion(
       // Thus finding a value available at the end of such a block means that
       // the block does _not_ must not exits the function normally; in other
       // words its terminator must be an UnreachableInst.
-      //
-      // In invalid OSSA, indicated by the `allowLeaks` flag, no such guarantee
-      // exists.
-      assert(isa<UnreachableInst>(block->getTerminator()) || allowLeaks);
+      assert(isa<UnreachableInst>(block->getTerminator()));
     }
     for (auto *successor : block->getSuccessorBlocks()) {
       regionWorklist.pushIfNotVisited(successor);
@@ -379,12 +369,6 @@ void AvailabilityBoundaryVisitor::visitAvailabilityBoundary(
     if (!block->succ_empty() && !hasUnavailableSuccessor()) {
       continue;
     }
-    if (allowLeaks && block->succ_empty() &&
-        !isa<UnreachableInst>(block->getTerminator())) {
-      // Availability extends to the end of a function-exiting-normally block.
-      // If leaks are allowed, don't visit.
-      continue;
-    }
     assert(hasUnavailableSuccessor() ||
            isa<UnreachableInst>(block->getTerminator()));
     visit(block->getTerminator(),
@@ -394,10 +378,10 @@ void AvailabilityBoundaryVisitor::visitAvailabilityBoundary(
 } // end anonymous namespace
 
 void OSSALifetimeCompletion::visitAvailabilityBoundary(
-    SILValue value, AllowLeaks_t allowLeaks, const SSAPrunedLiveness &liveness,
+    SILValue value, const SSAPrunedLiveness &liveness,
     llvm::function_ref<void(SILInstruction *, LifetimeEnd end)> visit) {
 
-  AvailabilityBoundaryVisitor visitor(value, allowLeaks);
+  AvailabilityBoundaryVisitor visitor(value);
   AvailabilityBoundaryVisitor::Result result(value->getFunction());
   visitor.visit(liveness, result, visit);
 
@@ -410,12 +394,12 @@ void OSSALifetimeCompletion::visitAvailabilityBoundary(
       });
 }
 
-static bool endLifetimeAtAvailabilityBoundary(
-    SILValue value, OSSALifetimeCompletion::AllowLeaks_t allowLeaks,
-    const SSAPrunedLiveness &liveness) {
+static bool
+endLifetimeAtAvailabilityBoundary(SILValue value,
+                                  const SSAPrunedLiveness &liveness) {
   bool changed = false;
   OSSALifetimeCompletion::visitAvailabilityBoundary(
-      value, allowLeaks, liveness, [&](auto *unreachable, auto end) {
+      value, liveness, [&](auto *unreachable, auto end) {
         SILBuilderWithScope builder(unreachable);
         endOSSALifetime(value, end, builder);
         changed = true;
@@ -442,12 +426,7 @@ bool OSSALifetimeCompletion::analyzeAndUpdateLifetime(SILValue value,
     changed |= endLifetimeAtLivenessBoundary(value, liveness.getLiveness());
     break;
   case Boundary::Availability:
-    changed |= endLifetimeAtAvailabilityBoundary(value, DoNotAllowLeaks,
-                                                 liveness.getLiveness());
-    break;
-  case Boundary::AvailabilityWithLeaks:
-    changed |= endLifetimeAtAvailabilityBoundary(value, AllowLeaks,
-                                                 liveness.getLiveness());
+    changed |= endLifetimeAtAvailabilityBoundary(value, liveness.getLiveness());
     break;
   }
   // TODO: Rebuild outer adjacent phis on demand (SILGen does not currently
@@ -472,9 +451,7 @@ static FunctionTest OSSALifetimeCompletionTest(
               arguments.takeString())
               .Case("liveness", OSSALifetimeCompletion::Boundary::Liveness)
               .Case("availability",
-                    OSSALifetimeCompletion::Boundary::Availability)
-              .Case("availability_with_leaks",
-                    OSSALifetimeCompletion::Boundary::AvailabilityWithLeaks);
+                    OSSALifetimeCompletion::Boundary::Availability);
       llvm::outs() << "OSSA lifetime completion on " << kind
                    << " boundary: " << value;
       OSSALifetimeCompletion completion(&function, /*domInfo*/ nullptr);

lib/SILOptimizer/Mandatory/SILGenCleanup.cpp

@@ -118,8 +118,7 @@ bool SILGenCleanup::completeOSSALifetimes(SILFunction *function) {
     for (SILInstruction &inst : reverse(*block)) {
       for (auto result : inst.getResults()) {
         if (completion.completeOSSALifetime(
-                result,
-                OSSALifetimeCompletion::Boundary::AvailabilityWithLeaks) ==
+                result, OSSALifetimeCompletion::Boundary::Availability) ==
             LifetimeCompletion::WasCompleted) {
           changed = true;
         }
@@ -128,7 +127,7 @@ bool SILGenCleanup::completeOSSALifetimes(SILFunction *function) {
     for (SILArgument *arg : block->getArguments()) {
       assert(!arg->isReborrow() && "reborrows not legal at this SIL stage");
       if (completion.completeOSSALifetime(
-              arg, OSSALifetimeCompletion::Boundary::AvailabilityWithLeaks) ==
+              arg, OSSALifetimeCompletion::Boundary::Availability) ==
           LifetimeCompletion::WasCompleted) {
         changed = true;
       }

lib/SILOptimizer/Utils/CanonicalizeOSSALifetime.cpp

@@ -274,8 +274,7 @@ void CanonicalizeOSSALifetime::extendLivenessToDeinitBarriers() {
   }
 
   OSSALifetimeCompletion::visitAvailabilityBoundary(
-      getCurrentDef(), OSSALifetimeCompletion::DoNotAllowLeaks,
-      completeLiveness, [&](auto *unreachable, auto end) {
+      getCurrentDef(), completeLiveness, [&](auto *unreachable, auto end) {
         if (end == OSSALifetimeCompletion::LifetimeEnd::Boundary) {
           recordUnreachableLifetimeEnd(unreachable);
         }