clang  9.0.0
ASTUnit.cpp
Go to the documentation of this file.
1 //===- ASTUnit.cpp - ASTUnit utility --------------------------------------===//
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 // ASTUnit Implementation.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/Frontend/ASTUnit.h"
14 #include "clang/AST/ASTConsumer.h"
15 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/Decl.h"
18 #include "clang/AST/DeclBase.h"
19 #include "clang/AST/DeclCXX.h"
20 #include "clang/AST/DeclGroup.h"
21 #include "clang/AST/DeclObjC.h"
22 #include "clang/AST/DeclTemplate.h"
26 #include "clang/AST/Type.h"
27 #include "clang/AST/TypeOrdering.h"
28 #include "clang/Basic/Diagnostic.h"
31 #include "clang/Basic/LLVM.h"
33 #include "clang/Basic/Module.h"
36 #include "clang/Basic/TargetInfo.h"
46 #include "clang/Frontend/Utils.h"
47 #include "clang/Lex/HeaderSearch.h"
49 #include "clang/Lex/Lexer.h"
50 #include "clang/Lex/PPCallbacks.h"
52 #include "clang/Lex/Preprocessor.h"
54 #include "clang/Lex/Token.h"
57 #include "clang/Sema/Sema.h"
65 #include "llvm/ADT/ArrayRef.h"
66 #include "llvm/ADT/DenseMap.h"
67 #include "llvm/ADT/IntrusiveRefCntPtr.h"
68 #include "llvm/ADT/None.h"
69 #include "llvm/ADT/Optional.h"
70 #include "llvm/ADT/STLExtras.h"
71 #include "llvm/ADT/SmallString.h"
72 #include "llvm/ADT/SmallVector.h"
73 #include "llvm/ADT/StringMap.h"
74 #include "llvm/ADT/StringRef.h"
75 #include "llvm/ADT/StringSet.h"
76 #include "llvm/ADT/Twine.h"
77 #include "llvm/ADT/iterator_range.h"
78 #include "llvm/Bitstream/BitstreamWriter.h"
79 #include "llvm/Support/Allocator.h"
80 #include "llvm/Support/Casting.h"
81 #include "llvm/Support/CrashRecoveryContext.h"
82 #include "llvm/Support/DJB.h"
83 #include "llvm/Support/ErrorHandling.h"
84 #include "llvm/Support/ErrorOr.h"
85 #include "llvm/Support/FileSystem.h"
86 #include "llvm/Support/MemoryBuffer.h"
87 #include "llvm/Support/Mutex.h"
88 #include "llvm/Support/Timer.h"
89 #include "llvm/Support/VirtualFileSystem.h"
90 #include "llvm/Support/raw_ostream.h"
91 #include <algorithm>
92 #include <atomic>
93 #include <cassert>
94 #include <cstdint>
95 #include <cstdio>
96 #include <cstdlib>
97 #include <memory>
98 #include <string>
99 #include <tuple>
100 #include <utility>
101 #include <vector>
102 
103 using namespace clang;
104 
105 using llvm::TimeRecord;
106 
107 namespace {
108 
109  class SimpleTimer {
110  bool WantTiming;
111  TimeRecord Start;
112  std::string Output;
113 
114  public:
115  explicit SimpleTimer(bool WantTiming) : WantTiming(WantTiming) {
116  if (WantTiming)
117  Start = TimeRecord::getCurrentTime();
118  }
119 
120  ~SimpleTimer() {
121  if (WantTiming) {
122  TimeRecord Elapsed = TimeRecord::getCurrentTime();
123  Elapsed -= Start;
124  llvm::errs() << Output << ':';
125  Elapsed.print(Elapsed, llvm::errs());
126  llvm::errs() << '\n';
127  }
128  }
129 
130  void setOutput(const Twine &Output) {
131  if (WantTiming)
132  this->Output = Output.str();
133  }
134  };
135 
136 } // namespace
137 
138 template <class T>
139 static std::unique_ptr<T> valueOrNull(llvm::ErrorOr<std::unique_ptr<T>> Val) {
140  if (!Val)
141  return nullptr;
142  return std::move(*Val);
143 }
144 
145 template <class T>
146 static bool moveOnNoError(llvm::ErrorOr<T> Val, T &Output) {
147  if (!Val)
148  return false;
149  Output = std::move(*Val);
150  return true;
151 }
152 
153 /// Get a source buffer for \p MainFilePath, handling all file-to-file
154 /// and file-to-buffer remappings inside \p Invocation.
155 static std::unique_ptr<llvm::MemoryBuffer>
157  llvm::vfs::FileSystem *VFS,
158  StringRef FilePath, bool isVolatile) {
159  const auto &PreprocessorOpts = Invocation.getPreprocessorOpts();
160 
161  // Try to determine if the main file has been remapped, either from the
162  // command line (to another file) or directly through the compiler
163  // invocation (to a memory buffer).
164  llvm::MemoryBuffer *Buffer = nullptr;
165  std::unique_ptr<llvm::MemoryBuffer> BufferOwner;
166  auto FileStatus = VFS->status(FilePath);
167  if (FileStatus) {
168  llvm::sys::fs::UniqueID MainFileID = FileStatus->getUniqueID();
169 
170  // Check whether there is a file-file remapping of the main file
171  for (const auto &RF : PreprocessorOpts.RemappedFiles) {
172  std::string MPath(RF.first);
173  auto MPathStatus = VFS->status(MPath);
174  if (MPathStatus) {
175  llvm::sys::fs::UniqueID MID = MPathStatus->getUniqueID();
176  if (MainFileID == MID) {
177  // We found a remapping. Try to load the resulting, remapped source.
178  BufferOwner = valueOrNull(VFS->getBufferForFile(RF.second, -1, true, isVolatile));
179  if (!BufferOwner)
180  return nullptr;
181  }
182  }
183  }
184 
185  // Check whether there is a file-buffer remapping. It supercedes the
186  // file-file remapping.
187  for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) {
188  std::string MPath(RB.first);
189  auto MPathStatus = VFS->status(MPath);
190  if (MPathStatus) {
191  llvm::sys::fs::UniqueID MID = MPathStatus->getUniqueID();
192  if (MainFileID == MID) {
193  // We found a remapping.
194  BufferOwner.reset();
195  Buffer = const_cast<llvm::MemoryBuffer *>(RB.second);
196  }
197  }
198  }
199  }
200 
201  // If the main source file was not remapped, load it now.
202  if (!Buffer && !BufferOwner) {
203  BufferOwner = valueOrNull(VFS->getBufferForFile(FilePath, -1, true, isVolatile));
204  if (!BufferOwner)
205  return nullptr;
206  }
207 
208  if (BufferOwner)
209  return BufferOwner;
210  if (!Buffer)
211  return nullptr;
212  return llvm::MemoryBuffer::getMemBufferCopy(Buffer->getBuffer(), FilePath);
213 }
214 
217  llvm::BitstreamWriter Stream;
219 
221  : Stream(Buffer), Writer(Stream, Buffer, ModuleCache, {}) {}
222 };
223 
224 void ASTUnit::clearFileLevelDecls() {
225  llvm::DeleteContainerSeconds(FileDecls);
226 }
227 
228 /// After failing to build a precompiled preamble (due to
229 /// errors in the source that occurs in the preamble), the number of
230 /// reparses during which we'll skip even trying to precompile the
231 /// preamble.
233 
234 /// Tracks the number of ASTUnit objects that are currently active.
235 ///
236 /// Used for debugging purposes only.
237 static std::atomic<unsigned> ActiveASTUnitObjects;
238 
239 ASTUnit::ASTUnit(bool _MainFileIsAST)
240  : MainFileIsAST(_MainFileIsAST), WantTiming(getenv("LIBCLANG_TIMING")),
241  ShouldCacheCodeCompletionResults(false),
242  IncludeBriefCommentsInCodeCompletion(false), UserFilesAreVolatile(false),
243  UnsafeToFree(false) {
244  if (getenv("LIBCLANG_OBJTRACKING"))
245  fprintf(stderr, "+++ %u translation units\n", ++ActiveASTUnitObjects);
246 }
247 
248 ASTUnit::~ASTUnit() {
249  // If we loaded from an AST file, balance out the BeginSourceFile call.
250  if (MainFileIsAST && getDiagnostics().getClient()) {
252  }
253 
254  clearFileLevelDecls();
255 
256  // Free the buffers associated with remapped files. We are required to
257  // perform this operation here because we explicitly request that the
258  // compiler instance *not* free these buffers for each invocation of the
259  // parser.
260  if (Invocation && OwnsRemappedFileBuffers) {
261  PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
262  for (const auto &RB : PPOpts.RemappedFileBuffers)
263  delete RB.second;
264  }
265 
266  ClearCachedCompletionResults();
267 
268  if (getenv("LIBCLANG_OBJTRACKING"))
269  fprintf(stderr, "--- %u translation units\n", --ActiveASTUnitObjects);
270 }
271 
272 void ASTUnit::setPreprocessor(std::shared_ptr<Preprocessor> PP) {
273  this->PP = std::move(PP);
274 }
275 
277  assert(getDiagnostics().getClient() && Ctx &&
278  "Bad context for source file");
279  getDiagnostics().getClient()->BeginSourceFile(Ctx->getLangOpts(), PP.get());
280 }
281 
282 /// Determine the set of code-completion contexts in which this
283 /// declaration should be shown.
284 static uint64_t getDeclShowContexts(const NamedDecl *ND,
285  const LangOptions &LangOpts,
286  bool &IsNestedNameSpecifier) {
287  IsNestedNameSpecifier = false;
288 
289  if (isa<UsingShadowDecl>(ND))
290  ND = ND->getUnderlyingDecl();
291  if (!ND)
292  return 0;
293 
294  uint64_t Contexts = 0;
295  if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND) ||
296  isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND) ||
297  isa<TypeAliasTemplateDecl>(ND)) {
298  // Types can appear in these contexts.
299  if (LangOpts.CPlusPlus || !isa<TagDecl>(ND))
300  Contexts |= (1LL << CodeCompletionContext::CCC_TopLevel)
306 
307  // In C++, types can appear in expressions contexts (for functional casts).
308  if (LangOpts.CPlusPlus)
309  Contexts |= (1LL << CodeCompletionContext::CCC_Expression);
310 
311  // In Objective-C, message sends can send interfaces. In Objective-C++,
312  // all types are available due to functional casts.
313  if (LangOpts.CPlusPlus || isa<ObjCInterfaceDecl>(ND))
315 
316  // In Objective-C, you can only be a subclass of another Objective-C class
317  if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) {
318  // Objective-C interfaces can be used in a class property expression.
319  if (ID->getDefinition())
320  Contexts |= (1LL << CodeCompletionContext::CCC_Expression);
322  }
323 
324  // Deal with tag names.
325  if (isa<EnumDecl>(ND)) {
326  Contexts |= (1LL << CodeCompletionContext::CCC_EnumTag);
327 
328  // Part of the nested-name-specifier in C++0x.
329  if (LangOpts.CPlusPlus11)
330  IsNestedNameSpecifier = true;
331  } else if (const auto *Record = dyn_cast<RecordDecl>(ND)) {
332  if (Record->isUnion())
333  Contexts |= (1LL << CodeCompletionContext::CCC_UnionTag);
334  else
335  Contexts |= (1LL << CodeCompletionContext::CCC_ClassOrStructTag);
336 
337  if (LangOpts.CPlusPlus)
338  IsNestedNameSpecifier = true;
339  } else if (isa<ClassTemplateDecl>(ND))
340  IsNestedNameSpecifier = true;
341  } else if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) {
342  // Values can appear in these contexts.
343  Contexts = (1LL << CodeCompletionContext::CCC_Statement)
347  } else if (isa<ObjCProtocolDecl>(ND)) {
349  } else if (isa<ObjCCategoryDecl>(ND)) {
351  } else if (isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) {
352  Contexts = (1LL << CodeCompletionContext::CCC_Namespace);
353 
354  // Part of the nested-name-specifier.
355  IsNestedNameSpecifier = true;
356  }
357 
358  return Contexts;
359 }
360 
361 void ASTUnit::CacheCodeCompletionResults() {
362  if (!TheSema)
363  return;
364 
365  SimpleTimer Timer(WantTiming);
366  Timer.setOutput("Cache global code completions for " + getMainFileName());
367 
368  // Clear out the previous results.
369  ClearCachedCompletionResults();
370 
371  // Gather the set of global code completions.
373  SmallVector<Result, 8> Results;
374  CachedCompletionAllocator = std::make_shared<GlobalCodeCompletionAllocator>();
375  CodeCompletionTUInfo CCTUInfo(CachedCompletionAllocator);
376  TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator,
377  CCTUInfo, Results);
378 
379  // Translate global code completions into cached completions.
380  llvm::DenseMap<CanQualType, unsigned> CompletionTypes;
382 
383  for (auto &R : Results) {
384  switch (R.Kind) {
385  case Result::RK_Declaration: {
386  bool IsNestedNameSpecifier = false;
387  CachedCodeCompletionResult CachedResult;
388  CachedResult.Completion = R.CreateCodeCompletionString(
389  *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,
390  IncludeBriefCommentsInCodeCompletion);
391  CachedResult.ShowInContexts = getDeclShowContexts(
392  R.Declaration, Ctx->getLangOpts(), IsNestedNameSpecifier);
393  CachedResult.Priority = R.Priority;
394  CachedResult.Kind = R.CursorKind;
395  CachedResult.Availability = R.Availability;
396 
397  // Keep track of the type of this completion in an ASTContext-agnostic
398  // way.
399  QualType UsageType = getDeclUsageType(*Ctx, R.Declaration);
400  if (UsageType.isNull()) {
401  CachedResult.TypeClass = STC_Void;
402  CachedResult.Type = 0;
403  } else {
404  CanQualType CanUsageType
405  = Ctx->getCanonicalType(UsageType.getUnqualifiedType());
406  CachedResult.TypeClass = getSimplifiedTypeClass(CanUsageType);
407 
408  // Determine whether we have already seen this type. If so, we save
409  // ourselves the work of formatting the type string by using the
410  // temporary, CanQualType-based hash table to find the associated value.
411  unsigned &TypeValue = CompletionTypes[CanUsageType];
412  if (TypeValue == 0) {
413  TypeValue = CompletionTypes.size();
414  CachedCompletionTypes[QualType(CanUsageType).getAsString()]
415  = TypeValue;
416  }
417 
418  CachedResult.Type = TypeValue;
419  }
420 
421  CachedCompletionResults.push_back(CachedResult);
422 
423  /// Handle nested-name-specifiers in C++.
424  if (TheSema->Context.getLangOpts().CPlusPlus && IsNestedNameSpecifier &&
425  !R.StartsNestedNameSpecifier) {
426  // The contexts in which a nested-name-specifier can appear in C++.
427  uint64_t NNSContexts
440 
441  if (isa<NamespaceDecl>(R.Declaration) ||
442  isa<NamespaceAliasDecl>(R.Declaration))
443  NNSContexts |= (1LL << CodeCompletionContext::CCC_Namespace);
444 
445  if (uint64_t RemainingContexts
446  = NNSContexts & ~CachedResult.ShowInContexts) {
447  // If there any contexts where this completion can be a
448  // nested-name-specifier but isn't already an option, create a
449  // nested-name-specifier completion.
450  R.StartsNestedNameSpecifier = true;
451  CachedResult.Completion = R.CreateCodeCompletionString(
452  *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,
453  IncludeBriefCommentsInCodeCompletion);
454  CachedResult.ShowInContexts = RemainingContexts;
455  CachedResult.Priority = CCP_NestedNameSpecifier;
456  CachedResult.TypeClass = STC_Void;
457  CachedResult.Type = 0;
458  CachedCompletionResults.push_back(CachedResult);
459  }
460  }
461  break;
462  }
463 
464  case Result::RK_Keyword:
465  case Result::RK_Pattern:
466  // Ignore keywords and patterns; we don't care, since they are so
467  // easily regenerated.
468  break;
469 
470  case Result::RK_Macro: {
471  CachedCodeCompletionResult CachedResult;
472  CachedResult.Completion = R.CreateCodeCompletionString(
473  *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,
474  IncludeBriefCommentsInCodeCompletion);
475  CachedResult.ShowInContexts
488 
489  CachedResult.Priority = R.Priority;
490  CachedResult.Kind = R.CursorKind;
491  CachedResult.Availability = R.Availability;
492  CachedResult.TypeClass = STC_Void;
493  CachedResult.Type = 0;
494  CachedCompletionResults.push_back(CachedResult);
495  break;
496  }
497  }
498  }
499 
500  // Save the current top-level hash value.
501  CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue;
502 }
503 
504 void ASTUnit::ClearCachedCompletionResults() {
505  CachedCompletionResults.clear();
506  CachedCompletionTypes.clear();
507  CachedCompletionAllocator = nullptr;
508 }
509 
510 namespace {
511 
512 /// Gathers information from ASTReader that will be used to initialize
513 /// a Preprocessor.
514 class ASTInfoCollector : public ASTReaderListener {
515  Preprocessor &PP;
516  ASTContext *Context;
517  HeaderSearchOptions &HSOpts;
518  PreprocessorOptions &PPOpts;
519  LangOptions &LangOpt;
520  std::shared_ptr<TargetOptions> &TargetOpts;
521  IntrusiveRefCntPtr<TargetInfo> &Target;
522  unsigned &Counter;
523  bool InitializedLanguage = false;
524 
525 public:
526  ASTInfoCollector(Preprocessor &PP, ASTContext *Context,
527  HeaderSearchOptions &HSOpts, PreprocessorOptions &PPOpts,
528  LangOptions &LangOpt,
529  std::shared_ptr<TargetOptions> &TargetOpts,
530  IntrusiveRefCntPtr<TargetInfo> &Target, unsigned &Counter)
531  : PP(PP), Context(Context), HSOpts(HSOpts), PPOpts(PPOpts),
532  LangOpt(LangOpt), TargetOpts(TargetOpts), Target(Target),
533  Counter(Counter) {}
534 
535  bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
536  bool AllowCompatibleDifferences) override {
537  if (InitializedLanguage)
538  return false;
539 
540  LangOpt = LangOpts;
541  InitializedLanguage = true;
542 
543  updated();
544  return false;
545  }
546 
547  bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
548  StringRef SpecificModuleCachePath,
549  bool Complain) override {
550  this->HSOpts = HSOpts;
551  return false;
552  }
553 
554  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain,
555  std::string &SuggestedPredefines) override {
556  this->PPOpts = PPOpts;
557  return false;
558  }
559 
560  bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
561  bool AllowCompatibleDifferences) override {
562  // If we've already initialized the target, don't do it again.
563  if (Target)
564  return false;
565 
566  this->TargetOpts = std::make_shared<TargetOptions>(TargetOpts);
567  Target =
568  TargetInfo::CreateTargetInfo(PP.getDiagnostics(), this->TargetOpts);
569 
570  updated();
571  return false;
572  }
573 
574  void ReadCounter(const serialization::ModuleFile &M,
575  unsigned Value) override {
576  Counter = Value;
577  }
578 
579 private:
580  void updated() {
581  if (!Target || !InitializedLanguage)
582  return;
583 
584  // Inform the target of the language options.
585  //
586  // FIXME: We shouldn't need to do this, the target should be immutable once
587  // created. This complexity should be lifted elsewhere.
588  Target->adjust(LangOpt);
589 
590  // Initialize the preprocessor.
591  PP.Initialize(*Target);
592 
593  if (!Context)
594  return;
595 
596  // Initialize the ASTContext
597  Context->InitBuiltinTypes(*Target);
598 
599  // Adjust printing policy based on language options.
600  Context->setPrintingPolicy(PrintingPolicy(LangOpt));
601 
602  // We didn't have access to the comment options when the ASTContext was
603  // constructed, so register them now.
605  LangOpt.CommentOpts);
606  }
607 };
608 
609 /// Diagnostic consumer that saves each diagnostic it is given.
610 class FilterAndStoreDiagnosticConsumer : public DiagnosticConsumer {
613  bool CaptureNonErrorsFromIncludes = true;
614  const LangOptions *LangOpts = nullptr;
615  SourceManager *SourceMgr = nullptr;
616 
617 public:
618  FilterAndStoreDiagnosticConsumer(
621  bool CaptureNonErrorsFromIncludes)
622  : StoredDiags(StoredDiags), StandaloneDiags(StandaloneDiags),
623  CaptureNonErrorsFromIncludes(CaptureNonErrorsFromIncludes) {
624  assert((StoredDiags || StandaloneDiags) &&
625  "No output collections were passed to StoredDiagnosticConsumer.");
626  }
627 
628  void BeginSourceFile(const LangOptions &LangOpts,
629  const Preprocessor *PP = nullptr) override {
630  this->LangOpts = &LangOpts;
631  if (PP)
632  SourceMgr = &PP->getSourceManager();
633  }
634 
635  void HandleDiagnostic(DiagnosticsEngine::Level Level,
636  const Diagnostic &Info) override;
637 };
638 
639 /// RAII object that optionally captures and filters diagnostics, if
640 /// there is no diagnostic client to capture them already.
641 class CaptureDroppedDiagnostics {
642  DiagnosticsEngine &Diags;
643  FilterAndStoreDiagnosticConsumer Client;
644  DiagnosticConsumer *PreviousClient = nullptr;
645  std::unique_ptr<DiagnosticConsumer> OwningPreviousClient;
646 
647 public:
648  CaptureDroppedDiagnostics(
649  CaptureDiagsKind CaptureDiagnostics, DiagnosticsEngine &Diags,
652  : Diags(Diags),
653  Client(StoredDiags, StandaloneDiags,
654  CaptureDiagnostics !=
656  if (CaptureDiagnostics != CaptureDiagsKind::None ||
657  Diags.getClient() == nullptr) {
658  OwningPreviousClient = Diags.takeClient();
659  PreviousClient = Diags.getClient();
660  Diags.setClient(&Client, false);
661  }
662  }
663 
664  ~CaptureDroppedDiagnostics() {
665  if (Diags.getClient() == &Client)
666  Diags.setClient(PreviousClient, !!OwningPreviousClient.release());
667  }
668 };
669 
670 } // namespace
671 
673 makeStandaloneDiagnostic(const LangOptions &LangOpts,
674  const StoredDiagnostic &InDiag);
675 
676 static bool isInMainFile(const clang::Diagnostic &D) {
677  if (!D.hasSourceManager() || !D.getLocation().isValid())
678  return false;
679 
680  auto &M = D.getSourceManager();
681  return M.isWrittenInMainFile(M.getExpansionLoc(D.getLocation()));
682 }
683 
684 void FilterAndStoreDiagnosticConsumer::HandleDiagnostic(
686  // Default implementation (Warnings/errors count).
688 
689  // Only record the diagnostic if it's part of the source manager we know
690  // about. This effectively drops diagnostics from modules we're building.
691  // FIXME: In the long run, ee don't want to drop source managers from modules.
692  if (!Info.hasSourceManager() || &Info.getSourceManager() == SourceMgr) {
693  if (!CaptureNonErrorsFromIncludes && Level <= DiagnosticsEngine::Warning &&
694  !isInMainFile(Info)) {
695  return;
696  }
697 
698  StoredDiagnostic *ResultDiag = nullptr;
699  if (StoredDiags) {
700  StoredDiags->emplace_back(Level, Info);
701  ResultDiag = &StoredDiags->back();
702  }
703 
704  if (StandaloneDiags) {
706  if (!ResultDiag) {
707  StoredDiag.emplace(Level, Info);
708  ResultDiag = StoredDiag.getPointer();
709  }
710  StandaloneDiags->push_back(
711  makeStandaloneDiagnostic(*LangOpts, *ResultDiag));
712  }
713  }
714 }
715 
717  return Reader;
718 }
719 
721  if (WriterData)
722  return &WriterData->Writer;
723  return nullptr;
724 }
725 
727  if (WriterData)
728  return &WriterData->Writer;
729  return nullptr;
730 }
731 
732 std::unique_ptr<llvm::MemoryBuffer>
733 ASTUnit::getBufferForFile(StringRef Filename, std::string *ErrorStr) {
734  assert(FileMgr);
735  auto Buffer = FileMgr->getBufferForFile(Filename, UserFilesAreVolatile);
736  if (Buffer)
737  return std::move(*Buffer);
738  if (ErrorStr)
739  *ErrorStr = Buffer.getError().message();
740  return nullptr;
741 }
742 
743 /// Configure the diagnostics object for use with ASTUnit.
744 void ASTUnit::ConfigureDiags(IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
745  ASTUnit &AST,
746  CaptureDiagsKind CaptureDiagnostics) {
747  assert(Diags.get() && "no DiagnosticsEngine was provided");
748  if (CaptureDiagnostics != CaptureDiagsKind::None)
749  Diags->setClient(new FilterAndStoreDiagnosticConsumer(
750  &AST.StoredDiagnostics, nullptr,
752 }
753 
754 std::unique_ptr<ASTUnit> ASTUnit::LoadFromASTFile(
755  const std::string &Filename, const PCHContainerReader &PCHContainerRdr,
757  const FileSystemOptions &FileSystemOpts, bool UseDebugInfo,
758  bool OnlyLocalDecls, ArrayRef<RemappedFile> RemappedFiles,
759  CaptureDiagsKind CaptureDiagnostics, bool AllowPCHWithCompilerErrors,
760  bool UserFilesAreVolatile) {
761  std::unique_ptr<ASTUnit> AST(new ASTUnit(true));
762 
763  // Recover resources if we crash before exiting this method.
764  llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
765  ASTUnitCleanup(AST.get());
766  llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
767  llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
768  DiagCleanup(Diags.get());
769 
770  ConfigureDiags(Diags, *AST, CaptureDiagnostics);
771 
772  AST->LangOpts = std::make_shared<LangOptions>();
773  AST->OnlyLocalDecls = OnlyLocalDecls;
774  AST->CaptureDiagnostics = CaptureDiagnostics;
775  AST->Diagnostics = Diags;
777  llvm::vfs::getRealFileSystem();
778  AST->FileMgr = new FileManager(FileSystemOpts, VFS);
779  AST->UserFilesAreVolatile = UserFilesAreVolatile;
780  AST->SourceMgr = new SourceManager(AST->getDiagnostics(),
781  AST->getFileManager(),
782  UserFilesAreVolatile);
783  AST->ModuleCache = new InMemoryModuleCache;
784  AST->HSOpts = std::make_shared<HeaderSearchOptions>();
785  AST->HSOpts->ModuleFormat = PCHContainerRdr.getFormat();
786  AST->HeaderInfo.reset(new HeaderSearch(AST->HSOpts,
787  AST->getSourceManager(),
788  AST->getDiagnostics(),
789  AST->getLangOpts(),
790  /*Target=*/nullptr));
791  AST->PPOpts = std::make_shared<PreprocessorOptions>();
792 
793  for (const auto &RemappedFile : RemappedFiles)
794  AST->PPOpts->addRemappedFile(RemappedFile.first, RemappedFile.second);
795 
796  // Gather Info for preprocessor construction later on.
797 
798  HeaderSearch &HeaderInfo = *AST->HeaderInfo;
799  unsigned Counter;
800 
801  AST->PP = std::make_shared<Preprocessor>(
802  AST->PPOpts, AST->getDiagnostics(), *AST->LangOpts,
803  AST->getSourceManager(), HeaderInfo, AST->ModuleLoader,
804  /*IILookup=*/nullptr,
805  /*OwnsHeaderSearch=*/false);
806  Preprocessor &PP = *AST->PP;
807 
808  if (ToLoad >= LoadASTOnly)
809  AST->Ctx = new ASTContext(*AST->LangOpts, AST->getSourceManager(),
810  PP.getIdentifierTable(), PP.getSelectorTable(),
811  PP.getBuiltinInfo());
812 
813  bool disableValid = false;
814  if (::getenv("LIBCLANG_DISABLE_PCH_VALIDATION"))
815  disableValid = true;
816  AST->Reader = new ASTReader(
817  PP, *AST->ModuleCache, AST->Ctx.get(), PCHContainerRdr, {},
818  /*isysroot=*/"",
819  /*DisableValidation=*/disableValid, AllowPCHWithCompilerErrors);
820 
821  AST->Reader->setListener(llvm::make_unique<ASTInfoCollector>(
822  *AST->PP, AST->Ctx.get(), *AST->HSOpts, *AST->PPOpts, *AST->LangOpts,
823  AST->TargetOpts, AST->Target, Counter));
824 
825  // Attach the AST reader to the AST context as an external AST
826  // source, so that declarations will be deserialized from the
827  // AST file as needed.
828  // We need the external source to be set up before we read the AST, because
829  // eagerly-deserialized declarations may use it.
830  if (AST->Ctx)
831  AST->Ctx->setExternalSource(AST->Reader);
832 
833  switch (AST->Reader->ReadAST(Filename, serialization::MK_MainFile,
835  case ASTReader::Success:
836  break;
837 
838  case ASTReader::Failure:
839  case ASTReader::Missing:
844  AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch);
845  return nullptr;
846  }
847 
848  AST->OriginalSourceFile = AST->Reader->getOriginalSourceFile();
849 
850  PP.setCounterValue(Counter);
851 
852  // Create an AST consumer, even though it isn't used.
853  if (ToLoad >= LoadASTOnly)
854  AST->Consumer.reset(new ASTConsumer);
855 
856  // Create a semantic analysis object and tell the AST reader about it.
857  if (ToLoad >= LoadEverything) {
858  AST->TheSema.reset(new Sema(PP, *AST->Ctx, *AST->Consumer));
859  AST->TheSema->Initialize();
860  AST->Reader->InitializeSema(*AST->TheSema);
861  }
862 
863  // Tell the diagnostic client that we have started a source file.
864  AST->getDiagnostics().getClient()->BeginSourceFile(PP.getLangOpts(), &PP);
865 
866  return AST;
867 }
868 
869 /// Add the given macro to the hash of all top-level entities.
870 static void AddDefinedMacroToHash(const Token &MacroNameTok, unsigned &Hash) {
871  Hash = llvm::djbHash(MacroNameTok.getIdentifierInfo()->getName(), Hash);
872 }
873 
874 namespace {
875 
876 /// Preprocessor callback class that updates a hash value with the names
877 /// of all macros that have been defined by the translation unit.
878 class MacroDefinitionTrackerPPCallbacks : public PPCallbacks {
879  unsigned &Hash;
880 
881 public:
882  explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) {}
883 
884  void MacroDefined(const Token &MacroNameTok,
885  const MacroDirective *MD) override {
886  AddDefinedMacroToHash(MacroNameTok, Hash);
887  }
888 };
889 
890 } // namespace
891 
892 /// Add the given declaration to the hash of all top-level entities.
893 static void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) {
894  if (!D)
895  return;
896 
897  DeclContext *DC = D->getDeclContext();
898  if (!DC)
899  return;
900 
901  if (!(DC->isTranslationUnit() || DC->getLookupParent()->isTranslationUnit()))
902  return;
903 
904  if (const auto *ND = dyn_cast<NamedDecl>(D)) {
905  if (const auto *EnumD = dyn_cast<EnumDecl>(D)) {
906  // For an unscoped enum include the enumerators in the hash since they
907  // enter the top-level namespace.
908  if (!EnumD->isScoped()) {
909  for (const auto *EI : EnumD->enumerators()) {
910  if (EI->getIdentifier())
911  Hash = llvm::djbHash(EI->getIdentifier()->getName(), Hash);
912  }
913  }
914  }
915 
916  if (ND->getIdentifier())
917  Hash = llvm::djbHash(ND->getIdentifier()->getName(), Hash);
918  else if (DeclarationName Name = ND->getDeclName()) {
919  std::string NameStr = Name.getAsString();
920  Hash = llvm::djbHash(NameStr, Hash);
921  }
922  return;
923  }
924 
925  if (const auto *ImportD = dyn_cast<ImportDecl>(D)) {
926  if (const Module *Mod = ImportD->getImportedModule()) {
927  std::string ModName = Mod->getFullModuleName();
928  Hash = llvm::djbHash(ModName, Hash);
929  }
930  return;
931  }
932 }
933 
934 namespace {
935 
936 class TopLevelDeclTrackerConsumer : public ASTConsumer {
937  ASTUnit &Unit;
938  unsigned &Hash;
939 
940 public:
941  TopLevelDeclTrackerConsumer(ASTUnit &_Unit, unsigned &Hash)
942  : Unit(_Unit), Hash(Hash) {
943  Hash = 0;
944  }
945 
946  void handleTopLevelDecl(Decl *D) {
947  if (!D)
948  return;
949 
950  // FIXME: Currently ObjC method declarations are incorrectly being
951  // reported as top-level declarations, even though their DeclContext
952  // is the containing ObjC @interface/@implementation. This is a
953  // fundamental problem in the parser right now.
954  if (isa<ObjCMethodDecl>(D))
955  return;
956 
958  Unit.addTopLevelDecl(D);
959 
960  handleFileLevelDecl(D);
961  }
962 
963  void handleFileLevelDecl(Decl *D) {
964  Unit.addFileLevelDecl(D);
965  if (auto *NSD = dyn_cast<NamespaceDecl>(D)) {
966  for (auto *I : NSD->decls())
967  handleFileLevelDecl(I);
968  }
969  }
970 
971  bool HandleTopLevelDecl(DeclGroupRef D) override {
972  for (auto *TopLevelDecl : D)
973  handleTopLevelDecl(TopLevelDecl);
974  return true;
975  }
976 
977  // We're not interested in "interesting" decls.
978  void HandleInterestingDecl(DeclGroupRef) override {}
979 
980  void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override {
981  for (auto *TopLevelDecl : D)
982  handleTopLevelDecl(TopLevelDecl);
983  }
984 
985  ASTMutationListener *GetASTMutationListener() override {
986  return Unit.getASTMutationListener();
987  }
988 
989  ASTDeserializationListener *GetASTDeserializationListener() override {
990  return Unit.getDeserializationListener();
991  }
992 };
993 
994 class TopLevelDeclTrackerAction : public ASTFrontendAction {
995 public:
996  ASTUnit &Unit;
997 
998  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
999  StringRef InFile) override {
1001  llvm::make_unique<MacroDefinitionTrackerPPCallbacks>(
1002  Unit.getCurrentTopLevelHashValue()));
1003  return llvm::make_unique<TopLevelDeclTrackerConsumer>(
1004  Unit, Unit.getCurrentTopLevelHashValue());
1005  }
1006 
1007 public:
1008  TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {}
1009 
1010  bool hasCodeCompletionSupport() const override { return false; }
1011 
1013  return Unit.getTranslationUnitKind();
1014  }
1015 };
1016 
1017 class ASTUnitPreambleCallbacks : public PreambleCallbacks {
1018 public:
1019  unsigned getHash() const { return Hash; }
1020 
1021  std::vector<Decl *> takeTopLevelDecls() { return std::move(TopLevelDecls); }
1022 
1023  std::vector<serialization::DeclID> takeTopLevelDeclIDs() {
1024  return std::move(TopLevelDeclIDs);
1025  }
1026 
1027  void AfterPCHEmitted(ASTWriter &Writer) override {
1028  TopLevelDeclIDs.reserve(TopLevelDecls.size());
1029  for (const auto *D : TopLevelDecls) {
1030  // Invalid top-level decls may not have been serialized.
1031  if (D->isInvalidDecl())
1032  continue;
1033  TopLevelDeclIDs.push_back(Writer.getDeclID(D));
1034  }
1035  }
1036 
1037  void HandleTopLevelDecl(DeclGroupRef DG) override {
1038  for (auto *D : DG) {
1039  // FIXME: Currently ObjC method declarations are incorrectly being
1040  // reported as top-level declarations, even though their DeclContext
1041  // is the containing ObjC @interface/@implementation. This is a
1042  // fundamental problem in the parser right now.
1043  if (isa<ObjCMethodDecl>(D))
1044  continue;
1046  TopLevelDecls.push_back(D);
1047  }
1048  }
1049 
1050  std::unique_ptr<PPCallbacks> createPPCallbacks() override {
1051  return llvm::make_unique<MacroDefinitionTrackerPPCallbacks>(Hash);
1052  }
1053 
1054 private:
1055  unsigned Hash = 0;
1056  std::vector<Decl *> TopLevelDecls;
1057  std::vector<serialization::DeclID> TopLevelDeclIDs;
1059 };
1060 
1061 } // namespace
1062 
1063 static bool isNonDriverDiag(const StoredDiagnostic &StoredDiag) {
1064  return StoredDiag.getLocation().isValid();
1065 }
1066 
1067 static void
1069  // Get rid of stored diagnostics except the ones from the driver which do not
1070  // have a source location.
1071  StoredDiags.erase(
1072  std::remove_if(StoredDiags.begin(), StoredDiags.end(), isNonDriverDiag),
1073  StoredDiags.end());
1074 }
1075 
1077  StoredDiagnostics,
1078  SourceManager &SM) {
1079  // The stored diagnostic has the old source manager in it; update
1080  // the locations to refer into the new source manager. Since we've
1081  // been careful to make sure that the source manager's state
1082  // before and after are identical, so that we can reuse the source
1083  // location itself.
1084  for (auto &SD : StoredDiagnostics) {
1085  if (SD.getLocation().isValid()) {
1086  FullSourceLoc Loc(SD.getLocation(), SM);
1087  SD.setLocation(Loc);
1088  }
1089  }
1090 }
1091 
1092 /// Parse the source file into a translation unit using the given compiler
1093 /// invocation, replacing the current translation unit.
1094 ///
1095 /// \returns True if a failure occurred that causes the ASTUnit not to
1096 /// contain any translation-unit information, false otherwise.
1097 bool ASTUnit::Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1098  std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer,
1100  if (!Invocation)
1101  return true;
1102 
1103  if (VFS && FileMgr)
1104  assert(VFS == &FileMgr->getVirtualFileSystem() &&
1105  "VFS passed to Parse and VFS in FileMgr are different");
1106 
1107  auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);
1108  if (OverrideMainBuffer) {
1109  assert(Preamble &&
1110  "No preamble was built, but OverrideMainBuffer is not null");
1111  Preamble->AddImplicitPreamble(*CCInvocation, VFS, OverrideMainBuffer.get());
1112  // VFS may have changed...
1113  }
1114 
1115  // Create the compiler instance to use for building the AST.
1116  std::unique_ptr<CompilerInstance> Clang(
1117  new CompilerInstance(std::move(PCHContainerOps)));
1118 
1119  // Ensure that Clang has a FileManager with the right VFS, which may have
1120  // changed above in AddImplicitPreamble. If VFS is nullptr, rely on
1121  // createFileManager to create one.
1122  if (VFS && FileMgr && &FileMgr->getVirtualFileSystem() == VFS)
1123  Clang->setFileManager(&*FileMgr);
1124  else
1125  FileMgr = Clang->createFileManager(std::move(VFS));
1126 
1127  // Recover resources if we crash before exiting this method.
1128  llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
1129  CICleanup(Clang.get());
1130 
1131  Clang->setInvocation(CCInvocation);
1132  OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile();
1133 
1134  // Set up diagnostics, capturing any diagnostics that would
1135  // otherwise be dropped.
1136  Clang->setDiagnostics(&getDiagnostics());
1137 
1138  // Create the target instance.
1139  Clang->setTarget(TargetInfo::CreateTargetInfo(
1140  Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
1141  if (!Clang->hasTarget())
1142  return true;
1143 
1144  // Inform the target of the language options.
1145  //
1146  // FIXME: We shouldn't need to do this, the target should be immutable once
1147  // created. This complexity should be lifted elsewhere.
1148  Clang->getTarget().adjust(Clang->getLangOpts());
1149 
1150  assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
1151  "Invocation must have exactly one source file!");
1152  assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
1154  "FIXME: AST inputs not yet supported here!");
1155  assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
1157  "IR inputs not support here!");
1158 
1159  // Configure the various subsystems.
1160  LangOpts = Clang->getInvocation().LangOpts;
1161  FileSystemOpts = Clang->getFileSystemOpts();
1162 
1163  ResetForParse();
1164 
1165  SourceMgr = new SourceManager(getDiagnostics(), *FileMgr,
1166  UserFilesAreVolatile);
1167  if (!OverrideMainBuffer) {
1168  checkAndRemoveNonDriverDiags(StoredDiagnostics);
1169  TopLevelDeclsInPreamble.clear();
1170  }
1171 
1172  // Create a file manager object to provide access to and cache the filesystem.
1173  Clang->setFileManager(&getFileManager());
1174 
1175  // Create the source manager.
1176  Clang->setSourceManager(&getSourceManager());
1177 
1178  // If the main file has been overridden due to the use of a preamble,
1179  // make that override happen and introduce the preamble.
1180  if (OverrideMainBuffer) {
1181  // The stored diagnostic has the old source manager in it; update
1182  // the locations to refer into the new source manager. Since we've
1183  // been careful to make sure that the source manager's state
1184  // before and after are identical, so that we can reuse the source
1185  // location itself.
1186  checkAndSanitizeDiags(StoredDiagnostics, getSourceManager());
1187 
1188  // Keep track of the override buffer;
1189  SavedMainFileBuffer = std::move(OverrideMainBuffer);
1190  }
1191 
1192  std::unique_ptr<TopLevelDeclTrackerAction> Act(
1193  new TopLevelDeclTrackerAction(*this));
1194 
1195  // Recover resources if we crash before exiting this method.
1196  llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
1197  ActCleanup(Act.get());
1198 
1199  if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0]))
1200  goto error;
1201 
1202  if (SavedMainFileBuffer)
1203  TranslateStoredDiagnostics(getFileManager(), getSourceManager(),
1204  PreambleDiagnostics, StoredDiagnostics);
1205  else
1206  PreambleSrcLocCache.clear();
1207 
1208  if (llvm::Error Err = Act->Execute()) {
1209  consumeError(std::move(Err)); // FIXME this drops errors on the floor.
1210  goto error;
1211  }
1212 
1213  transferASTDataFromCompilerInstance(*Clang);
1214 
1215  Act->EndSourceFile();
1216 
1217  FailedParseDiagnostics.clear();
1218 
1219  return false;
1220 
1221 error:
1222  // Remove the overridden buffer we used for the preamble.
1223  SavedMainFileBuffer = nullptr;
1224 
1225  // Keep the ownership of the data in the ASTUnit because the client may
1226  // want to see the diagnostics.
1227  transferASTDataFromCompilerInstance(*Clang);
1228  FailedParseDiagnostics.swap(StoredDiagnostics);
1229  StoredDiagnostics.clear();
1230  NumStoredDiagnosticsFromDriver = 0;
1231  return true;
1232 }
1233 
1234 static std::pair<unsigned, unsigned>
1236  const LangOptions &LangOpts) {
1237  CharSourceRange FileRange = Lexer::makeFileCharRange(Range, SM, LangOpts);
1238  unsigned Offset = SM.getFileOffset(FileRange.getBegin());
1239  unsigned EndOffset = SM.getFileOffset(FileRange.getEnd());
1240  return std::make_pair(Offset, EndOffset);
1241 }
1242 
1244  const LangOptions &LangOpts,
1245  const FixItHint &InFix) {
1246  ASTUnit::StandaloneFixIt OutFix;
1247  OutFix.RemoveRange = makeStandaloneRange(InFix.RemoveRange, SM, LangOpts);
1249  LangOpts);
1250  OutFix.CodeToInsert = InFix.CodeToInsert;
1252  return OutFix;
1253 }
1254 
1257  const StoredDiagnostic &InDiag) {
1259  OutDiag.ID = InDiag.getID();
1260  OutDiag.Level = InDiag.getLevel();
1261  OutDiag.Message = InDiag.getMessage();
1262  OutDiag.LocOffset = 0;
1263  if (InDiag.getLocation().isInvalid())
1264  return OutDiag;
1265  const SourceManager &SM = InDiag.getLocation().getManager();
1266  SourceLocation FileLoc = SM.getFileLoc(InDiag.getLocation());
1267  OutDiag.Filename = SM.getFilename(FileLoc);
1268  if (OutDiag.Filename.empty())
1269  return OutDiag;
1270  OutDiag.LocOffset = SM.getFileOffset(FileLoc);
1271  for (const auto &Range : InDiag.getRanges())
1272  OutDiag.Ranges.push_back(makeStandaloneRange(Range, SM, LangOpts));
1273  for (const auto &FixIt : InDiag.getFixIts())
1274  OutDiag.FixIts.push_back(makeStandaloneFixIt(SM, LangOpts, FixIt));
1275 
1276  return OutDiag;
1277 }
1278 
1279 /// Attempt to build or re-use a precompiled preamble when (re-)parsing
1280 /// the source file.
1281 ///
1282 /// This routine will compute the preamble of the main source file. If a
1283 /// non-trivial preamble is found, it will precompile that preamble into a
1284 /// precompiled header so that the precompiled preamble can be used to reduce
1285 /// reparsing time. If a precompiled preamble has already been constructed,
1286 /// this routine will determine if it is still valid and, if so, avoid
1287 /// rebuilding the precompiled preamble.
1288 ///
1289 /// \param AllowRebuild When true (the default), this routine is
1290 /// allowed to rebuild the precompiled preamble if it is found to be
1291 /// out-of-date.
1292 ///
1293 /// \param MaxLines When non-zero, the maximum number of lines that
1294 /// can occur within the preamble.
1295 ///
1296 /// \returns If the precompiled preamble can be used, returns a newly-allocated
1297 /// buffer that should be used in place of the main file when doing so.
1298 /// Otherwise, returns a NULL pointer.
1299 std::unique_ptr<llvm::MemoryBuffer>
1300 ASTUnit::getMainBufferWithPrecompiledPreamble(
1301  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1302  CompilerInvocation &PreambleInvocationIn,
1303  IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS, bool AllowRebuild,
1304  unsigned MaxLines) {
1305  auto MainFilePath =
1306  PreambleInvocationIn.getFrontendOpts().Inputs[0].getFile();
1307  std::unique_ptr<llvm::MemoryBuffer> MainFileBuffer =
1308  getBufferForFileHandlingRemapping(PreambleInvocationIn, VFS.get(),
1309  MainFilePath, UserFilesAreVolatile);
1310  if (!MainFileBuffer)
1311  return nullptr;
1312 
1313  PreambleBounds Bounds =
1314  ComputePreambleBounds(*PreambleInvocationIn.getLangOpts(),
1315  MainFileBuffer.get(), MaxLines);
1316  if (!Bounds.Size)
1317  return nullptr;
1318 
1319  if (Preamble) {
1320  if (Preamble->CanReuse(PreambleInvocationIn, MainFileBuffer.get(), Bounds,
1321  VFS.get())) {
1322  // Okay! We can re-use the precompiled preamble.
1323 
1324  // Set the state of the diagnostic object to mimic its state
1325  // after parsing the preamble.
1326  getDiagnostics().Reset();
1328  PreambleInvocationIn.getDiagnosticOpts());
1329  getDiagnostics().setNumWarnings(NumWarningsInPreamble);
1330 
1331  PreambleRebuildCountdown = 1;
1332  return MainFileBuffer;
1333  } else {
1334  Preamble.reset();
1335  PreambleDiagnostics.clear();
1336  TopLevelDeclsInPreamble.clear();
1337  PreambleSrcLocCache.clear();
1338  PreambleRebuildCountdown = 1;
1339  }
1340  }
1341 
1342  // If the preamble rebuild counter > 1, it's because we previously
1343  // failed to build a preamble and we're not yet ready to try
1344  // again. Decrement the counter and return a failure.
1345  if (PreambleRebuildCountdown > 1) {
1346  --PreambleRebuildCountdown;
1347  return nullptr;
1348  }
1349 
1350  assert(!Preamble && "No Preamble should be stored at that point");
1351  // If we aren't allowed to rebuild the precompiled preamble, just
1352  // return now.
1353  if (!AllowRebuild)
1354  return nullptr;
1355 
1356  ++PreambleCounter;
1357 
1358  SmallVector<StandaloneDiagnostic, 4> NewPreambleDiagsStandalone;
1359  SmallVector<StoredDiagnostic, 4> NewPreambleDiags;
1360  ASTUnitPreambleCallbacks Callbacks;
1361  {
1363  if (CaptureDiagnostics != CaptureDiagsKind::None)
1364  Capture.emplace(CaptureDiagnostics, *Diagnostics, &NewPreambleDiags,
1365  &NewPreambleDiagsStandalone);
1366 
1367  // We did not previously compute a preamble, or it can't be reused anyway.
1368  SimpleTimer PreambleTimer(WantTiming);
1369  PreambleTimer.setOutput("Precompiling preamble");
1370 
1371  const bool PreviousSkipFunctionBodies =
1372  PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies;
1373  if (SkipFunctionBodies == SkipFunctionBodiesScope::Preamble)
1374  PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies = true;
1375 
1376  llvm::ErrorOr<PrecompiledPreamble> NewPreamble = PrecompiledPreamble::Build(
1377  PreambleInvocationIn, MainFileBuffer.get(), Bounds, *Diagnostics, VFS,
1378  PCHContainerOps, /*StoreInMemory=*/false, Callbacks);
1379 
1380  PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies =
1381  PreviousSkipFunctionBodies;
1382 
1383  if (NewPreamble) {
1384  Preamble = std::move(*NewPreamble);
1385  PreambleRebuildCountdown = 1;
1386  } else {
1387  switch (static_cast<BuildPreambleError>(NewPreamble.getError().value())) {
1389  // Try again next time.
1390  PreambleRebuildCountdown = 1;
1391  return nullptr;
1396  // These erros are more likely to repeat, retry after some period.
1397  PreambleRebuildCountdown = DefaultPreambleRebuildInterval;
1398  return nullptr;
1399  }
1400  llvm_unreachable("unexpected BuildPreambleError");
1401  }
1402  }
1403 
1404  assert(Preamble && "Preamble wasn't built");
1405 
1406  TopLevelDecls.clear();
1407  TopLevelDeclsInPreamble = Callbacks.takeTopLevelDeclIDs();
1408  PreambleTopLevelHashValue = Callbacks.getHash();
1409 
1410  NumWarningsInPreamble = getDiagnostics().getNumWarnings();
1411 
1412  checkAndRemoveNonDriverDiags(NewPreambleDiags);
1413  StoredDiagnostics = std::move(NewPreambleDiags);
1414  PreambleDiagnostics = std::move(NewPreambleDiagsStandalone);
1415 
1416  // If the hash of top-level entities differs from the hash of the top-level
1417  // entities the last time we rebuilt the preamble, clear out the completion
1418  // cache.
1419  if (CurrentTopLevelHashValue != PreambleTopLevelHashValue) {
1420  CompletionCacheTopLevelHashValue = 0;
1421  PreambleTopLevelHashValue = CurrentTopLevelHashValue;
1422  }
1423 
1424  return MainFileBuffer;
1425 }
1426 
1427 void ASTUnit::RealizeTopLevelDeclsFromPreamble() {
1428  assert(Preamble && "Should only be called when preamble was built");
1429 
1430  std::vector<Decl *> Resolved;
1431  Resolved.reserve(TopLevelDeclsInPreamble.size());
1433  for (const auto TopLevelDecl : TopLevelDeclsInPreamble) {
1434  // Resolve the declaration ID to an actual declaration, possibly
1435  // deserializing the declaration in the process.
1436  if (Decl *D = Source.GetExternalDecl(TopLevelDecl))
1437  Resolved.push_back(D);
1438  }
1439  TopLevelDeclsInPreamble.clear();
1440  TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end());
1441 }
1442 
1443 void ASTUnit::transferASTDataFromCompilerInstance(CompilerInstance &CI) {
1444  // Steal the created target, context, and preprocessor if they have been
1445  // created.
1446  assert(CI.hasInvocation() && "missing invocation");
1447  LangOpts = CI.getInvocation().LangOpts;
1448  TheSema = CI.takeSema();
1449  Consumer = CI.takeASTConsumer();
1450  if (CI.hasASTContext())
1451  Ctx = &CI.getASTContext();
1452  if (CI.hasPreprocessor())
1453  PP = CI.getPreprocessorPtr();
1454  CI.setSourceManager(nullptr);
1455  CI.setFileManager(nullptr);
1456  if (CI.hasTarget())
1457  Target = &CI.getTarget();
1458  Reader = CI.getModuleManager();
1459  HadModuleLoaderFatalFailure = CI.hadModuleLoaderFatalFailure();
1460 }
1461 
1462 StringRef ASTUnit::getMainFileName() const {
1463  if (Invocation && !Invocation->getFrontendOpts().Inputs.empty()) {
1464  const FrontendInputFile &Input = Invocation->getFrontendOpts().Inputs[0];
1465  if (Input.isFile())
1466  return Input.getFile();
1467  else
1468  return Input.getBuffer()->getBufferIdentifier();
1469  }
1470 
1471  if (SourceMgr) {
1472  if (const FileEntry *
1473  FE = SourceMgr->getFileEntryForID(SourceMgr->getMainFileID()))
1474  return FE->getName();
1475  }
1476 
1477  return {};
1478 }
1479 
1480 StringRef ASTUnit::getASTFileName() const {
1481  if (!isMainFileAST())
1482  return {};
1483 
1485  Mod = Reader->getModuleManager().getPrimaryModule();
1486  return Mod.FileName;
1487 }
1488 
1489 std::unique_ptr<ASTUnit>
1490 ASTUnit::create(std::shared_ptr<CompilerInvocation> CI,
1492  CaptureDiagsKind CaptureDiagnostics,
1493  bool UserFilesAreVolatile) {
1494  std::unique_ptr<ASTUnit> AST(new ASTUnit(false));
1495  ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1497  createVFSFromCompilerInvocation(*CI, *Diags);
1498  AST->Diagnostics = Diags;
1499  AST->FileSystemOpts = CI->getFileSystemOpts();
1500  AST->Invocation = std::move(CI);
1501  AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS);
1502  AST->UserFilesAreVolatile = UserFilesAreVolatile;
1503  AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr,
1504  UserFilesAreVolatile);
1505  AST->ModuleCache = new InMemoryModuleCache;
1506 
1507  return AST;
1508 }
1509 
1511  std::shared_ptr<CompilerInvocation> CI,
1512  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1514  ASTUnit *Unit, bool Persistent, StringRef ResourceFilesPath,
1515  bool OnlyLocalDecls, CaptureDiagsKind CaptureDiagnostics,
1516  unsigned PrecompilePreambleAfterNParses, bool CacheCodeCompletionResults,
1517  bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile,
1518  std::unique_ptr<ASTUnit> *ErrAST) {
1519  assert(CI && "A CompilerInvocation is required");
1520 
1521  std::unique_ptr<ASTUnit> OwnAST;
1522  ASTUnit *AST = Unit;
1523  if (!AST) {
1524  // Create the AST unit.
1525  OwnAST = create(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile);
1526  AST = OwnAST.get();
1527  if (!AST)
1528  return nullptr;
1529  }
1530 
1531  if (!ResourceFilesPath.empty()) {
1532  // Override the resources path.
1533  CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
1534  }
1535  AST->OnlyLocalDecls = OnlyLocalDecls;
1536  AST->CaptureDiagnostics = CaptureDiagnostics;
1537  if (PrecompilePreambleAfterNParses > 0)
1538  AST->PreambleRebuildCountdown = PrecompilePreambleAfterNParses;
1539  AST->TUKind = Action ? Action->getTranslationUnitKind() : TU_Complete;
1540  AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1541  AST->IncludeBriefCommentsInCodeCompletion
1542  = IncludeBriefCommentsInCodeCompletion;
1543 
1544  // Recover resources if we crash before exiting this method.
1545  llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1546  ASTUnitCleanup(OwnAST.get());
1547  llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
1548  llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
1549  DiagCleanup(Diags.get());
1550 
1551  // We'll manage file buffers ourselves.
1552  CI->getPreprocessorOpts().RetainRemappedFileBuffers = true;
1553  CI->getFrontendOpts().DisableFree = false;
1554  ProcessWarningOptions(AST->getDiagnostics(), CI->getDiagnosticOpts());
1555 
1556  // Create the compiler instance to use for building the AST.
1557  std::unique_ptr<CompilerInstance> Clang(
1558  new CompilerInstance(std::move(PCHContainerOps)));
1559 
1560  // Recover resources if we crash before exiting this method.
1561  llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
1562  CICleanup(Clang.get());
1563 
1564  Clang->setInvocation(std::move(CI));
1565  AST->OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile();
1566 
1567  // Set up diagnostics, capturing any diagnostics that would
1568  // otherwise be dropped.
1569  Clang->setDiagnostics(&AST->getDiagnostics());
1570 
1571  // Create the target instance.
1572  Clang->setTarget(TargetInfo::CreateTargetInfo(
1573  Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
1574  if (!Clang->hasTarget())
1575  return nullptr;
1576 
1577  // Inform the target of the language options.
1578  //
1579  // FIXME: We shouldn't need to do this, the target should be immutable once
1580  // created. This complexity should be lifted elsewhere.
1581  Clang->getTarget().adjust(Clang->getLangOpts());
1582 
1583  assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
1584  "Invocation must have exactly one source file!");
1585  assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
1587  "FIXME: AST inputs not yet supported here!");
1588  assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
1590  "IR inputs not support here!");
1591 
1592  // Configure the various subsystems.
1593  AST->TheSema.reset();
1594  AST->Ctx = nullptr;
1595  AST->PP = nullptr;
1596  AST->Reader = nullptr;
1597 
1598  // Create a file manager object to provide access to and cache the filesystem.
1599  Clang->setFileManager(&AST->getFileManager());
1600 
1601  // Create the source manager.
1602  Clang->setSourceManager(&AST->getSourceManager());
1603 
1604  FrontendAction *Act = Action;
1605 
1606  std::unique_ptr<TopLevelDeclTrackerAction> TrackerAct;
1607  if (!Act) {
1608  TrackerAct.reset(new TopLevelDeclTrackerAction(*AST));
1609  Act = TrackerAct.get();
1610  }
1611 
1612  // Recover resources if we crash before exiting this method.
1613  llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
1614  ActCleanup(TrackerAct.get());
1615 
1616  if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
1617  AST->transferASTDataFromCompilerInstance(*Clang);
1618  if (OwnAST && ErrAST)
1619  ErrAST->swap(OwnAST);
1620 
1621  return nullptr;
1622  }
1623 
1624  if (Persistent && !TrackerAct) {
1625  Clang->getPreprocessor().addPPCallbacks(
1626  llvm::make_unique<MacroDefinitionTrackerPPCallbacks>(
1627  AST->getCurrentTopLevelHashValue()));
1628  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
1629  if (Clang->hasASTConsumer())
1630  Consumers.push_back(Clang->takeASTConsumer());
1631  Consumers.push_back(llvm::make_unique<TopLevelDeclTrackerConsumer>(
1632  *AST, AST->getCurrentTopLevelHashValue()));
1633  Clang->setASTConsumer(
1634  llvm::make_unique<MultiplexConsumer>(std::move(Consumers)));
1635  }
1636  if (llvm::Error Err = Act->Execute()) {
1637  consumeError(std::move(Err)); // FIXME this drops errors on the floor.
1638  AST->transferASTDataFromCompilerInstance(*Clang);
1639  if (OwnAST && ErrAST)
1640  ErrAST->swap(OwnAST);
1641 
1642  return nullptr;
1643  }
1644 
1645  // Steal the created target, context, and preprocessor.
1646  AST->transferASTDataFromCompilerInstance(*Clang);
1647 
1648  Act->EndSourceFile();
1649 
1650  if (OwnAST)
1651  return OwnAST.release();
1652  else
1653  return AST;
1654 }
1655 
1656 bool ASTUnit::LoadFromCompilerInvocation(
1657  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1658  unsigned PrecompilePreambleAfterNParses,
1660  if (!Invocation)
1661  return true;
1662 
1663  assert(VFS && "VFS is null");
1664 
1665  // We'll manage file buffers ourselves.
1666  Invocation->getPreprocessorOpts().RetainRemappedFileBuffers = true;
1667  Invocation->getFrontendOpts().DisableFree = false;
1668  getDiagnostics().Reset();
1669  ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
1670 
1671  std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
1672  if (PrecompilePreambleAfterNParses > 0) {
1673  PreambleRebuildCountdown = PrecompilePreambleAfterNParses;
1674  OverrideMainBuffer =
1675  getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);
1676  getDiagnostics().Reset();
1677  ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
1678  }
1679 
1680  SimpleTimer ParsingTimer(WantTiming);
1681  ParsingTimer.setOutput("Parsing " + getMainFileName());
1682 
1683  // Recover resources if we crash before exiting this method.
1684  llvm::CrashRecoveryContextCleanupRegistrar<llvm::MemoryBuffer>
1685  MemBufferCleanup(OverrideMainBuffer.get());
1686 
1687  return Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
1688 }
1689 
1690 std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation(
1691  std::shared_ptr<CompilerInvocation> CI,
1692  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1694  bool OnlyLocalDecls, CaptureDiagsKind CaptureDiagnostics,
1695  unsigned PrecompilePreambleAfterNParses, TranslationUnitKind TUKind,
1696  bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion,
1697  bool UserFilesAreVolatile) {
1698  // Create the AST unit.
1699  std::unique_ptr<ASTUnit> AST(new ASTUnit(false));
1700  ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1701  AST->Diagnostics = Diags;
1702  AST->OnlyLocalDecls = OnlyLocalDecls;
1703  AST->CaptureDiagnostics = CaptureDiagnostics;
1704  AST->TUKind = TUKind;
1705  AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1706  AST->IncludeBriefCommentsInCodeCompletion
1707  = IncludeBriefCommentsInCodeCompletion;
1708  AST->Invocation = std::move(CI);
1709  AST->FileSystemOpts = FileMgr->getFileSystemOpts();
1710  AST->FileMgr = FileMgr;
1711  AST->UserFilesAreVolatile = UserFilesAreVolatile;
1712 
1713  // Recover resources if we crash before exiting this method.
1714  llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1715  ASTUnitCleanup(AST.get());
1716  llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
1717  llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
1718  DiagCleanup(Diags.get());
1719 
1720  if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
1721  PrecompilePreambleAfterNParses,
1722  &AST->FileMgr->getVirtualFileSystem()))
1723  return nullptr;
1724  return AST;
1725 }
1726 
1728  const char **ArgBegin, const char **ArgEnd,
1729  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1730  IntrusiveRefCntPtr<DiagnosticsEngine> Diags, StringRef ResourceFilesPath,
1731  bool OnlyLocalDecls, CaptureDiagsKind CaptureDiagnostics,
1732  ArrayRef<RemappedFile> RemappedFiles, bool RemappedFilesKeepOriginalName,
1733  unsigned PrecompilePreambleAfterNParses, TranslationUnitKind TUKind,
1734  bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion,
1735  bool AllowPCHWithCompilerErrors, SkipFunctionBodiesScope SkipFunctionBodies,
1736  bool SingleFileParse, bool UserFilesAreVolatile, bool ForSerialization,
1737  llvm::Optional<StringRef> ModuleFormat, std::unique_ptr<ASTUnit> *ErrAST,
1739  assert(Diags.get() && "no DiagnosticsEngine was provided");
1740 
1741  SmallVector<StoredDiagnostic, 4> StoredDiagnostics;
1742 
1743  std::shared_ptr<CompilerInvocation> CI;
1744 
1745  {
1746  CaptureDroppedDiagnostics Capture(CaptureDiagnostics, *Diags,
1747  &StoredDiagnostics, nullptr);
1748 
1750  llvm::makeArrayRef(ArgBegin, ArgEnd), Diags, VFS);
1751  if (!CI)
1752  return nullptr;
1753  }
1754 
1755  // Override any files that need remapping
1756  for (const auto &RemappedFile : RemappedFiles) {
1757  CI->getPreprocessorOpts().addRemappedFile(RemappedFile.first,
1758  RemappedFile.second);
1759  }
1760  PreprocessorOptions &PPOpts = CI->getPreprocessorOpts();
1761  PPOpts.RemappedFilesKeepOriginalName = RemappedFilesKeepOriginalName;
1762  PPOpts.AllowPCHWithCompilerErrors = AllowPCHWithCompilerErrors;
1763  PPOpts.SingleFileParseMode = SingleFileParse;
1764 
1765  // Override the resources path.
1766  CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
1767 
1768  CI->getFrontendOpts().SkipFunctionBodies =
1769  SkipFunctionBodies == SkipFunctionBodiesScope::PreambleAndMainFile;
1770 
1771  if (ModuleFormat)
1772  CI->getHeaderSearchOpts().ModuleFormat = ModuleFormat.getValue();
1773 
1774  // Create the AST unit.
1775  std::unique_ptr<ASTUnit> AST;
1776  AST.reset(new ASTUnit(false));
1777  AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size();
1778  AST->StoredDiagnostics.swap(StoredDiagnostics);
1779  ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1780  AST->Diagnostics = Diags;
1781  AST->FileSystemOpts = CI->getFileSystemOpts();
1782  if (!VFS)
1783  VFS = llvm::vfs::getRealFileSystem();
1784  VFS = createVFSFromCompilerInvocation(*CI, *Diags, VFS);
1785  AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS);
1786  AST->ModuleCache = new InMemoryModuleCache;
1787  AST->OnlyLocalDecls = OnlyLocalDecls;
1788  AST->CaptureDiagnostics = CaptureDiagnostics;
1789  AST->TUKind = TUKind;
1790  AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1791  AST->IncludeBriefCommentsInCodeCompletion
1792  = IncludeBriefCommentsInCodeCompletion;
1793  AST->UserFilesAreVolatile = UserFilesAreVolatile;
1794  AST->Invocation = CI;
1795  AST->SkipFunctionBodies = SkipFunctionBodies;
1796  if (ForSerialization)
1797  AST->WriterData.reset(new ASTWriterData(*AST->ModuleCache));
1798  // Zero out now to ease cleanup during crash recovery.
1799  CI = nullptr;
1800  Diags = nullptr;
1801 
1802  // Recover resources if we crash before exiting this method.
1803  llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1804  ASTUnitCleanup(AST.get());
1805 
1806  if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
1807  PrecompilePreambleAfterNParses,
1808  VFS)) {
1809  // Some error occurred, if caller wants to examine diagnostics, pass it the
1810  // ASTUnit.
1811  if (ErrAST) {
1812  AST->StoredDiagnostics.swap(AST->FailedParseDiagnostics);
1813  ErrAST->swap(AST);
1814  }
1815  return nullptr;
1816  }
1817 
1818  return AST.release();
1819 }
1820 
1821 bool ASTUnit::Reparse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1822  ArrayRef<RemappedFile> RemappedFiles,
1824  if (!Invocation)
1825  return true;
1826 
1827  if (!VFS) {
1828  assert(FileMgr && "FileMgr is null on Reparse call");
1829  VFS = &FileMgr->getVirtualFileSystem();
1830  }
1831 
1832  clearFileLevelDecls();
1833 
1834  SimpleTimer ParsingTimer(WantTiming);
1835  ParsingTimer.setOutput("Reparsing " + getMainFileName());
1836 
1837  // Remap files.
1838  PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1839  for (const auto &RB : PPOpts.RemappedFileBuffers)
1840  delete RB.second;
1841 
1842  Invocation->getPreprocessorOpts().clearRemappedFiles();
1843  for (const auto &RemappedFile : RemappedFiles) {
1844  Invocation->getPreprocessorOpts().addRemappedFile(RemappedFile.first,
1845  RemappedFile.second);
1846  }
1847 
1848  // If we have a preamble file lying around, or if we might try to
1849  // build a precompiled preamble, do so now.
1850  std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
1851  if (Preamble || PreambleRebuildCountdown > 0)
1852  OverrideMainBuffer =
1853  getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);
1854 
1855  // Clear out the diagnostics state.
1856  FileMgr.reset();
1857  getDiagnostics().Reset();
1858  ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
1859  if (OverrideMainBuffer)
1860  getDiagnostics().setNumWarnings(NumWarningsInPreamble);
1861 
1862  // Parse the sources
1863  bool Result =
1864  Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
1865 
1866  // If we're caching global code-completion results, and the top-level
1867  // declarations have changed, clear out the code-completion cache.
1868  if (!Result && ShouldCacheCodeCompletionResults &&
1869  CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue)
1870  CacheCodeCompletionResults();
1871 
1872  // We now need to clear out the completion info related to this translation
1873  // unit; it'll be recreated if necessary.
1874  CCTUInfo.reset();
1875 
1876  return Result;
1877 }
1878 
1880  SavedMainFileBuffer.reset();
1881 
1882  SourceMgr.reset();
1883  TheSema.reset();
1884  Ctx.reset();
1885  PP.reset();
1886  Reader.reset();
1887 
1888  TopLevelDecls.clear();
1889  clearFileLevelDecls();
1890 }
1891 
1892 //----------------------------------------------------------------------------//
1893 // Code completion
1894 //----------------------------------------------------------------------------//
1895 
1896 namespace {
1897 
1898  /// Code completion consumer that combines the cached code-completion
1899  /// results from an ASTUnit with the code-completion results provided to it,
1900  /// then passes the result on to
1901  class AugmentedCodeCompleteConsumer : public CodeCompleteConsumer {
1902  uint64_t NormalContexts;
1903  ASTUnit &AST;
1904  CodeCompleteConsumer &Next;
1905 
1906  public:
1907  AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next,
1908  const CodeCompleteOptions &CodeCompleteOpts)
1909  : CodeCompleteConsumer(CodeCompleteOpts), AST(AST), Next(Next) {
1910  // Compute the set of contexts in which we will look when we don't have
1911  // any information about the specific context.
1912  NormalContexts
1926 
1927  if (AST.getASTContext().getLangOpts().CPlusPlus)
1928  NormalContexts |= (1LL << CodeCompletionContext::CCC_EnumTag)
1931  }
1932 
1933  void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context,
1934  CodeCompletionResult *Results,
1935  unsigned NumResults) override;
1936 
1937  void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
1938  OverloadCandidate *Candidates,
1939  unsigned NumCandidates,
1940  SourceLocation OpenParLoc) override {
1941  Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates,
1942  OpenParLoc);
1943  }
1944 
1945  CodeCompletionAllocator &getAllocator() override {
1946  return Next.getAllocator();
1947  }
1948 
1950  return Next.getCodeCompletionTUInfo();
1951  }
1952  };
1953 
1954 } // namespace
1955 
1956 /// Helper function that computes which global names are hidden by the
1957 /// local code-completion results.
1958 static void CalculateHiddenNames(const CodeCompletionContext &Context,
1959  CodeCompletionResult *Results,
1960  unsigned NumResults,
1961  ASTContext &Ctx,
1962  llvm::StringSet<llvm::BumpPtrAllocator> &HiddenNames){
1963  bool OnlyTagNames = false;
1964  switch (Context.getKind()) {
1983  break;
1984 
1988  OnlyTagNames = true;
1989  break;
1990 
2006  // We're looking for nothing, or we're looking for names that cannot
2007  // be hidden.
2008  return;
2009  }
2010 
2011  using Result = CodeCompletionResult;
2012  for (unsigned I = 0; I != NumResults; ++I) {
2013  if (Results[I].Kind != Result::RK_Declaration)
2014  continue;
2015 
2016  unsigned IDNS
2018 
2019  bool Hiding = false;
2020  if (OnlyTagNames)
2021  Hiding = (IDNS & Decl::IDNS_Tag);
2022  else {
2023  unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member |
2026  if (Ctx.getLangOpts().CPlusPlus)
2027  HiddenIDNS |= Decl::IDNS_Tag;
2028  Hiding = (IDNS & HiddenIDNS);
2029  }
2030 
2031  if (!Hiding)
2032  continue;
2033 
2034  DeclarationName Name = Results[I].Declaration->getDeclName();
2036  HiddenNames.insert(Identifier->getName());
2037  else
2038  HiddenNames.insert(Name.getAsString());
2039  }
2040 }
2041 
2042 void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S,
2043  CodeCompletionContext Context,
2044  CodeCompletionResult *Results,
2045  unsigned NumResults) {
2046  // Merge the results we were given with the results we cached.
2047  bool AddedResult = false;
2048  uint64_t InContexts =
2050  ? NormalContexts : (1LL << Context.getKind());
2051  // Contains the set of names that are hidden by "local" completion results.
2052  llvm::StringSet<llvm::BumpPtrAllocator> HiddenNames;
2053  using Result = CodeCompletionResult;
2054  SmallVector<Result, 8> AllResults;
2056  C = AST.cached_completion_begin(),
2057  CEnd = AST.cached_completion_end();
2058  C != CEnd; ++C) {
2059  // If the context we are in matches any of the contexts we are
2060  // interested in, we'll add this result.
2061  if ((C->ShowInContexts & InContexts) == 0)
2062  continue;
2063 
2064  // If we haven't added any results previously, do so now.
2065  if (!AddedResult) {
2066  CalculateHiddenNames(Context, Results, NumResults, S.Context,
2067  HiddenNames);
2068  AllResults.insert(AllResults.end(), Results, Results + NumResults);
2069  AddedResult = true;
2070  }
2071 
2072  // Determine whether this global completion result is hidden by a local
2073  // completion result. If so, skip it.
2074  if (C->Kind != CXCursor_MacroDefinition &&
2075  HiddenNames.count(C->Completion->getTypedText()))
2076  continue;
2077 
2078  // Adjust priority based on similar type classes.
2079  unsigned Priority = C->Priority;
2080  CodeCompletionString *Completion = C->Completion;
2081  if (!Context.getPreferredType().isNull()) {
2082  if (C->Kind == CXCursor_MacroDefinition) {
2083  Priority = getMacroUsagePriority(C->Completion->getTypedText(),
2084  S.getLangOpts(),
2085  Context.getPreferredType()->isAnyPointerType());
2086  } else if (C->Type) {
2089  Context.getPreferredType().getUnqualifiedType());
2090  SimplifiedTypeClass ExpectedSTC = getSimplifiedTypeClass(Expected);
2091  if (ExpectedSTC == C->TypeClass) {
2092  // We know this type is similar; check for an exact match.
2093  llvm::StringMap<unsigned> &CachedCompletionTypes
2094  = AST.getCachedCompletionTypes();
2095  llvm::StringMap<unsigned>::iterator Pos
2096  = CachedCompletionTypes.find(QualType(Expected).getAsString());
2097  if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type)
2098  Priority /= CCF_ExactTypeMatch;
2099  else
2100  Priority /= CCF_SimilarTypeMatch;
2101  }
2102  }
2103  }
2104 
2105  // Adjust the completion string, if required.
2106  if (C->Kind == CXCursor_MacroDefinition &&
2108  // Create a new code-completion string that just contains the
2109  // macro name, without its arguments.
2110  CodeCompletionBuilder Builder(getAllocator(), getCodeCompletionTUInfo(),
2111  CCP_CodePattern, C->Availability);
2112  Builder.AddTypedTextChunk(C->Completion->getTypedText());
2113  Priority = CCP_CodePattern;
2114  Completion = Builder.TakeString();
2115  }
2116 
2117  AllResults.push_back(Result(Completion, Priority, C->Kind,
2118  C->Availability));
2119  }
2120 
2121  // If we did not add any cached completion results, just forward the
2122  // results we were given to the next consumer.
2123  if (!AddedResult) {
2124  Next.ProcessCodeCompleteResults(S, Context, Results, NumResults);
2125  return;
2126  }
2127 
2128  Next.ProcessCodeCompleteResults(S, Context, AllResults.data(),
2129  AllResults.size());
2130 }
2131 
2133  StringRef File, unsigned Line, unsigned Column,
2134  ArrayRef<RemappedFile> RemappedFiles, bool IncludeMacros,
2135  bool IncludeCodePatterns, bool IncludeBriefComments,
2136  CodeCompleteConsumer &Consumer,
2137  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
2138  DiagnosticsEngine &Diag, LangOptions &LangOpts, SourceManager &SourceMgr,
2139  FileManager &FileMgr, SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics,
2141  if (!Invocation)
2142  return;
2143 
2144  SimpleTimer CompletionTimer(WantTiming);
2145  CompletionTimer.setOutput("Code completion @ " + File + ":" +
2146  Twine(Line) + ":" + Twine(Column));
2147 
2148  auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);
2149 
2150  FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts();
2151  CodeCompleteOptions &CodeCompleteOpts = FrontendOpts.CodeCompleteOpts;
2152  PreprocessorOptions &PreprocessorOpts = CCInvocation->getPreprocessorOpts();
2153 
2154  CodeCompleteOpts.IncludeMacros = IncludeMacros &&
2155  CachedCompletionResults.empty();
2156  CodeCompleteOpts.IncludeCodePatterns = IncludeCodePatterns;
2157  CodeCompleteOpts.IncludeGlobals = CachedCompletionResults.empty();
2158  CodeCompleteOpts.IncludeBriefComments = IncludeBriefComments;
2159  CodeCompleteOpts.LoadExternal = Consumer.loadExternal();
2160  CodeCompleteOpts.IncludeFixIts = Consumer.includeFixIts();
2161 
2162  assert(IncludeBriefComments == this->IncludeBriefCommentsInCodeCompletion);
2163 
2164  FrontendOpts.CodeCompletionAt.FileName = File;
2165  FrontendOpts.CodeCompletionAt.Line = Line;
2166  FrontendOpts.CodeCompletionAt.Column = Column;
2167 
2168  // Set the language options appropriately.
2169  LangOpts = *CCInvocation->getLangOpts();
2170 
2171  // Spell-checking and warnings are wasteful during code-completion.
2172  LangOpts.SpellChecking = false;
2173  CCInvocation->getDiagnosticOpts().IgnoreWarnings = true;
2174 
2175  std::unique_ptr<CompilerInstance> Clang(
2176  new CompilerInstance(PCHContainerOps));
2177 
2178  // Recover resources if we crash before exiting this method.
2179  llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
2180  CICleanup(Clang.get());
2181 
2182  auto &Inv = *CCInvocation;
2183  Clang->setInvocation(std::move(CCInvocation));
2184  OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile();
2185 
2186  // Set up diagnostics, capturing any diagnostics produced.
2187  Clang->setDiagnostics(&Diag);
2188  CaptureDroppedDiagnostics Capture(CaptureDiagsKind::All,
2189  Clang->getDiagnostics(),
2190  &StoredDiagnostics, nullptr);
2191  ProcessWarningOptions(Diag, Inv.getDiagnosticOpts());
2192 
2193  // Create the target instance.
2194  Clang->setTarget(TargetInfo::CreateTargetInfo(
2195  Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
2196  if (!Clang->hasTarget()) {
2197  Clang->setInvocation(nullptr);
2198  return;
2199  }
2200 
2201  // Inform the target of the language options.
2202  //
2203  // FIXME: We shouldn't need to do this, the target should be immutable once
2204  // created. This complexity should be lifted elsewhere.
2205  Clang->getTarget().adjust(Clang->getLangOpts());
2206 
2207  assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
2208  "Invocation must have exactly one source file!");
2209  assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
2211  "FIXME: AST inputs not yet supported here!");
2212  assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
2214  "IR inputs not support here!");
2215 
2216  // Use the source and file managers that we were given.
2217  Clang->setFileManager(&FileMgr);
2218  Clang->setSourceManager(&SourceMgr);
2219 
2220  // Remap files.
2221  PreprocessorOpts.clearRemappedFiles();
2222  PreprocessorOpts.RetainRemappedFileBuffers = true;
2223  for (const auto &RemappedFile : RemappedFiles) {
2224  PreprocessorOpts.addRemappedFile(RemappedFile.first, RemappedFile.second);
2225  OwnedBuffers.push_back(RemappedFile.second);
2226  }
2227 
2228  // Use the code completion consumer we were given, but adding any cached
2229  // code-completion results.
2230  AugmentedCodeCompleteConsumer *AugmentedConsumer
2231  = new AugmentedCodeCompleteConsumer(*this, Consumer, CodeCompleteOpts);
2232  Clang->setCodeCompletionConsumer(AugmentedConsumer);
2233 
2234  // If we have a precompiled preamble, try to use it. We only allow
2235  // the use of the precompiled preamble if we're if the completion
2236  // point is within the main file, after the end of the precompiled
2237  // preamble.
2238  std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
2239  if (Preamble) {
2240  std::string CompleteFilePath(File);
2241 
2242  auto &VFS = FileMgr.getVirtualFileSystem();
2243  auto CompleteFileStatus = VFS.status(CompleteFilePath);
2244  if (CompleteFileStatus) {
2245  llvm::sys::fs::UniqueID CompleteFileID = CompleteFileStatus->getUniqueID();
2246 
2247  std::string MainPath(OriginalSourceFile);
2248  auto MainStatus = VFS.status(MainPath);
2249  if (MainStatus) {
2250  llvm::sys::fs::UniqueID MainID = MainStatus->getUniqueID();
2251  if (CompleteFileID == MainID && Line > 1)
2252  OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(
2253  PCHContainerOps, Inv, &VFS, false, Line - 1);
2254  }
2255  }
2256  }
2257 
2258  // If the main file has been overridden due to the use of a preamble,
2259  // make that override happen and introduce the preamble.
2260  if (OverrideMainBuffer) {
2261  assert(Preamble &&
2262  "No preamble was built, but OverrideMainBuffer is not null");
2263 
2265  &FileMgr.getVirtualFileSystem();
2266  Preamble->AddImplicitPreamble(Clang->getInvocation(), VFS,
2267  OverrideMainBuffer.get());
2268  // FIXME: there is no way to update VFS if it was changed by
2269  // AddImplicitPreamble as FileMgr is accepted as a parameter by this method.
2270  // We use on-disk preambles instead and rely on FileMgr's VFS to ensure the
2271  // PCH files are always readable.
2272  OwnedBuffers.push_back(OverrideMainBuffer.release());
2273  } else {
2274  PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
2275  PreprocessorOpts.PrecompiledPreambleBytes.second = false;
2276  }
2277 
2278  // Disable the preprocessing record if modules are not enabled.
2279  if (!Clang->getLangOpts().Modules)
2280  PreprocessorOpts.DetailedRecord = false;
2281 
2282  std::unique_ptr<SyntaxOnlyAction> Act;
2283  Act.reset(new SyntaxOnlyAction);
2284  if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
2285  if (llvm::Error Err = Act->Execute()) {
2286  consumeError(std::move(Err)); // FIXME this drops errors on the floor.
2287  }
2288  Act->EndSourceFile();
2289  }
2290 }
2291 
2292 bool ASTUnit::Save(StringRef File) {
2293  if (HadModuleLoaderFatalFailure)
2294  return true;
2295 
2296  // Write to a temporary file and later rename it to the actual file, to avoid
2297  // possible race conditions.
2298  SmallString<128> TempPath;
2299  TempPath = File;
2300  TempPath += "-%%%%%%%%";
2301  int fd;
2302  if (llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath))
2303  return true;
2304 
2305  // FIXME: Can we somehow regenerate the stat cache here, or do we need to
2306  // unconditionally create a stat cache when we parse the file?
2307  llvm::raw_fd_ostream Out(fd, /*shouldClose=*/true);
2308 
2309  serialize(Out);
2310  Out.close();
2311  if (Out.has_error()) {
2312  Out.clear_error();
2313  return true;
2314  }
2315 
2316  if (llvm::sys::fs::rename(TempPath, File)) {
2317  llvm::sys::fs::remove(TempPath);
2318  return true;
2319  }
2320 
2321  return false;
2322 }
2323 
2324 static bool serializeUnit(ASTWriter &Writer,
2325  SmallVectorImpl<char> &Buffer,
2326  Sema &S,
2327  bool hasErrors,
2328  raw_ostream &OS) {
2329  Writer.WriteAST(S, std::string(), nullptr, "", hasErrors);
2330 
2331  // Write the generated bitstream to "Out".
2332  if (!Buffer.empty())
2333  OS.write(Buffer.data(), Buffer.size());
2334 
2335  return false;
2336 }
2337 
2338 bool ASTUnit::serialize(raw_ostream &OS) {
2339  // For serialization we are lenient if the errors were only warn-as-error kind.
2340  bool hasErrors = getDiagnostics().hasUncompilableErrorOccurred();
2341 
2342  if (WriterData)
2343  return serializeUnit(WriterData->Writer, WriterData->Buffer,
2344  getSema(), hasErrors, OS);
2345 
2346  SmallString<128> Buffer;
2347  llvm::BitstreamWriter Stream(Buffer);
2348  InMemoryModuleCache ModuleCache;
2349  ASTWriter Writer(Stream, Buffer, ModuleCache, {});
2350  return serializeUnit(Writer, Buffer, getSema(), hasErrors, OS);
2351 }
2352 
2354 
2355 void ASTUnit::TranslateStoredDiagnostics(
2356  FileManager &FileMgr,
2357  SourceManager &SrcMgr,
2360  // Map the standalone diagnostic into the new source manager. We also need to
2361  // remap all the locations to the new view. This includes the diag location,
2362  // any associated source ranges, and the source ranges of associated fix-its.
2363  // FIXME: There should be a cleaner way to do this.
2365  Result.reserve(Diags.size());
2366 
2367  for (const auto &SD : Diags) {
2368  // Rebuild the StoredDiagnostic.
2369  if (SD.Filename.empty())
2370  continue;
2371  const FileEntry *FE = FileMgr.getFile(SD.Filename);
2372  if (!FE)
2373  continue;
2374  SourceLocation FileLoc;
2375  auto ItFileID = PreambleSrcLocCache.find(SD.Filename);
2376  if (ItFileID == PreambleSrcLocCache.end()) {
2377  FileID FID = SrcMgr.translateFile(FE);
2378  FileLoc = SrcMgr.getLocForStartOfFile(FID);
2379  PreambleSrcLocCache[SD.Filename] = FileLoc;
2380  } else {
2381  FileLoc = ItFileID->getValue();
2382  }
2383 
2384  if (FileLoc.isInvalid())
2385  continue;
2386  SourceLocation L = FileLoc.getLocWithOffset(SD.LocOffset);
2387  FullSourceLoc Loc(L, SrcMgr);
2388 
2390  Ranges.reserve(SD.Ranges.size());
2391  for (const auto &Range : SD.Ranges) {
2392  SourceLocation BL = FileLoc.getLocWithOffset(Range.first);
2393  SourceLocation EL = FileLoc.getLocWithOffset(Range.second);
2394  Ranges.push_back(CharSourceRange::getCharRange(BL, EL));
2395  }
2396 
2398  FixIts.reserve(SD.FixIts.size());
2399  for (const auto &FixIt : SD.FixIts) {
2400  FixIts.push_back(FixItHint());
2401  FixItHint &FH = FixIts.back();
2402  FH.CodeToInsert = FixIt.CodeToInsert;
2403  SourceLocation BL = FileLoc.getLocWithOffset(FixIt.RemoveRange.first);
2404  SourceLocation EL = FileLoc.getLocWithOffset(FixIt.RemoveRange.second);
2406  }
2407 
2408  Result.push_back(StoredDiagnostic(SD.Level, SD.ID,
2409  SD.Message, Loc, Ranges, FixIts));
2410  }
2411  Result.swap(Out);
2412 }
2413 
2415  assert(D);
2416 
2417  // We only care about local declarations.
2418  if (D->isFromASTFile())
2419  return;
2420 
2421  SourceManager &SM = *SourceMgr;
2422  SourceLocation Loc = D->getLocation();
2423  if (Loc.isInvalid() || !SM.isLocalSourceLocation(Loc))
2424  return;
2425 
2426  // We only keep track of the file-level declarations of each file.
2427  if (!D->getLexicalDeclContext()->isFileContext())
2428  return;
2429 
2430  SourceLocation FileLoc = SM.getFileLoc(Loc);
2431  assert(SM.isLocalSourceLocation(FileLoc));
2432  FileID FID;
2433  unsigned Offset;
2434  std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc);
2435  if (FID.isInvalid())
2436  return;
2437 
2438  LocDeclsTy *&Decls = FileDecls[FID];
2439  if (!Decls)
2440  Decls = new LocDeclsTy();
2441 
2442  std::pair<unsigned, Decl *> LocDecl(Offset, D);
2443 
2444  if (Decls->empty() || Decls->back().first <= Offset) {
2445  Decls->push_back(LocDecl);
2446  return;
2447  }
2448 
2449  LocDeclsTy::iterator I =
2450  llvm::upper_bound(*Decls, LocDecl, llvm::less_first());
2451 
2452  Decls->insert(I, LocDecl);
2453 }
2454 
2455 void ASTUnit::findFileRegionDecls(FileID File, unsigned Offset, unsigned Length,
2456  SmallVectorImpl<Decl *> &Decls) {
2457  if (File.isInvalid())
2458  return;
2459 
2460  if (SourceMgr->isLoadedFileID(File)) {
2461  assert(Ctx->getExternalSource() && "No external source!");
2462  return Ctx->getExternalSource()->FindFileRegionDecls(File, Offset, Length,
2463  Decls);
2464  }
2465 
2466  FileDeclsTy::iterator I = FileDecls.find(File);
2467  if (I == FileDecls.end())
2468  return;
2469 
2470  LocDeclsTy &LocDecls = *I->second;
2471  if (LocDecls.empty())
2472  return;
2473 
2474  LocDeclsTy::iterator BeginIt =
2475  llvm::partition_point(LocDecls, [=](std::pair<unsigned, Decl *> LD) {
2476  return LD.first < Offset;
2477  });
2478  if (BeginIt != LocDecls.begin())
2479  --BeginIt;
2480 
2481  // If we are pointing at a top-level decl inside an objc container, we need
2482  // to backtrack until we find it otherwise we will fail to report that the
2483  // region overlaps with an objc container.
2484  while (BeginIt != LocDecls.begin() &&
2485  BeginIt->second->isTopLevelDeclInObjCContainer())
2486  --BeginIt;
2487 
2488  LocDeclsTy::iterator EndIt = llvm::upper_bound(
2489  LocDecls, std::make_pair(Offset + Length, (Decl *)nullptr),
2490  llvm::less_first());
2491  if (EndIt != LocDecls.end())
2492  ++EndIt;
2493 
2494  for (LocDeclsTy::iterator DIt = BeginIt; DIt != EndIt; ++DIt)
2495  Decls.push_back(DIt->second);
2496 }
2497 
2499  unsigned Line, unsigned Col) const {
2500  const SourceManager &SM = getSourceManager();
2501  SourceLocation Loc = SM.translateFileLineCol(File, Line, Col);
2502  return SM.getMacroArgExpandedLocation(Loc);
2503 }
2504 
2506  unsigned Offset) const {
2507  const SourceManager &SM = getSourceManager();
2508  SourceLocation FileLoc = SM.translateFileLineCol(File, 1, 1);
2509  return SM.getMacroArgExpandedLocation(FileLoc.getLocWithOffset(Offset));
2510 }
2511 
2512 /// If \arg Loc is a loaded location from the preamble, returns
2513 /// the corresponding local location of the main file, otherwise it returns
2514 /// \arg Loc.
2516  FileID PreambleID;
2517  if (SourceMgr)
2518  PreambleID = SourceMgr->getPreambleFileID();
2519 
2520  if (Loc.isInvalid() || !Preamble || PreambleID.isInvalid())
2521  return Loc;
2522 
2523  unsigned Offs;
2524  if (SourceMgr->isInFileID(Loc, PreambleID, &Offs) && Offs < Preamble->getBounds().Size) {
2525  SourceLocation FileLoc
2526  = SourceMgr->getLocForStartOfFile(SourceMgr->getMainFileID());
2527  return FileLoc.getLocWithOffset(Offs);
2528  }
2529 
2530  return Loc;
2531 }
2532 
2533 /// If \arg Loc is a local location of the main file but inside the
2534 /// preamble chunk, returns the corresponding loaded location from the
2535 /// preamble, otherwise it returns \arg Loc.
2537  FileID PreambleID;
2538  if (SourceMgr)
2539  PreambleID = SourceMgr->getPreambleFileID();
2540 
2541  if (Loc.isInvalid() || !Preamble || PreambleID.isInvalid())
2542  return Loc;
2543 
2544  unsigned Offs;
2545  if (SourceMgr->isInFileID(Loc, SourceMgr->getMainFileID(), &Offs) &&
2546  Offs < Preamble->getBounds().Size) {
2547  SourceLocation FileLoc = SourceMgr->getLocForStartOfFile(PreambleID);
2548  return FileLoc.getLocWithOffset(Offs);
2549  }
2550 
2551  return Loc;
2552 }
2553 
2555  FileID FID;
2556  if (SourceMgr)
2557  FID = SourceMgr->getPreambleFileID();
2558 
2559  if (Loc.isInvalid() || FID.isInvalid())
2560  return false;
2561 
2562  return SourceMgr->isInFileID(Loc, FID);
2563 }
2564 
2566  FileID FID;
2567  if (SourceMgr)
2568  FID = SourceMgr->getMainFileID();
2569 
2570  if (Loc.isInvalid() || FID.isInvalid())
2571  return false;
2572 
2573  return SourceMgr->isInFileID(Loc, FID);
2574 }
2575 
2577  FileID FID;
2578  if (SourceMgr)
2579  FID = SourceMgr->getPreambleFileID();
2580 
2581  if (FID.isInvalid())
2582  return {};
2583 
2584  return SourceMgr->getLocForEndOfFile(FID);
2585 }
2586 
2588  FileID FID;
2589  if (SourceMgr)
2590  FID = SourceMgr->getMainFileID();
2591 
2592  if (FID.isInvalid())
2593  return {};
2594 
2595  return SourceMgr->getLocForStartOfFile(FID);
2596 }
2597 
2598 llvm::iterator_range<PreprocessingRecord::iterator>
2600  if (isMainFileAST()) {
2602  Mod = Reader->getModuleManager().getPrimaryModule();
2603  return Reader->getModulePreprocessedEntities(Mod);
2604  }
2605 
2606  if (PreprocessingRecord *PPRec = PP->getPreprocessingRecord())
2607  return llvm::make_range(PPRec->local_begin(), PPRec->local_end());
2608 
2609  return llvm::make_range(PreprocessingRecord::iterator(),
2611 }
2612 
2614  if (isMainFileAST()) {
2616  Mod = Reader->getModuleManager().getPrimaryModule();
2617  for (const auto *D : Reader->getModuleFileLevelDecls(Mod)) {
2618  if (!Fn(context, D))
2619  return false;
2620  }
2621 
2622  return true;
2623  }
2624 
2626  TLEnd = top_level_end();
2627  TL != TLEnd; ++TL) {
2628  if (!Fn(context, *TL))
2629  return false;
2630  }
2631 
2632  return true;
2633 }
2634 
2636  if (!Reader)
2637  return nullptr;
2638 
2639  serialization::ModuleFile *Mod = nullptr;
2640  Reader->getModuleManager().visit([&Mod](serialization::ModuleFile &M) {
2641  switch (M.Kind) {
2642  case serialization::MK_ImplicitModule:
2643  case serialization::MK_ExplicitModule:
2644  case serialization::MK_PrebuiltModule:
2645  return true; // skip dependencies.
2646  case serialization::MK_PCH:
2647  Mod = &M;
2648  return true; // found it.
2649  case serialization::MK_Preamble:
2650  return false; // look in dependencies.
2651  case serialization::MK_MainFile:
2652  return false; // look in dependencies.
2653  }
2654 
2655  return true;
2656  });
2657  if (Mod)
2658  return Mod->File;
2659 
2660  return nullptr;
2661 }
2662 
2665 }
2666 
2668  auto &LangOpts = getLangOpts();
2669 
2670  InputKind::Language Lang;
2671  if (LangOpts.OpenCL)
2672  Lang = InputKind::OpenCL;
2673  else if (LangOpts.CUDA)
2674  Lang = InputKind::CUDA;
2675  else if (LangOpts.RenderScript)
2676  Lang = InputKind::RenderScript;
2677  else if (LangOpts.CPlusPlus)
2678  Lang = LangOpts.ObjC ? InputKind::ObjCXX : InputKind::CXX;
2679  else
2680  Lang = LangOpts.ObjC ? InputKind::ObjC : InputKind::C;
2681 
2683  if (LangOpts.getCompilingModule() == LangOptions::CMK_ModuleMap)
2684  Fmt = InputKind::ModuleMap;
2685 
2686  // We don't know if input was preprocessed. Assume not.
2687  bool PP = false;
2688 
2689  return InputKind(Lang, Fmt, PP);
2690 }
2691 
2692 #ifndef NDEBUG
2693 ASTUnit::ConcurrencyState::ConcurrencyState() {
2694  Mutex = new llvm::sys::MutexImpl(/*recursive=*/true);
2695 }
2696 
2697 ASTUnit::ConcurrencyState::~ConcurrencyState() {
2698  delete static_cast<llvm::sys::MutexImpl *>(Mutex);
2699 }
2700 
2701 void ASTUnit::ConcurrencyState::start() {
2702  bool acquired = static_cast<llvm::sys::MutexImpl *>(Mutex)->tryacquire();
2703  assert(acquired && "Concurrent access to ASTUnit!");
2704 }
2705 
2706 void ASTUnit::ConcurrencyState::finish() {
2707  static_cast<llvm::sys::MutexImpl *>(Mutex)->release();
2708 }
2709 
2710 #else // NDEBUG
2711 
2712 ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex = nullptr; }
2713 ASTUnit::ConcurrencyState::~ConcurrencyState() {}
2714 void ASTUnit::ConcurrencyState::start() {}
2715 void ASTUnit::ConcurrencyState::finish() {}
2716 
2717 #endif // NDEBUG
An unknown context, in which we are recovering from a parsing error and don&#39;t know which completions ...
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file. ...
Defines the clang::ASTContext interface.
Describes the bounds (start, size) of the preamble and a flag required by PreprocessorOptions::Precom...
Definition: Lexer.h:58
unsigned getID() const
Definition: Diagnostic.h:1466
void ResetForParse()
Free data that will be re-generated on the next parse.
Definition: ASTUnit.cpp:1879
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
CompilerInvocation & getInvocation()
StringRef Identifier
Definition: Format.cpp:1718
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
DiagnosticConsumer * getClient()
Definition: Diagnostic.h:510
A (possibly-)qualified type.
Definition: Type.h:643
virtual Decl * GetExternalDecl(uint32_t ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
static std::unique_ptr< T > valueOrNull(llvm::ErrorOr< std::unique_ptr< T >> Val)
Definition: ASTUnit.cpp:139
unsigned IncludeBriefComments
Show brief documentation comments in code completion results.
bool RemappedFilesKeepOriginalName
True if the SourceManager should report the original file name for contents of files that were remapp...
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:116
const LangOptions & getLangOpts() const
Definition: ASTUnit.h:461
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:33
std::pair< unsigned, unsigned > InsertFromRange
Definition: ASTUnit.h:93
void addTopLevelDecl(Decl *D)
Add a new top-level declaration.
Definition: ASTUnit.h:527
Defines the clang::FileManager interface and associated types.
Code completion for a selector, as in an @selector expression.
void EndSourceFile()
Perform any per-file post processing, deallocate per-file objects, and run statistics and output file...
Code completion occurred where an existing name(such as type, function or variable) is expected...
unsigned IncludeGlobals
Show top-level decls in code completion results.
unsigned getMacroUsagePriority(StringRef MacroName, const LangOptions &LangOpts, bool PreferredTypeIsPointer=false)
Determine the priority to be given to a macro code completion result with the given name...
Code completion where an Objective-C class message is expected.
C Language Family Type Representation.
Defines the SourceManager interface.
Code completion within a type-qualifier list.
Load everything, including Sema.
Definition: ASTUnit.h:678
Abstract base class for actions which can be performed by the frontend.
Defines the clang::Module class, which describes a module in the source code.
bool isLocalSourceLocation(SourceLocation Loc) const
Returns true if Loc did not come from a PCH/Module.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
Divide by this factor when a code-completion result&#39;s type exactly matches the type we expect...
ModuleKind Kind
The type of this module.
Definition: Module.h:119
const FileManager & getFileManager() const
Definition: ASTUnit.h:476
Defines the C++ template declaration subclasses.
const unsigned DefaultPreambleRebuildInterval
After failing to build a precompiled preamble (due to errors in the source that occurs in the preambl...
Definition: ASTUnit.cpp:232
Represents a diagnostic in a form that can be retained until its corresponding source manager is dest...
Definition: Diagnostic.h:1445
StringRef getASTFileName() const
If this ASTUnit came from an AST file, returns the filename for it.
Definition: ASTUnit.cpp:1480
std::string CodeToInsert
The actual code to insert at the insertion location, as a string.
Definition: Diagnostic.h:78
An unspecified code-completion context.
static std::unique_ptr< ASTUnit > create(std::shared_ptr< CompilerInvocation > CI, IntrusiveRefCntPtr< DiagnosticsEngine > Diags, CaptureDiagsKind CaptureDiagnostics, bool UserFilesAreVolatile)
Create a ASTUnit. Gets ownership of the passed CompilerInvocation.
Definition: ASTUnit.cpp:1490
bool isCompilingModule() const
Are we compiling a module interface (.cppm or module map)?
Definition: LangOptions.h:263
std::shared_ptr< LangOptions > LangOpts
Options controlling the language variant.
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
Format
The input file format.
bool loadExternal() const
Hint whether to load data from the external AST in order to provide full results. ...
std::unique_ptr< DiagnosticConsumer > takeClient()
Return the current diagnostic client along with ownership of that client.
Definition: Diagnostic.h:518
unsigned getIdentifierNamespace() const
Definition: DeclBase.h:799
Code completion occurred where an Objective-C message receiver is expected.
ASTContext & getASTContext() const
The AST file has errors.
Definition: ASTReader.h:403
Code completion occurred on the right-hand side of a member access expression using the arrow operato...
Code completion occurred after the "enum" keyword, to indicate an enumeration name.
void setSourceManager(SourceManager *Value)
setSourceManager - Replace the current source manager.
virtual void EndSourceFile()
Callback to inform the diagnostic client that processing of a source file has ended.
Definition: Diagnostic.h:1528
Options for controlling the target.
Definition: TargetOptions.h:26
SourceLocation mapLocationToPreamble(SourceLocation Loc) const
If Loc is a local location of the main file but inside the preamble chunk, returns the corresponding ...
Definition: ASTUnit.cpp:2536
void addRemappedFile(StringRef From, StringRef To)
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1496
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:431
static void checkAndSanitizeDiags(SmallVectorImpl< StoredDiagnostic > &StoredDiagnostics, SourceManager &SM)
Definition: ASTUnit.cpp:1076
Code completion occurred within the instance variable list of an Objective-C interface, implementation, or category implementation.
void AddTypedTextChunk(const char *Text)
Add a new typed-text chunk.
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:37
bool hasSourceManager() const
Definition: Diagnostic.h:1336
This interface provides a way to observe the actions of the preprocessor as it does its thing...
Definition: PPCallbacks.h:35
Parse and apply any fixits to the source.
Code completion occurred where both a new name and an existing symbol is permissible.
Types, declared with &#39;struct foo&#39;, typedefs, etc.
Definition: DeclBase.h:132
static ASTUnit * LoadFromCommandLine(const char **ArgBegin, const char **ArgEnd, std::shared_ptr< PCHContainerOperations > PCHContainerOps, IntrusiveRefCntPtr< DiagnosticsEngine > Diags, StringRef ResourceFilesPath, bool OnlyLocalDecls=false, CaptureDiagsKind CaptureDiagnostics=CaptureDiagsKind::None, ArrayRef< RemappedFile > RemappedFiles=None, bool RemappedFilesKeepOriginalName=true, unsigned PrecompilePreambleAfterNParses=0, TranslationUnitKind TUKind=TU_Complete, bool CacheCodeCompletionResults=false, bool IncludeBriefCommentsInCodeCompletion=false, bool AllowPCHWithCompilerErrors=false, SkipFunctionBodiesScope SkipFunctionBodies=SkipFunctionBodiesScope::None, bool SingleFileParse=false, bool UserFilesAreVolatile=false, bool ForSerialization=false, llvm::Optional< StringRef > ModuleFormat=llvm::None, std::unique_ptr< ASTUnit > *ErrAST=nullptr, IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)
LoadFromCommandLine - Create an ASTUnit from a vector of command line arguments, which must specify e...
Definition: ASTUnit.cpp:1727
std::vector< std::pair< unsigned, unsigned > > Ranges
Definition: ASTUnit.h:104
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
One of these records is kept for each identifier that is lexed.
CodeCompletionString * TakeString()
Take the resulting completion string.
cached_completion_iterator cached_completion_end()
Definition: ASTUnit.h:620
void setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)
Set the diagnostic client associated with this diagnostic object.
Definition: Diagnostic.cpp:99
SourceLocation getBegin() const
Iteration over the preprocessed entities.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
Utility class for loading a ASTContext from an AST file.
Definition: ASTUnit.h:89
bool BeginSourceFile(CompilerInstance &CI, const FrontendInputFile &Input)
Prepare the action for processing the input file Input.
SkipFunctionBodiesScope
Enumerates the available scopes for skipping function bodies.
Definition: ASTUnit.h:83
const llvm::MemoryBuffer * getBuffer() const
A "string" used to describe how code completion can be performed for an entity.
static std::atomic< unsigned > ActiveASTUnitObjects
Tracks the number of ASTUnit objects that are currently active.
Definition: ASTUnit.cpp:237
SourceLocation translateFileLineCol(const FileEntry *SourceFile, unsigned Line, unsigned Col) const
Get the source location for the given file:line:col triplet.
static bool moveOnNoError(llvm::ErrorOr< T > Val, T &Output)
Definition: ASTUnit.cpp:146
Kind getKind() const
Retrieve the kind of code-completion context.
Token - This structure provides full information about a lexed token.
Definition: Token.h:34
bool isInPreambleFileID(SourceLocation Loc) const
Definition: ASTUnit.cpp:2554
std::unique_ptr< llvm::MemoryBuffer > getBufferForFile(StringRef Filename, std::string *ErrorStr=nullptr)
Definition: ASTUnit.cpp:733
void setPrintingPolicy(const clang::PrintingPolicy &Policy)
Definition: ASTContext.h:661
std::shared_ptr< Preprocessor > getPreprocessorPtr()
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:49
Compiling a module from a module map.
Definition: LangOptions.h:78
Describes a module or submodule.
Definition: Module.h:64
StringRef getMainFileName() const
Definition: ASTUnit.cpp:1462
Languages that the frontend can parse and compile.
unsigned IncludeCodePatterns
Show code patterns in code completion results.
An allocator used specifically for the purpose of code completion.
DiagnosticsEngine::Level Level
Definition: ASTUnit.h:100
bool isInvalid() const
Load the AST, but do not restore Sema state.
Definition: ASTUnit.h:675
FileID translateFile(const FileEntry *SourceFile) const
Get the FileID for the given file.
void setPreprocessor(std::shared_ptr< Preprocessor > pp)
Definition: ASTUnit.cpp:272
std::unique_ptr< CompilerInvocation > createInvocationFromCommandLine(ArrayRef< const char *> Args, IntrusiveRefCntPtr< DiagnosticsEngine > Diags=IntrusiveRefCntPtr< DiagnosticsEngine >(), IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)
createInvocationFromCommandLine - Construct a compiler invocation object for a command line argument ...
A record of the steps taken while preprocessing a source file, including the various preprocessing di...
Namespaces, declared with &#39;namespace foo {}&#39;.
Definition: DeclBase.h:142
static std::unique_ptr< ASTUnit > LoadFromASTFile(const std::string &Filename, const PCHContainerReader &PCHContainerRdr, WhatToLoad ToLoad, IntrusiveRefCntPtr< DiagnosticsEngine > Diags, const FileSystemOptions &FileSystemOpts, bool UseDebugInfo=false, bool OnlyLocalDecls=false, ArrayRef< RemappedFile > RemappedFiles=None, CaptureDiagsKind CaptureDiagnostics=CaptureDiagsKind::None, bool AllowPCHWithCompilerErrors=false, bool UserFilesAreVolatile=false)
Create a ASTUnit from an AST file.
Definition: ASTUnit.cpp:754
const SourceLocation & getLocation() const
Definition: Diagnostic.h:1335
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
void Initialize(const TargetInfo &Target, const TargetInfo *AuxTarget=nullptr)
Initialize the preprocessor using information about the target.
const FileEntry * getPCHFile()
Get the PCH file if one was included.
Definition: ASTUnit.cpp:2635
Code completion occurred where a preprocessor directive is expected.
bool serialize(raw_ostream &OS)
Serialize this translation unit with the given output stream.
Definition: ASTUnit.cpp:2338
CaptureDiagsKind
Enumerates the available kinds for capturing diagnostics.
Definition: ASTUnit.h:86
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
std::string ResourceDir
The directory which holds the compiler resource files (builtin includes, etc.).
virtual CodeCompletionTUInfo & getCodeCompletionTUInfo()=0
Code completion occurred within an Objective-C implementation or category implementation.
ArrayRef< CharSourceRange > getRanges() const
Definition: Diagnostic.h:1479
Defines the Diagnostic-related interfaces.
bool RetainRemappedFileBuffers
Whether the compiler instance should retain (i.e., not free) the buffers associated with remapped fil...
unsigned SkipFunctionBodies
Skip over function bodies to speed up parsing in cases you do not need them (e.g. ...
void addFileLevelDecl(Decl *D)
Add a new local file-level declaration.
Definition: ASTUnit.cpp:2414
QualType getDeclUsageType(ASTContext &C, const NamedDecl *ND)
Determine the type that this declaration will have if it is used as a type or in an expression...
Code completion occurred where a namespace or namespace alias is expected.
ASTDeserializationListener * getDeserializationListener()
Definition: ASTUnit.cpp:726
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:828
void setFileManager(FileManager *Value)
Replace the current file manager and virtual file system.
const LangOptions & getLangOpts() const
Definition: Sema.h:1285
static bool isNonDriverDiag(const StoredDiagnostic &StoredDiag)
Definition: ASTUnit.cpp:1063
StringRef getMessage() const
Definition: Diagnostic.h:1469
void Reset()
Reset the state of the diagnostic object to its initial configuration.
Definition: Diagnostic.cpp:121
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
The AST file itself appears corrupted.
Definition: ASTReader.h:386
Ordinary names.
Definition: DeclBase.h:146
virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, OverloadCandidate *Candidates, unsigned NumCandidates, SourceLocation OpenParLoc)
std::vector< std::pair< std::string, llvm::MemoryBuffer * > > RemappedFileBuffers
The set of file-to-buffer remappings, which take existing files on the system (the first part of each...
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:158
FrontendOptions & getFrontendOpts()
A set of callbacks to gather useful information while building a preamble.
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
Code completion where an Objective-C category name is expected.
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
static void checkAndRemoveNonDriverDiags(SmallVectorImpl< StoredDiagnostic > &StoredDiags)
Definition: ASTUnit.cpp:1068
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:328
Code completion occurred within a "top-level" completion context, e.g., at namespace or global scope...
static void AddDefinedMacroToHash(const Token &MacroNameTok, unsigned &Hash)
Add the given macro to the hash of all top-level entities.
Definition: ASTUnit.cpp:870
This declaration is a C++ operator declared in a non-class context.
Definition: DeclBase.h:170
StringRef Filename
Definition: Format.cpp:1711
ASTFileSignature WriteAST(Sema &SemaRef, const std::string &OutputFile, Module *WritingModule, StringRef isysroot, bool hasErrors=false, bool ShouldCacheASTInMemory=false)
Write a precompiled header for the given semantic analysis.
Definition: ASTWriter.cpp:4644
bool isModuleFile() const
Returns true if the ASTUnit was constructed from a serialized module file.
Definition: ASTUnit.cpp:2663
Divide by this factor when a code-completion result&#39;s type is similar to the type we expect (e...
IntrusiveRefCntPtr< ASTReader > getModuleManager() const
unsigned Offset
Definition: Format.cpp:1713
Code completion occurred where a protocol name is expected.
Allows QualTypes to be sorted and hence used in maps and sets.
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:236
QualType getPreferredType() const
Retrieve the type that this expression would prefer to have, e.g., if the expression is a variable in...
CodeCompletionTUInfo & getCodeCompletionTUInfo()
Definition: ASTUnit.h:316
IntrusiveRefCntPtr< ASTReader > getASTReader() const
Definition: ASTUnit.cpp:716
Defines the clang::LangOptions interface.
bool isMainFileAST() const
Definition: ASTUnit.h:424
Represents a character-granular source range.
DiagnosticsEngine::Level getLevel() const
Definition: Diagnostic.h:1467
llvm::StringRef getAsString(SyncScope S)
Definition: SyncScope.h:50
std::pair< unsigned, unsigned > RemoveRange
Definition: ASTUnit.h:92
static void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash)
Add the given declaration to the hash of all top-level entities.
Definition: ASTUnit.cpp:893
unsigned & getCurrentTopLevelHashValue()
Retrieve a reference to the current top-level name hash value.
Definition: ASTUnit.h:543
bool hasUncompilableErrorOccurred() const
Errors that actually prevent compilation, not those that are upgraded from a warning by -Werror...
Definition: Diagnostic.h:753
const AnnotatedLine * Line
ArrayRef< FixItHint > getFixIts() const
Definition: Diagnostic.h:1489
StringRef getFile() const
std::vector< StandaloneFixIt > FixIts
Definition: ASTUnit.h:105
std::string getAsString() const
Retrieve the human-readable string for this name.
Defines the clang::Preprocessor interface.
const NamedDecl * Declaration
When Kind == RK_Declaration or RK_Pattern, the declaration we are referring to.
bool isFileContext() const
Definition: DeclBase.h:1849
comments::CommandTraits & getCommentCommandTraits() const
Definition: ASTContext.h:878
const SourceManager & getManager() const
DeclContext * getDeclContext()
Definition: DeclBase.h:438
bool isWrittenInMainFile(SourceLocation Loc) const
Returns true if the spelling location for the given location is in the main file buffer.
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
ASTEdit remove(RangeSelector S)
Removes the source selected by S.
Definition: Transformer.h:232
Information about a module that has been loaded by the ASTReader.
Definition: Module.h:107
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn&#39;t...
Captures a result of code completion.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Code completion in a parenthesized expression, which means that we may also have types here in C and ...
std::string FileName
The file name of the module file.
Definition: Module.h:122
bool BeforePreviousInsertions
Definition: Diagnostic.h:80
Code completion occurred in a context where natural language is expected, e.g., a comment or string l...
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)
Construct a target for the given options.
Definition: Targets.cpp:602
PreambleBounds ComputePreambleBounds(const LangOptions &LangOpts, llvm::MemoryBuffer *Buffer, unsigned MaxLines)
Runs lexer to compute suggested preamble bounds.
SmallString< 128 > Buffer
Definition: ASTUnit.cpp:216
An input file for the front end.
static ASTUnit::StandaloneFixIt makeStandaloneFixIt(const SourceManager &SM, const LangOptions &LangOpts, const FixItHint &InFix)
Definition: ASTUnit.cpp:1243
top_level_iterator top_level_begin()
Definition: ASTUnit.h:502
The result type of a method or function.
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:708
const SourceManager & SM
Definition: Format.cpp:1572
The client can&#39;t handle any AST loading failures.
Definition: ASTReader.h:1505
The AST file was missing.
Definition: ASTReader.h:389
CharSourceRange InsertFromRange
Code in the specific range that should be inserted in the insertion location.
Definition: Diagnostic.h:74
unsigned getNumWarnings() const
Definition: Diagnostic.h:763
std::unique_ptr< Sema > takeSema()
static CharSourceRange getCharRange(SourceRange R)
The context in which code completion occurred, so that the code-completion consumer can process the r...
bool AllowPCHWithCompilerErrors
When true, a PCH with compiler errors will not be rejected.
In-memory cache for modules.
CharSourceRange RemoveRange
Code that should be replaced to correct the error.
Definition: Diagnostic.h:70
unsigned getFileOffset(SourceLocation SpellingLoc) const
Returns the offset from the start of the file that the specified SourceLocation represents.
Abstract interface for external sources of AST nodes.
static void CalculateHiddenNames(const CodeCompletionContext &Context, CodeCompletionResult *Results, unsigned NumResults, ASTContext &Ctx, llvm::StringSet< llvm::BumpPtrAllocator > &HiddenNames)
Helper function that computes which global names are hidden by the local code-completion results...
Definition: ASTUnit.cpp:1958
StringRef getFilename(SourceLocation SpellingLoc) const
Return the filename of the file containing a SourceLocation.
The control block was read successfully.
Definition: ASTReader.h:383
std::pair< std::string, llvm::MemoryBuffer * > RemappedFile
A mapping from a file name to the memory buffer that stores the remapped contents of that file...
Definition: ASTUnit.h:662
Code completion occurred within a class, struct, or union.
Encapsulates changes to the "macros namespace" (the location where the macro name became active...
Definition: MacroInfo.h:290
#define false
Definition: stdbool.h:17
Kind
SourceLocation mapLocationFromPreamble(SourceLocation Loc) const
If Loc is a loaded location from the preamble, returns the corresponding local location of the main f...
Definition: ASTUnit.cpp:2515
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
Definition: Overload.h:739
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Encodes a location in the source.
Code completion occurred where a new name is expected.
bool isInMainFileID(SourceLocation Loc) const
Definition: ASTUnit.cpp:2565
Members, declared with object declarations within tag definitions.
Definition: DeclBase.h:138
FileSystemOptions & getFileSystemOpts()
Returns the current file system options.
Definition: FileManager.h:221
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
virtual TranslationUnitKind getTranslationUnitKind()
For AST-based actions, the kind of translation unit we&#39;re handling.
llvm::StringMap< unsigned > & getCachedCompletionTypes()
Retrieve the mapping from formatted type names to unique type identifiers.
Definition: ASTUnit.h:306
LLVM IR: we accept this so that we can run the optimizer on it, and compile it to assembly or object ...
std::vector< FrontendInputFile > Inputs
The input files and their types.
Sema & getSema() const
Definition: ASTUnit.h:456
void CodeComplete(StringRef File, unsigned Line, unsigned Column, ArrayRef< RemappedFile > RemappedFiles, bool IncludeMacros, bool IncludeCodePatterns, bool IncludeBriefComments, CodeCompleteConsumer &Consumer, std::shared_ptr< PCHContainerOperations > PCHContainerOps, DiagnosticsEngine &Diag, LangOptions &LangOpts, SourceManager &SourceMgr, FileManager &FileMgr, SmallVectorImpl< StoredDiagnostic > &StoredDiagnostics, SmallVectorImpl< const llvm::MemoryBuffer *> &OwnedBuffers)
Perform code completion at the given file, line, and column within this translation unit...
Definition: ASTUnit.cpp:2132
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:179
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
The kind of a file that we&#39;ve been handed as an input.
Code completion where the name of an Objective-C class is expected.
std::vector< CachedCodeCompletionResult >::iterator cached_completion_iterator
Definition: ASTUnit.h:614
void ProcessWarningOptions(DiagnosticsEngine &Diags, const DiagnosticOptions &Opts, bool ReportDiags=true)
ProcessWarningOptions - Initialize the diagnostic client and process the warning options specified on...
Definition: Warnings.cpp:43
Abstract base class to use for AST consumer-based frontend actions.
SourceLocation getFileLoc(SourceLocation Loc) const
Given Loc, if it is a macro location return the expansion location or the spelling location...
Code completion occurred within an Objective-C interface, protocol, or category interface.
Defines the clang::TargetOptions class.
DiagnosticOptions & getDiagnosticOpts() const
static std::pair< unsigned, unsigned > makeStandaloneRange(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts)
Definition: ASTUnit.cpp:1235
bool isAnyPointerType() const
Definition: Type.h:6388
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:702
virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info)
Handle this diagnostic, reporting it to the user or capturing it to a log as needed.
Definition: Diagnostic.cpp:531
void setListener(std::unique_ptr< ASTReaderListener > Listener)
Set the AST callbacks listener.
Definition: ASTReader.h:1572
void InitBuiltinTypes(const TargetInfo &Target, const TargetInfo *AuxTarget=nullptr)
Initialize built-in types.
SourceManager & getSourceManager() const
Definition: Diagnostic.h:1337
SimplifiedTypeClass getSimplifiedTypeClass(CanQualType T)
Determine the simplified type class of the given canonical type.
llvm::BitstreamWriter Stream
Definition: ASTUnit.cpp:217
TranslationUnitKind getTranslationUnitKind() const
Determine what kind of translation unit this AST represents.
Definition: ASTUnit.h:655
void setNumWarnings(unsigned NumWarnings)
Definition: Diagnostic.h:765
The AST file was writtten with a different language/target configuration.
Definition: ASTReader.h:400
bool visitLocalTopLevelDecls(void *context, DeclVisitorFn Fn)
Iterate over local declarations (locally parsed if this is a parsed source file or the loaded declara...
Definition: ASTUnit.cpp:2613
File is a PCH file treated as the actual main file.
Definition: Module.h:56
void registerCommentOptions(const CommentOptions &CommentOptions)
StringRef getName() const
Return the actual identifier string.
Abstract interface for a consumer of code-completion information.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Options controlling the behavior of code completion.
static ASTUnit::StandaloneDiagnostic makeStandaloneDiagnostic(const LangOptions &LangOpts, const StoredDiagnostic &InDiag)
Definition: ASTUnit.cpp:1256
Dataflow Directional Tag Classes.
virtual llvm::StringRef getFormat() const =0
Equivalent to the format passed to -fmodule-format=.
bool isValid() const
Return true if this is a valid SourceLocation object.
static std::unique_ptr< llvm::MemoryBuffer > getBufferForFileHandlingRemapping(const CompilerInvocation &Invocation, llvm::vfs::FileSystem *VFS, StringRef FilePath, bool isVolatile)
Get a source buffer for MainFilePath, handling all file-to-file and file-to-buffer remappings inside ...
Definition: ASTUnit.cpp:156
Code completion occurred where an macro is being defined.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
static uint64_t getDeclShowContexts(const NamedDecl *ND, const LangOptions &LangOpts, bool &IsNestedNameSpecifier)
Determine the set of code-completion contexts in which this declaration should be shown...
Definition: ASTUnit.cpp:284
PreprocessorOptions & getPreprocessorOpts()
static CharSourceRange makeFileCharRange(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts)
Accepts a range and returns a character range with file locations.
Definition: Lexer.cpp:866
llvm::Error Execute()
Set the source manager&#39;s main input file, and run the action.
Code completion occurred after the "struct" or "class" keyword, to indicate a struct or class name...
llvm::iterator_range< PreprocessingRecord::iterator > getLocalPreprocessingEntities() const
Returns an iterator range for the local preprocessing entities of the local Preprocessor, if this is a parsed source file, or the loaded preprocessing entities of the primary module if this is an AST file.
Definition: ASTUnit.cpp:2599
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:354
IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)
const FullSourceLoc & getLocation() const
Definition: Diagnostic.h:1468
Code completion occurred after the "union" keyword, to indicate a union name.
Code completion occurred where a macro name is expected (without any arguments, in the case of a func...
bool(*)(void *context, const Decl *D) DeclVisitorFn
Type for a function iterating over a number of declarations.
Definition: ASTUnit.h:636
bool includeFixIts() const
Whether to include completion items with small fix-its, e.g.
A builder class used to construct new code-completion strings.
Code completion where an Objective-C instance message is expected.
The name of a declaration.
ASTMutationListener * getASTMutationListener()
Definition: ASTUnit.cpp:720
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: Type.h:976
void enableSourceFileDiagnostics()
Enable source-range based diagnostic messages.
Definition: ASTUnit.cpp:276
bool SingleFileParseMode
When enabled, preprocessor is in a mode for parsing a single file only.
Helper class for holding the data necessary to invoke the compiler.
const HeaderSearchOptions & getHeaderSearchOpts() const
Definition: ASTUnit.h:466
static ASTUnit * LoadFromCompilerInvocationAction(std::shared_ptr< CompilerInvocation > CI, std::shared_ptr< PCHContainerOperations > PCHContainerOps, IntrusiveRefCntPtr< DiagnosticsEngine > Diags, FrontendAction *Action=nullptr, ASTUnit *Unit=nullptr, bool Persistent=true, StringRef ResourceFilesPath=StringRef(), bool OnlyLocalDecls=false, CaptureDiagsKind CaptureDiagnostics=CaptureDiagsKind::None, unsigned PrecompilePreambleAfterNParses=0, bool CacheCodeCompletionResults=false, bool IncludeBriefCommentsInCodeCompletion=false, bool UserFilesAreVolatile=false, std::unique_ptr< ASTUnit > *ErrAST=nullptr)
Create an ASTUnit from a source file, via a CompilerInvocation object, by invoking the optionally pro...
Definition: ASTUnit.cpp:1510
Language
The language for the input, used to select and validate the language standard and possible actions...
SourceLocation getMacroArgExpandedLocation(SourceLocation Loc) const
If Loc points inside a function macro argument, the returned location will be the macro location in w...
top_level_iterator top_level_end()
Definition: ASTUnit.h:509
A map from continuous integer ranges to some value, with a very specialized interface.
Tags, declared with &#39;struct foo;&#39; and referenced with &#39;struct foo&#39;.
Definition: DeclBase.h:127
FrontendOptions - Options for controlling the behavior of the frontend.
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1081
void findFileRegionDecls(FileID File, unsigned Offset, unsigned Length, SmallVectorImpl< Decl *> &Decls)
Get the decls that are contained in a file in the Offset/Length range.
Definition: ASTUnit.cpp:2455
Code completion occurred where a statement (or declaration) is expected in a function, method, or block.
static llvm::ErrorOr< PrecompiledPreamble > Build(const CompilerInvocation &Invocation, const llvm::MemoryBuffer *MainFileBuffer, PreambleBounds Bounds, DiagnosticsEngine &Diagnostics, IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS, std::shared_ptr< PCHContainerOperations > PCHContainerOps, bool StoreInMemory, PreambleCallbacks &Callbacks)
Try to build PrecompiledPreamble for Invocation.
Code completion occurred on the right-hand side of an Objective-C property access expression...
bool Save(StringRef File)
Save this translation unit to a file with the given name.
Definition: ASTUnit.cpp:2292
bool Reparse(std::shared_ptr< PCHContainerOperations > PCHContainerOps, ArrayRef< RemappedFile > RemappedFiles=None, IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)
Reparse the source files using the same command-line options that were originally used to produce thi...
Definition: ASTUnit.cpp:1821
cached_completion_iterator cached_completion_begin()
Definition: ASTUnit.h:616
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:126
SourceLocation getEndOfPreambleFileID() const
Definition: ASTUnit.cpp:2576
TargetInfo & getTarget() const
CodeCompleteOptions CodeCompleteOpts
unsigned Size
Size of the preamble in bytes.
Definition: Lexer.h:60
SourceLocation getEnd() const
ASTWriterData(InMemoryModuleCache &ModuleCache)
Definition: ASTUnit.cpp:220
const ASTContext & getASTContext() const
Definition: ASTUnit.h:439
Defines the PPCallbacks interface.
Keeps track of options that affect how file operations are performed.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2280
static bool serializeUnit(ASTWriter &Writer, SmallVectorImpl< char > &Buffer, Sema &S, bool hasErrors, raw_ostream &OS)
Definition: ASTUnit.cpp:2324
Preprocessor & getPreprocessor() const
Return the current preprocessor.
Code completion occurred within a preprocessor expression.
Code completion occurred where an expression is expected.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
Defines the clang::SourceLocation class and associated facilities.
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:6222
const DiagnosticsEngine & getDiagnostics() const
Definition: ASTUnit.h:429
Code completion inside the filename part of a #include directive.
virtual CodeCompletionAllocator & getAllocator()=0
Retrieve the allocator that will be used to allocate code completion strings.
DiagnosticsEngine & getDiagnostics() const
Definition: Preprocessor.h:900
Priority for a code pattern.
static bool isInMainFile(const clang::Diagnostic &D)
Definition: ASTUnit.cpp:676
const SourceManager & getSourceManager() const
Definition: ASTUnit.h:432
An unspecified code-completion context where we should also add macro completions.
Priority for a nested-name-specifier.
unsigned IncludeFixIts
Include results after corrections (small fix-its), e.g.
Level
The level of the diagnostic, after it has been through mapping.
Definition: Diagnostic.h:152
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:362
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
Definition: DeclBase.cpp:1039
Writes an AST file containing the contents of a translation unit.
Definition: ASTWriter.h:103
serialization::DeclID getDeclID(const Decl *D)
Determine the declaration ID of an already-emitted declaration.
Definition: ASTWriter.cpp:5657
bool hadModuleLoaderFatalFailure() const
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1324
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
Defines the clang::TargetInfo interface.
The AST file is out-of-date relative to its input files, and needs to be regenerated.
Definition: ASTReader.h:393
A SourceLocation and its associated SourceManager.
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
The translation unit is a complete translation unit.
Definition: LangOptions.h:364
SourceLocation getStartOfMainFileID() const
Definition: ASTUnit.cpp:2587
Defines the clang::FrontendAction interface and various convenience abstract classes (clang::ASTFront...
std::unique_ptr< ASTConsumer > takeASTConsumer()
takeASTConsumer - Remove the current AST consumer and give ownership to the caller.
unsigned LoadExternal
Hint whether to load data from the external AST to provide full results.
The AST file was written by a different version of Clang.
Definition: ASTReader.h:396
Code completion occurred on the right-hand side of a member access expression using the dot operator...
SimplifiedTypeClass
A simplified classification of types used when determining "similar" types for code completion...
Code completion occurred where a type name is expected.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:66
unsigned IncludeMacros
Show macros in code completion results.
ASTContext & Context
Definition: Sema.h:374
This represents a decl that may have a name.
Definition: Decl.h:248
bool isTranslationUnit() const
Definition: DeclBase.h:1854
InputKind getInputKind() const
Determine the input kind this AST unit represents.
Definition: ASTUnit.cpp:2667
virtual void BeginSourceFile(const LangOptions &LangOpts, const Preprocessor *PP=nullptr)
Callback to inform the diagnostic client that processing of a source file is beginning.
Definition: Diagnostic.h:1520
const FileEntry * File
The file entry for the module file.
Definition: Module.h:163
const LangOptions & getLangOpts() const
Definition: ASTContext.h:710
SourceLocation getLocation(const FileEntry *File, unsigned Line, unsigned Col) const
Get the source location for the given file:line:col triplet.
Definition: ASTUnit.cpp:2498
llvm::vfs::FileSystem & getVirtualFileSystem() const
Definition: FileManager.h:224
void addPPCallbacks(std::unique_ptr< PPCallbacks > C)
Definition: Preprocessor.h:995
This class handles loading and caching of source files into memory.
SourceLocation getLocation() const
Definition: DeclBase.h:429
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:124
std::vector< Decl * >::iterator top_level_iterator
Definition: ASTUnit.h:500