std::function-ize ClangTidyCheckFactories.

[djasper]

Feels like you are undoing the unique_ptr change I reviewed minutes ok. Nevertheless, this looks good.

[alexfh]

In D5289#4, @djasper wrote:

Feels like you are undoing the unique_ptr change I reviewed minutes ok. Nevertheless, this looks good.

I'd say, that I'm moving this code further in the same direction: making it lighter and more modern ;)

clang-tidy/ClangTidyModule.h

 //===--- ClangTidyModule.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_MODULE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_MODULE_H
 
 #include "ClangTidy.h"
-#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include <functional>
+#include <map>
+#include <string>
 #include <utility>
 
 namespace clang {
 namespace tidy {
 
-/// \brief A factory, that can instantiate a specific clang-tidy check for
-/// processing a translation unit.
+/// \brief A collection of \c ClangTidyCheckFactory instances.
 ///
-/// In order to register your check with the \c ClangTidyModule, create a
-/// subclass of \c CheckFactoryBase and implement \c createCheck(). Then, use
-/// this subclass in \c ClangTidyModule::addCheckFactories().
-class CheckFactoryBase {
+/// All clang-tidy modules register their check factories with an instance of
+/// this object.
+class ClangTidyCheckFactories {
 public:
-  virtual ~CheckFactoryBase() {}
-  virtual ClangTidyCheck *createCheck() = 0;
-};
+  /// \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);
 
-/// \brief A subclass of \c CheckFactoryBase that should be used for all
-/// \c ClangTidyChecks that don't require constructor parameters.
+  /// \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 &CheckFactories) override {
-///     CheckFactories.addCheckFactory(
-///         "myproject-my-check", new ClangTidyCheckFactory<MyTidyCheck>());
+  ///   void addCheckFactories(ClangTidyCheckFactories &Factories) override {
+  ///     Factories.registerCheck<MyTidyCheck>("myproject-my-check");
   ///   }
   /// };
   /// \endcode
-template <typename T> class ClangTidyCheckFactory : public CheckFactoryBase {
-public:
-  ClangTidyCheck *createCheck() override { return new T; }
-};
-
-class ClangTidyCheckFactories;
-
-/// \brief A clang-tidy module groups a number of \c ClangTidyChecks and gives
-/// them a prefixed name.
-class ClangTidyModule {
-public:
-  virtual ~ClangTidyModule() {}
-
-  /// \brief Implement this function in order to register all \c CheckFactories
-  /// belonging to this module.
-  virtual void addCheckFactories(ClangTidyCheckFactories &CheckFactories) = 0;
-};
-
-/// \brief A collection of \c ClangTidyCheckFactory instances.
-///
-/// All clang-tidy modules register their check factories with an instance of
-/// this object.
-class ClangTidyCheckFactories {
-public:
-  /// \brief Register \p Factory with the name \p Name.
-  void addCheckFactory(StringRef Name,
-                       std::unique_ptr<CheckFactoryBase> Factory);
-
-  /// \brief Registers the \c CheckType with the name \p Name by adding a
-  /// corresponding \c ClangTidyCheckFactory.
   template<typename CheckType>
   void registerCheck(StringRef Name) {
-    addCheckFactory(Name,
-                    llvm::make_unique<ClangTidyCheckFactory<CheckType>>());
+    registerCheckFactory(Name, []() { return new CheckType(); });
   }
 
   /// \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,
                     std::vector<std::unique_ptr<ClangTidyCheck>> &Checks);
 
-  typedef std::map<std::string, std::unique_ptr<CheckFactoryBase>> FactoryMap;
+  typedef std::map<std::string, std::function<ClangTidyCheck *()>> 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;
 };
 
+/// \brief A clang-tidy module groups a number of \c ClangTidyChecks and gives
+/// them a prefixed name.
+class ClangTidyModule {
+public:
+  virtual ~ClangTidyModule() {}
+
+  /// \brief Implement this function in order to register all \c CheckFactories
+  /// belonging to this module.
+  virtual void addCheckFactories(ClangTidyCheckFactories &CheckFactories) = 0;
+};
+
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_MODULE_H

clang-tidy/ClangTidyModule.cpp

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