Extract TextNodeDumper class

[steveire]

Summary

Start by moving some utilities to it. It will eventually house dumping
of individual nodes (after indentation etc has already been accounted
for).

[aaron.ballman]

Basically looking good, modulo namespace questions from D55188 and a few other organizational questions.

include/clang/AST/ASTTextNodeDumper.h

1 ↗

(On Diff #176322)

Perhaps the file should be named TextNodeDumper.h to match the class name?

44 ↗

(On Diff #176322)

Should these implementations live in the header file? I feel like they belong in a .cpp file instead.

[steveire]

Move implementation to cpp file

[aaron.ballman]

LGTM!

lib/AST/ASTDumper.cpp

90

Another nice cleanup for later would be to replace these call sites with the NodeDumper.foo() version. Same for dumpBareDeclRef() below.

[steveire]

lib/AST/ASTDumper.cpp

90

These methods are called from AttrDump.inc. They'll be removed when the commit to port the Attr dumping goes in.

include/clang/AST/TextNodeDumper.h

+//===--- TextNodeDumper.h - Printing of AST nodes -------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements AST dumping of components of individual AST nodes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_TEXTNODEDUMPER_H
+#define LLVM_CLANG_AST_TEXTNODEDUMPER_H
+
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTDumperUtils.h"
+#include "clang/AST/ExprCXX.h"
+
+namespace clang {
+
+class TextNodeDumper {
+  raw_ostream &OS;
+  const bool ShowColors;
+
+  /// Keep track of the last location we print out so that we can
+  /// print out deltas from then on out.
+  const char *LastLocFilename = "";
+  unsigned LastLocLine = ~0U;
+
+  const SourceManager *SM;
+
+  /// The policy to use for printing; can be defaulted.
+  PrintingPolicy PrintPolicy;
+
+public:
+  TextNodeDumper(raw_ostream &OS, bool ShowColors, const SourceManager *SM,
+                 const PrintingPolicy &PrintPolicy);
+
+  void dumpPointer(const void *Ptr);
+  void dumpLocation(SourceLocation Loc);
+  void dumpSourceRange(SourceRange R);
+  void dumpBareType(QualType T, bool Desugar = true);
+  void dumpType(QualType T);
+  void dumpBareDeclRef(const Decl *D);
+  void dumpName(const NamedDecl *ND);
+  void dumpAccessSpecifier(AccessSpecifier AS);
+  void dumpCXXTemporary(const CXXTemporary *Temporary);
+};
+
+} // namespace clang
+
+#endif // LLVM_CLANG_AST_TEXTNODEDUMPER_H

lib/AST/ASTDumper.cpp

 #include "clang/AST/CommentVisitor.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclLookups.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclOpenMP.h"
 #include "clang/AST/DeclVisitor.h"
 #include "clang/AST/LocInfoType.h"
 #include "clang/AST/StmtVisitor.h"
+#include "clang/AST/TextNodeDumper.h"
 #include "clang/AST/TypeVisitor.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/SourceManager.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace clang;
 using namespace clang::comments;
 
 //===----------------------------------------------------------------------===//
 // ASTDumper Visitor
 //===----------------------------------------------------------------------===//
 
 namespace  {
 
   class ASTDumper
       : public ConstDeclVisitor<ASTDumper>,
         public ConstStmtVisitor<ASTDumper>,
         public ConstCommentVisitor<ASTDumper, void, const FullComment *>,
         public TypeVisitor<ASTDumper> {
 
     TextTreeStructure TreeStructure;
+    TextNodeDumper NodeDumper;
 
     raw_ostream &OS;
     const CommandTraits *Traits;
-    const SourceManager *SM;
 
     /// The policy to use for printing; can be defaulted.
     PrintingPolicy PrintPolicy;
 
     /// Indicates whether we should trigger deserialization of nodes that had
     /// not already been loaded.
     bool Deserialize = false;
 
-    /// Keep track of the last location we print out so that we can
-    /// print out deltas from then on out.
-    const char *LastLocFilename = "";
-    unsigned LastLocLine = ~0U;
-
     const bool ShowColors;
 
     /// Dump a child of the current node.
     template<typename Fn> void dumpChild(Fn doDumpChild) {
       TreeStructure.addChild(doDumpChild);
     }
 
   public:
     ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
               const SourceManager *SM)
         : ASTDumper(OS, Traits, SM,
                     SM && SM->getDiagnostics().getShowColors()) {}
 
     ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
               const SourceManager *SM, bool ShowColors)
         : ASTDumper(OS, Traits, SM, ShowColors, LangOptions()) {}
     ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
               const SourceManager *SM, bool ShowColors,
               const PrintingPolicy &PrintPolicy)
-        : TreeStructure(OS, ShowColors), OS(OS), Traits(Traits), SM(SM),
+        : TreeStructure(OS, ShowColors),
+          NodeDumper(OS, ShowColors, SM, PrintPolicy), OS(OS), Traits(Traits),
           PrintPolicy(PrintPolicy), ShowColors(ShowColors) {}
 
     void setDeserialize(bool D) { Deserialize = D; }
 
     void dumpDecl(const Decl *D);
     void dumpStmt(const Stmt *S);
     void dumpFullComment(const FullComment *C);
 
     // Utilities
-    void dumpPointer(const void *Ptr);
-    void dumpSourceRange(SourceRange R);
-    void dumpLocation(SourceLocation Loc);
-    void dumpBareType(QualType T, bool Desugar = true);
-    void dumpType(QualType T);
+    void dumpType(QualType T) { NodeDumper.dumpType(T); }
     void dumpTypeAsChild(QualType T);
     void dumpTypeAsChild(const Type *T);
-    void dumpBareDeclRef(const Decl *Node);
     void dumpDeclRef(const Decl *Node, const char *Label = nullptr);
-    void dumpName(const NamedDecl *D);
+    void dumpBareDeclRef(const Decl *Node) { NodeDumper.dumpBareDeclRef(Node); }
     bool hasNodes(const DeclContext *DC);
     void dumpDeclContext(const DeclContext *DC);
     void dumpLookups(const DeclContext *DC, bool DumpDecls);
     void dumpAttr(const Attr *A);
 
     // C++ Utilities
-    void dumpAccessSpecifier(AccessSpecifier AS);
     void dumpCXXCtorInitializer(const CXXCtorInitializer *Init);
     void dumpTemplateParameters(const TemplateParameterList *TPL);
     void dumpTemplateArgumentListInfo(const TemplateArgumentListInfo &TALI);
     void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A);
     void dumpTemplateArgumentList(const TemplateArgumentList &TAL);
     void dumpTemplateArgument(const TemplateArgument &A,
                               SourceRange R = SourceRange());
 
void VisitArrayType(const ArrayType *T) {
       dumpTypeAsChild(T->getElementType());
     }
     void VisitConstantArrayType(const ConstantArrayType *T) {
       OS << " " << T->getSize();
       VisitArrayType(T);
     }
     void VisitVariableArrayType(const VariableArrayType *T) {
       OS << " ";
-      dumpSourceRange(T->getBracketsRange());
+      NodeDumper.dumpSourceRange(T->getBracketsRange());
       VisitArrayType(T);
       dumpStmt(T->getSizeExpr());
     }
     void VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
       switch (T->getSizeModifier()) {
         case ArrayType::Normal: break;
         case ArrayType::Static: OS << " static"; break;
         case ArrayType::Star: OS << " *"; break;
       }
       OS << " " << T->getIndexTypeQualifiers().getAsString();
       OS << " ";
-      dumpSourceRange(T->getBracketsRange());
+      NodeDumper.dumpSourceRange(T->getBracketsRange());
       dumpTypeAsChild(T->getElementType());
       dumpStmt(T->getSizeExpr());
     }
     void VisitDependentSizedExtVectorType(
         const DependentSizedExtVectorType *T) {
       OS << " ";
-      dumpLocation(T->getAttributeLoc());
+      NodeDumper.dumpLocation(T->getAttributeLoc());
       dumpTypeAsChild(T->getElementType());
       dumpStmt(T->getSizeExpr());
     }
     void VisitVectorType(const VectorType *T) {
       switch (T->getVectorKind()) {
         case VectorType::GenericVector: break;
         case VectorType::AltiVecVector: OS << " altivec"; break;
         case VectorType::AltiVecPixel: OS << " altivec pixel"; break;
public:
     void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *Node);
     void VisitCXXConstructExpr(const CXXConstructExpr *Node);
     void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node);
     void VisitCXXNewExpr(const CXXNewExpr *Node);
     void VisitCXXDeleteExpr(const CXXDeleteExpr *Node);
     void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node);
     void VisitExprWithCleanups(const ExprWithCleanups *Node);
     void VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node);
-    void dumpCXXTemporary(const CXXTemporary *Temporary);
     void VisitLambdaExpr(const LambdaExpr *Node) {
       VisitExpr(Node);
       dumpDecl(Node->getLambdaClass());
     }
     void VisitSizeOfPackExpr(const SizeOfPackExpr *Node);
     void
     VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *Node);
 
void visitVerbatimLineComment(const VerbatimLineComment *C,
                                   const FullComment *FC);
   };
 }
 
 //===----------------------------------------------------------------------===//
 //  Utilities
 //===----------------------------------------------------------------------===//
 
-void ASTDumper::dumpPointer(const void *Ptr) {
-  ColorScope Color(OS, ShowColors, AddressColor);
-  OS << ' ' << Ptr;
-}
-
-void ASTDumper::dumpLocation(SourceLocation Loc) {
-  if (!SM)
-    return;
-
-  ColorScope Color(OS, ShowColors, LocationColor);
-  SourceLocation SpellingLoc = SM->getSpellingLoc(Loc);
-
-  // The general format we print out is filename:line:col, but we drop pieces
-  // that haven't changed since the last loc printed.
-  PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc);
-
-  if (PLoc.isInvalid()) {
-    OS << "<invalid sloc>";
-    return;
-  }
-
-  if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) {
-    OS << PLoc.getFilename() << ':' << PLoc.getLine()
-       << ':' << PLoc.getColumn();
-    LastLocFilename = PLoc.getFilename();
-    LastLocLine = PLoc.getLine();
-  } else if (PLoc.getLine() != LastLocLine) {
-    OS << "line" << ':' << PLoc.getLine()
-       << ':' << PLoc.getColumn();
-    LastLocLine = PLoc.getLine();
-  } else {
-    OS << "col" << ':' << PLoc.getColumn();
-  }
-}
-
-void ASTDumper::dumpSourceRange(SourceRange R) {
-  // Can't translate locations if a SourceManager isn't available.
-  if (!SM)
-    return;
-
-  OS << " <";
-  dumpLocation(R.getBegin());
-  if (R.getBegin() != R.getEnd()) {
-    OS << ", ";
-    dumpLocation(R.getEnd());
-  }
-  OS << ">";
-
-  // <t2.c:123:421[blah], t2.c:412:321>
-
-}
-
-void ASTDumper::dumpBareType(QualType T, bool Desugar) {
-  ColorScope Color(OS, ShowColors, TypeColor);
-
-  SplitQualType T_split = T.split();
-  OS << "'" << QualType::getAsString(T_split, PrintPolicy) << "'";
-
-  if (Desugar && !T.isNull()) {
-    // If the type is sugared, also dump a (shallow) desugared type.
-    SplitQualType D_split = T.getSplitDesugaredType();
-    if (T_split != D_split)
-      OS << ":'" << QualType::getAsString(D_split, PrintPolicy) << "'";
-  }
-}
-
-void ASTDumper::dumpType(QualType T) {
-  OS << ' ';
-  dumpBareType(T);
-}
-
 void ASTDumper::dumpTypeAsChild(QualType T) {
   SplitQualType SQT = T.split();
   if (!SQT.Quals.hasQualifiers())
     return dumpTypeAsChild(SQT.Ty);
 
   dumpChild([=] {
     OS << "QualType";
-    dumpPointer(T.getAsOpaquePtr());
+    NodeDumper.dumpPointer(T.getAsOpaquePtr());
     OS << " ";
-    dumpBareType(T, false);
+    NodeDumper.dumpBareType(T, false);
     OS << " " << T.split().Quals.getAsString();
     dumpTypeAsChild(T.split().Ty);
   });
 }
 
 void ASTDumper::dumpTypeAsChild(const Type *T) {
   dumpChild([=] {
     if (!T) {
       ColorScope Color(OS, ShowColors, NullColor);
       OS << "<<<NULL>>>";
       return;
     }
     if (const LocInfoType *LIT = llvm::dyn_cast<LocInfoType>(T)) {
       {
         ColorScope Color(OS, ShowColors, TypeColor);
         OS << "LocInfo Type";
       }
-      dumpPointer(T);
+      NodeDumper.dumpPointer(T);
       dumpTypeAsChild(LIT->getTypeSourceInfo()->getType());
       return;
     }
 
     {
       ColorScope Color(OS, ShowColors, TypeColor);
       OS << T->getTypeClassName() << "Type";
     }
-    dumpPointer(T);
+    NodeDumper.dumpPointer(T);
     OS << " ";
-    dumpBareType(QualType(T, 0), false);
+    NodeDumper.dumpBareType(QualType(T, 0), false);
 
     QualType SingleStepDesugar =
         T->getLocallyUnqualifiedSingleStepDesugaredType();
     if (SingleStepDesugar != QualType(T, 0))
       OS << " sugar";
     if (T->isDependentType())
       OS << " dependent";
     else if (T->isInstantiationDependentType())
       OS << " instantiation_dependent";
     if (T->isVariablyModifiedType())
       OS << " variably_modified";
     if (T->containsUnexpandedParameterPack())
       OS << " contains_unexpanded_pack";
     if (T->isFromAST())
       OS << " imported";
 
     TypeVisitor<ASTDumper>::Visit(T);
 
     if (SingleStepDesugar != QualType(T, 0))
       dumpTypeAsChild(SingleStepDesugar);
   });
 }
 
-void ASTDumper::dumpBareDeclRef(const Decl *D) {
-  if (!D) {
-    ColorScope Color(OS, ShowColors, NullColor);
-    OS << "<<<NULL>>>";
-    return;
-  }
-
-  {
-    ColorScope Color(OS, ShowColors, DeclKindNameColor);
-    OS << D->getDeclKindName();
-  }
-  dumpPointer(D);
-
-  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
-    ColorScope Color(OS, ShowColors, DeclNameColor);
-    OS << " '" << ND->getDeclName() << '\'';
-  }
-
-  if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
-    dumpType(VD->getType());
-}
-
 void ASTDumper::dumpDeclRef(const Decl *D, const char *Label) {
   if (!D)
     return;
 
   dumpChild([=]{
     if (Label)
       OS << Label << ' ';
     dumpBareDeclRef(D);
   });
 }
 
-void ASTDumper::dumpName(const NamedDecl *ND) {
-  if (ND->getDeclName()) {
-    ColorScope Color(OS, ShowColors, DeclNameColor);
-    OS << ' ' << ND->getNameAsString();
-  }
-}
-
 bool ASTDumper::hasNodes(const DeclContext *DC) {
   if (!DC)
     return false;
 
   return DC->hasExternalLexicalStorage() ||
          (Deserialize ? DC->decls_begin() != DC->decls_end()
                       : DC->noload_decls_begin() != DC->noload_decls_end());
 }
dumpChild([=] {
       OS << "<undeserialized declarations>";
     });
   }
 }
 
 void ASTDumper::dumpLookups(const DeclContext *DC, bool DumpDecls) {
   dumpChild([=] {
     OS << "StoredDeclsMap ";
-    dumpBareDeclRef(cast<Decl>(DC));
+    NodeDumper.dumpBareDeclRef(cast<Decl>(DC));
 
     const DeclContext *Primary = DC->getPrimaryContext();
     if (Primary != DC) {
       OS << " primary";
-      dumpPointer(cast<Decl>(Primary));
+      NodeDumper.dumpPointer(cast<Decl>(Primary));
     }
 
     bool HasUndeserializedLookups = Primary->hasExternalVisibleStorage();
 
     auto Range = Deserialize
                      ? Primary->lookups()
                      : Primary->noload_lookups(/*PreserveInternalState=*/true);
     for (auto I = Range.begin(), E = Range.end(); I != E; ++I) {
       DeclarationName Name = I.getLookupName();
       DeclContextLookupResult R = *I;
 
       dumpChild([=] {
         OS << "DeclarationName ";
         {
           ColorScope Color(OS, ShowColors, DeclNameColor);
           OS << '\'' << Name << '\'';
         }
 
         for (DeclContextLookupResult::iterator RI = R.begin(), RE = R.end();
              RI != RE; ++RI) {
           dumpChild([=] {
-            dumpBareDeclRef(*RI);
+            NodeDumper.dumpBareDeclRef(*RI);
 
             if ((*RI)->isHidden())
               OS << " hidden";
 
             // If requested, dump the redecl chain for this lookup.
             if (DumpDecls) {
               // Dump earliest decl first.
               std::function<void(Decl *)> DumpWithPrev = [&](Decl *D) {
dumpChild([=] {
       ColorScope Color(OS, ShowColors, AttrColor);
 
       switch (A->getKind()) {
 #define ATTR(X) case attr::X: OS << #X; break;
 #include "clang/Basic/AttrList.inc"
       }
       OS << "Attr";
     }
-    dumpPointer(A);
-    dumpSourceRange(A->getRange());
+    NodeDumper.dumpPointer(A);
+    NodeDumper.dumpSourceRange(A->getRange());
     if (A->isInherited())
       OS << " Inherited";
     if (A->isImplicit())
       OS << " Implicit";
 #include "clang/AST/AttrDump.inc"
   });
 }
 
#include "clang/AST/DeclNodes.inc"
   }
   llvm_unreachable("Decl that isn't part of DeclNodes.inc!");
 }
 
 //===----------------------------------------------------------------------===//
 //  C++ Utilities
 //===----------------------------------------------------------------------===//
 
-void ASTDumper::dumpAccessSpecifier(AccessSpecifier AS) {
-  switch (AS) {
-  case AS_none:
-    break;
-  case AS_public:
-    OS << "public";
-    break;
-  case AS_protected:
-    OS << "protected";
-    break;
-  case AS_private:
-    OS << "private";
-    break;
-  }
-}
-
 void ASTDumper::dumpCXXCtorInitializer(const CXXCtorInitializer *Init) {
   dumpChild([=] {
     OS << "CXXCtorInitializer";
     if (Init->isAnyMemberInitializer()) {
       OS << ' ';
-      dumpBareDeclRef(Init->getAnyMember());
+      NodeDumper.dumpBareDeclRef(Init->getAnyMember());
     } else if (Init->isBaseInitializer()) {
-      dumpType(QualType(Init->getBaseClass(), 0));
+      NodeDumper.dumpType(QualType(Init->getBaseClass(), 0));
     } else if (Init->isDelegatingInitializer()) {
-      dumpType(Init->getTypeSourceInfo()->getType());
+      NodeDumper.dumpType(Init->getTypeSourceInfo()->getType());
     } else {
       llvm_unreachable("Unknown initializer type");
     }
     dumpStmt(Init->getInit());
   });
 }
 
 void ASTDumper::dumpTemplateParameters(const TemplateParameterList *TPL) {
void ASTDumper::dumpTemplateArgumentList(const TemplateArgumentList &TAL) {
   for (unsigned i = 0, e = TAL.size(); i < e; ++i)
     dumpTemplateArgument(TAL[i]);
 }
 
 void ASTDumper::dumpTemplateArgument(const TemplateArgument &A, SourceRange R) {
   dumpChild([=] {
     OS << "TemplateArgument";
     if (R.isValid())
-      dumpSourceRange(R);
+      NodeDumper.dumpSourceRange(R);
 
     switch (A.getKind()) {
     case TemplateArgument::Null:
       OS << " null";
       break;
     case TemplateArgument::Type:
       OS << " type";
-      dumpType(A.getAsType());
+      NodeDumper.dumpType(A.getAsType());
       break;
     case TemplateArgument::Declaration:
       OS << " decl";
       dumpDeclRef(A.getAsDecl());
       break;
     case TemplateArgument::NullPtr:
       OS << " nullptr";
       break;
if (!D) {
       OS << "<<<NULL>>>";
       return;
     }
 
     {
       ColorScope Color(OS, ShowColors, DeclKindNameColor);
       OS << D->getDeclKindName() << "Decl";
     }
-    dumpPointer(D);
+    NodeDumper.dumpPointer(D);
     if (D->getLexicalDeclContext() != D->getDeclContext())
       OS << " parent " << cast<Decl>(D->getDeclContext());
     dumpPreviousDecl(OS, D);
-    dumpSourceRange(D->getSourceRange());
+    NodeDumper.dumpSourceRange(D->getSourceRange());
     OS << ' ';
-    dumpLocation(D->getLocation());
+    NodeDumper.dumpLocation(D->getLocation());
     if (D->isFromASTFile())
       OS << " imported";
     if (Module *M = D->getOwningModule())
       OS << " in " << M->getFullModuleName();
     if (auto *ND = dyn_cast<NamedDecl>(D))
       for (Module *M : D->getASTContext().getModulesWithMergedDefinition(
                const_cast<NamedDecl *>(ND)))
         dumpChild([=] { OS << "also in " << M->getFullModuleName(); });
dumpChild([=] {
 
     // Decls within functions are visited by the body.
     if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D) &&
         hasNodes(dyn_cast<DeclContext>(D)))
       dumpDeclContext(cast<DeclContext>(D));
   });
 }
 
-void ASTDumper::VisitLabelDecl(const LabelDecl *D) {
-  dumpName(D);
-}
+void ASTDumper::VisitLabelDecl(const LabelDecl *D) { NodeDumper.dumpName(D); }
 
 void ASTDumper::VisitTypedefDecl(const TypedefDecl *D) {
-  dumpName(D);
-  dumpType(D->getUnderlyingType());
+  NodeDumper.dumpName(D);
+  NodeDumper.dumpType(D->getUnderlyingType());
   if (D->isModulePrivate())
     OS << " __module_private__";
   dumpTypeAsChild(D->getUnderlyingType());
 }
 
 void ASTDumper::VisitEnumDecl(const EnumDecl *D) {
   if (D->isScoped()) {
     if (D->isScopedUsingClassTag())
       OS << " class";
     else
       OS << " struct";
   }
-  dumpName(D);
+  NodeDumper.dumpName(D);
   if (D->isModulePrivate())
     OS << " __module_private__";
   if (D->isFixed())
-    dumpType(D->getIntegerType());
+    NodeDumper.dumpType(D->getIntegerType());
 }
 
 void ASTDumper::VisitRecordDecl(const RecordDecl *D) {
   OS << ' ' << D->getKindName();
-  dumpName(D);
+  NodeDumper.dumpName(D);
   if (D->isModulePrivate())
     OS << " __module_private__";
   if (D->isCompleteDefinition())
     OS << " definition";
 }
 
 void ASTDumper::VisitEnumConstantDecl(const EnumConstantDecl *D) {
-  dumpName(D);
-  dumpType(D->getType());
+  NodeDumper.dumpName(D);
+  NodeDumper.dumpType(D->getType());
   if (const Expr *Init = D->getInitExpr())
     dumpStmt(Init);
 }
 
 void ASTDumper::VisitIndirectFieldDecl(const IndirectFieldDecl *D) {
-  dumpName(D);
-  dumpType(D->getType());
+  NodeDumper.dumpName(D);
+  NodeDumper.dumpType(D->getType());
 
   for (auto *Child : D->chain())
     dumpDeclRef(Child);
 }
 
 void ASTDumper::VisitFunctionDecl(const FunctionDecl *D) {
-  dumpName(D);
-  dumpType(D->getType());
+  NodeDumper.dumpName(D);
+  NodeDumper.dumpType(D->getType());
 
   StorageClass SC = D->getStorageClass();
   if (SC != SC_None)
     OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
   if (D->isInlineSpecified())
     OS << " inline";
   if (D->isVirtualAsWritten())
     OS << " virtual";
if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
     }
   }
 
   if (D->doesThisDeclarationHaveABody())
     dumpStmt(D->getBody());
 }
 
 void ASTDumper::VisitFieldDecl(const FieldDecl *D) {
-  dumpName(D);
-  dumpType(D->getType());
+  NodeDumper.dumpName(D);
+  NodeDumper.dumpType(D->getType());
   if (D->isMutable())
     OS << " mutable";
   if (D->isModulePrivate())
     OS << " __module_private__";
 
   if (D->isBitField())
     dumpStmt(D->getBitWidth());
   if (Expr *Init = D->getInClassInitializer())
     dumpStmt(Init);
 }
 
 void ASTDumper::VisitVarDecl(const VarDecl *D) {
-  dumpName(D);
-  dumpType(D->getType());
+  NodeDumper.dumpName(D);
+  NodeDumper.dumpType(D->getType());
   StorageClass SC = D->getStorageClass();
   if (SC != SC_None)
     OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
   switch (D->getTLSKind()) {
   case VarDecl::TLS_None: break;
   case VarDecl::TLS_Static: OS << " tls"; break;
   case VarDecl::TLS_Dynamic: OS << " tls_dynamic"; break;
   }

 
 void ASTDumper::VisitDecompositionDecl(const DecompositionDecl *D) {
   VisitVarDecl(D);
   for (auto *B : D->bindings())
     dumpDecl(B);
 }
 
 void ASTDumper::VisitBindingDecl(const BindingDecl *D) {
-  dumpName(D);
-  dumpType(D->getType());
+  NodeDumper.dumpName(D);
+  NodeDumper.dumpType(D->getType());
   if (auto *E = D->getBinding())
     dumpStmt(E);
 }
 
 void ASTDumper::VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) {
   dumpStmt(D->getAsmString());
 }
 

 //===----------------------------------------------------------------------===//
 
 void ASTDumper::VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) {
   for (auto *E : D->varlists())
     dumpStmt(E);
 }
 
 void ASTDumper::VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) {
-  dumpName(D);
-  dumpType(D->getType());
+  NodeDumper.dumpName(D);
+  NodeDumper.dumpType(D->getType());
   OS << " combiner";
   dumpStmt(D->getCombiner());
   if (auto *Initializer = D->getInitializer()) {
     OS << " initializer";
     switch (D->getInitializerKind()) {
     case OMPDeclareReductionDecl::DirectInit:
       OS << " omp_priv = ";
       break;
dumpChild([=] {
         return;
       }
       {
         ColorScope Color(OS, ShowColors, AttrColor);
         StringRef ClauseName(getOpenMPClauseName(C->getClauseKind()));
         OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
            << ClauseName.drop_front() << "Clause";
       }
-      dumpPointer(C);
-      dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
+      NodeDumper.dumpPointer(C);
+      NodeDumper.dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
     });
   }
 }
 
 void ASTDumper::VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) {
-  dumpName(D);
-  dumpType(D->getType());
+  NodeDumper.dumpName(D);
+  NodeDumper.dumpType(D->getType());
   dumpStmt(D->getInit());
 }
 
 //===----------------------------------------------------------------------===//
 // C++ Declarations
 //===----------------------------------------------------------------------===//
 
 void ASTDumper::VisitNamespaceDecl(const NamespaceDecl *D) {
-  dumpName(D);
+  NodeDumper.dumpName(D);
   if (D->isInline())
     OS << " inline";
   if (!D->isOriginalNamespace())
     dumpDeclRef(D->getOriginalNamespace(), "original");
 }
 
 void ASTDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
   OS << ' ';
-  dumpBareDeclRef(D->getNominatedNamespace());
+  NodeDumper.dumpBareDeclRef(D->getNominatedNamespace());
 }
 
 void ASTDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
-  dumpName(D);
+  NodeDumper.dumpName(D);
   dumpDeclRef(D->getAliasedNamespace());
 }
 
 void ASTDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) {
-  dumpName(D);
-  dumpType(D->getUnderlyingType());
+  NodeDumper.dumpName(D);
+  NodeDumper.dumpType(D->getUnderlyingType());
   dumpTypeAsChild(D->getUnderlyingType());
 }
 
 void ASTDumper::VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) {
-  dumpName(D);
+  NodeDumper.dumpName(D);
   dumpTemplateParameters(D->getTemplateParameters());
   dumpDecl(D->getTemplatedDecl());
 }
 
 void ASTDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) {
   VisitRecordDecl(D);
   if (!D->isCompleteDefinition())
     return;
dumpChild([=] {
         FLAG(defaultedDestructorIsDeleted, defaulted_is_deleted);
     });
   });
 
   for (const auto &I : D->bases()) {
     dumpChild([=] {
       if (I.isVirtual())
         OS << "virtual ";
-      dumpAccessSpecifier(I.getAccessSpecifier());
-      dumpType(I.getType());
+      NodeDumper.dumpAccessSpecifier(I.getAccessSpecifier());
+      NodeDumper.dumpType(I.getType());
       if (I.isPackExpansion())
         OS << "...";
     });
   }
 }
 
 void ASTDumper::VisitStaticAssertDecl(const StaticAssertDecl *D) {
   dumpStmt(D->getAssertExpr());
void ASTDumper::VisitTemplateDeclSpecialization(const SpecializationDecl *D,
   // Ensure we dump at least one decl for each specialization.
   if (!DumpedAny)
     dumpDeclRef(D);
 }
 
 template<typename TemplateDecl>
 void ASTDumper::VisitTemplateDecl(const TemplateDecl *D,
                                   bool DumpExplicitInst) {
-  dumpName(D);
+  NodeDumper.dumpName(D);
   dumpTemplateParameters(D->getTemplateParameters());
 
   dumpDecl(D->getTemplatedDecl());
 
   for (auto *Child : D->specializations())
     VisitTemplateDeclSpecialization(Child, DumpExplicitInst,
                                     !D->isCanonicalDecl());
 }
if (D->hasExplicitTemplateArgs())
     dumpTemplateArgumentListInfo(D->templateArgs());
 }
 
 void ASTDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
   VisitTemplateDecl(D, false);
 }
 
 void ASTDumper::VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) {
-  dumpName(D);
+  NodeDumper.dumpName(D);
   dumpTemplateParameters(D->getTemplateParameters());
 }
 
 void ASTDumper::VisitVarTemplateSpecializationDecl(
     const VarTemplateSpecializationDecl *D) {
   dumpTemplateArgumentList(D->getTemplateArgs());
   VisitVarDecl(D);
 }
 
 void ASTDumper::VisitVarTemplatePartialSpecializationDecl(
     const VarTemplatePartialSpecializationDecl *D) {
   dumpTemplateParameters(D->getTemplateParameters());
   VisitVarTemplateSpecializationDecl(D);
 }
 
 void ASTDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
   if (D->wasDeclaredWithTypename())
     OS << " typename";
   else
     OS << " class";
   OS << " depth " << D->getDepth() << " index " << D->getIndex();
   if (D->isParameterPack())
     OS << " ...";
-  dumpName(D);
+  NodeDumper.dumpName(D);
   if (D->hasDefaultArgument())
     dumpTemplateArgument(D->getDefaultArgument());
   if (auto *From = D->getDefaultArgStorage().getInheritedFrom())
     dumpDeclRef(From, D->defaultArgumentWasInherited() ? "inherited from"
                                                        : "previous");
 }
 
 void ASTDumper::VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
-  dumpType(D->getType());
+  NodeDumper.dumpType(D->getType());
   OS << " depth " << D->getDepth() << " index " << D->getIndex();
   if (D->isParameterPack())
     OS << " ...";
-  dumpName(D);
+  NodeDumper.dumpName(D);
   if (D->hasDefaultArgument())
     dumpTemplateArgument(D->getDefaultArgument());
   if (auto *From = D->getDefaultArgStorage().getInheritedFrom())
     dumpDeclRef(From, D->defaultArgumentWasInherited() ? "inherited from"
                                                        : "previous");
 }
 
 void ASTDumper::VisitTemplateTemplateParmDecl(
     const TemplateTemplateParmDecl *D) {
   OS << " depth " << D->getDepth() << " index " << D->getIndex();
   if (D->isParameterPack())
     OS << " ...";
-  dumpName(D);
+  NodeDumper.dumpName(D);
   dumpTemplateParameters(D->getTemplateParameters());
   if (D->hasDefaultArgument())
     dumpTemplateArgumentLoc(D->getDefaultArgument());
   if (auto *From = D->getDefaultArgStorage().getInheritedFrom())
     dumpDeclRef(From, D->defaultArgumentWasInherited() ? "inherited from"
                                                        : "previous");
 }
 
void ASTDumper::VisitUnresolvedUsingTypenameDecl(
   OS << D->getNameAsString();
 }
 
 void ASTDumper::VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D) {
   OS << ' ';
   if (D->getQualifier())
     D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
   OS << D->getNameAsString();
-  dumpType(D->getType());
+  NodeDumper.dumpType(D->getType());
 }
 
 void ASTDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) {
   OS << ' ';
-  dumpBareDeclRef(D->getTargetDecl());
+  NodeDumper.dumpBareDeclRef(D->getTargetDecl());
   if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))
     dumpTypeAsChild(TD->getTypeForDecl());
 }
 
 void ASTDumper::VisitConstructorUsingShadowDecl(
     const ConstructorUsingShadowDecl *D) {
   if (D->constructsVirtualBase())
     OS << " virtual";
 
   dumpChild([=] {
     OS << "target ";
-    dumpBareDeclRef(D->getTargetDecl());
+    NodeDumper.dumpBareDeclRef(D->getTargetDecl());
   });
 
   dumpChild([=] {
     OS << "nominated ";
-    dumpBareDeclRef(D->getNominatedBaseClass());
+    NodeDumper.dumpBareDeclRef(D->getNominatedBaseClass());
     OS << ' ';
-    dumpBareDeclRef(D->getNominatedBaseClassShadowDecl());
+    NodeDumper.dumpBareDeclRef(D->getNominatedBaseClassShadowDecl());
   });
 
   dumpChild([=] {
     OS << "constructed ";
-    dumpBareDeclRef(D->getConstructedBaseClass());
+    NodeDumper.dumpBareDeclRef(D->getConstructedBaseClass());
     OS << ' ';
-    dumpBareDeclRef(D->getConstructedBaseClassShadowDecl());
+    NodeDumper.dumpBareDeclRef(D->getConstructedBaseClassShadowDecl());
   });
 }
 
 void ASTDumper::VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
   switch (D->getLanguage()) {
   case LinkageSpecDecl::lang_c: OS << " C"; break;
   case LinkageSpecDecl::lang_cxx: OS << " C++"; break;
   }
 }
 
 void ASTDumper::VisitAccessSpecDecl(const AccessSpecDecl *D) {
   OS << ' ';
-  dumpAccessSpecifier(D->getAccess());
+  NodeDumper.dumpAccessSpecifier(D->getAccess());
 }
 
 void ASTDumper::VisitFriendDecl(const FriendDecl *D) {
   if (TypeSourceInfo *T = D->getFriendType())
-    dumpType(T->getType());
+    NodeDumper.dumpType(T->getType());
   else
     dumpDecl(D->getFriendDecl());
 }
 
 //===----------------------------------------------------------------------===//
 // Obj-C Declarations
 //===----------------------------------------------------------------------===//
 
 void ASTDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
-  dumpName(D);
-  dumpType(D->getType());
+  NodeDumper.dumpName(D);
+  NodeDumper.dumpType(D->getType());
   if (D->getSynthesize())
     OS << " synthesize";
 
   switch (D->getAccessControl()) {
   case ObjCIvarDecl::None:
     OS << " none";
     break;
   case ObjCIvarDecl::Private:
void ASTDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
   }
 }
 
 void ASTDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
   if (D->isInstanceMethod())
     OS << " -";
   else
     OS << " +";
-  dumpName(D);
-  dumpType(D->getReturnType());
+  NodeDumper.dumpName(D);
+  NodeDumper.dumpType(D->getReturnType());
 
   if (D->isThisDeclarationADefinition()) {
     dumpDeclContext(D);
   } else {
     for (const ParmVarDecl *Parameter : D->parameters())
       dumpDecl(Parameter);
   }
 
   if (D->isVariadic())
     dumpChild([=] { OS << "..."; });
 
   if (D->hasBody())
     dumpStmt(D->getBody());
 }
 
 void ASTDumper::VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D) {
-  dumpName(D);
+  NodeDumper.dumpName(D);
   switch (D->getVariance()) {
   case ObjCTypeParamVariance::Invariant:
     break;
 
   case ObjCTypeParamVariance::Covariant:
     OS << " covariant";
     break;
 
   case ObjCTypeParamVariance::Contravariant:
     OS << " contravariant";
     break;
   }
 
   if (D->hasExplicitBound())
     OS << " bounded";
-  dumpType(D->getUnderlyingType());
+  NodeDumper.dumpType(D->getUnderlyingType());
 }
 
 void ASTDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
-  dumpName(D);
+  NodeDumper.dumpName(D);
   dumpDeclRef(D->getClassInterface());
   dumpObjCTypeParamList(D->getTypeParamList());
   dumpDeclRef(D->getImplementation());
   for (ObjCCategoryDecl::protocol_iterator I = D->protocol_begin(),
                                            E = D->protocol_end();
        I != E; ++I)
     dumpDeclRef(*I);
 }
 
 void ASTDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
-  dumpName(D);
+  NodeDumper.dumpName(D);
   dumpDeclRef(D->getClassInterface());
   dumpDeclRef(D->getCategoryDecl());
 }
 
 void ASTDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
-  dumpName(D);
+  NodeDumper.dumpName(D);
 
   for (auto *Child : D->protocols())
     dumpDeclRef(Child);
 }
 
 void ASTDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
-  dumpName(D);
+  NodeDumper.dumpName(D);
   dumpObjCTypeParamList(D->getTypeParamListAsWritten());
   dumpDeclRef(D->getSuperClass(), "super");
 
   dumpDeclRef(D->getImplementation());
   for (auto *Child : D->protocols())
     dumpDeclRef(Child);
 }
 
 void ASTDumper::VisitObjCImplementationDecl(const ObjCImplementationDecl *D) {
-  dumpName(D);
+  NodeDumper.dumpName(D);
   dumpDeclRef(D->getSuperClass(), "super");
   dumpDeclRef(D->getClassInterface());
   for (ObjCImplementationDecl::init_const_iterator I = D->init_begin(),
                                                    E = D->init_end();
        I != E; ++I)
     dumpCXXCtorInitializer(*I);
 }
 
 void ASTDumper::VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D) {
-  dumpName(D);
+  NodeDumper.dumpName(D);
   dumpDeclRef(D->getClassInterface());
 }
 
 void ASTDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
-  dumpName(D);
-  dumpType(D->getType());
+  NodeDumper.dumpName(D);
+  NodeDumper.dumpType(D->getType());
 
   if (D->getPropertyImplementation() == ObjCPropertyDecl::Required)
     OS << " required";
   else if (D->getPropertyImplementation() == ObjCPropertyDecl::Optional)
     OS << " optional";
 
   ObjCPropertyDecl::PropertyAttributeKind Attrs = D->getPropertyAttributes();
   if (Attrs != ObjCPropertyDecl::OBJC_PR_noattr) {
if (Attrs != ObjCPropertyDecl::OBJC_PR_noattr) {
     if (Attrs & ObjCPropertyDecl::OBJC_PR_getter)
       dumpDeclRef(D->getGetterMethodDecl(), "getter");
     if (Attrs & ObjCPropertyDecl::OBJC_PR_setter)
       dumpDeclRef(D->getSetterMethodDecl(), "setter");
   }
 }
 
 void ASTDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
-  dumpName(D->getPropertyDecl());
+  NodeDumper.dumpName(D->getPropertyDecl());
   if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
     OS << " synthesize";
   else
     OS << " dynamic";
   dumpDeclRef(D->getPropertyDecl());
   dumpDeclRef(D->getPropertyIvarDecl());
 }
 
for (const auto &I : D->captures()) {
     dumpChild([=] {
       OS << "capture";
       if (I.isByRef())
         OS << " byref";
       if (I.isNested())
         OS << " nested";
       if (I.getVariable()) {
         OS << ' ';
-        dumpBareDeclRef(I.getVariable());
+        NodeDumper.dumpBareDeclRef(I.getVariable());
       }
       if (I.hasCopyExpr())
         dumpStmt(I.getCopyExpr());
     });
   }
   dumpStmt(D->getBody());
 }
 
void ASTDumper::dumpStmt(const Stmt *S) {
   });
 }
 
 void ASTDumper::VisitStmt(const Stmt *Node) {
   {
     ColorScope Color(OS, ShowColors, StmtColor);
     OS << Node->getStmtClassName();
   }
-  dumpPointer(Node);
-  dumpSourceRange(Node->getSourceRange());
+  NodeDumper.dumpPointer(Node);
+  NodeDumper.dumpSourceRange(Node->getSourceRange());
 }
 
 void ASTDumper::VisitDeclStmt(const DeclStmt *Node) {
   VisitStmt(Node);
   for (DeclStmt::const_decl_iterator I = Node->decl_begin(),
                                      E = Node->decl_end();
        I != E; ++I)
     dumpDecl(*I);

 void ASTDumper::VisitLabelStmt(const LabelStmt *Node) {
   VisitStmt(Node);
   OS << " '" << Node->getName() << "'";
 }
 
 void ASTDumper::VisitGotoStmt(const GotoStmt *Node) {
   VisitStmt(Node);
   OS << " '" << Node->getLabel()->getName() << "'";
-  dumpPointer(Node->getLabel());
+  NodeDumper.dumpPointer(Node->getLabel());
 }
 
 void ASTDumper::VisitCXXCatchStmt(const CXXCatchStmt *Node) {
   VisitStmt(Node);
   dumpDecl(Node->getExceptionDecl());
 }
 
 void ASTDumper::VisitCaseStmt(const CaseStmt *Node) {
dumpChild([=] {
         return;
       }
       {
         ColorScope Color(OS, ShowColors, AttrColor);
         StringRef ClauseName(getOpenMPClauseName(C->getClauseKind()));
         OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
            << ClauseName.drop_front() << "Clause";
       }
-      dumpPointer(C);
-      dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
+      NodeDumper.dumpPointer(C);
+      NodeDumper.dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
       if (C->isImplicit())
         OS << " <implicit>";
       for (auto *S : C->children())
         dumpStmt(S);
     });
   }
 }
 
 //===----------------------------------------------------------------------===//
 //  Expr dumping methods.
 //===----------------------------------------------------------------------===//
 
 void ASTDumper::VisitExpr(const Expr *Node) {
   VisitStmt(Node);
-  dumpType(Node->getType());
+  NodeDumper.dumpType(Node->getType());
 
   {
     ColorScope Color(OS, ShowColors, ValueKindColor);
     switch (Node->getValueKind()) {
     case VK_RValue:
       break;
     case VK_LValue:
       OS << " lvalue";
void ASTDumper::VisitImplicitCastExpr(const ImplicitCastExpr *Node) {
   if (Node->isPartOfExplicitCast())
     OS << " part_of_explicit_cast";
 }
 
 void ASTDumper::VisitDeclRefExpr(const DeclRefExpr *Node) {
   VisitExpr(Node);
 
   OS << " ";
-  dumpBareDeclRef(Node->getDecl());
+  NodeDumper.dumpBareDeclRef(Node->getDecl());
   if (Node->getDecl() != Node->getFoundDecl()) {
     OS << " (";
-    dumpBareDeclRef(Node->getFoundDecl());
+    NodeDumper.dumpBareDeclRef(Node->getFoundDecl());
     OS << ")";
   }
 }
 
 void ASTDumper::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node) {
   VisitExpr(Node);
   OS << " (";
   if (!Node->requiresADL())
     OS << "no ";
   OS << "ADL) = '" << Node->getName() << '\'';
 
   UnresolvedLookupExpr::decls_iterator
     I = Node->decls_begin(), E = Node->decls_end();
   if (I == E)
     OS << " empty";
   for (; I != E; ++I)
-    dumpPointer(*I);
+    NodeDumper.dumpPointer(*I);
 }
 
 void ASTDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) {
   VisitExpr(Node);
 
   {
     ColorScope Color(OS, ShowColors, DeclKindNameColor);
     OS << " " << Node->getDecl()->getDeclKindName() << "Decl";
   }
   OS << "='" << *Node->getDecl() << "'";
-  dumpPointer(Node->getDecl());
+  NodeDumper.dumpPointer(Node->getDecl());
   if (Node->isFreeIvar())
     OS << " isFreeIvar";
 }
 
 void ASTDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
   VisitExpr(Node);
   OS << " " << PredefinedExpr::getIdentKindName(Node->getIdentKind());
 }
void ASTDumper::VisitInitListExpr(const InitListExpr *ILE) {
   if (auto *Filler = ILE->getArrayFiller()) {
     dumpChild([=] {
       OS << "array filler";
       dumpStmt(Filler);
     });
   }
   if (auto *Field = ILE->getInitializedFieldInUnion()) {
     OS << " field ";
-    dumpBareDeclRef(Field);
+    NodeDumper.dumpBareDeclRef(Field);
   }
 }
 
 void ASTDumper::VisitUnaryOperator(const UnaryOperator *Node) {
   VisitExpr(Node);
   OS << " " << (Node->isPostfix() ? "postfix" : "prefix")
      << " '" << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
   if (!Node->canOverflow())
void ASTDumper::VisitUnaryExprOrTypeTraitExpr(
   case UETT_OpenMPRequiredSimdAlign:
     OS << " __builtin_omp_required_simd_align";
     break;
   case UETT_PreferredAlignOf:
     OS << " __alignof";
     break;
   }
   if (Node->isArgumentType())
-    dumpType(Node->getArgumentType());
+    NodeDumper.dumpType(Node->getArgumentType());
 }
 
 void ASTDumper::VisitMemberExpr(const MemberExpr *Node) {
   VisitExpr(Node);
   OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl();
-  dumpPointer(Node->getMemberDecl());
+  NodeDumper.dumpPointer(Node->getMemberDecl());
 }
 
 void ASTDumper::VisitExtVectorElementExpr(const ExtVectorElementExpr *Node) {
   VisitExpr(Node);
   OS << " " << Node->getAccessor().getNameStart();
 }
 
 void ASTDumper::VisitBinaryOperator(const BinaryOperator *Node) {
   VisitExpr(Node);
   OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
 }
 
 void ASTDumper::VisitCompoundAssignOperator(
     const CompoundAssignOperator *Node) {
   VisitExpr(Node);
   OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
      << "' ComputeLHSTy=";
-  dumpBareType(Node->getComputationLHSType());
+  NodeDumper.dumpBareType(Node->getComputationLHSType());
   OS << " ComputeResultTy=";
-  dumpBareType(Node->getComputationResultType());
+  NodeDumper.dumpBareType(Node->getComputationResultType());
 }
 
 void ASTDumper::VisitBlockExpr(const BlockExpr *Node) {
   VisitExpr(Node);
   dumpDecl(Node->getBlockDecl());
 }
 
 void ASTDumper::VisitOpaqueValueExpr(const OpaqueValueExpr *Node) {
if (E->isResultDependent())
     OS << " result_dependent";
   dumpStmt(E->getControllingExpr());
   dumpTypeAsChild(E->getControllingExpr()->getType()); // FIXME: remove
 
   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
     dumpChild([=] {
       if (const TypeSourceInfo *TSI = E->getAssocTypeSourceInfo(I)) {
         OS << "case ";
-        dumpType(TSI->getType());
+        NodeDumper.dumpType(TSI->getType());
       } else {
         OS << "default";
       }
 
       if (!E->isResultDependent() && E->getResultIndex() == I)
         OS << " selected";
 
       if (const TypeSourceInfo *TSI = E->getAssocTypeSourceInfo(I))
         dumpTypeAsChild(TSI->getType());
       dumpStmt(E->getAssocExpr(I));
     });
   }
 }
 
 // GNU extensions.
 
 void ASTDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) {
   VisitExpr(Node);
   OS << " " << Node->getLabel()->getName();
-  dumpPointer(Node->getLabel());
+  NodeDumper.dumpPointer(Node->getLabel());
 }
 
 //===----------------------------------------------------------------------===//
 // C++ Expressions
 //===----------------------------------------------------------------------===//
 
 void ASTDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) {
   VisitExpr(Node);
void ASTDumper::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node) {
   VisitExpr(Node);
   OS << " functional cast to " << Node->getTypeAsWritten().getAsString()
      << " <" << Node->getCastKindName() << ">";
 }
 
 void ASTDumper::VisitCXXUnresolvedConstructExpr(
     const CXXUnresolvedConstructExpr *Node) {
   VisitExpr(Node);
-  dumpType(Node->getTypeAsWritten());
+  NodeDumper.dumpType(Node->getTypeAsWritten());
   if (Node->isListInitialization())
     OS << " list";
 }
 
 void ASTDumper::VisitCXXConstructExpr(const CXXConstructExpr *Node) {
   VisitExpr(Node);
   CXXConstructorDecl *Ctor = Node->getConstructor();
-  dumpType(Ctor->getType());
+  NodeDumper.dumpType(Ctor->getType());
   if (Node->isElidable())
     OS << " elidable";
   if (Node->isListInitialization())
     OS << " list";
   if (Node->isStdInitListInitialization())
     OS << " std::initializer_list";
   if (Node->requiresZeroInitialization())
     OS << " zeroing";
 }
 
 void ASTDumper::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node) {
   VisitExpr(Node);
   OS << " ";
-  dumpCXXTemporary(Node->getTemporary());
+  NodeDumper.dumpCXXTemporary(Node->getTemporary());
 }
 
 void ASTDumper::VisitCXXNewExpr(const CXXNewExpr *Node) {
   VisitExpr(Node);
   if (Node->isGlobalNew())
     OS << " global";
   if (Node->isArray())
     OS << " array";
   if (Node->getOperatorNew()) {
     OS << ' ';
-    dumpBareDeclRef(Node->getOperatorNew());
+    NodeDumper.dumpBareDeclRef(Node->getOperatorNew());
   }
   // We could dump the deallocation function used in case of error, but it's
   // usually not that interesting.
 }
 
 void ASTDumper::VisitCXXDeleteExpr(const CXXDeleteExpr *Node) {
   VisitExpr(Node);
   if (Node->isGlobalDelete())
     OS << " global";
   if (Node->isArrayForm())
     OS << " array";
   if (Node->getOperatorDelete()) {
     OS << ' ';
-    dumpBareDeclRef(Node->getOperatorDelete());
+    NodeDumper.dumpBareDeclRef(Node->getOperatorDelete());
   }
 }
 
 void
 ASTDumper::VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node) {
   VisitExpr(Node);
   if (const ValueDecl *VD = Node->getExtendingDecl()) {
     OS << " extended by ";
-    dumpBareDeclRef(VD);
+    NodeDumper.dumpBareDeclRef(VD);
   }
 }
 
 void ASTDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) {
   VisitExpr(Node);
   for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i)
     dumpDeclRef(Node->getObject(i), "cleanup");
 }
 
-void ASTDumper::dumpCXXTemporary(const CXXTemporary *Temporary) {
-  OS << "(CXXTemporary";
-  dumpPointer(Temporary);
-  OS << ")";
-}
-
 void ASTDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
   VisitExpr(Node);
-  dumpPointer(Node->getPack());
-  dumpName(Node->getPack());
+  NodeDumper.dumpPointer(Node->getPack());
+  NodeDumper.dumpName(Node->getPack());
   if (Node->isPartiallySubstituted())
     for (const auto &A : Node->getPartialArguments())
       dumpTemplateArgument(A);
 }
 
 void ASTDumper::VisitCXXDependentScopeMemberExpr(
     const CXXDependentScopeMemberExpr *Node) {
   VisitExpr(Node);
void ASTDumper::VisitObjCMessageExpr(const ObjCMessageExpr *Node) {
   OS << " selector=";
   Node->getSelector().print(OS);
   switch (Node->getReceiverKind()) {
   case ObjCMessageExpr::Instance:
     break;
 
   case ObjCMessageExpr::Class:
     OS << " class=";
-    dumpBareType(Node->getClassReceiver());
+    NodeDumper.dumpBareType(Node->getClassReceiver());
     break;
 
   case ObjCMessageExpr::SuperInstance:
     OS << " super (instance)";
     break;
 
   case ObjCMessageExpr::SuperClass:
     OS << " super (class)";
void ASTDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
   if (const VarDecl *CatchParam = Node->getCatchParamDecl())
     dumpDecl(CatchParam);
   else
     OS << " catch all";
 }
 
 void ASTDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) {
   VisitExpr(Node);
-  dumpType(Node->getEncodedType());
+  NodeDumper.dumpType(Node->getEncodedType());
 }
 
 void ASTDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *Node) {
   VisitExpr(Node);
 
   OS << " ";
   Node->getSelector().print(OS);
 }
if (!C) {
       OS << "<<<NULL>>>";
       return;
     }
 
     {
       ColorScope Color(OS, ShowColors, CommentColor);
       OS << C->getCommentKindName();
     }
-    dumpPointer(C);
-    dumpSourceRange(C->getSourceRange());
+    NodeDumper.dumpPointer(C);
+    NodeDumper.dumpSourceRange(C->getSourceRange());
     ConstCommentVisitor<ASTDumper, void, const FullComment *>::visit(C, FC);
     for (Comment::child_iterator I = C->child_begin(), E = C->child_end();
          I != E; ++I)
       dumpComment(*I, FC);
   });
 }
 
 void ASTDumper::visitTextComment(const TextComment *C, const FullComment *) {

lib/AST/CMakeLists.txt

add_clang_library(clangAST
   StmtIterator.cpp
   StmtObjC.cpp
   StmtOpenMP.cpp
   StmtPrinter.cpp
   StmtProfile.cpp
   StmtViz.cpp
   TemplateBase.cpp
   TemplateName.cpp
+  TextNodeDumper.cpp
   Type.cpp
   TypeLoc.cpp
   TypePrinter.cpp
   VTableBuilder.cpp
   VTTBuilder.cpp
 
   LINK_LIBS
   clangBasic
   clangLex
   )

lib/AST/TextNodeDumper.cpp

+//===--- TextNodeDumper.cpp - Printing of AST nodes -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements AST dumping of components of individual AST nodes.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/TextNodeDumper.h"
+
+using namespace clang;
+
+TextNodeDumper::TextNodeDumper(raw_ostream &OS, bool ShowColors,
+                               const SourceManager *SM,
+                               const PrintingPolicy &PrintPolicy)
+    : OS(OS), ShowColors(ShowColors), SM(SM), PrintPolicy(PrintPolicy) {}
+
+void TextNodeDumper::dumpPointer(const void *Ptr) {
+  ColorScope Color(OS, ShowColors, AddressColor);
+  OS << ' ' << Ptr;
+}
+
+void TextNodeDumper::dumpLocation(SourceLocation Loc) {
+  if (!SM)
+    return;
+
+  ColorScope Color(OS, ShowColors, LocationColor);
+  SourceLocation SpellingLoc = SM->getSpellingLoc(Loc);
+
+  // The general format we print out is filename:line:col, but we drop pieces
+  // that haven't changed since the last loc printed.
+  PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc);
+
+  if (PLoc.isInvalid()) {
+    OS << "<invalid sloc>";
+    return;
+  }
+
+  if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) {
+    OS << PLoc.getFilename() << ':' << PLoc.getLine() << ':'
+       << PLoc.getColumn();
+    LastLocFilename = PLoc.getFilename();
+    LastLocLine = PLoc.getLine();
+  } else if (PLoc.getLine() != LastLocLine) {
+    OS << "line" << ':' << PLoc.getLine() << ':' << PLoc.getColumn();
+    LastLocLine = PLoc.getLine();
+  } else {
+    OS << "col" << ':' << PLoc.getColumn();
+  }
+}
+
+void TextNodeDumper::dumpSourceRange(SourceRange R) {
+  // Can't translate locations if a SourceManager isn't available.
+  if (!SM)
+    return;
+
+  OS << " <";
+  dumpLocation(R.getBegin());
+  if (R.getBegin() != R.getEnd()) {
+    OS << ", ";
+    dumpLocation(R.getEnd());
+  }
+  OS << ">";
+
+  // <t2.c:123:421[blah], t2.c:412:321>
+}
+
+void TextNodeDumper::dumpBareType(QualType T, bool Desugar) {
+  ColorScope Color(OS, ShowColors, TypeColor);
+
+  SplitQualType T_split = T.split();
+  OS << "'" << QualType::getAsString(T_split, PrintPolicy) << "'";
+
+  if (Desugar && !T.isNull()) {
+    // If the type is sugared, also dump a (shallow) desugared type.
+    SplitQualType D_split = T.getSplitDesugaredType();
+    if (T_split != D_split)
+      OS << ":'" << QualType::getAsString(D_split, PrintPolicy) << "'";
+  }
+}
+
+void TextNodeDumper::dumpType(QualType T) {
+  OS << ' ';
+  dumpBareType(T);
+}
+
+void TextNodeDumper::dumpBareDeclRef(const Decl *D) {
+  if (!D) {
+    ColorScope Color(OS, ShowColors, NullColor);
+    OS << "<<<NULL>>>";
+    return;
+  }
+
+  {
+    ColorScope Color(OS, ShowColors, DeclKindNameColor);
+    OS << D->getDeclKindName();
+  }
+  dumpPointer(D);
+
+  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
+    ColorScope Color(OS, ShowColors, DeclNameColor);
+    OS << " '" << ND->getDeclName() << '\'';
+  }
+
+  if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
+    dumpType(VD->getType());
+}
+
+void TextNodeDumper::dumpName(const NamedDecl *ND) {
+  if (ND->getDeclName()) {
+    ColorScope Color(OS, ShowColors, DeclNameColor);
+    OS << ' ' << ND->getNameAsString();
+  }
+}
+
+void TextNodeDumper::dumpAccessSpecifier(AccessSpecifier AS) {
+  switch (AS) {
+  case AS_none:
+    break;
+  case AS_public:
+    OS << "public";
+    break;
+  case AS_protected:
+    OS << "protected";
+    break;
+  case AS_private:
+    OS << "private";
+    break;
+  }
+}
+
+void TextNodeDumper::dumpCXXTemporary(const CXXTemporary *Temporary) {
+  OS << "(CXXTemporary";
+  dumpPointer(Temporary);
+  OS << ")";
+}