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