Make PrunedLiveness::computeSimple one-level transitive

Computing simple liveness is distinct from computing transitive
liveness. But for safety and consistency, always handle the first
level of liveness transitively. This way, computeSimple can be used on
guaranteed values that need OSSA lifetime fixup.

Simple liveness just means that *inner* borrow and address scopes are
assumed to be complete.

This utility is still only used conservatively because OSSA lifetime
completion is not yet enabled. But, in the future, computeSimple can
be used in the common case.

Author: atrick

include/swift/SIL/PrunedLiveness.h

@@ -457,7 +457,7 @@ class PrunedLiveness {
   /// like an instantaneous use. But if \p operand "borrows" a value for the
   /// duration of a scoped address (store_borrow), then update liveness for the
   /// entire scope. This assumes that nested OSSA lifetimes are complete.
-  void checkAndUpdateInteriorPointer(Operand *operand);
+  AddressUseKind checkAndUpdateInteriorPointer(Operand *operand);
 
   /// Update this liveness to extend across the given liveness.
   void extendAcrossLiveness(PrunedLiveness &otherLiveness);

lib/SIL/Utils/OwnershipUtils.cpp

@@ -1087,7 +1087,7 @@ bool AddressOwnership::areUsesWithinLifetime(
   SILValue root = base.getOwnershipReferenceRoot();
   BorrowedValue borrow(root);
   if (borrow)
-    return borrow.areUsesWithinExtendedTransitiveScope(uses, &deadEndBlocks);
+    return borrow.areUsesWithinExtendedScope(uses, &deadEndBlocks);
 
   // --- A reference with no borrow scope! Currently happens for project_box.
 

lib/SIL/Utils/PrunedLiveness.cpp

@@ -133,7 +133,7 @@ InnerBorrowKind PrunedLiveness::updateForBorrowingOperand(Operand *operand) {
   return InnerBorrowKind::Contained;
 }
 
-void PrunedLiveness::checkAndUpdateInteriorPointer(Operand *operand) {
+AddressUseKind PrunedLiveness::checkAndUpdateInteriorPointer(Operand *operand) {
   assert(operand->getOperandOwnership() == OperandOwnership::InteriorPointer);
 
   if (auto *svi = dyn_cast<SingleValueInstruction>(operand->getUser())) {
@@ -142,10 +142,17 @@ void PrunedLiveness::checkAndUpdateInteriorPointer(Operand *operand) {
         updateForUse(end->getUser(), /*lifetimeEnding*/ false);
         return true;
       });
-      return;
+      return AddressUseKind::NonEscaping;
     }
   }
-  updateForUse(operand->getUser(), /*lifetimeEnding*/ false);
+  // FIXME: findTransitiveUses should be a visitor so we're not recursively
+  // allocating use vectors and potentially merging the use points.
+  SmallVector<Operand *, 8> uses;
+  auto useKind = InteriorPointerOperand(operand).findTransitiveUses(&uses);
+  for (auto *use : uses) {
+    updateForUse(use->getUser(), /*lifetimeEnding*/ false);
+  }
+  return useKind;
 }
 
 void PrunedLiveness::extendAcrossLiveness(PrunedLiveness &otherLivesness) {
@@ -276,8 +283,18 @@ SimpleLiveRangeSummary PrunedLiveRange<LivenessWithDefs>::updateForDef(SILValue
       summary.meet(AddressUseKind::PointerEscape);
       break;
     case OperandOwnership::InteriorPointer:
-      checkAndUpdateInteriorPointer(use);
+      summary.meet(checkAndUpdateInteriorPointer(use));
       break;
+    case OperandOwnership::ForwardingBorrow: {
+      ForwardingOperand(use).visitForwardedValues([&](SILValue result) {
+        // Do not include transitive uses with 'none' ownership
+        if (result->getOwnershipKind() != OwnershipKind::None) {
+          updateForDef(result);
+        }
+        return true;
+      });
+      break;
+    }
     default:
       updateForUse(use->getUser(), use->isLifetimeEnding());
       break;