[clang-tidy] Add "clang-tidy as a clang plugin" skeleton.

[bkramer]

Summary

This doesn't really do much at the moment. You can load it via libclang
and set the -checks via an extra command line argument as illustrated in
the test case. Support for other options (including headers check) is
currently missing. Also when using this with libclang some checks may
not work with the precompiled preamble in place.

This can be used to easily show clang-tidy warnings in an editor
integration as all that's needed is adding command line flags that are
passed into libclang. Warnings and FixIts are exposed via the existing
CXDiagnostic machinery.

[klimek]

LG. For now I don't see a better path forward.

[dblaikie]

Would this also be usable as a way to run clang-tidy checks as part of
normal compilation? (some things in clang-tidy aren't there because the FP
is too high to be a hard error on old codebases (but might be viable once a
codebase is able to be cleaned up (like several have been with LLVM)) or
because they're project specific (either stylistically, or because they're
about some project specific API))

clang-tools-extra/trunk/clang-tidy/CMakeLists.txt

add_clang_library(clangTidy
   clangSema
   clangStaticAnalyzerCore
   clangStaticAnalyzerFrontend
   clangTooling
   clangToolingCore
   )
 
 add_subdirectory(tool)
+add_subdirectory(plugin)
 add_subdirectory(cert)
 add_subdirectory(llvm)
 add_subdirectory(cppcoreguidelines)
 add_subdirectory(google)
 add_subdirectory(misc)
 add_subdirectory(modernize)
 add_subdirectory(performance)
 add_subdirectory(readability)
 add_subdirectory(utils)

clang-tools-extra/trunk/clang-tidy/ClangTidyDiagnosticConsumer.h

public:
   /// \brief Returns build directory of the current translation unit.
   const std::string &getCurrentBuildDirectory() {
     return CurrentBuildDirectory;
   }
 
 private:
   // Calls setDiagnosticsEngine() and storeError().
   friend class ClangTidyDiagnosticConsumer;
+  friend class ClangTidyPluginAction;
 
   /// \brief Sets the \c DiagnosticsEngine so that Diagnostics can be generated
   /// correctly.
   void setDiagnosticsEngine(DiagnosticsEngine *Engine);
 
   /// \brief Store an \p Error.
   void storeError(const ClangTidyError &Error);
 

clang-tools-extra/trunk/clang-tidy/plugin/CMakeLists.txt

+add_clang_library(clangTidyPlugin
+  ClangTidyPlugin.cpp
+
+  LINK_LIBS
+  clangAST
+  clangASTMatchers
+  clangBasic
+  clangFrontend
+  clangSema
+  clangTidy
+  clangTidyCERTModule
+  clangTidyCppCoreGuidelinesModule
+  clangTidyGoogleModule
+  clangTidyLLVMModule
+  clangTidyMiscModule
+  clangTidyModernizeModule
+  clangTidyPerformanceModule
+  clangTidyReadabilityModule
+  clangTooling
+  )

clang-tools-extra/trunk/clang-tidy/plugin/ClangTidyPlugin.cpp

+//===- ClangTidyPlugin.cpp - clang-tidy as a clang plugin -----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../ClangTidy.h"
+#include "../ClangTidyModule.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/FrontendPluginRegistry.h"
+#include "clang/Frontend/MultiplexConsumer.h"
+
+namespace clang {
+namespace tidy {
+
+/// The core clang tidy plugin action. This just provides the AST consumer and
+/// command line flag parsing for using clang-tidy as a clang plugin.
+class ClangTidyPluginAction : public PluginASTAction {
+  /// Wrapper to grant the context the same lifetime as the action. We use
+  /// MultiplexConsumer to avoid writing out all the forwarding methods.
+  class WrapConsumer : public MultiplexConsumer {
+    std::unique_ptr<ClangTidyContext> Context;
+
+  public:
+    WrapConsumer(std::unique_ptr<ClangTidyContext> Context,
+                 std::vector<std::unique_ptr<ASTConsumer>> Consumer)
+        : MultiplexConsumer(std::move(Consumer)), Context(std::move(Context)) {}
+  };
+
+public:
+  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
+                                                 StringRef File) override {
+    // Insert the current diagnostics engine.
+    Context->setDiagnosticsEngine(&Compiler.getDiagnostics());
+
+    // Create the AST consumer.
+    ClangTidyASTConsumerFactory Factory(*Context);
+    std::vector<std::unique_ptr<ASTConsumer>> Vec;
+    Vec.push_back(Factory.CreateASTConsumer(Compiler, File));
+
+    return llvm::make_unique<WrapConsumer>(std::move(Context), std::move(Vec));
+  }
+
+  bool ParseArgs(const CompilerInstance &,
+                 const std::vector<std::string> &Args) override {
+    ClangTidyGlobalOptions GlobalOptions;
+    ClangTidyOptions DefaultOptions;
+    ClangTidyOptions OverrideOptions;
+
+    // Parse the extra command line args.
+    // FIXME: This is very limited at the moment.
+    for (StringRef Arg : Args)
+      if (Arg.startswith("-checks="))
+        OverrideOptions.Checks = Arg.substr(strlen("-checks="));
+
+    auto Options = llvm::make_unique<FileOptionsProvider>(
+        GlobalOptions, DefaultOptions, OverrideOptions);
+    Context = llvm::make_unique<ClangTidyContext>(std::move(Options));
+    return true;
+  }
+
+private:
+  std::unique_ptr<ClangTidyContext> Context;
+};
+} // namespace tidy
+} // namespace clang
+
+// This anchor is used to force the linker to link in the generated object file
+// and thus register the clang-tidy plugin.
+volatile int ClangTidyPluginAnchorSource = 0;
+
+static clang::FrontendPluginRegistry::Add<clang::tidy::ClangTidyPluginAction>
+    X("clang-tidy", "clang-tidy");
+
+namespace clang {
+namespace tidy {
+
+// This anchor is used to force the linker to link the CERTModule.
+extern volatile int CERTModuleAnchorSource;
+static int LLVM_ATTRIBUTE_UNUSED CERTModuleAnchorDestination =
+    CERTModuleAnchorSource;
+
+// This anchor is used to force the linker to link the LLVMModule.
+extern volatile int LLVMModuleAnchorSource;
+static int LLVM_ATTRIBUTE_UNUSED LLVMModuleAnchorDestination =
+    LLVMModuleAnchorSource;
+
+// This anchor is used to force the linker to link the CppCoreGuidelinesModule.
+extern volatile int CppCoreGuidelinesModuleAnchorSource;
+static int LLVM_ATTRIBUTE_UNUSED CppCoreGuidelinesModuleAnchorDestination =
+    CppCoreGuidelinesModuleAnchorSource;
+
+// This anchor is used to force the linker to link the GoogleModule.
+extern volatile int GoogleModuleAnchorSource;
+static int LLVM_ATTRIBUTE_UNUSED GoogleModuleAnchorDestination =
+    GoogleModuleAnchorSource;
+
+// This anchor is used to force the linker to link the MiscModule.
+extern volatile int MiscModuleAnchorSource;
+static int LLVM_ATTRIBUTE_UNUSED MiscModuleAnchorDestination =
+    MiscModuleAnchorSource;
+
+// This anchor is used to force the linker to link the ModernizeModule.
+extern volatile int ModernizeModuleAnchorSource;
+static int LLVM_ATTRIBUTE_UNUSED ModernizeModuleAnchorDestination =
+    ModernizeModuleAnchorSource;
+
+// This anchor is used to force the linker to link the PerformanceModule.
+extern volatile int PerformanceModuleAnchorSource;
+static int LLVM_ATTRIBUTE_UNUSED PerformanceModuleAnchorDestination =
+    PerformanceModuleAnchorSource;
+
+// This anchor is used to force the linker to link the ReadabilityModule.
+extern volatile int ReadabilityModuleAnchorSource;
+static int LLVM_ATTRIBUTE_UNUSED ReadabilityModuleAnchorDestination =
+    ReadabilityModuleAnchorSource;
+
+} // namespace tidy
+} // namespace clang

clang-tools-extra/trunk/test/CMakeLists.txt

 
 set(CLANG_TOOLS_TEST_DEPS
   # Base line deps.
   FileCheck count not
 
   # clang-tidy tests require it.
   clang-headers
 
+  # For the clang-tidy libclang integration test.
+  c-index-test
+
   # Individual tools we test.
   clang-apply-replacements
   clang-rename
   clang-query
   clang-tidy
   modularize
   pp-trace
 

clang-tools-extra/trunk/test/clang-tidy/basic.cpp

 // RUN: clang-tidy %s -checks='-*,llvm-namespace-comment' -- | FileCheck %s
+// RUN: c-index-test -test-load-source-reparse 2 all %s -Xclang -add-plugin -Xclang clang-tidy -Xclang -plugin-arg-clang-tidy -Xclang -checks='-*,llvm-namespace-comment' 2>&1 | FileCheck %s
 
 namespace i {
 }
 // CHECK: warning: namespace 'i' not terminated with a closing comment [llvm-namespace-comment]