standardize BasicBlockWorkqueue

The pattern of using a breadth-first traversal over a
control-flow graph shows up in a few places within the
SIL optimizer, so this data-structure unifies those
manually-implemented traversals into a common utility.

Author: kavon

include/swift/SIL/BasicBlockDatastructures.h

@@ -19,6 +19,7 @@
 
 #include "swift/SIL/StackList.h"
 #include "swift/SIL/BasicBlockBits.h"
+#include <deque>
 
 namespace swift {
 
@@ -61,10 +62,12 @@ class BasicBlockSetVector {
   }
 };
 
-/// A utility for processing basic blocks in a worklist.
+/// A utility for processing basic blocks in a worklist that uses
+/// last-in-first-out order.
 ///
-/// It is basically a combination of a block vector and a block set. It can be
-/// used for typical worklist-processing algorithms.
+/// It is basically a combination of a stack list and a block set. It can be
+/// used for typical worklist-processing algorithms and is recommended in
+/// nearly all situations as its implementation is well-optimized.
 class BasicBlockWorklist {
   StackList<SILBasicBlock *> worklist;
   BasicBlockSet visited;
@@ -119,6 +122,70 @@ class BasicBlockWorklist {
   bool isVisited(SILBasicBlock *block) const { return visited.contains(block); }
 };
 
+
+/// A utility for processing basic blocks in a work-queue that uses
+/// first-in-first-out order.
+///
+/// It is basically a combination of a std::deque and a block set. It can be
+/// used for certain kinds of worklist-processing algorithms.
+///
+/// When in doubt, you should reach for a BasicBlockWorklist instead.
+class BasicBlockWorkqueue {
+  std::deque<SILBasicBlock*> workqueue;
+  BasicBlockSet visited;
+
+public:
+  /// Construct an empty workqueue.
+  BasicBlockWorkqueue(SILFunction *function)
+      : workqueue(), visited(function) {}
+
+  /// Initialize the workqueue with \p initialBlock.
+  BasicBlockWorkqueue(SILBasicBlock *initialBlock)
+      : BasicBlockWorkqueue(initialBlock->getParent()) {
+    push(initialBlock);
+  }
+
+  /// Pops the next element from the front of the workqueue or returns null,
+  /// if the workqueue is empty.
+  SILBasicBlock *pop() {
+    if (workqueue.empty())
+      return nullptr;
+    SILBasicBlock *block = workqueue.front();
+    workqueue.pop_front();
+    return block;
+  }
+
+  /// Pushes \p block onto the end of the workqueue if \p block has never been
+  /// pushed before.
+  bool pushIfNotVisited(SILBasicBlock *block) {
+    if (visited.insert(block)) {
+      workqueue.push_back(block);
+      return true;
+    }
+    return false;
+  }
+
+  /// Like `pushIfNotVisited`, but requires that \p block has never been on the
+  /// workqueue before.
+  void push(SILBasicBlock *block) {
+    assert(!visited.contains(block));
+    visited.insert(block);
+    workqueue.push_back(block);
+  }
+
+  /// Like `pop`, but marks the returned block as "unvisited". This means, that
+  /// the block can be pushed onto the queue again.
+  SILBasicBlock *popAndForget() {
+    SILBasicBlock *block = pop();
+    if (block)
+      visited.erase(block);
+    return block;
+  }
+
+  /// Returns true if \p block was visited, i.e. has been added to the workqueue
+  bool isVisited(SILBasicBlock *block) const { return visited.contains(block); }
+};
+
 } // namespace swift
 
 #endif