[sil] Add new API ValueBase:getUsersOfType<T>().

For some time now we have had the API ValueBase::getSingleUserOfType<T>() but we
never implemented getUsersOfType<T>() using transform/filter iterators.

Since there wasn't a specific API, several incarnations of this API have been
created for BeginBorrow, LoadBorrow, BeginAccess.

In this commit, I introduce the API and use it to excise the redundant code in
those above mentioned 3 instructions.

Author: gottesmm

include/swift/Basic/STLExtras.h

@@ -578,6 +578,8 @@ class OptionalTransformIterator {
     return *Op(*Current);
   }
 
+  reference operator*() { return *Op(*Current); }
+
   OptionalTransformIterator &operator++() {
     ++Current;
     skipNonMatching();

include/swift/SIL/SILInstruction.h

@@ -3289,16 +3289,6 @@ class StoreInst
 
 class EndBorrowInst;
 
-struct UseToEndBorrow {
-  Optional<EndBorrowInst *> operator()(Operand *use) const {
-    if (auto endBorrow = dyn_cast<EndBorrowInst>(use->getUser())) {
-      return endBorrow;
-    } else {
-      return None;
-    }
-  }
-};
-
 /// Represents a load of a borrowed value. Must be paired with an end_borrow
 /// instruction in its use-def list.
 class LoadBorrowInst :
@@ -3312,14 +3302,14 @@ class LoadBorrowInst :
                              LValue->getType().getObjectType()) {}
 
   using EndBorrowRange =
-      OptionalTransformRange<use_range, UseToEndBorrow, use_iterator>;
+      decltype(std::declval<ValueBase>().getUsersOfType<EndBorrowInst>());
 
   /// Return a range over all EndBorrow instructions for this BeginBorrow.
   EndBorrowRange getEndBorrows() const;
 };
 
 inline auto LoadBorrowInst::getEndBorrows() const -> EndBorrowRange {
-  return EndBorrowRange(getUses(), UseToEndBorrow());
+  return getUsersOfType<EndBorrowInst>();
 }
 
 /// Represents the begin scope of a borrowed value. Must be paired with an
@@ -3335,7 +3325,7 @@ class BeginBorrowInst
 
 public:
   using EndBorrowRange =
-      OptionalTransformRange<use_range, UseToEndBorrow, use_iterator>;
+      decltype(std::declval<ValueBase>().getUsersOfType<EndBorrowInst>());
 
   /// Return a range over all EndBorrow instructions for this BeginBorrow.
   EndBorrowRange getEndBorrows() const;
@@ -3350,7 +3340,7 @@ class BeginBorrowInst
 };
 
 inline auto BeginBorrowInst::getEndBorrows() const -> EndBorrowRange {
-  return EndBorrowRange(getUses(), UseToEndBorrow());
+  return getUsersOfType<EndBorrowInst>();
 }
 
 /// Represents a store of a borrowed value into an address. Returns the borrowed
@@ -3489,6 +3479,8 @@ enum class SILAccessEnforcement : uint8_t {
 };
 StringRef getSILAccessEnforcementName(SILAccessEnforcement enforcement);
 
+class EndAccessInst;
+
 /// Begins an access scope. Must be paired with an end_access instruction
 /// along every path.
 class BeginAccessInst
@@ -3560,13 +3552,8 @@ class BeginAccessInst
     return getOperand();
   }
 
-private:
-    /// Predicate used to filter EndAccessRange.
-  struct UseToEndAccess;
-
-public:
   using EndAccessRange =
-    OptionalTransformRange<use_range, UseToEndAccess, use_iterator>;
+      decltype(std::declval<ValueBase>().getUsersOfType<EndAccessInst>());
 
   /// Find all the associated end_access instructions for this begin_access.
   EndAccessRange getEndAccesses() const;
@@ -3607,18 +3594,8 @@ class EndAccessInst
   }
 };
 
-struct BeginAccessInst::UseToEndAccess {
-  Optional<EndAccessInst *> operator()(Operand *use) const {
-    if (auto access = dyn_cast<EndAccessInst>(use->getUser())) {
-      return access;
-    } else {
-      return None;
-    }
-  }
-};
-
 inline auto BeginAccessInst::getEndAccesses() const -> EndAccessRange {
-  return EndAccessRange(getUses(), UseToEndAccess());
+  return getUsersOfType<EndAccessInst>();
 }
 
 /// Begins an access without requiring a paired end_access.

include/swift/SIL/SILValue.h

@@ -275,6 +275,27 @@ class ValueBase : public SILNode, public SILAllocated<ValueBase> {
   template <class T>
   inline T *getSingleUserOfType() const;
 
+  /// Helper struct for DowncastUserFilterRange
+  struct UseToUser;
+
+  template <typename Subclass>
+  using DowncastUserFilterRange =
+      DowncastFilterRange<Subclass,
+                          llvm::iterator_range<llvm::mapped_iterator<
+                              use_iterator, UseToUser, SILInstruction *>>>;
+
+  /// Iterate over the use list of this ValueBase visiting all users that are of
+  /// class T.
+  ///
+  /// Example:
+  ///
+  ///   ValueBase *v = ...;
+  ///   for (CopyValueInst *cvi : v->getUsersOfType<CopyValueInst>()) { ... }
+  ///
+  /// NOTE: Uses llvm::dyn_cast internally.
+  template <typename T>
+  inline DowncastUserFilterRange<T> getUsersOfType() const;
+
   /// Return the instruction that defines this value, or null if it is
   /// not defined by an instruction.
   const SILInstruction *getDefiningInstruction() const {
@@ -717,6 +738,25 @@ inline T *ValueBase::getSingleUserOfType() const {
   return Result;
 }
 
+struct ValueBase::UseToUser {
+  SILInstruction *operator()(const Operand *use) const {
+    return const_cast<SILInstruction *>(use->getUser());
+  }
+  SILInstruction *operator()(const Operand &use) const {
+    return const_cast<SILInstruction *>(use.getUser());
+  }
+  SILInstruction *operator()(Operand *use) { return use->getUser(); }
+  SILInstruction *operator()(Operand &use) { return use.getUser(); }
+};
+
+template <typename T>
+inline ValueBase::DowncastUserFilterRange<T> ValueBase::getUsersOfType() const {
+  auto begin = llvm::map_iterator(use_begin(), UseToUser());
+  auto end = llvm::map_iterator(use_end(), UseToUser());
+  auto transformRange = llvm::make_range(begin, end);
+  return makeDowncastFilterRange<T>(transformRange);
+}
+
 /// A constant-size list of the operands of an instruction.
 template <unsigned N> class FixedOperandList {
   Operand Buffer[N];