Merge pull request swiftlang#30200 from gottesmm/pr-f782df1b8f778cdddc48f8343fb0876f598f9012

[ownership] Remove BranchPropagatedUser.

Author: gottesmm

include/swift/SIL/ApplySite.h

@@ -134,6 +134,9 @@ class ApplySite {
   /// Return the callee operand as a value.
   SILValue getCallee() const { return getCalleeOperand()->get(); }
 
+  /// Return the callee operand.
+  Operand *getCalleeOperand() { FOREACH_IMPL_RETURN(getCalleeOperand()); }
+
   /// Return the callee operand.
   const Operand *getCalleeOperand() const {
     FOREACH_IMPL_RETURN(getCalleeOperand());

include/swift/SIL/BasicBlockUtils.h

@@ -71,13 +71,13 @@ class DeadEndBlocks {
   DeadEndBlocks(const SILFunction *F) : F(F) {}
 
   /// Returns true if \p BB is a dead-end block.
-  bool isDeadEnd(SILBasicBlock *BB) {
+  bool isDeadEnd(const SILBasicBlock *block) {
     if (!isComputed) {
       // Lazily compute the dataflow.
       compute();
       isComputed = true;
     }
-    return ReachableBlocks.count(BB) == 0;
+    return ReachableBlocks.count(block) == 0;
   }
 };
 

include/swift/SIL/BranchPropagatedUser.h

@@ -15,7 +15,6 @@
 
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/LLVM.h"
-#include "swift/SIL/BranchPropagatedUser.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILValue.h"
@@ -29,7 +28,6 @@ class SILInstruction;
 class SILModule;
 class SILValue;
 class DeadEndBlocks;
-class BranchPropagatedUser;
 
 namespace ownership {
 
@@ -167,30 +165,21 @@ class LinearLifetimeChecker {
   /// \p leakingBlocks If non-null a list of blocks where the value was detected
   /// to leak. Can be used to insert missing destroys.
   LinearLifetimeError
-  checkValue(SILValue value, ArrayRef<BranchPropagatedUser> consumingUses,
-             ArrayRef<BranchPropagatedUser> nonConsumingUses,
+  checkValue(SILValue value, ArrayRef<Operand *> consumingUses,
+             ArrayRef<Operand *> nonConsumingUses,
              ownership::ErrorBehaviorKind errorBehavior,
              SmallVectorImpl<SILBasicBlock *> *leakingBlocks = nullptr);
 
   /// Returns true that \p value forms a linear lifetime with consuming uses \p
   /// consumingUses, non consuming uses \p nonConsumingUses. Returns false
   /// otherwise.
-  bool validateLifetime(SILValue value,
-                        ArrayRef<BranchPropagatedUser> consumingUses,
-                        ArrayRef<BranchPropagatedUser> nonConsumingUses) {
+  bool validateLifetime(SILValue value, ArrayRef<Operand *> consumingUses,
+                        ArrayRef<Operand *> nonConsumingUses) {
     return !checkValue(value, consumingUses, nonConsumingUses,
                        ownership::ErrorBehaviorKind::ReturnFalse,
                        nullptr /*leakingBlocks*/)
                 .getFoundError();
   }
-
-  bool validateLifetime(SILValue value,
-                        ArrayRef<SILInstruction *> consumingUses,
-                        ArrayRef<SILInstruction *> nonConsumingUses) {
-    return validateLifetime(
-        value, BranchPropagatedUser::convertFromInstArray(consumingUses),
-        BranchPropagatedUser::convertFromInstArray(nonConsumingUses));
-  }
 };
 
 } // namespace swift

include/swift/SIL/LinearLifetimeChecker.h

@@ -540,7 +540,7 @@ bool memInstMustInitialize(Operand *memOper);
 /// alloc_stack. If the alloc_stack is destroyed in pieces, we do not guarantee
 /// that the list of destroying users is a minimal jointly post-dominating set.
 bool isSingleInitAllocStack(AllocStackInst *asi,
-                            SmallVectorImpl<SILInstruction *> &destroyingUsers);
+                            SmallVectorImpl<Operand *> &destroyingUses);
 
 /// Return true if the given address producer may be the source of a formal
 /// access (a read or write of a potentially aliased, user visible variable).

include/swift/SIL/MemAccessUtils.h

@@ -319,16 +319,15 @@ struct BorrowScopeIntroducingValue {
 
   bool isLocalScope() const { return kind.isLocalScope(); }
 
-  /// Returns true if the passed in set of instructions is completely within the
-  /// lifetime of this borrow introducer.
+  /// Returns true if the passed in set of uses is completely within
+  /// the lifetime of this borrow introducer.
   ///
   /// NOTE: Scratch space is used internally to this method to store the end
   /// borrow scopes if needed.
-  bool
-  areInstructionsWithinScope(ArrayRef<SILInstruction *> instructions,
-                             SmallVectorImpl<SILInstruction *> &scratchSpace,
-                             SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
-                             DeadEndBlocks &deadEndBlocks) const;
+  bool areUsesWithinScope(ArrayRef<Operand *> instructions,
+                          SmallVectorImpl<Operand *> &scratchSpace,
+                          SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
+                          DeadEndBlocks &deadEndBlocks) const;
 
   /// Given a local borrow scope introducer, visit all non-forwarding consuming
   /// users. This means that this looks through guaranteed block arguments.

include/swift/SIL/OwnershipUtils.h

@@ -1875,6 +1875,7 @@ class ApplyInstBase<Impl, Base, false> : public Base {
   /// The operand number of the first argument.
   static unsigned getArgumentOperandNumber() { return NumStaticOperands; }
 
+  Operand *getCalleeOperand() { return &getAllOperands()[Callee]; }
   const Operand *getCalleeOperand() const { return &getAllOperands()[Callee]; }
   SILValue getCallee() const { return getCalleeOperand()->get(); }