[clang-tidy] Support for Static Analyzer plugins (clang part)

[xazax.hun]

Summary

This is the clang part of http://reviews.llvm.org/D9555.

[alexfh]

Replaced reviewers with the actual static analyzer code owners.

A few peanut gallery comments as well.

include/clang/StaticAnalyzer/Core/CheckerRegistry.h

16

nit: Place this before #include <vector> to maintain the correct order.

include/clang/StaticAnalyzer/Frontend/CheckerRegistration.h

30

s/plugins/Plugins/

lib/StaticAnalyzer/Core/CheckerRegistry.cpp

155

s/result/Result/ to follow the LLVM naming convention.

156

I'd rather sort result than the Checkers field. It's weird when a getter method modifies a class field (it's marked mutable for some reason, but I don't think it's good to abuse this).

158

Can you use a range-based for loop here?

lib/StaticAnalyzer/Frontend/CheckerRegistration.cpp

138

s/plugins/Plugins/

[alexfh]

What's the state here?

[alexfh]

http://reviews.llvm.org/D9555 depends on this patch. Are these two patches still interesting to someone?

[xazax.hun]

Unfortunately I had no time to work on this patch, and after I did not finish this the team I was working in took a different approach: running static analyzer checker through clang and tidy checkers through clang tidy. Initially we wanted to avoid this approach, because they are invoked differently. I have no interest finishing this patch at the moment, but I can not tell for sure for the future. Should I abadon this?

[alexfh]

In D9556#282718, @xazax.hun wrote:

Unfortunately I had no time to work on this patch, and after I did not finish this the team I was working in took a different approach: running static analyzer checker through clang and tidy checkers through clang tidy. Initially we wanted to avoid this approach, because they are invoked differently. I have no interest finishing this patch at the moment, but I can not tell for sure for the future. Should I abadon this?

If it's not needed, then probably yes.

include/clang/StaticAnalyzer/Core/CheckerRegistry.h

 //===--- CheckerRegistry.h - Maintains all available checkers ---*- 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_CORE_CHECKERREGISTRY_H
 #define LLVM_CLANG_STATICANALYZER_CORE_CHECKERREGISTRY_H
 
 #include "clang/Basic/LLVM.h"
 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include <vector>
+#include <string>
 
 // FIXME: move this information to an HTML file in docs/.
 // At the very least, a checker plugin is a dynamic library that exports
 // clang_analyzerAPIVersionString. This should be defined as follows:
 //
 //   extern "C"
 //   const char clang_analyzerAPIVersionString[] =
 //     CLANG_ANALYZER_API_VERSION_STRING;
public:
   /// This can be used to exclude certain checkers in an included package.
   void initializeManager(CheckerManager &mgr,
                          SmallVectorImpl<CheckerOptInfo> &opts) const;
 
   /// Prints the name and description of all checkers in this registry.
   /// This output is not intended to be machine-parseable.
   void printHelp(raw_ostream &out, size_t maxNameChars = 30) const ;
 
+  /// Get the list of every registered checker.
+  std::vector<std::string> getCheckerList() const;
+
 private:
   mutable CheckerInfoList Checkers;
   mutable llvm::StringMap<size_t> Packages;
 };
 
 } // end namespace ento
 } // end namespace clang
 
 #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 <memory>
 #include <string>
+#include <vector>
 
 namespace clang {
   class AnalyzerOptions;
   class LangOptions;
   class DiagnosticsEngine;
 
 namespace ento {
   class CheckerManager;
 
   std::unique_ptr<CheckerManager>
   createCheckerManager(AnalyzerOptions &opts, const LangOptions &langOpts,
                        ArrayRef<std::string> plugins, DiagnosticsEngine &diags);
 
+  std::vector<std::string> getCheckerList(ArrayRef<std::string> plugins);
 } // end ento namespace
 
 } // end namespace clang
 
 #endif

lib/StaticAnalyzer/Core/CheckerRegistry.cpp

if (pad < 0) {
       out << '\n';
       pad = optionFieldWidth + initialPad;
     }
     out.indent(pad + 2) << i->Desc;
 
     out << '\n';
   }
 }
+
+std::vector<std::string> CheckerRegistry::getCheckerList() const {
+  std::vector<std::string> result;
+  std::sort(Checkers.begin(), Checkers.end(), checkerNameLT);
+
+  for (CheckerInfoList::const_iterator i = Checkers.begin(), e = Checkers.end();
+       i != e; ++i) {
+    result.push_back(i->FullName);
+  }
+  return result;
+}

lib/StaticAnalyzer/Frontend/CheckerRegistration.cpp

 }
 
 void ento::printCheckerHelp(raw_ostream &out, ArrayRef<std::string> plugins) {
   out << "OVERVIEW: Clang Static Analyzer Checkers List\n\n";
   out << "USAGE: -analyzer-checker <CHECKER or PACKAGE,...>\n\n";
 
   ClangCheckerRegistry(plugins).printHelp(out);
 }
+
+std::vector<std::string> ento::getCheckerList(ArrayRef<std::string> plugins){
+  return ClangCheckerRegistry(plugins).getCheckerList();
+}