//===- ASTContext.cpp - Context to hold long-lived AST nodes --------------===//

//

// 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

//

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

//

//  This file implements the ASTContext interface.

//

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

#include "clang/AST/ASTContext.h"

#include "CXXABI.h"

#include "Interp/Context.h"

#include "clang/AST/APValue.h"

#include "clang/AST/ASTConcept.h"

#include "clang/AST/ASTMutationListener.h"

#include "clang/AST/ASTTypeTraits.h"

#include "clang/AST/Attr.h"

#include "clang/AST/AttrIterator.h"

#include "clang/AST/CharUnits.h"

#include "clang/AST/Comment.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclBase.h"

#include "clang/AST/DeclCXX.h"

#include "clang/AST/DeclContextInternals.h"

#include "clang/AST/DeclObjC.h"

#include "clang/AST/DeclOpenMP.h"

#include "clang/AST/DeclTemplate.h"

#include "clang/AST/DeclarationName.h"

#include "clang/AST/DependenceFlags.h"

#include "clang/AST/Expr.h"

#include "clang/AST/ExprCXX.h"

#include "clang/AST/ExprConcepts.h"

#include "clang/AST/ExternalASTSource.h"

#include "clang/AST/Mangle.h"

#include "clang/AST/MangleNumberingContext.h"

#include "clang/AST/NestedNameSpecifier.h"

#include "clang/AST/ParentMapContext.h"

#include "clang/AST/RawCommentList.h"

#include "clang/AST/RecordLayout.h"

#include "clang/AST/Stmt.h"

#include "clang/AST/TemplateBase.h"

#include "clang/AST/TemplateName.h"

#include "clang/AST/Type.h"

#include "clang/AST/TypeLoc.h"

#include "clang/AST/UnresolvedSet.h"

#include "clang/AST/VTableBuilder.h"

#include "clang/Basic/AddressSpaces.h"

#include "clang/Basic/Builtins.h"

#include "clang/Basic/CommentOptions.h"

#include "clang/Basic/ExceptionSpecificationType.h"

#include "clang/Basic/IdentifierTable.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/Linkage.h"

#include "clang/Basic/Module.h"

#include "clang/Basic/ObjCRuntime.h"

#include "clang/Basic/SanitizerBlacklist.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/SourceManager.h"

#include "clang/Basic/Specifiers.h"

#include "clang/Basic/TargetCXXABI.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/Basic/XRayLists.h"

#include "llvm/ADT/APFixedPoint.h"

#include "llvm/ADT/APInt.h"

#include "llvm/ADT/APSInt.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/DenseSet.h"

#include "llvm/ADT/FoldingSet.h"

#include "llvm/ADT/None.h"

#include "llvm/ADT/Optional.h"

#include "llvm/ADT/PointerUnion.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/SmallPtrSet.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/Triple.h"

#include "llvm/Support/Capacity.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/MathExtras.h"

#include "llvm/Support/raw_ostream.h"

#include <algorithm>

#include <cassert>

#include <cstddef>

#include <cstdint>

#include <cstdlib>

#include <map>

#include <memory>

#include <string>

#include <tuple>

#include <utility>

using namespace clang;

enum FloatingRank {

  BFloat16Rank, Float16Rank, HalfRank, FloatRank, DoubleRank, LongDoubleRank, Float128Rank

};

/// \returns location that is relevant when searching for Doc comments related

/// to \p D.

static SourceLocation getDeclLocForCommentSearch(const Decl *D,

                                                 SourceManager &SourceMgr) {

  assert(D);

  // User can not attach documentation to implicit declarations.

  if (D->isImplicit())

    return {};

  // User can not attach documentation to implicit instantiations.

  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {

    if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)

      return {};

  }

  if (const auto *VD = dyn_cast<VarDecl>(D)) {

    if (VD->isStaticDataMember() &&

        VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)

      return {};

  }

  if (const auto *CRD = dyn_cast<CXXRecordDecl>(D)) {

    if (CRD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)

      return {};

  }

  if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {

    TemplateSpecializationKind TSK = CTSD->getSpecializationKind();

    if (TSK == TSK_ImplicitInstantiation ||

        TSK == TSK_Undeclared)

      return {};

  }

  if (const auto *ED = dyn_cast<EnumDecl>(D)) {

    if (ED->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)

      return {};

  }

  if (const auto *TD = dyn_cast<TagDecl>(D)) {

    // When tag declaration (but not definition!) is part of the

    // decl-specifier-seq of some other declaration, it doesn't get comment

    if (TD->isEmbeddedInDeclarator() && 
!TD->isCompleteDefinition()187
)

      return {};

  }

  // TODO: handle comments for function parameters properly.

  if (isa<ParmVarDecl>(D))

    return {};

  // TODO: we could look up template parameter documentation in the template

  // documentation.

  if (isa<TemplateTypeParmDecl>(D) ||

      isa<NonTypeTemplateParmDecl>(D) ||

      isa<TemplateTemplateParmDecl>(D))

    return {};

  // Find declaration location.

  // For Objective-C declarations we generally don't expect to have multiple

  // declarators, thus use declaration starting location as the "declaration

  // location".

  // For all other declarations multiple declarators are used quite frequently,

  // so we use the location of the identifier as the "declaration location".

  if (isa<ObjCMethodDecl>(D) || 
isa<ObjCContainerDecl>(D)25.3k
 ||

      isa<ObjCPropertyDecl>(D) ||

      isa<RedeclarableTemplateDecl>(D) ||

      isa<ClassTemplateSpecializationDecl>(D) ||

      // Allow association with Y across {} in `typedef struct X {} Y`.

      isa<TypedefDecl>(D))

    return D->getBeginLoc();

  else {

    const SourceLocation DeclLoc = D->getLocation();

    if (DeclLoc.isMacroID()) {

      if (isa<TypedefDecl>(D)) {

        // If location of the typedef name is in a macro, it is because being

        // declared via a macro. Try using declaration's starting location as

        // the "declaration location".

        return D->getBeginLoc();

      } else if (const auto *TD = dyn_cast<TagDecl>(D)) {

        // If location of the tag decl is inside a macro, but the spelling of

        // the tag name comes from a macro argument, it looks like a special

        // macro like NS_ENUM is being used to define the tag decl.  In that

        // case, adjust the source location to the expansion loc so that we can

        // attach the comment to the tag decl.

        if (SourceMgr.isMacroArgExpansion(DeclLoc) &&

            TD->isCompleteDefinition())

          return SourceMgr.getExpansionLoc(DeclLoc);

      }

    }

    return DeclLoc;

  }

  return {};

}

RawComment *ASTContext::getRawCommentForDeclNoCacheImpl(

    const Decl *D, const SourceLocation RepresentativeLocForDecl,

    const std::map<unsigned, RawComment *> &CommentsInTheFile) const {

  // If the declaration doesn't map directly to a location in a file, we

  // can't find the comment.

  if (RepresentativeLocForDecl.isInvalid() ||

      !RepresentativeLocForDecl.isFileID())

    return nullptr;

  // If there are no comments anywhere, we won't find anything.

  if (CommentsInTheFile.empty())

    return nullptr;

  // Decompose the location for the declaration and find the beginning of the

  // file buffer.

  const std::pair<FileID, unsigned> DeclLocDecomp =

      SourceMgr.getDecomposedLoc(RepresentativeLocForDecl);

  // Slow path.

  auto OffsetCommentBehindDecl =

      CommentsInTheFile.lower_bound(DeclLocDecomp.second);

  // First check whether we have a trailing comment.

  if (OffsetCommentBehindDecl != CommentsInTheFile.end()) {

    RawComment *CommentBehindDecl = OffsetCommentBehindDecl->second;

    if ((CommentBehindDecl->isDocumentation() ||

         LangOpts.CommentOpts.ParseAllComments) &&

        CommentBehindDecl->isTrailingComment() &&

        (isa<FieldDecl>(D) || 
isa<EnumConstantDecl>(D)157
 || 
isa<VarDecl>(D)141
 ||

         
isa<ObjCMethodDecl>(D)77
 || 
isa<ObjCPropertyDecl>(D)65
)) {

      // Check that Doxygen trailing comment comes after the declaration, starts

      // on the same line and in the same file as the declaration.

      if (SourceMgr.getLineNumber(DeclLocDecomp.first, DeclLocDecomp.second) ==

          Comments.getCommentBeginLine(CommentBehindDecl, DeclLocDecomp.first,

                                       OffsetCommentBehindDecl->first)) {

        return CommentBehindDecl;

      }

    }

  }

  // The comment just after the declaration was not a trailing comment.

  // Let's look at the previous comment.

  if (OffsetCommentBehindDecl == CommentsInTheFile.begin())

    return nullptr;

  auto OffsetCommentBeforeDecl = --OffsetCommentBehindDecl;

  RawComment *CommentBeforeDecl = OffsetCommentBeforeDecl->second;

  // Check that we actually have a non-member Doxygen comment.

  if (!(CommentBeforeDecl->isDocumentation() ||

        LangOpts.CommentOpts.ParseAllComments) ||

      CommentBeforeDecl->isTrailingComment())

    return nullptr;

  // Decompose the end of the comment.

  const unsigned CommentEndOffset =

      Comments.getCommentEndOffset(CommentBeforeDecl);

  // Get the corresponding buffer.

  bool Invalid = false;

  const char *Buffer = SourceMgr.getBufferData(DeclLocDecomp.first,

                                               &Invalid).data();

  if (Invalid)

    return nullptr;

  // Extract text between the comment and declaration.

  StringRef Text(Buffer + CommentEndOffset,

                 DeclLocDecomp.second - CommentEndOffset);

  // There should be no other declarations or preprocessor directives between

  // comment and declaration.

  if (Text.find_first_of(";{}#@") != StringRef::npos)

    return nullptr;

  return CommentBeforeDecl;

}

RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const {

  const SourceLocation DeclLoc = getDeclLocForCommentSearch(D, SourceMgr);

  // If the declaration doesn't map directly to a location in a file, we

  // can't find the comment.

  if (DeclLoc.isInvalid() || 
!DeclLoc.isFileID()22.8k
)

    return nullptr;

  if (ExternalSource && 
!CommentsLoaded12.7k
) {

    ExternalSource->ReadComments();

    CommentsLoaded = true;

  }

  if (Comments.empty())

    return nullptr;

  const FileID File = SourceMgr.getDecomposedLoc(DeclLoc).first;

  const auto CommentsInThisFile = Comments.getCommentsInFile(File);

  if (!CommentsInThisFile || 
CommentsInThisFile->empty()1.54k
)

    return nullptr;

  return getRawCommentForDeclNoCacheImpl(D, DeclLoc, *CommentsInThisFile);

}

void ASTContext::addComment(const RawComment &RC) {

  assert(LangOpts.RetainCommentsFromSystemHeaders ||

         !SourceMgr.isInSystemHeader(RC.getSourceRange().getBegin()));

  Comments.addComment(RC, LangOpts.CommentOpts, BumpAlloc);

}

/// If we have a 'templated' declaration for a template, adjust 'D' to

/// refer to the actual template.

/// If we have an implicit instantiation, adjust 'D' to refer to template.

static const Decl &adjustDeclToTemplate(const Decl &D) {

  if (const auto *FD = dyn_cast<FunctionDecl>(&D)) {

    // Is this function declaration part of a function template?

    if (const FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())

      return *FTD;

    // Nothing to do if function is not an implicit instantiation.

    if (FD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)

      return D;

    // Function is an implicit instantiation of a function template?

    if (const FunctionTemplateDecl *FTD = FD->getPrimaryTemplate())

      return *FTD;

    // Function is instantiated from a member definition of a class template?

    if (const FunctionDecl *MemberDecl =

            FD->getInstantiatedFromMemberFunction())

      return *MemberDecl;

    return D;

  }

  if (const auto *VD = dyn_cast<VarDecl>(&D)) {

    // Static data member is instantiated from a member definition of a class

    // template?

    if (VD->isStaticDataMember())

      if (const VarDecl *MemberDecl = VD->getInstantiatedFromStaticDataMember())

        return *MemberDecl;

    return D;

  }

  if (const auto *CRD = dyn_cast<CXXRecordDecl>(&D)) {

    // Is this class declaration part of a class template?

    if (const ClassTemplateDecl *CTD = CRD->getDescribedClassTemplate())

      return *CTD;

    // Class is an implicit instantiation of a class template or partial

    // specialization?

    if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CRD)) {

      if (CTSD->getSpecializationKind() != TSK_ImplicitInstantiation)

        return D;

      llvm::PointerUnion<ClassTemplateDecl *,

                         ClassTemplatePartialSpecializationDecl *>

          PU = CTSD->getSpecializedTemplateOrPartial();

      return PU.is<ClassTemplateDecl *>()

                 ? *static_cast<const Decl *>(PU.get<ClassTemplateDecl *>())

                 : *static_cast<const Decl *>(

                       PU.get<ClassTemplatePartialSpecializationDecl *>());

    }

    // Class is instantiated from a member definition of a class template?

    if (const MemberSpecializationInfo *Info =

            CRD->getMemberSpecializationInfo())

      return *Info->getInstantiatedFrom();

    return D;

  }

  if (const auto *ED = dyn_cast<EnumDecl>(&D)) {

    // Enum is instantiated from a member definition of a class template?

    if (const EnumDecl *MemberDecl = ED->getInstantiatedFromMemberEnum())

      return *MemberDecl;

    return D;

  }

  // FIXME: Adjust alias templates?

  return D;

}

const RawComment *ASTContext::getRawCommentForAnyRedecl(

                                                const Decl *D,

                                                const Decl **OriginalDecl) const {

  if (!D) {

    if (OriginalDecl)

      OriginalDecl = nullptr;

    return nullptr;

  }

  D = &adjustDeclToTemplate(*D);

  // Any comment directly attached to D?

  {

    auto DeclComment = DeclRawComments.find(D);

    if (DeclComment != DeclRawComments.end()) {

      if (OriginalDecl)

        *OriginalDecl = D;

      return DeclComment->second;

    }

  }

  // Any comment attached to any redeclaration of D?

  const Decl *CanonicalD = D->getCanonicalDecl();

  if (!CanonicalD)

    return nullptr;

  {

    auto RedeclComment = RedeclChainComments.find(CanonicalD);

    if (RedeclComment != RedeclChainComments.end()) {

      if (OriginalDecl)

        *OriginalDecl = RedeclComment->second;

      auto CommentAtRedecl = DeclRawComments.find(RedeclComment->second);

      assert(CommentAtRedecl != DeclRawComments.end() &&

             "This decl is supposed to have comment attached.");

      return CommentAtRedecl->second;

    }

  }

  // Any redeclarations of D that we haven't checked for comments yet?

  // We can't use DenseMap::iterator directly since it'd get invalid.

  auto LastCheckedRedecl = [this, CanonicalD]() -> const Decl * {

    auto LookupRes = CommentlessRedeclChains.find(CanonicalD);

    if (LookupRes != CommentlessRedeclChains.end())

      return LookupRes->second;

    return nullptr;

  }();

  for (const auto Redecl : D->redecls()) {

    assert(Redecl);

    // Skip all redeclarations that have been checked previously.

    if (LastCheckedRedecl) {

      if (LastCheckedRedecl == Redecl) {

        LastCheckedRedecl = nullptr;

      }

      continue;

    }

    const RawComment *RedeclComment = getRawCommentForDeclNoCache(Redecl);

    if (RedeclComment) {

      cacheRawCommentForDecl(*Redecl, *RedeclComment);

      if (OriginalDecl)

        *OriginalDecl = Redecl;

      return RedeclComment;

    }

    CommentlessRedeclChains[CanonicalD] = Redecl;

  }

  if (OriginalDecl)

    *OriginalDecl = nullptr;

  return nullptr;

}

void ASTContext::cacheRawCommentForDecl(const Decl &OriginalD,

                                        const RawComment &Comment) const {

  assert(Comment.isDocumentation() || LangOpts.CommentOpts.ParseAllComments);

  DeclRawComments.try_emplace(&OriginalD, &Comment);

  const Decl *const CanonicalDecl = OriginalD.getCanonicalDecl();

  RedeclChainComments.try_emplace(CanonicalDecl, &OriginalD);

  CommentlessRedeclChains.erase(CanonicalDecl);

}

static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod,

                   SmallVectorImpl<const NamedDecl *> &Redeclared) {

  const DeclContext *DC = ObjCMethod->getDeclContext();

  if (const auto *IMD = dyn_cast<ObjCImplDecl>(DC)) {

    const ObjCInterfaceDecl *ID = IMD->getClassInterface();

    if (!ID)

      return;

    // Add redeclared method here.

    for (const auto *Ext : ID->known_extensions()) {

      if (ObjCMethodDecl *RedeclaredMethod =

            Ext->getMethod(ObjCMethod->getSelector(),

                                  ObjCMethod->isInstanceMethod()))

        Redeclared.push_back(RedeclaredMethod);

    }

  }

}

void ASTContext::attachCommentsToJustParsedDecls(ArrayRef<Decl *> Decls,

                                                 const Preprocessor *PP) {

  if (Comments.empty() || 
Decls.empty()1.04k
)

    return;

  FileID File;

  for (Decl *D : Decls) {

    SourceLocation Loc = D->getLocation();

    if (Loc.isValid()) {

      // See if there are any new comments that are not attached to a decl.

      // The location doesn't have to be precise - we care only about the file.

      File = SourceMgr.getDecomposedLoc(Loc).first;

      break;

    }

  }

  if (File.isInvalid())

    return;

  auto CommentsInThisFile = Comments.getCommentsInFile(File);

  if (!CommentsInThisFile || CommentsInThisFile->empty() ||

      CommentsInThisFile->rbegin()->second->isAttached())

    return;

  // There is at least one comment not attached to a decl.

  // Maybe it should be attached to one of Decls?

  //

  // Note that this way we pick up not only comments that precede the

  // declaration, but also comments that *follow* the declaration -- thanks to

  // the lookahead in the lexer: we've consumed the semicolon and looked

  // ahead through comments.

  
for (const Decl *D : Decls)1.04k
 {

    assert(D);

    if (D->isInvalidDecl())

      continue;

    D = &adjustDeclToTemplate(*D);

    const SourceLocation DeclLoc = getDeclLocForCommentSearch(D, SourceMgr);

    if (DeclLoc.isInvalid() || 
!DeclLoc.isFileID()1.05k
)

      continue;

    if (DeclRawComments.count(D) > 0)

      continue;

    if (RawComment *const DocComment =

            getRawCommentForDeclNoCacheImpl(D, DeclLoc, *CommentsInThisFile)) {

      cacheRawCommentForDecl(*D, *DocComment);

      comments::FullComment *FC = DocComment->parse(*this, PP, D);

      ParsedComments[D->getCanonicalDecl()] = FC;

    }

  }

}

comments::FullComment *ASTContext::cloneFullComment(comments::FullComment *FC,

                                                    const Decl *D) const {

  auto *ThisDeclInfo = new (*this) comments::DeclInfo;

  ThisDeclInfo->CommentDecl = D;

  ThisDeclInfo->IsFilled = false;

  ThisDeclInfo->fill();

  ThisDeclInfo->CommentDecl = FC->getDecl();

  if (!ThisDeclInfo->TemplateParameters)

    ThisDeclInfo->TemplateParameters = FC->getDeclInfo()->TemplateParameters;

  comments::FullComment *CFC =

    new (*this) comments::FullComment(FC->getBlocks(),

                                      ThisDeclInfo);

  return CFC;

}

comments::FullComment *ASTContext::getLocalCommentForDeclUncached(const Decl *D) const {

  const RawComment *RC = getRawCommentForDeclNoCache(D);

  return RC ? 
RC->parse(*this, nullptr, D)54
 : nullptr;

}

comments::FullComment *ASTContext::getCommentForDecl(

                                              const Decl *D,

                                              const Preprocessor *PP) const {

  if (!D || D->isInvalidDecl())

    return nullptr;

  D = &adjustDeclToTemplate(*D);

  const Decl *Canonical = D->getCanonicalDecl();

  llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos =

      ParsedComments.find(Canonical);

  if (Pos != ParsedComments.end()) {

    if (Canonical != D) {

      comments::FullComment *FC = Pos->second;

      comments::FullComment *CFC = cloneFullComment(FC, D);

      return CFC;

    }

    return Pos->second;

  }

  const Decl *OriginalDecl = nullptr;

  const RawComment *RC = getRawCommentForAnyRedecl(D, &OriginalDecl);

  if (!RC) {

    if (isa<ObjCMethodDecl>(D) || 
isa<FunctionDecl>(D)5.86k
) {

      SmallVector<const NamedDecl*, 8> Overridden;

      const auto *OMD = dyn_cast<ObjCMethodDecl>(D);

      if (OMD && 
OMD->isPropertyAccessor()403
)

        if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())

          if (comments::FullComment *FC = getCommentForDecl(PDecl, PP))

            return cloneFullComment(FC, D);

      if (OMD)

        addRedeclaredMethods(OMD, Overridden);

      getOverriddenMethods(dyn_cast<NamedDecl>(D), Overridden);

      for (unsigned i = 0, e = Overridden.size(); i < e; 
i++62
)

        if (comments::FullComment *FC = getCommentForDecl(Overridden[i], PP))

          return cloneFullComment(FC, D);

    }

    else if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {

      // Attach any tag type's documentation to its typedef if latter

      // does not have one of its own.

      QualType QT = TD->getUnderlyingType();

      if (const auto *TT = QT->getAs<TagType>())

        if (const Decl *TD = TT->getDecl())

          if (comments::FullComment *FC = getCommentForDecl(TD, PP))

            return cloneFullComment(FC, D);

    }

    else if (const auto *IC = dyn_cast<ObjCInterfaceDecl>(D)) {

      while (IC->getSuperClass()) {

        IC = IC->getSuperClass();

        if (comments::FullComment *FC = getCommentForDecl(IC, PP))

          return cloneFullComment(FC, D);

      }

    }

    else if (const auto *CD = dyn_cast<ObjCCategoryDecl>(D)) {

      if (const ObjCInterfaceDecl *IC = CD->getClassInterface())

        if (comments::FullComment *FC = getCommentForDecl(IC, PP))

          return cloneFullComment(FC, D);

    }

    else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {

      if (!(RD = RD->getDefinition()))

        return nullptr;

      // Check non-virtual bases.

      for (const auto &I : RD->bases()) {

        if (I.isVirtual() || 
(I.getAccessSpecifier() != AS_public)147
)

          continue;

        QualType Ty = I.getType();

        if (Ty.isNull())

          continue;

        if (const CXXRecordDecl *NonVirtualBase = Ty->getAsCXXRecordDecl()) {

          if (!(NonVirtualBase= NonVirtualBase->getDefinition()))

            continue;

          if (comments::FullComment *FC = getCommentForDecl((NonVirtualBase), PP))

            return cloneFullComment(FC, D);

        }

      }

      // Check virtual bases.

      for (const auto &I : RD->vbases()) {

        if (I.getAccessSpecifier() != AS_public)

          continue;

        QualType Ty = I.getType();

        if (Ty.isNull())

          continue;

        if (const CXXRecordDecl *VirtualBase = Ty->getAsCXXRecordDecl()) {

          if (!(VirtualBase= VirtualBase->getDefinition()))

            continue;

          if (comments::FullComment *FC = getCommentForDecl((VirtualBase), PP))

            return cloneFullComment(FC, D);

        }

      }

    }

    return nullptr;

  }

  // If the RawComment was attached to other redeclaration of this Decl, we

  // should parse the comment in context of that other Decl.  This is important

  // because comments can contain references to parameter names which can be

  // different across redeclarations.

  if (D != OriginalDecl && 
OriginalDecl18
)

    return getCommentForDecl(OriginalDecl, PP);

  comments::FullComment *FC = RC->parse(*this, PP, D);

  ParsedComments[Canonical] = FC;

  return FC;

}

void

ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,

                                                   const ASTContext &C,

                                               TemplateTemplateParmDecl *Parm) {

  ID.AddInteger(Parm->getDepth());

  ID.AddInteger(Parm->getPosition());

  ID.AddBoolean(Parm->isParameterPack());

  TemplateParameterList *Params = Parm->getTemplateParameters();

  ID.AddInteger(Params->size());

  for (TemplateParameterList::const_iterator P = Params->begin(),

                                          PEnd = Params->end();

       P != PEnd; 
++P31.0k
) {

    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {

      ID.AddInteger(0);

      ID.AddBoolean(TTP->isParameterPack());

      const TypeConstraint *TC = TTP->getTypeConstraint();

      ID.AddBoolean(TC != nullptr);

      if (TC)

        TC->getImmediatelyDeclaredConstraint()->Profile(ID, C,

                                                        /*Canonical=*/true);

      if (TTP->isExpandedParameterPack()) {

        ID.AddBoolean(true);

        ID.AddInteger(TTP->getNumExpansionParameters());

      } else

        ID.AddBoolean(false);

      continue;

    }

    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {

      ID.AddInteger(1);

      ID.AddBoolean(NTTP->isParameterPack());

      ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr());

      if (NTTP->isExpandedParameterPack()) {

        ID.AddBoolean(true);

        ID.AddInteger(NTTP->getNumExpansionTypes());

        for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; 
++I3
) {

          QualType T = NTTP->getExpansionType(I);

          ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());

        }

      } else

        ID.AddBoolean(false);

      continue;

    }

    auto *TTP = cast<TemplateTemplateParmDecl>(*P);

    ID.AddInteger(2);

    Profile(ID, C, TTP);

  }

  Expr *RequiresClause = Parm->getTemplateParameters()->getRequiresClause();

  ID.AddBoolean(RequiresClause != nullptr);

  if (RequiresClause)

    RequiresClause->Profile(ID, C, /*Canonical=*/true);

}

static Expr *

canonicalizeImmediatelyDeclaredConstraint(const ASTContext &C, Expr *IDC,

                                          QualType ConstrainedType) {

  // This is a bit ugly - we need to form a new immediately-declared

  // constraint that references the new parameter; this would ideally

  // require semantic analysis (e.g. template<C T> struct S {}; - the

  // converted arguments of C<T> could be an argument pack if C is

  // declared as template<typename... T> concept C = ...).

  // We don't have semantic analysis here so we dig deep into the

  // ready-made constraint expr and change the thing manually.

  ConceptSpecializationExpr *CSE;

  if (const auto *Fold = dyn_cast<CXXFoldExpr>(IDC))

    CSE = cast<ConceptSpecializationExpr>(Fold->getLHS());

  else

    CSE = cast<ConceptSpecializationExpr>(IDC);

  ArrayRef<TemplateArgument> OldConverted = CSE->getTemplateArguments();

  SmallVector<TemplateArgument, 3> NewConverted;

  NewConverted.reserve(OldConverted.size());

  if (OldConverted.front().getKind() == TemplateArgument::Pack) {

    // The case:

    // template<typename... T> concept C = true;

    // template<C<int> T> struct S; -> constraint is C<{T, int}>

    NewConverted.push_back(ConstrainedType);

    for (auto &Arg : OldConverted.front().pack_elements().drop_front(1))

      NewConverted.push_back(Arg);

    TemplateArgument NewPack(NewConverted);

    NewConverted.clear();

    NewConverted.push_back(NewPack);

    assert(OldConverted.size() == 1 &&

           "Template parameter pack should be the last parameter");

  } else {

    assert(OldConverted.front().getKind() == TemplateArgument::Type &&

           "Unexpected first argument kind for immediately-declared "

           "constraint");

    NewConverted.push_back(ConstrainedType);

    for (auto &Arg : OldConverted.drop_front(1))

      NewConverted.push_back(Arg);

  }

  Expr *NewIDC = ConceptSpecializationExpr::Create(

      C, CSE->getNamedConcept(), NewConverted, nullptr,

      CSE->isInstantiationDependent(), CSE->containsUnexpandedParameterPack());

  if (auto *OrigFold = dyn_cast<CXXFoldExpr>(IDC))

    NewIDC = new (C) CXXFoldExpr(

        OrigFold->getType(), /*Callee*/nullptr, SourceLocation(), NewIDC,

        BinaryOperatorKind::BO_LAnd, SourceLocation(), /*RHS=*/nullptr,

        SourceLocation(), /*NumExpansions=*/None);

  return NewIDC;

}

TemplateTemplateParmDecl *

ASTContext::getCanonicalTemplateTemplateParmDecl(

                                          TemplateTemplateParmDecl *TTP) const {

  // Check if we already have a canonical template template parameter.

  llvm::FoldingSetNodeID ID;

  CanonicalTemplateTemplateParm::Profile(ID, *this, TTP);

  void *InsertPos = nullptr;

  CanonicalTemplateTemplateParm *Canonical

    = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);

  if (Canonical)

    return Canonical->getParam();

  // Build a canonical template parameter list.

  TemplateParameterList *Params = TTP->getTemplateParameters();

  SmallVector<NamedDecl *, 4> CanonParams;

  CanonParams.reserve(Params->size());

  for (TemplateParameterList::const_iterator P = Params->begin(),

                                          PEnd = Params->end();

       P != PEnd; 
++P4.70k
) {

    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {

      TemplateTypeParmDecl *NewTTP = TemplateTypeParmDecl::Create(*this,

          getTranslationUnitDecl(), SourceLocation(), SourceLocation(),

          TTP->getDepth(), TTP->getIndex(), nullptr, false,

          TTP->isParameterPack(), TTP->hasTypeConstraint(),

          TTP->isExpandedParameterPack() ?

          
llvm::Optional<unsigned>(TTP->getNumExpansionParameters())0
 : None);

      if (const auto *TC = TTP->getTypeConstraint()) {

        QualType ParamAsArgument(NewTTP->getTypeForDecl(), 0);

        Expr *NewIDC = canonicalizeImmediatelyDeclaredConstraint(

                *this, TC->getImmediatelyDeclaredConstraint(),

                ParamAsArgument);

        TemplateArgumentListInfo CanonArgsAsWritten;

        if (auto *Args = TC->getTemplateArgsAsWritten())

          for (const auto &ArgLoc : Args->arguments())

            CanonArgsAsWritten.addArgument(

                TemplateArgumentLoc(ArgLoc.getArgument(),

                                    TemplateArgumentLocInfo()));

        NewTTP->setTypeConstraint(

            NestedNameSpecifierLoc(),

            DeclarationNameInfo(TC->getNamedConcept()->getDeclName(),

                                SourceLocation()), /*FoundDecl=*/nullptr,

            // Actually canonicalizing a TemplateArgumentLoc is difficult so we

            // simply omit the ArgsAsWritten

            TC->getNamedConcept(), /*ArgsAsWritten=*/nullptr, NewIDC);

      }

      CanonParams.push_back(NewTTP);

    } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {

      QualType T = getCanonicalType(NTTP->getType());

      TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T);

      NonTypeTemplateParmDecl *Param;

      if (NTTP->isExpandedParameterPack()) {

        SmallVector<QualType, 2> ExpandedTypes;

        SmallVector<TypeSourceInfo *, 2> ExpandedTInfos;

        for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; 
++I3
) {

          ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I)));

          ExpandedTInfos.push_back(

                                getTrivialTypeSourceInfo(ExpandedTypes.back()));

        }

        Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),

                                                SourceLocation(),

                                                SourceLocation(),

                                                NTTP->getDepth(),

                                                NTTP->getPosition(), nullptr,

                                                T,

                                                TInfo,

                                                ExpandedTypes,

                                                ExpandedTInfos);

      } else {

        Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),

                                                SourceLocation(),

                                                SourceLocation(),

                                                NTTP->getDepth(),

                                                NTTP->getPosition(), nullptr,

                                                T,

                                                NTTP->isParameterPack(),

                                                TInfo);

      }

      if (AutoType *AT = T->getContainedAutoType()) {

        if (AT->isConstrained()) {

          Param->setPlaceholderTypeConstraint(

              canonicalizeImmediatelyDeclaredConstraint(

                  *this, NTTP->getPlaceholderTypeConstraint(), T));

        }

      }

      CanonParams.push_back(Param);

    } else

      CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(

                                           cast<TemplateTemplateParmDecl>(*P)));

  }

  Expr *CanonRequiresClause = nullptr;

  if (Expr *RequiresClause = TTP->getTemplateParameters()->getRequiresClause())

    CanonRequiresClause = RequiresClause;

  TemplateTemplateParmDecl *CanonTTP

    = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(),

                                       SourceLocation(), TTP->getDepth(),

                                       TTP->getPosition(),

                                       TTP->isParameterPack(),

                                       nullptr,

                         TemplateParameterList::Create(*this, SourceLocation(),

                                                       SourceLocation(),

                                                       CanonParams,

                                                       SourceLocation(),

                                                       CanonRequiresClause));

  // Get the new insert position for the node we care about.

  Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);

  assert(!Canonical && "Shouldn't be in the map!");

  (void)Canonical;

  // Create the canonical template template parameter entry.

  Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP);

  CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);

  return CanonTTP;

}

CXXABI *ASTContext::createCXXABI(const TargetInfo &T) {

  if (!LangOpts.CPlusPlus) 
return nullptr17.7k
;

  switch (T.getCXXABI().getKind()) {

  case TargetCXXABI::Fuchsia:

  case TargetCXXABI::GenericARM: // Same as Itanium at this level

  case TargetCXXABI::iOS:

  case TargetCXXABI::iOS64:

  case TargetCXXABI::WatchOS:

  case TargetCXXABI::GenericAArch64:

  case TargetCXXABI::GenericMIPS:

  case TargetCXXABI::GenericItanium:

  case TargetCXXABI::WebAssembly:

  case TargetCXXABI::XL:

    return CreateItaniumCXXABI(*this);

  case TargetCXXABI::Microsoft:

    return CreateMicrosoftCXXABI(*this);

  }

  llvm_unreachable("Invalid CXXABI type!");

}

interp::Context &ASTContext::getInterpContext() {

  if (!InterpContext) {

    InterpContext.reset(new interp::Context(*this));

  }

  return *InterpContext.get();

}

ParentMapContext &ASTContext::getParentMapContext() {

  if (!ParentMapCtx)

    ParentMapCtx.reset(new ParentMapContext(*this));

  return *ParentMapCtx.get();

}

static const LangASMap *getAddressSpaceMap(const TargetInfo &T,

                                           const LangOptions &LOpts) {

  if (LOpts.FakeAddressSpaceMap) {

    // The fake address space map must have a distinct entry for each

    // language-specific address space.

    static const unsigned FakeAddrSpaceMap[] = {

        0,  // Default

        1,  // opencl_global

        3,  // opencl_local

        2,  // opencl_constant

        0,  // opencl_private

        4,  // opencl_generic

        5,  // opencl_global_device

        6,  // opencl_global_host

        7,  // cuda_device

        8,  // cuda_constant

        9,  // cuda_shared

        10, // ptr32_sptr

        11, // ptr32_uptr

        12  // ptr64

    };

    return &FakeAddrSpaceMap;

  } else {

    return &T.getAddressSpaceMap();

  }

}

static bool isAddrSpaceMapManglingEnabled(const TargetInfo &TI,

                                          const LangOptions &LangOpts) {

  switch (LangOpts.getAddressSpaceMapMangling()) {

  case LangOptions::ASMM_Target:

    return TI.useAddressSpaceMapMangling();

  case LangOptions::ASMM_On:

    return true;

  case LangOptions::ASMM_Off:

    return false;

  }

  llvm_unreachable("getAddressSpaceMapMangling() doesn't cover anything.");

}

ASTContext::ASTContext(LangOptions &LOpts, SourceManager &SM,

                       IdentifierTable &idents, SelectorTable &sels,

                       Builtin::Context &builtins)

    : ConstantArrayTypes(this_()), FunctionProtoTypes(this_()),

      TemplateSpecializationTypes(this_()),

      DependentTemplateSpecializationTypes(this_()), AutoTypes(this_()),

      SubstTemplateTemplateParmPacks(this_()),

      CanonTemplateTemplateParms(this_()), SourceMgr(SM), LangOpts(LOpts),

      SanitizerBL(new SanitizerBlacklist(LangOpts.SanitizerBlacklistFiles, SM)),

      XRayFilter(new XRayFunctionFilter(LangOpts.XRayAlwaysInstrumentFiles,

                                        LangOpts.XRayNeverInstrumentFiles,

                                        LangOpts.XRayAttrListFiles, SM)),

      PrintingPolicy(LOpts), Idents(idents), Selectors(sels),

      BuiltinInfo(builtins), DeclarationNames(*this), Comments(SM),

      CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),

      CompCategories(this_()), LastSDM(nullptr, 0) {

  TUDecl = TranslationUnitDecl::Create(*this);

  TraversalScope = {TUDecl};

}

ASTContext::~ASTContext() {

  // Release the DenseMaps associated with DeclContext objects.

  // FIXME: Is this the ideal solution?

  ReleaseDeclContextMaps();

  // Call all of the deallocation functions on all of their targets.

  for (auto &Pair : Deallocations)

    (Pair.first)(Pair.second);

  // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed

  // because they can contain DenseMaps.

  for (llvm::DenseMap<const ObjCContainerDecl*,

       const ASTRecordLayout*>::iterator

       I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; )

    // Increment in loop to prevent using deallocated memory.

    if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))

      R->Destroy(*this);

  for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator

       I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) {

    // Increment in loop to prevent using deallocated memory.

    if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))

      R->Destroy(*this);

  }

  for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),

                                                    AEnd = DeclAttrs.end();

       A != AEnd; 
++A12.4M
)

    A->second->~AttrVec();

  for (const auto &Value : ModuleInitializers)

    Value.second->~PerModuleInitializers();

  for (APValue *Value : APValueCleanups)

    Value->~APValue();

}

void ASTContext::setTraversalScope(const std::vector<Decl *> &TopLevelDecls) {

  TraversalScope = TopLevelDecls;

  getParentMapContext().clear();

}

void ASTContext::AddDeallocation(void (*Callback)(void *), void *Data) const {

  Deallocations.push_back({Callback, Data});

}

void

ASTContext::setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source) {

  ExternalSource = std::move(Source);

}