1 files changed, 343 insertions, 141 deletions

diff --git a/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp b/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp
index 620c0e5889..4267d8a2cd 100644
--- a/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp
+++ b/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp
@@ -1,9 +1,8 @@
 //===- CheckerRegistry.cpp - Maintains all available checkers -------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
 //
 //===----------------------------------------------------------------------===//
 
@@ -12,8 +11,8 @@
 #include "clang/Basic/LLVM.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
-#include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
+#include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringMap.h"
@@ -29,219 +28,422 @@ using llvm::sys::DynamicLibrary;
 
 using RegisterCheckersFn = void (*)(CheckerRegistry &);
 
-static bool isCompatibleAPIVersion(const char *versionString) {
-  // If the version string is null, it's not an analyzer plugin.
-  if (!versionString)
+static bool isCompatibleAPIVersion(const char *VersionString) {
+  // If the version string is null, its not an analyzer plugin.
+  if (!VersionString)
     return false;
 
   // For now, none of the static analyzer API is considered stable.
   // Versions must match exactly.
-  return strcmp(versionString, CLANG_ANALYZER_API_VERSION_STRING) == 0;
+  return strcmp(VersionString, CLANG_ANALYZER_API_VERSION_STRING) == 0;
+}
+
+namespace {
+template <class T> struct FullNameLT {
+  bool operator()(const T &Lhs, const T &Rhs) {
+    return Lhs.FullName < Rhs.FullName;
+  }
+};
+
+using PackageNameLT = FullNameLT<CheckerRegistry::PackageInfo>;
+using CheckerNameLT = FullNameLT<CheckerRegistry::CheckerInfo>;
+} // end of anonymous namespace
+
+template <class CheckerOrPackageInfoList>
+static
+    typename std::conditional<std::is_const<CheckerOrPackageInfoList>::value,
+                              typename CheckerOrPackageInfoList::const_iterator,
+                              typename CheckerOrPackageInfoList::iterator>::type
+    binaryFind(CheckerOrPackageInfoList &Collection, StringRef FullName) {
+
+  using CheckerOrPackage = typename CheckerOrPackageInfoList::value_type;
+  using CheckerOrPackageFullNameLT = FullNameLT<CheckerOrPackage>;
+
+  assert(std::is_sorted(Collection.begin(), Collection.end(),
+                        CheckerOrPackageFullNameLT{}) &&
+         "In order to efficiently gather checkers/packages, this function "
+         "expects them to be already sorted!");
+
+  return llvm::lower_bound(Collection, CheckerOrPackage(FullName),
+                           CheckerOrPackageFullNameLT{});
+}
+
+static constexpr char PackageSeparator = '.';
+
+static bool isInPackage(const CheckerRegistry::CheckerInfo &Checker,
+                        StringRef PackageName) {
+  // Does the checker's full name have the package as a prefix?
+  if (!Checker.FullName.startswith(PackageName))
+    return false;
+
+  // Is the package actually just the name of a specific checker?
+  if (Checker.FullName.size() == PackageName.size())
+    return true;
+
+  // Is the checker in the package (or a subpackage)?
+  if (Checker.FullName[PackageName.size()] == PackageSeparator)
+    return true;
+
+  return false;
 }
 
-CheckerRegistry::CheckerRegistry(ArrayRef<std::string> plugins,
-                                 DiagnosticsEngine &diags) : Diags(diags) {
+CheckerRegistry::CheckerInfoListRange
+CheckerRegistry::getMutableCheckersForCmdLineArg(StringRef CmdLineArg) {
+  auto It = binaryFind(Checkers, CmdLineArg);
+
+  if (!isInPackage(*It, CmdLineArg))
+    return {Checkers.end(), Checkers.end()};
+
+  // See how large the package is.
+  // If the package doesn't exist, assume the option refers to a single
+  // checker.
+  size_t Size = 1;
+  llvm::StringMap<size_t>::const_iterator PackageSize =
+      PackageSizes.find(CmdLineArg);
+
+  if (PackageSize != PackageSizes.end())
+    Size = PackageSize->getValue();
+
+  return {It, It + Size};
+}
+
+CheckerRegistry::CheckerRegistry(
+    ArrayRef<std::string> Plugins, DiagnosticsEngine &Diags,
+    AnalyzerOptions &AnOpts, const LangOptions &LangOpts,
+    ArrayRef<std::function<void(CheckerRegistry &)>> CheckerRegistrationFns)
+    : Diags(Diags), AnOpts(AnOpts), LangOpts(LangOpts) {
+
+  // Register builtin checkers.
 #define GET_CHECKERS
-#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI)                            \
-  addChecker(register##CLASS, FULLNAME, HELPTEXT, DOC_URI);
+#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN)                 \
+  addChecker(register##CLASS, shouldRegister##CLASS, FULLNAME, HELPTEXT,       \
+             DOC_URI, IS_HIDDEN);
+
+#define GET_PACKAGES
+#define PACKAGE(FULLNAME) addPackage(FULLNAME);
+
 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 #undef CHECKER
 #undef GET_CHECKERS
+#undef PACKAGE
+#undef GET_PACKAGES
 
-  for (ArrayRef<std::string>::iterator i = plugins.begin(), e = plugins.end();
-       i != e; ++i) {
+  // Register checkers from plugins.
+  for (const std::string &Plugin : Plugins) {
     // Get access to the plugin.
-    std::string err;
-    DynamicLibrary lib = DynamicLibrary::getPermanentLibrary(i->c_str(), &err);
-    if (!lib.isValid()) {
-      diags.Report(diag::err_fe_unable_to_load_plugin) << *i << err;
+    std::string ErrorMsg;
+    DynamicLibrary Lib =
+        DynamicLibrary::getPermanentLibrary(Plugin.c_str(), &ErrorMsg);
+    if (!Lib.isValid()) {
+      Diags.Report(diag::err_fe_unable_to_load_plugin) << Plugin << ErrorMsg;
       continue;
     }
 
-    // See if it's compatible with this build of clang.
-    const char *pluginAPIVersion =
-      (const char *) lib.getAddressOfSymbol("clang_analyzerAPIVersionString");
-    if (!isCompatibleAPIVersion(pluginAPIVersion)) {
+    // See if its compatible with this build of clang.
+    const char *PluginAPIVersion = static_cast<const char *>(
+        Lib.getAddressOfSymbol("clang_analyzerAPIVersionString"));
+
+    if (!isCompatibleAPIVersion(PluginAPIVersion)) {
       Diags.Report(diag::warn_incompatible_analyzer_plugin_api)
-          << llvm::sys::path::filename(*i);
+          << llvm::sys::path::filename(Plugin);
       Diags.Report(diag::note_incompatible_analyzer_plugin_api)
-          << CLANG_ANALYZER_API_VERSION_STRING
-          << pluginAPIVersion;
+          << CLANG_ANALYZER_API_VERSION_STRING << PluginAPIVersion;
       continue;
     }
 
     // Register its checkers.
-    RegisterCheckersFn registerPluginCheckers =
-      (RegisterCheckersFn) (intptr_t) lib.getAddressOfSymbol(
-                                                      "clang_registerCheckers");
-    if (registerPluginCheckers)
-      registerPluginCheckers(*this);
+    RegisterCheckersFn RegisterPluginCheckers =
+        reinterpret_cast<RegisterCheckersFn>(
+            Lib.getAddressOfSymbol("clang_registerCheckers"));
+    if (RegisterPluginCheckers)
+      RegisterPluginCheckers(*this);
   }
-}
 
-static constexpr char PackageSeparator = '.';
+  // Register statically linked checkers, that aren't generated from the tblgen
+  // file, but rather passed their registry function as a parameter in
+  // checkerRegistrationFns.
+
+  for (const auto &Fn : CheckerRegistrationFns)
+    Fn(*this);
 
-static bool checkerNameLT(const CheckerRegistry::CheckerInfo &a,
-                          const CheckerRegistry::CheckerInfo &b) {
-  return a.FullName < b.FullName;
+  // Sort checkers for efficient collection.
+  // FIXME: Alphabetical sort puts 'experimental' in the middle.
+  // Would it be better to name it '~experimental' or something else
+  // that's ASCIIbetically last?
+  llvm::sort(Packages, PackageNameLT{});
+  llvm::sort(Checkers, CheckerNameLT{});
+
+#define GET_CHECKER_DEPENDENCIES
+
+#define CHECKER_DEPENDENCY(FULLNAME, DEPENDENCY)                               \
+  addDependency(FULLNAME, DEPENDENCY);
+
+#define GET_CHECKER_OPTIONS
+#define CHECKER_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL)             \
+  addCheckerOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC);
+
+#define GET_PACKAGE_OPTIONS
+#define PACKAGE_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL)             \
+  addPackageOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC);
+
+#include "clang/StaticAnalyzer/Checkers/Checkers.inc"
+#undef CHECKER_DEPENDENCY
+#undef GET_CHECKER_DEPENDENCIES
+#undef CHECKER_OPTION
+#undef GET_CHECKER_OPTIONS
+#undef PACKAGE_OPTION
+#undef GET_PACKAGE_OPTIONS
+
+  resolveDependencies();
+  resolveCheckerAndPackageOptions();
+
+  // Parse '-analyzer-checker' and '-analyzer-disable-checker' options from the
+  // command line.
+  for (const std::pair<std::string, bool> &Opt : AnOpts.CheckersControlList) {
+    CheckerInfoListRange CheckerForCmdLineArg =
+        getMutableCheckersForCmdLineArg(Opt.first);
+
+    if (CheckerForCmdLineArg.begin() == CheckerForCmdLineArg.end()) {
+      Diags.Report(diag::err_unknown_analyzer_checker) << Opt.first;
+      Diags.Report(diag::note_suggest_disabling_all_checkers);
+    }
+
+    for (CheckerInfo &checker : CheckerForCmdLineArg) {
+      checker.State = Opt.second ? StateFromCmdLine::State_Enabled
+                                 : StateFromCmdLine::State_Disabled;
+    }
+  }
 }
 
-static bool isInPackage(const CheckerRegistry::CheckerInfo &checker,
-                        StringRef packageName) {
-  // Does the checker's full name have the package as a prefix?
-  if (!checker.FullName.startswith(packageName))
-    return false;
+/// Collects dependencies in \p ret, returns false on failure.
+static bool
+collectDependenciesImpl(const CheckerRegistry::ConstCheckerInfoList &Deps,
+                        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 LangOptions &LO) {
+
+  CheckerRegistry::CheckerInfoSet Ret;
+  // Add dependencies to the enabled checkers only if all of them can be
+  // enabled.
+  if (!collectDependenciesImpl(checker.Dependencies, LO, Ret))
+    return None;
+
+  return Ret;
+}
 
-  // Is the package actually just the name of a specific checker?
-  if (checker.FullName.size() == packageName.size())
-    return true;
+static bool
+collectDependenciesImpl(const CheckerRegistry::ConstCheckerInfoList &Deps,
+                        const LangOptions &LO,
+                        CheckerRegistry::CheckerInfoSet &Ret) {
 
-  // Is the checker in the package (or a subpackage)?
-  if (checker.FullName[packageName.size()] == PackageSeparator)
-    return true;
+  for (const CheckerRegistry::CheckerInfo *Dependency : Deps) {
 
-  return false;
+    if (Dependency->isDisabled(LO))
+      return false;
+
+    // Collect dependencies recursively.
+    if (!collectDependenciesImpl(Dependency->Dependencies, LO, Ret))
+      return false;
+
+    Ret.insert(Dependency);
+  }
+
+  return true;
 }
 
-CheckerRegistry::CheckerInfoSet CheckerRegistry::getEnabledCheckers(
-                                            const AnalyzerOptions &Opts) const {
+CheckerRegistry::CheckerInfoSet CheckerRegistry::getEnabledCheckers() const {
 
-  assert(std::is_sorted(Checkers.begin(), Checkers.end(), checkerNameLT) &&
-         "In order to efficiently gather checkers, this function expects them "
-         "to be already sorted!");
+  CheckerInfoSet EnabledCheckers;
 
-  CheckerInfoSet enabledCheckers;
-  const auto end = Checkers.cend();
+  for (const CheckerInfo &Checker : Checkers) {
+    if (!Checker.isEnabled(LangOpts))
+      continue;
 
-  for (const std::pair<std::string, bool> &opt : Opts.CheckersControlList) {
-    // Use a binary search to find the possible start of the package.
-    CheckerRegistry::CheckerInfo packageInfo(nullptr, opt.first, "", "");
-    auto firstRelatedChecker =
-      std::lower_bound(Checkers.cbegin(), end, packageInfo, checkerNameLT);
+    // Recursively enable its dependencies.
+    llvm::Optional<CheckerInfoSet> Deps =
+        collectDependencies(Checker, LangOpts);
 
-    if (firstRelatedChecker == end ||
-        !isInPackage(*firstRelatedChecker, opt.first)) {
-      Diags.Report(diag::err_unknown_analyzer_checker) << opt.first;
-      Diags.Report(diag::note_suggest_disabling_all_checkers);
-      return {};
+    if (!Deps) {
+      // If we failed to enable any of the dependencies, don't enable this
+      // checker.
+      continue;
     }
 
-    // See how large the package is.
-    // If the package doesn't exist, assume the option refers to a single
-    // checker.
-    size_t size = 1;
-    llvm::StringMap<size_t>::const_iterator packageSize =
-      Packages.find(opt.first);
-    if (packageSize != Packages.end())
-      size = packageSize->getValue();
-
-    // Step through all the checkers in the package.
-    for (auto lastRelatedChecker = firstRelatedChecker+size;
-         firstRelatedChecker != lastRelatedChecker; ++firstRelatedChecker)
-      if (opt.second)
-        enabledCheckers.insert(&*firstRelatedChecker);
-      else
-        enabledCheckers.remove(&*firstRelatedChecker);
+    // Note that set_union also preserves the order of insertion.
+    EnabledCheckers.set_union(*Deps);
+
+    // Enable the checker.
+    EnabledCheckers.insert(&Checker);
   }
 
-  return enabledCheckers;
+  return EnabledCheckers;
 }
 
-void CheckerRegistry::addChecker(InitializationFunction Fn, StringRef Name,
-                                 StringRef Desc, StringRef DocsUri) {
-  Checkers.emplace_back(Fn, Name, Desc, DocsUri);
+void CheckerRegistry::resolveDependencies() {
+  for (const std::pair<StringRef, StringRef> &Entry : Dependencies) {
+    auto CheckerIt = binaryFind(Checkers, Entry.first);
+    assert(CheckerIt != Checkers.end() && CheckerIt->FullName == Entry.first &&
+           "Failed to find the checker while attempting to set up its "
+           "dependencies!");
+
+    auto DependencyIt = binaryFind(Checkers, Entry.second);
+    assert(DependencyIt != Checkers.end() &&
+           DependencyIt->FullName == Entry.second &&
+           "Failed to find the dependency of a checker!");
+
+    CheckerIt->Dependencies.emplace_back(&*DependencyIt);
+  }
+
+  Dependencies.clear();
+}
+
+void CheckerRegistry::addDependency(StringRef FullName, StringRef Dependency) {
+  Dependencies.emplace_back(FullName, Dependency);
+}
+
+template <class T>
+static void
+insertOptionToCollection(StringRef FullName, T &Collection,
+                         const CheckerRegistry::CmdLineOption &&Option) {
+  auto It = binaryFind(Collection, FullName);
+  assert(It != Collection.end() &&
+         "Failed to find the checker while attempting to add a command line "
+         "option to it!");
+
+  It->CmdLineOptions.emplace_back(std::move(Option));
+}
+
+void CheckerRegistry::resolveCheckerAndPackageOptions() {
+  for (const std::pair<StringRef, CmdLineOption> &CheckerOptEntry :
+       CheckerOptions) {
+    insertOptionToCollection(CheckerOptEntry.first, Checkers,
+                             std::move(CheckerOptEntry.second));
+  }
+  CheckerOptions.clear();
+
+  for (const std::pair<StringRef, CmdLineOption> &PackageOptEntry :
+       PackageOptions) {
+    insertOptionToCollection(PackageOptEntry.first, Checkers,
+                             std::move(PackageOptEntry.second));
+  }
+  PackageOptions.clear();
+}
+
+void CheckerRegistry::addPackage(StringRef FullName) {
+  Packages.emplace_back(PackageInfo(FullName));
+}
+
+void CheckerRegistry::addPackageOption(StringRef OptionType,
+                                       StringRef PackageFullName,
+                                       StringRef OptionName,
+                                       StringRef DefaultValStr,
+                                       StringRef Description) {
+  PackageOptions.emplace_back(
+      PackageFullName,
+      CmdLineOption{OptionType, OptionName, DefaultValStr, Description});
+}
+
+void CheckerRegistry::addChecker(InitializationFunction Rfn,
+                                 ShouldRegisterFunction Sfn, StringRef Name,
+                                 StringRef Desc, StringRef DocsUri,
+                                 bool IsHidden) {
+  Checkers.emplace_back(Rfn, Sfn, Name, Desc, DocsUri, IsHidden);
 
   // Record the presence of the checker in its packages.
-  StringRef packageName, leafName;
-  std::tie(packageName, leafName) = Name.rsplit(PackageSeparator);
-  while (!leafName.empty()) {
-    Packages[packageName] += 1;
-    std::tie(packageName, leafName) = packageName.rsplit(PackageSeparator);
+  StringRef PackageName, LeafName;
+  std::tie(PackageName, LeafName) = Name.rsplit(PackageSeparator);
+  while (!LeafName.empty()) {
+    PackageSizes[PackageName] += 1;
+    std::tie(PackageName, LeafName) = PackageName.rsplit(PackageSeparator);
   }
 }
 
-void CheckerRegistry::initializeManager(CheckerManager &checkerMgr,
-                                        const AnalyzerOptions &Opts) const {
-  // Sort checkers for efficient collection.
-  llvm::sort(Checkers, checkerNameLT);
+void CheckerRegistry::addCheckerOption(StringRef OptionType,
+                                       StringRef CheckerFullName,
+                                       StringRef OptionName,
+                                       StringRef DefaultValStr,
+                                       StringRef Description) {
+  CheckerOptions.emplace_back(
+      CheckerFullName,
+      CmdLineOption{OptionType, OptionName, DefaultValStr, Description});
+}
 
+void CheckerRegistry::initializeManager(CheckerManager &CheckerMgr) const {
   // Collect checkers enabled by the options.
-  CheckerInfoSet enabledCheckers = getEnabledCheckers(Opts);
+  CheckerInfoSet enabledCheckers = getEnabledCheckers();
 
   // Initialize the CheckerManager with all enabled checkers.
-  for (const auto *i : enabledCheckers) {
-    checkerMgr.setCurrentCheckName(CheckName(i->FullName));
-    i->Initialize(checkerMgr);
+  for (const auto *Checker : enabledCheckers) {
+    CheckerMgr.setCurrentCheckName(CheckName(Checker->FullName));
+    Checker->Initialize(CheckerMgr);
   }
 }
 
-void CheckerRegistry::validateCheckerOptions(
-                                            const AnalyzerOptions &opts) const {
-  for (const auto &config : opts.Config) {
-    size_t pos = config.getKey().find(':');
-    if (pos == StringRef::npos)
+void CheckerRegistry::validateCheckerOptions() const {
+  for (const auto &Config : AnOpts.Config) {
+    size_t Pos = Config.getKey().find(':');
+    if (Pos == StringRef::npos)
       continue;
 
-    bool hasChecker = false;
-    StringRef checkerName = config.getKey().substr(0, pos);
-    for (const auto &checker : Checkers) {
-      if (checker.FullName.startswith(checkerName) &&
-          (checker.FullName.size() == pos || checker.FullName[pos] == '.')) {
-        hasChecker = true;
+    bool HasChecker = false;
+    StringRef CheckerName = Config.getKey().substr(0, Pos);
+    for (const auto &Checker : Checkers) {
+      if (Checker.FullName.startswith(CheckerName) &&
+          (Checker.FullName.size() == Pos || Checker.FullName[Pos] == '.')) {
+        HasChecker = true;
         break;
       }
     }
-    if (!hasChecker)
-      Diags.Report(diag::err_unknown_analyzer_checker) << checkerName;
+    if (!HasChecker)
+      Diags.Report(diag::err_unknown_analyzer_checker) << CheckerName;
   }
 }
 
-void CheckerRegistry::printHelp(raw_ostream &out,
-                                size_t maxNameChars) const {
-  // FIXME: Alphabetical sort puts 'experimental' in the middle.
-  // Would it be better to name it '~experimental' or something else
-  // that's ASCIIbetically last?
-  llvm::sort(Checkers, checkerNameLT);
-
+void CheckerRegistry::printCheckerWithDescList(raw_ostream &Out,
+                                               size_t MaxNameChars) const {
   // FIXME: Print available packages.
 
-  out << "CHECKERS:\n";
+  Out << "CHECKERS:\n";
 
   // Find the maximum option length.
-  size_t optionFieldWidth = 0;
-  for (const auto &i : Checkers) {
+  size_t OptionFieldWidth = 0;
+  for (const auto &Checker : Checkers) {
     // Limit the amount of padding we are willing to give up for alignment.
     //   Package.Name     Description  [Hidden]
-    size_t nameLength = i.FullName.size();
-    if (nameLength <= maxNameChars)
-      optionFieldWidth = std::max(optionFieldWidth, nameLength);
+    size_t NameLength = Checker.FullName.size();
+    if (NameLength <= MaxNameChars)
+      OptionFieldWidth = std::max(OptionFieldWidth, NameLength);
   }
 
-  const size_t initialPad = 2;
-  for (const auto &i : Checkers) {
-    out.indent(initialPad) << i.FullName;
+  const size_t InitialPad = 2;
+  for (const auto &Checker : Checkers) {
+    if (!AnOpts.ShowCheckerHelpHidden && Checker.IsHidden)
+      continue;
+
+    Out.indent(InitialPad) << Checker.FullName;
 
-    int pad = optionFieldWidth - i.FullName.size();
+    int Pad = OptionFieldWidth - Checker.FullName.size();
 
     // Break on long option names.
-    if (pad < 0) {
-      out << '\n';
-      pad = optionFieldWidth + initialPad;
+    if (Pad < 0) {
+      Out << '\n';
+      Pad = OptionFieldWidth + InitialPad;
     }
-    out.indent(pad + 2) << i.Desc;
+    Out.indent(Pad + 2) << Checker.Desc;
 
-    out << '\n';
+    Out << '\n';
   }
 }
 
-void CheckerRegistry::printList(raw_ostream &out,
-                                const AnalyzerOptions &opts) const {
-  // Sort checkers for efficient collection.
-  llvm::sort(Checkers, checkerNameLT);
-
+void CheckerRegistry::printEnabledCheckerList(raw_ostream &Out) const {
   // Collect checkers enabled by the options.
-  CheckerInfoSet enabledCheckers = getEnabledCheckers(opts);
+  CheckerInfoSet EnabledCheckers = getEnabledCheckers();
 
-  for (const auto *i : enabledCheckers)
-    out << i->FullName << '\n';
+  for (const auto *i : EnabledCheckers)
+    Out << i->FullName << '\n';
 }