Use DiagnosticIDs::getWarningOption to pass check names.

[alexfh]

Summary

This patch depends on D2660. I'm posting it now as an example of usage
of functionality added in D2660.

[klimek]

Remind me: is this still relevant?

[alexfh]

No, there's an idea to use tablegen'd warnings for clang-tidy instead. It requires some work on the DiagnosticsEngine side.

clang-tidy/ClangTidyDiagnosticConsumer.h

 //===--- ClangTidyDiagnosticConsumer.h - clang-tidy -------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_DIAGNOSTIC_CONSUMER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_DIAGNOSTIC_CONSUMER_H
 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Tooling/Refactoring.h"
-#include "llvm/ADT/DenseMap.h"
 
 namespace clang {
 
 class CompilerInstance;
 namespace ast_matchers {
 class MatchFinder;
 }
 namespace tooling {
public:
   /// This is called from the \c ClangTidyCheck base class.
   void setDiagnosticsEngine(DiagnosticsEngine *Engine);
 
   /// \brief Sets the \c SourceManager of the used \c DiagnosticsEngine.
   ///
   /// This is called from the \c ClangTidyCheck base class.
   void setSourceManager(SourceManager *SourceMgr);
 
-  /// \brief Returns the name of the clang-tidy check which produced this
-  /// diagnostic ID.
-  StringRef getCheckName(unsigned DiagnosticID) const;
-
 private:
   friend class ClangTidyDiagnosticConsumer; // Calls storeError().
 
   /// \brief Store a \c ClangTidyError.
   void storeError(const ClangTidyError &Error);
 
   SmallVectorImpl<ClangTidyError> *Errors;
   DiagnosticsEngine *DiagEngine;
-  llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;
 };
 
 /// \brief A diagnostic consumer that turns each \c Diagnostic into a
 /// \c SourceManager-independent \c ClangTidyError.
 //
 // FIXME: If we move away from unit-tests, this can be moved to a private
 // implementation file.
 class ClangTidyDiagnosticConsumer : public DiagnosticConsumer {

clang-tidy/ClangTidyDiagnosticConsumer.cpp

 ClangTidyError::ClangTidyError(StringRef CheckName,
                                const ClangTidyMessage &Message)
     : CheckName(CheckName), Message(Message) {}
 
 DiagnosticBuilder ClangTidyContext::diag(StringRef CheckName,
                                          SourceLocation Loc,
                                          StringRef Description) {
   unsigned ID = DiagEngine->getDiagnosticIDs()->getCustomDiagID(
-      DiagnosticIDs::Warning, Description);
-  if (CheckNamesByDiagnosticID.count(ID) == 0)
-    CheckNamesByDiagnosticID.insert(std::make_pair(ID, CheckName.str()));
+      DiagnosticIDs::Warning, Description, CheckName);
   return DiagEngine->Report(Loc, ID);
 }
 
 void ClangTidyContext::setDiagnosticsEngine(DiagnosticsEngine *Engine) {
   DiagEngine = Engine;
 }
 
 void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
   DiagEngine->setSourceManager(SourceMgr);
 }
 
 /// \brief Store a \c ClangTidyError.
 void ClangTidyContext::storeError(const ClangTidyError &Error) {
   Errors->push_back(Error);
 }
 
-StringRef ClangTidyContext::getCheckName(unsigned DiagnosticID) const {
-  llvm::DenseMap<unsigned, std::string>::const_iterator I =
-      CheckNamesByDiagnosticID.find(DiagnosticID);
-  if (I != CheckNamesByDiagnosticID.end())
-    return I->second;
-  return "";
-}
-
 ClangTidyDiagnosticConsumer::ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx)
     : Context(Ctx) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   Diags.reset(new DiagnosticsEngine(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts, this,
       /*ShouldOwnClient=*/false));
   Context.setDiagnosticsEngine(Diags.get());
 }
 
 void ClangTidyDiagnosticConsumer::HandleDiagnostic(
     DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
   // FIXME: Demultiplex diagnostics.
   // FIXME: Ensure that we don't get notes from user code related to errors
   // from non-user code.
-  if (Diags->getSourceManager().isInSystemHeader(Info.getLocation()))
+  if (Info.getDiags()->getSourceManager().isInSystemHeader(Info.getLocation()))
     return;
   if (DiagLevel != DiagnosticsEngine::Note) {
-    Errors.push_back(
-        ClangTidyError(Context.getCheckName(Info.getID()), getMessage(Info)));
+    Errors.push_back(ClangTidyError(
+        Info.getDiags()->getDiagnosticIDs()->getWarningOption(Info.getID()),
+        getMessage(Info)));
   } else {
     assert(!Errors.empty() &&
            "A diagnostic note can only be appended to a message.");
     Errors.back().Notes.push_back(getMessage(Info));
   }
   addFixes(Info, Errors.back());
 }