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