[CanonicalizeOSSALt] Extracted destroy pred.

Pulled out a simple check--that CanonicalizeOSSALifetime now uses to
determine whether to continue hoisting a destroy_value instruction--into
a predicate that can be used by LexicalDestroyFolding.

Author: nate-chandler

include/swift/SILOptimizer/Utils/CanonicalOSSALifetime.h

@@ -313,6 +313,23 @@ class CanonicalizeOSSALifetime {
   CanonicalOSSAConsumeInfo consumes;
 
 public:
+  /// When rewriting destroys, is this an instruction which destroys should not
+  /// be hoisted over to avoid churn and infinite looping.
+  static bool ignoredByDestroyHoisting(SILInstructionKind kind) {
+    switch (kind) {
+    case SILInstructionKind::DestroyValueInst:
+    case SILInstructionKind::CopyValueInst:
+    case SILInstructionKind::BeginBorrowInst:
+    case SILInstructionKind::EndBorrowInst:
+    case SILInstructionKind::FunctionRefInst:
+    case SILInstructionKind::EnumInst:
+    case SILInstructionKind::StructInst:
+      return true;
+    default:
+      return false;
+    }
+  }
+
   void maybeNotifyMoveOnlyCopy(Operand *use) {
     if (!moveOnlyCopyValueNotification)
       return;

lib/SILOptimizer/Utils/CanonicalOSSALifetime.cpp

@@ -492,9 +492,10 @@ void CanonicalizeOSSALifetime::findOrInsertDestroyInBlock(SILBasicBlock *bb) {
       return;
     }
     // This is not a potential last user. Keep scanning.
-    // Allow lifetimes to be artificially extended up to the next call. The goal
-    // is to prevent repeated destroy rewriting without inhibiting optimization.
-    if (ApplySite::isa(inst)) {
+    // Allow lifetimes to be artificially extended up to the next non-ignored
+    // instruction. The goal is to prevent repeated destroy rewriting without
+    // inhibiting optimization.
+    if (!ignoredByDestroyHoisting(inst->getKind())) {
       existingDestroy = nullptr;
     } else if (!existingDestroy) {
       if (auto *destroy = dyn_cast<DestroyValueInst>(inst)) {