NFC: Move VisitStmt code to dumpStmt

[steveire]

Summary

This call is duplicated in Visits of all direct subclasses of Stmt.

[aaron.ballman]

LGTM!

lib/AST/ASTDumper.cpp

public:
     void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D);
     void VisitObjCImplementationDecl(const ObjCImplementationDecl *D);
     void VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D);
     void VisitObjCPropertyDecl(const ObjCPropertyDecl *D);
     void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D);
     void VisitBlockDecl(const BlockDecl *D);
 
     // Stmts.
-    void VisitStmt(const Stmt *Node);
     void VisitDeclStmt(const DeclStmt *Node);
     void VisitAttributedStmt(const AttributedStmt *Node);
     void VisitIfStmt(const IfStmt *Node);
     void VisitSwitchStmt(const SwitchStmt *Node);
     void VisitWhileStmt(const WhileStmt *Node);
     void VisitLabelStmt(const LabelStmt *Node);
     void VisitGotoStmt(const GotoStmt *Node);
     void VisitCXXCatchStmt(const CXXCatchStmt *Node);

 
 void ASTDumper::dumpStmt(const Stmt *S) {
   dumpChild([=] {
     if (!S) {
       ColorScope Color(OS, ShowColors, NullColor);
       OS << "<<<NULL>>>";
       return;
     }
+    {
+      ColorScope Color(OS, ShowColors, StmtColor);
+      OS << S->getStmtClassName();
+    }
+    NodeDumper.dumpPointer(S);
+    NodeDumper.dumpSourceRange(S->getSourceRange());
 
     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())
       dumpStmt(SubStmt);
   });
 }
 
-void ASTDumper::VisitStmt(const Stmt *Node) {
-  {
-    ColorScope Color(OS, ShowColors, StmtColor);
-    OS << Node->getStmtClassName();
-  }
-  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::VisitAttributedStmt(const AttributedStmt *Node) {
-  VisitStmt(Node);
   for (ArrayRef<const Attr *>::iterator I = Node->getAttrs().begin(),
                                         E = Node->getAttrs().end();
        I != E; ++I)
     dumpAttr(*I);
 }
 
 void ASTDumper::VisitIfStmt(const IfStmt *Node) {
-  VisitStmt(Node);
   if (Node->hasInitStorage())
     OS << " has_init";
   if (Node->hasVarStorage())
     OS << " has_var";
   if (Node->hasElseStorage())
     OS << " has_else";
 }
 
 void ASTDumper::VisitSwitchStmt(const SwitchStmt *Node) {
-  VisitStmt(Node);
   if (Node->hasInitStorage())
     OS << " has_init";
   if (Node->hasVarStorage())
     OS << " has_var";
 }
 
 void ASTDumper::VisitWhileStmt(const WhileStmt *Node) {
-  VisitStmt(Node);
   if (Node->hasVarStorage())
     OS << " has_var";
 }
 
 void ASTDumper::VisitLabelStmt(const LabelStmt *Node) {
-  VisitStmt(Node);
   OS << " '" << Node->getName() << "'";
 }
 
 void ASTDumper::VisitGotoStmt(const GotoStmt *Node) {
-  VisitStmt(Node);
   OS << " '" << Node->getLabel()->getName() << "'";
   NodeDumper.dumpPointer(Node->getLabel());
 }
 
 void ASTDumper::VisitCXXCatchStmt(const CXXCatchStmt *Node) {
-  VisitStmt(Node);
   dumpDecl(Node->getExceptionDecl());
 }
 
 void ASTDumper::VisitCaseStmt(const CaseStmt *Node) {
-  VisitStmt(Node);
   if (Node->caseStmtIsGNURange())
     OS << " gnu_range";
 }
 
 void ASTDumper::VisitCapturedStmt(const CapturedStmt *Node) {
-  VisitStmt(Node);
   dumpDecl(Node->getCapturedDecl());
 }
 
 //===----------------------------------------------------------------------===//
 //  OpenMP dumping methods.
 //===----------------------------------------------------------------------===//
 
 void ASTDumper::VisitOMPExecutableDirective(
     const OMPExecutableDirective *Node) {
-  VisitStmt(Node);
   for (auto *C : Node->clauses()) {
     dumpChild([=] {
       if (!C) {
         ColorScope Color(OS, ShowColors, NullColor);
         OS << "<<<NULL>>> OMPClause";
         return;
       }
       {
void ASTDumper::VisitOMPExecutableDirective(
   }
 }
 
 //===----------------------------------------------------------------------===//
 //  Expr dumping methods.
 //===----------------------------------------------------------------------===//
 
 void ASTDumper::VisitExpr(const Expr *Node) {
-  VisitStmt(Node);
   NodeDumper.dumpType(Node->getType());
 
   {
     ColorScope Color(OS, ShowColors, ValueKindColor);
     switch (Node->getValueKind()) {
     case VK_RValue:
       break;
     case VK_LValue:
void ASTDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *Node) {
   VisitExpr(Node);
   if (auto *BoxingMethod = Node->getBoxingMethod()) {
     OS << " selector=";
     BoxingMethod->getSelector().print(OS);
   }
 }
 
 void ASTDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
-  VisitStmt(Node);
   if (const VarDecl *CatchParam = Node->getCatchParamDecl())
     dumpDecl(CatchParam);
   else
     OS << " catch all";
 }
 
 void ASTDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) {
   VisitExpr(Node);