Set up clang-tidy diagnostic consumer to print types etc.

[alexfh]

Now it doesn't crash.

[bkramer]

LGTM, thanks!

clang-tidy/ClangTidy.cpp

 }
 
 
 clang::ASTConsumer *ClangTidyASTConsumerFactory::CreateASTConsumer(
     clang::CompilerInstance &Compiler, StringRef File) {
   // FIXME: Move this to a separate method, so that CreateASTConsumer doesn't
   // modify Compiler.
   Context.setSourceManager(&Compiler.getSourceManager());
-  Context.setCurrentFile(File);
+  Context.setCurrentFile(File, &Compiler.getASTContext());
 
   std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
   ChecksFilter &Filter = Context.getChecksFilter();
   CheckFactories->createChecks(Filter, Checks);
 
   std::unique_ptr<ast_matchers::MatchFinder> Finder(
       new ast_matchers::MatchFinder);
   for (auto &Check : Checks) {

clang-tidy/ClangTidyDiagnosticConsumer.h

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Tooling/Refactoring.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Regex.h"
 
 namespace clang {
 
+class ASTContext;
 class CompilerInstance;
 namespace ast_matchers {
 class MatchFinder;
 }
 namespace tooling {
 class CompilationDatabase;
 }
 
DiagnosticBuilder diag(StringRef CheckName, SourceLocation Loc,
                          DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
 
   /// \brief Sets the \c SourceManager of the used \c DiagnosticsEngine.
   ///
   /// This is called from the \c ClangTidyCheck base class.
   void setSourceManager(SourceManager *SourceMgr);
 
   /// \brief Should be called when starting to process new translation unit.
-  void setCurrentFile(StringRef File);
+  void setCurrentFile(StringRef File, ASTContext *Context);
 
   /// \brief Returns the name of the clang-tidy check which produced this
   /// diagnostic ID.
   StringRef getCheckName(unsigned DiagnosticID) const;
 
   /// \brief Returns check filter for the \c CurrentFile.
   ChecksFilter &getChecksFilter();
 

clang-tidy/ClangTidyDiagnosticConsumer.cpp

 ///  This tool uses the Clang Tooling infrastructure, see
 ///    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
 ///  for details on setting it up with LLVM source tree.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyOptions.h"
+#include "clang/AST/ASTDiagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Frontend/DiagnosticRenderer.h"
 #include "llvm/ADT/SmallString.h"
 #include <set>
 #include <tuple>
 using namespace clang;
 using namespace tidy;
 
if (NextFilter)
     Enabled = NextFilter->isCheckEnabled(Name, Enabled);
   return Enabled;
 }
 
 ClangTidyContext::ClangTidyContext(ClangTidyOptionsProvider *OptionsProvider)
     : DiagEngine(nullptr), OptionsProvider(OptionsProvider) {
   // Before the first translation unit we can get errors related to command-line
   // parsing, use empty string for the file name in this case.
-  setCurrentFile("");
+  setCurrentFile("", nullptr);
 }
 
 DiagnosticBuilder ClangTidyContext::diag(
     StringRef CheckName, SourceLocation Loc, StringRef Description,
     DiagnosticIDs::Level Level /* = DiagnosticIDs::Warning*/) {
   assert(Loc.isValid());
   bool Invalid;
   const char *CharacterData =

 void ClangTidyContext::setDiagnosticsEngine(DiagnosticsEngine *Engine) {
   DiagEngine = Engine;
 }
 
 void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
   DiagEngine->setSourceManager(SourceMgr);
 }
 
-void ClangTidyContext::setCurrentFile(StringRef File) {
+static void DummyArgToStringFn(DiagnosticsEngine::ArgumentKind, intptr_t,
+                               StringRef, StringRef,
+                               ArrayRef<DiagnosticsEngine::ArgumentValue>,
+                               SmallVectorImpl<char> &Output, void *,
+                               ArrayRef<intptr_t>) {
+  StringRef Str = "<can't format argument>";
+  Output.append(Str.begin(), Str.end());
+}
+
+void ClangTidyContext::setCurrentFile(StringRef File, ASTContext *Context) {
   CurrentFile = File;
   CheckFilter.reset(new ChecksFilter(getOptions().Checks));
+  DiagEngine->SetArgToStringFn(Context ? &FormatASTNodeDiagnosticArgument
+                                       : &DummyArgToStringFn,
+                               Context);
 }
 
 const ClangTidyGlobalOptions &ClangTidyContext::getGlobalOptions() const {
   return OptionsProvider->getGlobalOptions();
 }
 
 const ClangTidyOptions &ClangTidyContext::getOptions() const {
   return OptionsProvider->getOptions(CurrentFile);