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

   1 //===--- tools/extra/clang-tidy/ClangTidy.cpp - Clang tidy tool -----------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 ///
   9 ///  \file This file implements a clang-tidy tool.
  10 ///
  11 ///  This tool uses the Clang Tooling infrastructure, see
  12 ///    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
  13 ///  for details on setting it up with LLVM source tree.
  14 ///
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "ClangTidy.h"
  18 #include "ClangTidyCheck.h"
  19 #include "ClangTidyDiagnosticConsumer.h"
  20 #include "ClangTidyModuleRegistry.h"
  21 #include "ClangTidyProfiling.h"
  22 #include "ExpandModularHeadersPPCallbacks.h"
  23 #include "clang-tidy-config.h"
  24 #include "clang/AST/ASTConsumer.h"
  25 #include "clang/ASTMatchers/ASTMatchFinder.h"
  26 #include "clang/Format/Format.h"
  27 #include "clang/Frontend/ASTConsumers.h"
  28 #include "clang/Frontend/CompilerInstance.h"
  29 #include "clang/Frontend/FrontendDiagnostic.h"
  30 #include "clang/Frontend/MultiplexConsumer.h"
  31 #include "clang/Frontend/TextDiagnosticPrinter.h"
  32 #include "clang/Lex/PPCallbacks.h"
  33 #include "clang/Lex/Preprocessor.h"
  34 #include "clang/Lex/PreprocessorOptions.h"
  35 #include "clang/Rewrite/Frontend/FixItRewriter.h"
  36 #include "clang/Rewrite/Frontend/FrontendActions.h"
  37 #include "clang/Tooling/Core/Diagnostic.h"
  38 #include "clang/Tooling/DiagnosticsYaml.h"
  39 #include "clang/Tooling/Refactoring.h"
  40 #include "clang/Tooling/ReplacementsYaml.h"
  41 #include "clang/Tooling/Tooling.h"
  42 #include "llvm/Support/Process.h"
  43 #include <algorithm>
  44 #include <utility>
  45
  46 #if CLANG_TIDY_ENABLE_STATIC_ANALYZER
  47 #include "clang/Analysis/PathDiagnostic.h"
  48 #include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
  49 #endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
  50
  51 using namespace clang::ast_matchers;
  52 using namespace clang::driver;
  53 using namespace clang::tooling;
  54 using namespace llvm;
  55
  56 LLVM_INSTANTIATE_REGISTRY(clang::tidy::ClangTidyModuleRegistry)
  57
  58 namespace clang::tidy {
  59
  60 namespace {
  61 #if CLANG_TIDY_ENABLE_STATIC_ANALYZER
  62 static const char *AnalyzerCheckNamePrefix = "clang-analyzer-";
  63
  64 class AnalyzerDiagnosticConsumer : public ento::PathDiagnosticConsumer {
  65 public:
  66   AnalyzerDiagnosticConsumer(ClangTidyContext &Context) : Context(Context) {}
  67
  68   void FlushDiagnosticsImpl(std::vector<const ento::PathDiagnostic *> &Diags,
  69                             FilesMade *FilesMade) override {
  70     for (const ento::PathDiagnostic *PD : Diags) {
  71       SmallString<64> CheckName(AnalyzerCheckNamePrefix);
  72       CheckName += PD->getCheckerName();
  73       Context.diag(CheckName, PD->getLocation().asLocation(),
  74                    PD->getShortDescription())
  75           << PD->path.back()->getRanges();
  76
  77       for (const auto &DiagPiece :
  78            PD->path.flatten(/*ShouldFlattenMacros=*/true)) {
  79         Context.diag(CheckName, DiagPiece->getLocation().asLocation(),
  80                      DiagPiece->getString(), DiagnosticIDs::Note)
  81             << DiagPiece->getRanges();
  82       }
  83     }
  84   }
  85
  86   StringRef getName() const override { return "ClangTidyDiags"; }
  87   bool supportsLogicalOpControlFlow() const override { return true; }
  88   bool supportsCrossFileDiagnostics() const override { return true; }
  89
  90 private:
  91   ClangTidyContext &Context;
  92 };
  93 #endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
  94
  95 class ErrorReporter {
  96 public:
  97   ErrorReporter(ClangTidyContext &Context, FixBehaviour ApplyFixes,
  98                 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS)
  99       : Files(FileSystemOptions(), std::move(BaseFS)),
 100         DiagOpts(new DiagnosticOptions()),
 101         DiagPrinter(new TextDiagnosticPrinter(llvm::outs(), &*DiagOpts)),
 102         Diags(IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts,
 103               DiagPrinter),
 104         SourceMgr(Diags, Files), Context(Context), ApplyFixes(ApplyFixes) {
 105     DiagOpts->ShowColors = Context.getOptions().UseColor.value_or(
 106         llvm::sys::Process::StandardOutHasColors());
 107     DiagPrinter->BeginSourceFile(LangOpts);
 108     if (DiagOpts->ShowColors && !llvm::sys::Process::StandardOutIsDisplayed()) {
 109       llvm::sys::Process::UseANSIEscapeCodes(true);
 110     }
 111   }
 112
 113   SourceManager &getSourceManager() { return SourceMgr; }
 114
 115   void reportDiagnostic(const ClangTidyError &Error) {
 116     const tooling::DiagnosticMessage &Message = Error.Message;
 117     SourceLocation Loc = getLocation(Message.FilePath, Message.FileOffset);
 118     // Contains a pair for each attempted fix: location and whether the fix was
 119     // applied successfully.
 120     SmallVector<std::pair<SourceLocation, bool>, 4> FixLocations;
 121     {
 122       auto Level = static_cast<DiagnosticsEngine::Level>(Error.DiagLevel);
 123       std::string Name = Error.DiagnosticName;
 124       if (!Error.EnabledDiagnosticAliases.empty())
 125         Name += "," + llvm::join(Error.EnabledDiagnosticAliases, ",");
 126       if (Error.IsWarningAsError) {
 127         Name += ",-warnings-as-errors";
 128         Level = DiagnosticsEngine::Error;
 129         WarningsAsErrors++;
 130       }
 131       auto Diag = Diags.Report(Loc, Diags.getCustomDiagID(Level, "%0 [%1]"))
 132                   << Message.Message << Name;
 133       for (const FileByteRange &FBR : Error.Message.Ranges)
 134         Diag << getRange(FBR);
 135       // FIXME: explore options to support interactive fix selection.
 136       const llvm::StringMap<Replacements> *ChosenFix = nullptr;
 137       if (ApplyFixes != FB_NoFix &&
 138           (ChosenFix = getFixIt(Error, ApplyFixes == FB_FixNotes))) {
 139         for (const auto &FileAndReplacements : *ChosenFix) {
 140           for (const auto &Repl : FileAndReplacements.second) {
 141             ++TotalFixes;
 142             bool CanBeApplied = false;
 143             if (!Repl.isApplicable())
 144               continue;
 145             SourceLocation FixLoc;
 146             SmallString<128> FixAbsoluteFilePath = Repl.getFilePath();
 147             Files.makeAbsolutePath(FixAbsoluteFilePath);
 148             tooling::Replacement R(FixAbsoluteFilePath, Repl.getOffset(),
 149                                    Repl.getLength(), Repl.getReplacementText());
 150             auto &Entry = FileReplacements[R.getFilePath()];
 151             Replacements &Replacements = Entry.Replaces;
 152             llvm::Error Err = Replacements.add(R);
 153             if (Err) {
 154               // FIXME: Implement better conflict handling.
 155               llvm::errs() << "Trying to resolve conflict: "
 156                            << llvm::toString(std::move(Err)) << "\n";
 157               unsigned NewOffset =
 158                   Replacements.getShiftedCodePosition(R.getOffset());
 159               unsigned NewLength = Replacements.getShiftedCodePosition(
 160                                        R.getOffset() + R.getLength()) -
 161                                    NewOffset;
 162               if (NewLength == R.getLength()) {
 163                 R = Replacement(R.getFilePath(), NewOffset, NewLength,
 164                                 R.getReplacementText());
 165                 Replacements = Replacements.merge(tooling::Replacements(R));
 166                 CanBeApplied = true;
 167                 ++AppliedFixes;
 168               } else {
 169                 llvm::errs()
 170                     << "Can't resolve conflict, skipping the replacement.\n";
 171               }
 172             } else {
 173               CanBeApplied = true;
 174               ++AppliedFixes;
 175             }
 176             FixLoc = getLocation(FixAbsoluteFilePath, Repl.getOffset());
 177             FixLocations.push_back(std::make_pair(FixLoc, CanBeApplied));
 178             Entry.BuildDir = Error.BuildDirectory;
 179           }
 180         }
 181       }
 182       reportFix(Diag, Error.Message.Fix);
 183     }
 184     for (auto Fix : FixLocations) {
 185       Diags.Report(Fix.first, Fix.second ? diag::note_fixit_applied
 186                                          : diag::note_fixit_failed);
 187     }
 188     for (const auto &Note : Error.Notes)
 189       reportNote(Note);
 190   }
 191
 192   void finish() {
 193     if (TotalFixes > 0) {
 194       auto &VFS = Files.getVirtualFileSystem();
 195       auto OriginalCWD = VFS.getCurrentWorkingDirectory();
 196       bool AnyNotWritten = false;
 197
 198       for (const auto &FileAndReplacements : FileReplacements) {
 199         Rewriter Rewrite(SourceMgr, LangOpts);
 200         StringRef File = FileAndReplacements.first();
 201         VFS.setCurrentWorkingDirectory(FileAndReplacements.second.BuildDir);
 202         llvm::ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
 203             SourceMgr.getFileManager().getBufferForFile(File);
 204         if (!Buffer) {
 205           llvm::errs() << "Can't get buffer for file " << File << ": "
 206                        << Buffer.getError().message() << "\n";
 207           // FIXME: Maybe don't apply fixes for other files as well.
 208           continue;
 209         }
 210         StringRef Code = Buffer.get()->getBuffer();
 211         auto Style = format::getStyle(
 212             *Context.getOptionsForFile(File).FormatStyle, File, "none");
 213         if (!Style) {
 214           llvm::errs() << llvm::toString(Style.takeError()) << "\n";
 215           continue;
 216         }
 217         llvm::Expected<tooling::Replacements> Replacements =
 218             format::cleanupAroundReplacements(
 219                 Code, FileAndReplacements.second.Replaces, *Style);
 220         if (!Replacements) {
 221           llvm::errs() << llvm::toString(Replacements.takeError()) << "\n";
 222           continue;
 223         }
 224         if (llvm::Expected<tooling::Replacements> FormattedReplacements =
 225                 format::formatReplacements(Code, *Replacements, *Style)) {
 226           Replacements = std::move(FormattedReplacements);
 227           if (!Replacements)
 228             llvm_unreachable("!Replacements");
 229         } else {
 230           llvm::errs() << llvm::toString(FormattedReplacements.takeError())
 231                        << ". Skipping formatting.\n";
 232         }
 233         if (!tooling::applyAllReplacements(Replacements.get(), Rewrite)) {
 234           llvm::errs() << "Can't apply replacements for file " << File << "\n";
 235         }
 236         AnyNotWritten |= Rewrite.overwriteChangedFiles();
 237       }
 238
 239       if (AnyNotWritten) {
 240         llvm::errs() << "clang-tidy failed to apply suggested fixes.\n";
 241       } else {
 242         llvm::errs() << "clang-tidy applied " << AppliedFixes << " of "
 243                      << TotalFixes << " suggested fixes.\n";
 244       }
 245
 246       if (OriginalCWD)
 247         VFS.setCurrentWorkingDirectory(*OriginalCWD);
 248     }
 249   }
 250
 251   unsigned getWarningsAsErrorsCount() const { return WarningsAsErrors; }
 252
 253 private:
 254   SourceLocation getLocation(StringRef FilePath, unsigned Offset) {
 255     if (FilePath.empty())
 256       return {};
 257
 258     auto File = SourceMgr.getFileManager().getOptionalFileRef(FilePath);
 259     if (!File)
 260       return {};
 261
 262     FileID ID = SourceMgr.getOrCreateFileID(*File, SrcMgr::C_User);
 263     return SourceMgr.getLocForStartOfFile(ID).getLocWithOffset(Offset);
 264   }
 265
 266   void reportFix(const DiagnosticBuilder &Diag,
 267                  const llvm::StringMap<Replacements> &Fix) {
 268     for (const auto &FileAndReplacements : Fix) {
 269       for (const auto &Repl : FileAndReplacements.second) {
 270         if (!Repl.isApplicable())
 271           continue;
 272         FileByteRange FBR;
 273         FBR.FilePath = Repl.getFilePath().str();
 274         FBR.FileOffset = Repl.getOffset();
 275         FBR.Length = Repl.getLength();
 276
 277         Diag << FixItHint::CreateReplacement(getRange(FBR),
 278                                              Repl.getReplacementText());
 279       }
 280     }
 281   }
 282
 283   void reportNote(const tooling::DiagnosticMessage &Message) {
 284     SourceLocation Loc = getLocation(Message.FilePath, Message.FileOffset);
 285     auto Diag =
 286         Diags.Report(Loc, Diags.getCustomDiagID(DiagnosticsEngine::Note, "%0"))
 287         << Message.Message;
 288     for (const FileByteRange &FBR : Message.Ranges)
 289       Diag << getRange(FBR);
 290     reportFix(Diag, Message.Fix);
 291   }
 292
 293   CharSourceRange getRange(const FileByteRange &Range) {
 294     SmallString<128> AbsoluteFilePath{Range.FilePath};
 295     Files.makeAbsolutePath(AbsoluteFilePath);
 296     SourceLocation BeginLoc = getLocation(AbsoluteFilePath, Range.FileOffset);
 297     SourceLocation EndLoc = BeginLoc.getLocWithOffset(Range.Length);
 298     // Retrieve the source range for applicable highlights and fixes. Macro
 299     // definition on the command line have locations in a virtual buffer and
 300     // don't have valid file paths and are therefore not applicable.
 301     return CharSourceRange::getCharRange(BeginLoc, EndLoc);
 302   }
 303
 304   struct ReplacementsWithBuildDir {
 305     StringRef BuildDir;
 306     Replacements Replaces;
 307   };
 308
 309   FileManager Files;
 310   LangOptions LangOpts; // FIXME: use langopts from each original file
 311   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
 312   DiagnosticConsumer *DiagPrinter;
 313   DiagnosticsEngine Diags;
 314   SourceManager SourceMgr;
 315   llvm::StringMap<ReplacementsWithBuildDir> FileReplacements;
 316   ClangTidyContext &Context;
 317   FixBehaviour ApplyFixes;
 318   unsigned TotalFixes = 0U;
 319   unsigned AppliedFixes = 0U;
 320   unsigned WarningsAsErrors = 0U;
 321 };
 322
 323 class ClangTidyASTConsumer : public MultiplexConsumer {
 324 public:
 325   ClangTidyASTConsumer(std::vector<std::unique_ptr<ASTConsumer>> Consumers,
 326                        std::unique_ptr<ClangTidyProfiling> Profiling,
 327                        std::unique_ptr<ast_matchers::MatchFinder> Finder,
 328                        std::vector<std::unique_ptr<ClangTidyCheck>> Checks)
 329       : MultiplexConsumer(std::move(Consumers)),
 330         Profiling(std::move(Profiling)), Finder(std::move(Finder)),
 331         Checks(std::move(Checks)) {}
 332
 333 private:
 334   // Destructor order matters! Profiling must be destructed last.
 335   // Or at least after Finder.
 336   std::unique_ptr<ClangTidyProfiling> Profiling;
 337   std::unique_ptr<ast_matchers::MatchFinder> Finder;
 338   std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
 339   void anchor() override {};
 340 };
 341
 342 } // namespace
 343
 344 ClangTidyASTConsumerFactory::ClangTidyASTConsumerFactory(
 345     ClangTidyContext &Context,
 346     IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFS)
 347     : Context(Context), OverlayFS(std::move(OverlayFS)),
 348       CheckFactories(new ClangTidyCheckFactories) {
 349   for (ClangTidyModuleRegistry::entry E : ClangTidyModuleRegistry::entries()) {
 350     std::unique_ptr<ClangTidyModule> Module = E.instantiate();
 351     Module->addCheckFactories(*CheckFactories);
 352   }
 353 }
 354
 355 #if CLANG_TIDY_ENABLE_STATIC_ANALYZER
 356 static void
 357 setStaticAnalyzerCheckerOpts(const ClangTidyOptions &Opts,
 358                              clang::AnalyzerOptions &AnalyzerOptions) {
 359   StringRef AnalyzerPrefix(AnalyzerCheckNamePrefix);
 360   for (const auto &Opt : Opts.CheckOptions) {
 361     StringRef OptName(Opt.getKey());
 362     if (!OptName.consume_front(AnalyzerPrefix))
 363       continue;
 364     // Analyzer options are always local options so we can ignore priority.
 365     AnalyzerOptions.Config[OptName] = Opt.getValue().Value;
 366   }
 367 }
 368
 369 using CheckersList = std::vector<std::pair<std::string, bool>>;
 370
 371 static CheckersList getAnalyzerCheckersAndPackages(ClangTidyContext &Context,
 372                                                    bool IncludeExperimental) {
 373   CheckersList List;
 374
 375   const auto &RegisteredCheckers =
 376       AnalyzerOptions::getRegisteredCheckers(IncludeExperimental);
 377   const bool AnalyzerChecksEnabled =
 378       llvm::any_of(RegisteredCheckers, [&](StringRef CheckName) -> bool {
 379         return Context.isCheckEnabled(
 380             (AnalyzerCheckNamePrefix + CheckName).str());
 381       });
 382
 383   if (!AnalyzerChecksEnabled)
 384     return List;
 385
 386   // List all static analyzer checkers that our filter enables.
 387   //
 388   // Always add all core checkers if any other static analyzer check is enabled.
 389   // This is currently necessary, as other path sensitive checks rely on the
 390   // core checkers.
 391   for (StringRef CheckName : RegisteredCheckers) {
 392     std::string ClangTidyCheckName((AnalyzerCheckNamePrefix + CheckName).str());
 393
 394     if (CheckName.starts_with("core") ||
 395         Context.isCheckEnabled(ClangTidyCheckName)) {
 396       List.emplace_back(std::string(CheckName), true);
 397     }
 398   }
 399   return List;
 400 }
 401 #endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
 402
 403 std::unique_ptr<clang::ASTConsumer>
 404 ClangTidyASTConsumerFactory::createASTConsumer(
 405     clang::CompilerInstance &Compiler, StringRef File) {
 406   // FIXME: Move this to a separate method, so that CreateASTConsumer doesn't
 407   // modify Compiler.
 408   SourceManager *SM = &Compiler.getSourceManager();
 409   Context.setSourceManager(SM);
 410   Context.setCurrentFile(File);
 411   Context.setASTContext(&Compiler.getASTContext());
 412
 413   auto WorkingDir = Compiler.getSourceManager()
 414                         .getFileManager()
 415                         .getVirtualFileSystem()
 416                         .getCurrentWorkingDirectory();
 417   if (WorkingDir)
 418     Context.setCurrentBuildDirectory(WorkingDir.get());
 419
 420   std::vector<std::unique_ptr<ClangTidyCheck>> Checks =
 421       CheckFactories->createChecksForLanguage(&Context);
 422
 423   ast_matchers::MatchFinder::MatchFinderOptions FinderOptions;
 424
 425   std::unique_ptr<ClangTidyProfiling> Profiling;
 426   if (Context.getEnableProfiling()) {
 427     Profiling = std::make_unique<ClangTidyProfiling>(
 428         Context.getProfileStorageParams());
 429     FinderOptions.CheckProfiling.emplace(Profiling->Records);
 430   }
 431
 432   std::unique_ptr<ast_matchers::MatchFinder> Finder(
 433       new ast_matchers::MatchFinder(std::move(FinderOptions)));
 434
 435   Preprocessor *PP = &Compiler.getPreprocessor();
 436   Preprocessor *ModuleExpanderPP = PP;
 437
 438   if (Context.canEnableModuleHeadersParsing() &&
 439       Context.getLangOpts().Modules && OverlayFS != nullptr) {
 440     auto ModuleExpander = std::make_unique<ExpandModularHeadersPPCallbacks>(
 441         &Compiler, OverlayFS);
 442     ModuleExpanderPP = ModuleExpander->getPreprocessor();
 443     PP->addPPCallbacks(std::move(ModuleExpander));
 444   }
 445
 446   for (auto &Check : Checks) {
 447     Check->registerMatchers(&*Finder);
 448     Check->registerPPCallbacks(*SM, PP, ModuleExpanderPP);
 449   }
 450
 451   std::vector<std::unique_ptr<ASTConsumer>> Consumers;
 452   if (!Checks.empty())
 453     Consumers.push_back(Finder->newASTConsumer());
 454
 455 #if CLANG_TIDY_ENABLE_STATIC_ANALYZER
 456   AnalyzerOptions &AnalyzerOptions = Compiler.getAnalyzerOpts();
 457   AnalyzerOptions.CheckersAndPackages = getAnalyzerCheckersAndPackages(
 458       Context, Context.canEnableAnalyzerAlphaCheckers());
 459   if (!AnalyzerOptions.CheckersAndPackages.empty()) {
 460     setStaticAnalyzerCheckerOpts(Context.getOptions(), AnalyzerOptions);
 461     AnalyzerOptions.AnalysisDiagOpt = PD_NONE;
 462     std::unique_ptr<ento::AnalysisASTConsumer> AnalysisConsumer =
 463         ento::CreateAnalysisConsumer(Compiler);
 464     AnalysisConsumer->AddDiagnosticConsumer(
 465         new AnalyzerDiagnosticConsumer(Context));
 466     Consumers.push_back(std::move(AnalysisConsumer));
 467   }
 468 #endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
 469   return std::make_unique<ClangTidyASTConsumer>(
 470       std::move(Consumers), std::move(Profiling), std::move(Finder),
 471       std::move(Checks));
 472 }
 473
 474 std::vector<std::string> ClangTidyASTConsumerFactory::getCheckNames() {
 475   std::vector<std::string> CheckNames;
 476   for (const auto &CheckFactory : *CheckFactories) {
 477     if (Context.isCheckEnabled(CheckFactory.getKey()))
 478       CheckNames.emplace_back(CheckFactory.getKey());
 479   }
 480
 481 #if CLANG_TIDY_ENABLE_STATIC_ANALYZER
 482   for (const auto &AnalyzerCheck : getAnalyzerCheckersAndPackages(
 483            Context, Context.canEnableAnalyzerAlphaCheckers()))
 484     CheckNames.push_back(AnalyzerCheckNamePrefix + AnalyzerCheck.first);
 485 #endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
 486
 487   llvm::sort(CheckNames);
 488   return CheckNames;
 489 }
 490
 491 ClangTidyOptions::OptionMap ClangTidyASTConsumerFactory::getCheckOptions() {
 492   ClangTidyOptions::OptionMap Options;
 493   std::vector<std::unique_ptr<ClangTidyCheck>> Checks =
 494       CheckFactories->createChecks(&Context);
 495   for (const auto &Check : Checks)
 496     Check->storeOptions(Options);
 497   return Options;
 498 }
 499
 500 std::vector<std::string>
 501 getCheckNames(const ClangTidyOptions &Options,
 502               bool AllowEnablingAnalyzerAlphaCheckers) {
 503   clang::tidy::ClangTidyContext Context(
 504       std::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
 505                                                 Options),
 506       AllowEnablingAnalyzerAlphaCheckers);
 507   ClangTidyASTConsumerFactory Factory(Context);
 508   return Factory.getCheckNames();
 509 }
 510
 511 ClangTidyOptions::OptionMap
 512 getCheckOptions(const ClangTidyOptions &Options,
 513                 bool AllowEnablingAnalyzerAlphaCheckers) {
 514   clang::tidy::ClangTidyContext Context(
 515       std::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
 516                                                 Options),
 517       AllowEnablingAnalyzerAlphaCheckers);
 518   ClangTidyDiagnosticConsumer DiagConsumer(Context);
 519   DiagnosticsEngine DE(llvm::makeIntrusiveRefCnt<DiagnosticIDs>(),
 520                        llvm::makeIntrusiveRefCnt<DiagnosticOptions>(),
 521                        &DiagConsumer, /*ShouldOwnClient=*/false);
 522   Context.setDiagnosticsEngine(&DE);
 523   ClangTidyASTConsumerFactory Factory(Context);
 524   return Factory.getCheckOptions();
 525 }
 526
 527 std::vector<ClangTidyError>
 528 runClangTidy(clang::tidy::ClangTidyContext &Context,
 529              const CompilationDatabase &Compilations,
 530              ArrayRef<std::string> InputFiles,
 531              llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> BaseFS,
 532              bool ApplyAnyFix, bool EnableCheckProfile,
 533              llvm::StringRef StoreCheckProfile) {
 534   ClangTool Tool(Compilations, InputFiles,
 535                  std::make_shared<PCHContainerOperations>(), BaseFS);
 536
 537   // Add extra arguments passed by the clang-tidy command-line.
 538   ArgumentsAdjuster PerFileExtraArgumentsInserter =
 539       [&Context](const CommandLineArguments &Args, StringRef Filename) {
 540         ClangTidyOptions Opts = Context.getOptionsForFile(Filename);
 541         CommandLineArguments AdjustedArgs = Args;
 542         if (Opts.ExtraArgsBefore) {
 543           auto I = AdjustedArgs.begin();
 544           if (I != AdjustedArgs.end() && !StringRef(*I).starts_with("-"))
 545             ++I; // Skip compiler binary name, if it is there.
 546           AdjustedArgs.insert(I, Opts.ExtraArgsBefore->begin(),
 547                               Opts.ExtraArgsBefore->end());
 548         }
 549         if (Opts.ExtraArgs)
 550           AdjustedArgs.insert(AdjustedArgs.end(), Opts.ExtraArgs->begin(),
 551                               Opts.ExtraArgs->end());
 552         return AdjustedArgs;
 553       };
 554
 555   Tool.appendArgumentsAdjuster(PerFileExtraArgumentsInserter);
 556   Tool.appendArgumentsAdjuster(getStripPluginsAdjuster());
 557   Context.setEnableProfiling(EnableCheckProfile);
 558   Context.setProfileStoragePrefix(StoreCheckProfile);
 559
 560   ClangTidyDiagnosticConsumer DiagConsumer(Context, nullptr, true, ApplyAnyFix);
 561   DiagnosticsEngine DE(new DiagnosticIDs(), new DiagnosticOptions(),
 562                        &DiagConsumer, /*ShouldOwnClient=*/false);
 563   Context.setDiagnosticsEngine(&DE);
 564   Tool.setDiagnosticConsumer(&DiagConsumer);
 565
 566   class ActionFactory : public FrontendActionFactory {
 567   public:
 568     ActionFactory(ClangTidyContext &Context,
 569                   IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> BaseFS)
 570         : ConsumerFactory(Context, std::move(BaseFS)) {}
 571     std::unique_ptr<FrontendAction> create() override {
 572       return std::make_unique<Action>(&ConsumerFactory);
 573     }
 574
 575     bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation,
 576                        FileManager *Files,
 577                        std::shared_ptr<PCHContainerOperations> PCHContainerOps,
 578                        DiagnosticConsumer *DiagConsumer) override {
 579       // Explicitly ask to define __clang_analyzer__ macro.
 580       Invocation->getPreprocessorOpts().SetUpStaticAnalyzer = true;
 581       return FrontendActionFactory::runInvocation(
 582           Invocation, Files, PCHContainerOps, DiagConsumer);
 583     }
 584
 585   private:
 586     class Action : public ASTFrontendAction {
 587     public:
 588       Action(ClangTidyASTConsumerFactory *Factory) : Factory(Factory) {}
 589       std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
 590                                                      StringRef File) override {
 591         return Factory->createASTConsumer(Compiler, File);
 592       }
 593
 594     private:
 595       ClangTidyASTConsumerFactory *Factory;
 596     };
 597
 598     ClangTidyASTConsumerFactory ConsumerFactory;
 599   };
 600
 601   ActionFactory Factory(Context, std::move(BaseFS));
 602   Tool.run(&Factory);
 603   return DiagConsumer.take();
 604 }
 605
 606 void handleErrors(llvm::ArrayRef<ClangTidyError> Errors,
 607                   ClangTidyContext &Context, FixBehaviour Fix,
 608                   unsigned &WarningsAsErrorsCount,
 609                   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS) {
 610   ErrorReporter Reporter(Context, Fix, std::move(BaseFS));
 611   llvm::vfs::FileSystem &FileSystem =
 612       Reporter.getSourceManager().getFileManager().getVirtualFileSystem();
 613   auto InitialWorkingDir = FileSystem.getCurrentWorkingDirectory();
 614   if (!InitialWorkingDir)
 615     llvm::report_fatal_error("Cannot get current working path.");
 616
 617   for (const ClangTidyError &Error : Errors) {
 618     if (!Error.BuildDirectory.empty()) {
 619       // By default, the working directory of file system is the current
 620       // clang-tidy running directory.
 621       //
 622       // Change the directory to the one used during the analysis.
 623       FileSystem.setCurrentWorkingDirectory(Error.BuildDirectory);
 624     }
 625     Reporter.reportDiagnostic(Error);
 626     // Return to the initial directory to correctly resolve next Error.
 627     FileSystem.setCurrentWorkingDirectory(InitialWorkingDir.get());
 628   }
 629   Reporter.finish();
 630   WarningsAsErrorsCount += Reporter.getWarningsAsErrorsCount();
 631 }
 632
 633 void exportReplacements(const llvm::StringRef MainFilePath,
 634                         const std::vector<ClangTidyError> &Errors,
 635                         raw_ostream &OS) {
 636   TranslationUnitDiagnostics TUD;
 637   TUD.MainSourceFile = std::string(MainFilePath);
 638   for (const auto &Error : Errors) {
 639     tooling::Diagnostic Diag = Error;
 640     if (Error.IsWarningAsError)
 641       Diag.DiagLevel = tooling::Diagnostic::Error;
 642     TUD.Diagnostics.insert(TUD.Diagnostics.end(), Diag);
 643   }
 644
 645   yaml::Output YAML(OS);
 646   YAML << TUD;
 647 }
 648
 649 NamesAndOptions
 650 getAllChecksAndOptions(bool AllowEnablingAnalyzerAlphaCheckers) {
 651   NamesAndOptions Result;
 652   ClangTidyOptions Opts;
 653   Opts.Checks = "*";
 654   clang::tidy::ClangTidyContext Context(
 655       std::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(), Opts),
 656       AllowEnablingAnalyzerAlphaCheckers);
 657   ClangTidyCheckFactories Factories;
 658   for (const ClangTidyModuleRegistry::entry &Module :
 659        ClangTidyModuleRegistry::entries()) {
 660     Module.instantiate()->addCheckFactories(Factories);
 661   }
 662
 663   for (const auto &Factory : Factories)
 664     Result.Names.insert(Factory.getKey());
 665
 666 #if CLANG_TIDY_ENABLE_STATIC_ANALYZER
 667   SmallString<64> Buffer(AnalyzerCheckNamePrefix);
 668   size_t DefSize = Buffer.size();
 669   for (const auto &AnalyzerCheck : AnalyzerOptions::getRegisteredCheckers(
 670            AllowEnablingAnalyzerAlphaCheckers)) {
 671     Buffer.truncate(DefSize);
 672     Buffer.append(AnalyzerCheck);
 673     Result.Names.insert(Buffer);
 674   }
 675   for (std::string OptionName : {
 676 #define GET_CHECKER_OPTIONS
 677 #define CHECKER_OPTION(TYPE, CHECKER, OPTION_NAME, DESCRIPTION, DEFAULT,       \
 678                        RELEASE, HIDDEN)                                        \
 679   Twine(AnalyzerCheckNamePrefix).concat(CHECKER ":" OPTION_NAME).str(),
 680
 681 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 682 #undef CHECKER_OPTION
 683 #undef GET_CHECKER_OPTIONS
 684        }) {
 685     Result.Options.insert(OptionName);
 686   }
 687 #endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
 688
 689   Context.setOptionsCollector(&Result.Options);
 690   for (const auto &Factory : Factories) {
 691     Factory.getValue()(Factory.getKey(), &Context);
 692   }
 693
 694   return Result;
 695 }
 696 } // namespace clang::tidy