Update clang to r84119.

1 files changed, 32 insertions, 32 deletions

diff --git a/include/clang/AST/StmtIterator.h b/include/clang/AST/StmtIterator.h
index 35bd5ad..2d523ff 100644
--- a/include/clang/AST/StmtIterator.h
+++ b/include/clang/AST/StmtIterator.h
@@ -14,54 +14,54 @@
 #ifndef LLVM_CLANG_AST_STMT_ITR_H
 #define LLVM_CLANG_AST_STMT_ITR_H
 
-#include "llvm/ADT/iterator.h"
 #include "llvm/Support/DataTypes.h"
 #include <cassert>
+#include <iterator>
 
 namespace clang {
 
 class Stmt;
 class Decl;
 class VariableArrayType;
-  
+
 class StmtIteratorBase {
 protected:
   enum { DeclMode = 0x1, SizeOfTypeVAMode = 0x2, DeclGroupMode = 0x3,
          Flags = 0x3 };
-  
+
   union { Stmt** stmt; Decl* decl; Decl** DGI; };
-  uintptr_t RawVAPtr;  
+  uintptr_t RawVAPtr;
   Decl** DGE;
 
   bool inDecl() const {
     return (RawVAPtr & Flags) == DeclMode;
   }
-  
+
   bool inDeclGroup() const {
     return (RawVAPtr & Flags) == DeclGroupMode;
   }
-  
-  bool inSizeOfTypeVA() const { 
+
+  bool inSizeOfTypeVA() const {
     return (RawVAPtr & Flags) == SizeOfTypeVAMode;
   }
-  
+
   bool inStmt() const {
     return (RawVAPtr & Flags) == 0;
   }
-    
+
   VariableArrayType* getVAPtr() const {
     return reinterpret_cast<VariableArrayType*>(RawVAPtr & ~Flags);
   }
-  
+
   void setVAPtr(VariableArrayType* P) {
-    assert (inDecl() || inDeclGroup() || inSizeOfTypeVA());    
+    assert (inDecl() || inDeclGroup() || inSizeOfTypeVA());
     RawVAPtr = reinterpret_cast<uintptr_t>(P) | (RawVAPtr & Flags);
   }
-  
+
   void NextDecl(bool ImmediateAdvance = true);
   bool HandleDecl(Decl* D);
   void NextVA();
-  
+
   Stmt*& GetDeclExpr() const;
 
   StmtIteratorBase(Stmt** s) : stmt(s), RawVAPtr(0) {}
@@ -70,22 +70,22 @@ protected:
   StmtIteratorBase(Decl** dgi, Decl** dge);
   StmtIteratorBase() : stmt(NULL), RawVAPtr(0) {}
 };
-  
-  
+
+
 template <typename DERIVED, typename REFERENCE>
-class StmtIteratorImpl : public StmtIteratorBase, 
+class StmtIteratorImpl : public StmtIteratorBase,
                          public std::iterator<std::forward_iterator_tag,
-                                              REFERENCE, ptrdiff_t, 
-                                              REFERENCE, REFERENCE> {  
+                                              REFERENCE, ptrdiff_t,
+                                              REFERENCE, REFERENCE> {
 protected:
   StmtIteratorImpl(const StmtIteratorBase& RHS) : StmtIteratorBase(RHS) {}
 public:
-  StmtIteratorImpl() {}                                                
+  StmtIteratorImpl() {}
   StmtIteratorImpl(Stmt** s) : StmtIteratorBase(s) {}
   StmtIteratorImpl(Decl** dgi, Decl** dge) : StmtIteratorBase(dgi, dge) {}
   StmtIteratorImpl(Decl* d) : StmtIteratorBase(d) {}
   StmtIteratorImpl(VariableArrayType* t) : StmtIteratorBase(t) {}
-  
+
   DERIVED& operator++() {
     if (inDecl() || inDeclGroup()) {
       if (getVAPtr()) NextVA();
@@ -95,36 +95,36 @@ public:
       NextVA();
     else
       ++stmt;
-      
+
     return static_cast<DERIVED&>(*this);
   }
-    
+
   DERIVED operator++(int) {
     DERIVED tmp = static_cast<DERIVED&>(*this);
     operator++();
     return tmp;
   }
-  
+
   bool operator==(const DERIVED& RHS) const {
     return stmt == RHS.stmt && RawVAPtr == RHS.RawVAPtr;
   }
-  
+
   bool operator!=(const DERIVED& RHS) const {
     return stmt != RHS.stmt || RawVAPtr != RHS.RawVAPtr;
   }
-  
-  REFERENCE operator*() const { 
+
+  REFERENCE operator*() const {
     return (REFERENCE) (inStmt() ? *stmt : GetDeclExpr());
   }
-  
-  REFERENCE operator->() const { return operator*(); }   
+
+  REFERENCE operator->() const { return operator*(); }
 };
 
 struct StmtIterator : public StmtIteratorImpl<StmtIterator,Stmt*&> {
   explicit StmtIterator() : StmtIteratorImpl<StmtIterator,Stmt*&>() {}
 
   StmtIterator(Stmt** S) : StmtIteratorImpl<StmtIterator,Stmt*&>(S) {}
-  StmtIterator(Decl** dgi, Decl** dge) 
+  StmtIterator(Decl** dgi, Decl** dge)
    : StmtIteratorImpl<StmtIterator,Stmt*&>(dgi, dge) {}
 
   StmtIterator(VariableArrayType* t):StmtIteratorImpl<StmtIterator,Stmt*&>(t) {}
@@ -133,10 +133,10 @@ struct StmtIterator : public StmtIteratorImpl<StmtIterator,Stmt*&> {
 
 struct ConstStmtIterator : public StmtIteratorImpl<ConstStmtIterator,
                                                    const Stmt*> {
-  explicit ConstStmtIterator() : 
+  explicit ConstStmtIterator() :
     StmtIteratorImpl<ConstStmtIterator,const Stmt*>() {}
-                                                     
-  ConstStmtIterator(const StmtIterator& RHS) : 
+
+  ConstStmtIterator(const StmtIterator& RHS) :
     StmtIteratorImpl<ConstStmtIterator,const Stmt*>(RHS) {}
 };