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