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  /*DisableValidationKind=*/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  llvm::erase_if(StoredDiags, isNonDriverDiag);
1073 }
1074 
1076  StoredDiagnostics,
1077  SourceManager &SM) {
1078  // The stored diagnostic has the old source manager in it; update
1079  // the locations to refer into the new source manager. Since we've
1080  // been careful to make sure that the source manager's state
1081  // before and after are identical, so that we can reuse the source
1082  // location itself.
1083  for (auto &SD : StoredDiagnostics) {
1084  if (SD.getLocation().isValid()) {
1085  FullSourceLoc Loc(SD.getLocation(), SM);
1086  SD.setLocation(Loc);
1087  }
1088  }
1089 }
1090 
1091 /// Parse the source file into a translation unit using the given compiler
1092 /// invocation, replacing the current translation unit.
1093 ///
1094 /// \returns True if a failure occurred that causes the ASTUnit not to
1095 /// contain any translation-unit information, false otherwise.
1096 bool ASTUnit::Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1097  std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer,
1099  if (!Invocation)
1100  return true;
1101 
1102  if (VFS && FileMgr)
1103  assert(VFS == &FileMgr->getVirtualFileSystem() &&
1104  "VFS passed to Parse and VFS in FileMgr are different");
1105 
1106  auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);
1107  if (OverrideMainBuffer) {
1108  assert(Preamble &&
1109  "No preamble was built, but OverrideMainBuffer is not null");
1110  Preamble->AddImplicitPreamble(*CCInvocation, VFS, OverrideMainBuffer.get());
1111  // VFS may have changed...
1112  }
1113 
1114  // Create the compiler instance to use for building the AST.
1115  std::unique_ptr<CompilerInstance> Clang(
1116  new CompilerInstance(std::move(PCHContainerOps)));
1117 
1118  // Clean up on error, disengage it if the function returns successfully.
1119  auto CleanOnError = llvm::make_scope_exit([&]() {
1120  // Remove the overridden buffer we used for the preamble.
1121  SavedMainFileBuffer = nullptr;
1122 
1123  // Keep the ownership of the data in the ASTUnit because the client may
1124  // want to see the diagnostics.
1125  transferASTDataFromCompilerInstance(*Clang);
1126  FailedParseDiagnostics.swap(StoredDiagnostics);
1127  StoredDiagnostics.clear();
1128  NumStoredDiagnosticsFromDriver = 0;
1129  });
1130 
1131  // Ensure that Clang has a FileManager with the right VFS, which may have
1132  // changed above in AddImplicitPreamble. If VFS is nullptr, rely on
1133  // createFileManager to create one.
1134  if (VFS && FileMgr && &FileMgr->getVirtualFileSystem() == VFS)
1135  Clang->setFileManager(&*FileMgr);
1136  else
1137  FileMgr = Clang->createFileManager(std::move(VFS));
1138 
1139  // Recover resources if we crash before exiting this method.
1140  llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
1141  CICleanup(Clang.get());
1142 
1143  Clang->setInvocation(CCInvocation);
1144  OriginalSourceFile =
1145  std::string(Clang->getFrontendOpts().Inputs[0].getFile());
1146 
1147  // Set up diagnostics, capturing any diagnostics that would
1148  // otherwise be dropped.
1149  Clang->setDiagnostics(&getDiagnostics());
1150 
1151  // Create the target instance.
1152  if (!Clang->createTarget())
1153  return true;
1154 
1155  assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
1156  "Invocation must have exactly one source file!");
1157  assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
1159  "FIXME: AST inputs not yet supported here!");
1160  assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
1162  "IR inputs not support here!");
1163 
1164  // Configure the various subsystems.
1165  LangOpts = Clang->getInvocation().LangOpts;
1166  FileSystemOpts = Clang->getFileSystemOpts();
1167 
1168  ResetForParse();
1169 
1170  SourceMgr = new SourceManager(getDiagnostics(), *FileMgr,
1171  UserFilesAreVolatile);
1172  if (!OverrideMainBuffer) {
1173  checkAndRemoveNonDriverDiags(StoredDiagnostics);
1174  TopLevelDeclsInPreamble.clear();
1175  }
1176 
1177  // Create the source manager.
1178  Clang->setSourceManager(&getSourceManager());
1179 
1180  // If the main file has been overridden due to the use of a preamble,
1181  // make that override happen and introduce the preamble.
1182  if (OverrideMainBuffer) {
1183  // The stored diagnostic has the old source manager in it; update
1184  // the locations to refer into the new source manager. Since we've
1185  // been careful to make sure that the source manager's state
1186  // before and after are identical, so that we can reuse the source
1187  // location itself.
1188  checkAndSanitizeDiags(StoredDiagnostics, getSourceManager());
1189 
1190  // Keep track of the override buffer;
1191  SavedMainFileBuffer = std::move(OverrideMainBuffer);
1192  }
1193 
1194  std::unique_ptr<TopLevelDeclTrackerAction> Act(
1195  new TopLevelDeclTrackerAction(*this));
1196 
1197  // Recover resources if we crash before exiting this method.
1198  llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
1199  ActCleanup(Act.get());
1200 
1201  if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0]))
1202  return true;
1203 
1204  if (SavedMainFileBuffer)
1205  TranslateStoredDiagnostics(getFileManager(), getSourceManager(),
1206  PreambleDiagnostics, StoredDiagnostics);
1207  else
1208  PreambleSrcLocCache.clear();
1209 
1210  if (llvm::Error Err = Act->Execute()) {
1211  consumeError(std::move(Err)); // FIXME this drops errors on the floor.
1212  return true;
1213  }
1214 
1215  transferASTDataFromCompilerInstance(*Clang);
1216 
1217  Act->EndSourceFile();
1218 
1219  FailedParseDiagnostics.clear();
1220 
1221  CleanOnError.release();
1222 
1223  return false;
1224 }
1225 
1226 static std::pair<unsigned, unsigned>
1228  const LangOptions &LangOpts) {
1229  CharSourceRange FileRange = Lexer::makeFileCharRange(Range, SM, LangOpts);
1230  unsigned Offset = SM.getFileOffset(FileRange.getBegin());
1231  unsigned EndOffset = SM.getFileOffset(FileRange.getEnd());
1232  return std::make_pair(Offset, EndOffset);
1233 }
1234 
1236  const LangOptions &LangOpts,
1237  const FixItHint &InFix) {
1238  ASTUnit::StandaloneFixIt OutFix;
1239  OutFix.RemoveRange = makeStandaloneRange(InFix.RemoveRange, SM, LangOpts);
1241  LangOpts);
1242  OutFix.CodeToInsert = InFix.CodeToInsert;
1244  return OutFix;
1245 }
1246 
1249  const StoredDiagnostic &InDiag) {
1251  OutDiag.ID = InDiag.getID();
1252  OutDiag.Level = InDiag.getLevel();
1253  OutDiag.Message = std::string(InDiag.getMessage());
1254  OutDiag.LocOffset = 0;
1255  if (InDiag.getLocation().isInvalid())
1256  return OutDiag;
1257  const SourceManager &SM = InDiag.getLocation().getManager();
1258  SourceLocation FileLoc = SM.getFileLoc(InDiag.getLocation());
1259  OutDiag.Filename = std::string(SM.getFilename(FileLoc));
1260  if (OutDiag.Filename.empty())
1261  return OutDiag;
1262  OutDiag.LocOffset = SM.getFileOffset(FileLoc);
1263  for (const auto &Range : InDiag.getRanges())
1264  OutDiag.Ranges.push_back(makeStandaloneRange(Range, SM, LangOpts));
1265  for (const auto &FixIt : InDiag.getFixIts())
1266  OutDiag.FixIts.push_back(makeStandaloneFixIt(SM, LangOpts, FixIt));
1267 
1268  return OutDiag;
1269 }
1270 
1271 /// Attempt to build or re-use a precompiled preamble when (re-)parsing
1272 /// the source file.
1273 ///
1274 /// This routine will compute the preamble of the main source file. If a
1275 /// non-trivial preamble is found, it will precompile that preamble into a
1276 /// precompiled header so that the precompiled preamble can be used to reduce
1277 /// reparsing time. If a precompiled preamble has already been constructed,
1278 /// this routine will determine if it is still valid and, if so, avoid
1279 /// rebuilding the precompiled preamble.
1280 ///
1281 /// \param AllowRebuild When true (the default), this routine is
1282 /// allowed to rebuild the precompiled preamble if it is found to be
1283 /// out-of-date.
1284 ///
1285 /// \param MaxLines When non-zero, the maximum number of lines that
1286 /// can occur within the preamble.
1287 ///
1288 /// \returns If the precompiled preamble can be used, returns a newly-allocated
1289 /// buffer that should be used in place of the main file when doing so.
1290 /// Otherwise, returns a NULL pointer.
1291 std::unique_ptr<llvm::MemoryBuffer>
1292 ASTUnit::getMainBufferWithPrecompiledPreamble(
1293  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1294  CompilerInvocation &PreambleInvocationIn,
1295  IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS, bool AllowRebuild,
1296  unsigned MaxLines) {
1297  auto MainFilePath =
1298  PreambleInvocationIn.getFrontendOpts().Inputs[0].getFile();
1299  std::unique_ptr<llvm::MemoryBuffer> MainFileBuffer =
1300  getBufferForFileHandlingRemapping(PreambleInvocationIn, VFS.get(),
1301  MainFilePath, UserFilesAreVolatile);
1302  if (!MainFileBuffer)
1303  return nullptr;
1304 
1306  *PreambleInvocationIn.getLangOpts(), *MainFileBuffer, MaxLines);
1307  if (!Bounds.Size)
1308  return nullptr;
1309 
1310  if (Preamble) {
1311  if (Preamble->CanReuse(PreambleInvocationIn, *MainFileBuffer, Bounds,
1312  *VFS)) {
1313  // Okay! We can re-use the precompiled preamble.
1314 
1315  // Set the state of the diagnostic object to mimic its state
1316  // after parsing the preamble.
1317  getDiagnostics().Reset();
1319  PreambleInvocationIn.getDiagnosticOpts());
1320  getDiagnostics().setNumWarnings(NumWarningsInPreamble);
1321 
1322  PreambleRebuildCountdown = 1;
1323  return MainFileBuffer;
1324  } else {
1325  Preamble.reset();
1326  PreambleDiagnostics.clear();
1327  TopLevelDeclsInPreamble.clear();
1328  PreambleSrcLocCache.clear();
1329  PreambleRebuildCountdown = 1;
1330  }
1331  }
1332 
1333  // If the preamble rebuild counter > 1, it's because we previously
1334  // failed to build a preamble and we're not yet ready to try
1335  // again. Decrement the counter and return a failure.
1336  if (PreambleRebuildCountdown > 1) {
1337  --PreambleRebuildCountdown;
1338  return nullptr;
1339  }
1340 
1341  assert(!Preamble && "No Preamble should be stored at that point");
1342  // If we aren't allowed to rebuild the precompiled preamble, just
1343  // return now.
1344  if (!AllowRebuild)
1345  return nullptr;
1346 
1347  ++PreambleCounter;
1348 
1349  SmallVector<StandaloneDiagnostic, 4> NewPreambleDiagsStandalone;
1350  SmallVector<StoredDiagnostic, 4> NewPreambleDiags;
1351  ASTUnitPreambleCallbacks Callbacks;
1352  {
1354  if (CaptureDiagnostics != CaptureDiagsKind::None)
1355  Capture.emplace(CaptureDiagnostics, *Diagnostics, &NewPreambleDiags,
1356  &NewPreambleDiagsStandalone);
1357 
1358  // We did not previously compute a preamble, or it can't be reused anyway.
1359  SimpleTimer PreambleTimer(WantTiming);
1360  PreambleTimer.setOutput("Precompiling preamble");
1361 
1362  const bool PreviousSkipFunctionBodies =
1363  PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies;
1364  if (SkipFunctionBodies == SkipFunctionBodiesScope::Preamble)
1365  PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies = true;
1366 
1367  llvm::ErrorOr<PrecompiledPreamble> NewPreamble = PrecompiledPreamble::Build(
1368  PreambleInvocationIn, MainFileBuffer.get(), Bounds, *Diagnostics, VFS,
1369  PCHContainerOps, /*StoreInMemory=*/false, Callbacks);
1370 
1371  PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies =
1372  PreviousSkipFunctionBodies;
1373 
1374  if (NewPreamble) {
1375  Preamble = std::move(*NewPreamble);
1376  PreambleRebuildCountdown = 1;
1377  } else {
1378  switch (static_cast<BuildPreambleError>(NewPreamble.getError().value())) {
1380  // Try again next time.
1381  PreambleRebuildCountdown = 1;
1382  return nullptr;
1387  // These erros are more likely to repeat, retry after some period.
1388  PreambleRebuildCountdown = DefaultPreambleRebuildInterval;
1389  return nullptr;
1390  }
1391  llvm_unreachable("unexpected BuildPreambleError");
1392  }
1393  }
1394 
1395  assert(Preamble && "Preamble wasn't built");
1396 
1397  TopLevelDecls.clear();
1398  TopLevelDeclsInPreamble = Callbacks.takeTopLevelDeclIDs();
1399  PreambleTopLevelHashValue = Callbacks.getHash();
1400 
1401  NumWarningsInPreamble = getDiagnostics().getNumWarnings();
1402 
1403  checkAndRemoveNonDriverDiags(NewPreambleDiags);
1404  StoredDiagnostics = std::move(NewPreambleDiags);
1405  PreambleDiagnostics = std::move(NewPreambleDiagsStandalone);
1406 
1407  // If the hash of top-level entities differs from the hash of the top-level
1408  // entities the last time we rebuilt the preamble, clear out the completion
1409  // cache.
1410  if (CurrentTopLevelHashValue != PreambleTopLevelHashValue) {
1411  CompletionCacheTopLevelHashValue = 0;
1412  PreambleTopLevelHashValue = CurrentTopLevelHashValue;
1413  }
1414 
1415  return MainFileBuffer;
1416 }
1417 
1418 void ASTUnit::RealizeTopLevelDeclsFromPreamble() {
1419  assert(Preamble && "Should only be called when preamble was built");
1420 
1421  std::vector<Decl *> Resolved;
1422  Resolved.reserve(TopLevelDeclsInPreamble.size());
1424  for (const auto TopLevelDecl : TopLevelDeclsInPreamble) {
1425  // Resolve the declaration ID to an actual declaration, possibly
1426  // deserializing the declaration in the process.
1427  if (Decl *D = Source.GetExternalDecl(TopLevelDecl))
1428  Resolved.push_back(D);
1429  }
1430  TopLevelDeclsInPreamble.clear();
1431  TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end());
1432 }
1433 
1434 void ASTUnit::transferASTDataFromCompilerInstance(CompilerInstance &CI) {
1435  // Steal the created target, context, and preprocessor if they have been
1436  // created.
1437  assert(CI.hasInvocation() && "missing invocation");
1438  LangOpts = CI.getInvocation().LangOpts;
1439  TheSema = CI.takeSema();
1440  Consumer = CI.takeASTConsumer();
1441  if (CI.hasASTContext())
1442  Ctx = &CI.getASTContext();
1443  if (CI.hasPreprocessor())
1444  PP = CI.getPreprocessorPtr();
1445  CI.setSourceManager(nullptr);
1446  CI.setFileManager(nullptr);
1447  if (CI.hasTarget())
1448  Target = &CI.getTarget();
1449  Reader = CI.getASTReader();
1450  HadModuleLoaderFatalFailure = CI.hadModuleLoaderFatalFailure();
1451 }
1452 
1453 StringRef ASTUnit::getMainFileName() const {
1454  if (Invocation && !Invocation->getFrontendOpts().Inputs.empty()) {
1455  const FrontendInputFile &Input = Invocation->getFrontendOpts().Inputs[0];
1456  if (Input.isFile())
1457  return Input.getFile();
1458  else
1459  return Input.getBuffer().getBufferIdentifier();
1460  }
1461 
1462  if (SourceMgr) {
1463  if (const FileEntry *
1464  FE = SourceMgr->getFileEntryForID(SourceMgr->getMainFileID()))
1465  return FE->getName();
1466  }
1467 
1468  return {};
1469 }
1470 
1471 StringRef ASTUnit::getASTFileName() const {
1472  if (!isMainFileAST())
1473  return {};
1474 
1476  Mod = Reader->getModuleManager().getPrimaryModule();
1477  return Mod.FileName;
1478 }
1479 
1480 std::unique_ptr<ASTUnit>
1481 ASTUnit::create(std::shared_ptr<CompilerInvocation> CI,
1483  CaptureDiagsKind CaptureDiagnostics,
1484  bool UserFilesAreVolatile) {
1485  std::unique_ptr<ASTUnit> AST(new ASTUnit(false));
1486  ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1488  createVFSFromCompilerInvocation(*CI, *Diags);
1489  AST->Diagnostics = Diags;
1490  AST->FileSystemOpts = CI->getFileSystemOpts();
1491  AST->Invocation = std::move(CI);
1492  AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS);
1493  AST->UserFilesAreVolatile = UserFilesAreVolatile;
1494  AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr,
1495  UserFilesAreVolatile);
1496  AST->ModuleCache = new InMemoryModuleCache;
1497 
1498  return AST;
1499 }
1500 
1502  std::shared_ptr<CompilerInvocation> CI,
1503  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1505  ASTUnit *Unit, bool Persistent, StringRef ResourceFilesPath,
1506  bool OnlyLocalDecls, CaptureDiagsKind CaptureDiagnostics,
1507  unsigned PrecompilePreambleAfterNParses, bool CacheCodeCompletionResults,
1508  bool UserFilesAreVolatile, std::unique_ptr<ASTUnit> *ErrAST) {
1509  assert(CI && "A CompilerInvocation is required");
1510 
1511  std::unique_ptr<ASTUnit> OwnAST;
1512  ASTUnit *AST = Unit;
1513  if (!AST) {
1514  // Create the AST unit.
1515  OwnAST = create(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile);
1516  AST = OwnAST.get();
1517  if (!AST)
1518  return nullptr;
1519  }
1520 
1521  if (!ResourceFilesPath.empty()) {
1522  // Override the resources path.
1523  CI->getHeaderSearchOpts().ResourceDir = std::string(ResourceFilesPath);
1524  }
1525  AST->OnlyLocalDecls = OnlyLocalDecls;
1526  AST->CaptureDiagnostics = CaptureDiagnostics;
1527  if (PrecompilePreambleAfterNParses > 0)
1528  AST->PreambleRebuildCountdown = PrecompilePreambleAfterNParses;
1529  AST->TUKind = Action ? Action->getTranslationUnitKind() : TU_Complete;
1530  AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1531  AST->IncludeBriefCommentsInCodeCompletion = false;
1532 
1533  // Recover resources if we crash before exiting this method.
1534  llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1535  ASTUnitCleanup(OwnAST.get());
1536  llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
1537  llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
1538  DiagCleanup(Diags.get());
1539 
1540  // We'll manage file buffers ourselves.
1541  CI->getPreprocessorOpts().RetainRemappedFileBuffers = true;
1542  CI->getFrontendOpts().DisableFree = false;
1543  ProcessWarningOptions(AST->getDiagnostics(), CI->getDiagnosticOpts());
1544 
1545  // Create the compiler instance to use for building the AST.
1546  std::unique_ptr<CompilerInstance> Clang(
1547  new CompilerInstance(std::move(PCHContainerOps)));
1548 
1549  // Recover resources if we crash before exiting this method.
1550  llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
1551  CICleanup(Clang.get());
1552 
1553  Clang->setInvocation(std::move(CI));
1554  AST->OriginalSourceFile =
1555  std::string(Clang->getFrontendOpts().Inputs[0].getFile());
1556 
1557  // Set up diagnostics, capturing any diagnostics that would
1558  // otherwise be dropped.
1559  Clang->setDiagnostics(&AST->getDiagnostics());
1560 
1561  // Create the target instance.
1562  if (!Clang->createTarget())
1563  return nullptr;
1564 
1565  assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
1566  "Invocation must have exactly one source file!");
1567  assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
1569  "FIXME: AST inputs not yet supported here!");
1570  assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
1572  "IR inputs not support here!");
1573 
1574  // Configure the various subsystems.
1575  AST->TheSema.reset();
1576  AST->Ctx = nullptr;
1577  AST->PP = nullptr;
1578  AST->Reader = nullptr;
1579 
1580  // Create a file manager object to provide access to and cache the filesystem.
1581  Clang->setFileManager(&AST->getFileManager());
1582 
1583  // Create the source manager.
1584  Clang->setSourceManager(&AST->getSourceManager());
1585 
1586  FrontendAction *Act = Action;
1587 
1588  std::unique_ptr<TopLevelDeclTrackerAction> TrackerAct;
1589  if (!Act) {
1590  TrackerAct.reset(new TopLevelDeclTrackerAction(*AST));
1591  Act = TrackerAct.get();
1592  }
1593 
1594  // Recover resources if we crash before exiting this method.
1595  llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
1596  ActCleanup(TrackerAct.get());
1597 
1598  if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
1599  AST->transferASTDataFromCompilerInstance(*Clang);
1600  if (OwnAST && ErrAST)
1601  ErrAST->swap(OwnAST);
1602 
1603  return nullptr;
1604  }
1605 
1606  if (Persistent && !TrackerAct) {
1607  Clang->getPreprocessor().addPPCallbacks(
1608  std::make_unique<MacroDefinitionTrackerPPCallbacks>(
1609  AST->getCurrentTopLevelHashValue()));
1610  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
1611  if (Clang->hasASTConsumer())
1612  Consumers.push_back(Clang->takeASTConsumer());
1613  Consumers.push_back(std::make_unique<TopLevelDeclTrackerConsumer>(
1614  *AST, AST->getCurrentTopLevelHashValue()));
1615  Clang->setASTConsumer(
1616  std::make_unique<MultiplexConsumer>(std::move(Consumers)));
1617  }
1618  if (llvm::Error Err = Act->Execute()) {
1619  consumeError(std::move(Err)); // FIXME this drops errors on the floor.
1620  AST->transferASTDataFromCompilerInstance(*Clang);
1621  if (OwnAST && ErrAST)
1622  ErrAST->swap(OwnAST);
1623 
1624  return nullptr;
1625  }
1626 
1627  // Steal the created target, context, and preprocessor.
1628  AST->transferASTDataFromCompilerInstance(*Clang);
1629 
1630  Act->EndSourceFile();
1631 
1632  if (OwnAST)
1633  return OwnAST.release();
1634  else
1635  return AST;
1636 }
1637 
1638 bool ASTUnit::LoadFromCompilerInvocation(
1639  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1640  unsigned PrecompilePreambleAfterNParses,
1642  if (!Invocation)
1643  return true;
1644 
1645  assert(VFS && "VFS is null");
1646 
1647  // We'll manage file buffers ourselves.
1648  Invocation->getPreprocessorOpts().RetainRemappedFileBuffers = true;
1649  Invocation->getFrontendOpts().DisableFree = false;
1650  getDiagnostics().Reset();
1651  ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
1652 
1653  std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
1654  if (PrecompilePreambleAfterNParses > 0) {
1655  PreambleRebuildCountdown = PrecompilePreambleAfterNParses;
1656  OverrideMainBuffer =
1657  getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);
1658  getDiagnostics().Reset();
1659  ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
1660  }
1661 
1662  SimpleTimer ParsingTimer(WantTiming);
1663  ParsingTimer.setOutput("Parsing " + getMainFileName());
1664 
1665  // Recover resources if we crash before exiting this method.
1666  llvm::CrashRecoveryContextCleanupRegistrar<llvm::MemoryBuffer>
1667  MemBufferCleanup(OverrideMainBuffer.get());
1668 
1669  return Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
1670 }
1671 
1672 std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation(
1673  std::shared_ptr<CompilerInvocation> CI,
1674  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1676  bool OnlyLocalDecls, CaptureDiagsKind CaptureDiagnostics,
1677  unsigned PrecompilePreambleAfterNParses, TranslationUnitKind TUKind,
1678  bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion,
1679  bool UserFilesAreVolatile) {
1680  // Create the AST unit.
1681  std::unique_ptr<ASTUnit> AST(new ASTUnit(false));
1682  ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1683  AST->Diagnostics = Diags;
1684  AST->OnlyLocalDecls = OnlyLocalDecls;
1685  AST->CaptureDiagnostics = CaptureDiagnostics;
1686  AST->TUKind = TUKind;
1687  AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1688  AST->IncludeBriefCommentsInCodeCompletion
1689  = IncludeBriefCommentsInCodeCompletion;
1690  AST->Invocation = std::move(CI);
1691  AST->FileSystemOpts = FileMgr->getFileSystemOpts();
1692  AST->FileMgr = FileMgr;
1693  AST->UserFilesAreVolatile = UserFilesAreVolatile;
1694 
1695  // Recover resources if we crash before exiting this method.
1696  llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1697  ASTUnitCleanup(AST.get());
1698  llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
1699  llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>
1700  DiagCleanup(Diags.get());
1701 
1702  if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
1703  PrecompilePreambleAfterNParses,
1704  &AST->FileMgr->getVirtualFileSystem()))
1705  return nullptr;
1706  return AST;
1707 }
1708 
1710  const char **ArgBegin, const char **ArgEnd,
1711  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1712  IntrusiveRefCntPtr<DiagnosticsEngine> Diags, StringRef ResourceFilesPath,
1713  bool OnlyLocalDecls, CaptureDiagsKind CaptureDiagnostics,
1714  ArrayRef<RemappedFile> RemappedFiles, bool RemappedFilesKeepOriginalName,
1715  unsigned PrecompilePreambleAfterNParses, TranslationUnitKind TUKind,
1716  bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion,
1717  bool AllowPCHWithCompilerErrors, SkipFunctionBodiesScope SkipFunctionBodies,
1718  bool SingleFileParse, bool UserFilesAreVolatile, bool ForSerialization,
1719  bool RetainExcludedConditionalBlocks,
1720  llvm::Optional<StringRef> ModuleFormat, std::unique_ptr<ASTUnit> *ErrAST,
1722  assert(Diags.get() && "no DiagnosticsEngine was provided");
1723 
1724  SmallVector<StoredDiagnostic, 4> StoredDiagnostics;
1725 
1726  std::shared_ptr<CompilerInvocation> CI;
1727 
1728  {
1729  CaptureDroppedDiagnostics Capture(CaptureDiagnostics, *Diags,
1730  &StoredDiagnostics, nullptr);
1731 
1733  llvm::makeArrayRef(ArgBegin, ArgEnd), Diags, VFS);
1734  if (!CI)
1735  return nullptr;
1736  }
1737 
1738  // Override any files that need remapping
1739  for (const auto &RemappedFile : RemappedFiles) {
1740  CI->getPreprocessorOpts().addRemappedFile(RemappedFile.first,
1741  RemappedFile.second);
1742  }
1743  PreprocessorOptions &PPOpts = CI->getPreprocessorOpts();
1744  PPOpts.RemappedFilesKeepOriginalName = RemappedFilesKeepOriginalName;
1745  PPOpts.AllowPCHWithCompilerErrors = AllowPCHWithCompilerErrors;
1746  PPOpts.SingleFileParseMode = SingleFileParse;
1747  PPOpts.RetainExcludedConditionalBlocks = RetainExcludedConditionalBlocks;
1748 
1749  // Override the resources path.
1750  CI->getHeaderSearchOpts().ResourceDir = std::string(ResourceFilesPath);
1751 
1752  CI->getFrontendOpts().SkipFunctionBodies =
1753  SkipFunctionBodies == SkipFunctionBodiesScope::PreambleAndMainFile;
1754 
1755  if (ModuleFormat)
1756  CI->getHeaderSearchOpts().ModuleFormat =
1757  std::string(ModuleFormat.getValue());
1758 
1759  // Create the AST unit.
1760  std::unique_ptr<ASTUnit> AST;
1761  AST.reset(new ASTUnit(false));
1762  AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size();
1763  AST->StoredDiagnostics.swap(StoredDiagnostics);
1764  ConfigureDiags(Diags, *AST, CaptureDiagnostics);
1765  AST->Diagnostics = Diags;
1766  AST->FileSystemOpts = CI->getFileSystemOpts();
1767  if (!VFS)
1768  VFS = llvm::vfs::getRealFileSystem();
1769  VFS = createVFSFromCompilerInvocation(*CI, *Diags, VFS);
1770  AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS);
1771  AST->ModuleCache = new InMemoryModuleCache;
1772  AST->OnlyLocalDecls = OnlyLocalDecls;
1773  AST->CaptureDiagnostics = CaptureDiagnostics;
1774  AST->TUKind = TUKind;
1775  AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1776  AST->IncludeBriefCommentsInCodeCompletion
1777  = IncludeBriefCommentsInCodeCompletion;
1778  AST->UserFilesAreVolatile = UserFilesAreVolatile;
1779  AST->Invocation = CI;
1780  AST->SkipFunctionBodies = SkipFunctionBodies;
1781  if (ForSerialization)
1782  AST->WriterData.reset(new ASTWriterData(*AST->ModuleCache));
1783  // Zero out now to ease cleanup during crash recovery.
1784  CI = nullptr;
1785  Diags = nullptr;
1786 
1787  // Recover resources if we crash before exiting this method.
1788  llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1789  ASTUnitCleanup(AST.get());
1790 
1791  if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
1792  PrecompilePreambleAfterNParses,
1793  VFS)) {
1794  // Some error occurred, if caller wants to examine diagnostics, pass it the
1795  // ASTUnit.
1796  if (ErrAST) {
1797  AST->StoredDiagnostics.swap(AST->FailedParseDiagnostics);
1798  ErrAST->swap(AST);
1799  }
1800  return nullptr;
1801  }
1802 
1803  return AST.release();
1804 }
1805 
1806 bool ASTUnit::Reparse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
1807  ArrayRef<RemappedFile> RemappedFiles,
1809  if (!Invocation)
1810  return true;
1811 
1812  if (!VFS) {
1813  assert(FileMgr && "FileMgr is null on Reparse call");
1814  VFS = &FileMgr->getVirtualFileSystem();
1815  }
1816 
1817  clearFileLevelDecls();
1818 
1819  SimpleTimer ParsingTimer(WantTiming);
1820  ParsingTimer.setOutput("Reparsing " + getMainFileName());
1821 
1822  // Remap files.
1823  PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1824  for (const auto &RB : PPOpts.RemappedFileBuffers)
1825  delete RB.second;
1826 
1827  Invocation->getPreprocessorOpts().clearRemappedFiles();
1828  for (const auto &RemappedFile : RemappedFiles) {
1829  Invocation->getPreprocessorOpts().addRemappedFile(RemappedFile.first,
1830  RemappedFile.second);
1831  }
1832 
1833  // If we have a preamble file lying around, or if we might try to
1834  // build a precompiled preamble, do so now.
1835  std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
1836  if (Preamble || PreambleRebuildCountdown > 0)
1837  OverrideMainBuffer =
1838  getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS);
1839 
1840  // Clear out the diagnostics state.
1841  FileMgr.reset();
1842  getDiagnostics().Reset();
1843  ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
1844  if (OverrideMainBuffer)
1845  getDiagnostics().setNumWarnings(NumWarningsInPreamble);
1846 
1847  // Parse the sources
1848  bool Result =
1849  Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
1850 
1851  // If we're caching global code-completion results, and the top-level
1852  // declarations have changed, clear out the code-completion cache.
1853  if (!Result && ShouldCacheCodeCompletionResults &&
1854  CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue)
1855  CacheCodeCompletionResults();
1856 
1857  // We now need to clear out the completion info related to this translation
1858  // unit; it'll be recreated if necessary.
1859  CCTUInfo.reset();
1860 
1861  return Result;
1862 }
1863 
1865  SavedMainFileBuffer.reset();
1866 
1867  SourceMgr.reset();
1868  TheSema.reset();
1869  Ctx.reset();
1870  PP.reset();
1871  Reader.reset();
1872 
1873  TopLevelDecls.clear();
1874  clearFileLevelDecls();
1875 }
1876 
1877 //----------------------------------------------------------------------------//
1878 // Code completion
1879 //----------------------------------------------------------------------------//
1880 
1881 namespace {
1882 
1883  /// Code completion consumer that combines the cached code-completion
1884  /// results from an ASTUnit with the code-completion results provided to it,
1885  /// then passes the result on to
1886  class AugmentedCodeCompleteConsumer : public CodeCompleteConsumer {
1887  uint64_t NormalContexts;
1888  ASTUnit &AST;
1889  CodeCompleteConsumer &Next;
1890 
1891  public:
1892  AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next,
1893  const CodeCompleteOptions &CodeCompleteOpts)
1894  : CodeCompleteConsumer(CodeCompleteOpts), AST(AST), Next(Next) {
1895  // Compute the set of contexts in which we will look when we don't have
1896  // any information about the specific context.
1897  NormalContexts
1911 
1912  if (AST.getASTContext().getLangOpts().CPlusPlus)
1913  NormalContexts |= (1LL << CodeCompletionContext::CCC_EnumTag)
1916  }
1917 
1918  void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context,
1919  CodeCompletionResult *Results,
1920  unsigned NumResults) override;
1921 
1922  void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
1923  OverloadCandidate *Candidates,
1924  unsigned NumCandidates,
1925  SourceLocation OpenParLoc,
1926  bool Braced) override {
1927  Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates,
1928  OpenParLoc, Braced);
1929  }
1930 
1931  CodeCompletionAllocator &getAllocator() override {
1932  return Next.getAllocator();
1933  }
1934 
1935  CodeCompletionTUInfo &getCodeCompletionTUInfo() override {
1936  return Next.getCodeCompletionTUInfo();
1937  }
1938  };
1939 
1940 } // namespace
1941 
1942 /// Helper function that computes which global names are hidden by the
1943 /// local code-completion results.
1944 static void CalculateHiddenNames(const CodeCompletionContext &Context,
1945  CodeCompletionResult *Results,
1946  unsigned NumResults,
1947  ASTContext &Ctx,
1948  llvm::StringSet<llvm::BumpPtrAllocator> &HiddenNames){
1949  bool OnlyTagNames = false;
1950  switch (Context.getKind()) {
1969  break;
1970 
1974  OnlyTagNames = true;
1975  break;
1976 
1993  // We're looking for nothing, or we're looking for names that cannot
1994  // be hidden.
1995  return;
1996  }
1997 
1998  using Result = CodeCompletionResult;
1999  for (unsigned I = 0; I != NumResults; ++I) {
2000  if (Results[I].Kind != Result::RK_Declaration)
2001  continue;
2002 
2003  unsigned IDNS
2004  = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace();
2005 
2006  bool Hiding = false;
2007  if (OnlyTagNames)
2008  Hiding = (IDNS & Decl::IDNS_Tag);
2009  else {
2010  unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member |
2013  if (Ctx.getLangOpts().CPlusPlus)
2014  HiddenIDNS |= Decl::IDNS_Tag;
2015  Hiding = (IDNS & HiddenIDNS);
2016  }
2017 
2018  if (!Hiding)
2019  continue;
2020 
2021  DeclarationName Name = Results[I].Declaration->getDeclName();
2022  if (IdentifierInfo *Identifier = Name.getAsIdentifierInfo())
2023  HiddenNames.insert(Identifier->getName());
2024  else
2025  HiddenNames.insert(Name.getAsString());
2026  }
2027 }
2028 
2029 void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S,
2030  CodeCompletionContext Context,
2031  CodeCompletionResult *Results,
2032  unsigned NumResults) {
2033  // Merge the results we were given with the results we cached.
2034  bool AddedResult = false;
2035  uint64_t InContexts =
2036  Context.getKind() == CodeCompletionContext::CCC_Recovery
2037  ? NormalContexts : (1LL << Context.getKind());
2038  // Contains the set of names that are hidden by "local" completion results.
2039  llvm::StringSet<llvm::BumpPtrAllocator> HiddenNames;
2040  using Result = CodeCompletionResult;
2041  SmallVector<Result, 8> AllResults;
2043  C = AST.cached_completion_begin(),
2044  CEnd = AST.cached_completion_end();
2045  C != CEnd; ++C) {
2046  // If the context we are in matches any of the contexts we are
2047  // interested in, we'll add this result.
2048  if ((C->ShowInContexts & InContexts) == 0)
2049  continue;
2050 
2051  // If we haven't added any results previously, do so now.
2052  if (!AddedResult) {
2053  CalculateHiddenNames(Context, Results, NumResults, S.Context,
2054  HiddenNames);
2055  AllResults.insert(AllResults.end(), Results, Results + NumResults);
2056  AddedResult = true;
2057  }
2058 
2059  // Determine whether this global completion result is hidden by a local
2060  // completion result. If so, skip it.
2061  if (C->Kind != CXCursor_MacroDefinition &&
2062  HiddenNames.count(C->Completion->getTypedText()))
2063  continue;
2064 
2065  // Adjust priority based on similar type classes.
2066  unsigned Priority = C->Priority;
2067  CodeCompletionString *Completion = C->Completion;
2068  if (!Context.getPreferredType().isNull()) {
2069  if (C->Kind == CXCursor_MacroDefinition) {
2070  Priority = getMacroUsagePriority(C->Completion->getTypedText(),
2071  S.getLangOpts(),
2072  Context.getPreferredType()->isAnyPointerType());
2073  } else if (C->Type) {
2076  Context.getPreferredType().getUnqualifiedType());
2078  if (ExpectedSTC == C->TypeClass) {
2079  // We know this type is similar; check for an exact match.
2080  llvm::StringMap<unsigned> &CachedCompletionTypes
2081  = AST.getCachedCompletionTypes();
2082  llvm::StringMap<unsigned>::iterator Pos
2083  = CachedCompletionTypes.find(QualType(Expected).getAsString());
2084  if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type)
2086  else
2088  }
2089  }
2090  }
2091 
2092  // Adjust the completion string, if required.
2093  if (C->Kind == CXCursor_MacroDefinition &&
2094  Context.getKind() == CodeCompletionContext::CCC_MacroNameUse) {
2095  // Create a new code-completion string that just contains the
2096  // macro name, without its arguments.
2097  CodeCompletionBuilder Builder(getAllocator(), getCodeCompletionTUInfo(),
2098  CCP_CodePattern, C->Availability);
2099  Builder.AddTypedTextChunk(C->Completion->getTypedText());
2101  Completion = Builder.TakeString();
2102  }
2103 
2104  AllResults.push_back(Result(Completion, Priority, C->Kind,
2105  C->Availability));
2106  }
2107 
2108  // If we did not add any cached completion results, just forward the
2109  // results we were given to the next consumer.
2110  if (!AddedResult) {
2111  Next.ProcessCodeCompleteResults(S, Context, Results, NumResults);
2112  return;
2113  }
2114 
2115  Next.ProcessCodeCompleteResults(S, Context, AllResults.data(),
2116  AllResults.size());
2117 }
2118 
2120  StringRef File, unsigned Line, unsigned Column,
2121  ArrayRef<RemappedFile> RemappedFiles, bool IncludeMacros,
2122  bool IncludeCodePatterns, bool IncludeBriefComments,
2123  CodeCompleteConsumer &Consumer,
2124  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
2125  DiagnosticsEngine &Diag, LangOptions &LangOpts, SourceManager &SourceMgr,
2126  FileManager &FileMgr, SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics,
2128  if (!Invocation)
2129  return;
2130 
2131  SimpleTimer CompletionTimer(WantTiming);
2132  CompletionTimer.setOutput("Code completion @ " + File + ":" +
2133  Twine(Line) + ":" + Twine(Column));
2134 
2135  auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);
2136 
2137  FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts();
2138  CodeCompleteOptions &CodeCompleteOpts = FrontendOpts.CodeCompleteOpts;
2139  PreprocessorOptions &PreprocessorOpts = CCInvocation->getPreprocessorOpts();
2140 
2141  CodeCompleteOpts.IncludeMacros = IncludeMacros &&
2142  CachedCompletionResults.empty();
2143  CodeCompleteOpts.IncludeCodePatterns = IncludeCodePatterns;
2144  CodeCompleteOpts.IncludeGlobals = CachedCompletionResults.empty();
2145  CodeCompleteOpts.IncludeBriefComments = IncludeBriefComments;
2146  CodeCompleteOpts.LoadExternal = Consumer.loadExternal();
2147  CodeCompleteOpts.IncludeFixIts = Consumer.includeFixIts();
2148 
2149  assert(IncludeBriefComments == this->IncludeBriefCommentsInCodeCompletion);
2150 
2151  FrontendOpts.CodeCompletionAt.FileName = std::string(File);
2152  FrontendOpts.CodeCompletionAt.Line = Line;
2153  FrontendOpts.CodeCompletionAt.Column = Column;
2154 
2155  // Set the language options appropriately.
2156  LangOpts = *CCInvocation->getLangOpts();
2157 
2158  // Spell-checking and warnings are wasteful during code-completion.
2159  LangOpts.SpellChecking = false;
2160  CCInvocation->getDiagnosticOpts().IgnoreWarnings = true;
2161 
2162  std::unique_ptr<CompilerInstance> Clang(
2163  new CompilerInstance(PCHContainerOps));
2164 
2165  // Recover resources if we crash before exiting this method.
2166  llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
2167  CICleanup(Clang.get());
2168 
2169  auto &Inv = *CCInvocation;
2170  Clang->setInvocation(std::move(CCInvocation));
2171  OriginalSourceFile =
2172  std::string(Clang->getFrontendOpts().Inputs[0].getFile());
2173 
2174  // Set up diagnostics, capturing any diagnostics produced.
2175  Clang->setDiagnostics(&Diag);
2176  CaptureDroppedDiagnostics Capture(CaptureDiagsKind::All,
2177  Clang->getDiagnostics(),
2178  &StoredDiagnostics, nullptr);
2179  ProcessWarningOptions(Diag, Inv.getDiagnosticOpts());
2180 
2181  // Create the target instance.
2182  if (!Clang->createTarget()) {
2183  Clang->setInvocation(nullptr);
2184  return;
2185  }
2186 
2187  assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
2188  "Invocation must have exactly one source file!");
2189  assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() ==
2191  "FIXME: AST inputs not yet supported here!");
2192  assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() !=
2194  "IR inputs not support here!");
2195 
2196  // Use the source and file managers that we were given.
2197  Clang->setFileManager(&FileMgr);
2198  Clang->setSourceManager(&SourceMgr);
2199 
2200  // Remap files.
2201  PreprocessorOpts.clearRemappedFiles();
2202  PreprocessorOpts.RetainRemappedFileBuffers = true;
2203  for (const auto &RemappedFile : RemappedFiles) {
2204  PreprocessorOpts.addRemappedFile(RemappedFile.first, RemappedFile.second);
2205  OwnedBuffers.push_back(RemappedFile.second);
2206  }
2207 
2208  // Use the code completion consumer we were given, but adding any cached
2209  // code-completion results.
2210  AugmentedCodeCompleteConsumer *AugmentedConsumer
2211  = new AugmentedCodeCompleteConsumer(*this, Consumer, CodeCompleteOpts);
2212  Clang->setCodeCompletionConsumer(AugmentedConsumer);
2213 
2214  auto getUniqueID =
2215  [&FileMgr](StringRef Filename) -> Optional<llvm::sys::fs::UniqueID> {
2216  if (auto Status = FileMgr.getVirtualFileSystem().status(Filename))
2217  return Status->getUniqueID();
2218  return None;
2219  };
2220 
2221  auto hasSameUniqueID = [getUniqueID](StringRef LHS, StringRef RHS) {
2222  if (LHS == RHS)
2223  return true;
2224  if (auto LHSID = getUniqueID(LHS))
2225  if (auto RHSID = getUniqueID(RHS))
2226  return *LHSID == *RHSID;
2227  return false;
2228  };
2229 
2230  // If we have a precompiled preamble, try to use it. We only allow
2231  // the use of the precompiled preamble if we're if the completion
2232  // point is within the main file, after the end of the precompiled
2233  // preamble.
2234  std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
2235  if (Preamble && Line > 1 && hasSameUniqueID(File, OriginalSourceFile)) {
2236  OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(
2237  PCHContainerOps, Inv, &FileMgr.getVirtualFileSystem(), false, Line - 1);
2238  }
2239 
2240  // If the main file has been overridden due to the use of a preamble,
2241  // make that override happen and introduce the preamble.
2242  if (OverrideMainBuffer) {
2243  assert(Preamble &&
2244  "No preamble was built, but OverrideMainBuffer is not null");
2245 
2247  &FileMgr.getVirtualFileSystem();
2248  Preamble->AddImplicitPreamble(Clang->getInvocation(), VFS,
2249  OverrideMainBuffer.get());
2250  // FIXME: there is no way to update VFS if it was changed by
2251  // AddImplicitPreamble as FileMgr is accepted as a parameter by this method.
2252  // We use on-disk preambles instead and rely on FileMgr's VFS to ensure the
2253  // PCH files are always readable.
2254  OwnedBuffers.push_back(OverrideMainBuffer.release());
2255  } else {
2256  PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
2257  PreprocessorOpts.PrecompiledPreambleBytes.second = false;
2258  }
2259 
2260  // Disable the preprocessing record if modules are not enabled.
2261  if (!Clang->getLangOpts().Modules)
2262  PreprocessorOpts.DetailedRecord = false;
2263 
2264  std::unique_ptr<SyntaxOnlyAction> Act;
2265  Act.reset(new SyntaxOnlyAction);
2266  if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
2267  if (llvm::Error Err = Act->Execute()) {
2268  consumeError(std::move(Err)); // FIXME this drops errors on the floor.
2269  }
2270  Act->EndSourceFile();
2271  }
2272 }
2273 
2274 bool ASTUnit::Save(StringRef File) {
2275  if (HadModuleLoaderFatalFailure)
2276  return true;
2277 
2278  // Write to a temporary file and later rename it to the actual file, to avoid
2279  // possible race conditions.
2280  SmallString<128> TempPath;
2281  TempPath = File;
2282  TempPath += "-%%%%%%%%";
2283  // FIXME: Can we somehow regenerate the stat cache here, or do we need to
2284  // unconditionally create a stat cache when we parse the file?
2285 
2286  if (llvm::Error Err = llvm::writeFileAtomically(
2287  TempPath, File, [this](llvm::raw_ostream &Out) {
2288  return serialize(Out) ? llvm::make_error<llvm::StringError>(
2289  "ASTUnit serialization failed",
2290  llvm::inconvertibleErrorCode())
2291  : llvm::Error::success();
2292  })) {
2293  consumeError(std::move(Err));
2294  return true;
2295  }
2296  return false;
2297 }
2298 
2299 static bool serializeUnit(ASTWriter &Writer,
2300  SmallVectorImpl<char> &Buffer,
2301  Sema &S,
2302  bool hasErrors,
2303  raw_ostream &OS) {
2304  Writer.WriteAST(S, std::string(), nullptr, "", hasErrors);
2305 
2306  // Write the generated bitstream to "Out".
2307  if (!Buffer.empty())
2308  OS.write(Buffer.data(), Buffer.size());
2309 
2310  return false;
2311 }
2312 
2313 bool ASTUnit::serialize(raw_ostream &OS) {
2314  // For serialization we are lenient if the errors were only warn-as-error kind.
2315  bool hasErrors = getDiagnostics().hasUncompilableErrorOccurred();
2316 
2317  if (WriterData)
2318  return serializeUnit(WriterData->Writer, WriterData->Buffer,
2319  getSema(), hasErrors, OS);
2320 
2321  SmallString<128> Buffer;
2322  llvm::BitstreamWriter Stream(Buffer);
2323  InMemoryModuleCache ModuleCache;
2324  ASTWriter Writer(Stream, Buffer, ModuleCache, {});
2325  return serializeUnit(Writer, Buffer, getSema(), hasErrors, OS);
2326 }
2327 
2329 
2330 void ASTUnit::TranslateStoredDiagnostics(
2331  FileManager &FileMgr,
2332  SourceManager &SrcMgr,
2335  // Map the standalone diagnostic into the new source manager. We also need to
2336  // remap all the locations to the new view. This includes the diag location,
2337  // any associated source ranges, and the source ranges of associated fix-its.
2338  // FIXME: There should be a cleaner way to do this.
2340  Result.reserve(Diags.size());
2341 
2342  for (const auto &SD : Diags) {
2343  // Rebuild the StoredDiagnostic.
2344  if (SD.Filename.empty())
2345  continue;
2346  auto FE = FileMgr.getFile(SD.Filename);
2347  if (!FE)
2348  continue;
2349  SourceLocation FileLoc;
2350  auto ItFileID = PreambleSrcLocCache.find(SD.Filename);
2351  if (ItFileID == PreambleSrcLocCache.end()) {
2352  FileID FID = SrcMgr.translateFile(*FE);
2353  FileLoc = SrcMgr.getLocForStartOfFile(FID);
2354  PreambleSrcLocCache[SD.Filename] = FileLoc;
2355  } else {
2356  FileLoc = ItFileID->getValue();
2357  }
2358 
2359  if (FileLoc.isInvalid())
2360  continue;
2361  SourceLocation L = FileLoc.getLocWithOffset(SD.LocOffset);
2362  FullSourceLoc Loc(L, SrcMgr);
2363 
2365  Ranges.reserve(SD.Ranges.size());
2366  for (const auto &Range : SD.Ranges) {
2367  SourceLocation BL = FileLoc.getLocWithOffset(Range.first);
2368  SourceLocation EL = FileLoc.getLocWithOffset(Range.second);
2369  Ranges.push_back(CharSourceRange::getCharRange(BL, EL));
2370  }
2371 
2373  FixIts.reserve(SD.FixIts.size());
2374  for (const auto &FixIt : SD.FixIts) {
2375  FixIts.push_back(FixItHint());
2376  FixItHint &FH = FixIts.back();
2377  FH.CodeToInsert = FixIt.CodeToInsert;
2378  SourceLocation BL = FileLoc.getLocWithOffset(FixIt.RemoveRange.first);
2379  SourceLocation EL = FileLoc.getLocWithOffset(FixIt.RemoveRange.second);
2381  }
2382 
2383  Result.push_back(StoredDiagnostic(SD.Level, SD.ID,
2384  SD.Message, Loc, Ranges, FixIts));
2385  }
2386  Result.swap(Out);
2387 }
2388 
2390  assert(D);
2391 
2392  // We only care about local declarations.
2393  if (D->isFromASTFile())
2394  return;
2395 
2396  SourceManager &SM = *SourceMgr;
2397  SourceLocation Loc = D->getLocation();
2398  if (Loc.isInvalid() || !SM.isLocalSourceLocation(Loc))
2399  return;
2400 
2401  // We only keep track of the file-level declarations of each file.
2402  if (!D->getLexicalDeclContext()->isFileContext())
2403  return;
2404 
2405  SourceLocation FileLoc = SM.getFileLoc(Loc);
2406  assert(SM.isLocalSourceLocation(FileLoc));
2407  FileID FID;
2408  unsigned Offset;
2409  std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc);
2410  if (FID.isInvalid())
2411  return;
2412 
2413  std::unique_ptr<LocDeclsTy> &Decls = FileDecls[FID];
2414  if (!Decls)
2415  Decls = std::make_unique<LocDeclsTy>();
2416 
2417  std::pair<unsigned, Decl *> LocDecl(Offset, D);
2418 
2419  if (Decls->empty() || Decls->back().first <= Offset) {
2420  Decls->push_back(LocDecl);
2421  return;
2422  }
2423 
2424  LocDeclsTy::iterator I =
2425  llvm::upper_bound(*Decls, LocDecl, llvm::less_first());
2426 
2427  Decls->insert(I, LocDecl);
2428 }
2429 
2430 void ASTUnit::findFileRegionDecls(FileID File, unsigned Offset, unsigned Length,
2431  SmallVectorImpl<Decl *> &Decls) {
2432  if (File.isInvalid())
2433  return;
2434 
2435  if (SourceMgr->isLoadedFileID(File)) {
2436  assert(Ctx->getExternalSource() && "No external source!");
2437  return Ctx->getExternalSource()->FindFileRegionDecls(File, Offset, Length,
2438  Decls);
2439  }
2440 
2441  FileDeclsTy::iterator I = FileDecls.find(File);
2442  if (I == FileDecls.end())
2443  return;
2444 
2445  LocDeclsTy &LocDecls = *I->second;
2446  if (LocDecls.empty())
2447  return;
2448 
2449  LocDeclsTy::iterator BeginIt =
2450  llvm::partition_point(LocDecls, [=](std::pair<unsigned, Decl *> LD) {
2451  return LD.first < Offset;
2452  });
2453  if (BeginIt != LocDecls.begin())
2454  --BeginIt;
2455 
2456  // If we are pointing at a top-level decl inside an objc container, we need
2457  // to backtrack until we find it otherwise we will fail to report that the
2458  // region overlaps with an objc container.
2459  while (BeginIt != LocDecls.begin() &&
2460  BeginIt->second->isTopLevelDeclInObjCContainer())
2461  --BeginIt;
2462 
2463  LocDeclsTy::iterator EndIt = llvm::upper_bound(
2464  LocDecls, std::make_pair(Offset + Length, (Decl *)nullptr),
2465  llvm::less_first());
2466  if (EndIt != LocDecls.end())
2467  ++EndIt;
2468 
2469  for (LocDeclsTy::iterator DIt = BeginIt; DIt != EndIt; ++DIt)
2470  Decls.push_back(DIt->second);
2471 }
2472 
2474  unsigned Line, unsigned Col) const {
2475  const SourceManager &SM = getSourceManager();
2476  SourceLocation Loc = SM.translateFileLineCol(File, Line, Col);
2477  return SM.getMacroArgExpandedLocation(Loc);
2478 }
2479 
2481  unsigned Offset) const {
2482  const SourceManager &SM = getSourceManager();
2483  SourceLocation FileLoc = SM.translateFileLineCol(File, 1, 1);
2484  return SM.getMacroArgExpandedLocation(FileLoc.getLocWithOffset(Offset));
2485 }
2486 
2487 /// If \arg Loc is a loaded location from the preamble, returns
2488 /// the corresponding local location of the main file, otherwise it returns
2489 /// \arg Loc.
2491  FileID PreambleID;
2492  if (SourceMgr)
2493  PreambleID = SourceMgr->getPreambleFileID();
2494 
2495  if (Loc.isInvalid() || !Preamble || PreambleID.isInvalid())
2496  return Loc;
2497 
2498  unsigned Offs;
2499  if (SourceMgr->isInFileID(Loc, PreambleID, &Offs) && Offs < Preamble->getBounds().Size) {
2500  SourceLocation FileLoc
2501  = SourceMgr->getLocForStartOfFile(SourceMgr->getMainFileID());
2502  return FileLoc.getLocWithOffset(Offs);
2503  }
2504 
2505  return Loc;
2506 }
2507 
2508 /// If \arg Loc is a local location of the main file but inside the
2509 /// preamble chunk, returns the corresponding loaded location from the
2510 /// preamble, otherwise it returns \arg Loc.
2512  FileID PreambleID;
2513  if (SourceMgr)
2514  PreambleID = SourceMgr->getPreambleFileID();
2515 
2516  if (Loc.isInvalid() || !Preamble || PreambleID.isInvalid())
2517  return Loc;
2518 
2519  unsigned Offs;
2520  if (SourceMgr->isInFileID(Loc, SourceMgr->getMainFileID(), &Offs) &&
2521  Offs < Preamble->getBounds().Size) {
2522  SourceLocation FileLoc = SourceMgr->getLocForStartOfFile(PreambleID);
2523  return FileLoc.getLocWithOffset(Offs);
2524  }
2525 
2526  return Loc;
2527 }
2528 
2530  FileID FID;
2531  if (SourceMgr)
2532  FID = SourceMgr->getPreambleFileID();
2533 
2534  if (Loc.isInvalid() || FID.isInvalid())
2535  return false;
2536 
2537  return SourceMgr->isInFileID(Loc, FID);
2538 }
2539 
2541  FileID FID;
2542  if (SourceMgr)
2543  FID = SourceMgr->getMainFileID();
2544 
2545  if (Loc.isInvalid() || FID.isInvalid())
2546  return false;
2547 
2548  return SourceMgr->isInFileID(Loc, FID);
2549 }
2550 
2552  FileID FID;
2553  if (SourceMgr)
2554  FID = SourceMgr->getPreambleFileID();
2555 
2556  if (FID.isInvalid())
2557  return {};
2558 
2559  return SourceMgr->getLocForEndOfFile(FID);
2560 }
2561 
2563  FileID FID;
2564  if (SourceMgr)
2565  FID = SourceMgr->getMainFileID();
2566 
2567  if (FID.isInvalid())
2568  return {};
2569 
2570  return SourceMgr->getLocForStartOfFile(FID);
2571 }
2572 
2573 llvm::iterator_range<PreprocessingRecord::iterator>
2575  if (isMainFileAST()) {
2577  Mod = Reader->getModuleManager().getPrimaryModule();
2578  return Reader->getModulePreprocessedEntities(Mod);
2579  }
2580 
2581  if (PreprocessingRecord *PPRec = PP->getPreprocessingRecord())
2582  return llvm::make_range(PPRec->local_begin(), PPRec->local_end());
2583 
2584  return llvm::make_range(PreprocessingRecord::iterator(),
2586 }
2587 
2589  if (isMainFileAST()) {
2591  Mod = Reader->getModuleManager().getPrimaryModule();
2592  for (const auto *D : Reader->getModuleFileLevelDecls(Mod)) {
2593  if (!Fn(context, D))
2594  return false;
2595  }
2596 
2597  return true;
2598  }
2599 
2601  TLEnd = top_level_end();
2602  TL != TLEnd; ++TL) {
2603  if (!Fn(context, *TL))
2604  return false;
2605  }
2606 
2607  return true;
2608 }
2609 
2611  if (!Reader)
2612  return nullptr;
2613 
2614  serialization::ModuleFile *Mod = nullptr;
2615  Reader->getModuleManager().visit([&Mod](serialization::ModuleFile &M) {
2616  switch (M.Kind) {
2617  case serialization::MK_ImplicitModule:
2618  case serialization::MK_ExplicitModule:
2619  case serialization::MK_PrebuiltModule:
2620  return true; // skip dependencies.
2621  case serialization::MK_PCH:
2622  Mod = &M;
2623  return true; // found it.
2624  case serialization::MK_Preamble:
2625  return false; // look in dependencies.
2626  case serialization::MK_MainFile:
2627  return false; // look in dependencies.
2628  }
2629 
2630  return true;
2631  });
2632  if (Mod)
2633  return Mod->File;
2634 
2635  return nullptr;
2636 }
2637 
2640 }
2641 
2643  auto &LangOpts = getLangOpts();
2644 
2645  Language Lang;
2646  if (LangOpts.OpenCL)
2647  Lang = Language::OpenCL;
2648  else if (LangOpts.CUDA)
2649  Lang = Language::CUDA;
2650  else if (LangOpts.RenderScript)
2651  Lang = Language::RenderScript;
2652  else if (LangOpts.CPlusPlus)
2653  Lang = LangOpts.ObjC ? Language::ObjCXX : Language::CXX;
2654  else
2655  Lang = LangOpts.ObjC ? Language::ObjC : Language::C;
2656 
2658  if (LangOpts.getCompilingModule() == LangOptions::CMK_ModuleMap)
2659  Fmt = InputKind::ModuleMap;
2660 
2661  // We don't know if input was preprocessed. Assume not.
2662  bool PP = false;
2663 
2664  return InputKind(Lang, Fmt, PP);
2665 }
2666 
2667 #ifndef NDEBUG
2668 ASTUnit::ConcurrencyState::ConcurrencyState() {
2669  Mutex = new std::recursive_mutex;
2670 }
2671 
2672 ASTUnit::ConcurrencyState::~ConcurrencyState() {
2673  delete static_cast<std::recursive_mutex *>(Mutex);
2674 }
2675 
2676 void ASTUnit::ConcurrencyState::start() {
2677  bool acquired = static_cast<std::recursive_mutex *>(Mutex)->try_lock();
2678  assert(acquired && "Concurrent access to ASTUnit!");
2679 }
2680 
2681 void ASTUnit::ConcurrencyState::finish() {
2682  static_cast<std::recursive_mutex *>(Mutex)->unlock();
2683 }
2684 
2685 #else // NDEBUG
2686 
2687 ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex = nullptr; }
2688 ASTUnit::ConcurrencyState::~ConcurrencyState() {}
2689 void ASTUnit::ConcurrencyState::start() {}
2690 void ASTUnit::ConcurrencyState::finish() {}
2691 
2692 #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:892
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:382
clang::Decl::IDNS_Type
@ IDNS_Type
Types, declared with 'struct foo', typedefs, etc.
Definition: DeclBase.h:127
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:2490
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:1159
clang::ASTUnit::StandaloneFixIt::CodeToInsert
std::string CodeToInsert
Definition: ASTUnit.h:94
clang::CharSourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:283
clang::ASTReader::HadErrors
@ HadErrors
The AST file has errors.
Definition: ASTReader.h:388
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:1501
clang::FullSourceLoc
A SourceLocation and its associated SourceManager.
Definition: SourceLocation.h:368
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:1341
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:447
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:371
llvm::SmallVector
Definition: LLVM.h:38
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::LangOptions::isCompilingModule
bool isCompilingModule() const
Are we compiling a module interface (.cppm or module map)?
Definition: LangOptions.h:393
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:134
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:247
TargetInfo.h
clang::NamedDecl::getUnderlyingDecl
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:457
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:2588
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:674
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:989
clang::ASTUnit::isInMainFileID
bool isInMainFileID(SourceLocation Loc) const
Definition: ASTUnit.cpp:2540
clang::DiagnosticConsumer
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1722
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:2429
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:1705
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:1016
SourceManager.h
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::ASTUnit::enableSourceFileDiagnostics
void enableSourceFileDiagnostics()
Enable source-range based diagnostic messages.
Definition: ASTUnit.cpp:279
clang::StoredDiagnostic::getMessage
StringRef getMessage() const
Definition: Diagnostic.h:1695
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:57
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:840
clang::sema::Capture
Definition: ScopeInfo.h:528
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:2437
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:1754
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:3923
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:143
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:2274
clang::FrontendInputFile::getFile
StringRef getFile() const
Definition: FrontendOptions.h:216
clang::StoredDiagnostic::getID
unsigned getID() const
Definition: Diagnostic.h:1692
CompilerInvocation.h
clang::Preprocessor::getIdentifierTable
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:967
clang::PCHContainerReader
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
Definition: PCHContainerOperations.h:55
clang::ASTUnit::getEndOfPreambleFileID
SourceLocation getEndOfPreambleFileID() const
Definition: ASTUnit.cpp:2551
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:410
clang::Preprocessor::getLangOpts
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:960
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:168
Decl.h
DeclObjC.h
clang::ParsedSourceLocation::Line
unsigned Line
Definition: CommandLineSourceLoc.h:26
Offset
unsigned Offset
Definition: Format.cpp:2431
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:1715
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:1547
clang::Sema::getLangOpts
const LangOptions & getLangOpts() const
Definition: Sema.h:1590
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:2574
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:265
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:837
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:561
clang::getAsString
llvm::StringRef getAsString(SyncScope S)
Definition: SyncScope.h:55
clang::ASTContext::getExternalSource
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
Definition: ASTContext.h:1156
clang::ASTReader::Success
@ Success
The control block was read successfully.
Definition: ASTReader.h:368
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:1806
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:2562
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:1533
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:561
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:209
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:170
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:969
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:2642
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:1929
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:1864
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:2478
clang::ASTContext::getCommentCommandTraits
comments::CommandTraits & getCommentCommandTraits() const
Definition: ASTContext.h:924
clang::CompilerInstance::getPreprocessor
Preprocessor & getPreprocessor() const
Return the current preprocessor.
Definition: CompilerInstance.h:442
clang::TargetInfo::CreateTargetInfo
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)
Construct a target for the given options.
Definition: Targets.cpp:668
clang::Preprocessor::setCounterValue
void setCounterValue(unsigned V)
Definition: Preprocessor.h:2028
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:851
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:462
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:83
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:2119
Line
const AnnotatedLine * Line
Definition: UsingDeclarationsSorter.cpp:68
DeclGroup.h
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:2473
clang::CompilerInstance
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Definition: CompilerInstance.h:72
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:133
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:141
ExternalASTSource.h
clang::CompilerInstance::hasTarget
bool hasTarget() const
Definition: CompilerInstance.h:367
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:6530
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:167
clang::StoredDiagnostic
Represents a diagnostic in a form that can be retained until its corresponding source manager is dest...
Definition: Diagnostic.h:1671
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:964
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:137
clang::ASTUnit::getASTFileName
StringRef getASTFileName() const
If this ASTUnit came from an AST file, returns the filename for it.
Definition: ASTUnit.cpp:1471
ASTBitCodes.h
clang::getSimplifiedTypeClass
SimplifiedTypeClass getSimplifiedTypeClass(CanQualType T)
Determine the simplified type class of the given canonical type.
Definition: SemaCodeComplete.cpp:841
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:492
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:1694
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:1746
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:710
clang::Preprocessor::getBuiltinInfo
Builtin::Context & getBuiltinInfo()
Definition: Preprocessor.h:970
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:439
LangStandard.h
clang::Diagnostic::getLocation
const SourceLocation & getLocation() const
Definition: Diagnostic.h:1558
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:5363
CXCursor_MacroDefinition
@ CXCursor_MacroDefinition
Definition: Index.h:2666
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:378
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:739
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:83
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:229
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:1155
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:1481
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:806
makeStandaloneFixIt
static ASTUnit::StandaloneFixIt makeStandaloneFixIt(const SourceManager &SM, const LangOptions &LangOpts, const FixItHint &InFix)
Definition: ASTUnit.cpp:1235
clang::CharSourceRange
Represents a character-granular source range.
Definition: SourceLocation.h:253
clang::FrontendAction::Execute
llvm::Error Execute()
Set the source manager's main input file, and run the action.
Definition: FrontendAction.cpp:960
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:385
clang::Sema
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:354
clang::Decl::IDNS_NonMemberOperator
@ IDNS_NonMemberOperator
This declaration is a C++ operator declared in a non-class context.
Definition: DeclBase.h:165
FrontendActions.h
ASTUnit.h
LLVM.h
clang::CompilerInstance::hadModuleLoaderFatalFailure
bool hadModuleLoaderFatalFailure() const
Definition: CompilerInstance.h:803
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:1560
clang::StoredDiagnostic::getLevel
DiagnosticsEngine::Level getLevel() const
Definition: Diagnostic.h:1693
clang::ASTContext::setPrintingPolicy
void setPrintingPolicy(const clang::PrintingPolicy &Policy)
Definition: ASTContext.h:689
clang::CharSourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:284
clang::DeclContext::isFileContext
bool isFileContext() const
Definition: DeclBase.h:1924
clang::ASTUnit::StandaloneDiagnostic
Definition: ASTUnit.h:98
clang::createVFSFromCompilerInvocation
IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)
Definition: CompilerInvocation.cpp:4662
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:84
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:2299
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:2511
PCHContainerOperations.h
Priority
int Priority
Definition: Format.cpp:2433
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:4403
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:340
clang::BuildPreambleError::CouldntEmitPCH
@ CouldntEmitPCH
clang::TranslationUnitKind
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:704
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:369
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:195
clang::Builtin::ID
ID
Definition: Builtins.h:48
clang::SourceLocation::isInvalid
bool isInvalid() const
Definition: SourceLocation.h:111
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:1058
makeStandaloneRange
static std::pair< unsigned, unsigned > makeStandaloneRange(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts)
Definition: ASTUnit.cpp:1227
clang::ASTUnit::serialize
bool serialize(raw_ostream &OS)
Serialize this translation unit with the given output stream.
Definition: ASTUnit.cpp:2313
PPCallbacks.h
clang::ASTUnit::addFileLevelDecl
void addFileLevelDecl(Decl *D)
Add a new local file-level declaration.
Definition: ASTUnit.cpp:2389
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::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
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:910
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:957
clang::ASTUnit::isInPreambleFileID
bool isInPreambleFileID(SourceLocation Loc) const
Definition: ASTUnit.cpp:2529
clang::ASTReaderListener
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:112
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:38
clang::CompilerInvocation
Helper class for holding the data necessary to invoke the compiler.
Definition: CompilerInvocation.h:193
clang::CCP_CodePattern
@ CCP_CodePattern
Priority for a code pattern.
Definition: CodeCompleteConsumer.h:78
clang::ASTReader::VersionMismatch
@ VersionMismatch
The AST file was written by a different version of Clang.
Definition: ASTReader.h:381
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:110
clang::CCP_NestedNameSpecifier
@ CCP_NestedNameSpecifier
Priority for a nested-name-specifier.
Definition: CodeCompleteConsumer.h:93
clang::ASTUnit::getMainFileName
StringRef getMainFileName() const
Definition: ASTUnit.cpp:1453
clang::FileID::isInvalid
bool isInvalid() const
Definition: SourceLocation.h:45
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:161
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:1248
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:1075
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:1559
clang::TU_Complete
@ TU_Complete
The translation unit is a complete translation unit.
Definition: LangOptions.h:706
CompilerInstance.h
clang::serialization::MK_MainFile
@ MK_MainFile
File is a PCH file treated as the actual main file.
Definition: ModuleFile.h:56
clang::PreprocessorOptions::clearRemappedFiles
void clearRemappedFiles()
Definition: PreprocessorOptions.h:234
clang::CompilerInstance::getASTReader
IntrusiveRefCntPtr< ASTReader > getASTReader() const
Definition: CompilerInstance.cpp:199
clang::LangOptions::CommentOpts
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:353
clang::ASTUnit::getPCHFile
const FileEntry * getPCHFile()
Get the PCH file if one was included.
Definition: ASTUnit.cpp:2610
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::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:126
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:2430
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:1944
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:165
SM
#define SM(sm)
Definition: Cuda.cpp:81
clang::CompilerInstance::takeSema
std::unique_ptr< Sema > takeSema()
Definition: CompilerInstance.cpp:195
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:1279
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:1654
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:424
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:122
clang::DiagnosticsEngine::setNumWarnings
void setNumWarnings(unsigned NumWarnings)
Definition: Diagnostic.h:853
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:111
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:227
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:763
clang::ASTUnit::isModuleFile
bool isModuleFile() const
Returns true if the ASTUnit was constructed from a serialized module file.
Definition: ASTUnit.cpp:2638
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:460
clang::serialization::ModuleFile::Kind
ModuleKind Kind
The type of this module.
Definition: ModuleFile.h:123
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:1709
clang::Decl::getDeclContext
DeclContext * getDeclContext()
Definition: DeclBase.h:433
clang::SkipFunctionBodiesScope::PreambleAndMainFile
@ PreambleAndMainFile
clang::ASTReader::Missing
@ Missing
The AST file was missing.
Definition: ASTReader.h:374
clang::Preprocessor::getPreprocessingRecord
PreprocessingRecord * getPreprocessingRecord() const
Retrieve the preprocessing record, or NULL if there is no preprocessing record.
Definition: Preprocessor.h:1329
MultiplexConsumer.h