Revert "[analyzer][NFC] Tie CheckerRegistry to CheckerManager, allow CheckerManager to be constructed for non-analysis purposes"

Temporarily reverting this patch because it breaks the modules build.

Author: JDevlieghere

clang/include/clang/StaticAnalyzer/Core/CheckerManager.h

@@ -14,11 +14,9 @@
 #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"
@@ -42,6 +40,7 @@ class BugReporter;
 class CallEvent;
 class CheckerBase;
 class CheckerContext;
+class CheckerRegistry;
 class ExplodedGraph;
 class ExplodedNode;
 class ExplodedNodeSet;
@@ -122,42 +121,14 @@ enum class ObjCMessageVisitKind {
 };
 
 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();
 
@@ -170,12 +141,7 @@ class 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.

clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h

@@ -55,7 +55,7 @@ class AnalysisASTConsumer : public ASTConsumer {
 std::unique_ptr<AnalysisASTConsumer>
 CreateAnalysisConsumer(CompilerInstance &CI);
 
-} // namespace ento
+} // end GR namespace
 
 } // end clang namespace
 

clang/include/clang/StaticAnalyzer/Frontend/AnalyzerHelpFlags.h

@@ -0,0 +1,38 @@
+//===-- 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

clang/include/clang/StaticAnalyzer/Frontend/CheckerRegistration.h

@@ -10,6 +10,7 @@
 #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"
@@ -73,8 +74,6 @@ class LangOptions;
 
 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.
@@ -84,15 +83,10 @@ class CheckerManager;
 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 &);
@@ -211,20 +205,14 @@ class CheckerRegistry {
 
   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,
@@ -233,16 +221,13 @@ class CheckerRegistry {
 
   /// 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
@@ -278,7 +263,7 @@ class CheckerRegistry {
   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
@@ -298,6 +283,11 @@ class CheckerRegistry {
   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".
@@ -324,7 +314,7 @@ class CheckerRegistry {
 
   DiagnosticsEngine &Diags;
   AnalyzerOptions &AnOpts;
-  CheckerInfoSet EnabledCheckers;
+  const LangOptions &LangOpts;
 };
 
 } // namespace ento

clang/include/clang/StaticAnalyzer/Frontend/CheckerRegistry.h

@@ -51,7 +51,22 @@ class ParseModelFileAction : public ASTFrontendAction {
   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
 

clang/include/clang/StaticAnalyzer/Frontend/FrontendActions.h

@@ -23,7 +23,6 @@
 #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"
@@ -244,24 +243,35 @@ bool ExecuteCompilerInvocation(CompilerInstance *Clang) {
   // 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;
   }
 

clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

@@ -64,9 +64,10 @@ void CheckerManager::reportInvalidCheckerOptionValue(
     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;
 }
 
 //===----------------------------------------------------------------------===//

clang/lib/StaticAnalyzer/Core/CheckerManager.cpp

@@ -33,6 +33,7 @@
 #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"
@@ -347,8 +348,8 @@ class AnalysisConsumer : public AnalysisASTConsumer,
 
   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,

clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

@@ -6,7 +6,7 @@ set(LLVM_LINK_COMPONENTS
 
 add_clang_library(clangStaticAnalyzerFrontend
   AnalysisConsumer.cpp
-  AnalyzerHelpFlags.cpp
+  CheckerRegistration.cpp
   CheckerRegistry.cpp
   FrontendActions.cpp
   ModelConsumer.cpp