//===- ASTUnit.cpp - ASTUnit utility --------------------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// ASTUnit Implementation.

//

//===----------------------------------------------------------------------===//

#include "clang/Frontend/ASTUnit.h"

#include "clang/AST/ASTConsumer.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/CommentCommandTraits.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclBase.h"

#include "clang/AST/DeclCXX.h"

#include "clang/AST/DeclGroup.h"

#include "clang/AST/DeclObjC.h"

#include "clang/AST/DeclTemplate.h"

#include "clang/AST/DeclarationName.h"

#include "clang/AST/ExternalASTSource.h"

#include "clang/AST/PrettyPrinter.h"

#include "clang/AST/Type.h"

#include "clang/AST/TypeOrdering.h"

#include "clang/Basic/Diagnostic.h"

#include "clang/Basic/FileManager.h"

#include "clang/Basic/IdentifierTable.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/LangStandard.h"

#include "clang/Basic/Module.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/SourceManager.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/Basic/TargetOptions.h"

#include "clang/Frontend/CompilerInstance.h"

#include "clang/Frontend/CompilerInvocation.h"

#include "clang/Frontend/FrontendAction.h"

#include "clang/Frontend/FrontendActions.h"

#include "clang/Frontend/FrontendDiagnostic.h"

#include "clang/Frontend/FrontendOptions.h"

#include "clang/Frontend/MultiplexConsumer.h"

#include "clang/Frontend/PrecompiledPreamble.h"

#include "clang/Frontend/Utils.h"

#include "clang/Lex/HeaderSearch.h"

#include "clang/Lex/HeaderSearchOptions.h"

#include "clang/Lex/Lexer.h"

#include "clang/Lex/PPCallbacks.h"

#include "clang/Lex/PreprocessingRecord.h"

#include "clang/Lex/Preprocessor.h"

#include "clang/Lex/PreprocessorOptions.h"

#include "clang/Lex/Token.h"

#include "clang/Sema/CodeCompleteConsumer.h"

#include "clang/Sema/CodeCompleteOptions.h"

#include "clang/Sema/Sema.h"

#include "clang/Serialization/ASTBitCodes.h"

#include "clang/Serialization/ASTReader.h"

#include "clang/Serialization/ASTWriter.h"

#include "clang/Serialization/ContinuousRangeMap.h"

#include "clang/Serialization/InMemoryModuleCache.h"

#include "clang/Serialization/ModuleFile.h"

#include "clang/Serialization/PCHContainerOperations.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/IntrusiveRefCntPtr.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/ScopeExit.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringMap.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/StringSet.h"

#include "llvm/ADT/Twine.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/Bitstream/BitstreamWriter.h"

#include "llvm/Support/Allocator.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/CrashRecoveryContext.h"

#include "llvm/Support/DJB.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/ErrorOr.h"

#include "llvm/Support/FileSystem.h"

#include "llvm/Support/MemoryBuffer.h"

#include "llvm/Support/SaveAndRestore.h"

#include "llvm/Support/Timer.h"

#include "llvm/Support/VirtualFileSystem.h"

#include "llvm/Support/raw_ostream.h"

#include <algorithm>

#include <atomic>

#include <cassert>

#include <cstdint>

#include <cstdio>

#include <cstdlib>

#include <memory>

#include <mutex>

#include <optional>

#include <string>

#include <tuple>

#include <utility>

#include <vector>

using namespace clang;

using llvm::TimeRecord;

namespace {

  class SimpleTimer {

    bool WantTiming;

    TimeRecord Start;

    std::string Output;

  public:

    explicit SimpleTimer(bool WantTiming) : WantTiming(WantTiming) {

      if (WantTiming)

        Start = TimeRecord::getCurrentTime();

    }

    ~SimpleTimer() {

      if (WantTiming) {

        TimeRecord Elapsed = TimeRecord::getCurrentTime();

        Elapsed -= Start;

        llvm::errs() << Output << ':';

        Elapsed.print(Elapsed, llvm::errs());

        llvm::errs() << '\n';

      }

    }

    void setOutput(const Twine &Output) {

      if (WantTiming)

        this->Output = Output.str();

    }

  };

} // namespace

template <class T>

static std::unique_ptr<T> valueOrNull(llvm::ErrorOr<std::unique_ptr<T>> Val) {

  if (!Val)

    return nullptr;

  return std::move(*Val);

}

template <class T>

static bool moveOnNoError(llvm::ErrorOr<T> Val, T &Output) {

  if (!Val)

    return false;

  Output = std::move(*Val);

  return true;

}

/// Get a source buffer for \p MainFilePath, handling all file-to-file

/// and file-to-buffer remappings inside \p Invocation.

static std::unique_ptr<llvm::MemoryBuffer>

getBufferForFileHandlingRemapping(const CompilerInvocation &Invocation,

                                  llvm::vfs::FileSystem *VFS,

                                  StringRef FilePath, bool isVolatile) {

  const auto &PreprocessorOpts = Invocation.getPreprocessorOpts();

  // Try to determine if the main file has been remapped, either from the

  // command line (to another file) or directly through the compiler

  // invocation (to a memory buffer).

  llvm::MemoryBuffer *Buffer = nullptr;

  std::unique_ptr<llvm::MemoryBuffer> BufferOwner;

  auto FileStatus = VFS->status(FilePath);

  if (FileStatus) {

    llvm::sys::fs::UniqueID MainFileID = FileStatus->getUniqueID();

    // Check whether there is a file-file remapping of the main file

    for (const auto &RF : PreprocessorOpts.RemappedFiles) {

      std::string MPath(RF.first);

      auto MPathStatus = VFS->status(MPath);

      if (MPathStatus) {

        llvm::sys::fs::UniqueID MID = MPathStatus->getUniqueID();

        if (MainFileID == MID) {

          // We found a remapping. Try to load the resulting, remapped source.

          BufferOwner = valueOrNull(VFS->getBufferForFile(RF.second, -1, true, isVolatile));

          if (!BufferOwner)

            return nullptr;

        }

      }

    }

    // Check whether there is a file-buffer remapping. It supercedes the

    // file-file remapping.

    for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) {

      std::string MPath(RB.first);

      auto MPathStatus = VFS->status(MPath);

      if (MPathStatus) {

        llvm::sys::fs::UniqueID MID = MPathStatus->getUniqueID();

        if (MainFileID == MID) {

          // We found a remapping.

          BufferOwner.reset();

          Buffer = const_cast<llvm::MemoryBuffer *>(RB.second);

        }

      }

    }

  }

  // If the main source file was not remapped, load it now.

  if (!Buffer && !BufferOwner) {

    BufferOwner = valueOrNull(VFS->getBufferForFile(FilePath, -1, true, isVolatile));

    if (!BufferOwner)

      return nullptr;

  }

  if (BufferOwner)

    return BufferOwner;

  if (!Buffer)

    return nullptr;

  return llvm::MemoryBuffer::getMemBufferCopy(Buffer->getBuffer(), FilePath);

}

struct ASTUnit::ASTWriterData {

  SmallString<128> Buffer;

  llvm::BitstreamWriter Stream;

  ASTWriter Writer;

  ASTWriterData(InMemoryModuleCache &ModuleCache)

      : Stream(Buffer), Writer(Stream, Buffer, ModuleCache, {}) {}

};

void ASTUnit::clearFileLevelDecls() {

  FileDecls.clear();

}

/// After failing to build a precompiled preamble (due to

/// errors in the source that occurs in the preamble), the number of

/// reparses during which we'll skip even trying to precompile the

/// preamble.

const unsigned DefaultPreambleRebuildInterval = 5;

/// Tracks the number of ASTUnit objects that are currently active.

///

/// Used for debugging purposes only.

static std::atomic<unsigned> ActiveASTUnitObjects;

ASTUnit::ASTUnit(bool _MainFileIsAST)

    : MainFileIsAST(_MainFileIsAST), WantTiming(getenv("LIBCLANG_TIMING")),

      ShouldCacheCodeCompletionResults(false),

      IncludeBriefCommentsInCodeCompletion(false), UserFilesAreVolatile(false),

      UnsafeToFree(false) {

  if (getenv("LIBCLANG_OBJTRACKING"))

    fprintf(stderr, "+++ %u translation units\n", ++ActiveASTUnitObjects);

}

ASTUnit::~ASTUnit() {

  // If we loaded from an AST file, balance out the BeginSourceFile call.

  if (MainFileIsAST && getDiagnostics().getClient()) {

    getDiagnostics().getClient()->EndSourceFile();

  }

  clearFileLevelDecls();

  // Free the buffers associated with remapped files. We are required to

  // perform this operation here because we explicitly request that the

  // compiler instance *not* free these buffers for each invocation of the

  // parser.

  if (Invocation && OwnsRemappedFileBuffers) {

    PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();

    for (const auto &RB : PPOpts.RemappedFileBuffers)

      delete RB.second;

  }

  ClearCachedCompletionResults();

  if (getenv("LIBCLANG_OBJTRACKING"))

    fprintf(stderr, "--- %u translation units\n", --ActiveASTUnitObjects);

}

void ASTUnit::setPreprocessor(std::shared_ptr<Preprocessor> PP) {

  this->PP = std::move(PP);

}

void ASTUnit::enableSourceFileDiagnostics() {

  assert(getDiagnostics().getClient() && Ctx &&

      "Bad context for source file");

  getDiagnostics().getClient()->BeginSourceFile(Ctx->getLangOpts(), PP.get());

}

/// Determine the set of code-completion contexts in which this

/// declaration should be shown.

static uint64_t getDeclShowContexts(const NamedDecl *ND,

                                    const LangOptions &LangOpts,

                                    bool &IsNestedNameSpecifier) {

  IsNestedNameSpecifier = false;

  if (isa<UsingShadowDecl>(ND))

    ND = ND->getUnderlyingDecl();

  if (!ND)

    return 0;

  uint64_t Contexts = 0;

  if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND) ||

      isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND) ||

      isa<TypeAliasTemplateDecl>(ND)) {

    // Types can appear in these contexts.

    if (LangOpts.CPlusPlus || !isa<TagDecl>(ND))

      Contexts |= (1LL << CodeCompletionContext::CCC_TopLevel)

               |  (1LL << CodeCompletionContext::CCC_ObjCIvarList)

               |  (1LL << CodeCompletionContext::CCC_ClassStructUnion)

               |  (1LL << CodeCompletionContext::CCC_Statement)

               |  (1LL << CodeCompletionContext::CCC_Type)

               |  (1LL << CodeCompletionContext::CCC_ParenthesizedExpression);

    // In C++, types can appear in expressions contexts (for functional casts).

    if (LangOpts.CPlusPlus)

      Contexts |= (1LL << CodeCompletionContext::CCC_Expression);

    // In Objective-C, message sends can send interfaces. In Objective-C++,

    // all types are available due to functional casts.

    if (LangOpts.CPlusPlus || isa<ObjCInterfaceDecl>(ND))

      Contexts |= (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver);

    // In Objective-C, you can only be a subclass of another Objective-C class

    if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) {

      // Objective-C interfaces can be used in a class property expression.

      if (ID->getDefinition())

        Contexts |= (1LL << CodeCompletionContext::CCC_Expression);

      Contexts |= (1LL << CodeCompletionContext::CCC_ObjCInterfaceName);

      Contexts |= (1LL << CodeCompletionContext::CCC_ObjCClassForwardDecl);

    }

    // Deal with tag names.

    if (isa<EnumDecl>(ND)) {

      Contexts |= (1LL << CodeCompletionContext::CCC_EnumTag);

      // Part of the nested-name-specifier in C++0x.

      if (LangOpts.CPlusPlus11)

        IsNestedNameSpecifier = true;

    } else if (const auto *Record = dyn_cast<RecordDecl>(ND)) {

      if (Record->isUnion())

        Contexts |= (1LL << CodeCompletionContext::CCC_UnionTag);

      else

        Contexts |= (1LL << CodeCompletionContext::CCC_ClassOrStructTag);

      if (LangOpts.CPlusPlus)

        IsNestedNameSpecifier = true;

    } else if (isa<ClassTemplateDecl>(ND))

      IsNestedNameSpecifier = true;

  } else if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) {

    // Values can appear in these contexts.

    Contexts = (1LL << CodeCompletionContext::CCC_Statement)

             | (1LL << CodeCompletionContext::CCC_Expression)

             | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression)

             | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver);

  } else if (isa<ObjCProtocolDecl>(ND)) {

    Contexts = (1LL << CodeCompletionContext::CCC_ObjCProtocolName);

  } else if (isa<ObjCCategoryDecl>(ND)) {

    Contexts = (1LL << CodeCompletionContext::CCC_ObjCCategoryName);

  } else if (isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) {

    Contexts = (1LL << CodeCompletionContext::CCC_Namespace);

    // Part of the nested-name-specifier.

    IsNestedNameSpecifier = true;

  }

  return Contexts;

}

void ASTUnit::CacheCodeCompletionResults() {

  if (!TheSema)

    return;

  SimpleTimer Timer(WantTiming);

  Timer.setOutput("Cache global code completions for " + getMainFileName());

  // Clear out the previous results.

  ClearCachedCompletionResults();

  // Gather the set of global code completions.

  using Result = CodeCompletionResult;

  SmallVector<Result, 8> Results;

  CachedCompletionAllocator = std::make_shared<GlobalCodeCompletionAllocator>();

  CodeCompletionTUInfo CCTUInfo(CachedCompletionAllocator);

  TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator,

                                       CCTUInfo, Results);

  // Translate global code completions into cached completions.

  llvm::DenseMap<CanQualType, unsigned> CompletionTypes;

  CodeCompletionContext CCContext(CodeCompletionContext::CCC_TopLevel);

  for (auto &R : Results) {

    switch (R.Kind) {

    case Result::RK_Declaration: {

      bool IsNestedNameSpecifier = false;

      CachedCodeCompletionResult CachedResult;

      CachedResult.Completion = R.CreateCodeCompletionString(

          *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,

          IncludeBriefCommentsInCodeCompletion);

      CachedResult.ShowInContexts = getDeclShowContexts(

          R.Declaration, Ctx->getLangOpts(), IsNestedNameSpecifier);

      CachedResult.Priority = R.Priority;

      CachedResult.Kind = R.CursorKind;

      CachedResult.Availability = R.Availability;

      // Keep track of the type of this completion in an ASTContext-agnostic

      // way.

      QualType UsageType = getDeclUsageType(*Ctx, R.Declaration);

      if (UsageType.isNull()) {

        CachedResult.TypeClass = STC_Void;

        CachedResult.Type = 0;

      } else {

        CanQualType CanUsageType

          = Ctx->getCanonicalType(UsageType.getUnqualifiedType());

        CachedResult.TypeClass = getSimplifiedTypeClass(CanUsageType);

        // Determine whether we have already seen this type. If so, we save

        // ourselves the work of formatting the type string by using the

        // temporary, CanQualType-based hash table to find the associated value.

        unsigned &TypeValue = CompletionTypes[CanUsageType];

        if (TypeValue == 0) {

          TypeValue = CompletionTypes.size();

          CachedCompletionTypes[QualType(CanUsageType).getAsString()]

            = TypeValue;

        }

        CachedResult.Type = TypeValue;

      }

      CachedCompletionResults.push_back(CachedResult);

      /// Handle nested-name-specifiers in C++.

      if (TheSema->Context.getLangOpts().CPlusPlus && IsNestedNameSpecifier &&

          !R.StartsNestedNameSpecifier) {

        // The contexts in which a nested-name-specifier can appear in C++.

        uint64_t NNSContexts

          = (1LL << CodeCompletionContext::CCC_TopLevel)

          | (1LL << CodeCompletionContext::CCC_ObjCIvarList)

          | (1LL << CodeCompletionContext::CCC_ClassStructUnion)

          | (1LL << CodeCompletionContext::CCC_Statement)

          | (1LL << CodeCompletionContext::CCC_Expression)

          | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver)

          | (1LL << CodeCompletionContext::CCC_EnumTag)

          | (1LL << CodeCompletionContext::CCC_UnionTag)

          | (1LL << CodeCompletionContext::CCC_ClassOrStructTag)

          | (1LL << CodeCompletionContext::CCC_Type)

          | (1LL << CodeCompletionContext::CCC_SymbolOrNewName)

          | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression);

        if (isa<NamespaceDecl>(R.Declaration) ||

            isa<NamespaceAliasDecl>(R.Declaration))

          NNSContexts |= (1LL << CodeCompletionContext::CCC_Namespace);

        if (uint64_t RemainingContexts

                                = NNSContexts & ~CachedResult.ShowInContexts) {

          // If there any contexts where this completion can be a

          // nested-name-specifier but isn't already an option, create a

          // nested-name-specifier completion.

          R.StartsNestedNameSpecifier = true;

          CachedResult.Completion = R.CreateCodeCompletionString(

              *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,

              IncludeBriefCommentsInCodeCompletion);

          CachedResult.ShowInContexts = RemainingContexts;

          CachedResult.Priority = CCP_NestedNameSpecifier;

          CachedResult.TypeClass = STC_Void;

          CachedResult.Type = 0;

          CachedCompletionResults.push_back(CachedResult);

        }

      }

      break;

    }

    case Result::RK_Keyword:

    case Result::RK_Pattern:

      // Ignore keywords and patterns; we don't care, since they are so

      // easily regenerated.

      break;

    case Result::RK_Macro: {

      CachedCodeCompletionResult CachedResult;

      CachedResult.Completion = R.CreateCodeCompletionString(

          *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,

          IncludeBriefCommentsInCodeCompletion);

      CachedResult.ShowInContexts

        = (1LL << CodeCompletionContext::CCC_TopLevel)

        | (1LL << CodeCompletionContext::CCC_ObjCInterface)

        | (1LL << CodeCompletionContext::CCC_ObjCImplementation)

        | (1LL << CodeCompletionContext::CCC_ObjCIvarList)

        | (1LL << CodeCompletionContext::CCC_ClassStructUnion)

        | (1LL << CodeCompletionContext::CCC_Statement)

        | (1LL << CodeCompletionContext::CCC_Expression)

        | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver)

        | (1LL << CodeCompletionContext::CCC_MacroNameUse)

        | (1LL << CodeCompletionContext::CCC_PreprocessorExpression)

        | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression)

        | (1LL << CodeCompletionContext::CCC_OtherWithMacros);

      CachedResult.Priority = R.Priority;

      CachedResult.Kind = R.CursorKind;

      CachedResult.Availability = R.Availability;

      CachedResult.TypeClass = STC_Void;

      CachedResult.Type = 0;

      CachedCompletionResults.push_back(CachedResult);

      break;

    }

    }

  }

  // Save the current top-level hash value.

  CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue;

}

void ASTUnit::ClearCachedCompletionResults() {

  CachedCompletionResults.clear();

  CachedCompletionTypes.clear();

  CachedCompletionAllocator = nullptr;

}

namespace {

/// Gathers information from ASTReader that will be used to initialize

/// a Preprocessor.

class ASTInfoCollector : public ASTReaderListener {

  Preprocessor &PP;

  ASTContext *Context;

  HeaderSearchOptions &HSOpts;

  PreprocessorOptions &PPOpts;

  LangOptions &LangOpt;

  std::shared_ptr<TargetOptions> &TargetOpts;

  IntrusiveRefCntPtr<TargetInfo> &Target;

  unsigned &Counter;

  bool InitializedLanguage = false;

  bool InitializedHeaderSearchPaths = false;

public:

  ASTInfoCollector(Preprocessor &PP, ASTContext *Context,

                   HeaderSearchOptions &HSOpts, PreprocessorOptions &PPOpts,

                   LangOptions &LangOpt,

                   std::shared_ptr<TargetOptions> &TargetOpts,

                   IntrusiveRefCntPtr<TargetInfo> &Target, unsigned &Counter)

      : PP(PP), Context(Context), HSOpts(HSOpts), PPOpts(PPOpts),

        LangOpt(LangOpt), TargetOpts(TargetOpts), Target(Target),

        Counter(Counter) {}

  bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,

                           bool AllowCompatibleDifferences) override {

    if (InitializedLanguage)

      return false;

    LangOpt = LangOpts;

    InitializedLanguage = true;

    updated();

    return false;

  }

  bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,

                               StringRef SpecificModuleCachePath,

                               bool Complain) override {

    // llvm::SaveAndRestore doesn't support bit field.

    auto ForceCheckCXX20ModulesInputFiles =

        this->HSOpts.ForceCheckCXX20ModulesInputFiles;

    llvm::SaveAndRestore X(this->HSOpts.UserEntries);

    llvm::SaveAndRestore Y(this->HSOpts.SystemHeaderPrefixes);

    llvm::SaveAndRestore Z(this->HSOpts.VFSOverlayFiles);

    this->HSOpts = HSOpts;

    this->HSOpts.ForceCheckCXX20ModulesInputFiles =

        ForceCheckCXX20ModulesInputFiles;

    return false;

  }

  bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,

                             bool Complain) override {

    if (InitializedHeaderSearchPaths)

      return false;

    this->HSOpts.UserEntries = HSOpts.UserEntries;

    this->HSOpts.SystemHeaderPrefixes = HSOpts.SystemHeaderPrefixes;

    this->HSOpts.VFSOverlayFiles = HSOpts.VFSOverlayFiles;

    // Initialize the FileManager. We can't do this in update(), since that

    // performs the initialization too late (once both target and language

    // options are read).

    PP.getFileManager().setVirtualFileSystem(createVFSFromOverlayFiles(

        HSOpts.VFSOverlayFiles, PP.getDiagnostics(),

        PP.getFileManager().getVirtualFileSystemPtr()));

    InitializedHeaderSearchPaths = true;

    return false;

  }

  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,

                               bool ReadMacros, bool Complain,

                               std::string &SuggestedPredefines) override {

    this->PPOpts = PPOpts;

    return false;

  }

  bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,

                         bool AllowCompatibleDifferences) override {

    // If we've already initialized the target, don't do it again.

    if (Target)

      return false;

    this->TargetOpts = std::make_shared<TargetOptions>(TargetOpts);

    Target =

        TargetInfo::CreateTargetInfo(PP.getDiagnostics(), this->TargetOpts);

    updated();

    return false;

  }

  void ReadCounter(const serialization::ModuleFile &M,

                   unsigned Value) override {

    Counter = Value;

  }

private:

  void updated() {

    if (!Target || !InitializedLanguage)

      return;

    // Inform the target of the language options.

    //

    // FIXME: We shouldn't need to do this, the target should be immutable once

    // created. This complexity should be lifted elsewhere.

    Target->adjust(PP.getDiagnostics(), LangOpt);

    // Initialize the preprocessor.

    PP.Initialize(*Target);

    if (!Context)

      return;

    // Initialize the ASTContext

    Context->InitBuiltinTypes(*Target);

    // Adjust printing policy based on language options.

    Context->setPrintingPolicy(PrintingPolicy(LangOpt));

    // We didn't have access to the comment options when the ASTContext was

    // constructed, so register them now.

    Context->getCommentCommandTraits().registerCommentOptions(

        LangOpt.CommentOpts);

  }

};

/// Diagnostic consumer that saves each diagnostic it is given.

class FilterAndStoreDiagnosticConsumer : public DiagnosticConsumer {

  SmallVectorImpl<StoredDiagnostic> *StoredDiags;

  SmallVectorImpl<ASTUnit::StandaloneDiagnostic> *StandaloneDiags;

  bool CaptureNonErrorsFromIncludes = true;

  const LangOptions *LangOpts = nullptr;

  SourceManager *SourceMgr = nullptr;

public:

  FilterAndStoreDiagnosticConsumer(

      SmallVectorImpl<StoredDiagnostic> *StoredDiags,

      SmallVectorImpl<ASTUnit::StandaloneDiagnostic> *StandaloneDiags,

      bool CaptureNonErrorsFromIncludes)

      : StoredDiags(StoredDiags), StandaloneDiags(StandaloneDiags),

        CaptureNonErrorsFromIncludes(CaptureNonErrorsFromIncludes) {

    assert((StoredDiags || StandaloneDiags) &&

           "No output collections were passed to StoredDiagnosticConsumer.");

  }

  void BeginSourceFile(const LangOptions &LangOpts,

                       const Preprocessor *PP = nullptr) override {

    this->LangOpts = &LangOpts;

    if (PP)

      SourceMgr = &PP->getSourceManager();

  }

  void HandleDiagnostic(DiagnosticsEngine::Level Level,

                        const Diagnostic &Info) override;

};

/// RAII object that optionally captures and filters diagnostics, if

/// there is no diagnostic client to capture them already.

class CaptureDroppedDiagnostics {

  DiagnosticsEngine &Diags;

  FilterAndStoreDiagnosticConsumer Client;

  DiagnosticConsumer *PreviousClient = nullptr;

  std::unique_ptr<DiagnosticConsumer> OwningPreviousClient;

public:

  CaptureDroppedDiagnostics(

      CaptureDiagsKind CaptureDiagnostics, DiagnosticsEngine &Diags,

      SmallVectorImpl<StoredDiagnostic> *StoredDiags,

      SmallVectorImpl<ASTUnit::StandaloneDiagnostic> *StandaloneDiags)

      : Diags(Diags),

        Client(StoredDiags, StandaloneDiags,

               CaptureDiagnostics !=

                   CaptureDiagsKind::AllWithoutNonErrorsFromIncludes) {

    if (CaptureDiagnostics != CaptureDiagsKind::None ||

        Diags.getClient() == nullptr) {

      OwningPreviousClient = Diags.takeClient();

      PreviousClient = Diags.getClient();

      Diags.setClient(&Client, false);

    }

  }

  ~CaptureDroppedDiagnostics() {

    if (Diags.getClient() == &Client)

      Diags.setClient(PreviousClient, !!OwningPreviousClient.release());

  }

};

} // namespace

static ASTUnit::StandaloneDiagnostic

makeStandaloneDiagnostic(const LangOptions &LangOpts,

                         const StoredDiagnostic &InDiag);

static bool isInMainFile(const clang::Diagnostic &D) {

  if (!D.hasSourceManager() || !D.getLocation().isValid())

    return false;

  auto &M = D.getSourceManager();

  return M.isWrittenInMainFile(M.getExpansionLoc(D.getLocation()));

}

void FilterAndStoreDiagnosticConsumer::HandleDiagnostic(

    DiagnosticsEngine::Level Level, const Diagnostic &Info) {

  // Default implementation (Warnings/errors count).

  DiagnosticConsumer::HandleDiagnostic(Level, Info);

  // Only record the diagnostic if it's part of the source manager we know

  // about. This effectively drops diagnostics from modules we're building.

  // FIXME: In the long run, ee don't want to drop source managers from modules.

  if (!Info.hasSourceManager() || &Info.getSourceManager() == SourceMgr) {

    if (!CaptureNonErrorsFromIncludes && Level <= DiagnosticsEngine::Warning &&

        !isInMainFile(Info)) {

      return;

    }

    StoredDiagnostic *ResultDiag = nullptr;

    if (StoredDiags) {

      StoredDiags->emplace_back(Level, Info);

      ResultDiag = &StoredDiags->back();

    }

    if (StandaloneDiags) {

      std::optional<StoredDiagnostic> StoredDiag;

      if (!ResultDiag) {

        StoredDiag.emplace(Level, Info);

        ResultDiag = &*StoredDiag;

      }

      StandaloneDiags->push_back(

          makeStandaloneDiagnostic(*LangOpts, *ResultDiag));

    }

  }

}

IntrusiveRefCntPtr<ASTReader> ASTUnit::getASTReader() const {

  return Reader;

}

ASTMutationListener *ASTUnit::getASTMutationListener() {

  if (WriterData)

    return &WriterData->Writer;

  return nullptr;

}

ASTDeserializationListener *ASTUnit::getDeserializationListener() {

  if (WriterData)

    return &WriterData->Writer;

  return nullptr;

}

std::unique_ptr<llvm::MemoryBuffer>

ASTUnit::getBufferForFile(StringRef Filename, std::string *ErrorStr) {

  assert(FileMgr);

  auto Buffer = FileMgr->getBufferForFile(Filename, UserFilesAreVolatile);

  if (Buffer)

    return std::move(*Buffer);

  if (ErrorStr)

    *ErrorStr = Buffer.getError().message();

  return nullptr;

}

/// Configure the diagnostics object for use with ASTUnit.

void ASTUnit::ConfigureDiags(IntrusiveRefCntPtr<DiagnosticsEngine> Diags,

                             ASTUnit &AST,

                             CaptureDiagsKind CaptureDiagnostics) {

  assert(Diags.get() && "no DiagnosticsEngine was provided");

  if (CaptureDiagnostics != CaptureDiagsKind::None)

    Diags->setClient(new FilterAndStoreDiagnosticConsumer(

        &AST.StoredDiagnostics, nullptr,

        CaptureDiagnostics != CaptureDiagsKind::AllWithoutNonErrorsFromIncludes));

}

std::unique_ptr<ASTUnit> ASTUnit::LoadFromASTFile(

    const std::string &Filename, const PCHContainerReader &PCHContainerRdr,

    WhatToLoad ToLoad, IntrusiveRefCntPtr<DiagnosticsEngine> Diags,

    const FileSystemOptions &FileSystemOpts,

    std::shared_ptr<HeaderSearchOptions> HSOpts, bool OnlyLocalDecls,

    CaptureDiagsKind CaptureDiagnostics, bool AllowASTWithCompilerErrors,

    bool UserFilesAreVolatile, IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) {

  std::unique_ptr<ASTUnit> AST(new ASTUnit(true));

  // Recover resources if we crash before exiting this method.

  llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>

    ASTUnitCleanup(AST.get());

  llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,

    llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>>

    DiagCleanup(Diags.get());

  ConfigureDiags(Diags, *AST, CaptureDiagnostics);

  AST->LangOpts = std::make_shared<LangOptions>();

  AST->OnlyLocalDecls = OnlyLocalDecls;

  AST->CaptureDiagnostics = CaptureDiagnostics;

  AST->Diagnostics = Diags;

  AST->FileMgr = new FileManager(FileSystemOpts, VFS);

  AST->UserFilesAreVolatile = UserFilesAreVolatile;

  AST->SourceMgr = new SourceManager(AST->getDiagnostics(),

                                     AST->getFileManager(),

                                     UserFilesAreVolatile);

  AST->ModuleCache = new InMemoryModuleCache;

  AST->HSOpts = HSOpts ? HSOpts : std::make_shared<HeaderSearchOptions>();

  AST->HSOpts->ModuleFormat = std::string(PCHContainerRdr.getFormats().front());

  AST->HeaderInfo.reset(new HeaderSearch(AST->HSOpts,

                                         AST->getSourceManager(),

                                         AST->getDiagnostics(),

                                         AST->getLangOpts(),

                                         /*Target=*/nullptr));

  AST->PPOpts = std::make_shared<PreprocessorOptions>();

  // Gather Info for preprocessor construction later on.

  HeaderSearch &HeaderInfo = *AST->HeaderInfo;

  AST->PP = std::make_shared<Preprocessor>(

      AST->PPOpts, AST->getDiagnostics(), *AST->LangOpts,

      AST->getSourceManager(), HeaderInfo, AST->ModuleLoader,

      /*IILookup=*/nullptr,

      /*OwnsHeaderSearch=*/false);

  Preprocessor &PP = *AST->PP;

  if (ToLoad >= LoadASTOnly)

    AST->Ctx = new ASTContext(*AST->LangOpts, AST->getSourceManager(),

                              PP.getIdentifierTable(), PP.getSelectorTable(),

                              PP.getBuiltinInfo(),

                              AST->getTranslationUnitKind());

  DisableValidationForModuleKind disableValid =

      DisableValidationForModuleKind::None;

  if (::getenv("LIBCLANG_DISABLE_PCH_VALIDATION"))

    disableValid = DisableValidationForModuleKind::All;

  AST->Reader = new ASTReader(

      PP, *AST->ModuleCache, AST->Ctx.get(), PCHContainerRdr, {},

      /*isysroot=*/"",

      /*DisableValidationKind=*/disableValid, AllowASTWithCompilerErrors);

  unsigned Counter = 0;

  AST->Reader->setListener(std::make_unique<ASTInfoCollector>(

      *AST->PP, AST->Ctx.get(), *AST->HSOpts, *AST->PPOpts, *AST->LangOpts,

      AST->TargetOpts, AST->Target, Counter));

  // Attach the AST reader to the AST context as an external AST

  // source, so that declarations will be deserialized from the

  // AST file as needed.

  // We need the external source to be set up before we read the AST, because

  // eagerly-deserialized declarations may use it.

  if (AST->Ctx)

    AST->Ctx->setExternalSource(AST->Reader);

  switch (AST->Reader->ReadAST(Filename, serialization::MK_MainFile,

                               SourceLocation(), ASTReader::ARR_None)) {

  case ASTReader::Success:

    break;

  case ASTReader::Failure:

  case ASTReader::Missing:

  case ASTReader::OutOfDate:

  case ASTReader::VersionMismatch:

  case ASTReader::ConfigurationMismatch:

  case ASTReader::HadErrors:

    AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch);

    return nullptr;

  }

  AST->OriginalSourceFile = std::string(AST->Reader->getOriginalSourceFile());

  PP.setCounterValue(Counter);

  Module *M = HeaderInfo.lookupModule(AST->getLangOpts().CurrentModule);

  if (M && AST->getLangOpts().isCompilingModule() && M->isNamedModule())

    AST->Ctx->setCurrentNamedModule(M);

  // Create an AST consumer, even though it isn't used.

  if (ToLoad >= LoadASTOnly)

    AST->Consumer.reset(new ASTConsumer);

  // Create a semantic analysis object and tell the AST reader about it.

  if (ToLoad >= LoadEverything) {

    AST->TheSema.reset(new Sema(PP, *AST->Ctx, *AST->Consumer));

    AST->TheSema->Initialize();

    AST->Reader->InitializeSema(*AST->TheSema);

  }

  // Tell the diagnostic client that we have started a source file.

  AST->getDiagnostics().getClient()->BeginSourceFile(PP.getLangOpts(), &PP);

  return AST;

}

/// Add the given macro to the hash of all top-level entities.

static void AddDefinedMacroToHash(const Token &MacroNameTok, unsigned &Hash) {

  Hash = llvm::djbHash(MacroNameTok.getIdentifierInfo()->getName(), Hash);

}

namespace {

/// Preprocessor callback class that updates a hash value with the names

/// of all macros that have been defined by the translation unit.

class MacroDefinitionTrackerPPCallbacks : public PPCallbacks {

  unsigned &Hash;

public:

  explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) {}

  void MacroDefined(const Token &MacroNameTok,

                    const MacroDirective *MD) override {

    AddDefinedMacroToHash(MacroNameTok, Hash);

  }

};

} // namespace

/// Add the given declaration to the hash of all top-level entities.

static void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) {

  if (!D)

    return;

  DeclContext *DC = D->getDeclContext();

  if (!DC)

    return;

  if (!(DC->isTranslationUnit() || DC->getLookupParent()->isTranslationUnit()))

    return;