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