Fix BorrowingOperand::visitScopeEndingUses() invariants.

This API only makes sense for a scoped borrow-introducer such as:
- reborrow
- owned mark_dependence

Borrowing operands that forward guaranteed values do not have scope-ending uses.

Author: atrick

include/swift/SIL/SILInstruction.h

@@ -8815,10 +8815,14 @@ class MarkDependenceInst
       uint8_t(MarkDependenceKind::Escaping);
   }
 
-  /// Visit the instructions that end the lifetime of an OSSA on-stack closure.
+  /// Visit the instructions that end the lifetime the dependent value.
+  ///
+  /// Preconditions:
+  /// - isNonEscaping()
+  /// - Produces an owned, Escapable, non-address value
   bool visitNonEscapingLifetimeEnds(
     llvm::function_ref<bool (Operand*)> visitScopeEnd,
-    llvm::function_ref<bool (Operand*)> visitUnknownUse) const;
+    llvm::function_ref<bool (Operand*)> visitUnknownUse);
 };
 
 /// Promote an Objective-C block that is on the stack to the heap, or simply

lib/SIL/IR/SILInstruction.cpp

@@ -2022,10 +2022,13 @@ visitRecursivelyLifetimeEndingUses(
 // the dependent value.
 bool MarkDependenceInst::visitNonEscapingLifetimeEnds(
   llvm::function_ref<bool (Operand *)> visitScopeEnd,
-  llvm::function_ref<bool (Operand *)> visitUnknownUse) const {
+  llvm::function_ref<bool (Operand *)> visitUnknownUse) {
   assert(getFunction()->hasOwnership() && isNonEscaping()
          && "only meaningful for nonescaping dependencies");
   assert(getType().isObject() && "lifetime ends only exist for values");
+  assert(getOwnershipKind() == OwnershipKind::Owned
+         && getType().isEscapable(*getFunction())
+         && "only correct for owned escapable values");
   bool noUsers = true;
   if (!visitRecursivelyLifetimeEndingUses(this, noUsers, visitScopeEnd,
                                           visitUnknownUse)) {

lib/SIL/Utils/OwnershipUtils.cpp

@@ -662,8 +662,12 @@ bool BorrowingOperand::visitScopeEndingUses(
   switch (kind) {
   case BorrowingOperandKind::Invalid:
     llvm_unreachable("Using invalid case");
-  case BorrowingOperandKind::BeginBorrow:
-  case BorrowingOperandKind::BorrowedFrom: {
+  case BorrowingOperandKind::BorrowedFrom:
+    if (!cast<BorrowedFromInst>(op->getUser())->isReborrow()) {
+      return visitUnknownUse(op);
+    }
+    LLVM_FALLTHROUGH;
+  case BorrowingOperandKind::BeginBorrow: {
     bool deadBorrow = true;
     for (auto *use : cast<SingleValueInstruction>(op->getUser())->getUses()) {
       if (use->isLifetimeEnding()) {
@@ -713,10 +717,16 @@ bool BorrowingOperand::visitScopeEndingUses(
     return user->visitOnStackLifetimeEnds(visitScopeEnd);
   }
   case BorrowingOperandKind::MarkDependenceNonEscaping: {
-    auto *user = cast<MarkDependenceInst>(op->getUser());
-    assert(user->isNonEscaping() && "escaping dependencies don't borrow");
-    assert(user->getType().isObject() && "borrows only exist for values");
-    return user->visitNonEscapingLifetimeEnds(visitScopeEnd, visitUnknownUse);
+    auto *mdi = cast<MarkDependenceInst>(op->getUser());
+    assert(mdi->isNonEscaping() && "escaping dependencies don't borrow");
+    // MarkDependenceInst::visitNonEscapingLifetimeEnds only makes sense for
+    // owned, escapable, non-address values.
+    if (mdi->getOwnershipKind() == OwnershipKind::Owned
+        && mdi->getType().isObject()
+        && mdi->getType().isEscapable(*mdi->getFunction())) {
+      return mdi->visitNonEscapingLifetimeEnds(visitScopeEnd, visitUnknownUse);
+    }
+    return visitUnknownUse(op);
   }
   case BorrowingOperandKind::BeginAsyncLet: {
     auto user = cast<BuiltinInst>(op->getUser());