[SIL] NFC: Replace boilerplate projection with swift::ArrayRefView

Author: davezarzycki

include/swift/Basic/ArrayRefView.h

@@ -44,6 +44,7 @@ class ArrayRefView {
     typedef std::random_access_iterator_tag iterator_category;
 
     Projected operator*() const { return Project(*Ptr); }
+    Projected operator->() const { return operator*(); }
     iterator &operator++() { Ptr++; return *this; }
     iterator operator++(int) { return iterator(Ptr++); }
     bool operator==(iterator rhs) const { return Ptr == rhs.Ptr; }

include/swift/SIL/SILValue.h

@@ -18,6 +18,7 @@
 #define SWIFT_SIL_SILVALUE_H
 
 #include "swift/Basic/Range.h"
+#include "swift/Basic/ArrayRefView.h"
 #include "swift/SIL/SILNode.h"
 #include "swift/SIL/SILType.h"
 #include "llvm/ADT/ArrayRef.h"
@@ -419,64 +420,10 @@ class Operand {
 ///
 /// The intent is that this should basically act exactly like
 /// ArrayRef except projecting away the Operand-ness.
-class OperandValueArrayRef {
-  ArrayRef<Operand> Operands;
-public:
-  explicit OperandValueArrayRef(ArrayRef<Operand> operands)
-    : Operands(operands) {}
-
-  /// A simple iterator adapter.
-  class iterator : public std::iterator<std::forward_iterator_tag,
-                                        SILValue, ptrdiff_t> {
-    const Operand *Ptr;
-  public:
-    iterator() = default;
-    iterator(const Operand *ptr) : Ptr(ptr) {}
-    SILValue operator*() const { assert(Ptr); return Ptr->get(); }
-    SILValue operator->() const { return operator*(); }
-    iterator &operator++() { ++Ptr; return *this; }
-    iterator operator++(int) { iterator copy = *this; ++Ptr; return copy; }
-
-    friend bool operator==(iterator lhs, iterator rhs) {
-      return lhs.Ptr == rhs.Ptr;
-    }
-    friend bool operator!=(iterator lhs, iterator rhs) {
-      return lhs.Ptr != rhs.Ptr;
-    }
-  };
-
-  iterator begin() const { return iterator(Operands.begin()); }
-  iterator end() const { return iterator(Operands.end()); }
-  size_t size() const { return Operands.size(); }
-  bool empty() const { return Operands.empty(); }
-
-  SILValue front() const { return Operands.front().get(); }
-  SILValue back() const { return Operands.back().get(); }
-
-  SILValue operator[](unsigned i) const { return Operands[i].get(); }
-  OperandValueArrayRef slice(unsigned begin, unsigned length) const {
-    return OperandValueArrayRef(Operands.slice(begin, length));
-  }
-  OperandValueArrayRef slice(unsigned begin) const {
-    return OperandValueArrayRef(Operands.slice(begin));
-  }
-  OperandValueArrayRef drop_back() const {
-    return OperandValueArrayRef(Operands.drop_back());
-  }
-
-  bool operator==(const OperandValueArrayRef RHS) const {
-    if (size() != RHS.size())
-      return false;
-    for (auto L = begin(), LE = end(), R = RHS.begin(); L != LE; ++L, ++R)
-      if (*L != *R)
-        return false;
-    return true;
-  }
-
-  bool operator!=(const OperandValueArrayRef RHS) const {
-    return !(*this == RHS);
-  }
-};
+inline SILValue getSILValueType(const Operand &op) {
+  return op.get();
+}
+typedef ArrayRefView<Operand,SILValue,getSILValueType> OperandValueArrayRef;
 
 /// An iterator over all uses of a ValueBase.
 class ValueBaseUseIterator : public std::iterator<std::forward_iterator_tag,

lib/SIL/SILInstructions.cpp

@@ -1309,7 +1309,6 @@ SELECT_ENUM_INST *SelectEnumInstBase::createSelectEnum(
   // Allocate enough room for the instruction with tail-allocated
   // EnumElementDecl and operand arrays. There are `CaseBBs.size()` decls
   // and `CaseBBs.size() + (DefaultBB ? 1 : 0)` values.
-  unsigned numCases = DeclsAndValues.size();
   SmallVector<SILValue, 4> CaseValues;
   SmallVector<EnumElementDecl*, 4> CaseDecls;
   for (auto &pair : DeclsAndValues) {

lib/SILOptimizer/Transforms/SimplifyCFG.cpp

@@ -360,7 +360,8 @@ class ThreadInfo {
                "Argument types must match");
         Builder.createBranch(SEI->getLoc(), ThreadedSuccessorBlock, {UED});
       } else
-        Builder.createBranch(SEI->getLoc(), ThreadedSuccessorBlock, {});
+        Builder.createBranch(SEI->getLoc(), ThreadedSuccessorBlock,
+                             ArrayRef<SILValue>());
       SEI->eraseFromParent();
 
       // Split the edge from 'Dest' to 'ThreadedSuccessorBlock' it is now
@@ -2123,7 +2124,8 @@ bool SimplifyCFG::simplifyTermWithIdenticalDestBlocks(SILBasicBlock *BB) {
 
   TermInst *Term = BB->getTerminator();
   DEBUG(llvm::dbgs() << "replace term with identical dests: " << *Term);
-  SILBuilderWithScope(Term).createBranch(Term->getLoc(), commonDest, {});
+  SILBuilderWithScope(Term).createBranch(Term->getLoc(), commonDest,
+                                         ArrayRef<SILValue>());
   Term->eraseFromParent();
   addToWorklist(BB);
   addToWorklist(commonDest);