/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/DeclTemplate.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/DeclTemplate.cpp
Warning:	line 87, column 9 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DeclTemplate.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangAST/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangAST/obj/../include/clang/AST -I /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangAST/../include -I /usr/src/gnu/usr.bin/clang/libclangAST/obj -I /usr/src/gnu/usr.bin/clang/libclangAST/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangAST/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/DeclTemplate.cpp
1//===- DeclTemplate.cpp - Template Declaration AST Node Implementation ----===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the C++ related Decl classes for templates.
10//
11//===----------------------------------------------------------------------===//

13#include "clang/AST/DeclTemplate.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/ASTMutationListener.h"
16#include "clang/AST/DeclCXX.h"
17#include "clang/AST/DeclarationName.h"
18#include "clang/AST/Expr.h"
19#include "clang/AST/ExternalASTSource.h"
20#include "clang/AST/TemplateBase.h"
21#include "clang/AST/TemplateName.h"
22#include "clang/AST/Type.h"
23#include "clang/AST/TypeLoc.h"
24#include "clang/Basic/Builtins.h"
25#include "clang/Basic/LLVM.h"
26#include "clang/Basic/SourceLocation.h"
27#include "llvm/ADT/ArrayRef.h"
28#include "llvm/ADT/FoldingSet.h"
29#include "llvm/ADT/None.h"
30#include "llvm/ADT/PointerUnion.h"
31#include "llvm/ADT/SmallVector.h"
32#include "llvm/Support/Casting.h"
33#include "llvm/Support/ErrorHandling.h"
34#include <algorithm>
35#include <cassert>
36#include <cstdint>
37#include <memory>
38#include <utility>

40using namespace clang;

42//===----------------------------------------------------------------------===//
43// TemplateParameterList Implementation
44//===----------------------------------------------------------------------===//


47TemplateParameterList::TemplateParameterList(const ASTContext& C,
                                           SourceLocation TemplateLoc,
                                           SourceLocation LAngleLoc,
                                           ArrayRef<NamedDecl *> Params,
                                           SourceLocation RAngleLoc,
                                           Expr *RequiresClause)
  : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
    NumParams(Params.size()), ContainsUnexpandedParameterPack(false),
    HasRequiresClause(RequiresClause != nullptr),
    HasConstrainedParameters(false) {
for (unsigned Idx = 0; Idx < NumParams; ++Idx) {
9
←
Assuming 'Idx' is < field 'NumParams'→
10
←
Loop condition is true.  Entering loop body→
16
←
Assuming 'Idx' is >= field 'NumParams'→
17
←
Loop condition is false. Execution continues on line 86→
  NamedDecl *P = Params[Idx];
  begin()[Idx] = P;

  bool IsPack = P->isTemplateParameterPack();
  if (const auto *NTTP11.1
'NTTP' is null
 = dyn_cast<NonTypeTemplateParmDecl>(P)) {
11
←
Assuming 'P' is not a 'NonTypeTemplateParmDecl'→
12
←
Taking false branch→
    if (!IsPack && NTTP->getType()->containsUnexpandedParameterPack())
      ContainsUnexpandedParameterPack = true;
    if (NTTP->hasPlaceholderTypeConstraint())
      HasConstrainedParameters = true;
  } else if (const auto *TTP13.1
'TTP' is non-null
 = dyn_cast<TemplateTemplateParmDecl>(P)) {
13
←
Assuming 'P' is a 'TemplateTemplateParmDecl'→
14
←
Taking true branch→
    if (!IsPack &&
15
←
Assuming 'IsPack' is true→
        TTP->getTemplateParameters()->containsUnexpandedParameterPack())
      ContainsUnexpandedParameterPack = true;
  } else if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
    if (const TypeConstraint *TC = TTP->getTypeConstraint()) {
      if (TC->getImmediatelyDeclaredConstraint()
          ->containsUnexpandedParameterPack())
        ContainsUnexpandedParameterPack = true;
    }
    if (TTP->hasTypeConstraint())
      HasConstrainedParameters = true;
  } else {
    llvm_unreachable("unexpcted template parameter type")__builtin_unreachable();
  }
  // FIXME: If a default argument contains an unexpanded parameter pack, the
  // template parameter list does too.
}

if (HasRequiresClause) {
18
←
Assuming field 'HasRequiresClause' is not equal to 0→
19
←
Taking true branch→
  if (RequiresClause->containsUnexpandedParameterPack())
20
←
Called C++ object pointer is null
    ContainsUnexpandedParameterPack = true;
  *getTrailingObjects<Expr *>() = RequiresClause;
}
91}

93bool TemplateParameterList::containsUnexpandedParameterPack() const {
if (ContainsUnexpandedParameterPack)
  return true;
if (!HasConstrainedParameters)
  return false;

// An implicit constrained parameter might have had a use of an unexpanded
// pack added to it after the template parameter list was created. All
// implicit parameters are at the end of the parameter list.
for (const NamedDecl *Param : llvm::reverse(asArray())) {
  if (!Param->isImplicit())
    break;

  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
    const auto *TC = TTP->getTypeConstraint();
    if (TC && TC->getImmediatelyDeclaredConstraint()
                  ->containsUnexpandedParameterPack())
      return true;
  }
}

return false;
115}

117TemplateParameterList *
118TemplateParameterList::Create(const ASTContext &C, SourceLocation TemplateLoc,
                            SourceLocation LAngleLoc,
                            ArrayRef<NamedDecl *> Params,
                            SourceLocation RAngleLoc, Expr *RequiresClause) {
void *Mem = C.Allocate(totalSizeToAlloc<NamedDecl *, Expr *>(
                           Params.size(), RequiresClause5.1
'RequiresClause' is null
 ? 1u : 0u),
6
←
'?' condition is false→
                       alignof(TemplateParameterList));
return new (Mem) TemplateParameterList(C, TemplateLoc, LAngleLoc, Params,
8
←
Calling constructor for 'TemplateParameterList'→
                                       RAngleLoc, RequiresClause);
7
←
Passing null pointer value via 6th parameter 'RequiresClause'→
127}

129unsigned TemplateParameterList::getMinRequiredArguments() const {
unsigned NumRequiredArgs = 0;
for (const NamedDecl *P : asArray()) {
  if (P->isTemplateParameterPack()) {
    if (Optional<unsigned> Expansions = getExpandedPackSize(P)) {
      NumRequiredArgs += *Expansions;
      continue;
    }
    break;
  }

  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
    if (TTP->hasDefaultArgument())
      break;
  } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
    if (NTTP->hasDefaultArgument())
      break;
  } else if (cast<TemplateTemplateParmDecl>(P)->hasDefaultArgument())
    break;

  ++NumRequiredArgs;
}

return NumRequiredArgs;
153}

155unsigned TemplateParameterList::getDepth() const {
if (size() == 0)
  return 0;

const NamedDecl *FirstParm = getParam(0);
if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(FirstParm))
  return TTP->getDepth();
else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
  return NTTP->getDepth();
else
  return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
166}

168static void AdoptTemplateParameterList(TemplateParameterList *Params,
                                     DeclContext *Owner) {
for (NamedDecl *P : *Params) {
  P->setDeclContext(Owner);

  if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
    AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner);
}
176}

178void TemplateParameterList::
179getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
if (HasConstrainedParameters)
  for (const NamedDecl *Param : *this) {
    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
      if (const auto *TC = TTP->getTypeConstraint())
        AC.push_back(TC->getImmediatelyDeclaredConstraint());
    } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
      if (const Expr *E = NTTP->getPlaceholderTypeConstraint())
        AC.push_back(E);
    }
  }
if (HasRequiresClause)
  AC.push_back(getRequiresClause());
192}

194bool TemplateParameterList::hasAssociatedConstraints() const {
return HasRequiresClause || HasConstrainedParameters;
196}

198bool TemplateParameterList::shouldIncludeTypeForArgument(
  const TemplateParameterList *TPL, unsigned Idx) {
if (!TPL || Idx >= TPL->size())
  return true;
const NamedDecl *TemplParam = TPL->getParam(Idx);
if (const auto *ParamValueDecl =
        dyn_cast<NonTypeTemplateParmDecl>(TemplParam))
  if (ParamValueDecl->getType()->getContainedDeducedType())
    return true;
return false;
208}

210namespace clang {

212void *allocateDefaultArgStorageChain(const ASTContext &C) {
return new (C) char[sizeof(void*) * 2];
214}

216} // namespace clang

218//===----------------------------------------------------------------------===//
219// TemplateDecl Implementation
220//===----------------------------------------------------------------------===//

222TemplateDecl::TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L,
                         DeclarationName Name, TemplateParameterList *Params,
                         NamedDecl *Decl)
  : NamedDecl(DK, DC, L, Name), TemplatedDecl(Decl), TemplateParams(Params) {}

227void TemplateDecl::anchor() {}

229void TemplateDecl::
230getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
TemplateParams->getAssociatedConstraints(AC);
if (auto *FD = dyn_cast_or_null<FunctionDecl>(getTemplatedDecl()))
  if (const Expr *TRC = FD->getTrailingRequiresClause())
    AC.push_back(TRC);
235}

237bool TemplateDecl::hasAssociatedConstraints() const {
if (TemplateParams->hasAssociatedConstraints())
  return true;
if (auto *FD = dyn_cast_or_null<FunctionDecl>(getTemplatedDecl()))
  return FD->getTrailingRequiresClause();
return false;
243}

245//===----------------------------------------------------------------------===//
246// RedeclarableTemplateDecl Implementation
247//===----------------------------------------------------------------------===//

249void RedeclarableTemplateDecl::anchor() {}

251RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() const {
if (Common)
  return Common;

// Walk the previous-declaration chain until we either find a declaration
// with a common pointer or we run out of previous declarations.
SmallVector<const RedeclarableTemplateDecl *, 2> PrevDecls;
for (const RedeclarableTemplateDecl *Prev = getPreviousDecl(); Prev;
     Prev = Prev->getPreviousDecl()) {
  if (Prev->Common) {
    Common = Prev->Common;
    break;
  }

  PrevDecls.push_back(Prev);
}

// If we never found a common pointer, allocate one now.
if (!Common) {
  // FIXME: If any of the declarations is from an AST file, we probably
  // need an update record to add the common data.

  Common = newCommon(getASTContext());
}

// Update any previous declarations we saw with the common pointer.
for (const RedeclarableTemplateDecl *Prev : PrevDecls)
  Prev->Common = Common;

return Common;
281}

283void RedeclarableTemplateDecl::loadLazySpecializationsImpl() const {
// Grab the most recent declaration to ensure we've loaded any lazy
// redeclarations of this template.
CommonBase *CommonBasePtr = getMostRecentDecl()->getCommonPtr();
if (CommonBasePtr->LazySpecializations) {
  ASTContext &Context = getASTContext();
  uint32_t *Specs = CommonBasePtr->LazySpecializations;
  CommonBasePtr->LazySpecializations = nullptr;
  for (uint32_t I = 0, N = *Specs++; I != N; ++I)
    (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
}
294}

296template<class EntryType, typename... ProfileArguments>
297typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
298RedeclarableTemplateDecl::findSpecializationImpl(
  llvm::FoldingSetVector<EntryType> &Specs, void *&InsertPos,
  ProfileArguments&&... ProfileArgs) {
using SETraits = SpecEntryTraits<EntryType>;

llvm::FoldingSetNodeID ID;
EntryType::Profile(ID, std::forward<ProfileArguments>(ProfileArgs)...,
                   getASTContext());
EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos);
return Entry ? SETraits::getDecl(Entry)->getMostRecentDecl() : nullptr;
308}

310template<class Derived, class EntryType>
311void RedeclarableTemplateDecl::addSpecializationImpl(
  llvm::FoldingSetVector<EntryType> &Specializations, EntryType *Entry,
  void *InsertPos) {
using SETraits = SpecEntryTraits<EntryType>;

if (InsertPos) {
317#ifndef NDEBUG1
  void *CorrectInsertPos;
  assert(!findSpecializationImpl(Specializations,((void)0)
                                 CorrectInsertPos,((void)0)
                                 SETraits::getTemplateArgs(Entry)) &&((void)0)
         InsertPos == CorrectInsertPos &&((void)0)
         "given incorrect InsertPos for specialization")((void)0);
324#endif
  Specializations.InsertNode(Entry, InsertPos);
} else {
  EntryType *Existing = Specializations.GetOrInsertNode(Entry);
  (void)Existing;
  assert(SETraits::getDecl(Existing)->isCanonicalDecl() &&((void)0)
         "non-canonical specialization?")((void)0);
}

if (ASTMutationListener *L = getASTMutationListener())
  L->AddedCXXTemplateSpecialization(cast<Derived>(this),
                                    SETraits::getDecl(Entry));
336}

338//===----------------------------------------------------------------------===//
339// FunctionTemplateDecl Implementation
340//===----------------------------------------------------------------------===//

342FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C,
                                                 DeclContext *DC,
                                                 SourceLocation L,
                                                 DeclarationName Name,
                                             TemplateParameterList *Params,
                                                 NamedDecl *Decl) {
AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
return new (C, DC) FunctionTemplateDecl(C, DC, L, Name, Params, Decl);
350}

352FunctionTemplateDecl *FunctionTemplateDecl::CreateDeserialized(ASTContext &C,
                                                             unsigned ID) {
return new (C, ID) FunctionTemplateDecl(C, nullptr, SourceLocation(),
                                        DeclarationName(), nullptr, nullptr);
356}

358RedeclarableTemplateDecl::CommonBase *
359FunctionTemplateDecl::newCommon(ASTContext &C) const {
auto *CommonPtr = new (C) Common;
C.addDestruction(CommonPtr);
return CommonPtr;
363}

365void FunctionTemplateDecl::LoadLazySpecializations() const {
loadLazySpecializationsImpl();
367}

369llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
370FunctionTemplateDecl::getSpecializations() const {
LoadLazySpecializations();
return getCommonPtr()->Specializations;
373}

375FunctionDecl *
376FunctionTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
                                       void *&InsertPos) {
return findSpecializationImpl(getSpecializations(), InsertPos, Args);
379}

381void FunctionTemplateDecl::addSpecialization(
    FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
addSpecializationImpl<FunctionTemplateDecl>(getSpecializations(), Info,
                                            InsertPos);
385}

387ArrayRef<TemplateArgument> FunctionTemplateDecl::getInjectedTemplateArgs() {
TemplateParameterList *Params = getTemplateParameters();
Common *CommonPtr = getCommonPtr();
if (!CommonPtr->InjectedArgs) {
  auto &Context = getASTContext();
  SmallVector<TemplateArgument, 16> TemplateArgs;
  Context.getInjectedTemplateArgs(Params, TemplateArgs);
  CommonPtr->InjectedArgs =
      new (Context) TemplateArgument[TemplateArgs.size()];
  std::copy(TemplateArgs.begin(), TemplateArgs.end(),
            CommonPtr->InjectedArgs);
}

return llvm::makeArrayRef(CommonPtr->InjectedArgs, Params->size());
401}

403void FunctionTemplateDecl::mergePrevDecl(FunctionTemplateDecl *Prev) {
using Base = RedeclarableTemplateDecl;

// If we haven't created a common pointer yet, then it can just be created
// with the usual method.
if (!Base::Common)
  return;

Common *ThisCommon = static_cast<Common *>(Base::Common);
Common *PrevCommon = nullptr;
SmallVector<FunctionTemplateDecl *, 8> PreviousDecls;
for (; Prev; Prev = Prev->getPreviousDecl()) {
  if (Prev->Base::Common) {
    PrevCommon = static_cast<Common *>(Prev->Base::Common);
    break;
  }
  PreviousDecls.push_back(Prev);
}

// If the previous redecl chain hasn't created a common pointer yet, then just
// use this common pointer.
if (!PrevCommon) {
  for (auto *D : PreviousDecls)
    D->Base::Common = ThisCommon;
  return;
}

// Ensure we don't leak any important state.
assert(ThisCommon->Specializations.size() == 0 &&((void)0)
       "Can't merge incompatible declarations!")((void)0);

Base::Common = PrevCommon;
435}

437//===----------------------------------------------------------------------===//
438// ClassTemplateDecl Implementation
439//===----------------------------------------------------------------------===//

441ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
                                           DeclContext *DC,
                                           SourceLocation L,
                                           DeclarationName Name,
                                           TemplateParameterList *Params,
                                           NamedDecl *Decl) {
AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));

return new (C, DC) ClassTemplateDecl(C, DC, L, Name, Params, Decl);
450}

452ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C,
                                                       unsigned ID) {
return new (C, ID) ClassTemplateDecl(C, nullptr, SourceLocation(),
                                     DeclarationName(), nullptr, nullptr);
456}

458void ClassTemplateDecl::LoadLazySpecializations() const {
loadLazySpecializationsImpl();
460}

462llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
463ClassTemplateDecl::getSpecializations() const {
LoadLazySpecializations();
return getCommonPtr()->Specializations;
466}

468llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
469ClassTemplateDecl::getPartialSpecializations() const {
LoadLazySpecializations();
return getCommonPtr()->PartialSpecializations;
472}

474RedeclarableTemplateDecl::CommonBase *
475ClassTemplateDecl::newCommon(ASTContext &C) const {
auto *CommonPtr = new (C) Common;
C.addDestruction(CommonPtr);
return CommonPtr;
479}

481ClassTemplateSpecializationDecl *
482ClassTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
                                    void *&InsertPos) {
return findSpecializationImpl(getSpecializations(), InsertPos, Args);
485}

487void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D,
                                        void *InsertPos) {
addSpecializationImpl<ClassTemplateDecl>(getSpecializations(), D, InsertPos);
490}

492ClassTemplatePartialSpecializationDecl *
493ClassTemplateDecl::findPartialSpecialization(
  ArrayRef<TemplateArgument> Args,
  TemplateParameterList *TPL, void *&InsertPos) {
return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args,
                              TPL);
498}

500static void ProfileTemplateParameterList(ASTContext &C,
  llvm::FoldingSetNodeID &ID, const TemplateParameterList *TPL) {
const Expr *RC = TPL->getRequiresClause();
ID.AddBoolean(RC != nullptr);
if (RC)
  RC->Profile(ID, C, /*Canonical=*/true);
ID.AddInteger(TPL->size());
for (NamedDecl *D : *TPL) {
  if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
    ID.AddInteger(0);
    ID.AddBoolean(NTTP->isParameterPack());
    NTTP->getType().getCanonicalType().Profile(ID);
    continue;
  }
  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(D)) {
    ID.AddInteger(1);
    ID.AddBoolean(TTP->isParameterPack());
    ID.AddBoolean(TTP->hasTypeConstraint());
    if (const TypeConstraint *TC = TTP->getTypeConstraint())
      TC->getImmediatelyDeclaredConstraint()->Profile(ID, C,
                                                      /*Canonical=*/true);
    continue;
  }
  const auto *TTP = cast<TemplateTemplateParmDecl>(D);
  ID.AddInteger(2);
  ID.AddBoolean(TTP->isParameterPack());
  ProfileTemplateParameterList(C, ID, TTP->getTemplateParameters());
}
528}

530void
531ClassTemplatePartialSpecializationDecl::Profile(llvm::FoldingSetNodeID &ID,
  ArrayRef<TemplateArgument> TemplateArgs, TemplateParameterList *TPL,
  ASTContext &Context) {
ID.AddInteger(TemplateArgs.size());
for (const TemplateArgument &TemplateArg : TemplateArgs)
  TemplateArg.Profile(ID, Context);
ProfileTemplateParameterList(Context, ID, TPL);
538}

540void ClassTemplateDecl::AddPartialSpecialization(
                                    ClassTemplatePartialSpecializationDecl *D,
                                    void *InsertPos) {
if (InsertPos)
  getPartialSpecializations().InsertNode(D, InsertPos);
else {
  ClassTemplatePartialSpecializationDecl *Existing
    = getPartialSpecializations().GetOrInsertNode(D);
  (void)Existing;
  assert(Existing->isCanonicalDecl() && "Non-canonical specialization?")((void)0);
}

if (ASTMutationListener *L = getASTMutationListener())
  L->AddedCXXTemplateSpecialization(this, D);
554}

556void ClassTemplateDecl::getPartialSpecializations(
  SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) const {
llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs
  = getPartialSpecializations();
PS.clear();
PS.reserve(PartialSpecs.size());
for (ClassTemplatePartialSpecializationDecl &P : PartialSpecs)
  PS.push_back(P.getMostRecentDecl());
564}

566ClassTemplatePartialSpecializationDecl *
567ClassTemplateDecl::findPartialSpecialization(QualType T) {
ASTContext &Context = getASTContext();
for (ClassTemplatePartialSpecializationDecl &P :
     getPartialSpecializations()) {
  if (Context.hasSameType(P.getInjectedSpecializationType(), T))
    return P.getMostRecentDecl();
}

return nullptr;
576}

578ClassTemplatePartialSpecializationDecl *
579ClassTemplateDecl::findPartialSpecInstantiatedFromMember(
                                  ClassTemplatePartialSpecializationDecl *D) {
Decl *DCanon = D->getCanonicalDecl();
for (ClassTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
  if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
    return P.getMostRecentDecl();
}

return nullptr;
588}

590QualType
591ClassTemplateDecl::getInjectedClassNameSpecialization() {
Common *CommonPtr = getCommonPtr();
if (!CommonPtr->InjectedClassNameType.isNull())
  return CommonPtr->InjectedClassNameType;

// C++0x [temp.dep.type]p2:
//  The template argument list of a primary template is a template argument
//  list in which the nth template argument has the value of the nth template
//  parameter of the class template. If the nth template parameter is a
//  template parameter pack (14.5.3), the nth template argument is a pack
//  expansion (14.5.3) whose pattern is the name of the template parameter
//  pack.
ASTContext &Context = getASTContext();
TemplateParameterList *Params = getTemplateParameters();
SmallVector<TemplateArgument, 16> TemplateArgs;
Context.getInjectedTemplateArgs(Params, TemplateArgs);
CommonPtr->InjectedClassNameType
  = Context.getTemplateSpecializationType(TemplateName(this),
                                          TemplateArgs);
return CommonPtr->InjectedClassNameType;
611}

613//===----------------------------------------------------------------------===//
614// TemplateTypeParm Allocation/Deallocation Method Implementations
615//===----------------------------------------------------------------------===//

617TemplateTypeParmDecl *
618TemplateTypeParmDecl::Create(const ASTContext &C, DeclContext *DC,
                           SourceLocation KeyLoc, SourceLocation NameLoc,
                           unsigned D, unsigned P, IdentifierInfo *Id,
                           bool Typename, bool ParameterPack,
                           bool HasTypeConstraint,
                           Optional<unsigned> NumExpanded) {
auto *TTPDecl =
    new (C, DC,
         additionalSizeToAlloc<TypeConstraint>(HasTypeConstraint ? 1 : 0))
    TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename,
                         HasTypeConstraint, NumExpanded);
QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);
TTPDecl->setTypeForDecl(TTPType.getTypePtr());
return TTPDecl;
632}

634TemplateTypeParmDecl *
635TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
return new (C, ID) TemplateTypeParmDecl(nullptr, SourceLocation(),
                                        SourceLocation(), nullptr, false,
                                        false, None);
639}

641TemplateTypeParmDecl *
642TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID,
                                       bool HasTypeConstraint) {
return new (C, ID,
            additionalSizeToAlloc<TypeConstraint>(HasTypeConstraint ? 1 : 0))
       TemplateTypeParmDecl(nullptr, SourceLocation(), SourceLocation(),
                            nullptr, false, HasTypeConstraint, None);
648}

650SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
return hasDefaultArgument()
           ? getDefaultArgumentInfo()->getTypeLoc().getBeginLoc()
           : SourceLocation();
654}

656SourceRange TemplateTypeParmDecl::getSourceRange() const {
if (hasDefaultArgument() && !defaultArgumentWasInherited())
  return SourceRange(getBeginLoc(),
                     getDefaultArgumentInfo()->getTypeLoc().getEndLoc());
// TypeDecl::getSourceRange returns a range containing name location, which is
// wrong for unnamed template parameters. e.g:
// it will return <[[typename>]] instead of <[[typename]]>
else if (getDeclName().isEmpty())
  return SourceRange(getBeginLoc());
return TypeDecl::getSourceRange();
666}

668unsigned TemplateTypeParmDecl::getDepth() const {
return getTypeForDecl()->castAs<TemplateTypeParmType>()->getDepth();
670}

672unsigned TemplateTypeParmDecl::getIndex() const {
return getTypeForDecl()->castAs<TemplateTypeParmType>()->getIndex();
674}

676bool TemplateTypeParmDecl::isParameterPack() const {
return getTypeForDecl()->castAs<TemplateTypeParmType>()->isParameterPack();
678}

680void TemplateTypeParmDecl::setTypeConstraint(NestedNameSpecifierLoc NNS,
  DeclarationNameInfo NameInfo, NamedDecl *FoundDecl, ConceptDecl *CD,
  const ASTTemplateArgumentListInfo *ArgsAsWritten,
  Expr *ImmediatelyDeclaredConstraint) {
assert(HasTypeConstraint &&((void)0)
       "HasTypeConstraint=true must be passed at construction in order to "((void)0)
       "call setTypeConstraint")((void)0);
assert(!TypeConstraintInitialized &&((void)0)
       "TypeConstraint was already initialized!")((void)0);
new (getTrailingObjects<TypeConstraint>()) TypeConstraint(NNS, NameInfo,
    FoundDecl, CD, ArgsAsWritten, ImmediatelyDeclaredConstraint);
TypeConstraintInitialized = true;
692}

694//===----------------------------------------------------------------------===//
695// NonTypeTemplateParmDecl Method Implementations
696//===----------------------------------------------------------------------===//

698NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(
  DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D,
  unsigned P, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
  ArrayRef<QualType> ExpandedTypes, ArrayRef<TypeSourceInfo *> ExpandedTInfos)
  : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
    TemplateParmPosition(D, P), ParameterPack(true),
    ExpandedParameterPack(true), NumExpandedTypes(ExpandedTypes.size()) {
if (!ExpandedTypes.empty() && !ExpandedTInfos.empty()) {
  auto TypesAndInfos =
      getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
  for (unsigned I = 0; I != NumExpandedTypes; ++I) {
    new (&TypesAndInfos[I].first) QualType(ExpandedTypes[I]);
    TypesAndInfos[I].second = ExpandedTInfos[I];
  }
}
713}

715NonTypeTemplateParmDecl *
716NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
                              SourceLocation StartLoc, SourceLocation IdLoc,
                              unsigned D, unsigned P, IdentifierInfo *Id,
                              QualType T, bool ParameterPack,
                              TypeSourceInfo *TInfo) {
AutoType *AT =
    C.getLangOpts().CPlusPlus20 ? T->getContainedAutoType() : nullptr;
return new (C, DC,
            additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
                                  Expr *>(0,
                                          AT && AT->isConstrained() ? 1 : 0))
    NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, ParameterPack,
                            TInfo);
729}

731NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create(
  const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
  SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
  QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
  ArrayRef<TypeSourceInfo *> ExpandedTInfos) {
AutoType *AT = TInfo->getType()->getContainedAutoType();
return new (C, DC,
            additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
                                  Expr *>(
                ExpandedTypes.size(), AT && AT->isConstrained() ? 1 : 0))
    NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, TInfo,
                            ExpandedTypes, ExpandedTInfos);
743}

745NonTypeTemplateParmDecl *
746NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
                                          bool HasTypeConstraint) {
return new (C, ID, additionalSizeToAlloc<std::pair<QualType,
                                                   TypeSourceInfo *>,
                                         Expr *>(0,
                                                 HasTypeConstraint ? 1 : 0))
        NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
                                0, 0, nullptr, QualType(), false, nullptr);
754}

756NonTypeTemplateParmDecl *
757NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
                                          unsigned NumExpandedTypes,
                                          bool HasTypeConstraint) {
auto *NTTP =
    new (C, ID, additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
                                      Expr *>(
                    NumExpandedTypes, HasTypeConstraint ? 1 : 0))
        NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
                                0, 0, nullptr, QualType(), nullptr, None,
                                None);
NTTP->NumExpandedTypes = NumExpandedTypes;
return NTTP;
769}

771SourceRange NonTypeTemplateParmDecl::getSourceRange() const {
if (hasDefaultArgument() && !defaultArgumentWasInherited())
  return SourceRange(getOuterLocStart(),
                     getDefaultArgument()->getSourceRange().getEnd());
return DeclaratorDecl::getSourceRange();
776}

778SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
return hasDefaultArgument()
  ? getDefaultArgument()->getSourceRange().getBegin()
  : SourceLocation();
782}

784//===----------------------------------------------------------------------===//
785// TemplateTemplateParmDecl Method Implementations
786//===----------------------------------------------------------------------===//

788void TemplateTemplateParmDecl::anchor() {}

790TemplateTemplateParmDecl::TemplateTemplateParmDecl(
  DeclContext *DC, SourceLocation L, unsigned D, unsigned P,
  IdentifierInfo *Id, TemplateParameterList *Params,
  ArrayRef<TemplateParameterList *> Expansions)
  : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
    TemplateParmPosition(D, P), ParameterPack(true),
    ExpandedParameterPack(true), NumExpandedParams(Expansions.size()) {
if (!Expansions.empty())
  std::uninitialized_copy(Expansions.begin(), Expansions.end(),
                          getTrailingObjects<TemplateParameterList *>());
800}

802TemplateTemplateParmDecl *
803TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
                               SourceLocation L, unsigned D, unsigned P,
                               bool ParameterPack, IdentifierInfo *Id,
                               TemplateParameterList *Params) {
return new (C, DC) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id,
                                            Params);
809}

811TemplateTemplateParmDecl *
812TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
                               SourceLocation L, unsigned D, unsigned P,
                               IdentifierInfo *Id,
                               TemplateParameterList *Params,
                               ArrayRef<TemplateParameterList *> Expansions) {
return new (C, DC,
            additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))
    TemplateTemplateParmDecl(DC, L, D, P, Id, Params, Expansions);
820}

822TemplateTemplateParmDecl *
823TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
return new (C, ID) TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0,
                                            false, nullptr, nullptr);
826}

828TemplateTemplateParmDecl *
829TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
                                           unsigned NumExpansions) {
auto *TTP =
    new (C, ID, additionalSizeToAlloc<TemplateParameterList *>(NumExpansions))
        TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, nullptr,
                                 nullptr, None);
TTP->NumExpandedParams = NumExpansions;
return TTP;
837}

839SourceLocation TemplateTemplateParmDecl::getDefaultArgumentLoc() const {
return hasDefaultArgument() ? getDefaultArgument().getLocation()
                            : SourceLocation();
842}

844void TemplateTemplateParmDecl::setDefaultArgument(
  const ASTContext &C, const TemplateArgumentLoc &DefArg) {
if (DefArg.getArgument().isNull())
  DefaultArgument.set(nullptr);
else
  DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg));
850}

852//===----------------------------------------------------------------------===//
853// TemplateArgumentList Implementation
854//===----------------------------------------------------------------------===//
855TemplateArgumentList::TemplateArgumentList(ArrayRef<TemplateArgument> Args)
  : Arguments(getTrailingObjects<TemplateArgument>()),
    NumArguments(Args.size()) {
std::uninitialized_copy(Args.begin(), Args.end(),
                        getTrailingObjects<TemplateArgument>());
860}

862TemplateArgumentList *
863TemplateArgumentList::CreateCopy(ASTContext &Context,
                               ArrayRef<TemplateArgument> Args) {
void *Mem = Context.Allocate(totalSizeToAlloc<TemplateArgument>(Args.size()));
return new (Mem) TemplateArgumentList(Args);
867}

869FunctionTemplateSpecializationInfo *FunctionTemplateSpecializationInfo::Create(
  ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template,
  TemplateSpecializationKind TSK, const TemplateArgumentList *TemplateArgs,
  const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI,
  MemberSpecializationInfo *MSInfo) {
const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
if (TemplateArgsAsWritten)
  ArgsAsWritten = ASTTemplateArgumentListInfo::Create(C,
                                                      *TemplateArgsAsWritten);

void *Mem =
    C.Allocate(totalSizeToAlloc<MemberSpecializationInfo *>(MSInfo ? 1 : 0));
return new (Mem) FunctionTemplateSpecializationInfo(
    FD, Template, TSK, TemplateArgs, ArgsAsWritten, POI, MSInfo);
883}

885//===----------------------------------------------------------------------===//
886// ClassTemplateSpecializationDecl Implementation
887//===----------------------------------------------------------------------===//

889ClassTemplateSpecializationDecl::
890ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
                              DeclContext *DC, SourceLocation StartLoc,
                              SourceLocation IdLoc,
                              ClassTemplateDecl *SpecializedTemplate,
                              ArrayRef<TemplateArgument> Args,
                              ClassTemplateSpecializationDecl *PrevDecl)
  : CXXRecordDecl(DK, TK, Context, DC, StartLoc, IdLoc,
                  SpecializedTemplate->getIdentifier(), PrevDecl),
  SpecializedTemplate(SpecializedTemplate),
  TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
  SpecializationKind(TSK_Undeclared) {
901}

903ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(ASTContext &C,
                                                               Kind DK)
  : CXXRecordDecl(DK, TTK_Struct, C, nullptr, SourceLocation(),
                  SourceLocation(), nullptr, nullptr),
    SpecializationKind(TSK_Undeclared) {}

909ClassTemplateSpecializationDecl *
910ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK,
                                      DeclContext *DC,
                                      SourceLocation StartLoc,
                                      SourceLocation IdLoc,
                                      ClassTemplateDecl *SpecializedTemplate,
                                      ArrayRef<TemplateArgument> Args,
                                 ClassTemplateSpecializationDecl *PrevDecl) {
auto *Result =
    new (Context, DC) ClassTemplateSpecializationDecl(
        Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,
        SpecializedTemplate, Args, PrevDecl);
Result->setMayHaveOutOfDateDef(false);

Context.getTypeDeclType(Result, PrevDecl);
return Result;
925}

927ClassTemplateSpecializationDecl *
928ClassTemplateSpecializationDecl::CreateDeserialized(ASTContext &C,
                                                  unsigned ID) {
auto *Result =
  new (C, ID) ClassTemplateSpecializationDecl(C, ClassTemplateSpecialization);
Result->setMayHaveOutOfDateDef(false);
return Result;
934}

936void ClassTemplateSpecializationDecl::getNameForDiagnostic(
  raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);

const auto *PS = dyn_cast<ClassTemplatePartialSpecializationDecl>(this);
if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
        PS ? PS->getTemplateArgsAsWritten() : nullptr) {
  printTemplateArgumentList(
      OS, ArgsAsWritten->arguments(), Policy,
      getSpecializedTemplate()->getTemplateParameters());
} else {
  const TemplateArgumentList &TemplateArgs = getTemplateArgs();
  printTemplateArgumentList(
      OS, TemplateArgs.asArray(), Policy,
      getSpecializedTemplate()->getTemplateParameters());
}
952}

954ClassTemplateDecl *
955ClassTemplateSpecializationDecl::getSpecializedTemplate() const {
if (const auto *PartialSpec =
        SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
  return PartialSpec->PartialSpecialization->getSpecializedTemplate();
return SpecializedTemplate.get<ClassTemplateDecl*>();
960}

962SourceRange
963ClassTemplateSpecializationDecl::getSourceRange() const {
if (ExplicitInfo) {
  SourceLocation Begin = getTemplateKeywordLoc();
  if (Begin.isValid()) {
    // Here we have an explicit (partial) specialization or instantiation.
    assert(getSpecializationKind() == TSK_ExplicitSpecialization ||((void)0)
           getSpecializationKind() == TSK_ExplicitInstantiationDeclaration ||((void)0)
           getSpecializationKind() == TSK_ExplicitInstantiationDefinition)((void)0);
    if (getExternLoc().isValid())
      Begin = getExternLoc();
    SourceLocation End = getBraceRange().getEnd();
    if (End.isInvalid())
      End = getTypeAsWritten()->getTypeLoc().getEndLoc();
    return SourceRange(Begin, End);
  }
  // An implicit instantiation of a class template partial specialization
  // uses ExplicitInfo to record the TypeAsWritten, but the source
  // locations should be retrieved from the instantiation pattern.
  using CTPSDecl = ClassTemplatePartialSpecializationDecl;
  auto *ctpsd = const_cast<CTPSDecl *>(cast<CTPSDecl>(this));
  CTPSDecl *inst_from = ctpsd->getInstantiatedFromMember();
  assert(inst_from != nullptr)((void)0);
  return inst_from->getSourceRange();
}
else {
  // No explicit info available.
  llvm::PointerUnion<ClassTemplateDecl *,
                     ClassTemplatePartialSpecializationDecl *>
    inst_from = getInstantiatedFrom();
  if (inst_from.isNull())
    return getSpecializedTemplate()->getSourceRange();
  if (const auto *ctd = inst_from.dyn_cast<ClassTemplateDecl *>())
    return ctd->getSourceRange();
  return inst_from.get<ClassTemplatePartialSpecializationDecl *>()
    ->getSourceRange();
}
999}

1001//===----------------------------------------------------------------------===//
1002// ConceptDecl Implementation
1003//===----------------------------------------------------------------------===//
1004ConceptDecl *ConceptDecl::Create(ASTContext &C, DeclContext *DC,
                               SourceLocation L, DeclarationName Name,
                               TemplateParameterList *Params,
                               Expr *ConstraintExpr) {
AdoptTemplateParameterList(Params, DC);
return new (C, DC) ConceptDecl(DC, L, Name, Params, ConstraintExpr);
1010}

1012ConceptDecl *ConceptDecl::CreateDeserialized(ASTContext &C,
                                           unsigned ID) {
ConceptDecl *Result = new (C, ID) ConceptDecl(nullptr, SourceLocation(),
                                              DeclarationName(),
                                              nullptr, nullptr);

return Result;
1019}

1021//===----------------------------------------------------------------------===//
1022// ClassTemplatePartialSpecializationDecl Implementation
1023//===----------------------------------------------------------------------===//
1024void ClassTemplatePartialSpecializationDecl::anchor() {}

1026ClassTemplatePartialSpecializationDecl::
1027ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
                                     DeclContext *DC,
                                     SourceLocation StartLoc,
                                     SourceLocation IdLoc,
                                     TemplateParameterList *Params,
                                     ClassTemplateDecl *SpecializedTemplate,
                                     ArrayRef<TemplateArgument> Args,
                             const ASTTemplateArgumentListInfo *ArgInfos,
                             ClassTemplatePartialSpecializationDecl *PrevDecl)
  : ClassTemplateSpecializationDecl(Context,
                                    ClassTemplatePartialSpecialization,
                                    TK, DC, StartLoc, IdLoc,
                                    SpecializedTemplate, Args, PrevDecl),
    TemplateParams(Params), ArgsAsWritten(ArgInfos),
    InstantiatedFromMember(nullptr, false) {
AdoptTemplateParameterList(Params, this);
1043}

1045ClassTemplatePartialSpecializationDecl *
1046ClassTemplatePartialSpecializationDecl::
1047Create(ASTContext &Context, TagKind TK,DeclContext *DC,
     SourceLocation StartLoc, SourceLocation IdLoc,
     TemplateParameterList *Params,
     ClassTemplateDecl *SpecializedTemplate,
     ArrayRef<TemplateArgument> Args,
     const TemplateArgumentListInfo &ArgInfos,
     QualType CanonInjectedType,
     ClassTemplatePartialSpecializationDecl *PrevDecl) {
const ASTTemplateArgumentListInfo *ASTArgInfos =
  ASTTemplateArgumentListInfo::Create(Context, ArgInfos);

auto *Result = new (Context, DC)
    ClassTemplatePartialSpecializationDecl(Context, TK, DC, StartLoc, IdLoc,
                                           Params, SpecializedTemplate, Args,
                                           ASTArgInfos, PrevDecl);
Result->setSpecializationKind(TSK_ExplicitSpecialization);
Result->setMayHaveOutOfDateDef(false);

Context.getInjectedClassNameType(Result, CanonInjectedType);
return Result;
1067}

1069ClassTemplatePartialSpecializationDecl *
1070ClassTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
                                                         unsigned ID) {
auto *Result = new (C, ID) ClassTemplatePartialSpecializationDecl(C);
Result->setMayHaveOutOfDateDef(false);
return Result;
1075}

1077//===----------------------------------------------------------------------===//
1078// FriendTemplateDecl Implementation
1079//===----------------------------------------------------------------------===//

1081void FriendTemplateDecl::anchor() {}

1083FriendTemplateDecl *
1084FriendTemplateDecl::Create(ASTContext &Context, DeclContext *DC,
                         SourceLocation L,
                         MutableArrayRef<TemplateParameterList *> Params,
                         FriendUnion Friend, SourceLocation FLoc) {
return new (Context, DC) FriendTemplateDecl(DC, L, Params, Friend, FLoc);
1089}

1091FriendTemplateDecl *FriendTemplateDecl::CreateDeserialized(ASTContext &C,
                                                         unsigned ID) {
return new (C, ID) FriendTemplateDecl(EmptyShell());
1094}

1096//===----------------------------------------------------------------------===//
1097// TypeAliasTemplateDecl Implementation
1098//===----------------------------------------------------------------------===//

1100TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C,
                                                   DeclContext *DC,
                                                   SourceLocation L,
                                                   DeclarationName Name,
                                                TemplateParameterList *Params,
                                                   NamedDecl *Decl) {
AdoptTemplateParameterList(Params, DC);
return new (C, DC) TypeAliasTemplateDecl(C, DC, L, Name, Params, Decl);
1108}

1110TypeAliasTemplateDecl *TypeAliasTemplateDecl::CreateDeserialized(ASTContext &C,
                                                               unsigned ID) {
return new (C, ID) TypeAliasTemplateDecl(C, nullptr, SourceLocation(),
                                         DeclarationName(), nullptr, nullptr);
1114}

1116RedeclarableTemplateDecl::CommonBase *
1117TypeAliasTemplateDecl::newCommon(ASTContext &C) const {
auto *CommonPtr = new (C) Common;
C.addDestruction(CommonPtr);
return CommonPtr;
1121}

1123//===----------------------------------------------------------------------===//
1124// ClassScopeFunctionSpecializationDecl Implementation
1125//===----------------------------------------------------------------------===//

1127void ClassScopeFunctionSpecializationDecl::anchor() {}

1129ClassScopeFunctionSpecializationDecl *
1130ClassScopeFunctionSpecializationDecl::CreateDeserialized(ASTContext &C,
                                                       unsigned ID) {
return new (C, ID) ClassScopeFunctionSpecializationDecl(
    nullptr, SourceLocation(), nullptr, nullptr);
1134}

1136//===----------------------------------------------------------------------===//
1137// VarTemplateDecl Implementation
1138//===----------------------------------------------------------------------===//

1140VarTemplateDecl *VarTemplateDecl::getDefinition() {
VarTemplateDecl *CurD = this;
while (CurD) {
  if (CurD->isThisDeclarationADefinition())
    return CurD;
  CurD = CurD->getPreviousDecl();
}
return nullptr;
1148}

1150VarTemplateDecl *VarTemplateDecl::Create(ASTContext &C, DeclContext *DC,
                                       SourceLocation L, DeclarationName Name,
                                       TemplateParameterList *Params,
                                       VarDecl *Decl) {
AdoptTemplateParameterList(Params, DC);
return new (C, DC) VarTemplateDecl(C, DC, L, Name, Params, Decl);
1156}

1158VarTemplateDecl *VarTemplateDecl::CreateDeserialized(ASTContext &C,
                                                   unsigned ID) {
return new (C, ID) VarTemplateDecl(C, nullptr, SourceLocation(),
                                   DeclarationName(), nullptr, nullptr);
1162}

1164void VarTemplateDecl::LoadLazySpecializations() const {
loadLazySpecializationsImpl();
1166}

1168llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
1169VarTemplateDecl::getSpecializations() const {
LoadLazySpecializations();
return getCommonPtr()->Specializations;
1172}

1174llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
1175VarTemplateDecl::getPartialSpecializations() const {
LoadLazySpecializations();
return getCommonPtr()->PartialSpecializations;
1178}

1180RedeclarableTemplateDecl::CommonBase *
1181VarTemplateDecl::newCommon(ASTContext &C) const {
auto *CommonPtr = new (C) Common;
C.addDestruction(CommonPtr);
return CommonPtr;
1185}

1187VarTemplateSpecializationDecl *
1188VarTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
                                  void *&InsertPos) {
return findSpecializationImpl(getSpecializations(), InsertPos, Args);
1191}

1193void VarTemplateDecl::AddSpecialization(VarTemplateSpecializationDecl *D,
                                      void *InsertPos) {
addSpecializationImpl<VarTemplateDecl>(getSpecializations(), D, InsertPos);
1196}

1198VarTemplatePartialSpecializationDecl *
1199VarTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
   TemplateParameterList *TPL, void *&InsertPos) {
return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args,
                              TPL);
1203}

1205void
1206VarTemplatePartialSpecializationDecl::Profile(llvm::FoldingSetNodeID &ID,
  ArrayRef<TemplateArgument> TemplateArgs, TemplateParameterList *TPL,
  ASTContext &Context) {
ID.AddInteger(TemplateArgs.size());
for (const TemplateArgument &TemplateArg : TemplateArgs)
  TemplateArg.Profile(ID, Context);
ProfileTemplateParameterList(Context, ID, TPL);
1213}

1215void VarTemplateDecl::AddPartialSpecialization(
  VarTemplatePartialSpecializationDecl *D, void *InsertPos) {
if (InsertPos)
  getPartialSpecializations().InsertNode(D, InsertPos);
else {
  VarTemplatePartialSpecializationDecl *Existing =
      getPartialSpecializations().GetOrInsertNode(D);
  (void)Existing;
  assert(Existing->isCanonicalDecl() && "Non-canonical specialization?")((void)0);
}

if (ASTMutationListener *L = getASTMutationListener())
  L->AddedCXXTemplateSpecialization(this, D);
1228}

1230void VarTemplateDecl::getPartialSpecializations(
  SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS) const {
llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &PartialSpecs =
    getPartialSpecializations();
PS.clear();
PS.reserve(PartialSpecs.size());
for (VarTemplatePartialSpecializationDecl &P : PartialSpecs)
  PS.push_back(P.getMostRecentDecl());
1238}

1240VarTemplatePartialSpecializationDecl *
1241VarTemplateDecl::findPartialSpecInstantiatedFromMember(
  VarTemplatePartialSpecializationDecl *D) {
Decl *DCanon = D->getCanonicalDecl();
for (VarTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
  if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
    return P.getMostRecentDecl();
}

return nullptr;
1250}

1252//===----------------------------------------------------------------------===//
1253// VarTemplateSpecializationDecl Implementation
1254//===----------------------------------------------------------------------===//

1256VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(
  Kind DK, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
  SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
  TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args)
  : VarDecl(DK, Context, DC, StartLoc, IdLoc,
            SpecializedTemplate->getIdentifier(), T, TInfo, S),
    SpecializedTemplate(SpecializedTemplate),
    TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
    SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}

1266VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(Kind DK,
                                                           ASTContext &C)
  : VarDecl(DK, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
            QualType(), nullptr, SC_None),
    SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}

1272VarTemplateSpecializationDecl *VarTemplateSpecializationDecl::Create(
  ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
  SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
  TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args) {
return new (Context, DC) VarTemplateSpecializationDecl(
    VarTemplateSpecialization, Context, DC, StartLoc, IdLoc,
    SpecializedTemplate, T, TInfo, S, Args);
1279}

1281VarTemplateSpecializationDecl *
1282VarTemplateSpecializationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
return new (C, ID)
    VarTemplateSpecializationDecl(VarTemplateSpecialization, C);
1285}

1287void VarTemplateSpecializationDecl::getNameForDiagnostic(
  raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);

const auto *PS = dyn_cast<VarTemplatePartialSpecializationDecl>(this);
if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
        PS ? PS->getTemplateArgsAsWritten() : nullptr) {
  printTemplateArgumentList(
      OS, ArgsAsWritten->arguments(), Policy,
      getSpecializedTemplate()->getTemplateParameters());
} else {
  const TemplateArgumentList &TemplateArgs = getTemplateArgs();
  printTemplateArgumentList(
      OS, TemplateArgs.asArray(), Policy,
      getSpecializedTemplate()->getTemplateParameters());
}
1303}

1305VarTemplateDecl *VarTemplateSpecializationDecl::getSpecializedTemplate() const {
if (const auto *PartialSpec =
        SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
  return PartialSpec->PartialSpecialization->getSpecializedTemplate();
return SpecializedTemplate.get<VarTemplateDecl *>();
1310}

1312void VarTemplateSpecializationDecl::setTemplateArgsInfo(
  const TemplateArgumentListInfo &ArgsInfo) {
TemplateArgsInfo.setLAngleLoc(ArgsInfo.getLAngleLoc());
TemplateArgsInfo.setRAngleLoc(ArgsInfo.getRAngleLoc());
for (const TemplateArgumentLoc &Loc : ArgsInfo.arguments())
  TemplateArgsInfo.addArgument(Loc);
1318}

1320//===----------------------------------------------------------------------===//
1321// VarTemplatePartialSpecializationDecl Implementation
1322//===----------------------------------------------------------------------===//

1324void VarTemplatePartialSpecializationDecl::anchor() {}

1326VarTemplatePartialSpecializationDecl::VarTemplatePartialSpecializationDecl(
  ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
  SourceLocation IdLoc, TemplateParameterList *Params,
  VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
  StorageClass S, ArrayRef<TemplateArgument> Args,
  const ASTTemplateArgumentListInfo *ArgInfos)
  : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization, Context,
                                  DC, StartLoc, IdLoc, SpecializedTemplate, T,
                                  TInfo, S, Args),
    TemplateParams(Params), ArgsAsWritten(ArgInfos),
    InstantiatedFromMember(nullptr, false) {
// TODO: The template parameters should be in DC by now. Verify.
// AdoptTemplateParameterList(Params, DC);
1339}

1341VarTemplatePartialSpecializationDecl *
1342VarTemplatePartialSpecializationDecl::Create(
  ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
  SourceLocation IdLoc, TemplateParameterList *Params,
  VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
  StorageClass S, ArrayRef<TemplateArgument> Args,
  const TemplateArgumentListInfo &ArgInfos) {
const ASTTemplateArgumentListInfo *ASTArgInfos
  = ASTTemplateArgumentListInfo::Create(Context, ArgInfos);

auto *Result =
    new (Context, DC) VarTemplatePartialSpecializationDecl(
        Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo,
        S, Args, ASTArgInfos);
Result->setSpecializationKind(TSK_ExplicitSpecialization);
return Result;
1357}

1359VarTemplatePartialSpecializationDecl *
1360VarTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
                                                       unsigned ID) {
return new (C, ID) VarTemplatePartialSpecializationDecl(C);
1363}

1365static TemplateParameterList *
1366createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC) {
// typename T
auto *T = TemplateTypeParmDecl::Create(
    C, DC, SourceLocation(), SourceLocation(), /*Depth=*/1, /*Position=*/0,
    /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false,
    /*HasTypeConstraint=*/false);
T->setImplicit(true);

// T ...Ints
TypeSourceInfo *TI =
    C.getTrivialTypeSourceInfo(QualType(T->getTypeForDecl(), 0));
auto *N = NonTypeTemplateParmDecl::Create(
    C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
    /*Id=*/nullptr, TI->getType(), /*ParameterPack=*/true, TI);
N->setImplicit(true);

// <typename T, T ...Ints>
NamedDecl *P[2] = {T, N};
auto *TPL = TemplateParameterList::Create(
    C, SourceLocation(), SourceLocation(), P, SourceLocation(), nullptr);

// template <typename T, ...Ints> class IntSeq
auto *TemplateTemplateParm = TemplateTemplateParmDecl::Create(
    C, DC, SourceLocation(), /*Depth=*/0, /*Position=*/0,
    /*ParameterPack=*/false, /*Id=*/nullptr, TPL);
TemplateTemplateParm->setImplicit(true);

// typename T
auto *TemplateTypeParm = TemplateTypeParmDecl::Create(
    C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
    /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false,
    /*HasTypeConstraint=*/false);
TemplateTypeParm->setImplicit(true);

// T N
TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(
    QualType(TemplateTypeParm->getTypeForDecl(), 0));
auto *NonTypeTemplateParm = NonTypeTemplateParmDecl::Create(
    C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/2,
    /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
NamedDecl *Params[] = {TemplateTemplateParm, TemplateTypeParm,
                       NonTypeTemplateParm};

// template <template <typename T, T ...Ints> class IntSeq, typename T, T N>
return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
                                     Params, SourceLocation(), nullptr);
1412}

1414static TemplateParameterList *
1415createTypePackElementParameterList(const ASTContext &C, DeclContext *DC) {
// std::size_t Index
TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(C.getSizeType());
auto *Index = NonTypeTemplateParmDecl::Create(
    C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/0,
    /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);

// typename ...T
auto *Ts = TemplateTypeParmDecl::Create(
    C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
    /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/true,
    /*HasTypeConstraint=*/false);
Ts->setImplicit(true);

// template <std::size_t Index, typename ...T>
NamedDecl *Params[] = {Index, Ts};
return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
5
←
Calling 'TemplateParameterList::Create'→
                                     llvm::makeArrayRef(Params),
                                     SourceLocation(), nullptr);
4
←
Passing null pointer value via 6th parameter 'RequiresClause'→
1434}

1436static TemplateParameterList *createBuiltinTemplateParameterList(
  const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK) {
switch (BTK) {
2
←
Control jumps to 'case BTK__type_pack_element:'  at line 1441→
case BTK__make_integer_seq:
  return createMakeIntegerSeqParameterList(C, DC);
case BTK__type_pack_element:
  return createTypePackElementParameterList(C, DC);
3
←
Calling 'createTypePackElementParameterList'→
}

llvm_unreachable("unhandled BuiltinTemplateKind!")__builtin_unreachable();
1446}

1448void BuiltinTemplateDecl::anchor() {}

1450BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
                                       DeclarationName Name,
                                       BuiltinTemplateKind BTK)
  : TemplateDecl(BuiltinTemplate, DC, SourceLocation(), Name,
                 createBuiltinTemplateParameterList(C, DC, BTK)),
1
Calling 'createBuiltinTemplateParameterList'→
    BTK(BTK) {}

1457void TypeConstraint::print(llvm::raw_ostream &OS, PrintingPolicy Policy) const {
if (NestedNameSpec)
  NestedNameSpec.getNestedNameSpecifier()->print(OS, Policy);
ConceptName.printName(OS, Policy);
if (hasExplicitTemplateArgs()) {
  OS << "<";
  // FIXME: Find corresponding parameter for argument
  for (auto &ArgLoc : ArgsAsWritten->arguments())
    ArgLoc.getArgument().print(Policy, OS, /*IncludeType*/ false);
  OS << ">";
}
1468}

1470TemplateParamObjectDecl *TemplateParamObjectDecl::Create(const ASTContext &C,
                                                       QualType T,
                                                       const APValue &V) {
DeclContext *DC = C.getTranslationUnitDecl();
auto *TPOD = new (C, DC) TemplateParamObjectDecl(DC, T, V);
C.addDestruction(&TPOD->Value);
return TPOD;
1477}

1479TemplateParamObjectDecl *
1480TemplateParamObjectDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
auto *TPOD = new (C, ID) TemplateParamObjectDecl(nullptr, QualType(), APValue());
C.addDestruction(&TPOD->Value);
return TPOD;
1484}

1486void TemplateParamObjectDecl::printName(llvm::raw_ostream &OS) const {
OS << "<template param ";
printAsExpr(OS);
OS << ">";
1490}

1492void TemplateParamObjectDecl::printAsExpr(llvm::raw_ostream &OS) const {
const ASTContext &Ctx = getASTContext();
getType().getUnqualifiedType().print(OS, Ctx.getPrintingPolicy());
printAsInit(OS);
1496}

1498void TemplateParamObjectDecl::printAsInit(llvm::raw_ostream &OS) const {
const ASTContext &Ctx = getASTContext();
getValue().printPretty(OS, Ctx, getType());
1501}