[analyzer] [NFC] Remove unused method visitItemsInWorkList and the corresponding interface

[NoQ]

I've no idea what it was meant to do.

include/clang/StaticAnalyzer/Core/PathSensitive/WorkList.h

void enqueue(ExplodedNode *N) {
     enqueue(WorkListUnit(N, CurrentCounter));
   }
 
   virtual WorkListUnit dequeue() = 0;
 
   void setBlockCounter(BlockCounter C) { CurrentCounter = C; }
   BlockCounter getBlockCounter() const { return CurrentCounter; }
 
-  class Visitor {
-  public:
-    Visitor() {}
-    virtual ~Visitor();
-    virtual bool visit(const WorkListUnit &U) = 0;
-  };
-  virtual bool visitItemsInWorkList(Visitor &V) = 0;
-  
   static WorkList *makeDFS();
   static WorkList *makeBFS();
   static WorkList *makeBFSBlockDFSContents();
 };
 
 } // end GR namespace
 
 } // end clang namespace
 
 #endif

lib/StaticAnalyzer/Core/CoreEngine.cpp

STATISTIC(NumReachedMaxSteps,
             "The # of times we reached the max number of steps.");
 STATISTIC(NumPathsExplored,
             "The # of paths explored by the analyzer.");
 
 //===----------------------------------------------------------------------===//
 // Worklist classes for exploration of reachable states.
 //===----------------------------------------------------------------------===//
 
-WorkList::Visitor::~Visitor() {}
-
 namespace {
 class DFS : public WorkList {
   SmallVector<WorkListUnit,20> Stack;
 public:
   bool hasWork() const override {
     return !Stack.empty();
   }
 
   void enqueue(const WorkListUnit& U) override {
     Stack.push_back(U);
   }
 
   WorkListUnit dequeue() override {
     assert (!Stack.empty());
     const WorkListUnit& U = Stack.back();
     Stack.pop_back(); // This technically "invalidates" U, but we are fine.
     return U;
   }
-
-  bool visitItemsInWorkList(Visitor &V) override {
-    for (SmallVectorImpl<WorkListUnit>::iterator
-         I = Stack.begin(), E = Stack.end(); I != E; ++I) {
-      if (V.visit(*I))
-        return true;
-    }
-    return false;
-  }
 };
 
 class BFS : public WorkList {
   std::deque<WorkListUnit> Queue;
 public:
   bool hasWork() const override {
     return !Queue.empty();
   }
 
   void enqueue(const WorkListUnit& U) override {
     Queue.push_back(U);
   }
 
   WorkListUnit dequeue() override {
     WorkListUnit U = Queue.front();
     Queue.pop_front();
     return U;
   }
 
-  bool visitItemsInWorkList(Visitor &V) override {
-    for (std::deque<WorkListUnit>::iterator
-         I = Queue.begin(), E = Queue.end(); I != E; ++I) {
-      if (V.visit(*I))
-        return true;
-    }
-    return false;
-  }
 };
 
 } // end anonymous namespace
 
 // Place the dstor for WorkList here because it contains virtual member
 // functions, and we the code for the dstor generated in one compilation unit.
 WorkList::~WorkList() {}
 
WorkListUnit dequeue() override {
 
       assert(!Queue.empty());
       // Don't use const reference.  The subsequent pop_back() might make it
       // unsafe.
       WorkListUnit U = Queue.front();
       Queue.pop_front();
       return U;
     }
-    bool visitItemsInWorkList(Visitor &V) override {
-      for (SmallVectorImpl<WorkListUnit>::iterator
-           I = Stack.begin(), E = Stack.end(); I != E; ++I) {
-        if (V.visit(*I))
-          return true;
-      }
-      for (std::deque<WorkListUnit>::iterator
-           I = Queue.begin(), E = Queue.end(); I != E; ++I) {
-        if (V.visit(*I))
-          return true;
-      }
-      return false;
-    }
-
   };
 } // end anonymous namespace
 
 WorkList* WorkList::makeBFSBlockDFSContents() {
   return new BFSBlockDFSContents();
 }
 
 //===----------------------------------------------------------------------===//