Vendor import of clang trunk r126079:

http://llvm.org/svn/llvm-project/cfe/trunk@126079

1 files changed, 88 insertions, 8 deletions

diff --git a/include/clang/AST/StmtIterator.h b/include/clang/AST/StmtIterator.h
index 4da2e34..851c001 100644
--- a/include/clang/AST/StmtIterator.h
+++ b/include/clang/AST/StmtIterator.h
@@ -1,4 +1,4 @@
-//===--- StmtIterator.h - Iterators for Statements ------------------------===//
+//===--- StmtIterator.h - Iterators for Statements --------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -14,7 +14,7 @@
 #ifndef LLVM_CLANG_AST_STMT_ITR_H
 #define LLVM_CLANG_AST_STMT_ITR_H
 
-#include "llvm/System/DataTypes.h"
+#include "llvm/Support/DataTypes.h"
 #include <cassert>
 #include <cstddef>
 #include <iterator>
@@ -51,11 +51,11 @@ protected:
     return (RawVAPtr & Flags) == 0;
   }
 
-  VariableArrayType* getVAPtr() const {
-    return reinterpret_cast<VariableArrayType*>(RawVAPtr & ~Flags);
+  const VariableArrayType *getVAPtr() const {
+    return reinterpret_cast<const VariableArrayType*>(RawVAPtr & ~Flags);
   }
 
-  void setVAPtr(VariableArrayType* P) {
+  void setVAPtr(const VariableArrayType *P) {
     assert (inDecl() || inDeclGroup() || inSizeOfTypeVA());
     RawVAPtr = reinterpret_cast<uintptr_t>(P) | (RawVAPtr & Flags);
   }
@@ -68,7 +68,7 @@ protected:
 
   StmtIteratorBase(Stmt **s) : stmt(s), decl(0), RawVAPtr(0) {}
   StmtIteratorBase(Decl *d, Stmt **s);
-  StmtIteratorBase(VariableArrayType *t);
+  StmtIteratorBase(const VariableArrayType *t);
   StmtIteratorBase(Decl **dgi, Decl **dge);
   StmtIteratorBase() : stmt(0), decl(0), RawVAPtr(0) {}
 };
@@ -86,7 +86,7 @@ public:
   StmtIteratorImpl(Stmt **s) : StmtIteratorBase(s) {}
   StmtIteratorImpl(Decl **dgi, Decl **dge) : StmtIteratorBase(dgi, dge) {}
   StmtIteratorImpl(Decl *d, Stmt **s) : StmtIteratorBase(d, s) {}
-  StmtIteratorImpl(VariableArrayType* t) : StmtIteratorBase(t) {}
+  StmtIteratorImpl(const VariableArrayType *t) : StmtIteratorBase(t) {}
 
   DERIVED& operator++() {
     if (inDecl() || inDeclGroup()) {
@@ -130,7 +130,7 @@ struct StmtIterator : public StmtIteratorImpl<StmtIterator,Stmt*&> {
   StmtIterator(Decl** dgi, Decl** dge)
    : StmtIteratorImpl<StmtIterator,Stmt*&>(dgi, dge) {}
 
-  StmtIterator(VariableArrayType* t)
+  StmtIterator(const VariableArrayType *t)
     : StmtIteratorImpl<StmtIterator,Stmt*&>(t) {}
 
   StmtIterator(Decl* D, Stmt **s = 0)
@@ -146,6 +146,86 @@ struct ConstStmtIterator : public StmtIteratorImpl<ConstStmtIterator,
     StmtIteratorImpl<ConstStmtIterator,const Stmt*>(RHS) {}
 };
 
+/// A range of statement iterators.
+///
+/// This class provides some extra functionality beyond std::pair
+/// in order to allow the following idiom:
+///   for (StmtRange range = stmt->children(); range; ++range)
+struct StmtRange : std::pair<StmtIterator,StmtIterator> {
+  StmtRange() {}
+  StmtRange(const StmtIterator &begin, const StmtIterator &end)
+    : std::pair<StmtIterator,StmtIterator>(begin, end) {}
+
+  bool empty() const { return first == second; }
+  operator bool() const { return !empty(); }
+
+  Stmt *operator->() const { return first.operator->(); }
+  Stmt *&operator*() const { return first.operator*(); }
+
+  StmtRange &operator++() {
+    assert(!empty() && "incrementing on empty range");
+    ++first;
+    return *this;
+  }
+
+  StmtRange operator++(int) {
+    assert(!empty() && "incrementing on empty range");
+    StmtRange copy = *this;
+    ++first;
+    return copy;
+  }
+
+  friend const StmtIterator &begin(const StmtRange &range) {
+    return range.first;
+  }
+  friend const StmtIterator &end(const StmtRange &range) {
+    return range.second;
+  }
+};
+
+/// A range of const statement iterators.
+///
+/// This class provides some extra functionality beyond std::pair
+/// in order to allow the following idiom:
+///   for (ConstStmtRange range = stmt->children(); range; ++range)
+struct ConstStmtRange : std::pair<ConstStmtIterator,ConstStmtIterator> {
+  ConstStmtRange() {}
+  ConstStmtRange(const ConstStmtIterator &begin,
+                 const ConstStmtIterator &end)
+    : std::pair<ConstStmtIterator,ConstStmtIterator>(begin, end) {}
+  ConstStmtRange(const StmtRange &range)
+    : std::pair<ConstStmtIterator,ConstStmtIterator>(range.first, range.second)
+  {}
+  ConstStmtRange(const StmtIterator &begin, const StmtIterator &end)
+    : std::pair<ConstStmtIterator,ConstStmtIterator>(begin, end) {}
+
+  bool empty() const { return first == second; }
+  operator bool() const { return !empty(); }
+
+  const Stmt *operator->() const { return first.operator->(); }
+  const Stmt *operator*() const { return first.operator*(); }
+
+  ConstStmtRange &operator++() {
+    assert(!empty() && "incrementing on empty range");
+    ++first;
+    return *this;
+  }
+
+  ConstStmtRange operator++(int) {
+    assert(!empty() && "incrementing on empty range");
+    ConstStmtRange copy = *this;
+    ++first;
+    return copy;
+  }
+
+  friend const ConstStmtIterator &begin(const ConstStmtRange &range) {
+    return range.first;
+  }
+  friend const ConstStmtIterator &end(const ConstStmtRange &range) {
+    return range.second;
+  }
+};
+
 } // end namespace clang
 
 #endif