[ownership] Centralize the concept of isReborrow on BorrowingOperand.

A reborrow occurs when a Borrowing Operand ends the lifetime of a borrowed value
and propagates forward a new guaranteed value that continues the guaranteed
lifetime of the value.

Author: gottesmm

include/swift/SIL/OwnershipUtils.h

@@ -178,7 +178,9 @@ struct BorrowingOperand {
 
   /// Returns true if this borrow scope operand consumes guaranteed
   /// values and produces a new scope afterwards.
-  bool consumesGuaranteedValues() const {
+  ///
+  /// TODO: tuple, struct, destructure_tuple, destructure_struct.
+  bool isReborrow() const {
     switch (kind) {
     case BorrowingOperandKind::BeginBorrow:
     case BorrowingOperandKind::BeginApply:

lib/SIL/Utils/OwnershipUtils.cpp

@@ -125,15 +125,6 @@ bool swift::isOwnershipForwardingInst(SILInstruction *i) {
   return isOwnershipForwardingValueKind(SILNodeKind(i->getKind()));
 }
 
-bool swift::isReborrowInstruction(const SILInstruction *i) {
-  switch (i->getKind()) {
-  case SILInstructionKind::BranchInst:
-    return true;
-  default:
-    return false;
-  }
-}
-
 //===----------------------------------------------------------------------===//
 //                           Borrowing Operand
 //===----------------------------------------------------------------------===//
@@ -247,7 +238,7 @@ void BorrowingOperand::visitConsumingUsesOfBorrowIntroducingUserResults(
     // single guaranteed scope.
     value.visitLocalScopeEndingUses([&](Operand *valueUser) {
       if (auto subBorrowScopeOp = BorrowingOperand::get(valueUser)) {
-        if (subBorrowScopeOp->consumesGuaranteedValues()) {
+        if (subBorrowScopeOp->isReborrow()) {
           subBorrowScopeOp->visitUserResultConsumingUses(func);
           return;
         }

lib/SIL/Verifier/LinearLifetimeChecker.cpp

@@ -313,7 +313,8 @@ void State::checkForSameBlockUseAfterFree(Operand *consumingUse,
                        }) == userBlock->end()) {
         continue;
       }
-    } else if (isReborrowInstruction(consumingUse->getUser())) {
+    } else if (auto borrowingOperand = BorrowingOperand::get(consumingUse)) {
+      assert(borrowingOperand->isReborrow());
       continue;
     }
 

lib/SIL/Verifier/ReborrowVerifier.cpp

@@ -52,11 +52,9 @@ void ReborrowVerifier::verifyReborrows(BorrowingOperand initialScopedOperand,
     std::tie(borrowLifetimeEndOp, baseVal) = worklist.pop_back_val();
     auto *borrowLifetimeEndUser = borrowLifetimeEndOp->getUser();
 
-    // TODO: Add a ReborrowOperand ADT if we need to treat more instructions as
-    // a reborrow
-    if (!isReborrowInstruction(borrowLifetimeEndUser)) {
+    auto borrowingOperand = BorrowingOperand::get(borrowLifetimeEndOp);
+    if (!borrowingOperand || !borrowingOperand->isReborrow())
       continue;
-    }
 
     if (isVisitedOp(borrowLifetimeEndOp, baseVal))
       continue;

lib/SIL/Verifier/SILOwnershipVerifier.cpp

@@ -354,7 +354,7 @@ bool SILValueOwnershipChecker::gatherUsers(
       // BorrowScopeOperand and if so, add its end scope instructions as
       // implicit regular users of our value.
       if (auto scopedOperand = BorrowingOperand::get(op)) {
-        assert(!scopedOperand->consumesGuaranteedValues());
+        assert(!scopedOperand->isReborrow());
 
         std::function<void(Operand *)> onError = [&](Operand *op) {
           errorBuilder.handleMalformedSIL([&] {