Rename hasPointerEscape -> findPointerEscape

Author: meg-gupta

include/swift/SIL/OwnershipUtils.h

@@ -90,13 +90,13 @@ inline bool isForwardingConsume(SILValue value) {
 //                        Ownership Def-Use Utilities
 //===----------------------------------------------------------------------===//
 
-bool hasPointerEscape(BorrowedValue value);
+bool findPointerEscape(BorrowedValue value);
 
 /// Whether the specified OSSA-lifetime introducer has a pointer escape.
 ///
 /// precondition: \p value introduces an OSSA-lifetime, either a BorrowedValue
 /// can be constructed from it or it's an owned value
-bool hasPointerEscape(SILValue value);
+bool findPointerEscape(SILValue value);
 
 /// Find leaf "use points" of \p guaranteedValue that determine its lifetime
 /// requirement. Return true if no PointerEscape use was found.

lib/SIL/Utils/OwnershipUtils.cpp

@@ -25,7 +25,7 @@
 
 using namespace swift;
 
-bool swift::hasPointerEscape(BorrowedValue original) {
+bool swift::findPointerEscape(BorrowedValue original) {
   ValueWorklist worklist(original->getFunction());
   worklist.push(*original);
 
@@ -68,9 +68,9 @@ bool swift::hasPointerEscape(BorrowedValue original) {
   return false;
 }
 
-bool swift::hasPointerEscape(SILValue original) {
+bool swift::findPointerEscape(SILValue original) {
   if (auto borrowedValue = BorrowedValue(original)) {
-    return hasPointerEscape(borrowedValue);
+    return findPointerEscape(borrowedValue);
   }
   assert(original->getOwnershipKind() == OwnershipKind::Owned);
 
@@ -2312,27 +2312,27 @@ bool swift::isRedundantMoveValue(MoveValueInst *mvi) {
   //
   // Check this in two ways, one cheaper than the other.
 
-  // First, avoid calling hasPointerEscape(original).
+  // First, avoid calling findPointerEscape(original).
   //
   // If the original value is not a phi (a phi's incoming values might have
   // escaping uses) and its only user is the move, then it doesn't escape. Also
   // if its only user is the move, then its only _consuming_ user is the move.
   auto *singleUser =
       original->getSingleUse() ? original->getSingleUse()->getUser() : nullptr;
   if (mvi == singleUser && !SILArgument::asPhi(original)) {
-    assert(!hasPointerEscape(original));
+    assert(!findPointerEscape(original));
     assert(original->getSingleConsumingUse()->getUser() == mvi);
     // - !escaping(original)
     // - singleConsumingUser(original) == move
     return true;
   }
 
-  // Second, call hasPointerEscape(original).
+  // Second, call findPointerEscape(original).
   //
   // Explicitly check both
   // - !escaping(original)
   // - singleConsumingUser(original) == move
-  auto originalHasEscape = hasPointerEscape(original);
+  auto originalHasEscape = findPointerEscape(original);
   auto *singleConsumingUser = original->getSingleConsumingUse()
                                   ? original->getSingleConsumingUse()->getUser()
                                   : nullptr;
@@ -2341,6 +2341,6 @@ bool swift::isRedundantMoveValue(MoveValueInst *mvi) {
   }
 
   // (3) Escaping matches?  (Expensive check, saved for last.)
-  auto moveHasEscape = hasPointerEscape(mvi);
+  auto moveHasEscape = findPointerEscape(mvi);
   return moveHasEscape == originalHasEscape;
 }

lib/SILOptimizer/SemanticARC/CopyValueOpts.cpp

@@ -511,7 +511,7 @@ static bool tryJoinIfDestroyConsumingUseInSameBlock(
   // Check whether the uses considered immediately above are all effectively
   // instantaneous uses. Pointer escapes propagate values ways that may not be
   // discoverable.
-  if (hasPointerEscape(operand)) {
+  if (findPointerEscape(operand)) {
     return false;
   }
 

lib/SILOptimizer/Transforms/DeadCodeElimination.cpp

@@ -277,7 +277,7 @@ void DCE::markLive() {
       case SILInstructionKind::DestroyValueInst: {
         auto phi = PhiValue(I.getOperand(0));
         // Disable DCE of phis which are lexical or may have a pointer escape.
-        if (phi && (phi->isLexical() || hasPointerEscape(phi))) {
+        if (phi && (phi->isLexical() || findPointerEscape(phi))) {
           markInstructionLive(&I);
         }
         // The instruction is live only if it's operand value is also live
@@ -287,7 +287,7 @@ void DCE::markLive() {
       case SILInstructionKind::EndBorrowInst: {
         auto phi = PhiValue(I.getOperand(0));
         // If there is a pointer escape or phi is lexical, disable DCE.
-        if (phi && (hasPointerEscape(phi) || phi->isLexical())) {
+        if (phi && (findPointerEscape(phi) || phi->isLexical())) {
           markInstructionLive(&I);
         }
         // The instruction is live only if it's operand value is also live

lib/SILOptimizer/UtilityPasses/UnitTestRunner.cpp

@@ -281,7 +281,7 @@ struct OwnershipUtilsHasPointerEscape : UnitTest {
   OwnershipUtilsHasPointerEscape(UnitTestRunner *pass) : UnitTest(pass) {}
   void invoke(Arguments &arguments) override {
     auto value = arguments.takeValue();
-    auto has = hasPointerEscape(value);
+    auto has = findPointerEscape(value);
     value->print(llvm::errs());
     auto *boolString = has ? "true" : "false";
     llvm::errs() << boolString << "\n";