Implemented clang-tidy-check-specific options.

[alexfh]

Summary

Each check can implement readOptions and storeOptions methods to read
and store custom options. Each check's options are stored in a local namespace
to avoid name collisions and provide some sort of context to the user.

[alexfh]

This is another variant of doing the same. Here we pass check name and context
via constructor arguments. This way we need to delegate the corresponding
constructor in each check, but we reduce the ClangTidyCheck API significantly
and allow getting options in the constructor, which is more straightforward.

[klimek]

clang-tidy/ClangTidy.h

99–100

or *it* has been overridden?

104–150

I think those should go somewhere else.

I'd vote for free-standing functions...

clang-tidy/llvm/NamespaceCommentCheck.cpp

21–28

\o/

[alexfh]

clang-tidy/ClangTidy.h

99–100

Done.

104–150

These functions call ClangTidyCheck::getQualifiedOptionName which otherwise would need to be called from the user code:

...
  : ShortNamespaceLines(getOption<unsigned>(getQualifiedOptionName("ShortNamespaceLines"), 1u)),
    SpacesBeforeComments(getOption<unsigned>(getQualifiedOptionName("SpacesBeforeComments"), 1u)) ...

IMO, we need to reduce boilerplate code here as much as we can.

[alexfh]

An alternative way to access options in the checks: use a separate OptionsView
class that accepts the check name and appends it to the check-local option name
to get the real option name.

WDYT?

[klimek]

LG

clang-tidy/ClangTidy.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_H
 
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyOptions.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Tooling/Refactoring.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/raw_ostream.h"
 #include <memory>
+#include <type_traits>
 #include <vector>
 
 namespace clang {
 
 class CompilerInstance;
 namespace tooling {
 class CompilationDatabase;
 }

 /// check for each match.
 ///
 /// A new \c ClangTidyCheck instance is created per translation unit.
 ///
 /// FIXME: Figure out whether carrying information from one TU to another is
 /// useful/necessary.
 class ClangTidyCheck : public ast_matchers::MatchFinder::MatchCallback {
 public:
+  /// \brief Initializes the check with \p CheckName and \p Context.
+  ///
+  /// Derived classes must implement the constructor with this signature or
+  /// delegate it. If a check needs to read options, it can do this in the
+  /// constructor using the getOption() methods below.
+  ClangTidyCheck(StringRef CheckName, ClangTidyContext *Context)
+      : CheckName(CheckName), Context(Context) {
+    assert(Context != nullptr);
+    assert(!CheckName.empty());
+  }
+
   virtual ~ClangTidyCheck() {}
 
   /// \brief Overwrite this to register \c PPCallbacks with \c Compiler.
   ///
   /// This should be used for clang-tidy checks that analyze preprocessor-
   /// dependent properties, e.g. the order of include directives.
   virtual void registerPPCallbacks(CompilerInstance &Compiler) {}
 
public:
   /// store these as members of the derived class. However, note that all
   /// matches occur in the order of the AST traversal.
   virtual void registerMatchers(ast_matchers::MatchFinder *Finder) {}
 
   /// \brief \c ClangTidyChecks that register ASTMatchers should do the actual
   /// work in here.
   virtual void check(const ast_matchers::MatchFinder::MatchResult &Result) {}
 
-  /// \brief The infrastructure sets the context to \p Ctx with this function.
-  void setContext(ClangTidyContext *Ctx) { Context = Ctx; }
-
   /// \brief Add a diagnostic with the check's name.
   DiagnosticBuilder diag(SourceLocation Loc, StringRef Description,
                          DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
 
-  /// \brief Sets the check name. Intended to be used by the clang-tidy
-  /// framework. Can be called only once.
-  void setName(StringRef Name);
+  /// \brief Should store all options supported by this check with their
+  /// current values or default values for options that haven't been overridden.
+  ///
+  /// The check should use \c storeOption() to store each option it supports
+  /// whether it has the default value or has been overridden.
+  virtual void storeOptions(ClangTidyOptions::OptionMap &Options) {}
+
+protected:
+  /// \brief Read a named option from the \c Context.
+  ///
+  /// Reads the option named <code>CheckName + "." +</code> \p LocalName
+  /// from the current options in the \c Context. If the corresponding key is
+  /// not present, returns \p Default.
+  std::string getOption(StringRef LocalName, std::string Default) const {
+    const auto &Options = Context->getOptions().CheckOptions;
+    const auto &Iter = Options.find(getQualifiedOptionName(LocalName));
+    if (Iter != Options.end())
+      return Iter->second;
+    return Default;
+  }
+
+  /// \brief Read a named option from the \c Context and parse it as \c T.
+  ///
+  /// Reads the option named <code>CheckName + "." +</code> \p LocalName
+  /// from the current options in the \c Context. If the corresponding key is
+  /// not present, returns \p Default.
+  template <typename T>
+  typename std::enable_if<std::is_integral<T>::value, T>::type
+  getOption(StringRef LocalName, T Default) const {
+    std::string Value = getOption(LocalName, "");
+    T Result = Default;
+    if (!Value.empty())
+      StringRef(Value).getAsInteger(10, Result);
+    return Result;
+  }
+
+  /// \brief Stores an option named \p LocalName with string value \p Value to
+  /// \p Options.
+  ///
+  /// The function calls \c getQualifiedOptionName(LocalName) to get the global
+  /// option name by prepending the check name.
+  void storeOption(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
+                   StringRef Value) const {
+    Options[getQualifiedOptionName(LocalName)] = Value;
+  }
+
+  /// \brief Stores an option named \p LocalName with \c int64_t value \p Value
+  /// to \p Options.
+  ///
+  /// The function calls \c getQualifiedOptionName(LocalName) to get the global
+  /// option name by prepending the check name.
+  void storeOption(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
+                   int64_t Value) const {
+    storeOption(Options, LocalName, llvm::itostr(Value));
+  }
 
 private:
+  std::string getQualifiedOptionName(StringRef OptionName) const {
+    assert(!CheckName.empty());
+    return CheckName + "." + OptionName.str();
+  }
+
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
-  ClangTidyContext *Context;
   std::string CheckName;
+  ClangTidyContext *Context;
 };
 
 class ClangTidyCheckFactories;
 
 class ClangTidyASTConsumerFactory {
 public:
   ClangTidyASTConsumerFactory(ClangTidyContext &Context);
 
   /// \brief Returns an ASTConsumer that runs the specified clang-tidy checks.
   std::unique_ptr<clang::ASTConsumer>
   CreateASTConsumer(clang::CompilerInstance &Compiler, StringRef File);
 
   /// \brief Get the list of enabled checks.
-  std::vector<std::string> getCheckNames(GlobList &Filter);
+  std::vector<std::string> getCheckNames();
+
+  /// \brief Get the union of options from all checks.
+  ClangTidyOptions::OptionMap getCheckOptions();
 
 private:
-  typedef std::vector<std::pair<std::string, bool> > CheckersList;
+  typedef std::vector<std::pair<std::string, bool>> CheckersList;
   CheckersList getCheckersControlList(GlobList &Filter);
 
   ClangTidyContext &Context;
   std::unique_ptr<ClangTidyCheckFactories> CheckFactories;
 };
 
 /// \brief Fills the list of check names that are enabled when the provided
 /// filters are applied.
 std::vector<std::string> getCheckNames(const ClangTidyOptions &Options);
 
+/// \brief Returns the effective check-specific options.
+///
+/// The method configures ClangTidy with the specified \p Options and collects
+/// effective options from all created checks. The returned set of options
+/// includes default check-specific options for all keys not overridden by \p
+/// Options.
+ClangTidyOptions::OptionMap getCheckOptions(const ClangTidyOptions &Options);
+
 /// \brief Run a set of clang-tidy checks on a set of files.
 ClangTidyStats
 runClangTidy(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
              const tooling::CompilationDatabase &Compilations,
              ArrayRef<std::string> InputFiles,
              std::vector<ClangTidyError> *Errors);
 
 // FIXME: This interface will need to be significantly extended to be useful.

clang-tidy/ClangTidy.cpp

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.setASTContext(&Compiler.getASTContext());
 
   std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
-  GlobList &Filter = Context.getChecksFilter();
-  CheckFactories->createChecks(Filter, Checks);
+  CheckFactories->createChecks(&Context, Checks);
 
   std::unique_ptr<ast_matchers::MatchFinder> Finder(
       new ast_matchers::MatchFinder);
   for (auto &Check : Checks) {
-    Check->setContext(&Context);
     Check->registerMatchers(&*Finder);
     Check->registerPPCallbacks(Compiler);
   }
 
   std::vector<std::unique_ptr<ASTConsumer>> Consumers;
   if (!Checks.empty())
     Consumers.push_back(Finder->newASTConsumer());
 
   AnalyzerOptionsRef AnalyzerOptions = Compiler.getAnalyzerOpts();
   // FIXME: Remove this option once clang's cfg-temporary-dtors option defaults
   // to true.
   AnalyzerOptions->Config["cfg-temporary-dtors"] =
       Context.getOptions().AnalyzeTemporaryDtors ? "true" : "false";
 
+  GlobList &Filter = Context.getChecksFilter();
   AnalyzerOptions->CheckersControlList = getCheckersControlList(Filter);
   if (!AnalyzerOptions->CheckersControlList.empty()) {
     AnalyzerOptions->AnalysisStoreOpt = RegionStoreModel;
     AnalyzerOptions->AnalysisDiagOpt = PD_NONE;
     AnalyzerOptions->AnalyzeNestedBlocks = true;
     AnalyzerOptions->eagerlyAssumeBinOpBifurcation = true;
     std::unique_ptr<ento::AnalysisASTConsumer> AnalysisConsumer =
         ento::CreateAnalysisConsumer(Compiler);
     AnalysisConsumer->AddDiagnosticConsumer(
         new AnalyzerDiagnosticConsumer(Context));
     Consumers.push_back(std::move(AnalysisConsumer));
   }
   return llvm::make_unique<ClangTidyASTConsumer>(
       std::move(Consumers), std::move(Finder), std::move(Checks));
 }
 
-std::vector<std::string>
-ClangTidyASTConsumerFactory::getCheckNames(GlobList &Filter) {
+std::vector<std::string> ClangTidyASTConsumerFactory::getCheckNames() {
   std::vector<std::string> CheckNames;
+  GlobList &Filter = Context.getChecksFilter();
   for (const auto &CheckFactory : *CheckFactories) {
     if (Filter.contains(CheckFactory.first))
       CheckNames.push_back(CheckFactory.first);
   }
 
   for (const auto &AnalyzerCheck : getCheckersControlList(Filter))
     CheckNames.push_back(AnalyzerCheckNamePrefix + AnalyzerCheck.first);
 
   std::sort(CheckNames.begin(), CheckNames.end());
   return CheckNames;
 }
 
+ClangTidyOptions::OptionMap ClangTidyASTConsumerFactory::getCheckOptions() {
+  ClangTidyOptions::OptionMap Options;
+  std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
+  CheckFactories->createChecks(&Context, Checks);
+  for (const auto &Check : Checks)
+    Check->storeOptions(Options);
+  return Options;
+}
+
 ClangTidyASTConsumerFactory::CheckersList
 ClangTidyASTConsumerFactory::getCheckersControlList(GlobList &Filter) {
   CheckersList List;
 
   bool AnalyzerChecksEnabled = false;
   for (StringRef CheckName : StaticAnalyzerChecks) {
     std::string Checker((AnalyzerCheckNamePrefix + CheckName).str());
     AnalyzerChecksEnabled =
DiagnosticBuilder ClangTidyCheck::diag(SourceLocation Loc, StringRef Message,
   return Context->diag(CheckName, Loc, Message, Level);
 }
 
 void ClangTidyCheck::run(const ast_matchers::MatchFinder::MatchResult &Result) {
   Context->setSourceManager(Result.SourceManager);
   check(Result);
 }
 
-void ClangTidyCheck::setName(StringRef Name) {
-  assert(CheckName.empty());
-  CheckName = Name.str();
-}
-
 std::vector<std::string> getCheckNames(const ClangTidyOptions &Options) {
   clang::tidy::ClangTidyContext Context(
       llvm::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
                                                 Options));
   ClangTidyASTConsumerFactory Factory(Context);
-  return Factory.getCheckNames(Context.getChecksFilter());
+  return Factory.getCheckNames();
+}
+ClangTidyOptions::OptionMap getCheckOptions(const ClangTidyOptions &Options) {
+  clang::tidy::ClangTidyContext Context(
+      llvm::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
+                                                Options));
+  ClangTidyASTConsumerFactory Factory(Context);
+  return Factory.getCheckOptions();
 }
 
 ClangTidyStats
 runClangTidy(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
              const tooling::CompilationDatabase &Compilations,
              ArrayRef<std::string> InputFiles,
              std::vector<ClangTidyError> *Errors) {
   ClangTool Tool(Compilations, InputFiles);

clang-tidy/ClangTidyModule.h

 namespace tidy {
 
 /// \brief A collection of \c ClangTidyCheckFactory instances.
 ///
 /// All clang-tidy modules register their check factories with an instance of
 /// this object.
 class ClangTidyCheckFactories {
 public:
+  typedef std::function<ClangTidyCheck *(
+      StringRef Name, ClangTidyContext *Context)> CheckFactory;
+
   /// \brief Registers check \p Factory with name \p Name.
   ///
   /// For all checks that have default constructors, use \c registerCheck.
-  void registerCheckFactory(StringRef Name,
-                            std::function<ClangTidyCheck *()> Factory);
+  void registerCheckFactory(StringRef Name, CheckFactory Factory);
 
   /// \brief Registers the \c CheckType with the name \p Name.
   ///
   /// This method should be used for all \c ClangTidyChecks that don't require
   /// constructor parameters.
   ///
   /// For example, if have a clang-tidy check like:
   /// \code
   /// class MyTidyCheck : public ClangTidyCheck {
   ///   void registerMatchers(ast_matchers::MatchFinder *Finder) override {
   ///     ..
   ///   }
   /// };
   /// \endcode
   /// you can register it with:
   /// \code
   /// class MyModule : public ClangTidyModule {
   ///   void addCheckFactories(ClangTidyCheckFactories &Factories) override {
   ///     Factories.registerCheck<MyTidyCheck>("myproject-my-check");
   ///   }
   /// };
   /// \endcode
-  template<typename CheckType>
-  void registerCheck(StringRef Name) {
-    registerCheckFactory(Name, []() { return new CheckType(); });
+  template <typename CheckType> void registerCheck(StringRef CheckName) {
+    registerCheckFactory(CheckName,
+                         [](StringRef Name, ClangTidyContext *Context) {
+      return new CheckType(Name, Context);
+    });
   }
 
   /// \brief Create instances of all checks matching \p CheckRegexString and
   /// store them in \p Checks.
   ///
   /// The caller takes ownership of the return \c ClangTidyChecks.
-  void createChecks(GlobList &Filter,
+  void createChecks(ClangTidyContext *Context,
                     std::vector<std::unique_ptr<ClangTidyCheck>> &Checks);
 
-  typedef std::map<std::string, std::function<ClangTidyCheck *()>> FactoryMap;
+  typedef std::map<std::string, CheckFactory> FactoryMap;
   FactoryMap::const_iterator begin() const { return Factories.begin(); }
   FactoryMap::const_iterator end() const { return Factories.end(); }
   bool empty() const { return Factories.empty(); }
 
 private:
   FactoryMap Factories;
 };
 

clang-tidy/ClangTidyModule.cpp

 ///
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyModule.h"
 
 namespace clang {
 namespace tidy {
 
-void ClangTidyCheckFactories::registerCheckFactory(
-    StringRef Name, std::function<ClangTidyCheck *()> Factory) {
+void ClangTidyCheckFactories::registerCheckFactory(StringRef Name,
+                                                   CheckFactory Factory) {
   Factories[Name] = Factory;
 }
 
 void ClangTidyCheckFactories::createChecks(
-    GlobList &Filter, std::vector<std::unique_ptr<ClangTidyCheck>> &Checks) {
+    ClangTidyContext *Context,
+    std::vector<std::unique_ptr<ClangTidyCheck>> &Checks) {
+  GlobList &Filter = Context->getChecksFilter();
   for (const auto &Factory : Factories) {
-    if (Filter.contains(Factory.first)) {
-      ClangTidyCheck *Check = Factory.second();
-      Check->setName(Factory.first);
-      Checks.emplace_back(Check);
-    }
+    if (Filter.contains(Factory.first))
+      Checks.emplace_back(Factory.second(Factory.first, Context));
   }
 }
 
 } // namespace tidy
 } // namespace clang

clang-tidy/ClangTidyOptions.h

 //===--- ClangTidyOptions.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_OPTIONS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_OPTIONS_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorOr.h"
+#include <map>
 #include <string>
 #include <system_error>
 #include <utility>
 #include <vector>
 
 namespace clang {
 namespace tidy {
 
struct ClangTidyOptions {
   llvm::Optional<std::string> Checks;
 
   /// \brief Output warnings from headers matching this filter. Warnings from
   /// main files will always be displayed.
   llvm::Optional<std::string> HeaderFilterRegex;
 
   /// \brief Turns on temporary destructor-based analysis.
   llvm::Optional<bool> AnalyzeTemporaryDtors;
+
+  typedef std::pair<std::string, std::string> StringPair;
+  typedef std::map<std::string, std::string> OptionMap;
+
+  /// \brief Key-value mapping used to store check-specific options.
+  OptionMap CheckOptions;
 };
 
 /// \brief Abstract interface for retrieving various ClangTidy options.
 class ClangTidyOptionsProvider {
 public:
   virtual ~ClangTidyOptionsProvider() {}
 
   /// \brief Returns global options, which are independent of the file.

clang-tidy/ClangTidyOptions.cpp

 
 #define DEBUG_TYPE "clang-tidy-options"
 
 using clang::tidy::ClangTidyOptions;
 using clang::tidy::FileFilter;
 
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter::LineRange)
+LLVM_YAML_IS_SEQUENCE_VECTOR(ClangTidyOptions::StringPair);
 
 namespace llvm {
 namespace yaml {
 
 // Map std::pair<int, int> to a JSON array of size 2.
 template <> struct SequenceTraits<FileFilter::LineRange> {
   static size_t size(IO &IO, FileFilter::LineRange &Range) {
     return Range.first == 0 ? 0 : Range.second == 0 ? 1 : 2;
static StringRef validate(IO &io, FileFilter &File) {
     for (const FileFilter::LineRange &Range : File.LineRanges) {
       if (Range.first <= 0 || Range.second <= 0)
         return "Invalid line range";
     }
     return StringRef();
   }
 };
 
+template <> struct MappingTraits<ClangTidyOptions::StringPair> {
+  static void mapping(IO &IO, ClangTidyOptions::StringPair &KeyValue) {
+    IO.mapRequired("key", KeyValue.first);
+    IO.mapRequired("value", KeyValue.second);
+  }
+};
+
+struct NOptionMap {
+  NOptionMap(IO &) {}
+  NOptionMap(IO &, const ClangTidyOptions::OptionMap &OptionMap)
+      : Options(OptionMap.begin(), OptionMap.end()) {}
+  ClangTidyOptions::OptionMap denormalize(IO &) {
+    ClangTidyOptions::OptionMap Map;
+    for (const auto &KeyValue : Options)
+      Map[KeyValue.first] = KeyValue.second;
+    return Map;
+  }
+  std::vector<ClangTidyOptions::StringPair> Options;
+};
+
 template <> struct MappingTraits<ClangTidyOptions> {
   static void mapping(IO &IO, ClangTidyOptions &Options) {
+    MappingNormalization<NOptionMap, ClangTidyOptions::OptionMap> NOpts(
+        IO, Options.CheckOptions);
     IO.mapOptional("Checks", Options.Checks);
     IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
     IO.mapOptional("AnalyzeTemporaryDtors", Options.AnalyzeTemporaryDtors);
+    IO.mapOptional("CheckOptions", NOpts->Options);
   }
 };
 
 } // namespace yaml
 } // namespace llvm
 
 namespace clang {
 namespace tidy {
 
 ClangTidyOptions
 ClangTidyOptions::mergeWith(const ClangTidyOptions &Other) const {
   ClangTidyOptions Result = *this;
 
   // Merge comma-separated glob lists by appending the new value after a comma.
   if (Other.Checks)
     Result.Checks =
         (Result.Checks && !Result.Checks->empty() ? *Result.Checks + "," : "") +
         *Other.Checks;
 
   if (Other.HeaderFilterRegex)
     Result.HeaderFilterRegex = Other.HeaderFilterRegex;
   if (Other.AnalyzeTemporaryDtors)
     Result.AnalyzeTemporaryDtors = Other.AnalyzeTemporaryDtors;
+
+  for (const auto &KeyValue : Other.CheckOptions)
+    Result.CheckOptions[KeyValue.first] = KeyValue.second;
+
   return Result;
 }
 
 FileOptionsProvider::FileOptionsProvider(
     const ClangTidyGlobalOptions &GlobalOptions,
     const ClangTidyOptions &FallbackOptions,
     const ClangTidyOptions &OverrideOptions)
     : DefaultOptionsProvider(GlobalOptions, FallbackOptions),
FileOptionsProvider::TryReadConfigFile(StringRef Directory) {
 
   if (!IsFile)
     return make_error_code(llvm::errc::no_such_file_or_directory);
 
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
       llvm::MemoryBuffer::getFile(ConfigFile.c_str());
   if (std::error_code EC = Text.getError())
     return EC;
+  // Skip empty files, e.g. files opened for writing via shell output
+  // redirection.
+  if ((*Text)->getBuffer().empty())
+    return make_error_code(llvm::errc::no_such_file_or_directory);
   if (std::error_code EC = parseConfiguration((*Text)->getBuffer(), Options))
     return EC;
   return Options.mergeWith(OverrideOptions);
 }
 
 /// \brief Parses -line-filter option and stores it to the \c Options.
 std::error_code parseLineFilter(StringRef LineFilter,
                                 clang::tidy::ClangTidyGlobalOptions &Options) {

clang-tidy/google/AvoidCStyleCastsCheck.h

 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Casting#Casting
 /// Corresponding cpplint.py check name: 'readability/casting'.
 ///
 /// This check is similar to -Wold-style-cast, but it will suggest automated
 /// fixes eventually. The reported locations should not be different from the
 /// ones generated by -Wold-style-cast.
 class AvoidCStyleCastsCheck : public ClangTidyCheck {
 public:
+  AvoidCStyleCastsCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOID_C_STYLE_CASTS_CHECK_H

clang-tidy/google/ExplicitConstructorCheck.h

 namespace tidy {
 
 /// \brief Checks that all single-argument constructors are explicit.
 ///
 /// see:
 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Explicit_Constructors
 class ExplicitConstructorCheck : public ClangTidyCheck {
 public:
+  ExplicitConstructorCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICIT_CONSTRUCTOR_CHECK_H

clang-tidy/google/ExplicitMakePairCheck.h

 /// \brief Check that make_pair's template arguments are deduced.
 ///
 /// G++ 4.6 in C++11 mode fails badly if make_pair's template arguments are
 /// specified explicitly, and such use isn't intended in any case.
 ///
 /// Corresponding cpplint.py check name: 'build/explicit_make_pair'.
 class ExplicitMakePairCheck : public ClangTidyCheck {
 public:
+  ExplicitMakePairCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace build
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICIT_MAKE_PAIR_CHECK_H

clang-tidy/google/IntegerTypesCheck.h

 namespace tidy {
 namespace runtime {
 
 /// \brief Finds uses of short, long and long long and suggest replacing them
 /// with u?intXX(_t)?.
 /// Correspondig cpplint.py check: runtime/int.
 class IntegerTypesCheck : public ClangTidyCheck {
 public:
-  IntegerTypesCheck()
-      : UnsignedTypePrefix("uint"), SignedTypePrefix("int"),
-        AddUnderscoreT(false) {}
+  IntegerTypesCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context), UnsignedTypePrefix("uint"),
+        SignedTypePrefix("int"), AddUnderscoreT(false) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const StringRef UnsignedTypePrefix;
   const StringRef SignedTypePrefix;
   const bool AddUnderscoreT;
 };
 
 } // namespace runtime
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_INTEGERTYPESCHECK_H

clang-tidy/google/MemsetZeroLengthCheck.h

 /// \brief Finds calls to memset with a literal zero in the length argument.
 ///
 /// This is most likely unintended and the length and value arguments are
 /// swapped.
 ///
 /// Corresponding cpplint.py check name: 'runtime/memset'.
 class MemsetZeroLengthCheck : public ClangTidyCheck {
 public:
+  MemsetZeroLengthCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace runtime
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_MEMSET_ZERO_LENGTH_CHECK_H

clang-tidy/google/NamedParameterCheck.h

 namespace readability {
 
 /// \brief Find functions with unnamed arguments.
 ///
 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Function_Declarations_and_Definitions#Function_Declarations_and_Definitions
 /// Corresponding cpplint.py check name: 'readability/function'.
 class NamedParameterCheck : public ClangTidyCheck {
 public:
+  NamedParameterCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_NAMED_PARAMETER_CHECK_H

clang-tidy/google/OverloadedUnaryAndCheck.h

 namespace runtime {
 
 /// \brief Finds overloads of unary operator &.
 ///
 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Operator_Overloading#Operator_Overloading
 /// Corresponding cpplint.py check name: 'runtime/operator'.
 class OverloadedUnaryAndCheck : public ClangTidyCheck {
 public:
+  OverloadedUnaryAndCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace runtime
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_OVERLOADED_UNARY_AND_CHECK_H

clang-tidy/google/StringReferenceMemberCheck.h

 /// reference.
 ///
 /// This check emit warnings for both std::string and ::string const reference
 /// members.
 ///
 /// Corresponding cpplint.py check name: 'runtime/member_string_reference'.
 class StringReferenceMemberCheck : public ClangTidyCheck {
 public:
+  StringReferenceMemberCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace runtime
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_STRING_REF_MEMBER_CHECK_H

clang-tidy/google/UnnamedNamespaceInHeaderCheck.h

 namespace build {
 
 /// \brief Finds anonymous namespaces in headers.
 ///
 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Namespaces#Namespaces
 /// Corresponding cpplint.py check name: 'build/namespaces'.
 class UnnamedNamespaceInHeaderCheck : public ClangTidyCheck {
 public:
+  UnnamedNamespaceInHeaderCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace build
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_UNNAMED_NAMESPACE_IN_HEADER_H

clang-tidy/google/UsingNamespaceDirectiveCheck.h

 namespace build {
 
 /// \brief Finds using namespace directives.
 ///
 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Namespaces#Namespaces
 /// Corresponding cpplint.py check name: 'build/namespaces'.
 class UsingNamespaceDirectiveCheck : public ClangTidyCheck {
 public:
+  UsingNamespaceDirectiveCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace build
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_USING_NAMESPACE_CHECK_H

clang-tidy/llvm/HeaderGuardCheck.h

 #include "../utils/HeaderGuard.h"
 
 namespace clang {
 namespace tidy {
 
 /// Finds and fixes header guards that do not adhere to LLVM style.
 class LLVMHeaderGuardCheck : public HeaderGuardCheck {
 public:
+  LLVMHeaderGuardCheck(StringRef Name, ClangTidyContext *Context)
+      : HeaderGuardCheck(Name, Context) {}
   bool shouldSuggestEndifComment(StringRef Filename) override { return false; }
   bool shouldFixHeaderGuard(StringRef Filename) override;
   std::string getHeaderGuard(StringRef Filename, StringRef OldGuard) override;
 };
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_HEADER_GUARD_CHECK_H

clang-tidy/llvm/IncludeOrderCheck.h

 namespace clang {
 namespace tidy {
 
 /// \brief Checks the correct order of \c #includes.
 ///
 /// see: http://llvm.org/docs/CodingStandards.html#include-style
 class IncludeOrderCheck : public ClangTidyCheck {
 public:
+  IncludeOrderCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerPPCallbacks(CompilerInstance &Compiler) override;
 };
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_INCLUDE_ORDER_CHECK_H

clang-tidy/llvm/NamespaceCommentCheck.h

 namespace clang {
 namespace tidy {
 
 /// \brief Checks that long namespaces have a closing comment.
 ///
 /// see: http://llvm.org/docs/CodingStandards.html#namespace-indentation
 class NamespaceCommentCheck : public ClangTidyCheck {
 public:
-  NamespaceCommentCheck();
+  NamespaceCommentCheck(StringRef Name, ClangTidyContext *Context);
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
+  void storeOptions(ClangTidyOptions::OptionMap &Options) override;
+
   llvm::Regex NamespaceCommentPattern;
   const unsigned ShortNamespaceLines;
+  const unsigned SpacesBeforeComments;
 };
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_NAMESPACE_COMMENT_CHECK_H

clang-tidy/llvm/NamespaceCommentCheck.cpp

 //===--- NamespaceCommentCheck.cpp - clang-tidy ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "NamespaceCommentCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Lex/Lexer.h"
-
-
-#include "llvm/Support/raw_ostream.h"
+#include "llvm/ADT/StringExtras.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 
-NamespaceCommentCheck::NamespaceCommentCheck()
-    : NamespaceCommentPattern("^/[/*] *(end (of )?)? *(anonymous|unnamed)? *"
+NamespaceCommentCheck::NamespaceCommentCheck(StringRef Name,
+                                             ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      NamespaceCommentPattern("^/[/*] *(end (of )?)? *(anonymous|unnamed)? *"
                               "namespace( +([a-zA-Z0-9_]+))? *(\\*/)?$",
                               llvm::Regex::IgnoreCase),
-      ShortNamespaceLines(1) {}
+      ShortNamespaceLines(getOption<unsigned>("ShortNamespaceLines", 1u)),
+      SpacesBeforeComments(getOption<unsigned>("SpacesBeforeComments", 1u)) {}
+
+void NamespaceCommentCheck::storeOptions(ClangTidyOptions::OptionMap &Options) {
+  storeOption(Options, "ShortNamespaceLines", ShortNamespaceLines);
+  storeOption(Options, "SpacesBeforeComments", SpacesBeforeComments);
+}
 
 void NamespaceCommentCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(namespaceDecl().bind("namespace"), this);
 }
 
 bool locationsInSameFile(const SourceManager &Sources, SourceLocation Loc1,
                          SourceLocation Loc2) {
   return Loc1.isFileID() && Loc2.isFileID() &&
          Sources.getFileID(Loc1) == Sources.getFileID(Loc2);
 }
 
-std::string getNamespaceComment(const NamespaceDecl *ND, bool InsertLineBreak) {
+std::string getNamespaceComment(const NamespaceDecl *ND, bool InsertLineBreak,
+                                unsigned SpacesBeforeComments) {
   std::string Fix = "// namespace";
   if (!ND->isAnonymousNamespace())
-    Fix.append(" ").append(ND->getNameAsString());
+    Fix.append(std::string(SpacesBeforeComments, ' '))
+        .append(ND->getNameAsString());
   if (InsertLineBreak)
     Fix.append("\n");
   return Fix;
 }
 
 void NamespaceCommentCheck::check(const MatchFinder::MatchResult &Result) {
   const NamespaceDecl *ND = Result.Nodes.getNodeAs<NamespaceDecl>("namespace");
   const SourceManager &Sources = *Result.SourceManager;
if (NamespaceCommentPattern.match(Comment, &Groups)) {
 
       // Otherwise we need to fix the comment.
       NeedLineBreak = Comment.startswith("/*");
       CharSourceRange OldCommentRange = CharSourceRange::getCharRange(
           SourceRange(Loc, Loc.getLocWithOffset(Tok.getLength())));
       diag(Loc, "namespace closing comment refers to a wrong namespace '%0'")
           << NamespaceNameInComment
           << FixItHint::CreateReplacement(
-                 OldCommentRange, getNamespaceComment(ND, NeedLineBreak));
+                 OldCommentRange,
+                 getNamespaceComment(ND, NeedLineBreak, SpacesBeforeComments));
       return;
     }
 
     // This is not a recognized form of a namespace closing comment.
     // Leave line comment on the same line. Move block comment to the next line,
     // as it can be multi-line or there may be other tokens behind it.
     if (Comment.startswith("//"))
       NeedLineBreak = false;
   }
 
   diag(ND->getLocation(), "namespace not terminated with a closing comment")
       << FixItHint::CreateInsertion(
-          AfterRBrace, " " + getNamespaceComment(ND, NeedLineBreak));
+          AfterRBrace,
+          " " + getNamespaceComment(ND, NeedLineBreak, SpacesBeforeComments));
 }
 
 } // namespace tidy
 } // namespace clang

clang-tidy/llvm/TwineLocalCheck.h

 
 namespace clang {
 namespace tidy {
 
 /// \brief Looks for local Twine variables which are prone to use after frees
 /// and should be generally avoided.
 class TwineLocalCheck : public ClangTidyCheck {
 public:
-  TwineLocalCheck();
+  TwineLocalCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_TWINE_LOCAL_CHECK_H

clang-tidy/llvm/TwineLocalCheck.cpp

 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 
-TwineLocalCheck::TwineLocalCheck() {}
-
 void TwineLocalCheck::registerMatchers(MatchFinder *Finder) {
   auto TwineType =
       qualType(hasDeclaration(recordDecl(hasName("::llvm::Twine"))));
   Finder->addMatcher(varDecl(hasType(TwineType)).bind("variable"), this);
 }
 
 void TwineLocalCheck::check(const MatchFinder::MatchResult &Result) {
   const VarDecl *VD = Result.Nodes.getNodeAs<VarDecl>("variable");

clang-tidy/misc/ArgumentCommentCheck.h

 #include "llvm/Support/Regex.h"
 
 namespace clang {
 namespace tidy {
 
 /// \brief Checks that argument comments match parameter names.
 class ArgumentCommentCheck : public ClangTidyCheck {
 public:
-  ArgumentCommentCheck();
+  ArgumentCommentCheck(StringRef Name, ClangTidyContext *Context);
 
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   llvm::Regex IdentRE;
 
   bool isLikelyTypo(llvm::ArrayRef<ParmVarDecl *> Params, StringRef ArgName,

clang-tidy/misc/ArgumentCommentCheck.cpp

 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/Token.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 
-ArgumentCommentCheck::ArgumentCommentCheck()
-    : IdentRE("^(/\\* *)([_A-Za-z][_A-Za-z0-9]*)( *= *\\*/)$") {}
+ArgumentCommentCheck::ArgumentCommentCheck(StringRef Name,
+                                           ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      IdentRE("^(/\\* *)([_A-Za-z][_A-Za-z0-9]*)( *= *\\*/)$") {}
 
 void ArgumentCommentCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       callExpr(unless(operatorCallExpr()),
                // NewCallback's arguments relate to the pointed function, don't
                // check them against NewCallback's parameter names.
                // FIXME: Make this configurable.
                unless(hasDeclaration(functionDecl(anyOf(

clang-tidy/misc/BoolPointerImplicitConversion.h

 /// \brief Checks for conditions based on implicit conversion from a bool
 /// pointer to bool e.g.
 /// bool *p;
 /// if (p) {
 ///   // Never used in a pointer-specific way.
 /// }
 class BoolPointerImplicitConversion : public ClangTidyCheck {
 public:
+  BoolPointerImplicitConversion(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_BOOL_POINTER_IMPLICIT_CONV_H
 

clang-tidy/misc/RedundantSmartptrGet.h

 /// \brief Find and remove redundant calls to smart pointer's .get() method.
 ///
 /// Examples:
 ///   ptr.get()->Foo()  ==>  ptr->Foo()
 ///   *ptr.get()  ==>  *ptr
 ///   *ptr->get()  ==>  **ptr
 class RedundantSmartptrGet : public ClangTidyCheck {
 public:
+  RedundantSmartptrGet(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_REDUNDANT_SMARTPTR_GET_H
 

clang-tidy/misc/SwappedArgumentsCheck.h

 
 namespace clang {
 namespace tidy {
 
 /// \brief Finds potentially swapped arguments by looking at implicit
 /// conversions.
 class SwappedArgumentsCheck : public ClangTidyCheck {
 public:
+  SwappedArgumentsCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SWAPPED_ARGUMENTS_CHECK_H
 

clang-tidy/misc/UndelegatedConstructor.h

 namespace clang {
 namespace tidy {
 
 /// \brief Finds creation of temporary objects in constructors that look like a
 /// function call to another constructor of the same class. The user most likely
 /// meant to use a delegating constructor or base class initializer.
 class UndelegatedConstructorCheck : public ClangTidyCheck {
 public:
+  UndelegatedConstructorCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNDELEGATED_CONSTRUCTOR_H

clang-tidy/misc/UnusedRAII.h

 ///   - Ignore code expanded from macros. Testing frameworks make heavy use of
 ///     this.
 ///   - Ignore types with no user-declared constructor. Those are very unlikely
 ///     to be RAII objects.
 ///   - Ignore objects at the end of a compound statement (doesn't change behavior).
 ///   - Ignore objects returned from a call.
 class UnusedRAIICheck : public ClangTidyCheck {
 public:
+  UnusedRAIICheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_RAII_H

clang-tidy/misc/UseOverride.h

 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
 
 /// \brief Use C++11's 'override' and remove 'virtual' where applicable.
 class UseOverride : public ClangTidyCheck {
 public:
+  UseOverride(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_USE_OVERRIDE_H
 

clang-tidy/tool/ClangTidyMain.cpp

if (ListChecks) {
     llvm::outs() << "Enabled checks:";
     for (auto CheckName : EnabledChecks)
       llvm::outs() << "\n    " << CheckName;
     llvm::outs() << "\n\n";
     return 0;
   }
 
   if (DumpConfig) {
+    EffectiveOptions.CheckOptions = getCheckOptions(EffectiveOptions);
     llvm::outs() << configurationAsText(ClangTidyOptions::getDefaults()
                                             .mergeWith(EffectiveOptions))
                  << "\n";
     return 0;
   }
 
   if (EnabledChecks.empty()) {
     llvm::errs() << "Error: no checks enabled.\n";

clang-tidy/utils/HeaderGuard.h

 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
 
 /// \brief Finds and fixes header guards.
 class HeaderGuardCheck : public ClangTidyCheck {
 public:
+  HeaderGuardCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerPPCallbacks(CompilerInstance &Compiler) override;
 
   /// \brief Returns true if the checker should suggest inserting a trailing
   /// comment on the #endif of the header guard. It will use the same name as
   /// returned by getHeaderGuard.
   virtual bool shouldSuggestEndifComment(StringRef Filename);
   /// \brief Returns true if the checker should suggest changing an existing
   /// header guard to the string returned by getHeaderGuard.

unittests/clang-tidy/ClangTidyDiagnosticConsumerTest.cpp

 #include "ClangTidy.h"
 #include "ClangTidyTest.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace tidy {
 namespace test {
 
 class TestCheck : public ClangTidyCheck {
 public:
+  TestCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override {
     Finder->addMatcher(ast_matchers::varDecl().bind("var"), this);
   }
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
     const VarDecl *Var = Result.Nodes.getNodeAs<VarDecl>("var");
     // Add diagnostics in the wrong order.
     diag(Var->getLocation(), "variable");
     diag(Var->getTypeSpecStartLoc(), "type specifier");
   }
 };
 
 TEST(ClangTidyDiagnosticConsumer, SortsErrors) {
   std::vector<ClangTidyError> Errors;
   runCheckOnCode<TestCheck>("int a;", &Errors);
   EXPECT_EQ(2ul, Errors.size());
-  // FIXME: Remove " []" once the check name is removed from the message text.
-  EXPECT_EQ("type specifier []", Errors[0].Message.Message);
-  EXPECT_EQ("variable []", Errors[1].Message.Message);
+  EXPECT_EQ("type specifier", Errors[0].Message.Message);
+  EXPECT_EQ("variable", Errors[1].Message.Message);
 }
 
 TEST(GlobList, Empty) {
   GlobList Filter("");
 
   EXPECT_TRUE(Filter.contains(""));
   EXPECT_FALSE(Filter.contains("aaa"));
 }

unittests/clang-tidy/ClangTidyTest.h

private:
   ClangTidyContext *Context;
 };
 
 template <typename T>
 std::string runCheckOnCode(StringRef Code,
                            std::vector<ClangTidyError> *Errors = nullptr,
                            const Twine &Filename = "input.cc",
                            ArrayRef<std::string> ExtraArgs = None) {
-  T Check;
   ClangTidyOptions Options;
   Options.Checks = "*";
   ClangTidyContext Context(llvm::make_unique<DefaultOptionsProvider>(
       ClangTidyGlobalOptions(), Options));
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
-  Check.setContext(&Context);
+  T Check("test-check", &Context);
   std::vector<std::string> ArgCXX11(1, "-std=c++11");
   ArgCXX11.insert(ArgCXX11.end(), ExtraArgs.begin(), ExtraArgs.end());
 
   if (!tooling::runToolOnCodeWithArgs(new TestPPAction(Check, &Context), Code,
                                       ArgCXX11, Filename))
     return "";
   ast_matchers::MatchFinder Finder;
   Check.registerMatchers(&Finder);

unittests/clang-tidy/LLVMModuleTest.cpp

 #if !defined(_WIN32)
 static std::string runHeaderGuardCheck(StringRef Code, const Twine &Filename) {
   return test::runCheckOnCode<LLVMHeaderGuardCheck>(
       Code, /*Errors=*/nullptr, Filename, std::string("-xc++-header"));
 }
 
 namespace {
 struct WithEndifComment : public LLVMHeaderGuardCheck {
+  WithEndifComment(StringRef Name, ClangTidyContext *Context)
+      : LLVMHeaderGuardCheck(Name, Context) {}
   bool shouldSuggestEndifComment(StringRef Filename) override { return true; }
 };
 } // namespace
 
 static std::string runHeaderGuardCheckWithEndif(StringRef Code,
                                                 const Twine &Filename) {
   return test::runCheckOnCode<WithEndifComment>(
       Code, /*Errors=*/nullptr, Filename, std::string("-xc++-header"));