[ownership] Rename Operand::isConsumingUse() -> Operand::isLifetimeEnding().

This makes it clearer that isConsumingUse() is not an owned oriented API and
returns also for instructions that end the lifetime of guaranteed values like
end_borrow.

Author: gottesmm

include/swift/SIL/SILValue.h

@@ -700,7 +700,7 @@ class Operand {
 
   /// Returns true if this operand acts as a use that consumes its associated
   /// value.
-  bool isConsumingUse() const {
+  bool isLifetimeEnding() const {
     // Type dependent uses can never be consuming and do not have valid
     // ownership maps since they do not participate in the ownership system.
     if (isTypeDependent())
@@ -795,9 +795,9 @@ class ConsumingUseIterator : public ValueBaseUseIterator {
   explicit ConsumingUseIterator(Operand *cur) : ValueBaseUseIterator(cur) {}
   ConsumingUseIterator &operator++() {
     assert(Cur && "incrementing past end()!");
-    assert(Cur->isConsumingUse());
+    assert(Cur->isLifetimeEnding());
     while ((Cur = Cur->NextUse)) {
-      if (Cur->isConsumingUse())
+      if (Cur->isLifetimeEnding())
         break;
     }
     return *this;
@@ -813,7 +813,7 @@ class ConsumingUseIterator : public ValueBaseUseIterator {
 inline ValueBase::consuming_use_iterator
 ValueBase::consuming_use_begin() const {
   auto cur = FirstUse;
-  while (cur && !cur->isConsumingUse()) {
+  while (cur && !cur->isLifetimeEnding()) {
     cur = cur->NextUse;
   }
   return ValueBase::consuming_use_iterator(cur);
@@ -828,9 +828,9 @@ class NonConsumingUseIterator : public ValueBaseUseIterator {
   explicit NonConsumingUseIterator(Operand *cur) : ValueBaseUseIterator(cur) {}
   NonConsumingUseIterator &operator++() {
     assert(Cur && "incrementing past end()!");
-    assert(!Cur->isConsumingUse());
+    assert(!Cur->isLifetimeEnding());
     while ((Cur = Cur->NextUse)) {
-      if (!Cur->isConsumingUse())
+      if (!Cur->isLifetimeEnding())
         break;
     }
     return *this;
@@ -846,7 +846,7 @@ class NonConsumingUseIterator : public ValueBaseUseIterator {
 inline ValueBase::non_consuming_use_iterator
 ValueBase::non_consuming_use_begin() const {
   auto cur = FirstUse;
-  while (cur && cur->isConsumingUse()) {
+  while (cur && cur->isLifetimeEnding()) {
     cur = cur->NextUse;
   }
   return ValueBase::non_consuming_use_iterator(cur);
@@ -883,7 +883,7 @@ inline Operand *ValueBase::getSingleUse() const {
 inline Operand *ValueBase::getSingleConsumingUse() const {
   Operand *result = nullptr;
   for (auto *op : getUses()) {
-    if (op->isConsumingUse()) {
+    if (op->isLifetimeEnding()) {
       if (result) {
         return nullptr;
       }

lib/SIL/Utils/OwnershipUtils.cpp

@@ -177,7 +177,7 @@ void BorrowingOperand::visitLocalEndScopeInstructions(
   switch (kind) {
   case BorrowingOperandKind::BeginBorrow:
     for (auto *use : cast<BeginBorrowInst>(op->getUser())->getUses()) {
-      if (use->isConsumingUse()) {
+      if (use->isLifetimeEnding()) {
         func(use);
       }
     }
@@ -248,7 +248,7 @@ void BorrowingOperand::visitUserResultConsumingUses(
   if (!ti) {
     for (SILValue result : op->getUser()->getResults()) {
       for (auto *use : result->getUses()) {
-        if (use->isConsumingUse()) {
+        if (use->isLifetimeEnding()) {
           visitor(use);
         }
       }
@@ -259,7 +259,7 @@ void BorrowingOperand::visitUserResultConsumingUses(
   for (auto *succBlock : ti->getSuccessorBlocks()) {
     auto *arg = succBlock->getArgument(op->getOperandNumber());
     for (auto *use : arg->getUses()) {
-      if (use->isConsumingUse()) {
+      if (use->isLifetimeEnding()) {
         visitor(use);
       }
     }
@@ -311,8 +311,8 @@ void BorrowedValue::getLocalScopeEndingInstructions(
   case BorrowedValueKind::LoadBorrow:
   case BorrowedValueKind::Phi:
     for (auto *use : value->getUses()) {
-      if (use->isConsumingUse()) {
-	scopeEndingInsts.push_back(use->getUser());
+      if (use->isLifetimeEnding()) {
+        scopeEndingInsts.push_back(use->getUser());
       }
     }
     return;
@@ -330,7 +330,7 @@ void BorrowedValue::visitLocalScopeEndingUses(
   case BorrowedValueKind::BeginBorrow:
   case BorrowedValueKind::Phi:
     for (auto *use : value->getUses()) {
-      if (use->isConsumingUse()) {
+      if (use->isLifetimeEnding()) {
         visitor(use);
       }
     }
@@ -385,7 +385,7 @@ bool BorrowedValue::visitLocalScopeTransitiveEndingUses(
   SmallVector<Operand *, 32> worklist;
   SmallPtrSet<Operand *, 16> beenInWorklist;
   for (auto *use : value->getUses()) {
-    if (!use->isConsumingUse())
+    if (!use->isLifetimeEnding())
       continue;
     worklist.push_back(use);
     beenInWorklist.insert(use);
@@ -394,7 +394,7 @@ bool BorrowedValue::visitLocalScopeTransitiveEndingUses(
   bool foundError = false;
   while (!worklist.empty()) {
     auto *op = worklist.pop_back_val();
-    assert(op->isConsumingUse() && "Expected only consuming uses");
+    assert(op->isLifetimeEnding() && "Expected only consuming uses");
 
     // See if we have a borrow scope operand. If we do not, then we know we are
     // a final consumer of our borrow scope introducer. Visit it and continue.
@@ -406,7 +406,7 @@ bool BorrowedValue::visitLocalScopeTransitiveEndingUses(
 
     scopeOperand->visitConsumingUsesOfBorrowIntroducingUserResults(
         [&](Operand *op) {
-          assert(op->isConsumingUse() && "Expected only consuming uses");
+          assert(op->isLifetimeEnding() && "Expected only consuming uses");
           // Make sure we haven't visited this consuming operand yet. If we
           // have, signal an error and bail without re-visiting the operand.
           if (!beenInWorklist.insert(op).second) {

lib/SIL/Verifier/SILOwnershipVerifier.cpp

@@ -242,7 +242,7 @@ bool SILValueOwnershipChecker::gatherNonGuaranteedUsers(
 
     // First do a quick check if we have a consuming use. If so, stash the value
     // and continue.
-    if (op->isConsumingUse()) {
+    if (op->isLifetimeEnding()) {
       LLVM_DEBUG(llvm::dbgs() << "Lifetime Ending User: " << *user);
       lifetimeEndingUsers.push_back(op);
       continue;
@@ -343,7 +343,7 @@ bool SILValueOwnershipChecker::gatherUsers(
     // Now check if we have a non guaranteed forwarding inst...
     if (!isGuaranteedForwardingInst(user)) {
       // First check if we are visiting an operand that is a consuming use...
-      if (op->isConsumingUse()) {
+      if (op->isLifetimeEnding()) {
         // If its underlying value is our original value, then this is a true
         // lifetime ending use. Otherwise, we have a guaranteed value that has
         // an end_borrow on a forwarded value which is not supported in any

lib/SILOptimizer/SemanticARC/BorrowScopeOpts.cpp

@@ -27,7 +27,7 @@ bool SemanticARCOptVisitor::visitBeginBorrowInst(BeginBorrowInst *bbi) {
   auto kind = bbi->getOperand().getOwnershipKind();
   SmallVector<EndBorrowInst *, 16> endBorrows;
   for (auto *op : bbi->getUses()) {
-    if (!op->isConsumingUse()) {
+    if (!op->isLifetimeEnding()) {
       // Make sure that this operand can accept our arguments kind.
       auto map = op->getOwnershipKindMap();
       if (map.canAcceptKind(kind))

lib/SILOptimizer/SemanticARC/OwnershipLiveRange.cpp

@@ -48,7 +48,7 @@ OwnershipLiveRange::OwnershipLiveRange(SILValue value)
     // can also accept something that is guaranteed. Any non-consuming use of
     // an owned value should be able to take a guaranteed parameter as well
     // (modulo bugs). We assert to catch these.
-    if (!op->isConsumingUse()) {
+    if (!op->isLifetimeEnding()) {
       continue;
     }
 

lib/SILOptimizer/Transforms/CopyPropagation.cpp

@@ -222,7 +222,7 @@ class LivenessInfo {
   //
   // This call cannot be allowed to destroy %val.
   void recordUser(Operand *use) {
-    bool consume = use->isConsumingUse();
+    bool consume = use->isLifetimeEnding();
     auto iterAndSuccess = users.try_emplace(use->getUser(), consume);
     if (!iterAndSuccess.second)
       iterAndSuccess.first->second &= consume;
@@ -429,7 +429,7 @@ static bool computeLiveness(CopyPropagationState &pass) {
         continue;
       }
 
-      if (use->isConsumingUse()) {
+      if (use->isLifetimeEnding()) {
         pass.liveness.recordOriginalDestroy(use);
         // Destroying a values does not force liveness.
         if (isa<DestroyValueInst>(user))
@@ -622,7 +622,7 @@ static void rewriteCopies(CopyPropagationState &pass) {
     }
 
     // Nonconsuming uses do not need copies and cannot be marked as destroys.
-    if (!use->isConsumingUse())
+    if (!use->isLifetimeEnding())
       return;
 
     // If this use was marked as a final destroy *and* this is the first

lib/SILOptimizer/Utils/InstOptUtils.cpp

@@ -403,7 +403,7 @@ static void destroyConsumedOperandOfDeadInst(Operand &operand) {
   assert(!isEndOfScopeMarker(deadInst) && !isa<DestroyValueInst>(deadInst) &&
          !isa<DestroyAddrInst>(deadInst) &&
          "lifetime ending instruction is deleted without its operand");
-  if (operand.isConsumingUse()) {
+  if (operand.isLifetimeEnding()) {
     // Since deadInst cannot be an end-of-scope instruction (asserted above),
     // this must be a consuming use of an owned value.
     assert(operandValue.getOwnershipKind() == ValueOwnershipKind::Owned);