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