[Syntax] Add syntax-tree-dump in clang-check.

[hokein]

Summary

This is useful to experiment/develop syntax trees.

[sammccall]

clang/tools/clang-check/ClangCheck.cpp

141

DumpSyntaxTree since this is used for its side-effect?

152

ooh, we should consider colorizing this one day :-)

[hokein]

address comment.

clang/test/Tooling/clang-check-syntax-tree-dump.cpp

+// RUN: clang-check -syntax-tree-dump "%s" -- 2>&1 | FileCheck %s
+int abc;
+// CHECK:      TranslationUnit Detached
+// CHECK-NEXT: `-SimpleDeclaration
+// CHECK-NEXT:   |-'int'
+// CHECK-NEXT:   |-DeclaratorList Declarators
+// CHECK-NEXT:   | `-SimpleDeclarator ListElement
+// CHECK-NEXT:   |   `-'abc'
+// CHECK-NEXT:   `-';'

clang/tools/clang-check/CMakeLists.txt

clang_target_link_libraries(clang-check
   clangAST
   clangBasic
   clangDriver
   clangFrontend
   clangRewriteFrontend
   clangSerialization
   clangStaticAnalyzerFrontend
   clangTooling
+  clangToolingSyntax
   )

clang/tools/clang-check/ClangCheck.cpp

 #include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
 #include "clang/Driver/Options.h"
 #include "clang/Frontend/ASTConsumers.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Rewrite/Frontend/FixItRewriter.h"
 #include "clang/Rewrite/Frontend/FrontendActions.h"
 #include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
 #include "clang/Tooling/CommonOptionsParser.h"
+#include "clang/Tooling/Syntax/BuildTree.h"
+#include "clang/Tooling/Syntax/Tokens.h"
+#include "clang/Tooling/Syntax/Tree.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 
 using namespace clang::driver;

 static cl::opt<bool>
     Fixit("fixit", cl::desc(Options.getOptionHelpText(options::OPT_fixit)),
           cl::cat(ClangCheckCategory));
 static cl::opt<bool> FixWhatYouCan(
     "fix-what-you-can",
     cl::desc(Options.getOptionHelpText(options::OPT_fix_what_you_can)),
     cl::cat(ClangCheckCategory));
 
+static cl::opt<bool> SyntaxTreeDump("syntax-tree-dump",
+                                    cl::desc("dump the syntax tree"),
+                                    cl::cat(ClangCheckCategory));
+
 namespace {
 
 // FIXME: Move FixItRewriteInPlace from lib/Rewrite/Frontend/FrontendActions.cpp
 // into a header file and reuse that.
 class FixItOptions : public clang::FixItOptions {
 public:
   FixItOptions() {
     FixWhatYouCan = ::FixWhatYouCan;
public:
   bool BeginSourceFileAction(clang::CompilerInstance& CI) override {
     FixItOpts.reset(new FixItOptions);
     Rewriter.reset(new FixItRewriter(CI.getDiagnostics(), CI.getSourceManager(),
                                      CI.getLangOpts(), FixItOpts.get()));
     return true;
   }
 };
 
+class DumpSyntaxTree : public clang::ASTFrontendAction {
+public:
+  std::unique_ptr<clang::ASTConsumer>
+  CreateASTConsumer(clang::CompilerInstance &CI, StringRef InFile) override {
+    class Consumer : public clang::ASTConsumer {
+    public:
+      Consumer(clang::CompilerInstance &CI) : Collector(CI.getPreprocessor()) {}
+
+      void HandleTranslationUnit(clang::ASTContext &AST) override {
+        clang::syntax::TokenBuffer TB = std::move(Collector).consume();
+        clang::syntax::Arena A(AST.getSourceManager(), AST.getLangOpts(), TB);
+        llvm::outs() << clang::syntax::buildSyntaxTree(A, AST)->dump(
+            AST.getSourceManager());
+      }
+
+    private:
+      clang::syntax::TokenCollector Collector;
+    };
+    return std::make_unique<Consumer>(CI);
+  }
+};
+
 class ClangCheckActionFactory {
 public:
   std::unique_ptr<clang::ASTConsumer> newASTConsumer() {
     if (ASTList)
       return clang::CreateASTDeclNodeLister();
     if (ASTDump)
       return clang::CreateASTDumper(nullptr /*Dump to stdout.*/, ASTDumpFilter,
                                     /*DumpDecls=*/true,
int main(int argc, const char **argv) {
   ClangCheckActionFactory CheckFactory;
   std::unique_ptr<FrontendActionFactory> FrontendFactory;
 
   // Choose the correct factory based on the selected mode.
   if (Analyze)
     FrontendFactory = newFrontendActionFactory<clang::ento::AnalysisAction>();
   else if (Fixit)
     FrontendFactory = newFrontendActionFactory<ClangCheckFixItAction>();
+  else if (SyntaxTreeDump)
+    FrontendFactory = newFrontendActionFactory<DumpSyntaxTree>();
   else
     FrontendFactory = newFrontendActionFactory(&CheckFactory);
 
   return Tool.run(FrontendFactory.get());
 }