[LexicalDestroyHoisting] Eliminate updateSSA.

UpdateSSA was being used to rewrite destroys, not for its intended
purpose.  Besides being a misuse, it's also wasteful.  Instead, just
rewrite the destroys that it would have updated.

Author: nate-chandler

lib/SILOptimizer/Utils/LexicalDestroyFolding.cpp

@@ -308,9 +308,6 @@ class FilterCandidates final {
 
   /// Determines whether each candidate is viable for folding.
   ///
-  /// Requiring findUsers to have been called, this uses the more expensive
-  /// isViableMatch.
-  ///
   /// returns true if any candidates were viable
   ///         false otherwise
   bool run(Candidates &candidates);
@@ -334,8 +331,7 @@ class FilterCandidates final {
 ///
 /// If there are, we can't fold the apply.  Specifically, we can't introduce
 /// a move_value [lexical] %borrowee because that value still needs to be used
-/// in those locations.  While updateSSA would happily rewrite those uses to
-/// be uses of the move, that is not a semantically valid transformation.
+/// in those locations.
 ///
 /// For example, given the following SIL
 ///     %borrowee : @owned
@@ -412,10 +408,6 @@ class Rewriter final {
   /// (3) delete the destroy_value
   void fold(Match, SmallVectorImpl<int> const &rewritableArgumentIndices);
 
-  // Update SSA to reflect that fact that %move and %borrowee are two
-  // defs for the "same value".
-  void updateSSA();
-
   // The move_value [lexical] instruction that was added during the run.
   //
   // Defined during createMove.
@@ -470,25 +462,31 @@ bool run(Context &context) {
 void Rewriter::run() {
   bool foldedAny = false;
   (void)foldedAny;
-  for (unsigned index = 0, count = candidates.vector.size(); index < count;
-       ++index) {
+  auto size = candidates.vector.size();
+  for (unsigned index = 0; index < size; ++index) {
     auto candidate = candidates.vector[index];
-    if (!candidate.viable)
-      continue;
     createMove();
+    if (!candidate.viable) {
+      // Nonviable candidates still end with the pattern
+      //
+      //     end_borrow %lifetime
+      //     ...
+      //     destroy_value %borrowee
+      //
+      // Now that the new move_value [lexical] dominates all candidates, the
+      // every candidate's destroy_value %borrowee is dominated by it, so every
+      // one is dominated by another consuming use which is illegal.  Rewrite
+      // each such destroy_value to be a destroy_value of the move.
+      candidate.match.dvi->setOperand(mvi);
+      continue;
+    }
 
     fold(candidate.match, candidate.argumentIndices);
 #ifndef NDEBUG
     foldedAny = true;
 #endif
   }
   assert(foldedAny && "rewriting without anything to rewrite!?");
-
-  // There are now "two defs for %borrowee":
-  // - %borrowee
-  // - %move
-  // We need to update SSA.
-  updateSSA();
 }
 
 bool Rewriter::createMove() {
@@ -551,26 +549,6 @@ void Rewriter::fold(Match candidate,
   context.deleter.forceDelete(candidate.dvi);
 }
 
-void Rewriter::updateSSA() {
-  SILSSAUpdater updater;
-  updater.initialize(context.borrowee->getType(),
-                     context.borrowee.getOwnershipKind());
-  updater.addAvailableValue(context.borrowee->getParentBlock(),
-                            context.borrowee);
-  updater.addAvailableValue(mvi->getParentBlock(), mvi);
-
-  SmallVector<Operand *, 16> uses;
-  for (auto use : context.borrowee->getUses()) {
-    if (use->getUser() == mvi)
-      continue;
-    uses.push_back(use);
-  }
-
-  for (auto use : uses) {
-    updater.rewriteUse(*use);
-  }
-}
-
 //===----------------------------------------------------------------------===//
 //                             MARK: Lookups
 //===----------------------------------------------------------------------===//
@@ -640,6 +618,8 @@ bool FilterCandidates::run(Candidates &candidates) {
 
 bool findBorroweeUsage(Context &context, BorroweeUsage &usage) {
   auto recordUse = [&](Operand *use) {
+    // Ignore uses that aren't dominated by the introducer.  PrunedLiveness
+    // relies on us doing this check.
     if (!context.dominanceTree.dominates(context.introducer, use->getUser()))
       return;
     usage.uses.push_back(use);

test/SILOptimizer/lexical_destroy_folding.sil

@@ -161,7 +161,7 @@ exit:
 
 }
 
-// Enclose a single guaranteed lexical scope that contains two paralell
+// Enclose a single guaranteed lexical scope that contains two parallel
 // applies of owned arguments with the destroy at a NONcanonical position
 // within a single owned lexical scope.
 //
@@ -514,11 +514,24 @@ exit:
   return %retval : $()
 }
 
-// Don't fold with apply when guaranteed lexical value used in one but not two
-// branches and the lexical scope ends before the use on the non-lexical branch.
+// Fold apply when guaranteed lexical value used in one but not two branches
+// and the lexical scope ends before the use on the non-lexical branch.
 //
 // CHECK-LABEL: sil [ossa] @nofold_two_parallel_owned_uses_one_lexical___scope_ends_before_use : {{.*}} {
-// CHECK-NOT: move_value [lexical]
+// CHECK:       {{bb[0-9]+}}([[INSTANCE:%[^,]+]] :
+// CHECK:         [[COPY:%[^,]+]] = copy_value [[INSTANCE]]
+// CHECK:         [[MOVE:%[^,]+]] = move_value [lexical] [[INSTANCE]]
+// CHECK:         [[CALLEE_OWNED:%[^,]+]] = function_ref @callee_owned
+// CHECK:         cond_br undef, [[LEFT:bb[0-9]+]], [[RIGHT:bb[0-9]+]]
+// CHECK:       [[LEFT]]:
+// CHECK:         apply [[CALLEE_OWNED]]([[MOVE]])
+// CHECK:         destroy_value [[COPY]]
+// CHECK:         br [[EXIT:bb[0-9]+]]
+// CHECK:       [[RIGHT]]:
+// CHECK:         destroy_value [[MOVE]]
+// CHECK:         apply [[CALLEE_OWNED]]([[COPY]])
+// CHECK:         br [[EXIT]]
+// CHECK:       [[EXIT]]:
 // CHECK-LABEL: } // end sil function 'nofold_two_parallel_owned_uses_one_lexical___scope_ends_before_use'
 sil [ossa] @nofold_two_parallel_owned_uses_one_lexical___scope_ends_before_use : $@convention(thin) (@owned C) -> () {
 entry(%instance : @owned $C):