[analyzer] Allow registering custom statically-linked analyzer checkers

[alexfh]

Summary

Add an extension point to allow registration of statically-linked Clang Static
Analyzer checkers that are not a part of the Clang tree. This extension point
employs the mechanism used when checkers are registered from dynamically loaded
plugins.

[george.karpenkov]

Tests would be nice, but on the other hand AFAIK we don't have unit tests for the analyzer. Maybe it's time we add those.

[george.karpenkov]

Actually, we do have unittests in tools/clang/unittest/Analysis.
@alexfh would you be able to write a unittest in there? It should be fairly easy following the structure of e.g. tools/clang/Analysis/CloneDetectionTest.cpp.
This would also help to ensure this entry point does not bit rot.

[alexfh]

In D45718#1074611, @george.karpenkov wrote:

Actually, we do have unittests in tools/clang/unittest/Analysis.
@alexfh would you be able to write a unittest in there? It should be fairly easy following the structure of e.g. tools/clang/Analysis/CloneDetectionTest.cpp.
This would also help to ensure this entry point does not bit rot.

Thanks for the pointer. I'll add a test.

[alexfh]

• Added a test.

[alexfh]

Please take another look.

[george.karpenkov]

LGTM

include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_STATICANALYZER_FRONTEND_ANALYSISCONSUMER_H
 #define LLVM_CLANG_STATICANALYZER_FRONTEND_ANALYSISCONSUMER_H
 
 #include "clang/AST/ASTConsumer.h"
 #include "clang/Basic/LLVM.h"
+#include <functional>
 #include <memory>
 
 namespace clang {
 
 class Preprocessor;
 class DiagnosticsEngine;
 class CodeInjector;
 class CompilerInstance;
 
 namespace ento {
 class PathDiagnosticConsumer;
 class CheckerManager;
+class CheckerRegistry;
 
 class AnalysisASTConsumer : public ASTConsumer {
 public:
   virtual void AddDiagnosticConsumer(PathDiagnosticConsumer *Consumer) = 0;
+
+  /// This method allows registering statically linked custom checkers that are
+  /// not a part of the Clang tree. It employs the same mechanism that is used
+  /// by plugins.
+  ///
+  /// Example:
+  ///
+  ///   Consumer->AddCheckerRegistrationFn([] (CheckerRegistry& Registry) {
+  ///     Registry.addChecker<MyCustomChecker>("example.MyCustomChecker",
+  ///                                          "Description");
+  ///   });
+  virtual void
+  AddCheckerRegistrationFn(std::function<void(CheckerRegistry &)> Fn) = 0;
 };
 
 /// CreateAnalysisConsumer - Creates an ASTConsumer to run various code
 /// analysis passes.  (The set of analyses run is controlled by command-line
 /// options.)
 std::unique_ptr<AnalysisASTConsumer>
 CreateAnalysisConsumer(CompilerInstance &CI);
 
 } // end GR namespace
 
 } // end clang namespace
 
 #endif

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/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,
-                       ArrayRef<std::string> plugins, DiagnosticsEngine &diags);
+  std::unique_ptr<CheckerManager> createCheckerManager(
+      AnalyzerOptions &opts, const LangOptions &langOpts,
+      ArrayRef<std::string> plugins,
+      ArrayRef<std::function<void(CheckerRegistry &)>> checkerRegistrationFns,
+      DiagnosticsEngine &diags);
 
 } // end ento namespace
 
 } // end namespace clang
 
 #endif

lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

class AnalysisConsumer : public AnalysisASTConsumer,
   };
   typedef unsigned AnalysisMode;
 
   /// Mode of the analyzes while recursively visiting Decls.
   AnalysisMode RecVisitorMode;
   /// Bug Reporter to use while recursively visiting Decls.
   BugReporter *RecVisitorBR;
 
+  std::vector<std::function<void(CheckerRegistry &)>> CheckerRegistrationFns;
+
 public:
   ASTContext *Ctx;
   const Preprocessor &PP;
   const std::string OutDir;
   AnalyzerOptionsRef Opts;
   ArrayRef<std::string> Plugins;
   CodeInjector *Injector;
   cross_tu::CrossTranslationUnitContext CTU;
if (Loc.isValid()) {
 
       llvm::errs() << ": " << Loc.getFilename() << ' '
                            << getFunctionName(D) << '\n';
     }
   }
 
   void Initialize(ASTContext &Context) override {
     Ctx = &Context;
-    checkerMgr = createCheckerManager(*Opts, PP.getLangOpts(), Plugins,
-                                      PP.getDiagnostics());
+    checkerMgr =
+        createCheckerManager(*Opts, PP.getLangOpts(), Plugins,
+                             CheckerRegistrationFns, PP.getDiagnostics());
 
     Mgr = llvm::make_unique<AnalysisManager>(
         *Ctx, PP.getDiagnostics(), PP.getLangOpts(), 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 VisitBlockDecl(BlockDecl *BD) {
     }
     return true;
   }
 
   void AddDiagnosticConsumer(PathDiagnosticConsumer *Consumer) override {
     PathConsumers.push_back(Consumer);
   }
 
+  void AddCheckerRegistrationFn(std::function<void(CheckerRegistry&)> Fn) override {
+    CheckerRegistrationFns.push_back(std::move(Fn));
+  }
+
 private:
   void storeTopLevelDecls(DeclGroupRef DG);
   std::string getFunctionName(const Decl *D);
 
   /// Check if we should skip (not analyze) the given function.
   AnalysisMode getModeForDecl(Decl *D, AnalysisMode Mode);
   void runAnalysisOnTranslationUnit(ASTContext &C);
 

lib/StaticAnalyzer/Frontend/CheckerRegistration.cpp

getCheckerOptList(const AnalyzerOptions &opts) {
   SmallVector<CheckerOptInfo, 8> checkerOpts;
   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,
-                           ArrayRef<std::string> plugins,
-                           DiagnosticsEngine &diags) {
+std::unique_ptr<CheckerManager> ento::createCheckerManager(
+    AnalyzerOptions &opts, const LangOptions &langOpts,
+    ArrayRef<std::function<void(CheckerRegistry &)>> checkerRegistrationFns,
   std::unique_ptr<CheckerManager> checkerMgr(
       new CheckerManager(langOpts, opts));
 
   SmallVector<CheckerOptInfo, 8> checkerOpts = getCheckerOptList(opts);
 
   ClangCheckerRegistry allCheckers(plugins, &diags);
+
+  for (const auto &Fn : checkerRegistrationFns)
+    Fn(allCheckers);
+
   allCheckers.initializeManager(*checkerMgr, checkerOpts);
   allCheckers.validateCheckerOptions(opts, diags);
   checkerMgr->finishedCheckerRegistration();
 
   for (unsigned i = 0, e = checkerOpts.size(); i != e; ++i) {
     if (checkerOpts[i].isUnclaimed()) {
       diags.Report(diag::err_unknown_analyzer_checker)
           << checkerOpts[i].getName();

unittests/StaticAnalyzer/AnalyzerOptionsTest.cpp

-//===- unittest/Analysis/AnalyzerOptionsTest.cpp - SA Options test --------===//
+//===- unittest/StaticAnalyzer/AnalyzerOptionsTest.cpp - SA Options test --===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

unittests/StaticAnalyzer/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(StaticAnalysisTests
   AnalyzerOptionsTest.cpp
+  RegisterCustomCheckersTest.cpp
   )
 
 target_link_libraries(StaticAnalysisTests
   PRIVATE
   clangBasic
   clangAnalysis
-  clangStaticAnalyzerCore 
+  clangStaticAnalyzerCore
+  clangStaticAnalyzerFrontend
+  clangTooling
   )

unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp

+//===- unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp ------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/CheckerRegistry.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
+#include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
+#include "clang/Tooling/Tooling.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace ento {
+namespace {
+
+class CustomChecker : public Checker<check::ASTCodeBody> {
+public:
+  void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr,
+                        BugReporter &BR) const {
+    BR.EmitBasicReport(D, this, "Custom diagnostic", categories::LogicError,
+                       "Custom diagnostic description",
+                       PathDiagnosticLocation(D, Mgr.getSourceManager()), {});
+  }
+};
+
+class TestAction : public ASTFrontendAction {
+  class DiagConsumer : public PathDiagnosticConsumer {
+    llvm::raw_ostream &Output;
+
+  public:
+    DiagConsumer(llvm::raw_ostream &Output) : Output(Output) {}
+    void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
+                              FilesMade *filesMade) override {
+      for (const auto *PD : Diags)
+        Output << PD->getCheckName() << ":" << PD->getShortDescription();
+    }
+
+    StringRef getName() const override { return "Test"; }
+  };
+
+  llvm::raw_ostream &DiagsOutput;
+
+public:
+  TestAction(llvm::raw_ostream &DiagsOutput) : DiagsOutput(DiagsOutput) {}
+
+  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
+                                                 StringRef File) override {
+    std::unique_ptr<AnalysisASTConsumer> AnalysisConsumer =
+        CreateAnalysisConsumer(Compiler);
+    AnalysisConsumer->AddDiagnosticConsumer(new DiagConsumer(DiagsOutput));
+    Compiler.getAnalyzerOpts()->CheckersControlList = {
+        {"custom.CustomChecker", true}};
+    AnalysisConsumer->AddCheckerRegistrationFn([](CheckerRegistry &Registry) {
+      Registry.addChecker<CustomChecker>("custom.CustomChecker", "Description");
+    });
+    return AnalysisConsumer;
+  }
+};
+
+
+TEST(RegisterCustomCheckers, RegisterChecker) {
+  std::string Diags;
+  {
+    llvm::raw_string_ostream OS(Diags);
+    EXPECT_TRUE(tooling::runToolOnCode(new TestAction(OS), "void f() {;}"));
+  }
+  EXPECT_EQ(Diags, "custom.CustomChecker:Custom diagnostic description");
+}
+
+}
+}
+}