Temporarily reverting this patch because it breaks the modules build.
#define LLVM_CLANG_STATICANALYZER_CORE_CHECKERMANAGER_H
#include "clang/Analysis/ProgramPoint.h"
-#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/LangOptions.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/Store.h"
-#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h"
class CallEvent;
class CheckerBase;
class CheckerContext;
+class CheckerRegistry;
class ExplodedGraph;
class ExplodedNode;
class ExplodedNodeSet;
};
class CheckerManager {
- ASTContext *Context;
+ ASTContext &Context;
const LangOptions LangOpts;
AnalyzerOptions &AOptions;
CheckerNameRef CurrentCheckerName;
- DiagnosticsEngine &Diags;
- CheckerRegistry Registry;
public:
- CheckerManager(
- ASTContext &Context, AnalyzerOptions &AOptions,
- ArrayRef<std::string> plugins,
- ArrayRef<std::function<void(CheckerRegistry &)>> checkerRegistrationFns)
- : Context(&Context), LangOpts(Context.getLangOpts()), AOptions(AOptions),
- Diags(Context.getDiagnostics()),
- Registry(plugins, Context.getDiagnostics(), AOptions,
- checkerRegistrationFns) {
- Registry.initializeRegistry(*this);
- Registry.initializeManager(*this);
- finishedCheckerRegistration();
- }
-
- /// Constructs a CheckerManager that ignores all non TblGen-generated
- /// checkers. Useful for unit testing, unless the checker infrastructure
- /// itself is tested.
CheckerManager(ASTContext &Context, AnalyzerOptions &AOptions)
- : CheckerManager(Context, AOptions, {}, {}) {}
-
- /// Constructs a CheckerManager without requiring an AST. No checker
- /// registration will take place. Only useful for retrieving the
- /// CheckerRegistry and print for help flags where the AST is unavalaible.
- CheckerManager(AnalyzerOptions &AOptions, const LangOptions &LangOpts,
- DiagnosticsEngine &Diags, ArrayRef<std::string> plugins)
- : LangOpts(LangOpts), AOptions(AOptions), Diags(Diags),
- Registry(plugins, Diags, AOptions) {
- Registry.initializeRegistry(*this);
- }
+ : Context(Context), LangOpts(Context.getLangOpts()), AOptions(AOptions) {}
~CheckerManager();
const LangOptions &getLangOpts() const { return LangOpts; }
AnalyzerOptions &getAnalyzerOptions() const { return AOptions; }
- const CheckerRegistry &getCheckerRegistry() const { return Registry; }
- DiagnosticsEngine &getDiagnostics() const { return Diags; }
- ASTContext &getASTContext() const {
- assert(Context);
- return *Context;
- }
+ ASTContext &getASTContext() const { return Context; }
/// Emits an error through a DiagnosticsEngine about an invalid user supplied
/// checker option value.
std::unique_ptr<AnalysisASTConsumer>
CreateAnalysisConsumer(CompilerInstance &CI);
-} // namespace ento
+} // end GR namespace
} // end clang namespace
+++ /dev/null
-//===-- AnalyzerHelpFlags.h - Query functions for --help flags --*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_STATICANALYZER_FRONTEND_ANALYZERHELPFLAGS_H
-#define LLVM_CLANG_STATICANALYZER_FRONTEND_ANALYZERHELPFLAGS_H
-
-namespace llvm {
-class raw_ostream;
-} // namespace llvm
-
-namespace clang {
-
-class CompilerInstance;
-
-namespace ento {
-
-void printCheckerHelp(llvm::raw_ostream &OS, CompilerInstance &CI);
-void printEnabledCheckerList(llvm::raw_ostream &OS, CompilerInstance &CI);
-void printAnalyzerConfigList(llvm::raw_ostream &OS);
-void printCheckerConfigList(llvm::raw_ostream &OS, CompilerInstance &CI);
-
-} // namespace ento
-} // namespace clang
-
-#endif
--- /dev/null
+//===-- CheckerRegistration.h - Checker Registration Function ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_STATICANALYZER_FRONTEND_CHECKERREGISTRATION_H
+#define LLVM_CLANG_STATICANALYZER_FRONTEND_CHECKERREGISTRATION_H
+
+#include "clang/AST/ASTContext.h"
+#include "clang/Basic/LLVM.h"
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace clang {
+ class AnalyzerOptions;
+ class LangOptions;
+ class DiagnosticsEngine;
+
+namespace ento {
+ class CheckerManager;
+ class CheckerRegistry;
+
+ std::unique_ptr<CheckerManager> createCheckerManager(
+ ASTContext &context,
+ AnalyzerOptions &opts,
+ ArrayRef<std::string> plugins,
+ ArrayRef<std::function<void(CheckerRegistry &)>> checkerRegistrationFns,
+ DiagnosticsEngine &diags);
+
+} // end ento namespace
+
+} // end namespace clang
+
+#endif
#define LLVM_CLANG_STATICANALYZER_CORE_CHECKERREGISTRY_H
#include "clang/Basic/LLVM.h"
+#include "clang/StaticAnalyzer/Core/CheckerManager.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
namespace ento {
-class CheckerManager;
-
/// Manages a set of available checkers for running a static analysis.
/// The checkers are organized into packages by full name, where including
/// a package will recursively include all subpackages and checkers within it.
class CheckerRegistry {
public:
CheckerRegistry(ArrayRef<std::string> plugins, DiagnosticsEngine &diags,
- AnalyzerOptions &AnOpts,
+ AnalyzerOptions &AnOpts, const LangOptions &LangOpts,
ArrayRef<std::function<void(CheckerRegistry &)>>
checkerRegistrationFns = {});
- /// Collects all enabled checkers in the field EnabledCheckers. It preserves
- /// the order of insertion, as dependencies have to be enabled before the
- /// checkers that depend on them.
- void initializeRegistry(const CheckerManager &Mgr);
-
/// Initialization functions perform any necessary setup for a checker.
/// They should include a call to CheckerManager::registerChecker.
using InitializationFunction = void (*)(CheckerManager &);
using PackageInfoList = llvm::SmallVector<PackageInfo, 0>;
-private:
- /// Default initialization function for checkers -- since CheckerManager
- /// includes this header, we need to make it a template parameter, and since
- /// the checker must be a template parameter as well, we can't put this in the
- /// cpp file.
- template <typename MGR, typename T> static void initializeManager(MGR &mgr) {
- mgr.template registerChecker<T>();
+ template <typename T> static void addToCheckerMgr(CheckerManager &mgr) {
+ mgr.registerChecker<T>();
}
- template <typename T> static bool returnTrue(const LangOptions &) {
+ static bool returnTrue(const LangOptions &LO) {
return true;
}
-public:
/// Adds a checker to the registry. Use this non-templated overload when your
/// checker requires custom initialization.
void addChecker(InitializationFunction Fn, ShouldRegisterFunction sfn,
/// Adds a checker to the registry. Use this templated overload when your
/// checker does not require any custom initialization.
- /// This function isn't really needed and probably causes more headaches than
- /// the tiny convenience that it provides, but external plugins might use it,
- /// and there isn't a strong incentive to remove it.
template <class T>
void addChecker(StringRef FullName, StringRef Desc, StringRef DocsUri,
bool IsHidden = false) {
// Avoid MSVC's Compiler Error C2276:
// http://msdn.microsoft.com/en-us/library/850cstw1(v=VS.80).aspx
- addChecker(&initializeManager<CheckerManager, T>, &returnTrue<T>, FullName,
- Desc, DocsUri, IsHidden);
+ addChecker(&CheckerRegistry::addToCheckerMgr<T>,
+ &CheckerRegistry::returnTrue, FullName, Desc, DocsUri, IsHidden);
}
/// Makes the checker with the full name \p fullName depends on the checker
void addPackageOption(StringRef OptionType, StringRef PackageFullName,
StringRef OptionName, StringRef DefaultValStr,
StringRef Description, StringRef DevelopmentStatus,
- bool IsHidden = false);
+ bool IsHidden = false);
// FIXME: This *really* should be added to the frontend flag descriptions.
/// Initializes a CheckerManager by calling the initialization functions for
void printCheckerOptionList(raw_ostream &Out) const;
private:
+ /// Collect all enabled checkers. The returned container preserves the order
+ /// of insertion, as dependencies have to be enabled before the checkers that
+ /// depend on them.
+ CheckerInfoSet getEnabledCheckers() const;
+
/// Return an iterator range of mutable CheckerInfos \p CmdLineArg applies to.
/// For example, it'll return the checkers for the core package, if
/// \p CmdLineArg is "core".
DiagnosticsEngine &Diags;
AnalyzerOptions &AnOpts;
- CheckerInfoSet EnabledCheckers;
+ const LangOptions &LangOpts;
};
} // namespace ento
llvm::StringMap<Stmt *> &Bodies;
};
-} // namespace ento
+void printCheckerHelp(raw_ostream &OS,
+ ArrayRef<std::string> plugins,
+ AnalyzerOptions &opts,
+ DiagnosticsEngine &diags,
+ const LangOptions &LangOpts);
+void printEnabledCheckerList(raw_ostream &OS, ArrayRef<std::string> plugins,
+ AnalyzerOptions &opts,
+ DiagnosticsEngine &diags,
+ const LangOptions &LangOpts);
+void printAnalyzerConfigList(raw_ostream &OS);
+void printCheckerConfigList(raw_ostream &OS, ArrayRef<std::string> plugins,
+ AnalyzerOptions &opts,
+ DiagnosticsEngine &diags,
+ const LangOptions &LangOpts);
+
+} // end GR namespace
} // end namespace clang
#include "clang/Frontend/Utils.h"
#include "clang/FrontendTool/Utils.h"
#include "clang/Rewrite/Frontend/FrontendActions.h"
-#include "clang/StaticAnalyzer/Frontend/AnalyzerHelpFlags.h"
#include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
#include "llvm/Option/OptTable.h"
#include "llvm/Option/Option.h"
// These should happen AFTER plugins have been loaded!
AnalyzerOptions &AnOpts = *Clang->getAnalyzerOpts();
-
// Honor -analyzer-checker-help and -analyzer-checker-help-hidden.
if (AnOpts.ShowCheckerHelp || AnOpts.ShowCheckerHelpAlpha ||
AnOpts.ShowCheckerHelpDeveloper) {
- ento::printCheckerHelp(llvm::outs(), *Clang);
+ ento::printCheckerHelp(llvm::outs(),
+ Clang->getFrontendOpts().Plugins,
+ AnOpts,
+ Clang->getDiagnostics(),
+ Clang->getLangOpts());
return true;
}
// Honor -analyzer-checker-option-help.
if (AnOpts.ShowCheckerOptionList || AnOpts.ShowCheckerOptionAlphaList ||
AnOpts.ShowCheckerOptionDeveloperList) {
- ento::printCheckerConfigList(llvm::outs(), *Clang);
+ ento::printCheckerConfigList(llvm::outs(),
+ Clang->getFrontendOpts().Plugins,
+ *Clang->getAnalyzerOpts(),
+ Clang->getDiagnostics(),
+ Clang->getLangOpts());
return true;
}
// Honor -analyzer-list-enabled-checkers.
if (AnOpts.ShowEnabledCheckerList) {
- ento::printEnabledCheckerList(llvm::outs(), *Clang);
+ ento::printEnabledCheckerList(llvm::outs(),
+ Clang->getFrontendOpts().Plugins,
+ AnOpts,
+ Clang->getDiagnostics(),
+ Clang->getLangOpts());
return true;
}
const CheckerBase *C, StringRef OptionName,
StringRef ExpectedValueDesc) const {
- getDiagnostics().Report(diag::err_analyzer_checker_option_invalid_input)
- << (llvm::Twine() + C->getTagDescription() + ":" + OptionName).str()
- << ExpectedValueDesc;
+ Context.getDiagnostics()
+ .Report(diag::err_analyzer_checker_option_invalid_input)
+ << (llvm::Twine() + C->getTagDescription() + ":" + OptionName).str()
+ << ExpectedValueDesc;
}
//===----------------------------------------------------------------------===//
#include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistration.h"
#include "clang/Tooling/Core/Replacement.h"
#include "clang/Tooling/Tooling.h"
#include "llvm/ADT/PostOrderIterator.h"
void Initialize(ASTContext &Context) override {
Ctx = &Context;
- checkerMgr = std::make_unique<CheckerManager>(*Ctx, *Opts, Plugins,
- CheckerRegistrationFns);
+ checkerMgr = createCheckerManager(
+ *Ctx, *Opts, Plugins, CheckerRegistrationFns, PP.getDiagnostics());
Mgr = std::make_unique<AnalysisManager>(*Ctx, PP, PathConsumers,
CreateStoreMgr, CreateConstraintMgr,
add_clang_library(clangStaticAnalyzerFrontend
AnalysisConsumer.cpp
- AnalyzerHelpFlags.cpp
+ CheckerRegistration.cpp
CheckerRegistry.cpp
FrontendActions.cpp
ModelConsumer.cpp
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Frontend/AnalyzerHelpFlags.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistration.h"
#include "clang/Basic/Diagnostic.h"
-#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendDiagnostic.h"
#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
#include "clang/StaticAnalyzer/Core/CheckerManager.h"
using namespace clang;
using namespace ento;
-void ento::printCheckerHelp(raw_ostream &out, CompilerInstance &CI) {
- out << "OVERVIEW: Clang Static Analyzer Checkers List\n\n";
- out << "USAGE: -analyzer-checker <CHECKER or PACKAGE,...>\n\n";
+std::unique_ptr<CheckerManager> ento::createCheckerManager(
+ ASTContext &context,
+ AnalyzerOptions &opts,
+ ArrayRef<std::string> plugins,
+ ArrayRef<std::function<void(CheckerRegistry &)>> checkerRegistrationFns,
+ DiagnosticsEngine &diags) {
+ auto checkerMgr = std::make_unique<CheckerManager>(context, opts);
- auto CheckerMgr = std::make_unique<CheckerManager>(
- *CI.getAnalyzerOpts(), CI.getLangOpts(), CI.getDiagnostics(),
- CI.getFrontendOpts().Plugins);
+ CheckerRegistry allCheckers(plugins, diags, opts, context.getLangOpts(),
+ checkerRegistrationFns);
- CheckerMgr->getCheckerRegistry().printCheckerWithDescList(out);
-}
+ allCheckers.initializeManager(*checkerMgr);
+ allCheckers.validateCheckerOptions();
+ checkerMgr->finishedCheckerRegistration();
-void ento::printEnabledCheckerList(raw_ostream &out, CompilerInstance &CI) {
- out << "OVERVIEW: Clang Static Analyzer Enabled Checkers List\n\n";
+ return checkerMgr;
+}
- auto CheckerMgr = std::make_unique<CheckerManager>(
- *CI.getAnalyzerOpts(), CI.getLangOpts(), CI.getDiagnostics(),
- CI.getFrontendOpts().Plugins);
+void ento::printCheckerHelp(raw_ostream &out, ArrayRef<std::string> plugins,
+ AnalyzerOptions &anopts,
+ DiagnosticsEngine &diags,
+ const LangOptions &langOpts) {
+ out << "OVERVIEW: Clang Static Analyzer Checkers List\n\n";
+ out << "USAGE: -analyzer-checker <CHECKER or PACKAGE,...>\n\n";
- CheckerMgr->getCheckerRegistry().printEnabledCheckerList(out);
+ CheckerRegistry(plugins, diags, anopts, langOpts)
+ .printCheckerWithDescList(out);
}
-void ento::printCheckerConfigList(raw_ostream &out, CompilerInstance &CI) {
+void ento::printEnabledCheckerList(raw_ostream &out,
+ ArrayRef<std::string> plugins,
+ AnalyzerOptions &anopts,
+ DiagnosticsEngine &diags,
+ const LangOptions &langOpts) {
+ out << "OVERVIEW: Clang Static Analyzer Enabled Checkers List\n\n";
- auto CheckerMgr = std::make_unique<CheckerManager>(
- *CI.getAnalyzerOpts(), CI.getLangOpts(), CI.getDiagnostics(),
- CI.getFrontendOpts().Plugins);
+ CheckerRegistry(plugins, diags, anopts, langOpts)
+ .printEnabledCheckerList(out);
+}
- CheckerMgr->getCheckerRegistry().printCheckerOptionList(out);
+void ento::printCheckerConfigList(raw_ostream &OS,
+ ArrayRef<std::string> plugins,
+ AnalyzerOptions &opts,
+ DiagnosticsEngine &diags,
+ const LangOptions &LangOpts) {
+ CheckerRegistry(plugins, diags, opts, LangOpts)
+ .printCheckerOptionList(OS);
}
void ento::printAnalyzerConfigList(raw_ostream &out) {
CheckerRegistry::CheckerRegistry(
ArrayRef<std::string> Plugins, DiagnosticsEngine &Diags,
- AnalyzerOptions &AnOpts,
+ AnalyzerOptions &AnOpts, const LangOptions &LangOpts,
ArrayRef<std::function<void(CheckerRegistry &)>> CheckerRegistrationFns)
- : Diags(Diags), AnOpts(AnOpts) {
+ : Diags(Diags), AnOpts(AnOpts), LangOpts(LangOpts) {
// Register builtin checkers.
#define GET_CHECKERS
addDependency(FULLNAME, DEPENDENCY);
#define GET_CHECKER_OPTIONS
-#define CHECKER_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL, \
- DEVELOPMENT_STATUS, IS_HIDDEN) \
- addCheckerOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC, \
- DEVELOPMENT_STATUS, IS_HIDDEN);
+#define CHECKER_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL, DEVELOPMENT_STATUS, IS_HIDDEN) \
+ addCheckerOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC, DEVELOPMENT_STATUS, IS_HIDDEN);
#define GET_PACKAGE_OPTIONS
-#define PACKAGE_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL, \
- DEVELOPMENT_STATUS, IS_HIDDEN) \
- addPackageOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC, \
- DEVELOPMENT_STATUS, IS_HIDDEN);
+#define PACKAGE_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL, DEVELOPMENT_STATUS, IS_HIDDEN) \
+ addPackageOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC, DEVELOPMENT_STATUS, IS_HIDDEN);
#include "clang/StaticAnalyzer/Checkers/Checkers.inc"
#undef CHECKER_DEPENDENCY
: StateFromCmdLine::State_Disabled;
}
}
- validateCheckerOptions();
-}
-
-/// Collects dependenies in \p enabledCheckers. Return None on failure.
-LLVM_NODISCARD
-static llvm::Optional<CheckerRegistry::CheckerInfoSet>
-collectDependencies(const CheckerRegistry::CheckerInfo &checker,
- const CheckerManager &Mgr);
-
-void CheckerRegistry::initializeRegistry(const CheckerManager &Mgr) {
- for (const CheckerInfo &Checker : Checkers) {
- if (!Checker.isEnabled(Mgr.getLangOpts()))
- continue;
-
- // Recursively enable its dependencies.
- llvm::Optional<CheckerInfoSet> Deps = collectDependencies(Checker, Mgr);
-
- if (!Deps) {
- // If we failed to enable any of the dependencies, don't enable this
- // checker.
- continue;
- }
-
- // Note that set_union also preserves the order of insertion.
- EnabledCheckers.set_union(*Deps);
-
- // Enable the checker.
- EnabledCheckers.insert(&Checker);
- }
}
/// Collects dependencies in \p ret, returns false on failure.
static bool
collectDependenciesImpl(const CheckerRegistry::ConstCheckerInfoList &Deps,
- const CheckerManager &Mgr,
+ const LangOptions &LO,
CheckerRegistry::CheckerInfoSet &Ret);
/// Collects dependenies in \p enabledCheckers. Return None on failure.
LLVM_NODISCARD
static llvm::Optional<CheckerRegistry::CheckerInfoSet>
collectDependencies(const CheckerRegistry::CheckerInfo &checker,
- const CheckerManager &Mgr) {
+ const LangOptions &LO) {
CheckerRegistry::CheckerInfoSet Ret;
// Add dependencies to the enabled checkers only if all of them can be
// enabled.
- if (!collectDependenciesImpl(checker.Dependencies, Mgr, Ret))
+ if (!collectDependenciesImpl(checker.Dependencies, LO, Ret))
return None;
return Ret;
static bool
collectDependenciesImpl(const CheckerRegistry::ConstCheckerInfoList &Deps,
- const CheckerManager &Mgr,
+ const LangOptions &LO,
CheckerRegistry::CheckerInfoSet &Ret) {
for (const CheckerRegistry::CheckerInfo *Dependency : Deps) {
- if (Dependency->isDisabled(Mgr.getLangOpts()))
+ if (Dependency->isDisabled(LO))
return false;
// Collect dependencies recursively.
- if (!collectDependenciesImpl(Dependency->Dependencies, Mgr, Ret))
+ if (!collectDependenciesImpl(Dependency->Dependencies, LO, Ret))
return false;
Ret.insert(Dependency);
return true;
}
+CheckerRegistry::CheckerInfoSet CheckerRegistry::getEnabledCheckers() const {
+
+ CheckerInfoSet EnabledCheckers;
+
+ for (const CheckerInfo &Checker : Checkers) {
+ if (!Checker.isEnabled(LangOpts))
+ continue;
+
+ // Recursively enable its dependencies.
+ llvm::Optional<CheckerInfoSet> Deps =
+ collectDependencies(Checker, LangOpts);
+
+ if (!Deps) {
+ // If we failed to enable any of the dependencies, don't enable this
+ // checker.
+ continue;
+ }
+
+ // Note that set_union also preserves the order of insertion.
+ EnabledCheckers.set_union(*Deps);
+
+ // Enable the checker.
+ EnabledCheckers.insert(&Checker);
+ }
+
+ return EnabledCheckers;
+}
+
void CheckerRegistry::resolveDependencies() {
for (const std::pair<StringRef, StringRef> &Entry : Dependencies) {
auto CheckerIt = binaryFind(Checkers, Entry.first);
CheckerIt->Dependencies.emplace_back(&*DependencyIt);
}
+
+ Dependencies.clear();
}
void CheckerRegistry::addDependency(StringRef FullName, StringRef Dependency) {
insertOptionToCollection(CheckerOptEntry.first, Checkers,
CheckerOptEntry.second, AnOpts, Diags);
}
+ CheckerOptions.clear();
for (const std::pair<StringRef, CmdLineOption> &PackageOptEntry :
PackageOptions) {
insertOptionToCollection(PackageOptEntry.first, Packages,
PackageOptEntry.second, AnOpts, Diags);
}
+ PackageOptions.clear();
}
void CheckerRegistry::addPackage(StringRef FullName) {
}
void CheckerRegistry::initializeManager(CheckerManager &CheckerMgr) const {
+ // Collect checkers enabled by the options.
+ CheckerInfoSet enabledCheckers = getEnabledCheckers();
+
// Initialize the CheckerManager with all enabled checkers.
- for (const auto *Checker : EnabledCheckers) {
+ for (const auto *Checker : enabledCheckers) {
CheckerMgr.setCurrentCheckerName(CheckerNameRef(Checker->FullName));
Checker->Initialize(CheckerMgr);
}
}
}
-//===----------------------------------------------------------------------===//
-// Printing functions.
-//===----------------------------------------------------------------------===//
-
void CheckerRegistry::printCheckerWithDescList(raw_ostream &Out,
size_t MaxNameChars) const {
// FIXME: Print available packages.
}
void CheckerRegistry::printEnabledCheckerList(raw_ostream &Out) const {
+ // Collect checkers enabled by the options.
+ CheckerInfoSet EnabledCheckers = getEnabledCheckers();
+
for (const auto *i : EnabledCheckers)
Out << i->FullName << '\n';
}