clang-tools-extra/clangd/ParsedAST.cpp

   1 //===--- ParsedAST.cpp -------------------------------------------*- C++-*-===//
   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 #include "ParsedAST.h"
  10 #include "../clang-tidy/ClangTidyCheck.h"
  11 #include "../clang-tidy/ClangTidyDiagnosticConsumer.h"
  12 #include "../clang-tidy/ClangTidyModule.h"
  13 #include "../clang-tidy/ClangTidyModuleRegistry.h"
  14 #include "../clang-tidy/ClangTidyOptions.h"
  15 #include "AST.h"
  16 #include "CollectMacros.h"
  17 #include "Compiler.h"
  18 #include "Config.h"
  19 #include "Diagnostics.h"
  20 #include "Feature.h"
  21 #include "FeatureModule.h"
  22 #include "Headers.h"
  23 #include "HeuristicResolver.h"
  24 #include "IncludeCleaner.h"
  25 #include "IncludeFixer.h"
  26 #include "Preamble.h"
  27 #include "SourceCode.h"
  28 #include "TidyProvider.h"
  29 #include "clang-include-cleaner/Record.h"
  30 #include "index/Symbol.h"
  31 #include "support/Logger.h"
  32 #include "support/Path.h"
  33 #include "support/Trace.h"
  34 #include "clang/AST/ASTContext.h"
  35 #include "clang/AST/Decl.h"
  36 #include "clang/AST/DeclGroup.h"
  37 #include "clang/AST/ExternalASTSource.h"
  38 #include "clang/ASTMatchers/ASTMatchFinder.h"
  39 #include "clang/Basic/Diagnostic.h"
  40 #include "clang/Basic/DiagnosticIDs.h"
  41 #include "clang/Basic/DiagnosticSema.h"
  42 #include "clang/Basic/FileEntry.h"
  43 #include "clang/Basic/LLVM.h"
  44 #include "clang/Basic/LangOptions.h"
  45 #include "clang/Basic/SourceLocation.h"
  46 #include "clang/Basic/SourceManager.h"
  47 #include "clang/Basic/TokenKinds.h"
  48 #include "clang/Frontend/CompilerInstance.h"
  49 #include "clang/Frontend/CompilerInvocation.h"
  50 #include "clang/Frontend/FrontendActions.h"
  51 #include "clang/Frontend/FrontendOptions.h"
  52 #include "clang/Frontend/PrecompiledPreamble.h"
  53 #include "clang/Lex/Lexer.h"
  54 #include "clang/Lex/PPCallbacks.h"
  55 #include "clang/Lex/Preprocessor.h"
  56 #include "clang/Serialization/ASTWriter.h"
  57 #include "clang/Tooling/CompilationDatabase.h"
  58 #include "clang/Tooling/Core/Diagnostic.h"
  59 #include "clang/Tooling/Syntax/Tokens.h"
  60 #include "llvm/ADT/ArrayRef.h"
  61 #include "llvm/ADT/DenseMap.h"
  62 #include "llvm/ADT/DenseSet.h"
  63 #include "llvm/ADT/STLExtras.h"
  64 #include "llvm/ADT/STLFunctionalExtras.h"
  65 #include "llvm/ADT/SmallVector.h"
  66 #include "llvm/ADT/StringRef.h"
  67 #include "llvm/Support/Error.h"
  68 #include "llvm/Support/MemoryBuffer.h"
  69 #include <cassert>
  70 #include <cstddef>
  71 #include <iterator>
  72 #include <memory>
  73 #include <optional>
  74 #include <string>
  75 #include <tuple>
  76 #include <utility>
  77 #include <vector>
  78
  79 // Force the linker to link in Clang-tidy modules.
  80 // clangd doesn't support the static analyzer.
  81 #if CLANGD_TIDY_CHECKS
  82 #define CLANG_TIDY_DISABLE_STATIC_ANALYZER_CHECKS
  83 #include "../clang-tidy/ClangTidyForceLinker.h"
  84 #endif
  85
  86 namespace clang {
  87 namespace clangd {
  88 namespace {
  89
  90 template <class T> std::size_t getUsedBytes(const std::vector<T> &Vec) {
  91   return Vec.capacity() * sizeof(T);
  92 }
  93
  94 class DeclTrackingASTConsumer : public ASTConsumer {
  95 public:
  96   DeclTrackingASTConsumer(std::vector<Decl *> &TopLevelDecls)
  97       : TopLevelDecls(TopLevelDecls) {}
  98
  99   bool HandleTopLevelDecl(DeclGroupRef DG) override {
 100     for (Decl *D : DG) {
 101       auto &SM = D->getASTContext().getSourceManager();
 102       if (!isInsideMainFile(D->getLocation(), SM))
 103         continue;
 104       if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
 105         if (isImplicitTemplateInstantiation(ND))
 106           continue;
 107
 108       // ObjCMethodDecl are not actually top-level decls.
 109       if (isa<ObjCMethodDecl>(D))
 110         continue;
 111
 112       TopLevelDecls.push_back(D);
 113     }
 114     return true;
 115   }
 116
 117 private:
 118   std::vector<Decl *> &TopLevelDecls;
 119 };
 120
 121 class ClangdFrontendAction : public SyntaxOnlyAction {
 122 public:
 123   std::vector<Decl *> takeTopLevelDecls() { return std::move(TopLevelDecls); }
 124
 125 protected:
 126   std::unique_ptr<ASTConsumer>
 127   CreateASTConsumer(CompilerInstance &CI, llvm::StringRef InFile) override {
 128     return std::make_unique<DeclTrackingASTConsumer>(/*ref*/ TopLevelDecls);
 129   }
 130
 131 private:
 132   std::vector<Decl *> TopLevelDecls;
 133 };
 134
 135 // When using a preamble, only preprocessor events outside its bounds are seen.
 136 // This is almost what we want: replaying transitive preprocessing wastes time.
 137 // However this confuses clang-tidy checks: they don't see any #includes!
 138 // So we replay the *non-transitive* #includes that appear in the main-file.
 139 // It would be nice to replay other events (macro definitions, ifdefs etc) but
 140 // this addresses the most common cases fairly cheaply.
 141 class ReplayPreamble : private PPCallbacks {
 142 public:
 143   // Attach preprocessor hooks such that preamble events will be injected at
 144   // the appropriate time.
 145   // Events will be delivered to the *currently registered* PP callbacks.
 146   static void attach(std::vector<Inclusion> Includes, CompilerInstance &Clang,
 147                      const PreambleBounds &PB) {
 148     auto &PP = Clang.getPreprocessor();
 149     auto *ExistingCallbacks = PP.getPPCallbacks();
 150     // No need to replay events if nobody is listening.
 151     if (!ExistingCallbacks)
 152       return;
 153     PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(new ReplayPreamble(
 154         std::move(Includes), ExistingCallbacks, Clang.getSourceManager(), PP,
 155         Clang.getLangOpts(), PB)));
 156     // We're relying on the fact that addPPCallbacks keeps the old PPCallbacks
 157     // around, creating a chaining wrapper. Guard against other implementations.
 158     assert(PP.getPPCallbacks() != ExistingCallbacks &&
 159            "Expected chaining implementation");
 160   }
 161
 162 private:
 163   ReplayPreamble(std::vector<Inclusion> Includes, PPCallbacks *Delegate,
 164                  const SourceManager &SM, Preprocessor &PP,
 165                  const LangOptions &LangOpts, const PreambleBounds &PB)
 166       : Includes(std::move(Includes)), Delegate(Delegate), SM(SM), PP(PP) {
 167     // Only tokenize the preamble section of the main file, as we are not
 168     // interested in the rest of the tokens.
 169     MainFileTokens = syntax::tokenize(
 170         syntax::FileRange(SM.getMainFileID(), 0, PB.Size), SM, LangOpts);
 171   }
 172
 173   // In a normal compile, the preamble traverses the following structure:
 174   //
 175   // mainfile.cpp
 176   //   <built-in>
 177   //     ... macro definitions like __cplusplus ...
 178   //     <command-line>
 179   //       ... macro definitions for args like -Dfoo=bar ...
 180   //   "header1.h"
 181   //     ... header file contents ...
 182   //   "header2.h"
 183   //     ... header file contents ...
 184   //   ... main file contents ...
 185   //
 186   // When using a preamble, the "header1" and "header2" subtrees get skipped.
 187   // We insert them right after the built-in header, which still appears.
 188   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
 189                    SrcMgr::CharacteristicKind Kind, FileID PrevFID) override {
 190     // It'd be nice if there was a better way to identify built-in headers...
 191     if (Reason == FileChangeReason::ExitFile &&
 192         SM.getBufferOrFake(PrevFID).getBufferIdentifier() == "<built-in>")
 193       replay();
 194   }
 195
 196   void replay() {
 197     for (const auto &Inc : Includes) {
 198       OptionalFileEntryRef File;
 199       if (Inc.Resolved != "")
 200         File = expectedToOptional(SM.getFileManager().getFileRef(Inc.Resolved));
 201
 202       // Re-lex the #include directive to find its interesting parts.
 203       auto HashLoc = SM.getComposedLoc(SM.getMainFileID(), Inc.HashOffset);
 204       auto HashTok = llvm::partition_point(MainFileTokens,
 205                                            [&HashLoc](const syntax::Token &T) {
 206                                              return T.location() < HashLoc;
 207                                            });
 208       assert(HashTok != MainFileTokens.end() && HashTok->kind() == tok::hash);
 209
 210       auto IncludeTok = std::next(HashTok);
 211       assert(IncludeTok != MainFileTokens.end());
 212
 213       auto FileTok = std::next(IncludeTok);
 214       assert(FileTok != MainFileTokens.end());
 215
 216       // Create a fake import/include token, none of the callers seem to care
 217       // about clang::Token::Flags.
 218       Token SynthesizedIncludeTok;
 219       SynthesizedIncludeTok.startToken();
 220       SynthesizedIncludeTok.setLocation(IncludeTok->location());
 221       SynthesizedIncludeTok.setLength(IncludeTok->length());
 222       SynthesizedIncludeTok.setKind(tok::raw_identifier);
 223       SynthesizedIncludeTok.setRawIdentifierData(IncludeTok->text(SM).data());
 224       PP.LookUpIdentifierInfo(SynthesizedIncludeTok);
 225
 226       // Same here, create a fake one for Filename, including angles or quotes.
 227       Token SynthesizedFilenameTok;
 228       SynthesizedFilenameTok.startToken();
 229       SynthesizedFilenameTok.setLocation(FileTok->location());
 230       // Note that we can't make use of FileTok->length/text in here as in the
 231       // case of angled includes this will contain tok::less instead of
 232       // filename. Whereas Inc.Written contains the full header name including
 233       // quotes/angles.
 234       SynthesizedFilenameTok.setLength(Inc.Written.length());
 235       SynthesizedFilenameTok.setKind(tok::header_name);
 236       SynthesizedFilenameTok.setLiteralData(Inc.Written.data());
 237
 238       llvm::StringRef WrittenFilename =
 239           llvm::StringRef(Inc.Written).drop_front().drop_back();
 240       Delegate->InclusionDirective(
 241           HashTok->location(), SynthesizedIncludeTok, WrittenFilename,
 242           Inc.Written.front() == '<',
 243           syntax::FileRange(SM, SynthesizedFilenameTok.getLocation(),
 244                             SynthesizedFilenameTok.getEndLoc())
 245               .toCharRange(SM),
 246           File, "SearchPath", "RelPath",
 247           /*SuggestedModule=*/nullptr, /*ModuleImported=*/false, Inc.FileKind);
 248       if (File)
 249         Delegate->FileSkipped(*File, SynthesizedFilenameTok, Inc.FileKind);
 250     }
 251   }
 252
 253   const std::vector<Inclusion> Includes;
 254   PPCallbacks *Delegate;
 255   const SourceManager &SM;
 256   Preprocessor &PP;
 257   std::vector<syntax::Token> MainFileTokens;
 258 };
 259
 260 // Filter for clang diagnostics groups enabled by CTOptions.Checks.
 261 //
 262 // These are check names like clang-diagnostics-unused.
 263 // Note that unlike -Wunused, clang-diagnostics-unused does not imply
 264 // subcategories like clang-diagnostics-unused-function.
 265 //
 266 // This is used to determine which diagnostics can be enabled by ExtraArgs in
 267 // the clang-tidy configuration.
 268 class TidyDiagnosticGroups {
 269   // Whether all diagnostic groups are enabled by default.
 270   // True if we've seen clang-diagnostic-*.
 271   bool Default = false;
 272   // Set of diag::Group whose enablement != Default.
 273   // If Default is false, this is foo where we've seen clang-diagnostic-foo.
 274   llvm::DenseSet<unsigned> Exceptions;
 275
 276 public:
 277   TidyDiagnosticGroups(llvm::StringRef Checks) {
 278     constexpr llvm::StringLiteral CDPrefix = "clang-diagnostic-";
 279
 280     llvm::StringRef Check;
 281     while (!Checks.empty()) {
 282       std::tie(Check, Checks) = Checks.split(',');
 283       if (Check.empty())
 284         continue;
 285
 286       bool Enable = !Check.consume_front("-");
 287       bool Glob = Check.consume_back("*");
 288       if (Glob) {
 289         // Is this clang-diagnostic-*, or *, or so?
 290         // (We ignore all other types of globs).
 291         if (CDPrefix.starts_with(Check)) {
 292           Default = Enable;
 293           Exceptions.clear();
 294         }
 295         continue;
 296       }
 297
 298       // In "*,clang-diagnostic-foo", the latter is a no-op.
 299       if (Default == Enable)
 300         continue;
 301       // The only non-glob entries we care about are clang-diagnostic-foo.
 302       if (!Check.consume_front(CDPrefix))
 303         continue;
 304
 305       if (auto Group = DiagnosticIDs::getGroupForWarningOption(Check))
 306         Exceptions.insert(static_cast<unsigned>(*Group));
 307     }
 308   }
 309
 310   bool operator()(diag::Group GroupID) const {
 311     return Exceptions.contains(static_cast<unsigned>(GroupID)) ? !Default
 312                                                                : Default;
 313   }
 314 };
 315
 316 // Find -W<group> and -Wno-<group> options in ExtraArgs and apply them to Diags.
 317 //
 318 // This is used to handle ExtraArgs in clang-tidy configuration.
 319 // We don't use clang's standard handling of this as we want slightly different
 320 // behavior (e.g. we want to exclude these from -Wno-error).
 321 void applyWarningOptions(llvm::ArrayRef<std::string> ExtraArgs,
 322                          llvm::function_ref<bool(diag::Group)> EnabledGroups,
 323                          DiagnosticsEngine &Diags) {
 324   for (llvm::StringRef Group : ExtraArgs) {
 325     // Only handle args that are of the form -W[no-]<group>.
 326     // Other flags are possible but rare and deliberately out of scope.
 327     llvm::SmallVector<diag::kind> Members;
 328     if (!Group.consume_front("-W") || Group.empty())
 329       continue;
 330     bool Enable = !Group.consume_front("no-");
 331     if (Diags.getDiagnosticIDs()->getDiagnosticsInGroup(
 332             diag::Flavor::WarningOrError, Group, Members))
 333       continue;
 334
 335     // Upgrade (or downgrade) the severity of each diagnostic in the group.
 336     // If -Werror is on, newly added warnings will be treated as errors.
 337     // We don't want this, so keep track of them to fix afterwards.
 338     bool NeedsWerrorExclusion = false;
 339     for (diag::kind ID : Members) {
 340       if (Enable) {
 341         if (Diags.getDiagnosticLevel(ID, SourceLocation()) <
 342             DiagnosticsEngine::Warning) {
 343           auto Group = DiagnosticIDs::getGroupForDiag(ID);
 344           if (!Group || !EnabledGroups(*Group))
 345             continue;
 346           Diags.setSeverity(ID, diag::Severity::Warning, SourceLocation());
 347           if (Diags.getWarningsAsErrors())
 348             NeedsWerrorExclusion = true;
 349         }
 350       } else {
 351         Diags.setSeverity(ID, diag::Severity::Ignored, SourceLocation());
 352       }
 353     }
 354     if (NeedsWerrorExclusion) {
 355       // FIXME: there's no API to suppress -Werror for single diagnostics.
 356       // In some cases with sub-groups, we may end up erroneously
 357       // downgrading diagnostics that were -Werror in the compile command.
 358       Diags.setDiagnosticGroupWarningAsError(Group, false);
 359     }
 360   }
 361 }
 362
 363 std::vector<Diag> getIncludeCleanerDiags(ParsedAST &AST, llvm::StringRef Code,
 364                                          const ThreadsafeFS &TFS) {
 365   auto &Cfg = Config::current();
 366   if (Cfg.Diagnostics.SuppressAll)
 367     return {};
 368   bool SuppressMissing =
 369       Cfg.Diagnostics.Suppress.contains("missing-includes") ||
 370       Cfg.Diagnostics.MissingIncludes == Config::IncludesPolicy::None;
 371   bool SuppressUnused =
 372       Cfg.Diagnostics.Suppress.contains("unused-includes") ||
 373       Cfg.Diagnostics.UnusedIncludes == Config::IncludesPolicy::None;
 374   if (SuppressMissing && SuppressUnused)
 375     return {};
 376   auto Findings = computeIncludeCleanerFindings(
 377       AST, Cfg.Diagnostics.Includes.AnalyzeAngledIncludes);
 378   if (SuppressMissing)
 379     Findings.MissingIncludes.clear();
 380   if (SuppressUnused)
 381     Findings.UnusedIncludes.clear();
 382   return issueIncludeCleanerDiagnostics(AST, Code, Findings, TFS,
 383                                         Cfg.Diagnostics.Includes.IgnoreHeader);
 384 }
 385
 386 tidy::ClangTidyCheckFactories
 387 filterFastTidyChecks(const tidy::ClangTidyCheckFactories &All,
 388                      Config::FastCheckPolicy Policy) {
 389   if (Policy == Config::FastCheckPolicy::None)
 390     return All;
 391   bool AllowUnknown = Policy == Config::FastCheckPolicy::Loose;
 392   tidy::ClangTidyCheckFactories Fast;
 393   for (const auto &Factory : All) {
 394     if (isFastTidyCheck(Factory.getKey()).value_or(AllowUnknown))
 395       Fast.registerCheckFactory(Factory.first(), Factory.second);
 396   }
 397   return Fast;
 398 }
 399
 400 } // namespace
 401
 402 std::optional<ParsedAST>
 403 ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
 404                  std::unique_ptr<clang::CompilerInvocation> CI,
 405                  llvm::ArrayRef<Diag> CompilerInvocationDiags,
 406                  std::shared_ptr<const PreambleData> Preamble) {
 407   trace::Span Tracer("BuildAST");
 408   SPAN_ATTACH(Tracer, "File", Filename);
 409   const Config &Cfg = Config::current();
 410
 411   auto VFS = Inputs.TFS->view(Inputs.CompileCommand.Directory);
 412   if (Preamble && Preamble->StatCache)
 413     VFS = Preamble->StatCache->getConsumingFS(std::move(VFS));
 414
 415   assert(CI);
 416
 417   if (CI->getFrontendOpts().Inputs.size() > 0) {
 418     auto Lang = CI->getFrontendOpts().Inputs[0].getKind().getLanguage();
 419     if (Lang == Language::Asm || Lang == Language::LLVM_IR) {
 420       elog("Clangd does not support assembly or IR source files");
 421       return std::nullopt;
 422     }
 423   }
 424
 425   // Command-line parsing sets DisableFree to true by default, but we don't want
 426   // to leak memory in clangd.
 427   CI->getFrontendOpts().DisableFree = false;
 428   const PrecompiledPreamble *PreamblePCH =
 429       Preamble ? &Preamble->Preamble : nullptr;
 430
 431   // This is on-by-default in windows to allow parsing SDK headers, but it
 432   // breaks many features. Disable it for the main-file (not preamble).
 433   CI->getLangOpts().DelayedTemplateParsing = false;
 434
 435   std::vector<std::unique_ptr<FeatureModule::ASTListener>> ASTListeners;
 436   if (Inputs.FeatureModules) {
 437     for (auto &M : *Inputs.FeatureModules) {
 438       if (auto Listener = M.astListeners())
 439         ASTListeners.emplace_back(std::move(Listener));
 440     }
 441   }
 442   StoreDiags ASTDiags;
 443   ASTDiags.setDiagCallback(
 444       [&ASTListeners](const clang::Diagnostic &D, clangd::Diag &Diag) {
 445         for (const auto &L : ASTListeners)
 446           L->sawDiagnostic(D, Diag);
 447       });
 448
 449   // Adjust header search options to load the built module files recorded
 450   // in RequiredModules.
 451   if (Preamble && Preamble->RequiredModules)
 452     Preamble->RequiredModules->adjustHeaderSearchOptions(
 453         CI->getHeaderSearchOpts());
 454
 455   std::optional<PreamblePatch> Patch;
 456   // We might use an ignoring diagnostic consumer if they are going to be
 457   // dropped later on to not pay for extra latency by processing them.
 458   DiagnosticConsumer *DiagConsumer = &ASTDiags;
 459   IgnoreDiagnostics DropDiags;
 460   if (Preamble) {
 461     Patch = PreamblePatch::createFullPatch(Filename, Inputs, *Preamble);
 462     Patch->apply(*CI);
 463   }
 464   auto Clang = prepareCompilerInstance(
 465       std::move(CI), PreamblePCH,
 466       llvm::MemoryBuffer::getMemBufferCopy(Inputs.Contents, Filename), VFS,
 467       *DiagConsumer);
 468
 469   if (!Clang) {
 470     // The last diagnostic contains information about the reason of this
 471     // failure.
 472     std::vector<Diag> Diags(ASTDiags.take());
 473     elog("Failed to prepare a compiler instance: {0}",
 474          !Diags.empty() ? static_cast<DiagBase &>(Diags.back()).Message
 475                         : "unknown error");
 476     return std::nullopt;
 477   }
 478   tidy::ClangTidyOptions ClangTidyOpts;
 479   {
 480     trace::Span Tracer("ClangTidyOpts");
 481     ClangTidyOpts = getTidyOptionsForFile(Inputs.ClangTidyProvider, Filename);
 482     dlog("ClangTidy configuration for file {0}: {1}", Filename,
 483          tidy::configurationAsText(ClangTidyOpts));
 484
 485     // If clang-tidy is configured to emit clang warnings, we should too.
 486     //
 487     // Such clang-tidy configuration consists of two parts:
 488     //   - ExtraArgs: ["-Wfoo"] causes clang to produce the warnings
 489     //   - Checks: "clang-diagnostic-foo" prevents clang-tidy filtering them out
 490     //
 491     // In clang-tidy, diagnostics are emitted if they pass both checks.
 492     // When groups contain subgroups, -Wparent includes the child, but
 493     // clang-diagnostic-parent does not.
 494     //
 495     // We *don't* want to change the compile command directly. This can have
 496     // too many unexpected effects: breaking the command, interactions with
 497     // -- and -Werror, etc. Besides, we've already parsed the command.
 498     // Instead we parse the -W<group> flags and handle them directly.
 499     //
 500     // Similarly, we don't want to use Checks to filter clang diagnostics after
 501     // they are generated, as this spreads clang-tidy emulation everywhere.
 502     // Instead, we just use these to filter which extra diagnostics we enable.
 503     auto &Diags = Clang->getDiagnostics();
 504     TidyDiagnosticGroups TidyGroups(ClangTidyOpts.Checks ? *ClangTidyOpts.Checks
 505                                                          : llvm::StringRef());
 506     if (ClangTidyOpts.ExtraArgsBefore)
 507       applyWarningOptions(*ClangTidyOpts.ExtraArgsBefore, TidyGroups, Diags);
 508     if (ClangTidyOpts.ExtraArgs)
 509       applyWarningOptions(*ClangTidyOpts.ExtraArgs, TidyGroups, Diags);
 510   }
 511
 512   auto Action = std::make_unique<ClangdFrontendAction>();
 513   const FrontendInputFile &MainInput = Clang->getFrontendOpts().Inputs[0];
 514   if (!Action->BeginSourceFile(*Clang, MainInput)) {
 515     log("BeginSourceFile() failed when building AST for {0}",
 516         MainInput.getFile());
 517     return std::nullopt;
 518   }
 519   // If we saw an include guard in the preamble section of the main file,
 520   // mark the main-file as include-guarded.
 521   // This information is part of the HeaderFileInfo but is not loaded from the
 522   // preamble as the file's size is part of its identity and may have changed.
 523   // (The rest of HeaderFileInfo is not relevant for our purposes).
 524   if (Preamble && Preamble->MainIsIncludeGuarded) {
 525     const SourceManager &SM = Clang->getSourceManager();
 526     OptionalFileEntryRef MainFE = SM.getFileEntryRefForID(SM.getMainFileID());
 527     Clang->getPreprocessor().getHeaderSearchInfo().MarkFileIncludeOnce(*MainFE);
 528   }
 529
 530   // Set up ClangTidy. Must happen after BeginSourceFile() so ASTContext exists.
 531   // Clang-tidy has some limitations to ensure reasonable performance:
 532   //  - checks don't see all preprocessor events in the preamble
 533   //  - matchers run only over the main-file top-level decls (and can't see
 534   //    ancestors outside this scope).
 535   // In practice almost all checks work well without modifications.
 536   std::vector<std::unique_ptr<tidy::ClangTidyCheck>> CTChecks;
 537   ast_matchers::MatchFinder CTFinder;
 538   std::optional<tidy::ClangTidyContext> CTContext;
 539   // Must outlive FixIncludes.
 540   auto BuildDir = VFS->getCurrentWorkingDirectory();
 541   std::optional<IncludeFixer> FixIncludes;
 542   llvm::DenseMap<diag::kind, DiagnosticsEngine::Level> OverriddenSeverity;
 543   // No need to run clang-tidy or IncludeFixerif we are not going to surface
 544   // diagnostics.
 545   {
 546     trace::Span Tracer("ClangTidyInit");
 547     static const auto *AllCTFactories = [] {
 548       auto *CTFactories = new tidy::ClangTidyCheckFactories;
 549       for (const auto &E : tidy::ClangTidyModuleRegistry::entries())
 550         E.instantiate()->addCheckFactories(*CTFactories);
 551       return CTFactories;
 552     }();
 553     tidy::ClangTidyCheckFactories FastFactories = filterFastTidyChecks(
 554         *AllCTFactories, Cfg.Diagnostics.ClangTidy.FastCheckFilter);
 555     CTContext.emplace(std::make_unique<tidy::DefaultOptionsProvider>(
 556         tidy::ClangTidyGlobalOptions(), ClangTidyOpts));
 557     CTContext->setDiagnosticsEngine(&Clang->getDiagnostics());
 558     CTContext->setASTContext(&Clang->getASTContext());
 559     CTContext->setCurrentFile(Filename);
 560     CTContext->setSelfContainedDiags(true);
 561     CTChecks = FastFactories.createChecksForLanguage(&*CTContext);
 562     Preprocessor *PP = &Clang->getPreprocessor();
 563     for (const auto &Check : CTChecks) {
 564       Check->registerPPCallbacks(Clang->getSourceManager(), PP, PP);
 565       Check->registerMatchers(&CTFinder);
 566     }
 567
 568     // Clang only corrects typos for use of undeclared functions in C if that
 569     // use is an error. Include fixer relies on typo correction, so pretend
 570     // this is an error. (The actual typo correction is nice too).
 571     // We restore the original severity in the level adjuster.
 572     // FIXME: It would be better to have a real API for this, but what?
 573     for (auto ID : {diag::ext_implicit_function_decl_c99,
 574                     diag::ext_implicit_lib_function_decl,
 575                     diag::ext_implicit_lib_function_decl_c99,
 576                     diag::warn_implicit_function_decl}) {
 577       OverriddenSeverity.try_emplace(
 578           ID, Clang->getDiagnostics().getDiagnosticLevel(ID, SourceLocation()));
 579       Clang->getDiagnostics().setSeverity(ID, diag::Severity::Error,
 580                                           SourceLocation());
 581     }
 582
 583     ASTDiags.setLevelAdjuster([&](DiagnosticsEngine::Level DiagLevel,
 584                                   const clang::Diagnostic &Info) {
 585       if (Cfg.Diagnostics.SuppressAll ||
 586           isBuiltinDiagnosticSuppressed(Info.getID(), Cfg.Diagnostics.Suppress,
 587                                         Clang->getLangOpts()))
 588         return DiagnosticsEngine::Ignored;
 589
 590       auto It = OverriddenSeverity.find(Info.getID());
 591       if (It != OverriddenSeverity.end())
 592         DiagLevel = It->second;
 593
 594       if (!CTChecks.empty()) {
 595         std::string CheckName = CTContext->getCheckName(Info.getID());
 596         bool IsClangTidyDiag = !CheckName.empty();
 597         if (IsClangTidyDiag) {
 598           if (Cfg.Diagnostics.Suppress.contains(CheckName))
 599             return DiagnosticsEngine::Ignored;
 600           // Check for suppression comment. Skip the check for diagnostics not
 601           // in the main file, because we don't want that function to query the
 602           // source buffer for preamble files. For the same reason, we ask
 603           // shouldSuppressDiagnostic to avoid I/O.
 604           // We let suppression comments take precedence over warning-as-error
 605           // to match clang-tidy's behaviour.
 606           bool IsInsideMainFile =
 607               Info.hasSourceManager() &&
 608               isInsideMainFile(Info.getLocation(), Info.getSourceManager());
 609           SmallVector<tooling::Diagnostic, 1> TidySuppressedErrors;
 610           if (IsInsideMainFile && CTContext->shouldSuppressDiagnostic(
 611                                       DiagLevel, Info, TidySuppressedErrors,
 612                                       /*AllowIO=*/false,
 613                                       /*EnableNolintBlocks=*/true)) {
 614             // FIXME: should we expose the suppression error (invalid use of
 615             // NOLINT comments)?
 616             return DiagnosticsEngine::Ignored;
 617           }
 618           if (!CTContext->getOptions().SystemHeaders.value_or(false) &&
 619               Info.hasSourceManager() &&
 620               Info.getSourceManager().isInSystemMacro(Info.getLocation()))
 621             return DiagnosticsEngine::Ignored;
 622
 623           // Check for warning-as-error.
 624           if (DiagLevel == DiagnosticsEngine::Warning &&
 625               CTContext->treatAsError(CheckName)) {
 626             return DiagnosticsEngine::Error;
 627           }
 628         }
 629       }
 630       return DiagLevel;
 631     });
 632
 633     // Add IncludeFixer which can recover diagnostics caused by missing includes
 634     // (e.g. incomplete type) and attach include insertion fixes to diagnostics.
 635     if (Inputs.Index && !BuildDir.getError()) {
 636       auto Style =
 637           getFormatStyleForFile(Filename, Inputs.Contents, *Inputs.TFS, false);
 638       auto Inserter = std::make_shared<IncludeInserter>(
 639           Filename, Inputs.Contents, Style, BuildDir.get(),
 640           &Clang->getPreprocessor().getHeaderSearchInfo());
 641       ArrayRef<Inclusion> MainFileIncludes;
 642       if (Preamble) {
 643         MainFileIncludes = Preamble->Includes.MainFileIncludes;
 644         for (const auto &Inc : Preamble->Includes.MainFileIncludes)
 645           Inserter->addExisting(Inc);
 646       }
 647       // FIXME: Consider piping through ASTSignals to fetch this to handle the
 648       // case where a header file contains ObjC decls but no #imports.
 649       Symbol::IncludeDirective Directive =
 650           Inputs.Opts.ImportInsertions
 651               ? preferredIncludeDirective(Filename, Clang->getLangOpts(),
 652                                           MainFileIncludes, {})
 653               : Symbol::Include;
 654       FixIncludes.emplace(Filename, Inserter, *Inputs.Index,
 655                           /*IndexRequestLimit=*/5, Directive);
 656       ASTDiags.contributeFixes([&FixIncludes](DiagnosticsEngine::Level DiagLevl,
 657                                               const clang::Diagnostic &Info) {
 658         return FixIncludes->fix(DiagLevl, Info);
 659       });
 660       Clang->setExternalSemaSource(FixIncludes->unresolvedNameRecorder());
 661     }
 662   }
 663
 664   IncludeStructure Includes;
 665   include_cleaner::PragmaIncludes PI;
 666   // If we are using a preamble, copy existing includes.
 667   if (Preamble) {
 668     Includes = Preamble->Includes;
 669     Includes.MainFileIncludes = Patch->preambleIncludes();
 670     // Replay the preamble includes so that clang-tidy checks can see them.
 671     ReplayPreamble::attach(Patch->preambleIncludes(), *Clang,
 672                            Patch->modifiedBounds());
 673     PI = *Preamble->Pragmas;
 674   }
 675   // Important: collectIncludeStructure is registered *after* ReplayPreamble!
 676   // Otherwise we would collect the replayed includes again...
 677   // (We can't *just* use the replayed includes, they don't have Resolved path).
 678   Includes.collect(*Clang);
 679   // Same for pragma-includes, we're already inheriting preamble includes, so we
 680   // should only receive callbacks for non-preamble mainfile includes.
 681   PI.record(*Clang);
 682   // Copy over the macros in the preamble region of the main file, and combine
 683   // with non-preamble macros below.
 684   MainFileMacros Macros;
 685   std::vector<PragmaMark> Marks;
 686   if (Preamble) {
 687     Macros = Patch->mainFileMacros();
 688     Marks = Patch->marks();
 689   }
 690   auto &PP = Clang->getPreprocessor();
 691   PP.addPPCallbacks(std::make_unique<CollectMainFileMacros>(PP, Macros));
 692
 693   PP.addPPCallbacks(
 694       collectPragmaMarksCallback(Clang->getSourceManager(), Marks));
 695
 696   // FIXME: Attach a comment handler to take care of
 697   // keep/export/no_include etc. IWYU pragmas.
 698
 699   // Collect tokens of the main file.
 700   syntax::TokenCollector CollectTokens(PP);
 701
 702   // To remain consistent with preamble builds, these callbacks must be called
 703   // exactly here, after preprocessor is initialized and BeginSourceFile() was
 704   // called already.
 705   for (const auto &L : ASTListeners)
 706     L->beforeExecute(*Clang);
 707
 708   if (llvm::Error Err = Action->Execute())
 709     log("Execute() failed when building AST for {0}: {1}", MainInput.getFile(),
 710         toString(std::move(Err)));
 711
 712   // We have to consume the tokens before running clang-tidy to avoid collecting
 713   // tokens from running the preprocessor inside the checks (only
 714   // modernize-use-trailing-return-type does that today).
 715   syntax::TokenBuffer Tokens = std::move(CollectTokens).consume();
 716   // Makes SelectionTree build much faster.
 717   Tokens.indexExpandedTokens();
 718   std::vector<Decl *> ParsedDecls = Action->takeTopLevelDecls();
 719   // AST traversals should exclude the preamble, to avoid performance cliffs.
 720   Clang->getASTContext().setTraversalScope(ParsedDecls);
 721   if (!CTChecks.empty()) {
 722     // Run the AST-dependent part of the clang-tidy checks.
 723     // (The preprocessor part ran already, via PPCallbacks).
 724     trace::Span Tracer("ClangTidyMatch");
 725     CTFinder.matchAST(Clang->getASTContext());
 726   }
 727
 728   // XXX: This is messy: clang-tidy checks flush some diagnostics at EOF.
 729   // However Action->EndSourceFile() would destroy the ASTContext!
 730   // So just inform the preprocessor of EOF, while keeping everything alive.
 731   PP.EndSourceFile();
 732   // UnitDiagsConsumer is local, we can not store it in CompilerInstance that
 733   // has a longer lifetime.
 734   Clang->getDiagnostics().setClient(new IgnoreDiagnostics);
 735   // CompilerInstance won't run this callback, do it directly.
 736   ASTDiags.EndSourceFile();
 737
 738   std::vector<Diag> Diags = CompilerInvocationDiags;
 739   // FIXME: Also skip generation of diagnostics altogether to speed up ast
 740   // builds when we are patching a stale preamble.
 741   // Add diagnostics from the preamble, if any.
 742   if (Preamble)
 743     llvm::append_range(Diags, Patch->patchedDiags());
 744   // Finally, add diagnostics coming from the AST.
 745   {
 746     std::vector<Diag> D = ASTDiags.take(&*CTContext);
 747     Diags.insert(Diags.end(), D.begin(), D.end());
 748   }
 749   ParsedAST Result(Filename, Inputs.Version, std::move(Preamble),
 750                    std::move(Clang), std::move(Action), std::move(Tokens),
 751                    std::move(Macros), std::move(Marks), std::move(ParsedDecls),
 752                    std::move(Diags), std::move(Includes), std::move(PI));
 753   llvm::move(getIncludeCleanerDiags(Result, Inputs.Contents, *Inputs.TFS),
 754              std::back_inserter(Result.Diags));
 755   return std::move(Result);
 756 }
 757
 758 ParsedAST::ParsedAST(ParsedAST &&Other) = default;
 759
 760 ParsedAST &ParsedAST::operator=(ParsedAST &&Other) = default;
 761
 762 ParsedAST::~ParsedAST() {
 763   if (Action) {
 764     // We already notified the PP of end-of-file earlier, so detach it first.
 765     // We must keep it alive until after EndSourceFile(), Sema relies on this.
 766     auto PP = Clang->getPreprocessorPtr(); // Keep PP alive for now.
 767     Clang->setPreprocessor(nullptr);       // Detach so we don't send EOF again.
 768     Action->EndSourceFile();               // Destroy ASTContext and Sema.
 769     // Now Sema is gone, it's safe for PP to go out of scope.
 770   }
 771 }
 772
 773 ASTContext &ParsedAST::getASTContext() { return Clang->getASTContext(); }
 774
 775 const ASTContext &ParsedAST::getASTContext() const {
 776   return Clang->getASTContext();
 777 }
 778
 779 Sema &ParsedAST::getSema() { return Clang->getSema(); }
 780
 781 Preprocessor &ParsedAST::getPreprocessor() { return Clang->getPreprocessor(); }
 782
 783 std::shared_ptr<Preprocessor> ParsedAST::getPreprocessorPtr() {
 784   return Clang->getPreprocessorPtr();
 785 }
 786
 787 const Preprocessor &ParsedAST::getPreprocessor() const {
 788   return Clang->getPreprocessor();
 789 }
 790
 791 llvm::ArrayRef<Decl *> ParsedAST::getLocalTopLevelDecls() {
 792   return LocalTopLevelDecls;
 793 }
 794
 795 llvm::ArrayRef<const Decl *> ParsedAST::getLocalTopLevelDecls() const {
 796   return LocalTopLevelDecls;
 797 }
 798
 799 const MainFileMacros &ParsedAST::getMacros() const { return Macros; }
 800 const std::vector<PragmaMark> &ParsedAST::getMarks() const { return Marks; }
 801
 802 std::size_t ParsedAST::getUsedBytes() const {
 803   auto &AST = getASTContext();
 804   // FIXME(ibiryukov): we do not account for the dynamically allocated part of
 805   // Message and Fixes inside each diagnostic.
 806   std::size_t Total =
 807       clangd::getUsedBytes(LocalTopLevelDecls) + clangd::getUsedBytes(Diags);
 808
 809   // FIXME: the rest of the function is almost a direct copy-paste from
 810   // libclang's clang_getCXTUResourceUsage. We could share the implementation.
 811
 812   // Sum up various allocators inside the ast context and the preprocessor.
 813   Total += AST.getASTAllocatedMemory();
 814   Total += AST.getSideTableAllocatedMemory();
 815   Total += AST.Idents.getAllocator().getTotalMemory();
 816   Total += AST.Selectors.getTotalMemory();
 817
 818   Total += AST.getSourceManager().getContentCacheSize();
 819   Total += AST.getSourceManager().getDataStructureSizes();
 820   Total += AST.getSourceManager().getMemoryBufferSizes().malloc_bytes;
 821
 822   if (ExternalASTSource *Ext = AST.getExternalSource())
 823     Total += Ext->getMemoryBufferSizes().malloc_bytes;
 824
 825   const Preprocessor &PP = getPreprocessor();
 826   Total += PP.getTotalMemory();
 827   if (PreprocessingRecord *PRec = PP.getPreprocessingRecord())
 828     Total += PRec->getTotalMemory();
 829   Total += PP.getHeaderSearchInfo().getTotalMemory();
 830
 831   return Total;
 832 }
 833
 834 const IncludeStructure &ParsedAST::getIncludeStructure() const {
 835   return Includes;
 836 }
 837
 838 ParsedAST::ParsedAST(PathRef TUPath, llvm::StringRef Version,
 839                      std::shared_ptr<const PreambleData> Preamble,
 840                      std::unique_ptr<CompilerInstance> Clang,
 841                      std::unique_ptr<FrontendAction> Action,
 842                      syntax::TokenBuffer Tokens, MainFileMacros Macros,
 843                      std::vector<PragmaMark> Marks,
 844                      std::vector<Decl *> LocalTopLevelDecls,
 845                      std::vector<Diag> Diags, IncludeStructure Includes,
 846                      include_cleaner::PragmaIncludes PI)
 847     : TUPath(TUPath), Version(Version), Preamble(std::move(Preamble)),
 848       Clang(std::move(Clang)), Action(std::move(Action)),
 849       Tokens(std::move(Tokens)), Macros(std::move(Macros)),
 850       Marks(std::move(Marks)), Diags(std::move(Diags)),
 851       LocalTopLevelDecls(std::move(LocalTopLevelDecls)),
 852       Includes(std::move(Includes)), PI(std::move(PI)),
 853       Resolver(std::make_unique<HeuristicResolver>(getASTContext())) {
 854   assert(this->Clang);
 855   assert(this->Action);
 856 }
 857
 858 const include_cleaner::PragmaIncludes &ParsedAST::getPragmaIncludes() const {
 859   return PI;
 860 }
 861
 862 std::optional<llvm::StringRef> ParsedAST::preambleVersion() const {
 863   if (!Preamble)
 864     return std::nullopt;
 865   return llvm::StringRef(Preamble->Version);
 866 }
 867
 868 llvm::ArrayRef<Diag> ParsedAST::getDiagnostics() const { return Diags; }
 869 } // namespace clangd
 870 } // namespace clang