[AST] Extract ASTNodeTraverser class from ASTDumper

Summary:
This new traverser class allows clients to re-use the traversal logic
which was previously part of ASTDumper.  This means that alternative
visit logic may be implemented, such as

* Dump to alternative data formats such as JSON
* Implement AST Matcher parent/child visitation matching AST dumps

Reviewers: aaron.ballman

Subscribers: jfb, cfe-commits

Differential Revision: https://reviews.llvm.org/D57472

llvm-svn: 352989

1 files changed, 29 insertions, 558 deletions

diff --git a/clang/lib/AST/ASTDumper.cpp b/clang/lib/AST/ASTDumper.cpp
index e539290fccf..f8938512afe 100644
--- a/clang/lib/AST/ASTDumper.cpp
+++ b/clang/lib/AST/ASTDumper.cpp
@@ -12,20 +12,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTContext.h"
-#include "clang/AST/ASTDumperUtils.h"
-#include "clang/AST/Attr.h"
-#include "clang/AST/AttrVisitor.h"
-#include "clang/AST/CommentVisitor.h"
-#include "clang/AST/DeclCXX.h"
+#include "clang/AST/ASTNodeTraverser.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/TemplateArgumentVisitor.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"
@@ -39,562 +28,44 @@ using namespace clang::comments;
 
 namespace  {
 
-  class ASTDumper
-      : public ConstDeclVisitor<ASTDumper>,
-        public ConstStmtVisitor<ASTDumper>,
-        public ConstCommentVisitor<ASTDumper, void, const FullComment *>,
-        public TypeVisitor<ASTDumper>,
-        public ConstAttrVisitor<ASTDumper>,
-        public ConstTemplateArgumentVisitor<ASTDumper> {
+class ASTDumper : public ASTNodeTraverser<ASTDumper, TextNodeDumper> {
 
-    TextNodeDumper NodeDumper;
+  TextNodeDumper NodeDumper;
 
-    raw_ostream &OS;
+  raw_ostream &OS;
 
-    /// Indicates whether we should trigger deserialization of nodes that had
-    /// not already been loaded.
-    bool Deserialize = false;
+  const bool ShowColors;
 
-    const bool ShowColors;
+public:
+  ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
+            const SourceManager *SM)
+      : ASTDumper(OS, Traits, SM, SM && SM->getDiagnostics().getShowColors()) {}
 
-  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)
+      : NodeDumper(OS, ShowColors, SM, PrintPolicy, Traits), OS(OS),
+        ShowColors(ShowColors) {}
 
-    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)
-        : NodeDumper(OS, ShowColors, SM, PrintPolicy, Traits), OS(OS),
-          ShowColors(ShowColors) {}
+  TextNodeDumper &doGetNodeDelegate() { return NodeDumper; }
 
-    void setDeserialize(bool D) { Deserialize = D; }
+  void dumpLookups(const DeclContext *DC, bool DumpDecls);
 
-    void Visit(const Decl *D) {
-      NodeDumper.AddChild([=] {
-        NodeDumper.Visit(D);
-        if (!D)
-          return;
-
-        ConstDeclVisitor<ASTDumper>::Visit(D);
-
-        for (const auto &A : D->attrs())
-          Visit(A);
-
-        if (const FullComment *Comment =
-                D->getASTContext().getLocalCommentForDeclUncached(D))
-          Visit(Comment, Comment);
-
-        // Decls within functions are visited by the body.
-        if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)) {
-          if (const auto *DC = dyn_cast<DeclContext>(D))
-            dumpDeclContext(DC);
-        }
-      });
-    }
-
-    void Visit(const Stmt *S, StringRef Label = {}) {
-      NodeDumper.AddChild(Label, [=] {
-        NodeDumper.Visit(S);
-
-        if (!S) {
-          return;
-        }
-
-        ConstStmtVisitor<ASTDumper>::Visit(S);
-
-        // Some statements have custom mechanisms for dumping their children.
-        if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)) {
-          return;
-        }
-
-        for (const Stmt *SubStmt : S->children())
-          Visit(SubStmt);
-      });
-    }
-
-    void Visit(QualType T) {
-      SplitQualType SQT = T.split();
-      if (!SQT.Quals.hasQualifiers())
-        return Visit(SQT.Ty);
-
-      NodeDumper.AddChild([=] {
-        NodeDumper.Visit(T);
-        Visit(T.split().Ty);
-      });
-    }
-
-    void Visit(const Type *T) {
-      NodeDumper.AddChild([=] {
-        NodeDumper.Visit(T);
-        if (!T)
-          return;
-        TypeVisitor<ASTDumper>::Visit(T);
-
-        QualType SingleStepDesugar =
-            T->getLocallyUnqualifiedSingleStepDesugaredType();
-        if (SingleStepDesugar != QualType(T, 0))
-          Visit(SingleStepDesugar);
-      });
-    }
-
-    void Visit(const Attr *A) {
-      NodeDumper.AddChild([=] {
-        NodeDumper.Visit(A);
-        ConstAttrVisitor<ASTDumper>::Visit(A);
-      });
-    }
-
-    void Visit(const CXXCtorInitializer *Init) {
-      NodeDumper.AddChild([=] {
-        NodeDumper.Visit(Init);
-        Visit(Init->getInit());
-      });
-    }
-
-    void Visit(const TemplateArgument &A, SourceRange R = {},
-               const Decl *From = nullptr, const char *Label = nullptr) {
-      NodeDumper.AddChild([=] {
-        NodeDumper.Visit(A, R, From, Label);
-        ConstTemplateArgumentVisitor<ASTDumper>::Visit(A);
-      });
-    }
-
-    void Visit(const BlockDecl::Capture &C) {
-      NodeDumper.AddChild([=] {
-        NodeDumper.Visit(C);
-        if (C.hasCopyExpr())
-          Visit(C.getCopyExpr());
-      });
-    }
-
-    void Visit(const OMPClause *C) {
-      NodeDumper.AddChild([=] {
-        NodeDumper.Visit(C);
-        for (const auto *S : C->children())
-          Visit(S);
-      });
-    }
-
-    void Visit(const GenericSelectionExpr::ConstAssociation &A) {
-      NodeDumper.AddChild([=] {
-        NodeDumper.Visit(A);
-        if (const TypeSourceInfo *TSI = A.getTypeSourceInfo())
-          Visit(TSI->getType());
-        Visit(A.getAssociationExpr());
-      });
-    }
-
-    void Visit(const Comment *C, const FullComment *FC) {
-      NodeDumper.AddChild([=] {
-        NodeDumper.Visit(C, FC);
-        if (!C) {
-          return;
-        }
-        ConstCommentVisitor<ASTDumper, void, const FullComment *>::visit(C, FC);
-        for (Comment::child_iterator I = C->child_begin(), E = C->child_end();
-             I != E; ++I)
-          Visit(*I, FC);
-      });
-    }
-
-    void dumpDeclContext(const DeclContext *DC);
-    void dumpLookups(const DeclContext *DC, bool DumpDecls);
-
-    void dumpTemplateParameters(const TemplateParameterList *TPL) {
-      if (!TPL)
-        return;
-
-      for (const auto &TP : *TPL)
-        Visit(TP);
-    }
-
-    void dumpTemplateArgumentListInfo(const TemplateArgumentListInfo &TALI) {
-      for (const auto &TA : TALI.arguments())
-        dumpTemplateArgumentLoc(TA);
-    }
-
-    void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A,
-                                 const Decl *From = nullptr,
-                                 const char *Label = nullptr) {
-      Visit(A.getArgument(), A.getSourceRange(), From, Label);
-    }
-
-    void dumpTemplateArgumentList(const TemplateArgumentList &TAL) {
-      for (unsigned i = 0, e = TAL.size(); i < e; ++i)
-        Visit(TAL[i]);
-    }
-
-    void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams) {
-      if (!typeParams)
-        return;
-
-      for (const auto &typeParam : *typeParams) {
-        Visit(typeParam);
-      }
-    }
-
-    void VisitComplexType(const ComplexType *T) { Visit(T->getElementType()); }
-    void VisitLocInfoType(const LocInfoType *T) {
-      Visit(T->getTypeSourceInfo()->getType());
-    }
-    void VisitPointerType(const PointerType *T) { Visit(T->getPointeeType()); }
-    void VisitBlockPointerType(const BlockPointerType *T) {
-      Visit(T->getPointeeType());
-    }
-    void VisitReferenceType(const ReferenceType *T) {
-      Visit(T->getPointeeType());
-    }
-    void VisitMemberPointerType(const MemberPointerType *T) {
-      Visit(T->getClass());
-      Visit(T->getPointeeType());
-    }
-    void VisitArrayType(const ArrayType *T) { Visit(T->getElementType()); }
-    void VisitVariableArrayType(const VariableArrayType *T) {
-      VisitArrayType(T);
-      Visit(T->getSizeExpr());
-    }
-    void VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
-      Visit(T->getElementType());
-      Visit(T->getSizeExpr());
-    }
-    void
-    VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T) {
-      Visit(T->getElementType());
-      Visit(T->getSizeExpr());
-    }
-    void VisitVectorType(const VectorType *T) { Visit(T->getElementType()); }
-    void VisitFunctionType(const FunctionType *T) { Visit(T->getReturnType()); }
-    void VisitFunctionProtoType(const FunctionProtoType *T) {
-      VisitFunctionType(T);
-      for (const QualType &PT : T->getParamTypes())
-        Visit(PT);
-    }
-    void VisitTypeOfExprType(const TypeOfExprType *T) {
-      Visit(T->getUnderlyingExpr());
-    }
-    void VisitDecltypeType(const DecltypeType *T) {
-      Visit(T->getUnderlyingExpr());
-    }
-    void VisitUnaryTransformType(const UnaryTransformType *T) {
-      Visit(T->getBaseType());
-    }
-    void VisitAttributedType(const AttributedType *T) {
-      // FIXME: AttrKind
-      Visit(T->getModifiedType());
-    }
-    void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
-      Visit(T->getReplacedParameter());
-    }
-    void
-    VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {
-      Visit(T->getReplacedParameter());
-      Visit(T->getArgumentPack());
-    }
-    void VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
-      for (const auto &Arg : *T)
-        Visit(Arg);
-      if (T->isTypeAlias())
-        Visit(T->getAliasedType());
-    }
-    void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
-      Visit(T->getPointeeType());
-    }
-    void VisitAtomicType(const AtomicType *T) { Visit(T->getValueType()); }
-    void VisitPipeType(const PipeType *T) { Visit(T->getElementType()); }
-    void VisitAdjustedType(const AdjustedType *T) {
-      Visit(T->getOriginalType());
-    }
-    void VisitPackExpansionType(const PackExpansionType *T) {
-      if (!T->isSugared())
-        Visit(T->getPattern());
-    }
-    // FIXME: ElaboratedType, DependentNameType,
-    // DependentTemplateSpecializationType, ObjCObjectType
-
-    void VisitTypedefDecl(const TypedefDecl *D) {
-      Visit(D->getUnderlyingType());
-    }
-
-    void VisitEnumConstantDecl(const EnumConstantDecl *D) {
-      if (const Expr *Init = D->getInitExpr())
-        Visit(Init);
-    }
-
-    void VisitFunctionDecl(const FunctionDecl *D) {
-      if (const auto *FTSI = D->getTemplateSpecializationInfo())
-        dumpTemplateArgumentList(*FTSI->TemplateArguments);
-
-      if (D->param_begin())
-        for (const auto *Parameter : D->parameters())
-          Visit(Parameter);
-
-      if (const auto *C = dyn_cast<CXXConstructorDecl>(D))
-        for (const auto *I : C->inits())
-          Visit(I);
+  template <typename SpecializationDecl>
+  void dumpTemplateDeclSpecialization(const SpecializationDecl *D,
+                                      bool DumpExplicitInst, bool DumpRefOnly);
+  template <typename TemplateDecl>
+  void dumpTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst);
 
-      if (D->doesThisDeclarationHaveABody())
-        Visit(D->getBody());
-    }
-
-    void VisitFieldDecl(const FieldDecl *D) {
-      if (D->isBitField())
-        Visit(D->getBitWidth());
-      if (Expr *Init = D->getInClassInitializer())
-        Visit(Init);
-    }
-
-    void VisitVarDecl(const VarDecl *D) {
-      if (D->hasInit())
-        Visit(D->getInit());
-    }
-
-    void VisitDecompositionDecl(const DecompositionDecl *D) {
-      VisitVarDecl(D);
-      for (const auto *B : D->bindings())
-        Visit(B);
-    }
-
-    void VisitBindingDecl(const BindingDecl *D) {
-      if (const auto *E = D->getBinding())
-        Visit(E);
-    }
-
-    void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) {
-      Visit(D->getAsmString());
-    }
-
-    void VisitCapturedDecl(const CapturedDecl *D) { Visit(D->getBody()); }
-
-    void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) {
-      for (const auto *E : D->varlists())
-        Visit(E);
-    }
-
-    void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) {
-      Visit(D->getCombiner());
-      if (const auto *Initializer = D->getInitializer())
-        Visit(Initializer);
-    }
-
-    void VisitOMPDeclareMapperDecl(const OMPDeclareMapperDecl *D) {
-      for (const auto *C : D->clauselists())
-        Visit(C);
-    }
-
-    void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) {
-      Visit(D->getInit());
-    }
-
-    template <typename SpecializationDecl>
-    void dumpTemplateDeclSpecialization(const SpecializationDecl *D,
-                                        bool DumpExplicitInst,
-                                        bool DumpRefOnly);
-    template <typename TemplateDecl>
-    void dumpTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst);
-
-    void VisitTypeAliasDecl(const TypeAliasDecl *D) {
-      Visit(D->getUnderlyingType());
-    }
-
-    void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) {
-      dumpTemplateParameters(D->getTemplateParameters());
-      Visit(D->getTemplatedDecl());
-    }
-
-    void VisitStaticAssertDecl(const StaticAssertDecl *D) {
-      Visit(D->getAssertExpr());
-      Visit(D->getMessage());
-    }
-    void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D);
-    void VisitClassTemplateDecl(const ClassTemplateDecl *D);
-
-    void VisitClassTemplateSpecializationDecl(
-        const ClassTemplateSpecializationDecl *D) {
-      dumpTemplateArgumentList(D->getTemplateArgs());
-    }
-
-    void VisitClassTemplatePartialSpecializationDecl(
-        const ClassTemplatePartialSpecializationDecl *D) {
-      VisitClassTemplateSpecializationDecl(D);
-      dumpTemplateParameters(D->getTemplateParameters());
-    }
-
-    void VisitClassScopeFunctionSpecializationDecl(
-        const ClassScopeFunctionSpecializationDecl *D) {
-      Visit(D->getSpecialization());
-      if (D->hasExplicitTemplateArgs())
-        dumpTemplateArgumentListInfo(D->templateArgs());
-    }
-    void VisitVarTemplateDecl(const VarTemplateDecl *D);
-
-    void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) {
-      dumpTemplateParameters(D->getTemplateParameters());
-    }
-
-    void
-    VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl *D) {
-      dumpTemplateArgumentList(D->getTemplateArgs());
-      VisitVarDecl(D);
-    }
-
-    void VisitVarTemplatePartialSpecializationDecl(
-        const VarTemplatePartialSpecializationDecl *D) {
-      dumpTemplateParameters(D->getTemplateParameters());
-      VisitVarTemplateSpecializationDecl(D);
-    }
-
-    void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
-      if (D->hasDefaultArgument())
-        Visit(D->getDefaultArgument(), SourceRange(),
-              D->getDefaultArgStorage().getInheritedFrom(),
-              D->defaultArgumentWasInherited() ? "inherited from" : "previous");
-    }
-
-    void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
-      if (D->hasDefaultArgument())
-        Visit(D->getDefaultArgument(), SourceRange(),
-              D->getDefaultArgStorage().getInheritedFrom(),
-              D->defaultArgumentWasInherited() ? "inherited from" : "previous");
-    }
-
-    void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) {
-      dumpTemplateParameters(D->getTemplateParameters());
-      if (D->hasDefaultArgument())
-        dumpTemplateArgumentLoc(
-            D->getDefaultArgument(),
-            D->getDefaultArgStorage().getInheritedFrom(),
-            D->defaultArgumentWasInherited() ? "inherited from" : "previous");
-    }
-
-    void VisitUsingShadowDecl(const UsingShadowDecl *D) {
-      if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))
-        Visit(TD->getTypeForDecl());
-    }
-
-    void VisitFriendDecl(const FriendDecl *D) {
-      if (!D->getFriendType())
-        Visit(D->getFriendDecl());
-    }
-
-    void VisitObjCMethodDecl(const ObjCMethodDecl *D) {
-      if (D->isThisDeclarationADefinition())
-        dumpDeclContext(D);
-      else
-        for (const ParmVarDecl *Parameter : D->parameters())
-          Visit(Parameter);
-
-      if (D->hasBody())
-        Visit(D->getBody());
-    }
-
-    void VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
-      dumpObjCTypeParamList(D->getTypeParamList());
-    }
-
-    void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
-      dumpObjCTypeParamList(D->getTypeParamListAsWritten());
-    }
-
-    void VisitObjCImplementationDecl(const ObjCImplementationDecl *D) {
-      for (const auto &I : D->inits())
-        Visit(I);
-    }
-
-    void VisitBlockDecl(const BlockDecl *D) {
-      for (const auto &I : D->parameters())
-        Visit(I);
-
-      for (const auto &I : D->captures())
-        Visit(I);
-      Visit(D->getBody());
-    }
-
-    void VisitDeclStmt(const DeclStmt *Node) {
-      for (const auto &D : Node->decls())
-        Visit(D);
-    }
-
-    void VisitAttributedStmt(const AttributedStmt *Node) {
-      for (const auto *A : Node->getAttrs())
-        Visit(A);
-    }
-
-    void VisitCXXCatchStmt(const CXXCatchStmt *Node) {
-      Visit(Node->getExceptionDecl());
-    }
-
-    void VisitCapturedStmt(const CapturedStmt *Node) {
-      Visit(Node->getCapturedDecl());
-    }
-
-    void VisitOMPExecutableDirective(const OMPExecutableDirective *Node) {
-      for (const auto *C : Node->clauses())
-        Visit(C);
-    }
-
-    void VisitInitListExpr(const InitListExpr *ILE) {
-      if (auto *Filler = ILE->getArrayFiller()) {
-        Visit(Filler, "array_filler");
-      }
-    }
-
-    void VisitBlockExpr(const BlockExpr *Node) { Visit(Node->getBlockDecl()); }
-
-    void VisitOpaqueValueExpr(const OpaqueValueExpr *Node) {
-      if (Expr *Source = Node->getSourceExpr())
-        Visit(Source);
-    }
-
-    void VisitGenericSelectionExpr(const GenericSelectionExpr *E) {
-      Visit(E->getControllingExpr());
-      Visit(E->getControllingExpr()->getType()); // FIXME: remove
-
-      for (const auto &Assoc : E->associations()) {
-        Visit(Assoc);
-      }
-    }
-
-    void VisitLambdaExpr(const LambdaExpr *Node) {
-      Visit(Node->getLambdaClass());
-    }
-
-    void VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
-      if (Node->isPartiallySubstituted())
-        for (const auto &A : Node->getPartialArguments())
-          Visit(A);
-    }
-
-    void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
-      if (const VarDecl *CatchParam = Node->getCatchParamDecl())
-        Visit(CatchParam);
-    }
-
-    void VisitExpressionTemplateArgument(const TemplateArgument &TA) {
-      Visit(TA.getAsExpr());
-    }
-    void VisitPackTemplateArgument(const TemplateArgument &TA) {
-      for (const auto &TArg : TA.pack_elements())
-        Visit(TArg);
-    }
-
-    // Implements Visit methods for Attrs.
-#include "clang/AST/AttrNodeTraverse.inc"
-  };
+  void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D);
+  void VisitClassTemplateDecl(const ClassTemplateDecl *D);
+  void VisitVarTemplateDecl(const VarTemplateDecl *D);
+};
 } // namespace
 
-void ASTDumper::dumpDeclContext(const DeclContext *DC) {
-  if (!DC)
-    return;
-
-  for (const auto *D : (Deserialize ? DC->decls() : DC->noload_decls()))
-    Visit(D);
-}
-
 void ASTDumper::dumpLookups(const DeclContext *DC, bool DumpDecls) {
   NodeDumper.AddChild([=] {
     OS << "StoredDeclsMap ";
@@ -608,7 +79,7 @@ void ASTDumper::dumpLookups(const DeclContext *DC, bool DumpDecls) {
 
     bool HasUndeserializedLookups = Primary->hasExternalVisibleStorage();
 
-    auto Range = Deserialize
+    auto Range = getDeserialize()
                      ? Primary->lookups()
                      : Primary->noload_lookups(/*PreserveInternalState=*/true);
     for (auto I = Range.begin(), E = Range.end(); I != E; ++I) {