Rename visitExtendedLocalScopeEndingUses

To visitExtendedScopeEndingUses.

We need to talk about the "local" scope, which does not cross
reborrows, in contrast to the extended scope. So the name was a
contradiction that could cause confusion elsewhere.

Author: atrick

include/swift/SIL/OwnershipUtils.h

@@ -150,7 +150,7 @@ bool findTransitiveGuaranteedUses(SILValue guaranteedValue,
 /// 1. If \p guaranteedValue introduces a borrow scope (begin_borrow,
 /// load_borrow, or phi), then its only use points are the extended scope-ending
 /// uses, and this function returns true. This is, in fact, equivalent to
-/// calling BorrowedValue::visitExtendedLocalScopeEndingUses().
+/// calling BorrowedValue::visitExtendedScopeEndingUses().
 ///
 /// 2. If \p guaranteedValue does not introduce a borrow scope (it is not a
 /// valid BorrowedValue), then its uses are discovered transitively by looking
@@ -320,8 +320,6 @@ struct BorrowingOperand {
   /// BorrowingOperand.
   ///
   /// Returns false and early exits if the visitor \p func returns false.
-  ///
-  /// Note: this does not visit the intermediate reborrows.
   bool visitExtendedScopeEndingUses(function_ref<bool(Operand *)> func) const;
 
   /// Returns true if this borrow scope operand consumes guaranteed
@@ -504,7 +502,7 @@ struct InteriorPointerOperand;
 /// jointly post-dominate this value (see visitLocalScopeEndingUses()). The
 /// extended scope, including reborrows has end points that are not dominated by
 /// this value but still jointly post-dominate (see
-/// visitExtendedLocalScopeEndingUses()).
+/// visitExtendedScopeEndingUses()).
 struct BorrowedValue {
   SILValue value;
   BorrowedValueKind kind = BorrowedValueKind::Invalid;
@@ -563,8 +561,8 @@ struct BorrowedValue {
   /// Given a local borrow scope introducer, visit all non-forwarding consuming
   /// users. This means that this looks through guaranteed block arguments. \p
   /// visitor is *not* called on Reborrows, only on final scope ending uses.
-  bool visitExtendedLocalScopeEndingUses(
-      function_ref<bool(Operand *)> visitor) const;
+  bool
+  visitExtendedScopeEndingUses(function_ref<bool(Operand *)> visitor) const;
 
   void print(llvm::raw_ostream &os) const;
   SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }

lib/SIL/Utils/OwnershipUtils.cpp

@@ -244,7 +244,7 @@ findInnerTransitiveGuaranteedUses(SILValue guaranteedValue,
 // Find all use points of \p guaranteedValue within its borrow scope. All use
 // points will be dominated by \p guaranteedValue.
 //
-// Record (non-nested) reborrows as uses and call \p visitReborrow.
+// Record (non-nested) reborrows as uses.
 //
 // BorrowedValues (which introduce a borrow scope) are fundamentally different
 // than "inner" guaranteed values. Their only use points are their scope-ending
@@ -418,14 +418,15 @@ bool BorrowingOperand::visitScopeEndingUses(
 }
 
 bool BorrowingOperand::visitExtendedScopeEndingUses(
-    function_ref<bool(Operand *)> func) const {
+    function_ref<bool(Operand *)> visitor) const {
+
   if (hasBorrowIntroducingUser()) {
     return visitBorrowIntroducingUserResults(
-        [func](BorrowedValue borrowedValue) {
-          return borrowedValue.visitExtendedLocalScopeEndingUses(func);
+        [visitor](BorrowedValue borrowedValue) {
+          return borrowedValue.visitExtendedScopeEndingUses(visitor);
         });
   }
-  return visitScopeEndingUses(func);
+  return visitScopeEndingUses(visitor);
 }
 
 bool BorrowingOperand::visitBorrowIntroducingUserResults(
@@ -598,8 +599,8 @@ bool BorrowedValue::areUsesWithinLocalScope(
 }
 
 // The visitor \p func is only called on final scope-ending uses, not reborrows.
-bool BorrowedValue::visitExtendedLocalScopeEndingUses(
-    function_ref<bool(Operand *)> func) const {
+bool BorrowedValue::visitExtendedScopeEndingUses(
+    function_ref<bool(Operand *)> visitor) const {
   assert(isLocalScope());
 
   SmallPtrSetVector<SILValue, 4> reborrows;
@@ -613,7 +614,7 @@ bool BorrowedValue::visitExtendedLocalScopeEndingUses(
         });
       return true;
     }
-    return func(scopeEndingUse);
+    return visitor(scopeEndingUse);
   };
 
   if (!visitLocalScopeEndingUses(visitEnd))