[CFG] Add iterator_ranges to CFG and CFGBlock.

[mboehme]

Summary

(Needed for D23353.)

[mboehme]

Re-add inadvertently deleted blank line

[alexfh]

include/clang/Analysis/CFG.h

526

Most of the time the new functions will be used in a range-based for loop. I don't think the type returned by the functions will need to be explicitly specified anywhere. I'd remove the typedefs.

[alexfh]

Actually, there's just one comment. Otherwise it's looking good.

[mboehme]

include/clang/Analysis/CFG.h

526

I agree the typedefs will probably never be used outside this class, but typedefs for iterator_ranges seem to be a common pattern in the Clang codebase. (EnumDecl::enumerator_range and CallExpr::arg_range are two random examples.) I assume the intent is to make the definition of the functions that return these ranges less verbose.

Are you OK with me submitting this patch as-is (with the typedefs)?

[alexfh]

include/clang/Analysis/CFG.h

526

Makes sense.

include/clang/Analysis/CFG.h

 
 #include "clang/AST/Stmt.h"
 #include "clang/Analysis/Support/BumpVector.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/GraphTraits.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerIntPair.h"
+#include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/raw_ostream.h"
 #include <bitset>
 #include <cassert>
 #include <iterator>
 #include <memory>
 
public:
 
   CFGElement operator[](size_t i) const  { return Elements[i]; }
 
   // CFG iterators
   typedef AdjacentBlocks::iterator                              pred_iterator;
   typedef AdjacentBlocks::const_iterator                  const_pred_iterator;
   typedef AdjacentBlocks::reverse_iterator              pred_reverse_iterator;
   typedef AdjacentBlocks::const_reverse_iterator  const_pred_reverse_iterator;
+  typedef llvm::iterator_range<pred_iterator>                      pred_range;
+  typedef llvm::iterator_range<const_pred_iterator>          pred_const_range;
 
   typedef AdjacentBlocks::iterator                              succ_iterator;
   typedef AdjacentBlocks::const_iterator                  const_succ_iterator;
   typedef AdjacentBlocks::reverse_iterator              succ_reverse_iterator;
   typedef AdjacentBlocks::const_reverse_iterator  const_succ_reverse_iterator;
+  typedef llvm::iterator_range<succ_iterator>                      succ_range;
+  typedef llvm::iterator_range<const_succ_iterator>          succ_const_range;
 
   pred_iterator                pred_begin()        { return Preds.begin();   }
   pred_iterator                pred_end()          { return Preds.end();     }
   const_pred_iterator          pred_begin()  const { return Preds.begin();   }
   const_pred_iterator          pred_end()    const { return Preds.end();     }
 
   pred_reverse_iterator        pred_rbegin()       { return Preds.rbegin();  }
   pred_reverse_iterator        pred_rend()         { return Preds.rend();    }
   const_pred_reverse_iterator  pred_rbegin() const { return Preds.rbegin();  }
   const_pred_reverse_iterator  pred_rend()   const { return Preds.rend();    }
 
+  pred_range                   preds() {
+    return pred_range(pred_begin(), pred_end());
+  }
+  pred_const_range             preds() const {
+    return pred_const_range(pred_begin(), pred_end());
+  }
+
   succ_iterator                succ_begin()        { return Succs.begin();   }
   succ_iterator                succ_end()          { return Succs.end();     }
   const_succ_iterator          succ_begin()  const { return Succs.begin();   }
   const_succ_iterator          succ_end()    const { return Succs.end();     }
 
   succ_reverse_iterator        succ_rbegin()       { return Succs.rbegin();  }
   succ_reverse_iterator        succ_rend()         { return Succs.rend();    }
   const_succ_reverse_iterator  succ_rbegin() const { return Succs.rbegin();  }
   const_succ_reverse_iterator  succ_rend()   const { return Succs.rend();    }
 
+  succ_range                   succs() {
+    return succ_range(succ_begin(), succ_end());
+  }
+  succ_const_range             succs() const {
+    return succ_const_range(succ_begin(), succ_end());
+  }
+
   unsigned                     succ_size()   const { return Succs.size();    }
   bool                         succ_empty()  const { return Succs.empty();   }
 
   unsigned                     pred_size()   const { return Preds.size();    }
   bool                         pred_empty()  const { return Preds.empty();   }
 
-
   class FilterOptions {
   public:
     FilterOptions() {
       IgnoreNullPredecessors = 1;
       IgnoreDefaultsWithCoveredEnums = 0;
     }
 
     unsigned IgnoreNullPredecessors : 1;
void addSyntheticDeclStmt(const DeclStmt *Synthetic,
     assert(Synthetic->isSingleDecl() && "Can handle single declarations only");
     assert(Synthetic != Source && "Don't include original DeclStmts in map");
     assert(!SyntheticDeclStmts.count(Synthetic) && "Already in map");
     SyntheticDeclStmts[Synthetic] = Source;
   }
 
   typedef llvm::DenseMap<const DeclStmt *, const DeclStmt *>::const_iterator
     synthetic_stmt_iterator;
+  typedef llvm::iterator_range<synthetic_stmt_iterator> synthetic_stmt_range;
 
   /// Iterates over synthetic DeclStmts in the CFG.
   ///
   /// Each element is a (synthetic statement, source statement) pair.
   ///
   /// \sa addSyntheticDeclStmt
   synthetic_stmt_iterator synthetic_stmt_begin() const {
     return SyntheticDeclStmts.begin();
   }
 
   /// \sa synthetic_stmt_begin
   synthetic_stmt_iterator synthetic_stmt_end() const {
     return SyntheticDeclStmts.end();
   }
 
+  /// \sa synthetic_stmt_begin
+  synthetic_stmt_range synthetic_stmts() const {
+    return synthetic_stmt_range(synthetic_stmt_begin(), synthetic_stmt_end());
+  }
+
   //===--------------------------------------------------------------------===//
   // Member templates useful for various batch operations over CFGs.
   //===--------------------------------------------------------------------===//
 
   template <typename CALLBACK>
   void VisitBlockStmts(CALLBACK& O) const {
     for (const_iterator I=begin(), E=end(); I != E; ++I)
       for (CFGBlock::const_iterator BI=(*I)->begin(), BE=(*I)->end();