[clang-tools-extra] Adopt FileManager's error-returning APIs
[lldb.git] / clang-tools-extra / clangd / ClangdUnit.cpp
1 //===--- ClangdUnit.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 "ClangdUnit.h"
10 #include "../clang-tidy/ClangTidyDiagnosticConsumer.h"
11 #include "../clang-tidy/ClangTidyModuleRegistry.h"
12 #include "Compiler.h"
13 #include "Diagnostics.h"
14 #include "Headers.h"
15 #include "IncludeFixer.h"
16 #include "Logger.h"
17 #include "SourceCode.h"
18 #include "Trace.h"
19 #include "index/CanonicalIncludes.h"
20 #include "index/Index.h"
21 #include "clang/AST/ASTContext.h"
22 #include "clang/Basic/LangOptions.h"
23 #include "clang/Basic/SourceManager.h"
24 #include "clang/Basic/TokenKinds.h"
25 #include "clang/Frontend/CompilerInstance.h"
26 #include "clang/Frontend/CompilerInvocation.h"
27 #include "clang/Frontend/FrontendActions.h"
28 #include "clang/Frontend/Utils.h"
29 #include "clang/Index/IndexDataConsumer.h"
30 #include "clang/Index/IndexingAction.h"
31 #include "clang/Lex/Lexer.h"
32 #include "clang/Lex/MacroInfo.h"
33 #include "clang/Lex/Preprocessor.h"
34 #include "clang/Lex/PreprocessorOptions.h"
35 #include "clang/Sema/Sema.h"
36 #include "clang/Serialization/ASTWriter.h"
37 #include "clang/Serialization/PCHContainerOperations.h"
38 #include "clang/Tooling/CompilationDatabase.h"
39 #include "clang/Tooling/Syntax/Tokens.h"
40 #include "llvm/ADT/ArrayRef.h"
41 #include "llvm/ADT/STLExtras.h"
42 #include "llvm/ADT/SmallString.h"
43 #include "llvm/ADT/SmallVector.h"
44 #include "llvm/Support/raw_ostream.h"
45 #include <algorithm>
46 #include <memory>
47
48 namespace clang {
49 namespace clangd {
50 namespace {
51
52 bool compileCommandsAreEqual(const tooling::CompileCommand &LHS,
53                              const tooling::CompileCommand &RHS) {
54   // We don't check for Output, it should not matter to clangd.
55   return LHS.Directory == RHS.Directory && LHS.Filename == RHS.Filename &&
56          llvm::makeArrayRef(LHS.CommandLine).equals(RHS.CommandLine);
57 }
58
59 template <class T> std::size_t getUsedBytes(const std::vector<T> &Vec) {
60   return Vec.capacity() * sizeof(T);
61 }
62
63 class DeclTrackingASTConsumer : public ASTConsumer {
64 public:
65   DeclTrackingASTConsumer(std::vector<Decl *> &TopLevelDecls)
66       : TopLevelDecls(TopLevelDecls) {}
67
68   bool HandleTopLevelDecl(DeclGroupRef DG) override {
69     for (Decl *D : DG) {
70       auto &SM = D->getASTContext().getSourceManager();
71       if (!isInsideMainFile(D->getLocation(), SM))
72         continue;
73
74       // ObjCMethodDecl are not actually top-level decls.
75       if (isa<ObjCMethodDecl>(D))
76         continue;
77
78       TopLevelDecls.push_back(D);
79     }
80     return true;
81   }
82
83 private:
84   std::vector<Decl *> &TopLevelDecls;
85 };
86
87 class ClangdFrontendAction : public SyntaxOnlyAction {
88 public:
89   std::vector<Decl *> takeTopLevelDecls() { return std::move(TopLevelDecls); }
90
91 protected:
92   std::unique_ptr<ASTConsumer>
93   CreateASTConsumer(CompilerInstance &CI, llvm::StringRef InFile) override {
94     return llvm::make_unique<DeclTrackingASTConsumer>(/*ref*/ TopLevelDecls);
95   }
96
97 private:
98   std::vector<Decl *> TopLevelDecls;
99 };
100
101 class CollectMainFileMacros : public PPCallbacks {
102 public:
103   explicit CollectMainFileMacros(const SourceManager &SM,
104                                  std::vector<std::string> *Out)
105       : SM(SM), Out(Out) {}
106
107   void FileChanged(SourceLocation Loc, FileChangeReason,
108                    SrcMgr::CharacteristicKind, FileID Prev) {
109     InMainFile = SM.isWrittenInMainFile(Loc);
110   }
111
112   void MacroDefined(const Token &MacroName, const MacroDirective *MD) {
113     if (InMainFile)
114       MainFileMacros.insert(MacroName.getIdentifierInfo()->getName());
115   }
116
117   void EndOfMainFile() {
118     for (const auto &Entry : MainFileMacros)
119       Out->push_back(Entry.getKey());
120     llvm::sort(*Out);
121   }
122
123 private:
124   const SourceManager &SM;
125   bool InMainFile = true;
126   llvm::StringSet<> MainFileMacros;
127   std::vector<std::string> *Out;
128 };
129
130 class CppFilePreambleCallbacks : public PreambleCallbacks {
131 public:
132   CppFilePreambleCallbacks(PathRef File, PreambleParsedCallback ParsedCallback)
133       : File(File), ParsedCallback(ParsedCallback) {
134   }
135
136   IncludeStructure takeIncludes() { return std::move(Includes); }
137
138   std::vector<std::string> takeMainFileMacros() {
139     return std::move(MainFileMacros);
140   }
141
142   CanonicalIncludes takeCanonicalIncludes() { return std::move(CanonIncludes); }
143
144   void AfterExecute(CompilerInstance &CI) override {
145     if (!ParsedCallback)
146       return;
147     trace::Span Tracer("Running PreambleCallback");
148     ParsedCallback(CI.getASTContext(), CI.getPreprocessorPtr(), CanonIncludes);
149   }
150
151   void BeforeExecute(CompilerInstance &CI) override {
152     addSystemHeadersMapping(&CanonIncludes, CI.getLangOpts());
153     SourceMgr = &CI.getSourceManager();
154   }
155
156   std::unique_ptr<PPCallbacks> createPPCallbacks() override {
157     assert(SourceMgr && "SourceMgr must be set at this point");
158     return llvm::make_unique<PPChainedCallbacks>(
159         collectIncludeStructureCallback(*SourceMgr, &Includes),
160         llvm::make_unique<CollectMainFileMacros>(*SourceMgr, &MainFileMacros));
161   }
162
163   CommentHandler *getCommentHandler() override {
164     IWYUHandler = collectIWYUHeaderMaps(&CanonIncludes);
165     return IWYUHandler.get();
166   }
167
168 private:
169   PathRef File;
170   PreambleParsedCallback ParsedCallback;
171   IncludeStructure Includes;
172   CanonicalIncludes CanonIncludes;
173   std::vector<std::string> MainFileMacros;
174   std::unique_ptr<CommentHandler> IWYUHandler = nullptr;
175   SourceManager *SourceMgr = nullptr;
176 };
177
178 // When using a preamble, only preprocessor events outside its bounds are seen.
179 // This is almost what we want: replaying transitive preprocessing wastes time.
180 // However this confuses clang-tidy checks: they don't see any #includes!
181 // So we replay the *non-transitive* #includes that appear in the main-file.
182 // It would be nice to replay other events (macro definitions, ifdefs etc) but
183 // this addresses the most common cases fairly cheaply.
184 class ReplayPreamble : private PPCallbacks {
185 public:
186   // Attach preprocessor hooks such that preamble events will be injected at
187   // the appropriate time.
188   // Events will be delivered to the *currently registered* PP callbacks.
189   static void attach(const IncludeStructure &Includes,
190                      CompilerInstance &Clang) {
191     auto &PP = Clang.getPreprocessor();
192     auto *ExistingCallbacks = PP.getPPCallbacks();
193     // No need to replay events if nobody is listening.
194     if (!ExistingCallbacks)
195       return;
196     PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(
197         new ReplayPreamble(Includes, ExistingCallbacks,
198                            Clang.getSourceManager(), PP, Clang.getLangOpts())));
199     // We're relying on the fact that addPPCallbacks keeps the old PPCallbacks
200     // around, creating a chaining wrapper. Guard against other implementations.
201     assert(PP.getPPCallbacks() != ExistingCallbacks &&
202            "Expected chaining implementation");
203   }
204
205 private:
206   ReplayPreamble(const IncludeStructure &Includes, PPCallbacks *Delegate,
207                  const SourceManager &SM, Preprocessor &PP,
208                  const LangOptions &LangOpts)
209       : Includes(Includes), Delegate(Delegate), SM(SM), PP(PP),
210         LangOpts(LangOpts) {}
211
212   // In a normal compile, the preamble traverses the following structure:
213   //
214   // mainfile.cpp
215   //   <built-in>
216   //     ... macro definitions like __cplusplus ...
217   //     <command-line>
218   //       ... macro definitions for args like -Dfoo=bar ...
219   //   "header1.h"
220   //     ... header file contents ...
221   //   "header2.h"
222   //     ... header file contents ...
223   //   ... main file contents ...
224   //
225   // When using a preamble, the "header1" and "header2" subtrees get skipped.
226   // We insert them right after the built-in header, which still appears.
227   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
228                    SrcMgr::CharacteristicKind Kind, FileID PrevFID) override {
229     // It'd be nice if there was a better way to identify built-in headers...
230     if (Reason == FileChangeReason::ExitFile &&
231         SM.getBuffer(PrevFID)->getBufferIdentifier() == "<built-in>")
232       replay();
233   }
234
235   void replay() {
236     for (const auto &Inc : Includes.MainFileIncludes) {
237       const FileEntry *File = nullptr;
238       if (Inc.Resolved != "")
239         if (auto FE = SM.getFileManager().getFile(Inc.Resolved))
240           File = *FE;
241
242       llvm::StringRef WrittenFilename =
243           llvm::StringRef(Inc.Written).drop_front().drop_back();
244       bool Angled = llvm::StringRef(Inc.Written).startswith("<");
245
246       // Re-lex the #include directive to find its interesting parts.
247       llvm::StringRef Src = SM.getBufferData(SM.getMainFileID());
248       Lexer RawLexer(SM.getLocForStartOfFile(SM.getMainFileID()), LangOpts,
249                      Src.begin(), Src.begin() + Inc.HashOffset, Src.end());
250       Token HashTok, IncludeTok, FilenameTok;
251       RawLexer.LexFromRawLexer(HashTok);
252       assert(HashTok.getKind() == tok::hash);
253       RawLexer.setParsingPreprocessorDirective(true);
254       RawLexer.LexFromRawLexer(IncludeTok);
255       IdentifierInfo *II = PP.getIdentifierInfo(IncludeTok.getRawIdentifier());
256       IncludeTok.setIdentifierInfo(II);
257       IncludeTok.setKind(II->getTokenID());
258       RawLexer.LexIncludeFilename(FilenameTok);
259
260       Delegate->InclusionDirective(
261           HashTok.getLocation(), IncludeTok, WrittenFilename, Angled,
262           CharSourceRange::getCharRange(FilenameTok.getLocation(),
263                                         FilenameTok.getEndLoc()),
264           File, "SearchPath", "RelPath", /*Imported=*/nullptr, Inc.FileKind);
265       if (File)
266         Delegate->FileSkipped(*File, FilenameTok, Inc.FileKind);
267       else {
268         llvm::SmallString<1> UnusedRecovery;
269         Delegate->FileNotFound(WrittenFilename, UnusedRecovery);
270       }
271     }
272   }
273
274   const IncludeStructure &Includes;
275   PPCallbacks *Delegate;
276   const SourceManager &SM;
277   Preprocessor &PP;
278   const LangOptions &LangOpts;
279 };
280
281 } // namespace
282
283 void dumpAST(ParsedAST &AST, llvm::raw_ostream &OS) {
284   AST.getASTContext().getTranslationUnitDecl()->dump(OS, true);
285 }
286
287 llvm::Optional<ParsedAST>
288 ParsedAST::build(std::unique_ptr<CompilerInvocation> CI,
289                  std::shared_ptr<const PreambleData> Preamble,
290                  std::unique_ptr<llvm::MemoryBuffer> Buffer,
291                  llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
292                  const SymbolIndex *Index, const ParseOptions &Opts) {
293   assert(CI);
294   // Command-line parsing sets DisableFree to true by default, but we don't want
295   // to leak memory in clangd.
296   CI->getFrontendOpts().DisableFree = false;
297   const PrecompiledPreamble *PreamblePCH =
298       Preamble ? &Preamble->Preamble : nullptr;
299
300   StoreDiags ASTDiags;
301   std::string Content = Buffer->getBuffer();
302
303   auto Clang = prepareCompilerInstance(std::move(CI), PreamblePCH,
304                                        std::move(Buffer), VFS, ASTDiags);
305   if (!Clang)
306     return None;
307
308   auto Action = llvm::make_unique<ClangdFrontendAction>();
309   const FrontendInputFile &MainInput = Clang->getFrontendOpts().Inputs[0];
310   if (!Action->BeginSourceFile(*Clang, MainInput)) {
311     log("BeginSourceFile() failed when building AST for {0}",
312         MainInput.getFile());
313     return None;
314   }
315
316   // Set up ClangTidy. Must happen after BeginSourceFile() so ASTContext exists.
317   // Clang-tidy has some limitiations to ensure reasonable performance:
318   //  - checks don't see all preprocessor events in the preamble
319   //  - matchers run only over the main-file top-level decls (and can't see
320   //    ancestors outside this scope).
321   // In practice almost all checks work well without modifications.
322   std::vector<std::unique_ptr<tidy::ClangTidyCheck>> CTChecks;
323   ast_matchers::MatchFinder CTFinder;
324   llvm::Optional<tidy::ClangTidyContext> CTContext;
325   {
326     trace::Span Tracer("ClangTidyInit");
327     dlog("ClangTidy configuration for file {0}: {1}", MainInput.getFile(),
328          tidy::configurationAsText(Opts.ClangTidyOpts));
329     tidy::ClangTidyCheckFactories CTFactories;
330     for (const auto &E : tidy::ClangTidyModuleRegistry::entries())
331       E.instantiate()->addCheckFactories(CTFactories);
332     CTContext.emplace(llvm::make_unique<tidy::DefaultOptionsProvider>(
333         tidy::ClangTidyGlobalOptions(), Opts.ClangTidyOpts));
334     CTContext->setDiagnosticsEngine(&Clang->getDiagnostics());
335     CTContext->setASTContext(&Clang->getASTContext());
336     CTContext->setCurrentFile(MainInput.getFile());
337     CTFactories.createChecks(CTContext.getPointer(), CTChecks);
338     ASTDiags.setLevelAdjuster([&CTContext](DiagnosticsEngine::Level DiagLevel,
339                                            const clang::Diagnostic &Info) {
340       if (CTContext) {
341         std::string CheckName = CTContext->getCheckName(Info.getID());
342         bool IsClangTidyDiag = !CheckName.empty();
343         if (IsClangTidyDiag) {
344           // Check for warning-as-error.
345           // We deliberately let this take precedence over suppression comments
346           // to match clang-tidy's behaviour.
347           if (DiagLevel == DiagnosticsEngine::Warning &&
348               CTContext->treatAsError(CheckName)) {
349             return DiagnosticsEngine::Error;
350           }
351
352           // Check for suppression comment. Skip the check for diagnostics not
353           // in the main file, because we don't want that function to query the
354           // source buffer for preamble files. For the same reason, we ask
355           // ShouldSuppressDiagnostic not to follow macro expansions, since
356           // those might take us into a preamble file as well.
357           bool IsInsideMainFile =
358               Info.hasSourceManager() &&
359               isInsideMainFile(Info.getLocation(), Info.getSourceManager());
360           if (IsInsideMainFile && tidy::ShouldSuppressDiagnostic(
361                                       DiagLevel, Info, *CTContext,
362                                       /* CheckMacroExpansion = */ false)) {
363             return DiagnosticsEngine::Ignored;
364           }
365         }
366       }
367       return DiagLevel;
368     });
369     Preprocessor *PP = &Clang->getPreprocessor();
370     for (const auto &Check : CTChecks) {
371       // FIXME: the PP callbacks skip the entire preamble.
372       // Checks that want to see #includes in the main file do not see them.
373       Check->registerPPCallbacks(Clang->getSourceManager(), PP, PP);
374       Check->registerMatchers(&CTFinder);
375     }
376   }
377
378   // Add IncludeFixer which can recover diagnostics caused by missing includes
379   // (e.g. incomplete type) and attach include insertion fixes to diagnostics.
380   llvm::Optional<IncludeFixer> FixIncludes;
381   auto BuildDir = VFS->getCurrentWorkingDirectory();
382   if (Opts.SuggestMissingIncludes && Index && !BuildDir.getError()) {
383     auto Style = getFormatStyleForFile(MainInput.getFile(), Content, VFS.get());
384     auto Inserter = std::make_shared<IncludeInserter>(
385         MainInput.getFile(), Content, Style, BuildDir.get(),
386         &Clang->getPreprocessor().getHeaderSearchInfo());
387     if (Preamble) {
388       for (const auto &Inc : Preamble->Includes.MainFileIncludes)
389         Inserter->addExisting(Inc);
390     }
391     FixIncludes.emplace(MainInput.getFile(), Inserter, *Index,
392                         /*IndexRequestLimit=*/5);
393     ASTDiags.contributeFixes([&FixIncludes](DiagnosticsEngine::Level DiagLevl,
394                                             const clang::Diagnostic &Info) {
395       return FixIncludes->fix(DiagLevl, Info);
396     });
397     Clang->setExternalSemaSource(FixIncludes->unresolvedNameRecorder());
398   }
399
400   // Copy over the includes from the preamble, then combine with the
401   // non-preamble includes below.
402   auto Includes = Preamble ? Preamble->Includes : IncludeStructure{};
403   // Replay the preamble includes so that clang-tidy checks can see them.
404   if (Preamble)
405     ReplayPreamble::attach(Includes, *Clang);
406   // Important: collectIncludeStructure is registered *after* ReplayPreamble!
407   // Otherwise we would collect the replayed includes again...
408   // (We can't *just* use the replayed includes, they don't have Resolved path).
409   Clang->getPreprocessor().addPPCallbacks(
410       collectIncludeStructureCallback(Clang->getSourceManager(), &Includes));
411
412   // Copy over the includes from the preamble, then combine with the
413   // non-preamble includes below.
414   CanonicalIncludes CanonIncludes;
415   if (Preamble)
416     CanonIncludes = Preamble->CanonIncludes;
417   else
418     addSystemHeadersMapping(&CanonIncludes, Clang->getLangOpts());
419   std::unique_ptr<CommentHandler> IWYUHandler =
420       collectIWYUHeaderMaps(&CanonIncludes);
421   Clang->getPreprocessor().addCommentHandler(IWYUHandler.get());
422
423   // Collect tokens of the main file.
424   syntax::TokenCollector CollectTokens(Clang->getPreprocessor());
425
426   if (llvm::Error Err = Action->Execute())
427     log("Execute() failed when building AST for {0}: {1}", MainInput.getFile(),
428         toString(std::move(Err)));
429
430   // We have to consume the tokens before running clang-tidy to avoid collecting
431   // tokens from running the preprocessor inside the checks (only
432   // modernize-use-trailing-return-type does that today).
433   syntax::TokenBuffer Tokens = std::move(CollectTokens).consume();
434   std::vector<Decl *> ParsedDecls = Action->takeTopLevelDecls();
435   // AST traversals should exclude the preamble, to avoid performance cliffs.
436   Clang->getASTContext().setTraversalScope(ParsedDecls);
437   {
438     // Run the AST-dependent part of the clang-tidy checks.
439     // (The preprocessor part ran already, via PPCallbacks).
440     trace::Span Tracer("ClangTidyMatch");
441     CTFinder.matchAST(Clang->getASTContext());
442   }
443
444   // UnitDiagsConsumer is local, we can not store it in CompilerInstance that
445   // has a longer lifetime.
446   Clang->getDiagnostics().setClient(new IgnoreDiagnostics);
447   // CompilerInstance won't run this callback, do it directly.
448   ASTDiags.EndSourceFile();
449   // XXX: This is messy: clang-tidy checks flush some diagnostics at EOF.
450   // However Action->EndSourceFile() would destroy the ASTContext!
451   // So just inform the preprocessor of EOF, while keeping everything alive.
452   Clang->getPreprocessor().EndSourceFile();
453
454   std::vector<Diag> Diags = ASTDiags.take(CTContext.getPointer());
455   // Add diagnostics from the preamble, if any.
456   if (Preamble)
457     Diags.insert(Diags.begin(), Preamble->Diags.begin(), Preamble->Diags.end());
458   return ParsedAST(std::move(Preamble), std::move(Clang), std::move(Action),
459                    std::move(Tokens), std::move(ParsedDecls), std::move(Diags),
460                    std::move(Includes), std::move(CanonIncludes));
461 }
462
463 ParsedAST::ParsedAST(ParsedAST &&Other) = default;
464
465 ParsedAST &ParsedAST::operator=(ParsedAST &&Other) = default;
466
467 ParsedAST::~ParsedAST() {
468   if (Action) {
469     // We already notified the PP of end-of-file earlier, so detach it first.
470     // We must keep it alive until after EndSourceFile(), Sema relies on this.
471     auto PP = Clang->getPreprocessorPtr(); // Keep PP alive for now.
472     Clang->setPreprocessor(nullptr);       // Detach so we don't send EOF again.
473     Action->EndSourceFile();               // Destroy ASTContext and Sema.
474     // Now Sema is gone, it's safe for PP to go out of scope.
475   }
476 }
477
478 ASTContext &ParsedAST::getASTContext() { return Clang->getASTContext(); }
479
480 const ASTContext &ParsedAST::getASTContext() const {
481   return Clang->getASTContext();
482 }
483
484 Preprocessor &ParsedAST::getPreprocessor() { return Clang->getPreprocessor(); }
485
486 std::shared_ptr<Preprocessor> ParsedAST::getPreprocessorPtr() {
487   return Clang->getPreprocessorPtr();
488 }
489
490 const Preprocessor &ParsedAST::getPreprocessor() const {
491   return Clang->getPreprocessor();
492 }
493
494 llvm::ArrayRef<Decl *> ParsedAST::getLocalTopLevelDecls() {
495   return LocalTopLevelDecls;
496 }
497
498 const std::vector<Diag> &ParsedAST::getDiagnostics() const { return Diags; }
499
500 std::size_t ParsedAST::getUsedBytes() const {
501   auto &AST = getASTContext();
502   // FIXME(ibiryukov): we do not account for the dynamically allocated part of
503   // Message and Fixes inside each diagnostic.
504   std::size_t Total =
505       clangd::getUsedBytes(LocalTopLevelDecls) + clangd::getUsedBytes(Diags);
506
507   // FIXME: the rest of the function is almost a direct copy-paste from
508   // libclang's clang_getCXTUResourceUsage. We could share the implementation.
509
510   // Sum up variaous allocators inside the ast context and the preprocessor.
511   Total += AST.getASTAllocatedMemory();
512   Total += AST.getSideTableAllocatedMemory();
513   Total += AST.Idents.getAllocator().getTotalMemory();
514   Total += AST.Selectors.getTotalMemory();
515
516   Total += AST.getSourceManager().getContentCacheSize();
517   Total += AST.getSourceManager().getDataStructureSizes();
518   Total += AST.getSourceManager().getMemoryBufferSizes().malloc_bytes;
519
520   if (ExternalASTSource *Ext = AST.getExternalSource())
521     Total += Ext->getMemoryBufferSizes().malloc_bytes;
522
523   const Preprocessor &PP = getPreprocessor();
524   Total += PP.getTotalMemory();
525   if (PreprocessingRecord *PRec = PP.getPreprocessingRecord())
526     Total += PRec->getTotalMemory();
527   Total += PP.getHeaderSearchInfo().getTotalMemory();
528
529   return Total;
530 }
531
532 const IncludeStructure &ParsedAST::getIncludeStructure() const {
533   return Includes;
534 }
535
536 const CanonicalIncludes &ParsedAST::getCanonicalIncludes() const {
537   return CanonIncludes;
538 }
539
540 PreambleData::PreambleData(PrecompiledPreamble Preamble,
541                            std::vector<Diag> Diags, IncludeStructure Includes,
542                            std::vector<std::string> MainFileMacros,
543                            std::unique_ptr<PreambleFileStatusCache> StatCache,
544                            CanonicalIncludes CanonIncludes)
545     : Preamble(std::move(Preamble)), Diags(std::move(Diags)),
546       Includes(std::move(Includes)), MainFileMacros(std::move(MainFileMacros)),
547       StatCache(std::move(StatCache)), CanonIncludes(std::move(CanonIncludes)) {
548 }
549
550 ParsedAST::ParsedAST(std::shared_ptr<const PreambleData> Preamble,
551                      std::unique_ptr<CompilerInstance> Clang,
552                      std::unique_ptr<FrontendAction> Action,
553                      syntax::TokenBuffer Tokens,
554                      std::vector<Decl *> LocalTopLevelDecls,
555                      std::vector<Diag> Diags, IncludeStructure Includes,
556                      CanonicalIncludes CanonIncludes)
557     : Preamble(std::move(Preamble)), Clang(std::move(Clang)),
558       Action(std::move(Action)), Tokens(std::move(Tokens)),
559       Diags(std::move(Diags)),
560       LocalTopLevelDecls(std::move(LocalTopLevelDecls)),
561       Includes(std::move(Includes)), CanonIncludes(std::move(CanonIncludes)) {
562   assert(this->Clang);
563   assert(this->Action);
564 }
565
566 std::shared_ptr<const PreambleData>
567 buildPreamble(PathRef FileName, CompilerInvocation &CI,
568               std::shared_ptr<const PreambleData> OldPreamble,
569               const tooling::CompileCommand &OldCompileCommand,
570               const ParseInputs &Inputs, bool StoreInMemory,
571               PreambleParsedCallback PreambleCallback) {
572   // Note that we don't need to copy the input contents, preamble can live
573   // without those.
574   auto ContentsBuffer =
575       llvm::MemoryBuffer::getMemBuffer(Inputs.Contents, FileName);
576   auto Bounds =
577       ComputePreambleBounds(*CI.getLangOpts(), ContentsBuffer.get(), 0);
578
579   if (OldPreamble &&
580       compileCommandsAreEqual(Inputs.CompileCommand, OldCompileCommand) &&
581       OldPreamble->Preamble.CanReuse(CI, ContentsBuffer.get(), Bounds,
582                                      Inputs.FS.get())) {
583     vlog("Reusing preamble for file {0}", llvm::Twine(FileName));
584     return OldPreamble;
585   }
586   vlog("Preamble for file {0} cannot be reused. Attempting to rebuild it.",
587        FileName);
588
589   trace::Span Tracer("BuildPreamble");
590   SPAN_ATTACH(Tracer, "File", FileName);
591   StoreDiags PreambleDiagnostics;
592   llvm::IntrusiveRefCntPtr<DiagnosticsEngine> PreambleDiagsEngine =
593       CompilerInstance::createDiagnostics(&CI.getDiagnosticOpts(),
594                                           &PreambleDiagnostics, false);
595
596   // Skip function bodies when building the preamble to speed up building
597   // the preamble and make it smaller.
598   assert(!CI.getFrontendOpts().SkipFunctionBodies);
599   CI.getFrontendOpts().SkipFunctionBodies = true;
600   // We don't want to write comment locations into PCH. They are racy and slow
601   // to read back. We rely on dynamic index for the comments instead.
602   CI.getPreprocessorOpts().WriteCommentListToPCH = false;
603
604   CppFilePreambleCallbacks SerializedDeclsCollector(FileName, PreambleCallback);
605   if (Inputs.FS->setCurrentWorkingDirectory(Inputs.CompileCommand.Directory)) {
606     log("Couldn't set working directory when building the preamble.");
607     // We proceed anyway, our lit-tests rely on results for non-existing working
608     // dirs.
609   }
610
611   llvm::SmallString<32> AbsFileName(FileName);
612   Inputs.FS->makeAbsolute(AbsFileName);
613   auto StatCache = llvm::make_unique<PreambleFileStatusCache>(AbsFileName);
614   auto BuiltPreamble = PrecompiledPreamble::Build(
615       CI, ContentsBuffer.get(), Bounds, *PreambleDiagsEngine,
616       StatCache->getProducingFS(Inputs.FS),
617       std::make_shared<PCHContainerOperations>(), StoreInMemory,
618       SerializedDeclsCollector);
619
620   // When building the AST for the main file, we do want the function
621   // bodies.
622   CI.getFrontendOpts().SkipFunctionBodies = false;
623
624   if (BuiltPreamble) {
625     vlog("Built preamble of size {0} for file {1}", BuiltPreamble->getSize(),
626          FileName);
627     std::vector<Diag> Diags = PreambleDiagnostics.take();
628     return std::make_shared<PreambleData>(
629         std::move(*BuiltPreamble), std::move(Diags),
630         SerializedDeclsCollector.takeIncludes(),
631         SerializedDeclsCollector.takeMainFileMacros(), std::move(StatCache),
632         SerializedDeclsCollector.takeCanonicalIncludes());
633   } else {
634     elog("Could not build a preamble for file {0}", FileName);
635     return nullptr;
636   }
637 }
638
639 llvm::Optional<ParsedAST>
640 buildAST(PathRef FileName, std::unique_ptr<CompilerInvocation> Invocation,
641          const ParseInputs &Inputs,
642          std::shared_ptr<const PreambleData> Preamble) {
643   trace::Span Tracer("BuildAST");
644   SPAN_ATTACH(Tracer, "File", FileName);
645
646   auto VFS = Inputs.FS;
647   if (Preamble && Preamble->StatCache)
648     VFS = Preamble->StatCache->getConsumingFS(std::move(VFS));
649   if (VFS->setCurrentWorkingDirectory(Inputs.CompileCommand.Directory)) {
650     log("Couldn't set working directory when building the preamble.");
651     // We proceed anyway, our lit-tests rely on results for non-existing working
652     // dirs.
653   }
654
655   return ParsedAST::build(
656       llvm::make_unique<CompilerInvocation>(*Invocation), Preamble,
657       llvm::MemoryBuffer::getMemBufferCopy(Inputs.Contents, FileName),
658       std::move(VFS), Inputs.Index, Inputs.Opts);
659 }
660
661 SourceLocation getBeginningOfIdentifier(const ParsedAST &Unit,
662                                         const Position &Pos, const FileID FID) {
663   const ASTContext &AST = Unit.getASTContext();
664   const SourceManager &SourceMgr = AST.getSourceManager();
665   auto Offset = positionToOffset(SourceMgr.getBufferData(FID), Pos);
666   if (!Offset) {
667     log("getBeginningOfIdentifier: {0}", Offset.takeError());
668     return SourceLocation();
669   }
670
671   // GetBeginningOfToken(pos) is almost what we want, but does the wrong thing
672   // if the cursor is at the end of the identifier.
673   // Instead, we lex at GetBeginningOfToken(pos - 1). The cases are:
674   //  1) at the beginning of an identifier, we'll be looking at something
675   //  that isn't an identifier.
676   //  2) at the middle or end of an identifier, we get the identifier.
677   //  3) anywhere outside an identifier, we'll get some non-identifier thing.
678   // We can't actually distinguish cases 1 and 3, but returning the original
679   // location is correct for both!
680   SourceLocation InputLoc = SourceMgr.getComposedLoc(FID, *Offset);
681   if (*Offset == 0) // Case 1 or 3.
682     return SourceMgr.getMacroArgExpandedLocation(InputLoc);
683   SourceLocation Before = SourceMgr.getComposedLoc(FID, *Offset - 1);
684
685   Before = Lexer::GetBeginningOfToken(Before, SourceMgr, AST.getLangOpts());
686   Token Tok;
687   if (Before.isValid() &&
688       !Lexer::getRawToken(Before, Tok, SourceMgr, AST.getLangOpts(), false) &&
689       Tok.is(tok::raw_identifier))
690     return SourceMgr.getMacroArgExpandedLocation(Before); // Case 2.
691   return SourceMgr.getMacroArgExpandedLocation(InputLoc); // Case 1 or 3.
692 }
693
694 } // namespace clangd
695 namespace tidy {
696 // Force the linker to link in Clang-tidy modules.
697 #define LINK_TIDY_MODULE(X)                                                    \
698   extern volatile int X##ModuleAnchorSource;                                   \
699   static int LLVM_ATTRIBUTE_UNUSED X##ModuleAnchorDestination =                \
700       X##ModuleAnchorSource
701 LINK_TIDY_MODULE(CERT);
702 LINK_TIDY_MODULE(Abseil);
703 LINK_TIDY_MODULE(Boost);
704 LINK_TIDY_MODULE(Bugprone);
705 LINK_TIDY_MODULE(LLVM);
706 LINK_TIDY_MODULE(CppCoreGuidelines);
707 LINK_TIDY_MODULE(Fuchsia);
708 LINK_TIDY_MODULE(Google);
709 LINK_TIDY_MODULE(Android);
710 LINK_TIDY_MODULE(Misc);
711 LINK_TIDY_MODULE(Modernize);
712 LINK_TIDY_MODULE(Performance);
713 LINK_TIDY_MODULE(Portability);
714 LINK_TIDY_MODULE(Readability);
715 LINK_TIDY_MODULE(ObjC);
716 LINK_TIDY_MODULE(HICPP);
717 LINK_TIDY_MODULE(Zircon);
718 #undef LINK_TIDY_MODULE
719 } // namespace tidy
720 } // namespace clang