[sil] Rename SILSuccessorIterator -> SILSuccessor::pred_iterator.

This iterator is not actually a SILSuccessorIterator since it is not iterating
over the "successors" of a block. Instead it is used to given the head of a CFG
edge, iterate over the CFG edge's predecessors using the double linked list
stored inside SILSuccessor.

This rename/refactor ties SILSuccessor closer to SILSuccessorIterator and makes
it clear what we are actually iterating over.

Author: gottesmm

include/swift/SIL/SILBasicBlock.h

@@ -286,7 +286,7 @@ public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
     return makeTransformRange(getSuccessors(), F);
   }
 
-  using pred_iterator = SILSuccessorIterator;
+  using pred_iterator = SILSuccessor::pred_iterator;
 
   bool pred_empty() const { return PredList == nullptr; }
   pred_iterator pred_begin() const { return pred_iterator(PredList); }

include/swift/SIL/SILSuccessor.h

@@ -34,8 +34,6 @@ class TermInst;
 /// predecessors. This is done by using an ilist that is embedded into
 /// SILSuccessors.
 class SILSuccessor {
-  friend class SILSuccessorIterator;
-
   /// The terminator instruction that contains this SILSuccessor.
   TermInst *ContainingInst = nullptr;
 
@@ -78,41 +76,40 @@ class SILSuccessor {
   // Do not copy or move these.
   SILSuccessor(const SILSuccessor &) = delete;
   SILSuccessor(SILSuccessor &&) = delete;
-};
-  
-/// SILSuccessorIterator - This is an iterator for walking the successor list of
-/// a SILBasicBlock.
-class SILSuccessorIterator {
-  SILSuccessor *Cur;
-public:
-  using difference_type = std::ptrdiff_t;
-  using value_type = SILBasicBlock *;
-  using pointer = SILBasicBlock **;
-  using reference = SILBasicBlock *&;
-  using iterator_category = std::forward_iterator_tag;
-  
-  SILSuccessorIterator(SILSuccessor *Cur = 0) : Cur(Cur) {}
-  
-  bool operator==(SILSuccessorIterator I2) const { return Cur == I2.Cur; }
-  bool operator!=(SILSuccessorIterator I2) const { return Cur != I2.Cur; }
 
-  SILSuccessorIterator &operator++() {
-    assert(Cur && "Trying to advance past end");
-    Cur = Cur->Next;
-    return *this;
-  }
-
-  SILSuccessorIterator operator++(int) {
-    SILSuccessorIterator copy = *this;
-    ++*this;
-    return copy;
-  }
-
-  SILSuccessor *getSuccessorRef() const { return Cur; }
-  SILBasicBlock *operator*();
-  const SILBasicBlock *operator*() const;
+  /// This is an iterator for walking the predecessor list of a SILBasicBlock.
+  class pred_iterator {
+    SILSuccessor *Cur;
+
+  public:
+    using difference_type = std::ptrdiff_t;
+    using value_type = SILBasicBlock *;
+    using pointer = SILBasicBlock **;
+    using reference = SILBasicBlock *&;
+    using iterator_category = std::forward_iterator_tag;
+
+    pred_iterator(SILSuccessor *Cur = 0) : Cur(Cur) {}
+
+    bool operator==(pred_iterator I2) const { return Cur == I2.Cur; }
+    bool operator!=(pred_iterator I2) const { return Cur != I2.Cur; }
+
+    pred_iterator &operator++() {
+      assert(Cur && "Trying to advance past end");
+      Cur = Cur->Next;
+      return *this;
+    }
+
+    pred_iterator operator++(int) {
+      pred_iterator copy = *this;
+      ++*this;
+      return copy;
+    }
+
+    SILSuccessor *getSuccessorRef() const { return Cur; }
+    SILBasicBlock *operator*();
+    const SILBasicBlock *operator*() const;
+  };
 };
-  
 
 } // end swift namespace
 

lib/SIL/SILSuccessor.cpp

@@ -38,14 +38,14 @@ void SILSuccessor::operator=(SILBasicBlock *BB) {
   SuccessorBlock = BB;
 }
 
-// Dereferencing the SuccIterator returns the predecessor's SILBasicBlock.
-SILBasicBlock *SILSuccessorIterator::operator*() {
+// Dereferencing the pred_iterator returns the predecessor's SILBasicBlock.
+SILBasicBlock *SILSuccessor::pred_iterator::operator*() {
   assert(Cur && "Can't deference end (or default constructed) iterator");
   return Cur->ContainingInst->getParent();
 }
 
-// Dereferencing the SuccIterator returns the predecessor's SILBasicBlock.
-const SILBasicBlock *SILSuccessorIterator::operator*() const {
+// Dereferencing the pred_iterator returns the predecessor's SILBasicBlock.
+const SILBasicBlock *SILSuccessor::pred_iterator::operator*() const {
   assert(Cur && "Can't deference end (or default constructed) iterator");
   return Cur->ContainingInst->getParent();
 }