[analyzer][NFC] Clang-format CheckerRegistry

[baloghadamsoftware]

No patch should be committed without clang-formatting anyway...

include/clang/StaticAnalyzer/Frontend/CheckerRegistry.h

 /// 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.
 /// For example, the checker "core.builtin.NoReturnFunctionChecker" will be
 /// included if initializeManager() is called with an option of "core",
 /// "core.builtin", or the full name "core.builtin.NoReturnFunctionChecker".
 class CheckerRegistry {
 public:
-  CheckerRegistry(
-      ArrayRef<std::string> plugins, DiagnosticsEngine &diags,
+  CheckerRegistry(ArrayRef<std::string> plugins, DiagnosticsEngine &diags,
                   AnalyzerOptions &AnOpts, const LangOptions &LangOpts,
                   ArrayRef<std::function<void(CheckerRegistry &)>>
                       checkerRegistrationFns = {});
 
   /// Initialization functions perform any necessary setup for a checker.
   /// They should include a call to CheckerManager::registerChecker.
   using InitializationFunction = void (*)(CheckerManager &);
   using ShouldRegisterFunction = bool (*)(const LangOptions &);
 
   struct CheckerInfo;
 
CheckerInfo(InitializationFunction Fn, ShouldRegisterFunction sfn,
                 StringRef Name, StringRef Desc, StringRef DocsUri)
         : Initialize(Fn), ShouldRegister(sfn), FullName(Name), Desc(Desc),
           DocumentationUri(DocsUri) {}
   };
 
   using StateFromCmdLine = CheckerInfo::StateFromCmdLine;
 
 private:
-  template <typename T>
-  static void initializeManager(CheckerManager &mgr) {
+  template <typename T> static void initializeManager(CheckerManager &mgr) {
     mgr.registerChecker<T>();
   }
 
-
-  template <typename T>
-  static bool returnTrue(const LangOptions &LO) {
+  template <typename T> 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,
                   StringRef FullName, StringRef Desc, StringRef DocsUri);

lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp

 //===- CheckerRegistry.cpp - Maintains all available checkers -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
 #include "clang/Basic/Diagnostic.h"
 #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"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
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;
 }
 
 namespace {
-template <class T>
-struct FullNameLT {
+template <class T> struct FullNameLT {
   bool operator()(const T &Lhs, const T &Rhs) {
     return Lhs.FullName < Rhs.FullName;
   }
 };
 
 using CheckerNameLT = FullNameLT<CheckerRegistry::CheckerInfo>;
 } // end of anonymous namespace
 

 CheckerRegistry::CheckerInfoListRange
 CheckerRegistry::getMutableCheckersForCmdLineArg(StringRef CmdLineArg) {
 
   assert(std::is_sorted(Checkers.begin(), Checkers.end(), CheckerNameLT{}) &&
          "In order to efficiently gather checkers, this function expects them "
          "to be already sorted!");
 
   // Use a binary search to find the possible start of the package.
-  CheckerRegistry::CheckerInfo
-      PackageInfo(nullptr, nullptr, CmdLineArg, "", "");
-  auto It = std::lower_bound(Checkers.begin(), Checkers.end(),
-                             PackageInfo, CheckerNameLT{});
+  CheckerRegistry::CheckerInfo PackageInfo(nullptr, nullptr, CmdLineArg, "",
+                                           "");
+  auto It = std::lower_bound(Checkers.begin(), Checkers.end(), PackageInfo,
+                             CheckerNameLT{});
 
   if (!isInPackage(*It, CmdLineArg))
-    return { Checkers.end(), Checkers.end() };
+    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 };
+  return {It, It + Size};
 }
 
 CheckerRegistry::CheckerRegistry(
-     ArrayRef<std::string> Plugins, DiagnosticsEngine &Diags,
-     AnalyzerOptions &AnOpts, const LangOptions &LangOpts,
-     ArrayRef<std::function<void(CheckerRegistry &)>>
-         CheckerRegistrationFns)
+    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, shouldRegister##CLASS, FULLNAME, HELPTEXT,       \
              DOC_URI);
 
 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
for (const std::string &Plugin : Plugins) {
     // 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(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 =
-        reinterpret_cast<RegisterCheckersFn>(Lib.getAddressOfSymbol(
-                                                     "clang_registerCheckers"));
+        reinterpret_cast<RegisterCheckersFn>(
+            Lib.getAddressOfSymbol("clang_registerCheckers"));
     if (RegisterPluginCheckers)
       RegisterPluginCheckers(*this);
   }
 
   // Register statically linked checkers, that aren't generated from the tblgen
-  // file, but rather passed their registry function as a parameter in 
-  // checkerRegistrationFns. 
+  // file, but rather passed their registry function as a parameter in
+  // checkerRegistrationFns.
 
   for (const auto &Fn : CheckerRegistrationFns)
     Fn(*this);
 
   // 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(Checkers, CheckerNameLT{});
 
 #define GET_CHECKER_DEPENDENCIES
 
 #define CHECKER_DEPENDENCY(FULLNAME, DEPENDENCY)                               \
   addDependency(FULLNAME, DEPENDENCY);
 
 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 #undef CHECKER_DEPENDENCY
 #undef GET_CHECKER_DEPENDENCIES
 
   // 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;
+      checker.State = Opt.second ? StateFromCmdLine::State_Enabled
+                                 : StateFromCmdLine::State_Disabled;
     }
   }
 }
 
 /// Collects dependencies in \p ret, returns false on failure.
-static bool collectDependenciesImpl(
-                              const CheckerRegistry::ConstCheckerInfoList &Deps,
-                              const LangOptions &LO,
-                              CheckerRegistry::CheckerInfoSet &Ret);
+static bool
+collectDependenciesImpl(const CheckerRegistry::ConstCheckerInfoList &Deps,
 
 /// Collects dependenies in \p enabledCheckers. Return None on failure.
 LLVM_NODISCARD
-static llvm::Optional<CheckerRegistry::CheckerInfoSet> collectDependencies(
-     const CheckerRegistry::CheckerInfo &checker, const LangOptions &LO) {
+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;
 }
 
-static bool collectDependenciesImpl(
-                              const CheckerRegistry::ConstCheckerInfoList &Deps,
-                              const LangOptions &LO,
-                              CheckerRegistry::CheckerInfoSet &Ret) {
+static bool
+collectDependenciesImpl(const CheckerRegistry::ConstCheckerInfoList &Deps,
 
   for (const CheckerRegistry::CheckerInfo *Dependency : Deps) {
 
     if (Dependency->isDisabled(LO))
       return false;
 
     // Collect dependencies recursively.
     if (!collectDependenciesImpl(Dependency->Dependencies, LO, Ret))
void CheckerRegistry::addChecker(InitializationFunction Rfn,
   std::tie(PackageName, LeafName) = Name.rsplit(PackageSeparator);
   while (!LeafName.empty()) {
     PackageSizes[PackageName] += 1;
     std::tie(PackageName, LeafName) = PackageName.rsplit(PackageSeparator);
   }
 }
 
 void CheckerRegistry::addDependency(StringRef FullName, StringRef dependency) {
-  auto CheckerThatNeedsDeps =
-     [&FullName](const CheckerInfo &Chk) { return Chk.FullName == FullName; };
-  auto Dependency =
-    [&dependency](const CheckerInfo &Chk) {
-      return Chk.FullName == dependency;
-    };
+  auto CheckerThatNeedsDeps = [&FullName](const CheckerInfo &Chk) {
+    return Chk.FullName == FullName;
+  };
+  auto Dependency = [&dependency](const CheckerInfo &Chk) {
 
   auto CheckerIt = llvm::find_if(Checkers, CheckerThatNeedsDeps);
   assert(CheckerIt != Checkers.end() &&
          "Failed to find the checker while attempting to set up its "
          "dependencies!");
 
   auto DependencyIt = llvm::find_if(Checkers, Dependency);
   assert(DependencyIt != Checkers.end() &&