[clang-tidy] Remove dead plugin code

[mattbeardsley]

Summary

The following removed the only use of the clang-tidy plugin code:
https://reviews.llvm.org/D97693

This removes the rest of the now-unused and now-untested clang-tidy plugin code.

[thakis]

If this code is truly dead, this looks fine to me.

But IIRC D97693 was about no longer linking clang-tidy into libclang, while clang-tidy/plugin/ClangTidyPlugin.cpp (if I read the comments therein right) is for using clang-tidy as a clang plugin. Those are two separate things I think (?)

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

set(ALL_CLANG_TIDY_CHECKS
   )
 if(CLANG_TIDY_ENABLE_STATIC_ANALYZER)
   list(APPEND ALL_CLANG_TIDY_CHECKS clangTidyMPIModule)
 endif()
 set(ALL_CLANG_TIDY_CHECKS ${ALL_CLANG_TIDY_CHECKS} PARENT_SCOPE)
 
 # Other subtargets. These may reference ALL_CLANG_TIDY_CHECKS
 # and must be below its definition.
-add_subdirectory(plugin)
 add_subdirectory(tool)
 add_subdirectory(utils)
 
 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
   install(DIRECTORY .
     DESTINATION include/clang-tidy
     COMPONENT clang-tidy-headers
     FILES_MATCHING

clang-tools-extra/clang-tidy/ClangTidy.cpp

 //===--- tools/extra/clang-tidy/ClangTidy.cpp - Clang tidy tool -----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
ArgumentsAdjuster PerFileExtraArgumentsInserter =
         return AdjustedArgs;
       };
 
   Tool.appendArgumentsAdjuster(PerFileExtraArgumentsInserter);
   Tool.appendArgumentsAdjuster(getStripPluginsAdjuster());
   Context.setEnableProfiling(EnableCheckProfile);
   Context.setProfileStoragePrefix(StoreCheckProfile);
 
-  ClangTidyDiagnosticConsumer DiagConsumer(Context, nullptr, true, ApplyAnyFix);
+  ClangTidyDiagnosticConsumer DiagConsumer(Context, true, ApplyAnyFix);
   DiagnosticsEngine DE(new DiagnosticIDs(), new DiagnosticOptions(),
                        &DiagConsumer, /*ShouldOwnClient=*/false);
   Context.setDiagnosticsEngine(&DE);
   Tool.setDiagnosticConsumer(&DiagConsumer);
 
   class ActionFactory : public FrontendActionFactory {
   public:
     ActionFactory(ClangTidyContext &Context,

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

 //===--- ClangTidyDiagnosticConsumer.h - clang-tidy -------------*- 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
 //
 //===----------------------------------------------------------------------===//
 

 /// \param EnableNolintBlocks Enables diagnostic-disabling inside blocks of
 /// code, delimited by NOLINTBEGIN and NOLINTEND.
 //
 // FIXME: If we move away from unit-tests, this can be moved to a private
 // implementation file.
 class ClangTidyDiagnosticConsumer : public DiagnosticConsumer {
 public:
   ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx,
-                              DiagnosticsEngine *ExternalDiagEngine = nullptr,
                               bool RemoveIncompatibleErrors = true,
                               bool GetFixesFromNotes = false,
                               bool EnableNolintBlocks = true);
 
   // FIXME: The concept of converting between FixItHints and Replacements is
   // more generic and should be pulled out into a more useful Diagnostics
   // library.
   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
private:
   /// context.
   llvm::Regex *getHeaderFilter();
 
   /// Updates \c LastErrorRelatesToUserCode and LastErrorPassesLineFilter
   /// according to the diagnostic \p Location.
   void checkFilters(SourceLocation Location, const SourceManager &Sources);
   bool passesLineFilter(StringRef FileName, unsigned LineNumber) const;
 
-  void forwardDiagnostic(const Diagnostic &Info);
-
   ClangTidyContext &Context;
-  DiagnosticsEngine *ExternalDiagEngine;
   bool RemoveIncompatibleErrors;
   bool GetFixesFromNotes;
   bool EnableNolintBlocks;
   std::vector<ClangTidyError> Errors;
   std::unique_ptr<llvm::Regex> HeaderFilter;
   bool LastErrorRelatesToUserCode;
   bool LastErrorPassesLineFilter;
   bool LastErrorWasIgnored;
 };
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

 //===--- tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp ----------=== //
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
std::string ClangTidyContext::getCheckName(unsigned DiagnosticID) const {
   llvm::DenseMap<unsigned, std::string>::const_iterator I =
       CheckNamesByDiagnosticID.find(DiagnosticID);
   if (I != CheckNamesByDiagnosticID.end())
     return I->second;
   return "";
 }
 
 ClangTidyDiagnosticConsumer::ClangTidyDiagnosticConsumer(
-    ClangTidyContext &Ctx, DiagnosticsEngine *ExternalDiagEngine,
-    bool RemoveIncompatibleErrors, bool GetFixesFromNotes,
-    bool EnableNolintBlocks)
-    : Context(Ctx), ExternalDiagEngine(ExternalDiagEngine),
-      RemoveIncompatibleErrors(RemoveIncompatibleErrors),
-      GetFixesFromNotes(GetFixesFromNotes),
-      EnableNolintBlocks(EnableNolintBlocks), LastErrorRelatesToUserCode(false),
-      LastErrorPassesLineFilter(false), LastErrorWasIgnored(false) {}
+    ClangTidyContext &Ctx, bool RemoveIncompatibleErrors,
+    bool GetFixesFromNotes, bool EnableNolintBlocks)
+    : Context(Ctx),  RemoveIncompatibleErrors(RemoveIncompatibleErrors),
+      GetFixesFromNotes(GetFixesFromNotes), EnableNolintBlocks(EnableNolintBlocks),
+      LastErrorRelatesToUserCode(false), LastErrorPassesLineFilter(false),
+      LastErrorWasIgnored(false) {}
 
 void ClangTidyDiagnosticConsumer::finalizeLastError() {
   if (!Errors.empty()) {
     ClangTidyError &Error = Errors.back();
     if (Error.DiagnosticName == "clang-tidy-config") {
       // Never ignore these.
     } else if (!Context.isCheckEnabled(Error.DiagnosticName) &&
                Error.DiagLevel != ClangTidyError::Error) {
if (DiagLevel == DiagnosticsEngine::Note) {
     }
 
     bool IsWarningAsError = DiagLevel == DiagnosticsEngine::Warning &&
                             Context.treatAsError(CheckName);
     Errors.emplace_back(CheckName, Level, Context.getCurrentBuildDirectory(),
                         IsWarningAsError);
   }
 
-  if (ExternalDiagEngine) {
-    // If there is an external diagnostics engine, like in the
-    // ClangTidyPluginAction case, forward the diagnostics to it.
-    forwardDiagnostic(Info);
-  } else {
-    ClangTidyDiagnosticRenderer Converter(
-        Context.getLangOpts(), &Context.DiagEngine->getDiagnosticOptions(),
-        Errors.back());
-    SmallString<100> Message;
-    Info.FormatDiagnostic(Message);
-    FullSourceLoc Loc;
-    if (Info.getLocation().isValid() && Info.hasSourceManager())
       Loc = FullSourceLoc(Info.getLocation(), Info.getSourceManager());
-    Converter.emitDiagnostic(Loc, DiagLevel, Message, Info.getRanges(),
-                             Info.getFixItHints());
-  }
 
   if (Info.hasSourceManager())
     checkFilters(Info.getLocation(), Info.getSourceManager());
 
   Context.DiagEngine->Clear();
   for (const auto &Error : SuppressionErrors)
     Context.diag(Error);
 }
if (FileName.endswith(Filter.Name)) {
           return true;
       }
       return false;
     }
   }
   return false;
 }
 
-void ClangTidyDiagnosticConsumer::forwardDiagnostic(const Diagnostic &Info) {
-  // Acquire a diagnostic ID also in the external diagnostics engine.
-  auto DiagLevelAndFormatString =
-      Context.getDiagLevelAndFormatString(Info.getID(), Info.getLocation());
-  unsigned ExternalID = ExternalDiagEngine->getDiagnosticIDs()->getCustomDiagID(
-      DiagLevelAndFormatString.first, DiagLevelAndFormatString.second);
-
-  // Forward the details.
-  auto Builder = ExternalDiagEngine->Report(Info.getLocation(), ExternalID);
-  for (auto Hint : Info.getFixItHints())
-    Builder << Hint;
-  for (auto Range : Info.getRanges())
-    Builder << Range;
-  for (unsigned Index = 0; Index < Info.getNumArgs(); ++Index) {
-    DiagnosticsEngine::ArgumentKind Kind = Info.getArgKind(Index);
-    switch (Kind) {
-    case clang::DiagnosticsEngine::ak_std_string:
-      Builder << Info.getArgStdStr(Index);
-      break;
-    case clang::DiagnosticsEngine::ak_c_string:
-      Builder << Info.getArgCStr(Index);
-      break;
-    case clang::DiagnosticsEngine::ak_sint:
-      Builder << Info.getArgSInt(Index);
-      break;
-    case clang::DiagnosticsEngine::ak_uint:
-      Builder << Info.getArgUInt(Index);
-      break;
-    case clang::DiagnosticsEngine::ak_tokenkind:
-      Builder << static_cast<tok::TokenKind>(Info.getRawArg(Index));
-      break;
-    case clang::DiagnosticsEngine::ak_identifierinfo:
-      Builder << Info.getArgIdentifier(Index);
-      break;
-    case clang::DiagnosticsEngine::ak_qual:
-      Builder << Qualifiers::fromOpaqueValue(Info.getRawArg(Index));
-      break;
-    case clang::DiagnosticsEngine::ak_qualtype:
-      Builder << QualType::getFromOpaquePtr((void *)Info.getRawArg(Index));
-      break;
-    case clang::DiagnosticsEngine::ak_declarationname:
-      Builder << DeclarationName::getFromOpaqueInteger(Info.getRawArg(Index));
-      break;
-    case clang::DiagnosticsEngine::ak_nameddecl:
-      Builder << reinterpret_cast<const NamedDecl *>(Info.getRawArg(Index));
-      break;
-    case clang::DiagnosticsEngine::ak_nestednamespec:
-      Builder << reinterpret_cast<NestedNameSpecifier *>(Info.getRawArg(Index));
-      break;
-    case clang::DiagnosticsEngine::ak_declcontext:
-      Builder << reinterpret_cast<DeclContext *>(Info.getRawArg(Index));
-      break;
-    case clang::DiagnosticsEngine::ak_qualtype_pair:
-      assert(false); // This one is not passed around.
-      break;
-    case clang::DiagnosticsEngine::ak_attr:
-      Builder << reinterpret_cast<Attr *>(Info.getRawArg(Index));
-      break;
-    case clang::DiagnosticsEngine::ak_addrspace:
-      Builder << static_cast<LangAS>(Info.getRawArg(Index));
-      break;
-    }
-  }
-}
-
 void ClangTidyDiagnosticConsumer::checkFilters(SourceLocation Location,
                                                const SourceManager &Sources) {
   // Invalid location may mean a diagnostic in a command line, don't skip these.
   if (!Location.isValid()) {
     LastErrorRelatesToUserCode = true;
     LastErrorPassesLineFilter = true;
     return;
   }

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

-add_clang_library(clangTidyPlugin
-  ClangTidyPlugin.cpp
-
-  LINK_LIBS
-  clangTidy
-  ${ALL_CLANG_TIDY_CHECKS}
-
-  DEPENDS
-  omp_gen
-  )
-
-clang_target_link_libraries(clangTidyPlugin
-  PRIVATE
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangFrontend
-  clangSema
-  clangTooling
-  )

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

-//===- ClangTidyPlugin.cpp - clang-tidy as a clang plugin -----------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#include "../ClangTidy.h"
-#include "../ClangTidyDiagnosticConsumer.h"
-#include "../ClangTidyForceLinker.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 and diagnostics engine 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;
-    std::unique_ptr<DiagnosticsEngine> DiagEngine;
-
-  public:
-    WrapConsumer(std::unique_ptr<ClangTidyContext> Context,
-                 std::unique_ptr<DiagnosticsEngine> DiagEngine,
-                 std::vector<std::unique_ptr<ASTConsumer>> Consumer)
-        : MultiplexConsumer(std::move(Consumer)), Context(std::move(Context)),
-          DiagEngine(std::move(DiagEngine)) {}
-  };
-
-public:
-  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
-                                                 StringRef File) override {
-    // Create and set diagnostics engine
-    auto *DiagConsumer =
-        new ClangTidyDiagnosticConsumer(*Context, &Compiler.getDiagnostics());
-    auto DiagEngine = std::make_unique<DiagnosticsEngine>(
-        new DiagnosticIDs, new DiagnosticOptions, DiagConsumer);
-    Context->setDiagnosticsEngine(DiagEngine.get());
-
-    // Create the AST consumer.
-    ClangTidyASTConsumerFactory Factory(*Context);
-    std::vector<std::unique_ptr<ASTConsumer>> Vec;
-    Vec.push_back(Factory.createASTConsumer(Compiler, File));
-
-    return std::make_unique<WrapConsumer>(
-        std::move(Context), std::move(DiagEngine), 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 = std::string(Arg.substr(strlen("-checks=")));
-
-    auto Options = std::make_unique<FileOptionsProvider>(
-        GlobalOptions, DefaultOptions, OverrideOptions);
-    Context = std::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");