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