This is an archive of the discontinued LLVM Phabricator instance.

Differential D5288

Unique-ptrify ClangTidyCheckFactories. Add a more convenient alternative to addCheckFactory: registerCheck.
ClosedPublic

Authored by alexfh on Sep 10 2014, 3:53 AM.

Details

Reviewers
djasper
Commits
rGbe8c143dd604: Unique-ptrify ClangTidyCheckFactories. Add a more convenient alternative to…
rCTE217489: Unique-ptrify ClangTidyCheckFactories. Add a more convenient alternative to
rL217489: Unique-ptrify ClangTidyCheckFactories. Add a more convenient alternative to

Diff Detail

Event Timeline

alexfh updated this revision to Diff 13526.Sep 10 2014, 3:53 AM
alexfh retitled this revision from to Unique-ptrify ClangTidyCheckFactories. Add a more convenient alternative to addCheckFactory: registerCheck..
alexfh updated this object.
alexfh edited the test plan for this revision. (Show Details)
alexfh added a reviewer: djasper.
alexfh added a subscriber: Unknown Object (MLST).
djasper accepted this revision.Sep 10 2014, 4:10 AM
djasper edited edge metadata.

Looks good.

This revision is now accepted and ready to land.Sep 10 2014, 4:10 AM
alexfh closed this revision.Sep 10 2014, 4:16 AM

Revision Contents

PathSize
clang-tidy/
18 lines
11 lines
google/
50 lines
llvm/
15 lines
misc/
32 lines

Diff 13526

clang-tidy/ClangTidyModule.h

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
}; };
/// \brief A collection of \c ClangTidyCheckFactory instances. /// \brief A collection of \c ClangTidyCheckFactory instances.
/// ///
/// All clang-tidy modules register their check factories with an instance of /// All clang-tidy modules register their check factories with an instance of
/// this object. /// this object.
class ClangTidyCheckFactories { class ClangTidyCheckFactories {
public: public:
ClangTidyCheckFactories() {}
~ClangTidyCheckFactories();
/// \brief Register \p Factory with the name \p Name. /// \brief Register \p Factory with the name \p Name.
/// void addCheckFactory(StringRef Name,
/// The \c ClangTidyCheckFactories object takes ownership of the \p Factory. std::unique_ptr<CheckFactoryBase> Factory);
void addCheckFactory(StringRef Name, CheckFactoryBase *Factory);
/// \brief Registers \c CheckType by adding a corresponding
/// \c ClangTidyCheckFactory.
template<typename CheckType>
void registerCheck(StringRef Name) {
addCheckFactory(Name,
llvm::make_unique<ClangTidyCheckFactory<CheckType>>());
}
/// \brief Create instances of all checks matching \p CheckRegexString and /// \brief Create instances of all checks matching \p CheckRegexString and
/// store them in \p Checks. /// store them in \p Checks.
/// ///
/// The caller takes ownership of the return \c ClangTidyChecks. /// The caller takes ownership of the return \c ClangTidyChecks.
void createChecks(GlobList &Filter, void createChecks(GlobList &Filter,
std::vector<std::unique_ptr<ClangTidyCheck>> &Checks); std::vector<std::unique_ptr<ClangTidyCheck>> &Checks);
typedef std::map<std::string, CheckFactoryBase *> FactoryMap; typedef std::map<std::string, std::unique_ptr<CheckFactoryBase>> FactoryMap;
FactoryMap::const_iterator begin() const { return Factories.begin(); } FactoryMap::const_iterator begin() const { return Factories.begin(); }
FactoryMap::const_iterator end() const { return Factories.end(); } FactoryMap::const_iterator end() const { return Factories.end(); }
bool empty() const { return Factories.empty(); } bool empty() const { return Factories.empty(); }
private: private:
FactoryMap Factories; FactoryMap Factories;
}; };
} // end namespace tidy } // end namespace tidy
} // end namespace clang } // end namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_MODULE_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_MODULE_H

clang-tidy/ClangTidyModule.cpp

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

clang-tidy/google/GoogleTidyModule.cpp

Show All 23 Lines
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
class GoogleModule : public ClangTidyModule { class GoogleModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.addCheckFactory( CheckFactories.registerCheck<build::ExplicitMakePairCheck>(
"google-build-explicit-make-pair", "google-build-explicit-make-pair");
new ClangTidyCheckFactory<build::ExplicitMakePairCheck>()); CheckFactories.registerCheck<build::UnnamedNamespaceInHeaderCheck>(
CheckFactories.addCheckFactory( "google-build-namespaces");
"google-build-namespaces", CheckFactories.registerCheck<build::UsingNamespaceDirectiveCheck>(
new ClangTidyCheckFactory<build::UnnamedNamespaceInHeaderCheck>()); "google-build-using-namespace");
CheckFactories.addCheckFactory( CheckFactories.registerCheck<ExplicitConstructorCheck>(
"google-build-using-namespace", "google-explicit-constructor");
new ClangTidyCheckFactory<build::UsingNamespaceDirectiveCheck>()); CheckFactories.registerCheck<runtime::IntegerTypesCheck>(
CheckFactories.addCheckFactory( "google-runtime-int");
"google-explicit-constructor", CheckFactories.registerCheck<runtime::OverloadedUnaryAndCheck>(
new ClangTidyCheckFactory<ExplicitConstructorCheck>()); "google-runtime-operator");
CheckFactories.addCheckFactory( CheckFactories.registerCheck<runtime::StringReferenceMemberCheck>(
"google-runtime-int", "google-runtime-member-string-references");
new ClangTidyCheckFactory<runtime::IntegerTypesCheck>()); CheckFactories.registerCheck<runtime::MemsetZeroLengthCheck>(
CheckFactories.addCheckFactory( "google-runtime-memset");
"google-runtime-operator", CheckFactories.registerCheck<readability::AvoidCStyleCastsCheck>(
new ClangTidyCheckFactory<runtime::OverloadedUnaryAndCheck>()); "google-readability-casting");
CheckFactories.addCheckFactory( CheckFactories.registerCheck<readability::NamedParameterCheck>(
"google-runtime-member-string-references", "google-readability-function");
new ClangTidyCheckFactory<runtime::StringReferenceMemberCheck>());
CheckFactories.addCheckFactory(
"google-runtime-memset",
new ClangTidyCheckFactory<runtime::MemsetZeroLengthCheck>());
CheckFactories.addCheckFactory(
"google-readability-casting",
new ClangTidyCheckFactory<readability::AvoidCStyleCastsCheck>());
CheckFactories.addCheckFactory(
"google-readability-function",
new ClangTidyCheckFactory<readability::NamedParameterCheck>());
} }
}; };
// Register the GoogleTidyModule using this statically initialized variable. // Register the GoogleTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<GoogleModule> X("google-module", static ClangTidyModuleRegistry::Add<GoogleModule> X("google-module",
"Adds Google lint checks."); "Adds Google lint checks.");
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the GoogleModule. // and thus register the GoogleModule.
volatile int GoogleModuleAnchorSource = 0; volatile int GoogleModuleAnchorSource = 0;
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/llvm/LLVMTidyModule.cpp

Show All 15 Lines
#include "TwineLocalCheck.h" #include "TwineLocalCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
class LLVMModule : public ClangTidyModule { class LLVMModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.addCheckFactory( CheckFactories.registerCheck<LLVMHeaderGuardCheck>("llvm-header-guard");
"llvm-header-guard", new ClangTidyCheckFactory<LLVMHeaderGuardCheck>()); CheckFactories.registerCheck<IncludeOrderCheck>("llvm-include-order");
CheckFactories.addCheckFactory( CheckFactories.registerCheck<NamespaceCommentCheck>(
"llvm-include-order", new ClangTidyCheckFactory<IncludeOrderCheck>()); "llvm-namespace-comment");
CheckFactories.addCheckFactory( CheckFactories.registerCheck<TwineLocalCheck>("llvm-twine-local");
"llvm-namespace-comment",
new ClangTidyCheckFactory<NamespaceCommentCheck>());
CheckFactories.addCheckFactory(
"llvm-twine-local",
new ClangTidyCheckFactory<TwineLocalCheck>());
} }
}; };
// Register the LLVMTidyModule using this statically initialized variable. // Register the LLVMTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<LLVMModule> X("llvm-module", static ClangTidyModuleRegistry::Add<LLVMModule> X("llvm-module",
"Adds LLVM lint checks."); "Adds LLVM lint checks.");
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the LLVMModule. // and thus register the LLVMModule.
volatile int LLVMModuleAnchorSource = 0; volatile int LLVMModuleAnchorSource = 0;
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/misc/MiscTidyModule.cpp

Show All 18 Lines
#include "UseOverride.h" #include "UseOverride.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
class MiscModule : public ClangTidyModule { class MiscModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.addCheckFactory( CheckFactories.registerCheck<ArgumentCommentCheck>("misc-argument-comment");
"misc-argument-comment", CheckFactories.registerCheck<BoolPointerImplicitConversion>(
new ClangTidyCheckFactory<ArgumentCommentCheck>()); "misc-bool-pointer-implicit-conversion");
CheckFactories.addCheckFactory( CheckFactories.registerCheck<RedundantSmartptrGet>(
"misc-bool-pointer-implicit-conversion", "misc-redundant-smartptr-get");
new ClangTidyCheckFactory<BoolPointerImplicitConversion>()); CheckFactories.registerCheck<SwappedArgumentsCheck>(
CheckFactories.addCheckFactory( "misc-swapped-arguments");
"misc-redundant-smartptr-get", CheckFactories.registerCheck<UndelegatedConstructorCheck>(
new ClangTidyCheckFactory<RedundantSmartptrGet>()); "misc-undelegated-constructor");
CheckFactories.addCheckFactory( CheckFactories.registerCheck<UnusedRAIICheck>("misc-unused-raii");
"misc-swapped-arguments", CheckFactories.registerCheck<UseOverride>("misc-use-override");
new ClangTidyCheckFactory<SwappedArgumentsCheck>());
CheckFactories.addCheckFactory(
"misc-undelegated-constructor",
new ClangTidyCheckFactory<UndelegatedConstructorCheck>());
CheckFactories.addCheckFactory(
"misc-unused-raii",
new ClangTidyCheckFactory<UnusedRAIICheck>());
CheckFactories.addCheckFactory(
"misc-use-override",
new ClangTidyCheckFactory<UseOverride>());
} }
}; };
// Register the MiscTidyModule using this statically initialized variable. // Register the MiscTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<MiscModule> static ClangTidyModuleRegistry::Add<MiscModule>
X("misc-module", "Adds miscellaneous lint checks."); X("misc-module", "Adds miscellaneous lint checks.");
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the MiscModule. // and thus register the MiscModule.
volatile int MiscModuleAnchorSource = 0; volatile int MiscModuleAnchorSource = 0;
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang