[analyzer] Add ASTContext to CheckerManager

[george.karpenkov]

Summary

Some checkers require ASTContext. Having it in the constructor saves a lot of boilerplate of having to pass it around.

[NoQ]

clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

297–298

I'm pretty sure PP.getLangOpts() would be the same as Context.getLangOpts(), so there's no need to pass them separately: they can be obtained from the context within the constructor.

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

 
 enum class ObjCMessageVisitKind {
   Pre,
   Post,
   MessageNil
 };
 
 class CheckerManager {
+  ASTContext &Context;
   const LangOptions LangOpts;
   AnalyzerOptions &AOptions;
   CheckName CurrentCheckName;
 
 public:
-  CheckerManager(const LangOptions &langOpts, AnalyzerOptions &AOptions)
-      : LangOpts(langOpts), AOptions(AOptions) {}
+  CheckerManager(ASTContext &Context, AnalyzerOptions &AOptions)
+      : Context(Context), LangOpts(Context.getLangOpts()), AOptions(AOptions) {}
 
   ~CheckerManager();
 
   void setCurrentCheckName(CheckName name) { CurrentCheckName = name; }
   CheckName getCurrentCheckName() const { return CurrentCheckName; }
 
   bool hasPathSensitiveCheckers() const;
 
   void finishedCheckerRegistration();
 
   const LangOptions &getLangOpts() const { return LangOpts; }
   AnalyzerOptions &getAnalyzerOptions() { return AOptions; }
+  ASTContext &getASTContext() { return Context; }
 
   using CheckerRef = CheckerBase *;
   using CheckerTag = const void *;
   using CheckerDtor = CheckerFn<void ()>;
 
 //===----------------------------------------------------------------------===//
 // registerChecker
 //===----------------------------------------------------------------------===//

clang/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h

class AnalysisManager : public BugReporterData {
   StoreManagerCreator CreateStoreMgr;
   ConstraintManagerCreator CreateConstraintMgr;
 
   CheckerManager *CheckerMgr;
 
 public:
   AnalyzerOptions &options;
 
-  AnalysisManager(ASTContext &ctx,DiagnosticsEngine &diags,
-                  const LangOptions &lang,
+  AnalysisManager(ASTContext &ctx, DiagnosticsEngine &diags,
                   const PathDiagnosticConsumers &Consumers,
                   StoreManagerCreator storemgr,
                   ConstraintManagerCreator constraintmgr,
-                  CheckerManager *checkerMgr,
-                  AnalyzerOptions &Options,
-                  CodeInjector* injector = nullptr);
+                  CheckerManager *checkerMgr, AnalyzerOptions &Options,
+                  CodeInjector *injector = nullptr);
 
   ~AnalysisManager() override;
 
   void ClearContexts() {
     AnaCtxMgr.clear();
   }
 
   AnalysisDeclContextManager& getAnalysisDeclContextManager() {

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

 //===-- CheckerRegistration.h - Checker Registration Function ---*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #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(
-      AnalyzerOptions &opts, const LangOptions &langOpts,
+      ASTContext &context,
+      AnalyzerOptions &opts,
       ArrayRef<std::string> plugins,
       ArrayRef<std::function<void(CheckerRegistry &)>> checkerRegistrationFns,
       DiagnosticsEngine &diags);
 
 } // end ento namespace
 
 } // end namespace clang
 
 #endif

clang/lib/StaticAnalyzer/Core/AnalysisManager.cpp

 //===-- AnalysisManager.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 
 using namespace clang;
 using namespace ento;
 
 void AnalysisManager::anchor() { }
 
-AnalysisManager::AnalysisManager(
-    ASTContext &ASTCtx, DiagnosticsEngine &diags, const LangOptions &lang,
-    const PathDiagnosticConsumers &PDC, StoreManagerCreator storemgr,
-    ConstraintManagerCreator constraintmgr, CheckerManager *checkerMgr,
-    AnalyzerOptions &Options, CodeInjector *injector)
-    : AnaCtxMgr(ASTCtx, Options.UnoptimizedCFG,
-                Options.includeImplicitDtorsInCFG(),
-                /*AddInitializers=*/true, Options.includeTemporaryDtorsInCFG(),
-                Options.includeLifetimeInCFG(),
-                // Adding LoopExit elements to the CFG is a requirement for loop
-                // unrolling.
-                Options.includeLoopExitInCFG() || Options.shouldUnrollLoops(),
-                Options.includeScopesInCFG(),
-                Options.shouldSynthesizeBodies(),
-                Options.shouldConditionalizeStaticInitializers(),
-                /*addCXXNewAllocator=*/true,
-                Options.includeRichConstructorsInCFG(),
-                Options.shouldElideConstructors(),
-                injector),
-      Ctx(ASTCtx), Diags(diags), LangOpts(lang), PathConsumers(PDC),
-      CreateStoreMgr(storemgr), CreateConstraintMgr(constraintmgr),
-      CheckerMgr(checkerMgr), options(Options) {
+AnalysisManager::AnalysisManager(ASTContext &ASTCtx, DiagnosticsEngine &diags,
+                                 const PathDiagnosticConsumers &PDC,
+                                 StoreManagerCreator storemgr,
+                                 ConstraintManagerCreator constraintmgr,
+                                 CheckerManager *checkerMgr,
+                                 AnalyzerOptions &Options,
+                                 CodeInjector *injector)
+    : AnaCtxMgr(
+          ASTCtx, Options.UnoptimizedCFG, Options.includeImplicitDtorsInCFG(),
+          Options.includeScopesInCFG(), Options.shouldSynthesizeBodies(),
+          /*addCXXNewAllocator=*/true, Options.includeRichConstructorsInCFG(),
+          Options.shouldElideConstructors(), injector),
+      Ctx(ASTCtx), Diags(diags), LangOpts(ASTCtx.getLangOpts()),
+      PathConsumers(PDC), CreateStoreMgr(storemgr),
+      CreateConstraintMgr(constraintmgr), CheckerMgr(checkerMgr),
+      options(Options) {
   AnaCtxMgr.getCFGBuildOptions().setAllAlwaysAdd();
 }
 
 AnalysisManager::~AnalysisManager() {
   FlushDiagnostics();
   for (PathDiagnosticConsumers::iterator I = PathConsumers.begin(),
        E = PathConsumers.end(); I != E; ++I) {
     delete *I;

clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

if (Loc.isValid()) {
         assert(Mode == (AM_Syntax | AM_Path) && "Unexpected mode!");
 
       llvm::errs() << ": " << Loc.getFilename() << ' '
                            << getFunctionName(D) << '\n';
     }
   }
 
   void Initialize(ASTContext &Context) override {
     Ctx = &Context;
-    checkerMgr =
-        createCheckerManager(*Opts, PP.getLangOpts(), Plugins,
-                             CheckerRegistrationFns, PP.getDiagnostics());
+    checkerMgr = createCheckerManager(
+        *Ctx, *Opts, Plugins, CheckerRegistrationFns, PP.getDiagnostics());
 
     Mgr = llvm::make_unique<AnalysisManager>(
-        *Ctx, PP.getDiagnostics(), PP.getLangOpts(), PathConsumers,
-        CreateStoreMgr, CreateConstraintMgr, checkerMgr.get(), *Opts, Injector);
+        *Ctx, PP.getDiagnostics(), PathConsumers, CreateStoreMgr,
+        CreateConstraintMgr, checkerMgr.get(), *Opts, Injector);
   }
 
   /// Store the top level decls in the set to be processed later on.
   /// (Doing this pre-processing avoids deserialization of data from PCH.)
   bool HandleTopLevelDecl(DeclGroupRef D) override;
   void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override;
 
   void HandleTranslationUnit(ASTContext &C) override;

clang/lib/StaticAnalyzer/Frontend/CheckerRegistration.cpp

getCheckerOptList(const AnalyzerOptions &opts) {
   for (unsigned i = 0, e = opts.CheckersControlList.size(); i != e; ++i) {
     const std::pair<std::string, bool> &opt = opts.CheckersControlList[i];
     checkerOpts.push_back(CheckerOptInfo(opt.first, opt.second));
   }
   return checkerOpts;
 }
 
 std::unique_ptr<CheckerManager> ento::createCheckerManager(
-    AnalyzerOptions &opts, const LangOptions &langOpts,
+    ASTContext &context,
+    AnalyzerOptions &opts,
     ArrayRef<std::string> plugins,
     ArrayRef<std::function<void(CheckerRegistry &)>> checkerRegistrationFns,
     DiagnosticsEngine &diags) {
-  std::unique_ptr<CheckerManager> checkerMgr(
-      new CheckerManager(langOpts, opts));
+  auto checkerMgr = llvm::make_unique<CheckerManager>(context, opts);
 
   SmallVector<CheckerOptInfo, 8> checkerOpts = getCheckerOptList(opts);
 
   ClangCheckerRegistry allCheckers(plugins, &diags);
 
   for (const auto &Fn : checkerRegistrationFns)
     Fn(allCheckers);