/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

Bug Summary

File:	tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
Warning:	line 1845, column 33 Access to field 'TypeAsWritten' results in a dereference of a null pointer (loaded from field 'ExplicitInfo')

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaTemplateInstantiateDecl.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn326061/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326061/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326061/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326061/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn326061/build-llvm/tools/clang/lib/Sema -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-02-26-041543-15277-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

→

1//===--- SemaTemplateInstantiateDecl.cpp - C++ Template Decl Instantiation ===/
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//===----------------------------------------------------------------------===/
8//
9//  This file implements C++ template instantiation for declarations.
10//
11//===----------------------------------------------------------------------===/
12#include "clang/Sema/SemaInternal.h"
13#include "clang/AST/ASTConsumer.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/ASTMutationListener.h"
16#include "clang/AST/DeclTemplate.h"
17#include "clang/AST/DeclVisitor.h"
18#include "clang/AST/DependentDiagnostic.h"
19#include "clang/AST/Expr.h"
20#include "clang/AST/ExprCXX.h"
21#include "clang/AST/TypeLoc.h"
22#include "clang/Sema/Initialization.h"
23#include "clang/Sema/Lookup.h"
24#include "clang/Sema/PrettyDeclStackTrace.h"
25#include "clang/Sema/Template.h"
26#include "clang/Sema/TemplateInstCallback.h"

28using namespace clang;

30static bool isDeclWithinFunction(const Decl *D) {
const DeclContext *DC = D->getDeclContext();
if (DC->isFunctionOrMethod())
  return true;

if (DC->isRecord())
  return cast<CXXRecordDecl>(DC)->isLocalClass();

return false;
39}

41template<typename DeclT>
42static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl,
                         const MultiLevelTemplateArgumentList &TemplateArgs) {
if (!OldDecl->getQualifierLoc())
  return false;

assert((NewDecl->getFriendObjectKind() ||(static_cast <bool> ((NewDecl->getFriendObjectKind()
 || !OldDecl->getLexicalDeclContext()->isDependentContext
()) && "non-friend with qualified name defined in dependent context"
) ? void (0) : __assert_fail ("(NewDecl->getFriendObjectKind() || !OldDecl->getLexicalDeclContext()->isDependentContext()) && \"non-friend with qualified name defined in dependent context\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 49, __extension__ __PRETTY_FUNCTION__))
        !OldDecl->getLexicalDeclContext()->isDependentContext()) &&(static_cast <bool> ((NewDecl->getFriendObjectKind()
 || !OldDecl->getLexicalDeclContext()->isDependentContext
()) && "non-friend with qualified name defined in dependent context"
) ? void (0) : __assert_fail ("(NewDecl->getFriendObjectKind() || !OldDecl->getLexicalDeclContext()->isDependentContext()) && \"non-friend with qualified name defined in dependent context\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 49, __extension__ __PRETTY_FUNCTION__))
       "non-friend with qualified name defined in dependent context")(static_cast <bool> ((NewDecl->getFriendObjectKind()
 || !OldDecl->getLexicalDeclContext()->isDependentContext
()) && "non-friend with qualified name defined in dependent context"
) ? void (0) : __assert_fail ("(NewDecl->getFriendObjectKind() || !OldDecl->getLexicalDeclContext()->isDependentContext()) && \"non-friend with qualified name defined in dependent context\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 49, __extension__ __PRETTY_FUNCTION__));
Sema::ContextRAII SavedContext(
    SemaRef,
    const_cast<DeclContext *>(NewDecl->getFriendObjectKind()
                                  ? NewDecl->getLexicalDeclContext()
                                  : OldDecl->getLexicalDeclContext()));

NestedNameSpecifierLoc NewQualifierLoc
    = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
                                          TemplateArgs);

if (!NewQualifierLoc)
  return true;

NewDecl->setQualifierInfo(NewQualifierLoc);
return false;
65}

67bool TemplateDeclInstantiator::SubstQualifier(const DeclaratorDecl *OldDecl,
                                            DeclaratorDecl *NewDecl) {
return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
70}

72bool TemplateDeclInstantiator::SubstQualifier(const TagDecl *OldDecl,
                                            TagDecl *NewDecl) {
return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
75}

77// Include attribute instantiation code.
78#include "clang/Sema/AttrTemplateInstantiate.inc"

80static void instantiateDependentAlignedAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion) {
if (Aligned->isAlignmentExpr()) {
  // The alignment expression is a constant expression.
  EnterExpressionEvaluationContext Unevaluated(
      S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
  ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs);
  if (!Result.isInvalid())
    S.AddAlignedAttr(Aligned->getLocation(), New, Result.getAs<Expr>(),
                     Aligned->getSpellingListIndex(), IsPackExpansion);
} else {
  TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(),
                                       TemplateArgs, Aligned->getLocation(),
                                       DeclarationName());
  if (Result)
    S.AddAlignedAttr(Aligned->getLocation(), New, Result,
                     Aligned->getSpellingListIndex(), IsPackExpansion);
}
99}

101static void instantiateDependentAlignedAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const AlignedAttr *Aligned, Decl *New) {
if (!Aligned->isPackExpansion()) {
  instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
  return;
}

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
if (Aligned->isAlignmentExpr())
  S.collectUnexpandedParameterPacks(Aligned->getAlignmentExpr(),
                                    Unexpanded);
else
  S.collectUnexpandedParameterPacks(Aligned->getAlignmentType()->getTypeLoc(),
                                    Unexpanded);
assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 116, __extension__ __PRETTY_FUNCTION__));

// Determine whether we can expand this attribute pack yet.
bool Expand = true, RetainExpansion = false;
Optional<unsigned> NumExpansions;
// FIXME: Use the actual location of the ellipsis.
SourceLocation EllipsisLoc = Aligned->getLocation();
if (S.CheckParameterPacksForExpansion(EllipsisLoc, Aligned->getRange(),
                                      Unexpanded, TemplateArgs, Expand,
                                      RetainExpansion, NumExpansions))
  return;

if (!Expand) {
  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, -1);
  instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, true);
} else {
  for (unsigned I = 0; I != *NumExpansions; ++I) {
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, I);
    instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
  }
}
137}

139static void instantiateDependentAssumeAlignedAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const AssumeAlignedAttr *Aligned, Decl *New) {
// The alignment expression is a constant expression.
EnterExpressionEvaluationContext Unevaluated(
    S, Sema::ExpressionEvaluationContext::ConstantEvaluated);

Expr *E, *OE = nullptr;
ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
if (Result.isInvalid())
  return;
E = Result.getAs<Expr>();

if (Aligned->getOffset()) {
  Result = S.SubstExpr(Aligned->getOffset(), TemplateArgs);
  if (Result.isInvalid())
    return;
  OE = Result.getAs<Expr>();
}

S.AddAssumeAlignedAttr(Aligned->getLocation(), New, E, OE,
                       Aligned->getSpellingListIndex());
161}

163static void instantiateDependentAlignValueAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const AlignValueAttr *Aligned, Decl *New) {
// The alignment expression is a constant expression.
EnterExpressionEvaluationContext Unevaluated(
    S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
if (!Result.isInvalid())
  S.AddAlignValueAttr(Aligned->getLocation(), New, Result.getAs<Expr>(),
                      Aligned->getSpellingListIndex());
173}

175static void instantiateDependentAllocAlignAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const AllocAlignAttr *Align, Decl *New) {
Expr *Param = IntegerLiteral::Create(
    S.getASTContext(), llvm::APInt(64, Align->getParamIndex()),
    S.getASTContext().UnsignedLongLongTy, Align->getLocation());
S.AddAllocAlignAttr(Align->getLocation(), New, Param,
                    Align->getSpellingListIndex());
183}

185static Expr *instantiateDependentFunctionAttrCondition(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New) {
Expr *Cond = nullptr;
{
  Sema::ContextRAII SwitchContext(S, New);
  EnterExpressionEvaluationContext Unevaluated(
      S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
  ExprResult Result = S.SubstExpr(OldCond, TemplateArgs);
  if (Result.isInvalid())
    return nullptr;
  Cond = Result.getAs<Expr>();
}
if (!Cond->isTypeDependent()) {
  ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
  if (Converted.isInvalid())
    return nullptr;
  Cond = Converted.get();
}

SmallVector<PartialDiagnosticAt, 8> Diags;
if (OldCond->isValueDependent() && !Cond->isValueDependent() &&
    !Expr::isPotentialConstantExprUnevaluated(Cond, New, Diags)) {
  S.Diag(A->getLocation(), diag::err_attr_cond_never_constant_expr) << A;
  for (const auto &P : Diags)
    S.Diag(P.first, P.second);
  return nullptr;
}
return Cond;
214}

216static void instantiateDependentEnableIfAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New) {
Expr *Cond = instantiateDependentFunctionAttrCondition(
    S, TemplateArgs, EIA, EIA->getCond(), Tmpl, New);

if (Cond)
  New->addAttr(new (S.getASTContext()) EnableIfAttr(
      EIA->getLocation(), S.getASTContext(), Cond, EIA->getMessage(),
      EIA->getSpellingListIndex()));
226}

228static void instantiateDependentDiagnoseIfAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New) {
Expr *Cond = instantiateDependentFunctionAttrCondition(
    S, TemplateArgs, DIA, DIA->getCond(), Tmpl, New);

if (Cond)
  New->addAttr(new (S.getASTContext()) DiagnoseIfAttr(
      DIA->getLocation(), S.getASTContext(), Cond, DIA->getMessage(),
      DIA->getDiagnosticType(), DIA->getArgDependent(), New,
      DIA->getSpellingListIndex()));
239}

241// Constructs and adds to New a new instance of CUDALaunchBoundsAttr using
242// template A as the base and arguments from TemplateArgs.
243static void instantiateDependentCUDALaunchBoundsAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const CUDALaunchBoundsAttr &Attr, Decl *New) {
// The alignment expression is a constant expression.
EnterExpressionEvaluationContext Unevaluated(
    S, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult Result = S.SubstExpr(Attr.getMaxThreads(), TemplateArgs);
if (Result.isInvalid())
  return;
Expr *MaxThreads = Result.getAs<Expr>();

Expr *MinBlocks = nullptr;
if (Attr.getMinBlocks()) {
  Result = S.SubstExpr(Attr.getMinBlocks(), TemplateArgs);
  if (Result.isInvalid())
    return;
  MinBlocks = Result.getAs<Expr>();
}

S.AddLaunchBoundsAttr(Attr.getLocation(), New, MaxThreads, MinBlocks,
                      Attr.getSpellingListIndex());
265}

267static void
268instantiateDependentModeAttr(Sema &S,
                           const MultiLevelTemplateArgumentList &TemplateArgs,
                           const ModeAttr &Attr, Decl *New) {
S.AddModeAttr(Attr.getRange(), New, Attr.getMode(),
              Attr.getSpellingListIndex(), /*InInstantiation=*/true);
273}

275/// Instantiation of 'declare simd' attribute and its arguments.
276static void instantiateOMPDeclareSimdDeclAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const OMPDeclareSimdDeclAttr &Attr, Decl *New) {
// Allow 'this' in clauses with varlists.
if (auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
  New = FTD->getTemplatedDecl();
auto *FD = cast<FunctionDecl>(New);
auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
SmallVector<Expr *, 4> Uniforms, Aligneds, Alignments, Linears, Steps;
SmallVector<unsigned, 4> LinModifiers;

auto &&Subst = [&](Expr *E) -> ExprResult {
  if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
    if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
      Sema::ContextRAII SavedContext(S, FD);
      LocalInstantiationScope Local(S);
      if (FD->getNumParams() > PVD->getFunctionScopeIndex())
        Local.InstantiatedLocal(
            PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
      return S.SubstExpr(E, TemplateArgs);
    }
  Sema::CXXThisScopeRAII ThisScope(S, ThisContext, /*TypeQuals=*/0,
                                   FD->isCXXInstanceMember());
  return S.SubstExpr(E, TemplateArgs);
};

ExprResult Simdlen;
if (auto *E = Attr.getSimdlen())
  Simdlen = Subst(E);

if (Attr.uniforms_size() > 0) {
  for(auto *E : Attr.uniforms()) {
    ExprResult Inst = Subst(E);
    if (Inst.isInvalid())
      continue;
    Uniforms.push_back(Inst.get());
  }
}

auto AI = Attr.alignments_begin();
for (auto *E : Attr.aligneds()) {
  ExprResult Inst = Subst(E);
  if (Inst.isInvalid())
    continue;
  Aligneds.push_back(Inst.get());
  Inst = ExprEmpty();
  if (*AI)
    Inst = S.SubstExpr(*AI, TemplateArgs);
  Alignments.push_back(Inst.get());
  ++AI;
}

auto SI = Attr.steps_begin();
for (auto *E : Attr.linears()) {
  ExprResult Inst = Subst(E);
  if (Inst.isInvalid())
    continue;
  Linears.push_back(Inst.get());
  Inst = ExprEmpty();
  if (*SI)
    Inst = S.SubstExpr(*SI, TemplateArgs);
  Steps.push_back(Inst.get());
  ++SI;
}
LinModifiers.append(Attr.modifiers_begin(), Attr.modifiers_end());
(void)S.ActOnOpenMPDeclareSimdDirective(
    S.ConvertDeclToDeclGroup(New), Attr.getBranchState(), Simdlen.get(),
    Uniforms, Aligneds, Alignments, Linears, LinModifiers, Steps,
    Attr.getRange());
345}

347void Sema::InstantiateAttrsForDecl(
  const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Tmpl,
  Decl *New, LateInstantiatedAttrVec *LateAttrs,
  LocalInstantiationScope *OuterMostScope) {
if (NamedDecl *ND = dyn_cast<NamedDecl>(New)) {
  for (const auto *TmplAttr : Tmpl->attrs()) {
    // FIXME: If any of the special case versions from InstantiateAttrs become
    // applicable to template declaration, we'll need to add them here.
    CXXThisScopeRAII ThisScope(
        *this, dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()),
        /*TypeQuals*/ 0, ND->isCXXInstanceMember());

    Attr *NewAttr = sema::instantiateTemplateAttributeForDecl(
        TmplAttr, Context, *this, TemplateArgs);
    if (NewAttr)
      New->addAttr(NewAttr);
  }
}
365}

367void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
                          const Decl *Tmpl, Decl *New,
                          LateInstantiatedAttrVec *LateAttrs,
                          LocalInstantiationScope *OuterMostScope) {
for (const auto *TmplAttr : Tmpl->attrs()) {
  // FIXME: This should be generalized to more than just the AlignedAttr.
  const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
  if (Aligned && Aligned->isAlignmentDependent()) {
    instantiateDependentAlignedAttr(*this, TemplateArgs, Aligned, New);
    continue;
  }

  const AssumeAlignedAttr *AssumeAligned = dyn_cast<AssumeAlignedAttr>(TmplAttr);
  if (AssumeAligned) {
    instantiateDependentAssumeAlignedAttr(*this, TemplateArgs, AssumeAligned, New);
    continue;
  }

  const AlignValueAttr *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr);
  if (AlignValue) {
    instantiateDependentAlignValueAttr(*this, TemplateArgs, AlignValue, New);
    continue;
  }

  if (const auto *AllocAlign = dyn_cast<AllocAlignAttr>(TmplAttr)) {
    instantiateDependentAllocAlignAttr(*this, TemplateArgs, AllocAlign, New);
    continue;
  }


  if (const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) {
    instantiateDependentEnableIfAttr(*this, TemplateArgs, EnableIf, Tmpl,
                                     cast<FunctionDecl>(New));
    continue;
  }

  if (const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) {
    instantiateDependentDiagnoseIfAttr(*this, TemplateArgs, DiagnoseIf, Tmpl,
                                       cast<FunctionDecl>(New));
    continue;
  }

  if (const CUDALaunchBoundsAttr *CUDALaunchBounds =
          dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
    instantiateDependentCUDALaunchBoundsAttr(*this, TemplateArgs,
                                             *CUDALaunchBounds, New);
    continue;
  }

  if (const ModeAttr *Mode = dyn_cast<ModeAttr>(TmplAttr)) {
    instantiateDependentModeAttr(*this, TemplateArgs, *Mode, New);
    continue;
  }

  if (const auto *OMPAttr = dyn_cast<OMPDeclareSimdDeclAttr>(TmplAttr)) {
    instantiateOMPDeclareSimdDeclAttr(*this, TemplateArgs, *OMPAttr, New);
    continue;
  }

  // Existing DLL attribute on the instantiation takes precedence.
  if (TmplAttr->getKind() == attr::DLLExport ||
      TmplAttr->getKind() == attr::DLLImport) {
    if (New->hasAttr<DLLExportAttr>() || New->hasAttr<DLLImportAttr>()) {
      continue;
    }
  }

  if (auto ABIAttr = dyn_cast<ParameterABIAttr>(TmplAttr)) {
    AddParameterABIAttr(ABIAttr->getRange(), New, ABIAttr->getABI(),
                        ABIAttr->getSpellingListIndex());
    continue;
  }

  if (isa<NSConsumedAttr>(TmplAttr) || isa<CFConsumedAttr>(TmplAttr)) {
    AddNSConsumedAttr(TmplAttr->getRange(), New,
                      TmplAttr->getSpellingListIndex(),
                      isa<NSConsumedAttr>(TmplAttr),
                      /*template instantiation*/ true);
    continue;
  }

  assert(!TmplAttr->isPackExpansion())(static_cast <bool> (!TmplAttr->isPackExpansion()) ?
 void (0) : __assert_fail ("!TmplAttr->isPackExpansion()",
 "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 448, __extension__ __PRETTY_FUNCTION__));
  if (TmplAttr->isLateParsed() && LateAttrs) {
    // Late parsed attributes must be instantiated and attached after the
    // enclosing class has been instantiated.  See Sema::InstantiateClass.
    LocalInstantiationScope *Saved = nullptr;
    if (CurrentInstantiationScope)
      Saved = CurrentInstantiationScope->cloneScopes(OuterMostScope);
    LateAttrs->push_back(LateInstantiatedAttribute(TmplAttr, Saved, New));
  } else {
    // Allow 'this' within late-parsed attributes.
    NamedDecl *ND = dyn_cast<NamedDecl>(New);
    CXXRecordDecl *ThisContext =
        dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
    CXXThisScopeRAII ThisScope(*this, ThisContext, /*TypeQuals*/0,
                               ND && ND->isCXXInstanceMember());

    Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context,
                                                       *this, TemplateArgs);
    if (NewAttr)
      New->addAttr(NewAttr);
  }
}
470}

472/// Get the previous declaration of a declaration for the purposes of template
473/// instantiation. If this finds a previous declaration, then the previous
474/// declaration of the instantiation of D should be an instantiation of the
475/// result of this function.
476template<typename DeclT>
477static DeclT *getPreviousDeclForInstantiation(DeclT *D) {
DeclT *Result = D->getPreviousDecl();

// If the declaration is within a class, and the previous declaration was
// merged from a different definition of that class, then we don't have a
// previous declaration for the purpose of template instantiation.
if (Result && isa<CXXRecordDecl>(D->getDeclContext()) &&
    D->getLexicalDeclContext() != Result->getLexicalDeclContext())
  return nullptr;

return Result;
488}

490Decl *
491TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
llvm_unreachable("Translation units cannot be instantiated")::llvm::llvm_unreachable_internal("Translation units cannot be instantiated"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 492);
493}

495Decl *
496TemplateDeclInstantiator::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
llvm_unreachable("pragma comment cannot be instantiated")::llvm::llvm_unreachable_internal("pragma comment cannot be instantiated"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 497);
498}

500Decl *TemplateDeclInstantiator::VisitPragmaDetectMismatchDecl(
  PragmaDetectMismatchDecl *D) {
llvm_unreachable("pragma comment cannot be instantiated")::llvm::llvm_unreachable_internal("pragma comment cannot be instantiated"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 502);
503}

505Decl *
506TemplateDeclInstantiator::VisitExternCContextDecl(ExternCContextDecl *D) {
llvm_unreachable("extern \"C\" context cannot be instantiated")::llvm::llvm_unreachable_internal("extern \"C\" context cannot be instantiated"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 507);
508}

510Decl *
511TemplateDeclInstantiator::VisitLabelDecl(LabelDecl *D) {
LabelDecl *Inst = LabelDecl::Create(SemaRef.Context, Owner, D->getLocation(),
                                    D->getIdentifier());
Owner->addDecl(Inst);
return Inst;
516}

518Decl *
519TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) {
llvm_unreachable("Namespaces cannot be instantiated")::llvm::llvm_unreachable_internal("Namespaces cannot be instantiated"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 520);
521}

523Decl *
524TemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
NamespaceAliasDecl *Inst
  = NamespaceAliasDecl::Create(SemaRef.Context, Owner,
                               D->getNamespaceLoc(),
                               D->getAliasLoc(),
                               D->getIdentifier(),
                               D->getQualifierLoc(),
                               D->getTargetNameLoc(),
                               D->getNamespace());
Owner->addDecl(Inst);
return Inst;
535}

537Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D,
                                                         bool IsTypeAlias) {
bool Invalid = false;
TypeSourceInfo *DI = D->getTypeSourceInfo();
if (DI->getType()->isInstantiationDependentType() ||
    DI->getType()->isVariablyModifiedType()) {
  DI = SemaRef.SubstType(DI, TemplateArgs,
                         D->getLocation(), D->getDeclName());
  if (!DI) {
    Invalid = true;
    DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
  }
} else {
  SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
}

// HACK: g++ has a bug where it gets the value kind of ?: wrong.
// libstdc++ relies upon this bug in its implementation of common_type.
// If we happen to be processing that implementation, fake up the g++ ?:
// semantics. See LWG issue 2141 for more information on the bug.
const DecltypeType *DT = DI->getType()->getAs<DecltypeType>();
CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
if (DT && RD && isa<ConditionalOperator>(DT->getUnderlyingExpr()) &&
    DT->isReferenceType() &&
    RD->getEnclosingNamespaceContext() == SemaRef.getStdNamespace() &&
    RD->getIdentifier() && RD->getIdentifier()->isStr("common_type") &&
    D->getIdentifier() && D->getIdentifier()->isStr("type") &&
    SemaRef.getSourceManager().isInSystemHeader(D->getLocStart()))
  // Fold it to the (non-reference) type which g++ would have produced.
  DI = SemaRef.Context.getTrivialTypeSourceInfo(
    DI->getType().getNonReferenceType());

// Create the new typedef
TypedefNameDecl *Typedef;
if (IsTypeAlias)
  Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
                                  D->getLocation(), D->getIdentifier(), DI);
else
  Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
                                D->getLocation(), D->getIdentifier(), DI);
if (Invalid)
  Typedef->setInvalidDecl();

// If the old typedef was the name for linkage purposes of an anonymous
// tag decl, re-establish that relationship for the new typedef.
if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) {
  TagDecl *oldTag = oldTagType->getDecl();
  if (oldTag->getTypedefNameForAnonDecl() == D && !Invalid) {
    TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl();
    assert(!newTag->hasNameForLinkage())(static_cast <bool> (!newTag->hasNameForLinkage()) ?
 void (0) : __assert_fail ("!newTag->hasNameForLinkage()",
 "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 586, __extension__ __PRETTY_FUNCTION__));
    newTag->setTypedefNameForAnonDecl(Typedef);
  }
}

if (TypedefNameDecl *Prev = getPreviousDeclForInstantiation(D)) {
  NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev,
                                                     TemplateArgs);
  if (!InstPrev)
    return nullptr;

  TypedefNameDecl *InstPrevTypedef = cast<TypedefNameDecl>(InstPrev);

  // If the typedef types are not identical, reject them.
  SemaRef.isIncompatibleTypedef(InstPrevTypedef, Typedef);

  Typedef->setPreviousDecl(InstPrevTypedef);
}

SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef);

Typedef->setAccess(D->getAccess());

return Typedef;
610}

612Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) {
Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/false);
if (Typedef)
  Owner->addDecl(Typedef);
return Typedef;
617}

619Decl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) {
Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/true);
if (Typedef)
  Owner->addDecl(Typedef);
return Typedef;
624}

626Decl *
627TemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
// Create a local instantiation scope for this type alias template, which
// will contain the instantiations of the template parameters.
LocalInstantiationScope Scope(SemaRef);

TemplateParameterList *TempParams = D->getTemplateParameters();
TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
if (!InstParams)
  return nullptr;

TypeAliasDecl *Pattern = D->getTemplatedDecl();

TypeAliasTemplateDecl *PrevAliasTemplate = nullptr;
if (getPreviousDeclForInstantiation<TypedefNameDecl>(Pattern)) {
  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
  if (!Found.empty()) {
    PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Found.front());
  }
}

TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>(
  InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true));
if (!AliasInst)
  return nullptr;

TypeAliasTemplateDecl *Inst
  = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(),
                                  D->getDeclName(), InstParams, AliasInst);
AliasInst->setDescribedAliasTemplate(Inst);
if (PrevAliasTemplate)
  Inst->setPreviousDecl(PrevAliasTemplate);

Inst->setAccess(D->getAccess());

if (!PrevAliasTemplate)
  Inst->setInstantiatedFromMemberTemplate(D);

Owner->addDecl(Inst);

return Inst;
667}

669Decl *TemplateDeclInstantiator::VisitBindingDecl(BindingDecl *D) {
auto *NewBD = BindingDecl::Create(SemaRef.Context, Owner, D->getLocation(),
                                  D->getIdentifier());
NewBD->setReferenced(D->isReferenced());
SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewBD);
return NewBD;
675}

677Decl *TemplateDeclInstantiator::VisitDecompositionDecl(DecompositionDecl *D) {
// Transform the bindings first.
SmallVector<BindingDecl*, 16> NewBindings;
for (auto *OldBD : D->bindings())
  NewBindings.push_back(cast<BindingDecl>(VisitBindingDecl(OldBD)));
ArrayRef<BindingDecl*> NewBindingArray = NewBindings;

auto *NewDD = cast_or_null<DecompositionDecl>(
    VisitVarDecl(D, /*InstantiatingVarTemplate=*/false, &NewBindingArray));

if (!NewDD || NewDD->isInvalidDecl())
  for (auto *NewBD : NewBindings)
    NewBD->setInvalidDecl();

return NewDD;
692}

694Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) {
return VisitVarDecl(D, /*InstantiatingVarTemplate=*/false);
696}

698Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D,
                                           bool InstantiatingVarTemplate,
                                           ArrayRef<BindingDecl*> *Bindings) {

// Do substitution on the type of the declaration
TypeSourceInfo *DI = SemaRef.SubstType(
    D->getTypeSourceInfo(), TemplateArgs, D->getTypeSpecStartLoc(),
    D->getDeclName(), /*AllowDeducedTST*/true);
if (!DI)
  return nullptr;

if (DI->getType()->isFunctionType()) {
  SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
    << D->isStaticDataMember() << DI->getType();
  return nullptr;
}

DeclContext *DC = Owner;
if (D->isLocalExternDecl())
  SemaRef.adjustContextForLocalExternDecl(DC);

// Build the instantiated declaration.
VarDecl *Var;
if (Bindings)
  Var = DecompositionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
                                  D->getLocation(), DI->getType(), DI,
                                  D->getStorageClass(), *Bindings);
else
  Var = VarDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
                        D->getLocation(), D->getIdentifier(), DI->getType(),
                        DI, D->getStorageClass());

// In ARC, infer 'retaining' for variables of retainable type.
if (SemaRef.getLangOpts().ObjCAutoRefCount && 
    SemaRef.inferObjCARCLifetime(Var))
  Var->setInvalidDecl();

// Substitute the nested name specifier, if any.
if (SubstQualifier(D, Var))
  return nullptr;

SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
                                   StartingScope, InstantiatingVarTemplate);

if (D->isNRVOVariable()) {
  QualType ReturnType = cast<FunctionDecl>(DC)->getReturnType();
  if (SemaRef.isCopyElisionCandidate(ReturnType, Var, false))
    Var->setNRVOVariable(true);
}

Var->setImplicit(D->isImplicit());

return Var;
751}

753Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) {
AccessSpecDecl* AD
  = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner,
                           D->getAccessSpecifierLoc(), D->getColonLoc());
Owner->addHiddenDecl(AD);
return AD;
759}

761Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
bool Invalid = false;
TypeSourceInfo *DI = D->getTypeSourceInfo();
if (DI->getType()->isInstantiationDependentType() ||
    DI->getType()->isVariablyModifiedType())  {
  DI = SemaRef.SubstType(DI, TemplateArgs,
                         D->getLocation(), D->getDeclName());
  if (!DI) {
    DI = D->getTypeSourceInfo();
    Invalid = true;
  } else if (DI->getType()->isFunctionType()) {
    // C++ [temp.arg.type]p3:
    //   If a declaration acquires a function type through a type
    //   dependent on a template-parameter and this causes a
    //   declaration that does not use the syntactic form of a
    //   function declarator to have function type, the program is
    //   ill-formed.
    SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
      << DI->getType();
    Invalid = true;
  }
} else {
  SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
}

Expr *BitWidth = D->getBitWidth();
if (Invalid)
  BitWidth = nullptr;
else if (BitWidth) {
  // The bit-width expression is a constant expression.
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

  ExprResult InstantiatedBitWidth
    = SemaRef.SubstExpr(BitWidth, TemplateArgs);
  if (InstantiatedBitWidth.isInvalid()) {
    Invalid = true;
    BitWidth = nullptr;
  } else
    BitWidth = InstantiatedBitWidth.getAs<Expr>();
}

FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(),
                                          DI->getType(), DI,
                                          cast<RecordDecl>(Owner),
                                          D->getLocation(),
                                          D->isMutable(),
                                          BitWidth,
                                          D->getInClassInitStyle(),
                                          D->getInnerLocStart(),
                                          D->getAccess(),
                                          nullptr);
if (!Field) {
  cast<Decl>(Owner)->setInvalidDecl();
  return nullptr;
}

SemaRef.InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope);

if (Field->hasAttrs())
  SemaRef.CheckAlignasUnderalignment(Field);

if (Invalid)
  Field->setInvalidDecl();

if (!Field->getDeclName()) {
  // Keep track of where this decl came from.
  SemaRef.Context.setInstantiatedFromUnnamedFieldDecl(Field, D);
}
if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) {
  if (Parent->isAnonymousStructOrUnion() &&
      Parent->getRedeclContext()->isFunctionOrMethod())
    SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field);
}

Field->setImplicit(D->isImplicit());
Field->setAccess(D->getAccess());
Owner->addDecl(Field);

return Field;
841}

843Decl *TemplateDeclInstantiator::VisitMSPropertyDecl(MSPropertyDecl *D) {
bool Invalid = false;
TypeSourceInfo *DI = D->getTypeSourceInfo();

if (DI->getType()->isVariablyModifiedType()) {
  SemaRef.Diag(D->getLocation(), diag::err_property_is_variably_modified)
    << D;
  Invalid = true;
} else if (DI->getType()->isInstantiationDependentType())  {
  DI = SemaRef.SubstType(DI, TemplateArgs,
                         D->getLocation(), D->getDeclName());
  if (!DI) {
    DI = D->getTypeSourceInfo();
    Invalid = true;
  } else if (DI->getType()->isFunctionType()) {
    // C++ [temp.arg.type]p3:
    //   If a declaration acquires a function type through a type
    //   dependent on a template-parameter and this causes a
    //   declaration that does not use the syntactic form of a
    //   function declarator to have function type, the program is
    //   ill-formed.
    SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
    << DI->getType();
    Invalid = true;
  }
} else {
  SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
}

MSPropertyDecl *Property = MSPropertyDecl::Create(
    SemaRef.Context, Owner, D->getLocation(), D->getDeclName(), DI->getType(),
    DI, D->getLocStart(), D->getGetterId(), D->getSetterId());

SemaRef.InstantiateAttrs(TemplateArgs, D, Property, LateAttrs,
                         StartingScope);

if (Invalid)
  Property->setInvalidDecl();

Property->setAccess(D->getAccess());
Owner->addDecl(Property);

return Property;
886}

888Decl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
NamedDecl **NamedChain =
  new (SemaRef.Context)NamedDecl*[D->getChainingSize()];

int i = 0;
for (auto *PI : D->chain()) {
  NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), PI,
                                            TemplateArgs);
  if (!Next)
    return nullptr;

  NamedChain[i++] = Next;
}

QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
IndirectFieldDecl *IndirectField = IndirectFieldDecl::Create(
    SemaRef.Context, Owner, D->getLocation(), D->getIdentifier(), T,
    {NamedChain, D->getChainingSize()});

for (const auto *Attr : D->attrs())
  IndirectField->addAttr(Attr->clone(SemaRef.Context));

IndirectField->setImplicit(D->isImplicit());
IndirectField->setAccess(D->getAccess());
Owner->addDecl(IndirectField);
return IndirectField;
914}

916Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) {
// Handle friend type expressions by simply substituting template
// parameters into the pattern type and checking the result.
if (TypeSourceInfo *Ty = D->getFriendType()) {
  TypeSourceInfo *InstTy;
  // If this is an unsupported friend, don't bother substituting template
  // arguments into it. The actual type referred to won't be used by any
  // parts of Clang, and may not be valid for instantiating. Just use the
  // same info for the instantiated friend.
  if (D->isUnsupportedFriend()) {
    InstTy = Ty;
  } else {
    InstTy = SemaRef.SubstType(Ty, TemplateArgs,
                               D->getLocation(), DeclarationName());
  }
  if (!InstTy)
    return nullptr;

  FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getLocStart(),
                                               D->getFriendLoc(), InstTy);
  if (!FD)
    return nullptr;

  FD->setAccess(AS_public);
  FD->setUnsupportedFriend(D->isUnsupportedFriend());
  Owner->addDecl(FD);
  return FD;
}

NamedDecl *ND = D->getFriendDecl();
assert(ND && "friend decl must be a decl or a type!")(static_cast <bool> (ND && "friend decl must be a decl or a type!"
) ? void (0) : __assert_fail ("ND && \"friend decl must be a decl or a type!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 946, __extension__ __PRETTY_FUNCTION__));

// All of the Visit implementations for the various potential friend
// declarations have to be carefully written to work for friend
// objects, with the most important detail being that the target
// decl should almost certainly not be placed in Owner.
Decl *NewND = Visit(ND);
if (!NewND) return nullptr;

FriendDecl *FD =
  FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(),
                     cast<NamedDecl>(NewND), D->getFriendLoc());
FD->setAccess(AS_public);
FD->setUnsupportedFriend(D->isUnsupportedFriend());
Owner->addDecl(FD);
return FD;
962}

964Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) {
Expr *AssertExpr = D->getAssertExpr();

// The expression in a static assertion is a constant expression.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult InstantiatedAssertExpr
  = SemaRef.SubstExpr(AssertExpr, TemplateArgs);
if (InstantiatedAssertExpr.isInvalid())
  return nullptr;

return SemaRef.BuildStaticAssertDeclaration(D->getLocation(),
                                            InstantiatedAssertExpr.get(),
                                            D->getMessage(),
                                            D->getRParenLoc(),
                                            D->isFailed());
981}

983Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) {
EnumDecl *PrevDecl = nullptr;
if (EnumDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
  NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
                                                 PatternPrev,
                                                 TemplateArgs);
  if (!Prev) return nullptr;
  PrevDecl = cast<EnumDecl>(Prev);
}

EnumDecl *Enum = EnumDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
                                  D->getLocation(), D->getIdentifier(),
                                  PrevDecl, D->isScoped(),
                                  D->isScopedUsingClassTag(), D->isFixed());
if (D->isFixed()) {
  if (TypeSourceInfo *TI = D->getIntegerTypeSourceInfo()) {
    // If we have type source information for the underlying type, it means it
    // has been explicitly set by the user. Perform substitution on it before
    // moving on.
    SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
    TypeSourceInfo *NewTI = SemaRef.SubstType(TI, TemplateArgs, UnderlyingLoc,
                                              DeclarationName());
    if (!NewTI || SemaRef.CheckEnumUnderlyingType(NewTI))
      Enum->setIntegerType(SemaRef.Context.IntTy);
    else
      Enum->setIntegerTypeSourceInfo(NewTI);
  } else {
    assert(!D->getIntegerType()->isDependentType()(static_cast <bool> (!D->getIntegerType()->isDependentType
() && "Dependent type without type source info") ? void
 (0) : __assert_fail ("!D->getIntegerType()->isDependentType() && \"Dependent type without type source info\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1011, __extension__ __PRETTY_FUNCTION__))
           && "Dependent type without type source info")(static_cast <bool> (!D->getIntegerType()->isDependentType
() && "Dependent type without type source info") ? void
 (0) : __assert_fail ("!D->getIntegerType()->isDependentType() && \"Dependent type without type source info\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1011, __extension__ __PRETTY_FUNCTION__));
    Enum->setIntegerType(D->getIntegerType());
  }
}

SemaRef.InstantiateAttrs(TemplateArgs, D, Enum);

Enum->setInstantiationOfMemberEnum(D, TSK_ImplicitInstantiation);
Enum->setAccess(D->getAccess());
// Forward the mangling number from the template to the instantiated decl.
SemaRef.Context.setManglingNumber(Enum, SemaRef.Context.getManglingNumber(D));
// See if the old tag was defined along with a declarator.
// If it did, mark the new tag as being associated with that declarator.
if (DeclaratorDecl *DD = SemaRef.Context.getDeclaratorForUnnamedTagDecl(D))
  SemaRef.Context.addDeclaratorForUnnamedTagDecl(Enum, DD);
// See if the old tag was defined along with a typedef.
// If it did, mark the new tag as being associated with that typedef.
if (TypedefNameDecl *TND = SemaRef.Context.getTypedefNameForUnnamedTagDecl(D))
  SemaRef.Context.addTypedefNameForUnnamedTagDecl(Enum, TND);
if (SubstQualifier(D, Enum)) return nullptr;
Owner->addDecl(Enum);

EnumDecl *Def = D->getDefinition();
if (Def && Def != D) {
  // If this is an out-of-line definition of an enum member template, check
  // that the underlying types match in the instantiation of both
  // declarations.
  if (TypeSourceInfo *TI = Def->getIntegerTypeSourceInfo()) {
    SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
    QualType DefnUnderlying =
      SemaRef.SubstType(TI->getType(), TemplateArgs,
                        UnderlyingLoc, DeclarationName());
    SemaRef.CheckEnumRedeclaration(Def->getLocation(), Def->isScoped(),
                                   DefnUnderlying, /*IsFixed=*/true, Enum);
  }
}

// C++11 [temp.inst]p1: The implicit instantiation of a class template
// specialization causes the implicit instantiation of the declarations, but
// not the definitions of scoped member enumerations.
//
// DR1484 clarifies that enumeration definitions inside of a template
// declaration aren't considered entities that can be separately instantiated
// from the rest of the entity they are declared inside of.
if (isDeclWithinFunction(D) ? D == Def : Def && !Enum->isScoped()) {
  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Enum);
  InstantiateEnumDefinition(Enum, Def);
}

return Enum;
1061}

1063void TemplateDeclInstantiator::InstantiateEnumDefinition(
  EnumDecl *Enum, EnumDecl *Pattern) {
Enum->startDefinition();

// Update the location to refer to the definition.
Enum->setLocation(Pattern->getLocation());

SmallVector<Decl*, 4> Enumerators;

EnumConstantDecl *LastEnumConst = nullptr;
for (auto *EC : Pattern->enumerators()) {
  // The specified value for the enumerator.
  ExprResult Value((Expr *)nullptr);
  if (Expr *UninstValue = EC->getInitExpr()) {
    // The enumerator's value expression is a constant expression.
    EnterExpressionEvaluationContext Unevaluated(
        SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

    Value = SemaRef.SubstExpr(UninstValue, TemplateArgs);
  }

  // Drop the initial value and continue.
  bool isInvalid = false;
  if (Value.isInvalid()) {
    Value = nullptr;
    isInvalid = true;
  }

  EnumConstantDecl *EnumConst
    = SemaRef.CheckEnumConstant(Enum, LastEnumConst,
                                EC->getLocation(), EC->getIdentifier(),
                                Value.get());

  if (isInvalid) {
    if (EnumConst)
      EnumConst->setInvalidDecl();
    Enum->setInvalidDecl();
  }

  if (EnumConst) {
    SemaRef.InstantiateAttrs(TemplateArgs, EC, EnumConst);

    EnumConst->setAccess(Enum->getAccess());
    Enum->addDecl(EnumConst);
    Enumerators.push_back(EnumConst);
    LastEnumConst = EnumConst;

    if (Pattern->getDeclContext()->isFunctionOrMethod() &&
        !Enum->isScoped()) {
      // If the enumeration is within a function or method, record the enum
      // constant as a local.
      SemaRef.CurrentInstantiationScope->InstantiatedLocal(EC, EnumConst);
    }
  }
}

SemaRef.ActOnEnumBody(Enum->getLocation(), Enum->getBraceRange(), Enum,
                      Enumerators,
                      nullptr, nullptr);
1122}

1124Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) {
llvm_unreachable("EnumConstantDecls can only occur within EnumDecls.")::llvm::llvm_unreachable_internal("EnumConstantDecls can only occur within EnumDecls."
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1125);
1126}

1128Decl *
1129TemplateDeclInstantiator::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
llvm_unreachable("BuiltinTemplateDecls cannot be instantiated.")::llvm::llvm_unreachable_internal("BuiltinTemplateDecls cannot be instantiated."
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1130);
1131}

1133Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None);

// Create a local instantiation scope for this class template, which
// will contain the instantiations of the template parameters.
LocalInstantiationScope Scope(SemaRef);
TemplateParameterList *TempParams = D->getTemplateParameters();
TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
if (!InstParams)
  return nullptr;

CXXRecordDecl *Pattern = D->getTemplatedDecl();

// Instantiate the qualifier.  We have to do this first in case
// we're a friend declaration, because if we are then we need to put
// the new declaration in the appropriate context.
NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
if (QualifierLoc) {
  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
                                                     TemplateArgs);
  if (!QualifierLoc)
    return nullptr;
}

CXXRecordDecl *PrevDecl = nullptr;
ClassTemplateDecl *PrevClassTemplate = nullptr;

if (!isFriend && getPreviousDeclForInstantiation(Pattern)) {
  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
  if (!Found.empty()) {
    PrevClassTemplate = dyn_cast<ClassTemplateDecl>(Found.front());
    if (PrevClassTemplate)
      PrevDecl = PrevClassTemplate->getTemplatedDecl();
  }
}

// If this isn't a friend, then it's a member template, in which
// case we just want to build the instantiation in the
// specialization.  If it is a friend, we want to build it in
// the appropriate context.
DeclContext *DC = Owner;
if (isFriend) {
  if (QualifierLoc) {
    CXXScopeSpec SS;
    SS.Adopt(QualifierLoc);
    DC = SemaRef.computeDeclContext(SS);
    if (!DC) return nullptr;
  } else {
    DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(),
                                         Pattern->getDeclContext(),
                                         TemplateArgs);
  }

  // Look for a previous declaration of the template in the owning
  // context.
  LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(),
                 Sema::LookupOrdinaryName,
                 SemaRef.forRedeclarationInCurContext());
  SemaRef.LookupQualifiedName(R, DC);

  if (R.isSingleResult()) {
    PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>();
    if (PrevClassTemplate)
      PrevDecl = PrevClassTemplate->getTemplatedDecl();
  }

  if (!PrevClassTemplate && QualifierLoc) {
    SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope)
      << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC
      << QualifierLoc.getSourceRange();
    return nullptr;
  }

  bool AdoptedPreviousTemplateParams = false;
  if (PrevClassTemplate) {
    bool Complain = true;

    // HACK: libstdc++ 4.2.1 contains an ill-formed friend class
    // template for struct std::tr1::__detail::_Map_base, where the
    // template parameters of the friend declaration don't match the
    // template parameters of the original declaration. In this one
    // case, we don't complain about the ill-formed friend
    // declaration.
    if (isFriend && Pattern->getIdentifier() &&
        Pattern->getIdentifier()->isStr("_Map_base") &&
        DC->isNamespace() &&
        cast<NamespaceDecl>(DC)->getIdentifier() &&
        cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__detail")) {
      DeclContext *DCParent = DC->getParent();
      if (DCParent->isNamespace() &&
          cast<NamespaceDecl>(DCParent)->getIdentifier() &&
          cast<NamespaceDecl>(DCParent)->getIdentifier()->isStr("tr1")) {
        if (cast<Decl>(DCParent)->isInStdNamespace())
          Complain = false;
      }
    }

    TemplateParameterList *PrevParams
      = PrevClassTemplate->getTemplateParameters();

    // Make sure the parameter lists match.
    if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams,
                                                Complain,
                                                Sema::TPL_TemplateMatch)) {
      if (Complain)
        return nullptr;

      AdoptedPreviousTemplateParams = true;
      InstParams = PrevParams;
    }

    // Do some additional validation, then merge default arguments
    // from the existing declarations.
    if (!AdoptedPreviousTemplateParams &&
        SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
                                           Sema::TPC_ClassTemplate))
      return nullptr;
  }
}

CXXRecordDecl *RecordInst
  = CXXRecordDecl::Create(SemaRef.Context, Pattern->getTagKind(), DC,
                          Pattern->getLocStart(), Pattern->getLocation(),
                          Pattern->getIdentifier(), PrevDecl,
                          /*DelayTypeCreation=*/true);

if (QualifierLoc)
  RecordInst->setQualifierInfo(QualifierLoc);

ClassTemplateDecl *Inst
  = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
                              D->getIdentifier(), InstParams, RecordInst);
assert(!(isFriend && Owner->isDependentContext()))(static_cast <bool> (!(isFriend && Owner->isDependentContext
())) ? void (0) : __assert_fail ("!(isFriend && Owner->isDependentContext())"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1265, __extension__ __PRETTY_FUNCTION__));
Inst->setPreviousDecl(PrevClassTemplate);

RecordInst->setDescribedClassTemplate(Inst);

if (isFriend) {
  if (PrevClassTemplate)
    Inst->setAccess(PrevClassTemplate->getAccess());
  else
    Inst->setAccess(D->getAccess());

  Inst->setObjectOfFriendDecl();
  // TODO: do we want to track the instantiation progeny of this
  // friend target decl?
} else {
  Inst->setAccess(D->getAccess());
  if (!PrevClassTemplate)
    Inst->setInstantiatedFromMemberTemplate(D);
}

// Trigger creation of the type for the instantiation.
SemaRef.Context.getInjectedClassNameType(RecordInst,
                                  Inst->getInjectedClassNameSpecialization());

// Finish handling of friends.
if (isFriend) {
  DC->makeDeclVisibleInContext(Inst);
  Inst->setLexicalDeclContext(Owner);
  RecordInst->setLexicalDeclContext(Owner);
  return Inst;
}

if (D->isOutOfLine()) {
  Inst->setLexicalDeclContext(D->getLexicalDeclContext());
  RecordInst->setLexicalDeclContext(D->getLexicalDeclContext());
}

Owner->addDecl(Inst);

if (!PrevClassTemplate) {
  // Queue up any out-of-line partial specializations of this member
  // class template; the client will force their instantiation once
  // the enclosing class has been instantiated.
  SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
  D->getPartialSpecializations(PartialSpecs);
  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
    if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
      OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
}

return Inst;
1316}

1318Decl *
1319TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
                                 ClassTemplatePartialSpecializationDecl *D) {
ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();

// Lookup the already-instantiated declaration in the instantiation
// of the class template and return that.
DeclContext::lookup_result Found
  = Owner->lookup(ClassTemplate->getDeclName());
if (Found.empty())
1
Assuming the condition is false→
2
←
Taking false branch→
  return nullptr;

ClassTemplateDecl *InstClassTemplate
  = dyn_cast<ClassTemplateDecl>(Found.front());
if (!InstClassTemplate)
3
←
Assuming 'InstClassTemplate' is non-null→
4
←
Taking false branch→
  return nullptr;

if (ClassTemplatePartialSpecializationDecl *Result
5
←
Assuming 'Result' is null→
6
←
Taking false branch→
      = InstClassTemplate->findPartialSpecInstantiatedFromMember(D))
  return Result;

return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D);
7
←
Calling 'TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization'→
1340}

1342Decl *TemplateDeclInstantiator::VisitVarTemplateDecl(VarTemplateDecl *D) {
assert(D->getTemplatedDecl()->isStaticDataMember() &&(static_cast <bool> (D->getTemplatedDecl()->isStaticDataMember
() && "Only static data member templates are allowed."
) ? void (0) : __assert_fail ("D->getTemplatedDecl()->isStaticDataMember() && \"Only static data member templates are allowed.\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1344, __extension__ __PRETTY_FUNCTION__))
       "Only static data member templates are allowed.")(static_cast <bool> (D->getTemplatedDecl()->isStaticDataMember
() && "Only static data member templates are allowed."
) ? void (0) : __assert_fail ("D->getTemplatedDecl()->isStaticDataMember() && \"Only static data member templates are allowed.\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1344, __extension__ __PRETTY_FUNCTION__));

// Create a local instantiation scope for this variable template, which
// will contain the instantiations of the template parameters.
LocalInstantiationScope Scope(SemaRef);
TemplateParameterList *TempParams = D->getTemplateParameters();
TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
if (!InstParams)
  return nullptr;

VarDecl *Pattern = D->getTemplatedDecl();
VarTemplateDecl *PrevVarTemplate = nullptr;

if (getPreviousDeclForInstantiation(Pattern)) {
  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
  if (!Found.empty())
    PrevVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
}

VarDecl *VarInst =
    cast_or_null<VarDecl>(VisitVarDecl(Pattern,
                                       /*InstantiatingVarTemplate=*/true));
if (!VarInst) return nullptr;

DeclContext *DC = Owner;

VarTemplateDecl *Inst = VarTemplateDecl::Create(
    SemaRef.Context, DC, D->getLocation(), D->getIdentifier(), InstParams,
    VarInst);
VarInst->setDescribedVarTemplate(Inst);
Inst->setPreviousDecl(PrevVarTemplate);

Inst->setAccess(D->getAccess());
if (!PrevVarTemplate)
  Inst->setInstantiatedFromMemberTemplate(D);

if (D->isOutOfLine()) {
  Inst->setLexicalDeclContext(D->getLexicalDeclContext());
  VarInst->setLexicalDeclContext(D->getLexicalDeclContext());
}

Owner->addDecl(Inst);

if (!PrevVarTemplate) {
  // Queue up any out-of-line partial specializations of this member
  // variable template; the client will force their instantiation once
  // the enclosing class has been instantiated.
  SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
  D->getPartialSpecializations(PartialSpecs);
  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
    if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
      OutOfLineVarPartialSpecs.push_back(
          std::make_pair(Inst, PartialSpecs[I]));
}

return Inst;
1400}

1402Decl *TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl(
  VarTemplatePartialSpecializationDecl *D) {
assert(D->isStaticDataMember() &&(static_cast <bool> (D->isStaticDataMember() &&
 "Only static data member templates are allowed.") ? void (0)
 : __assert_fail ("D->isStaticDataMember() && \"Only static data member templates are allowed.\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1405, __extension__ __PRETTY_FUNCTION__))
       "Only static data member templates are allowed.")(static_cast <bool> (D->isStaticDataMember() &&
 "Only static data member templates are allowed.") ? void (0)
 : __assert_fail ("D->isStaticDataMember() && \"Only static data member templates are allowed.\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1405, __extension__ __PRETTY_FUNCTION__));

VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();

// Lookup the already-instantiated declaration and return that.
DeclContext::lookup_result Found = Owner->lookup(VarTemplate->getDeclName());
assert(!Found.empty() && "Instantiation found nothing?")(static_cast <bool> (!Found.empty() && "Instantiation found nothing?"
) ? void (0) : __assert_fail ("!Found.empty() && \"Instantiation found nothing?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1411, __extension__ __PRETTY_FUNCTION__));

VarTemplateDecl *InstVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
assert(InstVarTemplate && "Instantiation did not find a variable template?")(static_cast <bool> (InstVarTemplate && "Instantiation did not find a variable template?"
) ? void (0) : __assert_fail ("InstVarTemplate && \"Instantiation did not find a variable template?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1414, __extension__ __PRETTY_FUNCTION__));

if (VarTemplatePartialSpecializationDecl *Result =
        InstVarTemplate->findPartialSpecInstantiatedFromMember(D))
  return Result;

return InstantiateVarTemplatePartialSpecialization(InstVarTemplate, D);
1421}

1423Decl *
1424TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
// Create a local instantiation scope for this function template, which
// will contain the instantiations of the template parameters and then get
// merged with the local instantiation scope for the function template
// itself.
LocalInstantiationScope Scope(SemaRef);

TemplateParameterList *TempParams = D->getTemplateParameters();
TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
if (!InstParams)
  return nullptr;

FunctionDecl *Instantiated = nullptr;
if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl()))
  Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod,
                                                               InstParams));
else
  Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl(
                                                        D->getTemplatedDecl(),
                                                              InstParams));

if (!Instantiated)
  return nullptr;

// Link the instantiated function template declaration to the function
// template from which it was instantiated.
FunctionTemplateDecl *InstTemplate
  = Instantiated->getDescribedFunctionTemplate();
InstTemplate->setAccess(D->getAccess());
assert(InstTemplate &&(static_cast <bool> (InstTemplate && "VisitFunctionDecl/CXXMethodDecl didn't create a template!"
) ? void (0) : __assert_fail ("InstTemplate && \"VisitFunctionDecl/CXXMethodDecl didn't create a template!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1454, __extension__ __PRETTY_FUNCTION__))
       "VisitFunctionDecl/CXXMethodDecl didn't create a template!")(static_cast <bool> (InstTemplate && "VisitFunctionDecl/CXXMethodDecl didn't create a template!"
) ? void (0) : __assert_fail ("InstTemplate && \"VisitFunctionDecl/CXXMethodDecl didn't create a template!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1454, __extension__ __PRETTY_FUNCTION__));

bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None);

// Link the instantiation back to the pattern *unless* this is a
// non-definition friend declaration.
if (!InstTemplate->getInstantiatedFromMemberTemplate() &&
    !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition()))
  InstTemplate->setInstantiatedFromMemberTemplate(D);

// Make declarations visible in the appropriate context.
if (!isFriend) {
  Owner->addDecl(InstTemplate);
} else if (InstTemplate->getDeclContext()->isRecord() &&
           !getPreviousDeclForInstantiation(D)) {
  SemaRef.CheckFriendAccess(InstTemplate);
}

return InstTemplate;
1473}

1475Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) {
CXXRecordDecl *PrevDecl = nullptr;
if (D->isInjectedClassName())
  PrevDecl = cast<CXXRecordDecl>(Owner);
else if (CXXRecordDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
  NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
                                                 PatternPrev,
                                                 TemplateArgs);
  if (!Prev) return nullptr;
  PrevDecl = cast<CXXRecordDecl>(Prev);
}

CXXRecordDecl *Record
  = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner,
                          D->getLocStart(), D->getLocation(),
                          D->getIdentifier(), PrevDecl);

// Substitute the nested name specifier, if any.
if (SubstQualifier(D, Record))
  return nullptr;

Record->setImplicit(D->isImplicit());
// FIXME: Check against AS_none is an ugly hack to work around the issue that
// the tag decls introduced by friend class declarations don't have an access
// specifier. Remove once this area of the code gets sorted out.
if (D->getAccess() != AS_none)
  Record->setAccess(D->getAccess());
if (!D->isInjectedClassName())
  Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);

// If the original function was part of a friend declaration,
// inherit its namespace state.
if (D->getFriendObjectKind())
  Record->setObjectOfFriendDecl();

// Make sure that anonymous structs and unions are recorded.
if (D->isAnonymousStructOrUnion())
  Record->setAnonymousStructOrUnion(true);

if (D->isLocalClass())
  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record);

// Forward the mangling number from the template to the instantiated decl.
SemaRef.Context.setManglingNumber(Record,
                                  SemaRef.Context.getManglingNumber(D));

// See if the old tag was defined along with a declarator.
// If it did, mark the new tag as being associated with that declarator.
if (DeclaratorDecl *DD = SemaRef.Context.getDeclaratorForUnnamedTagDecl(D))
  SemaRef.Context.addDeclaratorForUnnamedTagDecl(Record, DD);

// See if the old tag was defined along with a typedef.
// If it did, mark the new tag as being associated with that typedef.
if (TypedefNameDecl *TND = SemaRef.Context.getTypedefNameForUnnamedTagDecl(D))
  SemaRef.Context.addTypedefNameForUnnamedTagDecl(Record, TND);

Owner->addDecl(Record);

// DR1484 clarifies that the members of a local class are instantiated as part
// of the instantiation of their enclosing entity.
if (D->isCompleteDefinition() && D->isLocalClass()) {
  Sema::LocalEagerInstantiationScope LocalInstantiations(SemaRef);

  SemaRef.InstantiateClass(D->getLocation(), Record, D, TemplateArgs,
                           TSK_ImplicitInstantiation,
                           /*Complain=*/true);

  // For nested local classes, we will instantiate the members when we
  // reach the end of the outermost (non-nested) local class.
  if (!D->isCXXClassMember())
    SemaRef.InstantiateClassMembers(D->getLocation(), Record, TemplateArgs,
                                    TSK_ImplicitInstantiation);

  // This class may have local implicit instantiations that need to be
  // performed within this scope.
  LocalInstantiations.perform();
}

SemaRef.DiagnoseUnusedNestedTypedefs(Record);

return Record;
1556}

1558/// \brief Adjust the given function type for an instantiation of the
1559/// given declaration, to cope with modifications to the function's type that
1560/// aren't reflected in the type-source information.
1561///
1562/// \param D The declaration we're instantiating.
1563/// \param TInfo The already-instantiated type.
1564static QualType adjustFunctionTypeForInstantiation(ASTContext &Context,
                                                 FunctionDecl *D,
                                                 TypeSourceInfo *TInfo) {
const FunctionProtoType *OrigFunc
  = D->getType()->castAs<FunctionProtoType>();
const FunctionProtoType *NewFunc
  = TInfo->getType()->castAs<FunctionProtoType>();
if (OrigFunc->getExtInfo() == NewFunc->getExtInfo())
  return TInfo->getType();

FunctionProtoType::ExtProtoInfo NewEPI = NewFunc->getExtProtoInfo();
NewEPI.ExtInfo = OrigFunc->getExtInfo();
return Context.getFunctionType(NewFunc->getReturnType(),
                               NewFunc->getParamTypes(), NewEPI);
1578}

1580/// Normal class members are of more specific types and therefore
1581/// don't make it here.  This function serves three purposes:
1582///   1) instantiating function templates
1583///   2) substituting friend declarations
1584///   3) substituting deduction guide declarations for nested class templates
1585Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D,
                                     TemplateParameterList *TemplateParams) {
// Check whether there is already a function template specialization for
// this declaration.
FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
if (FunctionTemplate && !TemplateParams) {
  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();

  void *InsertPos = nullptr;
  FunctionDecl *SpecFunc
    = FunctionTemplate->findSpecialization(Innermost, InsertPos);

  // If we already have a function template specialization, return it.
  if (SpecFunc)
    return SpecFunc;
}

bool isFriend;
if (FunctionTemplate)
  isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
else
  isFriend = (D->getFriendObjectKind() != Decl::FOK_None);

bool MergeWithParentScope = (TemplateParams != nullptr) ||
  Owner->isFunctionOrMethod() ||
  !(isa<Decl>(Owner) &&
    cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);

SmallVector<ParmVarDecl *, 4> Params;
TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
if (!TInfo)
  return nullptr;
QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);

NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
if (QualifierLoc) {
  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
                                                     TemplateArgs);
  if (!QualifierLoc)
    return nullptr;
}

// If we're instantiating a local function declaration, put the result
// in the enclosing namespace; otherwise we need to find the instantiated
// context.
DeclContext *DC;
if (D->isLocalExternDecl()) {
  DC = Owner;
  SemaRef.adjustContextForLocalExternDecl(DC);
} else if (isFriend && QualifierLoc) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);
  DC = SemaRef.computeDeclContext(SS);
  if (!DC) return nullptr;
} else {
  DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
                                       TemplateArgs);
}

DeclarationNameInfo NameInfo
  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);

FunctionDecl *Function;
if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
  Function = CXXDeductionGuideDecl::Create(
    SemaRef.Context, DC, D->getInnerLocStart(), DGuide->isExplicit(),
    NameInfo, T, TInfo, D->getSourceRange().getEnd());
  if (DGuide->isCopyDeductionCandidate())
    cast<CXXDeductionGuideDecl>(Function)->setIsCopyDeductionCandidate();
} else {
  Function = FunctionDecl::Create(
      SemaRef.Context, DC, D->getInnerLocStart(), NameInfo, T, TInfo,
      D->getCanonicalDecl()->getStorageClass(), D->isInlineSpecified(),
      D->hasWrittenPrototype(), D->isConstexpr());
  Function->setRangeEnd(D->getSourceRange().getEnd());
}

if (D->isInlined())
  Function->setImplicitlyInline();

if (QualifierLoc)
  Function->setQualifierInfo(QualifierLoc);

if (D->isLocalExternDecl())
  Function->setLocalExternDecl();

DeclContext *LexicalDC = Owner;
if (!isFriend && D->isOutOfLine() && !D->isLocalExternDecl()) {
  assert(D->getDeclContext()->isFileContext())(static_cast <bool> (D->getDeclContext()->isFileContext
()) ? void (0) : __assert_fail ("D->getDeclContext()->isFileContext()"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1674, __extension__ __PRETTY_FUNCTION__));
  LexicalDC = D->getDeclContext();
}

Function->setLexicalDeclContext(LexicalDC);

// Attach the parameters
for (unsigned P = 0; P < Params.size(); ++P)
  if (Params[P])
    Params[P]->setOwningFunction(Function);
Function->setParams(Params);

if (TemplateParams) {
  // Our resulting instantiation is actually a function template, since we
  // are substituting only the outer template parameters. For example, given
  //
  //   template<typename T>
  //   struct X {
  //     template<typename U> friend void f(T, U);
  //   };
  //
  //   X<int> x;
  //
  // We are instantiating the friend function template "f" within X<int>,
  // which means substituting int for T, but leaving "f" as a friend function
  // template.
  // Build the function template itself.
  FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC,
                                                  Function->getLocation(),
                                                  Function->getDeclName(),
                                                  TemplateParams, Function);
  Function->setDescribedFunctionTemplate(FunctionTemplate);

  FunctionTemplate->setLexicalDeclContext(LexicalDC);

  if (isFriend && D->isThisDeclarationADefinition()) {
    FunctionTemplate->setInstantiatedFromMemberTemplate(
                                         D->getDescribedFunctionTemplate());
  }
} else if (FunctionTemplate) {
  // Record this function template specialization.
  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
  Function->setFunctionTemplateSpecialization(FunctionTemplate,
                          TemplateArgumentList::CreateCopy(SemaRef.Context,
                                                           Innermost),
                                              /*InsertPos=*/nullptr);
} else if (isFriend && D->isThisDeclarationADefinition()) {
  // Do not connect the friend to the template unless it's actually a
  // definition. We don't want non-template functions to be marked as being
  // template instantiations.
  Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
}

if (InitFunctionInstantiation(Function, D))
  Function->setInvalidDecl();

bool isExplicitSpecialization = false;

LookupResult Previous(
    SemaRef, Function->getDeclName(), SourceLocation(),
    D->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage
                           : Sema::LookupOrdinaryName,
    D->isLocalExternDecl() ? Sema::ForExternalRedeclaration
                           : SemaRef.forRedeclarationInCurContext());

if (DependentFunctionTemplateSpecializationInfo *Info
      = D->getDependentSpecializationInfo()) {
  assert(isFriend && "non-friend has dependent specialization info?")(static_cast <bool> (isFriend && "non-friend has dependent specialization info?"
) ? void (0) : __assert_fail ("isFriend && \"non-friend has dependent specialization info?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1741, __extension__ __PRETTY_FUNCTION__));

  // This needs to be set now for future sanity.
  Function->setObjectOfFriendDecl();

  // Instantiate the explicit template arguments.
  TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
                                        Info->getRAngleLoc());
  if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
                    ExplicitArgs, TemplateArgs))
    return nullptr;

  // Map the candidate templates to their instantiations.
  for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
    Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
                                              Info->getTemplate(I),
                                              TemplateArgs);
    if (!Temp) return nullptr;

    Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
  }

  if (SemaRef.CheckFunctionTemplateSpecialization(Function,
                                                  &ExplicitArgs,
                                                  Previous))
    Function->setInvalidDecl();

  isExplicitSpecialization = true;

} else if (TemplateParams || !FunctionTemplate) {
  // Look only into the namespace where the friend would be declared to
  // find a previous declaration. This is the innermost enclosing namespace,
  // as described in ActOnFriendFunctionDecl.
  SemaRef.LookupQualifiedName(Previous, DC);

  // In C++, the previous declaration we find might be a tag type
  // (class or enum). In this case, the new declaration will hide the
  // tag type. Note that this does does not apply if we're declaring a
  // typedef (C++ [dcl.typedef]p4).
  if (Previous.isSingleTagDecl())
    Previous.clear();
}

if (isFriend)
  Function->setObjectOfFriendDecl();

SemaRef.CheckFunctionDeclaration(/*Scope*/ nullptr, Function, Previous,
                                 isExplicitSpecialization);

NamedDecl *PrincipalDecl = (TemplateParams
                            ? cast<NamedDecl>(FunctionTemplate)
                            : Function);

// If the original function was part of a friend declaration,
// inherit its namespace state and add it to the owner.
if (isFriend) {
  PrincipalDecl->setObjectOfFriendDecl();
  DC->makeDeclVisibleInContext(PrincipalDecl);

  bool QueuedInstantiation = false;

  // C++11 [temp.friend]p4 (DR329):
  //   When a function is defined in a friend function declaration in a class
  //   template, the function is instantiated when the function is odr-used.
  //   The same restrictions on multiple declarations and definitions that
  //   apply to non-template function declarations and definitions also apply
  //   to these implicit definitions.
  if (D->isThisDeclarationADefinition()) {
    // Check for a function body.
    const FunctionDecl *Definition = nullptr;
    if (Function->isDefined(Definition) &&
        Definition->getTemplateSpecializationKind() == TSK_Undeclared) {
      SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
          << Function->getDeclName();
      SemaRef.Diag(Definition->getLocation(), diag::note_previous_definition);
    }
    // Check for redefinitions due to other instantiations of this or
    // a similar friend function.
    else for (auto R : Function->redecls()) {
      if (R == Function)
        continue;

      // If some prior declaration of this function has been used, we need
      // to instantiate its definition.
      if (!QueuedInstantiation && R->isUsed(false)) {
        if (MemberSpecializationInfo *MSInfo =
                Function->getMemberSpecializationInfo()) {
          if (MSInfo->getPointOfInstantiation().isInvalid()) {
            SourceLocation Loc = R->getLocation(); // FIXME
            MSInfo->setPointOfInstantiation(Loc);
            SemaRef.PendingLocalImplicitInstantiations.push_back(
                                             std::make_pair(Function, Loc));
            QueuedInstantiation = true;
          }
        }
      }

      // If some prior declaration of this function was a friend with an
      // uninstantiated definition, reject it.
      if (R->getFriendObjectKind()) {
        if (const FunctionDecl *RPattern =
                R->getTemplateInstantiationPattern()) {
          if (RPattern->isDefined(RPattern)) {
            SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
              << Function->getDeclName();
            SemaRef.Diag(R->getLocation(), diag::note_previous_definition);
            break;
          }
        }
      }
    }
  }

  // Check the template parameter list against the previous declaration. The
  // goal here is to pick up default arguments added since the friend was
  // declared; we know the template parameter lists match, since otherwise
  // we would not have picked this template as the previous declaration.
  if (TemplateParams && FunctionTemplate->getPreviousDecl()) {
    SemaRef.CheckTemplateParameterList(
        TemplateParams,
        FunctionTemplate->getPreviousDecl()->getTemplateParameters(),
        Function->isThisDeclarationADefinition()
            ? Sema::TPC_FriendFunctionTemplateDefinition
            : Sema::TPC_FriendFunctionTemplate);
  }
}

if (Function->isLocalExternDecl() && !Function->getPreviousDecl())
  DC->makeDeclVisibleInContext(PrincipalDecl);

if (Function->isOverloadedOperator() && !DC->isRecord() &&
    PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
  PrincipalDecl->setNonMemberOperator();

assert(!D->isDefaulted() && "only methods should be defaulted")(static_cast <bool> (!D->isDefaulted() && "only methods should be defaulted"
) ? void (0) : __assert_fail ("!D->isDefaulted() && \"only methods should be defaulted\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1875, __extension__ __PRETTY_FUNCTION__));
return Function;
1877}

1879Decl *
1880TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D,
                                    TemplateParameterList *TemplateParams,
                                    bool IsClassScopeSpecialization) {
FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
if (FunctionTemplate && !TemplateParams) {
  // We are creating a function template specialization from a function
  // template. Check whether there is already a function template
  // specialization for this particular set of template arguments.
  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();

  void *InsertPos = nullptr;
  FunctionDecl *SpecFunc
    = FunctionTemplate->findSpecialization(Innermost, InsertPos);

  // If we already have a function template specialization, return it.
  if (SpecFunc)
    return SpecFunc;
}

bool isFriend;
if (FunctionTemplate)
  isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
else
  isFriend = (D->getFriendObjectKind() != Decl::FOK_None);

bool MergeWithParentScope = (TemplateParams != nullptr) ||
  !(isa<Decl>(Owner) &&
    cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);

// Instantiate enclosing template arguments for friends.
SmallVector<TemplateParameterList *, 4> TempParamLists;
unsigned NumTempParamLists = 0;
if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) {
  TempParamLists.resize(NumTempParamLists);
  for (unsigned I = 0; I != NumTempParamLists; ++I) {
    TemplateParameterList *TempParams = D->getTemplateParameterList(I);
    TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
    if (!InstParams)
      return nullptr;
    TempParamLists[I] = InstParams;
  }
}

SmallVector<ParmVarDecl *, 4> Params;
TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
if (!TInfo)
  return nullptr;
QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);

NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
if (QualifierLoc) {
  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
                                               TemplateArgs);
  if (!QualifierLoc)
    return nullptr;
}

DeclContext *DC = Owner;
if (isFriend) {
  if (QualifierLoc) {
    CXXScopeSpec SS;
    SS.Adopt(QualifierLoc);
    DC = SemaRef.computeDeclContext(SS);

    if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
      return nullptr;
  } else {
    DC = SemaRef.FindInstantiatedContext(D->getLocation(),
                                         D->getDeclContext(),
                                         TemplateArgs);
  }
  if (!DC) return nullptr;
}

// Build the instantiated method declaration.
CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
CXXMethodDecl *Method = nullptr;

SourceLocation StartLoc = D->getInnerLocStart();
DeclarationNameInfo NameInfo
  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
  Method = CXXConstructorDecl::Create(SemaRef.Context, Record,
                                      StartLoc, NameInfo, T, TInfo,
                                      Constructor->isExplicit(),
                                      Constructor->isInlineSpecified(),
                                      false, Constructor->isConstexpr());
  Method->setRangeEnd(Constructor->getLocEnd());
} else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
  Method = CXXDestructorDecl::Create(SemaRef.Context, Record,
                                     StartLoc, NameInfo, T, TInfo,
                                     Destructor->isInlineSpecified(),
                                     false);
  Method->setRangeEnd(Destructor->getLocEnd());
} else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
  Method = CXXConversionDecl::Create(SemaRef.Context, Record,
                                     StartLoc, NameInfo, T, TInfo,
                                     Conversion->isInlineSpecified(),
                                     Conversion->isExplicit(),
                                     Conversion->isConstexpr(),
                                     Conversion->getLocEnd());
} else {
  StorageClass SC = D->isStatic() ? SC_Static : SC_None;
  Method = CXXMethodDecl::Create(SemaRef.Context, Record,
                                 StartLoc, NameInfo, T, TInfo,
                                 SC, D->isInlineSpecified(),
                                 D->isConstexpr(), D->getLocEnd());
}

if (D->isInlined())
  Method->setImplicitlyInline();

if (QualifierLoc)
  Method->setQualifierInfo(QualifierLoc);

if (TemplateParams) {
  // Our resulting instantiation is actually a function template, since we
  // are substituting only the outer template parameters. For example, given
  //
  //   template<typename T>
  //   struct X {
  //     template<typename U> void f(T, U);
  //   };
  //
  //   X<int> x;
  //
  // We are instantiating the member template "f" within X<int>, which means
  // substituting int for T, but leaving "f" as a member function template.
  // Build the function template itself.
  FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record,
                                                  Method->getLocation(),
                                                  Method->getDeclName(),
                                                  TemplateParams, Method);
  if (isFriend) {
    FunctionTemplate->setLexicalDeclContext(Owner);
    FunctionTemplate->setObjectOfFriendDecl();
  } else if (D->isOutOfLine())
    FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext());
  Method->setDescribedFunctionTemplate(FunctionTemplate);
} else if (FunctionTemplate) {
  // Record this function template specialization.
  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
  Method->setFunctionTemplateSpecialization(FunctionTemplate,
                       TemplateArgumentList::CreateCopy(SemaRef.Context,
                                                        Innermost),
                                            /*InsertPos=*/nullptr);
} else if (!isFriend) {
  // Record that this is an instantiation of a member function.
  Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
}

// If we are instantiating a member function defined
// out-of-line, the instantiation will have the same lexical
// context (which will be a namespace scope) as the template.
if (isFriend) {
  if (NumTempParamLists)
    Method->setTemplateParameterListsInfo(
        SemaRef.Context,
        llvm::makeArrayRef(TempParamLists.data(), NumTempParamLists));

  Method->setLexicalDeclContext(Owner);
  Method->setObjectOfFriendDecl();
} else if (D->isOutOfLine())
  Method->setLexicalDeclContext(D->getLexicalDeclContext());

// Attach the parameters
for (unsigned P = 0; P < Params.size(); ++P)
  Params[P]->setOwningFunction(Method);
Method->setParams(Params);

if (InitMethodInstantiation(Method, D))
  Method->setInvalidDecl();

LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName,
                      Sema::ForExternalRedeclaration);

if (!FunctionTemplate || TemplateParams || isFriend) {
  SemaRef.LookupQualifiedName(Previous, Record);

  // In C++, the previous declaration we find might be a tag type
  // (class or enum). In this case, the new declaration will hide the
  // tag type. Note that this does does not apply if we're declaring a
  // typedef (C++ [dcl.typedef]p4).
  if (Previous.isSingleTagDecl())
    Previous.clear();
}

if (!IsClassScopeSpecialization)
  SemaRef.CheckFunctionDeclaration(nullptr, Method, Previous, false);

if (D->isPure())
  SemaRef.CheckPureMethod(Method, SourceRange());

// Propagate access.  For a non-friend declaration, the access is
// whatever we're propagating from.  For a friend, it should be the
// previous declaration we just found.
if (isFriend && Method->getPreviousDecl())
  Method->setAccess(Method->getPreviousDecl()->getAccess());
else 
  Method->setAccess(D->getAccess());
if (FunctionTemplate)
  FunctionTemplate->setAccess(Method->getAccess());

SemaRef.CheckOverrideControl(Method);

// If a function is defined as defaulted or deleted, mark it as such now.
if (D->isExplicitlyDefaulted())
  SemaRef.SetDeclDefaulted(Method, Method->getLocation());
if (D->isDeletedAsWritten())
  SemaRef.SetDeclDeleted(Method, Method->getLocation());

// If there's a function template, let our caller handle it.
if (FunctionTemplate) {
  // do nothing

// Don't hide a (potentially) valid declaration with an invalid one.
} else if (Method->isInvalidDecl() && !Previous.empty()) {
  // do nothing

// Otherwise, check access to friends and make them visible.
} else if (isFriend) {
  // We only need to re-check access for methods which we didn't
  // manage to match during parsing.
  if (!D->getPreviousDecl())
    SemaRef.CheckFriendAccess(Method);

  Record->makeDeclVisibleInContext(Method);

// Otherwise, add the declaration.  We don't need to do this for
// class-scope specializations because we'll have matched them with
// the appropriate template.
} else if (!IsClassScopeSpecialization) {
  Owner->addDecl(Method);
}

return Method;
2117}

2119Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
return VisitCXXMethodDecl(D);
2121}

2123Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
return VisitCXXMethodDecl(D);
2125}

2127Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
return VisitCXXMethodDecl(D);
2129}

2131Decl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0, None,
                                /*ExpectParameterPack=*/ false);
2134}

2136Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
                                                  TemplateTypeParmDecl *D) {
// TODO: don't always clone when decls are refcounted.
assert(D->getTypeForDecl()->isTemplateTypeParmType())(static_cast <bool> (D->getTypeForDecl()->isTemplateTypeParmType
()) ? void (0) : __assert_fail ("D->getTypeForDecl()->isTemplateTypeParmType()"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2139, __extension__ __PRETTY_FUNCTION__));

TemplateTypeParmDecl *Inst = TemplateTypeParmDecl::Create(
    SemaRef.Context, Owner, D->getLocStart(), D->getLocation(),
    D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), D->getIndex(),
    D->getIdentifier(), D->wasDeclaredWithTypename(), D->isParameterPack());
Inst->setAccess(AS_public);

if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
  TypeSourceInfo *InstantiatedDefaultArg =
      SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs,
                        D->getDefaultArgumentLoc(), D->getDeclName());
  if (InstantiatedDefaultArg)
    Inst->setDefaultArgument(InstantiatedDefaultArg);
}

// Introduce this template parameter's instantiation into the instantiation
// scope.
SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);

return Inst;
2160}

2162Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
                                               NonTypeTemplateParmDecl *D) {
// Substitute into the type of the non-type template parameter.
TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc();
SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten;
SmallVector<QualType, 4> ExpandedParameterPackTypes;
bool IsExpandedParameterPack = false;
TypeSourceInfo *DI;
QualType T;
bool Invalid = false;

if (D->isExpandedParameterPack()) {
  // The non-type template parameter pack is an already-expanded pack
  // expansion of types. Substitute into each of the expanded types.
  ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes());
  ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes());
  for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
    TypeSourceInfo *NewDI =
        SemaRef.SubstType(D->getExpansionTypeSourceInfo(I), TemplateArgs,
                          D->getLocation(), D->getDeclName());
    if (!NewDI)
      return nullptr;

    QualType NewT =
        SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
    if (NewT.isNull())
      return nullptr;

    ExpandedParameterPackTypesAsWritten.push_back(NewDI);
    ExpandedParameterPackTypes.push_back(NewT);
  }

  IsExpandedParameterPack = true;
  DI = D->getTypeSourceInfo();
  T = DI->getType();
} else if (D->isPackExpansion()) {
  // The non-type template parameter pack's type is a pack expansion of types.
  // Determine whether we need to expand this parameter pack into separate
  // types.
  PackExpansionTypeLoc Expansion = TL.castAs<PackExpansionTypeLoc>();
  TypeLoc Pattern = Expansion.getPatternLoc();
  SmallVector<UnexpandedParameterPack, 2> Unexpanded;
  SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);

  // Determine whether the set of unexpanded parameter packs can and should
  // be expanded.
  bool Expand = true;
  bool RetainExpansion = false;
  Optional<unsigned> OrigNumExpansions
    = Expansion.getTypePtr()->getNumExpansions();
  Optional<unsigned> NumExpansions = OrigNumExpansions;
  if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
                                              Pattern.getSourceRange(),
                                              Unexpanded,
                                              TemplateArgs,
                                              Expand, RetainExpansion,
                                              NumExpansions))
    return nullptr;

  if (Expand) {
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
      TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs,
                                                D->getLocation(),
                                                D->getDeclName());
      if (!NewDI)
        return nullptr;

      QualType NewT =
          SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
      if (NewT.isNull())
        return nullptr;

      ExpandedParameterPackTypesAsWritten.push_back(NewDI);
      ExpandedParameterPackTypes.push_back(NewT);
    }

    // Note that we have an expanded parameter pack. The "type" of this
    // expanded parameter pack is the original expansion type, but callers
    // will end up using the expanded parameter pack types for type-checking.
    IsExpandedParameterPack = true;
    DI = D->getTypeSourceInfo();
    T = DI->getType();
  } else {
    // We cannot fully expand the pack expansion now, so substitute into the
    // pattern and create a new pack expansion type.
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
    TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs,
                                                   D->getLocation(),
                                                   D->getDeclName());
    if (!NewPattern)
      return nullptr;

    SemaRef.CheckNonTypeTemplateParameterType(NewPattern, D->getLocation());
    DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(),
                                    NumExpansions);
    if (!DI)
      return nullptr;

    T = DI->getType();
  }
} else {
  // Simple case: substitution into a parameter that is not a parameter pack.
  DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
                         D->getLocation(), D->getDeclName());
  if (!DI)
    return nullptr;

  // Check that this type is acceptable for a non-type template parameter.
  T = SemaRef.CheckNonTypeTemplateParameterType(DI, D->getLocation());
  if (T.isNull()) {
    T = SemaRef.Context.IntTy;
    Invalid = true;
  }
}

NonTypeTemplateParmDecl *Param;
if (IsExpandedParameterPack)
  Param = NonTypeTemplateParmDecl::Create(
      SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
      D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
      D->getPosition(), D->getIdentifier(), T, DI, ExpandedParameterPackTypes,
      ExpandedParameterPackTypesAsWritten);
else
  Param = NonTypeTemplateParmDecl::Create(
      SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
      D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
      D->getPosition(), D->getIdentifier(), T, D->isParameterPack(), DI);

Param->setAccess(AS_public);
if (Invalid)
  Param->setInvalidDecl();

if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
  EnterExpressionEvaluationContext ConstantEvaluated(
      SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
  ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs);
  if (!Value.isInvalid())
    Param->setDefaultArgument(Value.get());
}

// Introduce this template parameter's instantiation into the instantiation
// scope.
SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
return Param;
2307}

2309static void collectUnexpandedParameterPacks(
  Sema &S,
  TemplateParameterList *Params,
  SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
for (const auto &P : *Params) {
  if (P->isTemplateParameterPack())
    continue;
  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
    S.collectUnexpandedParameterPacks(NTTP->getTypeSourceInfo()->getTypeLoc(),
                                      Unexpanded);
  if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
    collectUnexpandedParameterPacks(S, TTP->getTemplateParameters(),
                                    Unexpanded);
}
2323}

2325Decl *
2326TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
                                                TemplateTemplateParmDecl *D) {
// Instantiate the template parameter list of the template template parameter.
TemplateParameterList *TempParams = D->getTemplateParameters();
TemplateParameterList *InstParams;
SmallVector<TemplateParameterList*, 8> ExpandedParams;

bool IsExpandedParameterPack = false;

if (D->isExpandedParameterPack()) {
  // The template template parameter pack is an already-expanded pack
  // expansion of template parameters. Substitute into each of the expanded
  // parameters.
  ExpandedParams.reserve(D->getNumExpansionTemplateParameters());
  for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
       I != N; ++I) {
    LocalInstantiationScope Scope(SemaRef);
    TemplateParameterList *Expansion =
      SubstTemplateParams(D->getExpansionTemplateParameters(I));
    if (!Expansion)
      return nullptr;
    ExpandedParams.push_back(Expansion);
  }

  IsExpandedParameterPack = true;
  InstParams = TempParams;
} else if (D->isPackExpansion()) {
  // The template template parameter pack expands to a pack of template
  // template parameters. Determine whether we need to expand this parameter
  // pack into separate parameters.
  SmallVector<UnexpandedParameterPack, 2> Unexpanded;
  collectUnexpandedParameterPacks(SemaRef, D->getTemplateParameters(),
                                  Unexpanded);

  // Determine whether the set of unexpanded parameter packs can and should
  // be expanded.
  bool Expand = true;
  bool RetainExpansion = false;
  Optional<unsigned> NumExpansions;
  if (SemaRef.CheckParameterPacksForExpansion(D->getLocation(),
                                              TempParams->getSourceRange(),
                                              Unexpanded,
                                              TemplateArgs,
                                              Expand, RetainExpansion,
                                              NumExpansions))
    return nullptr;

  if (Expand) {
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
      LocalInstantiationScope Scope(SemaRef);
      TemplateParameterList *Expansion = SubstTemplateParams(TempParams);
      if (!Expansion)
        return nullptr;
      ExpandedParams.push_back(Expansion);
    }

    // Note that we have an expanded parameter pack. The "type" of this
    // expanded parameter pack is the original expansion type, but callers
    // will end up using the expanded parameter pack types for type-checking.
    IsExpandedParameterPack = true;
    InstParams = TempParams;
  } else {
    // We cannot fully expand the pack expansion now, so just substitute
    // into the pattern.
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);

    LocalInstantiationScope Scope(SemaRef);
    InstParams = SubstTemplateParams(TempParams);
    if (!InstParams)
      return nullptr;
  }
} else {
  // Perform the actual substitution of template parameters within a new,
  // local instantiation scope.
  LocalInstantiationScope Scope(SemaRef);
  InstParams = SubstTemplateParams(TempParams);
  if (!InstParams)
    return nullptr;
}

// Build the template template parameter.
TemplateTemplateParmDecl *Param;
if (IsExpandedParameterPack)
  Param = TemplateTemplateParmDecl::Create(
      SemaRef.Context, Owner, D->getLocation(),
      D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
      D->getPosition(), D->getIdentifier(), InstParams, ExpandedParams);
else
  Param = TemplateTemplateParmDecl::Create(
      SemaRef.Context, Owner, D->getLocation(),
      D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
      D->getPosition(), D->isParameterPack(), D->getIdentifier(), InstParams);
if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
  NestedNameSpecifierLoc QualifierLoc =
      D->getDefaultArgument().getTemplateQualifierLoc();
  QualifierLoc =
      SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs);
  TemplateName TName = SemaRef.SubstTemplateName(
      QualifierLoc, D->getDefaultArgument().getArgument().getAsTemplate(),
      D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
  if (!TName.isNull())
    Param->setDefaultArgument(
        SemaRef.Context,
        TemplateArgumentLoc(TemplateArgument(TName),
                            D->getDefaultArgument().getTemplateQualifierLoc(),
                            D->getDefaultArgument().getTemplateNameLoc()));
}
Param->setAccess(AS_public);

// Introduce this template parameter's instantiation into the instantiation
// scope.
SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);

return Param;
2441}

2443Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
// Using directives are never dependent (and never contain any types or
// expressions), so they require no explicit instantiation work.

UsingDirectiveDecl *Inst
  = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(),
                               D->getNamespaceKeyLocation(),
                               D->getQualifierLoc(),
                               D->getIdentLocation(),
                               D->getNominatedNamespace(),
                               D->getCommonAncestor());

// Add the using directive to its declaration context
// only if this is not a function or method.
if (!Owner->isFunctionOrMethod())
  Owner->addDecl(Inst);

return Inst;
2461}

2463Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {

// The nested name specifier may be dependent, for example
//     template <typename T> struct t {
//       struct s1 { T f1(); };
//       struct s2 : s1 { using s1::f1; };
//     };
//     template struct t<int>;
// Here, in using s1::f1, s1 refers to t<T>::s1;
// we need to substitute for t<int>::s1.
NestedNameSpecifierLoc QualifierLoc
  = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
                                        TemplateArgs);
if (!QualifierLoc)
  return nullptr;

// For an inheriting constructor declaration, the name of the using
// declaration is the name of a constructor in this class, not in the
// base class.
DeclarationNameInfo NameInfo = D->getNameInfo();
if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
  if (auto *RD = dyn_cast<CXXRecordDecl>(SemaRef.CurContext))
    NameInfo.setName(SemaRef.Context.DeclarationNames.getCXXConstructorName(
        SemaRef.Context.getCanonicalType(SemaRef.Context.getRecordType(RD))));

// We only need to do redeclaration lookups if we're in a class
// scope (in fact, it's not really even possible in non-class
// scopes).
bool CheckRedeclaration = Owner->isRecord();

LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName,
                  Sema::ForVisibleRedeclaration);

UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner,
                                     D->getUsingLoc(),
                                     QualifierLoc,
                                     NameInfo,
                                     D->hasTypename());

CXXScopeSpec SS;
SS.Adopt(QualifierLoc);
if (CheckRedeclaration) {
  Prev.setHideTags(false);
  SemaRef.LookupQualifiedName(Prev, Owner);

  // Check for invalid redeclarations.
  if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLoc(),
                                          D->hasTypename(), SS,
                                          D->getLocation(), Prev))
    NewUD->setInvalidDecl();

}

if (!NewUD->isInvalidDecl() &&
    SemaRef.CheckUsingDeclQualifier(D->getUsingLoc(), D->hasTypename(),
                                    SS, NameInfo, D->getLocation()))
  NewUD->setInvalidDecl();

SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
NewUD->setAccess(D->getAccess());
Owner->addDecl(NewUD);

// Don't process the shadow decls for an invalid decl.
if (NewUD->isInvalidDecl())
  return NewUD;

if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
  SemaRef.CheckInheritingConstructorUsingDecl(NewUD);

bool isFunctionScope = Owner->isFunctionOrMethod();

// Process the shadow decls.
for (auto *Shadow : D->shadows()) {
  // FIXME: UsingShadowDecl doesn't preserve its immediate target, so
  // reconstruct it in the case where it matters.
  NamedDecl *OldTarget = Shadow->getTargetDecl();
  if (auto *CUSD = dyn_cast<ConstructorUsingShadowDecl>(Shadow))
    if (auto *BaseShadow = CUSD->getNominatedBaseClassShadowDecl())
      OldTarget = BaseShadow;

  NamedDecl *InstTarget =
      cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
          Shadow->getLocation(), OldTarget, TemplateArgs));
  if (!InstTarget)
    return nullptr;

  UsingShadowDecl *PrevDecl = nullptr;
  if (CheckRedeclaration) {
    if (SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev, PrevDecl))
      continue;
  } else if (UsingShadowDecl *OldPrev =
                 getPreviousDeclForInstantiation(Shadow)) {
    PrevDecl = cast_or_null<UsingShadowDecl>(SemaRef.FindInstantiatedDecl(
        Shadow->getLocation(), OldPrev, TemplateArgs));
  }

  UsingShadowDecl *InstShadow =
      SemaRef.BuildUsingShadowDecl(/*Scope*/nullptr, NewUD, InstTarget,
                                   PrevDecl);
  SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);

  if (isFunctionScope)
    SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow);
}

return NewUD;
2569}

2571Decl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) {
// Ignore these;  we handle them in bulk when processing the UsingDecl.
return nullptr;
2574}

2576Decl *TemplateDeclInstantiator::VisitConstructorUsingShadowDecl(
  ConstructorUsingShadowDecl *D) {
// Ignore these;  we handle them in bulk when processing the UsingDecl.
return nullptr;
2580}

2582template <typename T>
2583Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(
  T *D, bool InstantiatingPackElement) {
// If this is a pack expansion, expand it now.
if (D->isPackExpansion() && !InstantiatingPackElement) {
  SmallVector<UnexpandedParameterPack, 2> Unexpanded;
  SemaRef.collectUnexpandedParameterPacks(D->getQualifierLoc(), Unexpanded);
  SemaRef.collectUnexpandedParameterPacks(D->getNameInfo(), Unexpanded);

  // Determine whether the set of unexpanded parameter packs can and should
  // be expanded.
  bool Expand = true;
  bool RetainExpansion = false;
  Optional<unsigned> NumExpansions;
  if (SemaRef.CheckParameterPacksForExpansion(
        D->getEllipsisLoc(), D->getSourceRange(), Unexpanded, TemplateArgs,
          Expand, RetainExpansion, NumExpansions))
    return nullptr;

  // This declaration cannot appear within a function template signature,
  // so we can't have a partial argument list for a parameter pack.
  assert(!RetainExpansion &&(static_cast <bool> (!RetainExpansion && "should never need to retain an expansion for UsingPackDecl"
) ? void (0) : __assert_fail ("!RetainExpansion && \"should never need to retain an expansion for UsingPackDecl\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2604, __extension__ __PRETTY_FUNCTION__))
         "should never need to retain an expansion for UsingPackDecl")(static_cast <bool> (!RetainExpansion && "should never need to retain an expansion for UsingPackDecl"
) ? void (0) : __assert_fail ("!RetainExpansion && \"should never need to retain an expansion for UsingPackDecl\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2604, __extension__ __PRETTY_FUNCTION__));

  if (!Expand) {
    // We cannot fully expand the pack expansion now, so substitute into the
    // pattern and create a new pack expansion.
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
    return instantiateUnresolvedUsingDecl(D, true);
  }

  // Within a function, we don't have any normal way to check for conflicts
  // between shadow declarations from different using declarations in the
  // same pack expansion, but this is always ill-formed because all expansions
  // must produce (conflicting) enumerators.
  //
  // Sadly we can't just reject this in the template definition because it
  // could be valid if the pack is empty or has exactly one expansion.
  if (D->getDeclContext()->isFunctionOrMethod() && *NumExpansions > 1) {
    SemaRef.Diag(D->getEllipsisLoc(),
                 diag::err_using_decl_redeclaration_expansion);
    return nullptr;
  }

  // Instantiate the slices of this pack and build a UsingPackDecl.
  SmallVector<NamedDecl*, 8> Expansions;
  for (unsigned I = 0; I != *NumExpansions; ++I) {
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
    Decl *Slice = instantiateUnresolvedUsingDecl(D, true);
    if (!Slice)
      return nullptr;
    // Note that we can still get unresolved using declarations here, if we
    // had arguments for all packs but the pattern also contained other
    // template arguments (this only happens during partial substitution, eg
    // into the body of a generic lambda in a function template).
    Expansions.push_back(cast<NamedDecl>(Slice));
  }

  auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
  if (isDeclWithinFunction(D))
    SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
  return NewD;
}

UnresolvedUsingTypenameDecl *TD = dyn_cast<UnresolvedUsingTypenameDecl>(D);
SourceLocation TypenameLoc = TD ? TD->getTypenameLoc() : SourceLocation();

NestedNameSpecifierLoc QualifierLoc
  = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
                                        TemplateArgs);
if (!QualifierLoc)
  return nullptr;

CXXScopeSpec SS;
SS.Adopt(QualifierLoc);

DeclarationNameInfo NameInfo
  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);

// Produce a pack expansion only if we're not instantiating a particular
// slice of a pack expansion.
bool InstantiatingSlice = D->getEllipsisLoc().isValid() &&
                          SemaRef.ArgumentPackSubstitutionIndex != -1;
SourceLocation EllipsisLoc =
    InstantiatingSlice ? SourceLocation() : D->getEllipsisLoc();

NamedDecl *UD = SemaRef.BuildUsingDeclaration(
    /*Scope*/ nullptr, D->getAccess(), D->getUsingLoc(),
    /*HasTypename*/ TD, TypenameLoc, SS, NameInfo, EllipsisLoc, nullptr,
    /*IsInstantiation*/ true);
if (UD)
  SemaRef.Context.setInstantiatedFromUsingDecl(UD, D);

return UD;
2676}

2678Decl *TemplateDeclInstantiator::VisitUnresolvedUsingTypenameDecl(
  UnresolvedUsingTypenameDecl *D) {
return instantiateUnresolvedUsingDecl(D);
2681}

2683Decl *TemplateDeclInstantiator::VisitUnresolvedUsingValueDecl(
  UnresolvedUsingValueDecl *D) {
return instantiateUnresolvedUsingDecl(D);
2686}

2688Decl *TemplateDeclInstantiator::VisitUsingPackDecl(UsingPackDecl *D) {
SmallVector<NamedDecl*, 8> Expansions;
for (auto *UD : D->expansions()) {
  if (auto *NewUD =
          SemaRef.FindInstantiatedDecl(D->getLocation(), UD, TemplateArgs))
    Expansions.push_back(cast<NamedDecl>(NewUD));
  else
    return nullptr;
}

auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
if (isDeclWithinFunction(D))
  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
return NewD;
2702}

2704Decl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl(
                                   ClassScopeFunctionSpecializationDecl *Decl) {
CXXMethodDecl *OldFD = Decl->getSpecialization();
CXXMethodDecl *NewFD =
  cast_or_null<CXXMethodDecl>(VisitCXXMethodDecl(OldFD, nullptr, true));
if (!NewFD)
  return nullptr;

LookupResult Previous(SemaRef, NewFD->getNameInfo(), Sema::LookupOrdinaryName,
                      Sema::ForExternalRedeclaration);

TemplateArgumentListInfo TemplateArgs;
TemplateArgumentListInfo *TemplateArgsPtr = nullptr;
if (Decl->hasExplicitTemplateArgs()) {
  TemplateArgs = Decl->templateArgs();
  TemplateArgsPtr = &TemplateArgs;
}

SemaRef.LookupQualifiedName(Previous, SemaRef.CurContext);
if (SemaRef.CheckFunctionTemplateSpecialization(NewFD, TemplateArgsPtr,
                                                Previous)) {
  NewFD->setInvalidDecl();
  return NewFD;
}

// Associate the specialization with the pattern.
FunctionDecl *Specialization = cast<FunctionDecl>(Previous.getFoundDecl());
assert(Specialization && "Class scope Specialization is null")(static_cast <bool> (Specialization && "Class scope Specialization is null"
) ? void (0) : __assert_fail ("Specialization && \"Class scope Specialization is null\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2731, __extension__ __PRETTY_FUNCTION__));
SemaRef.Context.setClassScopeSpecializationPattern(Specialization, OldFD);

return NewFD;
2735}

2737Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
                                   OMPThreadPrivateDecl *D) {
SmallVector<Expr *, 5> Vars;
for (auto *I : D->varlists()) {
  Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
  assert(isa<DeclRefExpr>(Var) && "threadprivate arg is not a DeclRefExpr")(static_cast <bool> (isa<DeclRefExpr>(Var) &&
 "threadprivate arg is not a DeclRefExpr") ? void (0) : __assert_fail
 ("isa<DeclRefExpr>(Var) && \"threadprivate arg is not a DeclRefExpr\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2742, __extension__ __PRETTY_FUNCTION__));
  Vars.push_back(Var);
}

OMPThreadPrivateDecl *TD =
  SemaRef.CheckOMPThreadPrivateDecl(D->getLocation(), Vars);

TD->setAccess(AS_public);
Owner->addDecl(TD);

return TD;
2753}

2755Decl *TemplateDeclInstantiator::VisitOMPDeclareReductionDecl(
  OMPDeclareReductionDecl *D) {
// Instantiate type and check if it is allowed.
QualType SubstReductionType = SemaRef.ActOnOpenMPDeclareReductionType(
    D->getLocation(),
    ParsedType::make(SemaRef.SubstType(D->getType(), TemplateArgs,
                                       D->getLocation(), DeclarationName())));
if (SubstReductionType.isNull())
  return nullptr;
bool IsCorrect = !SubstReductionType.isNull();
// Create instantiated copy.
std::pair<QualType, SourceLocation> ReductionTypes[] = {
    std::make_pair(SubstReductionType, D->getLocation())};
auto *PrevDeclInScope = D->getPrevDeclInScope();
if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
  PrevDeclInScope = cast<OMPDeclareReductionDecl>(
      SemaRef.CurrentInstantiationScope->findInstantiationOf(PrevDeclInScope)
          ->get<Decl *>());
}
auto DRD = SemaRef.ActOnOpenMPDeclareReductionDirectiveStart(
    /*S=*/nullptr, Owner, D->getDeclName(), ReductionTypes, D->getAccess(),
    PrevDeclInScope);
auto *NewDRD = cast<OMPDeclareReductionDecl>(DRD.get().getSingleDecl());
if (isDeclWithinFunction(NewDRD))
  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewDRD);
Expr *SubstCombiner = nullptr;
Expr *SubstInitializer = nullptr;
// Combiners instantiation sequence.
if (D->getCombiner()) {
  SemaRef.ActOnOpenMPDeclareReductionCombinerStart(
      /*S=*/nullptr, NewDRD);
  const char *Names[] = {"omp_in", "omp_out"};
  for (auto &Name : Names) {
    DeclarationName DN(&SemaRef.Context.Idents.get(Name));
    auto OldLookup = D->lookup(DN);
    auto Lookup = NewDRD->lookup(DN);
    if (!OldLookup.empty() && !Lookup.empty()) {
      assert(Lookup.size() == 1 && OldLookup.size() == 1)(static_cast <bool> (Lookup.size() == 1 && OldLookup
.size() == 1) ? void (0) : __assert_fail ("Lookup.size() == 1 && OldLookup.size() == 1"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2792, __extension__ __PRETTY_FUNCTION__));
      SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldLookup.front(),
                                                           Lookup.front());
    }
  }
  SubstCombiner = SemaRef.SubstExpr(D->getCombiner(), TemplateArgs).get();
  SemaRef.ActOnOpenMPDeclareReductionCombinerEnd(NewDRD, SubstCombiner);
  // Initializers instantiation sequence.
  if (D->getInitializer()) {
    VarDecl *OmpPrivParm =
        SemaRef.ActOnOpenMPDeclareReductionInitializerStart(
            /*S=*/nullptr, NewDRD);
    const char *Names[] = {"omp_orig", "omp_priv"};
    for (auto &Name : Names) {
      DeclarationName DN(&SemaRef.Context.Idents.get(Name));
      auto OldLookup = D->lookup(DN);
      auto Lookup = NewDRD->lookup(DN);
      if (!OldLookup.empty() && !Lookup.empty()) {
        assert(Lookup.size() == 1 && OldLookup.size() == 1)(static_cast <bool> (Lookup.size() == 1 && OldLookup
.size() == 1) ? void (0) : __assert_fail ("Lookup.size() == 1 && OldLookup.size() == 1"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2810, __extension__ __PRETTY_FUNCTION__));
        auto *OldVD = cast<VarDecl>(OldLookup.front());
        auto *NewVD = cast<VarDecl>(Lookup.front());
        SemaRef.InstantiateVariableInitializer(NewVD, OldVD, TemplateArgs);
        SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldVD, NewVD);
      }
    }
    if (D->getInitializerKind() == OMPDeclareReductionDecl::CallInit) {
      SubstInitializer =
          SemaRef.SubstExpr(D->getInitializer(), TemplateArgs).get();
    } else {
      IsCorrect = IsCorrect && OmpPrivParm->hasInit();
    }
    SemaRef.ActOnOpenMPDeclareReductionInitializerEnd(
        NewDRD, SubstInitializer, OmpPrivParm);
  }
  IsCorrect =
      IsCorrect && SubstCombiner &&
      (!D->getInitializer() ||
       (D->getInitializerKind() == OMPDeclareReductionDecl::CallInit &&
        SubstInitializer) ||
       (D->getInitializerKind() != OMPDeclareReductionDecl::CallInit &&
        !SubstInitializer && !SubstInitializer));
} else
  IsCorrect = false;

(void)SemaRef.ActOnOpenMPDeclareReductionDirectiveEnd(/*S=*/nullptr, DRD,
                                                      IsCorrect);

return NewDRD;
2840}

2842Decl *TemplateDeclInstantiator::VisitOMPCapturedExprDecl(
  OMPCapturedExprDecl * /*D*/) {
llvm_unreachable("Should not be met in templates")::llvm::llvm_unreachable_internal("Should not be met in templates"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2844);
2845}

2847Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D) {
return VisitFunctionDecl(D, nullptr);
2849}

2851Decl *
2852TemplateDeclInstantiator::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
return VisitFunctionDecl(D, nullptr);
2854}

2856Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D) {
return VisitCXXMethodDecl(D, nullptr);
2858}

2860Decl *TemplateDeclInstantiator::VisitRecordDecl(RecordDecl *D) {
llvm_unreachable("There are only CXXRecordDecls in C++")::llvm::llvm_unreachable_internal("There are only CXXRecordDecls in C++"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2861);
2862}

2864Decl *
2865TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
  ClassTemplateSpecializationDecl *D) {
// As a MS extension, we permit class-scope explicit specialization
// of member class templates.
ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
assert(ClassTemplate->getDeclContext()->isRecord() &&(static_cast <bool> (ClassTemplate->getDeclContext()
->isRecord() && D->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization && "can only instantiate an explicit specialization "
 "for a member class template") ? void (0) : __assert_fail ("ClassTemplate->getDeclContext()->isRecord() && D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization && \"can only instantiate an explicit specialization \" \"for a member class template\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2873, __extension__ __PRETTY_FUNCTION__))
       D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&(static_cast <bool> (ClassTemplate->getDeclContext()
->isRecord() && D->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization && "can only instantiate an explicit specialization "
 "for a member class template") ? void (0) : __assert_fail ("ClassTemplate->getDeclContext()->isRecord() && D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization && \"can only instantiate an explicit specialization \" \"for a member class template\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2873, __extension__ __PRETTY_FUNCTION__))
       "can only instantiate an explicit specialization "(static_cast <bool> (ClassTemplate->getDeclContext()
->isRecord() && D->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization && "can only instantiate an explicit specialization "
 "for a member class template") ? void (0) : __assert_fail ("ClassTemplate->getDeclContext()->isRecord() && D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization && \"can only instantiate an explicit specialization \" \"for a member class template\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2873, __extension__ __PRETTY_FUNCTION__))
       "for a member class template")(static_cast <bool> (ClassTemplate->getDeclContext()
->isRecord() && D->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization && "can only instantiate an explicit specialization "
 "for a member class template") ? void (0) : __assert_fail ("ClassTemplate->getDeclContext()->isRecord() && D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization && \"can only instantiate an explicit specialization \" \"for a member class template\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2873, __extension__ __PRETTY_FUNCTION__));

// Lookup the already-instantiated declaration in the instantiation
// of the class template. FIXME: Diagnose or assert if this fails?
DeclContext::lookup_result Found
  = Owner->lookup(ClassTemplate->getDeclName());
if (Found.empty())
  return nullptr;
ClassTemplateDecl *InstClassTemplate
  = dyn_cast<ClassTemplateDecl>(Found.front());
if (!InstClassTemplate)
  return nullptr;

// Substitute into the template arguments of the class template explicit
// specialization.
TemplateSpecializationTypeLoc Loc = D->getTypeAsWritten()->getTypeLoc().
                                      castAs<TemplateSpecializationTypeLoc>();
TemplateArgumentListInfo InstTemplateArgs(Loc.getLAngleLoc(),
                                          Loc.getRAngleLoc());
SmallVector<TemplateArgumentLoc, 4> ArgLocs;
for (unsigned I = 0; I != Loc.getNumArgs(); ++I)
  ArgLocs.push_back(Loc.getArgLoc(I));
if (SemaRef.Subst(ArgLocs.data(), ArgLocs.size(),
                  InstTemplateArgs, TemplateArgs))
  return nullptr;

// Check that the template argument list is well-formed for this
// class template.
SmallVector<TemplateArgument, 4> Converted;
if (SemaRef.CheckTemplateArgumentList(InstClassTemplate,
                                      D->getLocation(),
                                      InstTemplateArgs,
                                      false,
                                      Converted))
  return nullptr;

// Figure out where to insert this class template explicit specialization
// in the member template's set of class template explicit specializations.
void *InsertPos = nullptr;
ClassTemplateSpecializationDecl *PrevDecl =
    InstClassTemplate->findSpecialization(Converted, InsertPos);

// Check whether we've already seen a conflicting instantiation of this
// declaration (for instance, if there was a prior implicit instantiation).
bool Ignored;
if (PrevDecl &&
    SemaRef.CheckSpecializationInstantiationRedecl(D->getLocation(),
                                                   D->getSpecializationKind(),
                                                   PrevDecl,
                                                   PrevDecl->getSpecializationKind(),
                                                   PrevDecl->getPointOfInstantiation(),
                                                   Ignored))
  return nullptr;

// If PrevDecl was a definition and D is also a definition, diagnose.
// This happens in cases like:
//
//   template<typename T, typename U>
//   struct Outer {
//     template<typename X> struct Inner;
//     template<> struct Inner<T> {};
//     template<> struct Inner<U> {};
//   };
//
//   Outer<int, int> outer; // error: the explicit specializations of Inner
//                          // have the same signature.
if (PrevDecl && PrevDecl->getDefinition() &&
    D->isThisDeclarationADefinition()) {
  SemaRef.Diag(D->getLocation(), diag::err_redefinition) << PrevDecl;
  SemaRef.Diag(PrevDecl->getDefinition()->getLocation(),
               diag::note_previous_definition);
  return nullptr;
}

// Create the class template partial specialization declaration.
ClassTemplateSpecializationDecl *InstD
  = ClassTemplateSpecializationDecl::Create(SemaRef.Context,
                                            D->getTagKind(),
                                            Owner,
                                            D->getLocStart(),
                                            D->getLocation(),
                                            InstClassTemplate,
                                            Converted,
                                            PrevDecl);

// Add this partial specialization to the set of class template partial
// specializations.
if (!PrevDecl)
  InstClassTemplate->AddSpecialization(InstD, InsertPos);

// Substitute the nested name specifier, if any.
if (SubstQualifier(D, InstD))
  return nullptr;

// Build the canonical type that describes the converted template
// arguments of the class template explicit specialization.
QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
    TemplateName(InstClassTemplate), Converted,
    SemaRef.Context.getRecordType(InstD));

// Build the fully-sugared type for this class template
// specialization as the user wrote in the specialization
// itself. This means that we'll pretty-print the type retrieved
// from the specialization's declaration the way that the user
// actually wrote the specialization, rather than formatting the
// name based on the "canonical" representation used to store the
// template arguments in the specialization.
TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
    TemplateName(InstClassTemplate), D->getLocation(), InstTemplateArgs,
    CanonType);

InstD->setAccess(D->getAccess());
InstD->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
InstD->setSpecializationKind(D->getSpecializationKind());
InstD->setTypeAsWritten(WrittenTy);
InstD->setExternLoc(D->getExternLoc());
InstD->setTemplateKeywordLoc(D->getTemplateKeywordLoc());

Owner->addDecl(InstD);

// Instantiate the members of the class-scope explicit specialization eagerly.
// We don't have support for lazy instantiation of an explicit specialization
// yet, and MSVC eagerly instantiates in this case.
if (D->isThisDeclarationADefinition() &&
    SemaRef.InstantiateClass(D->getLocation(), InstD, D, TemplateArgs,
                             TSK_ImplicitInstantiation,
                             /*Complain=*/true))
  return nullptr;

return InstD;
3003}

3005Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
  VarTemplateSpecializationDecl *D) {

TemplateArgumentListInfo VarTemplateArgsInfo;
VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
assert(VarTemplate &&(static_cast <bool> (VarTemplate && "A template specialization without specialized template?"
) ? void (0) : __assert_fail ("VarTemplate && \"A template specialization without specialized template?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3011, __extension__ __PRETTY_FUNCTION__))
       "A template specialization without specialized template?")(static_cast <bool> (VarTemplate && "A template specialization without specialized template?"
) ? void (0) : __assert_fail ("VarTemplate && \"A template specialization without specialized template?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3011, __extension__ __PRETTY_FUNCTION__));

// Substitute the current template arguments.
const TemplateArgumentListInfo &TemplateArgsInfo = D->getTemplateArgsInfo();
VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo.getLAngleLoc());
VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo.getRAngleLoc());

if (SemaRef.Subst(TemplateArgsInfo.getArgumentArray(),
                  TemplateArgsInfo.size(), VarTemplateArgsInfo, TemplateArgs))
  return nullptr;

// Check that the template argument list is well-formed for this template.
SmallVector<TemplateArgument, 4> Converted;
if (SemaRef.CheckTemplateArgumentList(
        VarTemplate, VarTemplate->getLocStart(),
        const_cast<TemplateArgumentListInfo &>(VarTemplateArgsInfo), false,
        Converted))
  return nullptr;

// Find the variable template specialization declaration that
// corresponds to these arguments.
void *InsertPos = nullptr;
if (VarTemplateSpecializationDecl *VarSpec = VarTemplate->findSpecialization(
        Converted, InsertPos))
  // If we already have a variable template specialization, return it.
  return VarSpec;

return VisitVarTemplateSpecializationDecl(VarTemplate, D, InsertPos,
                                          VarTemplateArgsInfo, Converted);
3040}

3042Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
  VarTemplateDecl *VarTemplate, VarDecl *D, void *InsertPos,
  const TemplateArgumentListInfo &TemplateArgsInfo,
  ArrayRef<TemplateArgument> Converted) {

// Do substitution on the type of the declaration
TypeSourceInfo *DI =
    SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
                      D->getTypeSpecStartLoc(), D->getDeclName());
if (!DI)
  return nullptr;

if (DI->getType()->isFunctionType()) {
  SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
      << D->isStaticDataMember() << DI->getType();
  return nullptr;
}

// Build the instantiated declaration
VarTemplateSpecializationDecl *Var = VarTemplateSpecializationDecl::Create(
    SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
    VarTemplate, DI->getType(), DI, D->getStorageClass(), Converted);
Var->setTemplateArgsInfo(TemplateArgsInfo);
if (InsertPos)
  VarTemplate->AddSpecialization(Var, InsertPos);

// Substitute the nested name specifier, if any.
if (SubstQualifier(D, Var))
  return nullptr;

SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs,
                                   Owner, StartingScope);

return Var;
3076}

3078Decl *TemplateDeclInstantiator::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
llvm_unreachable("@defs is not supported in Objective-C++")::llvm::llvm_unreachable_internal("@defs is not supported in Objective-C++"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3079);
3080}

3082Decl *TemplateDeclInstantiator::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
// FIXME: We need to be able to instantiate FriendTemplateDecls.
unsigned DiagID = SemaRef.getDiagnostics().getCustomDiagID(
                                             DiagnosticsEngine::Error,
                                             "cannot instantiate %0 yet");
SemaRef.Diag(D->getLocation(), DiagID)
  << D->getDeclKindName();

return nullptr;
3091}

3093Decl *TemplateDeclInstantiator::VisitDecl(Decl *D) {
llvm_unreachable("Unexpected decl")::llvm::llvm_unreachable_internal("Unexpected decl", "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3094);
3095}

3097Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
                    const MultiLevelTemplateArgumentList &TemplateArgs) {
TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
if (D->isInvalidDecl())
  return nullptr;

return Instantiator.Visit(D);
3104}

3106/// \brief Instantiates a nested template parameter list in the current
3107/// instantiation context.
3108///
3109/// \param L The parameter list to instantiate
3110///
3111/// \returns NULL if there was an error
3112TemplateParameterList *
3113TemplateDeclInstantiator::SubstTemplateParams(TemplateParameterList *L) {
// Get errors for all the parameters before bailing out.
bool Invalid = false;

unsigned N = L->size();
typedef SmallVector<NamedDecl *, 8> ParamVector;
ParamVector Params;
Params.reserve(N);
for (auto &P : *L) {
  NamedDecl *D = cast_or_null<NamedDecl>(Visit(P));
  Params.push_back(D);
  Invalid = Invalid || !D || D->isInvalidDecl();
}

// Clean up if we had an error.
if (Invalid)
  return nullptr;

// Note: we substitute into associated constraints later
Expr *const UninstantiatedRequiresClause = L->getRequiresClause();

TemplateParameterList *InstL
  = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
                                  L->getLAngleLoc(), Params,
                                  L->getRAngleLoc(),
                                  UninstantiatedRequiresClause);
return InstL;
3140}

3142/// \brief Instantiate the declaration of a class template partial
3143/// specialization.
3144///
3145/// \param ClassTemplate the (instantiated) class template that is partially
3146// specialized by the instantiation of \p PartialSpec.
3147///
3148/// \param PartialSpec the (uninstantiated) class template partial
3149/// specialization that we are instantiating.
3150///
3151/// \returns The instantiated partial specialization, if successful; otherwise,
3152/// NULL to indicate an error.
3153ClassTemplatePartialSpecializationDecl *
3154TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(
                                          ClassTemplateDecl *ClassTemplate,
                        ClassTemplatePartialSpecializationDecl *PartialSpec) {
// Create a local instantiation scope for this class template partial
// specialization, which will contain the instantiations of the template
// parameters.
LocalInstantiationScope Scope(SemaRef);

// Substitute into the template parameters of the class template partial
// specialization.
TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
if (!InstParams)
8
←
Assuming 'InstParams' is non-null→
9
←
Taking false branch→
  return nullptr;

// Substitute into the template arguments of the class template partial
// specialization.
const ASTTemplateArgumentListInfo *TemplArgInfo
  = PartialSpec->getTemplateArgsAsWritten();
TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
                                          TemplArgInfo->RAngleLoc);
if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
10
←
Assuming the condition is false→
11
←
Taking false branch→
                  TemplArgInfo->NumTemplateArgs,
                  InstTemplateArgs, TemplateArgs))
  return nullptr;

// Check that the template argument list is well-formed for this
// class template.
SmallVector<TemplateArgument, 4> Converted;
if (SemaRef.CheckTemplateArgumentList(ClassTemplate,
12
←
Assuming the condition is false→
13
←
Taking false branch→
                                      PartialSpec->getLocation(),
                                      InstTemplateArgs,
                                      false,
                                      Converted))
  return nullptr;

// Check these arguments are valid for a template partial specialization.
if (SemaRef.CheckTemplatePartialSpecializationArgs(
14
←
Assuming the condition is false→
15
←
Taking false branch→
        PartialSpec->getLocation(), ClassTemplate, InstTemplateArgs.size(),
        Converted))
  return nullptr;

// Figure out where to insert this class template partial specialization
// in the member template's set of class template partial specializations.
void *InsertPos = nullptr;
ClassTemplateSpecializationDecl *PrevDecl
  = ClassTemplate->findPartialSpecialization(Converted, InsertPos);

// Build the canonical type that describes the converted template
// arguments of the class template partial specialization.
QualType CanonType
  = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate),
                                                  Converted);

// Build the fully-sugared type for this class template
// specialization as the user wrote in the specialization
// itself. This means that we'll pretty-print the type retrieved
// from the specialization's declaration the way that the user
// actually wrote the specialization, rather than formatting the
// name based on the "canonical" representation used to store the
// template arguments in the specialization.
TypeSourceInfo *WrittenTy
  = SemaRef.Context.getTemplateSpecializationTypeInfo(
                                                  TemplateName(ClassTemplate),
                                                  PartialSpec->getLocation(),
                                                  InstTemplateArgs,
                                                  CanonType);

if (PrevDecl) {
16
←
Assuming 'PrevDecl' is null→
17
←
Taking false branch→
  // We've already seen a partial specialization with the same template
  // parameters and template arguments. This can happen, for example, when
  // substituting the outer template arguments ends up causing two
  // class template partial specializations of a member class template
  // to have identical forms, e.g.,
  //
  //   template<typename T, typename U>
  //   struct Outer {
  //     template<typename X, typename Y> struct Inner;
  //     template<typename Y> struct Inner<T, Y>;
  //     template<typename Y> struct Inner<U, Y>;
  //   };
  //
  //   Outer<int, int> outer; // error: the partial specializations of Inner
  //                          // have the same signature.
  SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared)
    << WrittenTy->getType();
  SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here)
    << SemaRef.Context.getTypeDeclType(PrevDecl);
  return nullptr;
}


// Create the class template partial specialization declaration.
ClassTemplatePartialSpecializationDecl *InstPartialSpec
  = ClassTemplatePartialSpecializationDecl::Create(SemaRef.Context,
                                                   PartialSpec->getTagKind(),
                                                   Owner,
                                                   PartialSpec->getLocStart(),
                                                   PartialSpec->getLocation(),
                                                   InstParams,
                                                   ClassTemplate,
                                                   Converted,
                                                   InstTemplateArgs,
                                                   CanonType,
                                                   nullptr);
// Substitute the nested name specifier, if any.
if (SubstQualifier(PartialSpec, InstPartialSpec))
18
←
Taking false branch→
  return nullptr;

InstPartialSpec->setInstantiatedFromMember(PartialSpec);
InstPartialSpec->setTypeAsWritten(WrittenTy);
19
←
Calling 'ClassTemplateSpecializationDecl::setTypeAsWritten'→

// Check the completed partial specialization.
SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);

// Add this partial specialization to the set of class template partial
// specializations.
ClassTemplate->AddPartialSpecialization(InstPartialSpec,
                                        /*InsertPos=*/nullptr);
return InstPartialSpec;
3274}

3276/// \brief Instantiate the declaration of a variable template partial
3277/// specialization.
3278///
3279/// \param VarTemplate the (instantiated) variable template that is partially
3280/// specialized by the instantiation of \p PartialSpec.
3281///
3282/// \param PartialSpec the (uninstantiated) variable template partial
3283/// specialization that we are instantiating.
3284///
3285/// \returns The instantiated partial specialization, if successful; otherwise,
3286/// NULL to indicate an error.
3287VarTemplatePartialSpecializationDecl *
3288TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(
  VarTemplateDecl *VarTemplate,
  VarTemplatePartialSpecializationDecl *PartialSpec) {
// Create a local instantiation scope for this variable template partial
// specialization, which will contain the instantiations of the template
// parameters.
LocalInstantiationScope Scope(SemaRef);

// Substitute into the template parameters of the variable template partial
// specialization.
TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
if (!InstParams)
  return nullptr;

// Substitute into the template arguments of the variable template partial
// specialization.
const ASTTemplateArgumentListInfo *TemplArgInfo
  = PartialSpec->getTemplateArgsAsWritten();
TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
                                          TemplArgInfo->RAngleLoc);
if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
                  TemplArgInfo->NumTemplateArgs,
                  InstTemplateArgs, TemplateArgs))
  return nullptr;

// Check that the template argument list is well-formed for this
// class template.
SmallVector<TemplateArgument, 4> Converted;
if (SemaRef.CheckTemplateArgumentList(VarTemplate, PartialSpec->getLocation(),
                                      InstTemplateArgs, false, Converted))
  return nullptr;

// Check these arguments are valid for a template partial specialization.
if (SemaRef.CheckTemplatePartialSpecializationArgs(
        PartialSpec->getLocation(), VarTemplate, InstTemplateArgs.size(),
        Converted))
  return nullptr;

// Figure out where to insert this variable template partial specialization
// in the member template's set of variable template partial specializations.
void *InsertPos = nullptr;
VarTemplateSpecializationDecl *PrevDecl =
    VarTemplate->findPartialSpecialization(Converted, InsertPos);

// Build the canonical type that describes the converted template
// arguments of the variable template partial specialization.
QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
    TemplateName(VarTemplate), Converted);

// Build the fully-sugared type for this variable template
// specialization as the user wrote in the specialization
// itself. This means that we'll pretty-print the type retrieved
// from the specialization's declaration the way that the user
// actually wrote the specialization, rather than formatting the
// name based on the "canonical" representation used to store the
// template arguments in the specialization.
TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
    TemplateName(VarTemplate), PartialSpec->getLocation(), InstTemplateArgs,
    CanonType);

if (PrevDecl) {
  // We've already seen a partial specialization with the same template
  // parameters and template arguments. This can happen, for example, when
  // substituting the outer template arguments ends up causing two
  // variable template partial specializations of a member variable template
  // to have identical forms, e.g.,
  //
  //   template<typename T, typename U>
  //   struct Outer {
  //     template<typename X, typename Y> pair<X,Y> p;
  //     template<typename Y> pair<T, Y> p;
  //     template<typename Y> pair<U, Y> p;
  //   };
  //
  //   Outer<int, int> outer; // error: the partial specializations of Inner
  //                          // have the same signature.
  SemaRef.Diag(PartialSpec->getLocation(),
               diag::err_var_partial_spec_redeclared)
      << WrittenTy->getType();
  SemaRef.Diag(PrevDecl->getLocation(),
               diag::note_var_prev_partial_spec_here);
  return nullptr;
}

// Do substitution on the type of the declaration
TypeSourceInfo *DI = SemaRef.SubstType(
    PartialSpec->getTypeSourceInfo(), TemplateArgs,
    PartialSpec->getTypeSpecStartLoc(), PartialSpec->getDeclName());
if (!DI)
  return nullptr;

if (DI->getType()->isFunctionType()) {
  SemaRef.Diag(PartialSpec->getLocation(),
               diag::err_variable_instantiates_to_function)
      << PartialSpec->isStaticDataMember() << DI->getType();
  return nullptr;
}

// Create the variable template partial specialization declaration.
VarTemplatePartialSpecializationDecl *InstPartialSpec =
    VarTemplatePartialSpecializationDecl::Create(
        SemaRef.Context, Owner, PartialSpec->getInnerLocStart(),
        PartialSpec->getLocation(), InstParams, VarTemplate, DI->getType(),
        DI, PartialSpec->getStorageClass(), Converted, InstTemplateArgs);

// Substitute the nested name specifier, if any.
if (SubstQualifier(PartialSpec, InstPartialSpec))
  return nullptr;

InstPartialSpec->setInstantiatedFromMember(PartialSpec);
InstPartialSpec->setTypeAsWritten(WrittenTy);

// Check the completed partial specialization.
SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);

// Add this partial specialization to the set of variable template partial
// specializations. The instantiation of the initializer is not necessary.
VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/nullptr);

SemaRef.BuildVariableInstantiation(InstPartialSpec, PartialSpec, TemplateArgs,
                                   LateAttrs, Owner, StartingScope);

return InstPartialSpec;
3412}

3414TypeSourceInfo*
3415TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D,
                            SmallVectorImpl<ParmVarDecl *> &Params) {
TypeSourceInfo *OldTInfo = D->getTypeSourceInfo();
assert(OldTInfo && "substituting function without type source info")(static_cast <bool> (OldTInfo && "substituting function without type source info"
) ? void (0) : __assert_fail ("OldTInfo && \"substituting function without type source info\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3418, __extension__ __PRETTY_FUNCTION__));
assert(Params.empty() && "parameter vector is non-empty at start")(static_cast <bool> (Params.empty() && "parameter vector is non-empty at start"
) ? void (0) : __assert_fail ("Params.empty() && \"parameter vector is non-empty at start\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3419, __extension__ __PRETTY_FUNCTION__));

CXXRecordDecl *ThisContext = nullptr;
unsigned ThisTypeQuals = 0;
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
  ThisContext = cast<CXXRecordDecl>(Owner);
  ThisTypeQuals = Method->getTypeQualifiers();
}

TypeSourceInfo *NewTInfo
  = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs,
                                  D->getTypeSpecStartLoc(),
                                  D->getDeclName(),
                                  ThisContext, ThisTypeQuals);
if (!NewTInfo)
  return nullptr;

TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
if (FunctionProtoTypeLoc OldProtoLoc = OldTL.getAs<FunctionProtoTypeLoc>()) {
  if (NewTInfo != OldTInfo) {
    // Get parameters from the new type info.
    TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();
    FunctionProtoTypeLoc NewProtoLoc = NewTL.castAs<FunctionProtoTypeLoc>();
    unsigned NewIdx = 0;
    for (unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumParams();
         OldIdx != NumOldParams; ++OldIdx) {
      ParmVarDecl *OldParam = OldProtoLoc.getParam(OldIdx);
      LocalInstantiationScope *Scope = SemaRef.CurrentInstantiationScope;

      Optional<unsigned> NumArgumentsInExpansion;
      if (OldParam->isParameterPack())
        NumArgumentsInExpansion =
            SemaRef.getNumArgumentsInExpansion(OldParam->getType(),
                                               TemplateArgs);
      if (!NumArgumentsInExpansion) {
        // Simple case: normal parameter, or a parameter pack that's
        // instantiated to a (still-dependent) parameter pack.
        ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
        Params.push_back(NewParam);
        Scope->InstantiatedLocal(OldParam, NewParam);
      } else {
        // Parameter pack expansion: make the instantiation an argument pack.
        Scope->MakeInstantiatedLocalArgPack(OldParam);
        for (unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
          ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
          Params.push_back(NewParam);
          Scope->InstantiatedLocalPackArg(OldParam, NewParam);
        }
      }
    }
  } else {
    // The function type itself was not dependent and therefore no
    // substitution occurred. However, we still need to instantiate
    // the function parameters themselves.
    const FunctionProtoType *OldProto =
        cast<FunctionProtoType>(OldProtoLoc.getType());
    for (unsigned i = 0, i_end = OldProtoLoc.getNumParams(); i != i_end;
         ++i) {
      ParmVarDecl *OldParam = OldProtoLoc.getParam(i);
      if (!OldParam) {
        Params.push_back(SemaRef.BuildParmVarDeclForTypedef(
            D, D->getLocation(), OldProto->getParamType(i)));
        continue;
      }

      ParmVarDecl *Parm =
          cast_or_null<ParmVarDecl>(VisitParmVarDecl(OldParam));
      if (!Parm)
        return nullptr;
      Params.push_back(Parm);
    }
  }
} else {
  // If the type of this function, after ignoring parentheses, is not
  // *directly* a function type, then we're instantiating a function that
  // was declared via a typedef or with attributes, e.g.,
  //
  //   typedef int functype(int, int);
  //   functype func;
  //   int __cdecl meth(int, int);
  //
  // In this case, we'll just go instantiate the ParmVarDecls that we
  // synthesized in the method declaration.
  SmallVector<QualType, 4> ParamTypes;
  Sema::ExtParameterInfoBuilder ExtParamInfos;
  if (SemaRef.SubstParmTypes(D->getLocation(), D->parameters(), nullptr,
                             TemplateArgs, ParamTypes, &Params,
                             ExtParamInfos))
    return nullptr;
}

return NewTInfo;
3511}

3513/// Introduce the instantiated function parameters into the local
3514/// instantiation scope, and set the parameter names to those used
3515/// in the template.
3516static bool addInstantiatedParametersToScope(Sema &S, FunctionDecl *Function,
                                           const FunctionDecl *PatternDecl,
                                           LocalInstantiationScope &Scope,
                         const MultiLevelTemplateArgumentList &TemplateArgs) {
unsigned FParamIdx = 0;
for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
  const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
  if (!PatternParam->isParameterPack()) {
    // Simple case: not a parameter pack.
    assert(FParamIdx < Function->getNumParams())(static_cast <bool> (FParamIdx < Function->getNumParams
()) ? void (0) : __assert_fail ("FParamIdx < Function->getNumParams()"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3525, __extension__ __PRETTY_FUNCTION__));
    ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
    FunctionParam->setDeclName(PatternParam->getDeclName());
    // If the parameter's type is not dependent, update it to match the type
    // in the pattern. They can differ in top-level cv-qualifiers, and we want
    // the pattern's type here. If the type is dependent, they can't differ,
    // per core issue 1668. Substitute into the type from the pattern, in case
    // it's instantiation-dependent.
    // FIXME: Updating the type to work around this is at best fragile.
    if (!PatternDecl->getType()->isDependentType()) {
      QualType T = S.SubstType(PatternParam->getType(), TemplateArgs,
                               FunctionParam->getLocation(),
                               FunctionParam->getDeclName());
      if (T.isNull())
        return true;
      FunctionParam->setType(T);
    }

    Scope.InstantiatedLocal(PatternParam, FunctionParam);
    ++FParamIdx;
    continue;
  }

  // Expand the parameter pack.
  Scope.MakeInstantiatedLocalArgPack(PatternParam);
  Optional<unsigned> NumArgumentsInExpansion
    = S.getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
  assert(NumArgumentsInExpansion &&(static_cast <bool> (NumArgumentsInExpansion &&
 "should only be called when all template arguments are known"
) ? void (0) : __assert_fail ("NumArgumentsInExpansion && \"should only be called when all template arguments are known\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3553, __extension__ __PRETTY_FUNCTION__))
         "should only be called when all template arguments are known")(static_cast <bool> (NumArgumentsInExpansion &&
 "should only be called when all template arguments are known"
) ? void (0) : __assert_fail ("NumArgumentsInExpansion && \"should only be called when all template arguments are known\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3553, __extension__ __PRETTY_FUNCTION__));
  QualType PatternType =
      PatternParam->getType()->castAs<PackExpansionType>()->getPattern();
  for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
    ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
    FunctionParam->setDeclName(PatternParam->getDeclName());
    if (!PatternDecl->getType()->isDependentType()) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, Arg);
      QualType T = S.SubstType(PatternType, TemplateArgs,
                               FunctionParam->getLocation(),
                               FunctionParam->getDeclName());
      if (T.isNull())
        return true;
      FunctionParam->setType(T);
    }

    Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
    ++FParamIdx;
  }
}

return false;
3575}

3577void Sema::InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
                                  FunctionDecl *Decl) {
const FunctionProtoType *Proto = Decl->getType()->castAs<FunctionProtoType>();
if (Proto->getExceptionSpecType() != EST_Uninstantiated)
  return;

InstantiatingTemplate Inst(*this, PointOfInstantiation, Decl,
                           InstantiatingTemplate::ExceptionSpecification());
if (Inst.isInvalid()) {
  // We hit the instantiation depth limit. Clear the exception specification
  // so that our callers don't have to cope with EST_Uninstantiated.
  UpdateExceptionSpec(Decl, EST_None);
  return;
}
if (Inst.isAlreadyInstantiating()) {
  // This exception specification indirectly depends on itself. Reject.
  // FIXME: Corresponding rule in the standard?
  Diag(PointOfInstantiation, diag::err_exception_spec_cycle) << Decl;
  UpdateExceptionSpec(Decl, EST_None);
  return;
}

// Enter the scope of this instantiation. We don't use
// PushDeclContext because we don't have a scope.
Sema::ContextRAII savedContext(*this, Decl);
LocalInstantiationScope Scope(*this);

MultiLevelTemplateArgumentList TemplateArgs =
  getTemplateInstantiationArgs(Decl, nullptr, /*RelativeToPrimary*/true);

FunctionDecl *Template = Proto->getExceptionSpecTemplate();
if (addInstantiatedParametersToScope(*this, Decl, Template, Scope,
                                     TemplateArgs)) {
  UpdateExceptionSpec(Decl, EST_None);
  return;
}

SubstExceptionSpec(Decl, Template->getType()->castAs<FunctionProtoType>(),
                   TemplateArgs);
3616}

3618/// \brief Initializes the common fields of an instantiation function
3619/// declaration (New) from the corresponding fields of its template (Tmpl).
3620///
3621/// \returns true if there was an error
3622bool
3623TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New,
                                                  FunctionDecl *Tmpl) {
if (Tmpl->isDeleted())
  New->setDeletedAsWritten();

New->setImplicit(Tmpl->isImplicit());

// Forward the mangling number from the template to the instantiated decl.
SemaRef.Context.setManglingNumber(New,
                                  SemaRef.Context.getManglingNumber(Tmpl));

// If we are performing substituting explicitly-specified template arguments
// or deduced template arguments into a function template and we reach this
// point, we are now past the point where SFINAE applies and have committed
// to keeping the new function template specialization. We therefore
// convert the active template instantiation for the function template
// into a template instantiation for this specific function template
// specialization, which is not a SFINAE context, so that we diagnose any
// further errors in the declaration itself.
typedef Sema::CodeSynthesisContext ActiveInstType;
ActiveInstType &ActiveInst = SemaRef.CodeSynthesisContexts.back();
if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
    ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
  if (FunctionTemplateDecl *FunTmpl
        = dyn_cast<FunctionTemplateDecl>(ActiveInst.Entity)) {
    assert(FunTmpl->getTemplatedDecl() == Tmpl &&(static_cast <bool> (FunTmpl->getTemplatedDecl() == Tmpl
 && "Deduction from the wrong function template?") ? void
 (0) : __assert_fail ("FunTmpl->getTemplatedDecl() == Tmpl && \"Deduction from the wrong function template?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3649, __extension__ __PRETTY_FUNCTION__))
           "Deduction from the wrong function template?")(static_cast <bool> (FunTmpl->getTemplatedDecl() == Tmpl
 && "Deduction from the wrong function template?") ? void
 (0) : __assert_fail ("FunTmpl->getTemplatedDecl() == Tmpl && \"Deduction from the wrong function template?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3649, __extension__ __PRETTY_FUNCTION__));
    (void) FunTmpl;
    atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef, ActiveInst);
    ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
    ActiveInst.Entity = New;
    atTemplateBegin(SemaRef.TemplateInstCallbacks, SemaRef, ActiveInst);
  }
}

const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>();
assert(Proto && "Function template without prototype?")(static_cast <bool> (Proto && "Function template without prototype?"
) ? void (0) : __assert_fail ("Proto && \"Function template without prototype?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3659, __extension__ __PRETTY_FUNCTION__));

if (Proto->hasExceptionSpec() || Proto->getNoReturnAttr()) {
  FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();

  // DR1330: In C++11, defer instantiation of a non-trivial
  // exception specification.
  // DR1484: Local classes and their members are instantiated along with the
  // containing function.
  if (SemaRef.getLangOpts().CPlusPlus11 &&
      EPI.ExceptionSpec.Type != EST_None &&
      EPI.ExceptionSpec.Type != EST_DynamicNone &&
      EPI.ExceptionSpec.Type != EST_BasicNoexcept &&
      !Tmpl->isLexicallyWithinFunctionOrMethod()) {
    FunctionDecl *ExceptionSpecTemplate = Tmpl;
    if (EPI.ExceptionSpec.Type == EST_Uninstantiated)
      ExceptionSpecTemplate = EPI.ExceptionSpec.SourceTemplate;
    ExceptionSpecificationType NewEST = EST_Uninstantiated;
    if (EPI.ExceptionSpec.Type == EST_Unevaluated)
      NewEST = EST_Unevaluated;

    // Mark the function has having an uninstantiated exception specification.
    const FunctionProtoType *NewProto
      = New->getType()->getAs<FunctionProtoType>();
    assert(NewProto && "Template instantiation without function prototype?")(static_cast <bool> (NewProto && "Template instantiation without function prototype?"
) ? void (0) : __assert_fail ("NewProto && \"Template instantiation without function prototype?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3683, __extension__ __PRETTY_FUNCTION__));
    EPI = NewProto->getExtProtoInfo();
    EPI.ExceptionSpec.Type = NewEST;
    EPI.ExceptionSpec.SourceDecl = New;
    EPI.ExceptionSpec.SourceTemplate = ExceptionSpecTemplate;
    New->setType(SemaRef.Context.getFunctionType(
        NewProto->getReturnType(), NewProto->getParamTypes(), EPI));
  } else {
    Sema::ContextRAII SwitchContext(SemaRef, New);
    SemaRef.SubstExceptionSpec(New, Proto, TemplateArgs);
  }
}

// Get the definition. Leaves the variable unchanged if undefined.
const FunctionDecl *Definition = Tmpl;
Tmpl->isDefined(Definition);

SemaRef.InstantiateAttrs(TemplateArgs, Definition, New,
                         LateAttrs, StartingScope);

return false;
3704}

3706/// \brief Initializes common fields of an instantiated method
3707/// declaration (New) from the corresponding fields of its template
3708/// (Tmpl).
3709///
3710/// \returns true if there was an error
3711bool
3712TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New,
                                                CXXMethodDecl *Tmpl) {
if (InitFunctionInstantiation(New, Tmpl))
  return true;

New->setAccess(Tmpl->getAccess());
if (Tmpl->isVirtualAsWritten())
  New->setVirtualAsWritten(true);

// FIXME: New needs a pointer to Tmpl
return false;
3723}

3725/// Instantiate (or find existing instantiation of) a function template with a
3726/// given set of template arguments.
3727///
3728/// Usually this should not be used, and template argument deduction should be
3729/// used in its place.
3730FunctionDecl *
3731Sema::InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,
                                   const TemplateArgumentList *Args,
                                   SourceLocation Loc) {
FunctionDecl *FD = FTD->getTemplatedDecl();

sema::TemplateDeductionInfo Info(Loc);
InstantiatingTemplate Inst(
    *this, Loc, FTD, Args->asArray(),
    CodeSynthesisContext::ExplicitTemplateArgumentSubstitution, Info);
if (Inst.isInvalid())
  return nullptr;

ContextRAII SavedContext(*this, FD);
MultiLevelTemplateArgumentList MArgs(*Args);

return cast_or_null<FunctionDecl>(SubstDecl(FD, FD->getParent(), MArgs));
3747}

3749/// In the MS ABI, we need to instantiate default arguments of dllexported
3750/// default constructors along with the constructor definition. This allows IR
3751/// gen to emit a constructor closure which calls the default constructor with
3752/// its default arguments.
3753static void InstantiateDefaultCtorDefaultArgs(Sema &S,
                                            CXXConstructorDecl *Ctor) {
assert(S.Context.getTargetInfo().getCXXABI().isMicrosoft() &&(static_cast <bool> (S.Context.getTargetInfo().getCXXABI
().isMicrosoft() && Ctor->isDefaultConstructor()) ?
 void (0) : __assert_fail ("S.Context.getTargetInfo().getCXXABI().isMicrosoft() && Ctor->isDefaultConstructor()"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3756, __extension__ __PRETTY_FUNCTION__))
       Ctor->isDefaultConstructor())(static_cast <bool> (S.Context.getTargetInfo().getCXXABI
().isMicrosoft() && Ctor->isDefaultConstructor()) ?
 void (0) : __assert_fail ("S.Context.getTargetInfo().getCXXABI().isMicrosoft() && Ctor->isDefaultConstructor()"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3756, __extension__ __PRETTY_FUNCTION__));
unsigned NumParams = Ctor->getNumParams();
if (NumParams == 0)
  return;
DLLExportAttr *Attr = Ctor->getAttr<DLLExportAttr>();
if (!Attr)
  return;
for (unsigned I = 0; I != NumParams; ++I) {
  (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), Ctor,
                                 Ctor->getParamDecl(I));
  S.DiscardCleanupsInEvaluationContext();
}
3768}

3770/// \brief Instantiate the definition of the given function from its
3771/// template.
3772///
3773/// \param PointOfInstantiation the point at which the instantiation was
3774/// required. Note that this is not precisely a "point of instantiation"
3775/// for the function, but it's close.
3776///
3777/// \param Function the already-instantiated declaration of a
3778/// function template specialization or member function of a class template
3779/// specialization.
3780///
3781/// \param Recursive if true, recursively instantiates any functions that
3782/// are required by this instantiation.
3783///
3784/// \param DefinitionRequired if true, then we are performing an explicit
3785/// instantiation where the body of the function is required. Complain if
3786/// there is no such body.
3787void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
                                       FunctionDecl *Function,
                                       bool Recursive,
                                       bool DefinitionRequired,
                                       bool AtEndOfTU) {
if (Function->isInvalidDecl() || Function->isDefined() ||
    isa<CXXDeductionGuideDecl>(Function))
  return;

// Never instantiate an explicit specialization except if it is a class scope
// explicit specialization.
TemplateSpecializationKind TSK = Function->getTemplateSpecializationKind();
if (TSK == TSK_ExplicitSpecialization &&
    !Function->getClassScopeSpecializationPattern())
  return;

// Find the function body that we'll be substituting.
const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern();
assert(PatternDecl && "instantiating a non-template")(static_cast <bool> (PatternDecl && "instantiating a non-template"
) ? void (0) : __assert_fail ("PatternDecl && \"instantiating a non-template\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3805, __extension__ __PRETTY_FUNCTION__));

const FunctionDecl *PatternDef = PatternDecl->getDefinition();
Stmt *Pattern = nullptr;
if (PatternDef) {
  Pattern = PatternDef->getBody(PatternDef);
  PatternDecl = PatternDef;
  if (PatternDef->willHaveBody())
    PatternDef = nullptr;
}

// FIXME: We need to track the instantiation stack in order to know which
// definitions should be visible within this instantiation.
if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Function,
                              Function->getInstantiatedFromMemberFunction(),
                                   PatternDecl, PatternDef, TSK,
                                   /*Complain*/DefinitionRequired)) {
  if (DefinitionRequired)
    Function->setInvalidDecl();
  else if (TSK == TSK_ExplicitInstantiationDefinition) {
    // Try again at the end of the translation unit (at which point a
    // definition will be required).
    assert(!Recursive)(static_cast <bool> (!Recursive) ? void (0) : __assert_fail
 ("!Recursive", "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3827, __extension__ __PRETTY_FUNCTION__));
    Function->setInstantiationIsPending(true);
    PendingInstantiations.push_back(
      std::make_pair(Function, PointOfInstantiation));
  } else if (TSK == TSK_ImplicitInstantiation) {
    if (AtEndOfTU && !getDiagnostics().hasErrorOccurred() &&
        !getSourceManager().isInSystemHeader(PatternDecl->getLocStart())) {
      Diag(PointOfInstantiation, diag::warn_func_template_missing)
        << Function;
      Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
      if (getLangOpts().CPlusPlus11)
        Diag(PointOfInstantiation, diag::note_inst_declaration_hint)
          << Function;
    }
  }

  return;
}

// Postpone late parsed template instantiations.
if (PatternDecl->isLateTemplateParsed() &&
    !LateTemplateParser) {
  Function->setInstantiationIsPending(true);
  PendingInstantiations.push_back(
    std::make_pair(Function, PointOfInstantiation));
  return;
}

// If we're performing recursive template instantiation, create our own
// queue of pending implicit instantiations that we will instantiate later,
// while we're still within our own instantiation context.
// This has to happen before LateTemplateParser below is called, so that
// it marks vtables used in late parsed templates as used.
GlobalEagerInstantiationScope GlobalInstantiations(*this,
                                                   /*Enabled=*/Recursive);
LocalEagerInstantiationScope LocalInstantiations(*this);

// Call the LateTemplateParser callback if there is a need to late parse
// a templated function definition.
if (!Pattern && PatternDecl->isLateTemplateParsed() &&
    LateTemplateParser) {
  // FIXME: Optimize to allow individual templates to be deserialized.
  if (PatternDecl->isFromASTFile())
    ExternalSource->ReadLateParsedTemplates(LateParsedTemplateMap);

  auto LPTIter = LateParsedTemplateMap.find(PatternDecl);
  assert(LPTIter != LateParsedTemplateMap.end() &&(static_cast <bool> (LPTIter != LateParsedTemplateMap.end
() && "missing LateParsedTemplate") ? void (0) : __assert_fail
 ("LPTIter != LateParsedTemplateMap.end() && \"missing LateParsedTemplate\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3874, __extension__ __PRETTY_FUNCTION__))
         "missing LateParsedTemplate")(static_cast <bool> (LPTIter != LateParsedTemplateMap.end
() && "missing LateParsedTemplate") ? void (0) : __assert_fail
 ("LPTIter != LateParsedTemplateMap.end() && \"missing LateParsedTemplate\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3874, __extension__ __PRETTY_FUNCTION__));
  LateTemplateParser(OpaqueParser, *LPTIter->second);
  Pattern = PatternDecl->getBody(PatternDecl);
}

// Note, we should never try to instantiate a deleted function template.
assert((Pattern || PatternDecl->isDefaulted() ||(static_cast <bool> ((Pattern || PatternDecl->isDefaulted
() || PatternDecl->hasSkippedBody()) && "unexpected kind of function template definition"
) ? void (0) : __assert_fail ("(Pattern || PatternDecl->isDefaulted() || PatternDecl->hasSkippedBody()) && \"unexpected kind of function template definition\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3882, __extension__ __PRETTY_FUNCTION__))
        PatternDecl->hasSkippedBody()) &&(static_cast <bool> ((Pattern || PatternDecl->isDefaulted
() || PatternDecl->hasSkippedBody()) && "unexpected kind of function template definition"
) ? void (0) : __assert_fail ("(Pattern || PatternDecl->isDefaulted() || PatternDecl->hasSkippedBody()) && \"unexpected kind of function template definition\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3882, __extension__ __PRETTY_FUNCTION__))
       "unexpected kind of function template definition")(static_cast <bool> ((Pattern || PatternDecl->isDefaulted
() || PatternDecl->hasSkippedBody()) && "unexpected kind of function template definition"
) ? void (0) : __assert_fail ("(Pattern || PatternDecl->isDefaulted() || PatternDecl->hasSkippedBody()) && \"unexpected kind of function template definition\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3882, __extension__ __PRETTY_FUNCTION__));

// C++1y [temp.explicit]p10:
//   Except for inline functions, declarations with types deduced from their
//   initializer or return value, and class template specializations, other
//   explicit instantiation declarations have the effect of suppressing the
//   implicit instantiation of the entity to which they refer.
if (TSK == TSK_ExplicitInstantiationDeclaration &&
    !PatternDecl->isInlined() &&
    !PatternDecl->getReturnType()->getContainedAutoType())
  return;

if (PatternDecl->isInlined()) {
  // Function, and all later redeclarations of it (from imported modules,
  // for instance), are now implicitly inline.
  for (auto *D = Function->getMostRecentDecl(); /**/;
       D = D->getPreviousDecl()) {
    D->setImplicitlyInline();
    if (D == Function)
      break;
  }
}

InstantiatingTemplate Inst(*this, PointOfInstantiation, Function);
if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
  return;
PrettyDeclStackTraceEntry CrashInfo(*this, Function, SourceLocation(),
                                    "instantiating function definition");

// The instantiation is visible here, even if it was first declared in an
// unimported module.
Function->setVisibleDespiteOwningModule();

// Copy the inner loc start from the pattern.
Function->setInnerLocStart(PatternDecl->getInnerLocStart());

EnterExpressionEvaluationContext EvalContext(
    *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);

// Introduce a new scope where local variable instantiations will be
// recorded, unless we're actually a member function within a local
// class, in which case we need to merge our results with the parent
// scope (of the enclosing function).
bool MergeWithParentScope = false;
if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext()))
  MergeWithParentScope = Rec->isLocalClass();

LocalInstantiationScope Scope(*this, MergeWithParentScope);

if (PatternDecl->isDefaulted())
  SetDeclDefaulted(Function, PatternDecl->getLocation());
else {
  MultiLevelTemplateArgumentList TemplateArgs =
    getTemplateInstantiationArgs(Function, nullptr, false, PatternDecl);

  // Substitute into the qualifier; we can get a substitution failure here
  // through evil use of alias templates.
  // FIXME: Is CurContext correct for this? Should we go to the (instantiation
  // of the) lexical context of the pattern?
  SubstQualifier(*this, PatternDecl, Function, TemplateArgs);

  ActOnStartOfFunctionDef(nullptr, Function);

  // Enter the scope of this instantiation. We don't use
  // PushDeclContext because we don't have a scope.
  Sema::ContextRAII savedContext(*this, Function);

  if (addInstantiatedParametersToScope(*this, Function, PatternDecl, Scope,
                                       TemplateArgs))
    return;

  if (PatternDecl->hasSkippedBody()) {
    ActOnSkippedFunctionBody(Function);
  } else {
    if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Function)) {
      // If this is a constructor, instantiate the member initializers.
      InstantiateMemInitializers(Ctor, cast<CXXConstructorDecl>(PatternDecl),
                                 TemplateArgs);

      // If this is an MS ABI dllexport default constructor, instantiate any
      // default arguments.
      if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
          Ctor->isDefaultConstructor()) {
        InstantiateDefaultCtorDefaultArgs(*this, Ctor);
      }
    }

    // Instantiate the function body.
    StmtResult Body = SubstStmt(Pattern, TemplateArgs);

    if (Body.isInvalid())
      Function->setInvalidDecl();

    // FIXME: finishing the function body while in an expression evaluation
    // context seems wrong. Investigate more.
    ActOnFinishFunctionBody(Function, Body.get(),
                            /*IsInstantiation=*/true);
  }

  PerformDependentDiagnostics(PatternDecl, TemplateArgs);

  if (auto *Listener = getASTMutationListener())
    Listener->FunctionDefinitionInstantiated(Function);

  savedContext.pop();
}

DeclGroupRef DG(Function);
Consumer.HandleTopLevelDecl(DG);

// This class may have local implicit instantiations that need to be
// instantiation within this scope.
LocalInstantiations.perform();
Scope.Exit();
GlobalInstantiations.perform();
3997}

3999VarTemplateSpecializationDecl *Sema::BuildVarTemplateInstantiation(
  VarTemplateDecl *VarTemplate, VarDecl *FromVar,
  const TemplateArgumentList &TemplateArgList,
  const TemplateArgumentListInfo &TemplateArgsInfo,
  SmallVectorImpl<TemplateArgument> &Converted,
  SourceLocation PointOfInstantiation, void *InsertPos,
  LateInstantiatedAttrVec *LateAttrs,
  LocalInstantiationScope *StartingScope) {
if (FromVar->isInvalidDecl())
  return nullptr;

InstantiatingTemplate Inst(*this, PointOfInstantiation, FromVar);
if (Inst.isInvalid())
  return nullptr;

MultiLevelTemplateArgumentList TemplateArgLists;
TemplateArgLists.addOuterTemplateArguments(&TemplateArgList);

// Instantiate the first declaration of the variable template: for a partial
// specialization of a static data member template, the first declaration may
// or may not be the declaration in the class; if it's in the class, we want
// to instantiate a member in the class (a declaration), and if it's outside,
// we want to instantiate a definition.
//
// If we're instantiating an explicitly-specialized member template or member
// partial specialization, don't do this. The member specialization completely
// replaces the original declaration in this case.
bool IsMemberSpec = false;
if (VarTemplatePartialSpecializationDecl *PartialSpec =
        dyn_cast<VarTemplatePartialSpecializationDecl>(FromVar))
  IsMemberSpec = PartialSpec->isMemberSpecialization();
else if (VarTemplateDecl *FromTemplate = FromVar->getDescribedVarTemplate())
  IsMemberSpec = FromTemplate->isMemberSpecialization();
if (!IsMemberSpec)
  FromVar = FromVar->getFirstDecl();

MultiLevelTemplateArgumentList MultiLevelList(TemplateArgList);
TemplateDeclInstantiator Instantiator(*this, FromVar->getDeclContext(),
                                      MultiLevelList);

// TODO: Set LateAttrs and StartingScope ...

return cast_or_null<VarTemplateSpecializationDecl>(
    Instantiator.VisitVarTemplateSpecializationDecl(
        VarTemplate, FromVar, InsertPos, TemplateArgsInfo, Converted));
4044}

4046/// \brief Instantiates a variable template specialization by completing it
4047/// with appropriate type information and initializer.
4048VarTemplateSpecializationDecl *Sema::CompleteVarTemplateSpecializationDecl(
  VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
  const MultiLevelTemplateArgumentList &TemplateArgs) {
assert(PatternDecl->isThisDeclarationADefinition() &&(static_cast <bool> (PatternDecl->isThisDeclarationADefinition
() && "don't have a definition to instantiate from") ?
 void (0) : __assert_fail ("PatternDecl->isThisDeclarationADefinition() && \"don't have a definition to instantiate from\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4052, __extension__ __PRETTY_FUNCTION__))
       "don't have a definition to instantiate from")(static_cast <bool> (PatternDecl->isThisDeclarationADefinition
() && "don't have a definition to instantiate from") ?
 void (0) : __assert_fail ("PatternDecl->isThisDeclarationADefinition() && \"don't have a definition to instantiate from\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4052, __extension__ __PRETTY_FUNCTION__));

// Do substitution on the type of the declaration
TypeSourceInfo *DI =
    SubstType(PatternDecl->getTypeSourceInfo(), TemplateArgs,
              PatternDecl->getTypeSpecStartLoc(), PatternDecl->getDeclName());
if (!DI)
  return nullptr;

// Update the type of this variable template specialization.
VarSpec->setType(DI->getType());

// Convert the declaration into a definition now.
VarSpec->setCompleteDefinition();

// Instantiate the initializer.
InstantiateVariableInitializer(VarSpec, PatternDecl, TemplateArgs);

return VarSpec;
4071}

4073/// BuildVariableInstantiation - Used after a new variable has been created.
4074/// Sets basic variable data and decides whether to postpone the
4075/// variable instantiation.
4076void Sema::BuildVariableInstantiation(
  VarDecl *NewVar, VarDecl *OldVar,
  const MultiLevelTemplateArgumentList &TemplateArgs,
  LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner,
  LocalInstantiationScope *StartingScope,
  bool InstantiatingVarTemplate) {

// If we are instantiating a local extern declaration, the
// instantiation belongs lexically to the containing function.
// If we are instantiating a static data member defined
// out-of-line, the instantiation will have the same lexical
// context (which will be a namespace scope) as the template.
if (OldVar->isLocalExternDecl()) {
  NewVar->setLocalExternDecl();
  NewVar->setLexicalDeclContext(Owner);
} else if (OldVar->isOutOfLine())
  NewVar->setLexicalDeclContext(OldVar->getLexicalDeclContext());
NewVar->setTSCSpec(OldVar->getTSCSpec());
NewVar->setInitStyle(OldVar->getInitStyle());
NewVar->setCXXForRangeDecl(OldVar->isCXXForRangeDecl());
NewVar->setConstexpr(OldVar->isConstexpr());
NewVar->setInitCapture(OldVar->isInitCapture());
NewVar->setPreviousDeclInSameBlockScope(
    OldVar->isPreviousDeclInSameBlockScope());
NewVar->setAccess(OldVar->getAccess());

if (!OldVar->isStaticDataMember()) {
  if (OldVar->isUsed(false))
    NewVar->setIsUsed();
  NewVar->setReferenced(OldVar->isReferenced());
}

InstantiateAttrs(TemplateArgs, OldVar, NewVar, LateAttrs, StartingScope);

LookupResult Previous(
    *this, NewVar->getDeclName(), NewVar->getLocation(),
    NewVar->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage
                                : Sema::LookupOrdinaryName,
    NewVar->isLocalExternDecl() ? Sema::ForExternalRedeclaration
                                : forRedeclarationInCurContext());

if (NewVar->isLocalExternDecl() && OldVar->getPreviousDecl() &&
    (!OldVar->getPreviousDecl()->getDeclContext()->isDependentContext() ||
     OldVar->getPreviousDecl()->getDeclContext()==OldVar->getDeclContext())) {
  // We have a previous declaration. Use that one, so we merge with the
  // right type.
  if (NamedDecl *NewPrev = FindInstantiatedDecl(
          NewVar->getLocation(), OldVar->getPreviousDecl(), TemplateArgs))
    Previous.addDecl(NewPrev);
} else if (!isa<VarTemplateSpecializationDecl>(NewVar) &&
           OldVar->hasLinkage())
  LookupQualifiedName(Previous, NewVar->getDeclContext(), false);
CheckVariableDeclaration(NewVar, Previous);

if (!InstantiatingVarTemplate) {
  NewVar->getLexicalDeclContext()->addHiddenDecl(NewVar);
  if (!NewVar->isLocalExternDecl() || !NewVar->getPreviousDecl())
    NewVar->getDeclContext()->makeDeclVisibleInContext(NewVar);
}

if (!OldVar->isOutOfLine()) {
  if (NewVar->getDeclContext()->isFunctionOrMethod())
    CurrentInstantiationScope->InstantiatedLocal(OldVar, NewVar);
}

// Link instantiations of static data members back to the template from
// which they were instantiated.
if (NewVar->isStaticDataMember() && !InstantiatingVarTemplate)
  NewVar->setInstantiationOfStaticDataMember(OldVar,
                                             TSK_ImplicitInstantiation);

// Forward the mangling number from the template to the instantiated decl.
Context.setManglingNumber(NewVar, Context.getManglingNumber(OldVar));
Context.setStaticLocalNumber(NewVar, Context.getStaticLocalNumber(OldVar));

// Delay instantiation of the initializer for variable templates or inline
// static data members until a definition of the variable is needed. We need
// it right away if the type contains 'auto'.
if ((!isa<VarTemplateSpecializationDecl>(NewVar) &&
     !InstantiatingVarTemplate &&
     !(OldVar->isInline() && OldVar->isThisDeclarationADefinition() &&
       !NewVar->isThisDeclarationADefinition())) ||
    NewVar->getType()->isUndeducedType())
  InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);

// Diagnose unused local variables with dependent types, where the diagnostic
// will have been deferred.
if (!NewVar->isInvalidDecl() &&
    NewVar->getDeclContext()->isFunctionOrMethod() &&
    OldVar->getType()->isDependentType())
  DiagnoseUnusedDecl(NewVar);
4167}

4169/// \brief Instantiate the initializer of a variable.
4170void Sema::InstantiateVariableInitializer(
  VarDecl *Var, VarDecl *OldVar,
  const MultiLevelTemplateArgumentList &TemplateArgs) {
if (ASTMutationListener *L = getASTContext().getASTMutationListener())
  L->VariableDefinitionInstantiated(Var);

// We propagate the 'inline' flag with the initializer, because it
// would otherwise imply that the variable is a definition for a
// non-static data member.
if (OldVar->isInlineSpecified())
  Var->setInlineSpecified();
else if (OldVar->isInline())
  Var->setImplicitlyInline();

if (OldVar->getInit()) {
  EnterExpressionEvaluationContext Evaluated(
      *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, Var);

  // Instantiate the initializer.
  ExprResult Init;

  {
    ContextRAII SwitchContext(*this, Var->getDeclContext());
    Init = SubstInitializer(OldVar->getInit(), TemplateArgs,
                            OldVar->getInitStyle() == VarDecl::CallInit);
  }

  if (!Init.isInvalid()) {
    Expr *InitExpr = Init.get();

    if (Var->hasAttr<DLLImportAttr>() &&
        (!InitExpr ||
         !InitExpr->isConstantInitializer(getASTContext(), false))) {
      // Do not dynamically initialize dllimport variables.
    } else if (InitExpr) {
      bool DirectInit = OldVar->isDirectInit();
      AddInitializerToDecl(Var, InitExpr, DirectInit);
    } else
      ActOnUninitializedDecl(Var);
  } else {
    // FIXME: Not too happy about invalidating the declaration
    // because of a bogus initializer.
    Var->setInvalidDecl();
  }
} else {
  if (Var->isStaticDataMember()) {
    if (!Var->isOutOfLine())
      return;

    // If the declaration inside the class had an initializer, don't add
    // another one to the out-of-line definition.
    if (OldVar->getFirstDecl()->hasInit())
      return;
  }

  // We'll add an initializer to a for-range declaration later.
  if (Var->isCXXForRangeDecl())
    return;

  ActOnUninitializedDecl(Var);
}
4231}

4233/// \brief Instantiate the definition of the given variable from its
4234/// template.
4235///
4236/// \param PointOfInstantiation the point at which the instantiation was
4237/// required. Note that this is not precisely a "point of instantiation"
4238/// for the variable, but it's close.
4239///
4240/// \param Var the already-instantiated declaration of a templated variable.
4241///
4242/// \param Recursive if true, recursively instantiates any functions that
4243/// are required by this instantiation.
4244///
4245/// \param DefinitionRequired if true, then we are performing an explicit
4246/// instantiation where a definition of the variable is required. Complain
4247/// if there is no such definition.
4248void Sema::InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
                                       VarDecl *Var, bool Recursive,
                                    bool DefinitionRequired, bool AtEndOfTU) {
if (Var->isInvalidDecl())
  return;

VarTemplateSpecializationDecl *VarSpec =
    dyn_cast<VarTemplateSpecializationDecl>(Var);
VarDecl *PatternDecl = nullptr, *Def = nullptr;
MultiLevelTemplateArgumentList TemplateArgs =
    getTemplateInstantiationArgs(Var);

if (VarSpec) {
  // If this is a variable template specialization, make sure that it is
  // non-dependent, then find its instantiation pattern.
  bool InstantiationDependent = false;
  assert(!TemplateSpecializationType::anyDependentTemplateArguments((static_cast <bool> (!TemplateSpecializationType::anyDependentTemplateArguments
( VarSpec->getTemplateArgsInfo(), InstantiationDependent) &&
 "Only instantiate variable template specializations that are "
 "not type-dependent") ? void (0) : __assert_fail ("!TemplateSpecializationType::anyDependentTemplateArguments( VarSpec->getTemplateArgsInfo(), InstantiationDependent) && \"Only instantiate variable template specializations that are \" \"not type-dependent\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4267, __extension__ __PRETTY_FUNCTION__))
             VarSpec->getTemplateArgsInfo(), InstantiationDependent) &&(static_cast <bool> (!TemplateSpecializationType::anyDependentTemplateArguments
( VarSpec->getTemplateArgsInfo(), InstantiationDependent) &&
 "Only instantiate variable template specializations that are "
 "not type-dependent") ? void (0) : __assert_fail ("!TemplateSpecializationType::anyDependentTemplateArguments( VarSpec->getTemplateArgsInfo(), InstantiationDependent) && \"Only instantiate variable template specializations that are \" \"not type-dependent\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4267, __extension__ __PRETTY_FUNCTION__))
         "Only instantiate variable template specializations that are "(static_cast <bool> (!TemplateSpecializationType::anyDependentTemplateArguments
( VarSpec->getTemplateArgsInfo(), InstantiationDependent) &&
 "Only instantiate variable template specializations that are "
 "not type-dependent") ? void (0) : __assert_fail ("!TemplateSpecializationType::anyDependentTemplateArguments( VarSpec->getTemplateArgsInfo(), InstantiationDependent) && \"Only instantiate variable template specializations that are \" \"not type-dependent\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4267, __extension__ __PRETTY_FUNCTION__))
         "not type-dependent")(static_cast <bool> (!TemplateSpecializationType::anyDependentTemplateArguments
( VarSpec->getTemplateArgsInfo(), InstantiationDependent) &&
 "Only instantiate variable template specializations that are "
 "not type-dependent") ? void (0) : __assert_fail ("!TemplateSpecializationType::anyDependentTemplateArguments( VarSpec->getTemplateArgsInfo(), InstantiationDependent) && \"Only instantiate variable template specializations that are \" \"not type-dependent\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4267, __extension__ __PRETTY_FUNCTION__));
  (void)InstantiationDependent;

  // Find the variable initialization that we'll be substituting. If the
  // pattern was instantiated from a member template, look back further to
  // find the real pattern.
  assert(VarSpec->getSpecializedTemplate() &&(static_cast <bool> (VarSpec->getSpecializedTemplate
() && "Specialization without specialized template?")
 ? void (0) : __assert_fail ("VarSpec->getSpecializedTemplate() && \"Specialization without specialized template?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4274, __extension__ __PRETTY_FUNCTION__))
         "Specialization without specialized template?")(static_cast <bool> (VarSpec->getSpecializedTemplate
() && "Specialization without specialized template?")
 ? void (0) : __assert_fail ("VarSpec->getSpecializedTemplate() && \"Specialization without specialized template?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4274, __extension__ __PRETTY_FUNCTION__));
  llvm::PointerUnion<VarTemplateDecl *,
                     VarTemplatePartialSpecializationDecl *> PatternPtr =
      VarSpec->getSpecializedTemplateOrPartial();
  if (PatternPtr.is<VarTemplatePartialSpecializationDecl *>()) {
    VarTemplatePartialSpecializationDecl *Tmpl =
        PatternPtr.get<VarTemplatePartialSpecializationDecl *>();
    while (VarTemplatePartialSpecializationDecl *From =
               Tmpl->getInstantiatedFromMember()) {
      if (Tmpl->isMemberSpecialization())
        break;

      Tmpl = From;
    }
    PatternDecl = Tmpl;
  } else {
    VarTemplateDecl *Tmpl = PatternPtr.get<VarTemplateDecl *>();
    while (VarTemplateDecl *From =
               Tmpl->getInstantiatedFromMemberTemplate()) {
      if (Tmpl->isMemberSpecialization())
        break;

      Tmpl = From;
    }
    PatternDecl = Tmpl->getTemplatedDecl();
  }

  // If this is a static data member template, there might be an
  // uninstantiated initializer on the declaration. If so, instantiate
  // it now.
  //
  // FIXME: This largely duplicates what we would do below. The difference
  // is that along this path we may instantiate an initializer from an
  // in-class declaration of the template and instantiate the definition
  // from a separate out-of-class definition.
  if (PatternDecl->isStaticDataMember() &&
      (PatternDecl = PatternDecl->getFirstDecl())->hasInit() &&
      !Var->hasInit()) {
    // FIXME: Factor out the duplicated instantiation context setup/tear down
    // code here.
    InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
    if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
      return;
    PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
                                        "instantiating variable initializer");

    // The instantiation is visible here, even if it was first declared in an
    // unimported module.
    Var->setVisibleDespiteOwningModule();

    // If we're performing recursive template instantiation, create our own
    // queue of pending implicit instantiations that we will instantiate
    // later, while we're still within our own instantiation context.
    GlobalEagerInstantiationScope GlobalInstantiations(*this,
                                                       /*Enabled=*/Recursive);
    LocalInstantiationScope Local(*this);
    LocalEagerInstantiationScope LocalInstantiations(*this);

    // Enter the scope of this instantiation. We don't use
    // PushDeclContext because we don't have a scope.
    ContextRAII PreviousContext(*this, Var->getDeclContext());
    InstantiateVariableInitializer(Var, PatternDecl, TemplateArgs);
    PreviousContext.pop();

    // This variable may have local implicit instantiations that need to be
    // instantiated within this scope.
    LocalInstantiations.perform();
    Local.Exit();
    GlobalInstantiations.perform();
  }

  // Find actual definition
  Def = PatternDecl->getDefinition(getASTContext());
} else {
  // If this is a static data member, find its out-of-line definition.
  assert(Var->isStaticDataMember() && "not a static data member?")(static_cast <bool> (Var->isStaticDataMember() &&
 "not a static data member?") ? void (0) : __assert_fail ("Var->isStaticDataMember() && \"not a static data member?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4349, __extension__ __PRETTY_FUNCTION__));
  PatternDecl = Var->getInstantiatedFromStaticDataMember();

  assert(PatternDecl && "data member was not instantiated from a template?")(static_cast <bool> (PatternDecl && "data member was not instantiated from a template?"
) ? void (0) : __assert_fail ("PatternDecl && \"data member was not instantiated from a template?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4352, __extension__ __PRETTY_FUNCTION__));
  assert(PatternDecl->isStaticDataMember() && "not a static data member?")(static_cast <bool> (PatternDecl->isStaticDataMember
() && "not a static data member?") ? void (0) : __assert_fail
 ("PatternDecl->isStaticDataMember() && \"not a static data member?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4353, __extension__ __PRETTY_FUNCTION__));
  Def = PatternDecl->getDefinition();
}

TemplateSpecializationKind TSK = Var->getTemplateSpecializationKind();

// If we don't have a definition of the variable template, we won't perform
// any instantiation. Rather, we rely on the user to instantiate this
// definition (or provide a specialization for it) in another translation
// unit.
if (!Def && !DefinitionRequired) {
  if (TSK == TSK_ExplicitInstantiationDefinition) {
    PendingInstantiations.push_back(
      std::make_pair(Var, PointOfInstantiation));
  } else if (TSK == TSK_ImplicitInstantiation) {
    // Warn about missing definition at the end of translation unit.
    if (AtEndOfTU && !getDiagnostics().hasErrorOccurred() &&
        !getSourceManager().isInSystemHeader(PatternDecl->getLocStart())) {
      Diag(PointOfInstantiation, diag::warn_var_template_missing)
        << Var;
      Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
      if (getLangOpts().CPlusPlus11)
        Diag(PointOfInstantiation, diag::note_inst_declaration_hint) << Var;
    }
    return;
  }

}

// FIXME: We need to track the instantiation stack in order to know which
// definitions should be visible within this instantiation.
// FIXME: Produce diagnostics when Var->getInstantiatedFromStaticDataMember().
if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Var,
                                   /*InstantiatedFromMember*/false,
                                   PatternDecl, Def, TSK,
                                   /*Complain*/DefinitionRequired))
  return;


// Never instantiate an explicit specialization.
if (TSK == TSK_ExplicitSpecialization)
  return;

// C++11 [temp.explicit]p10:
//   Except for inline functions, const variables of literal types, variables
//   of reference types, [...] explicit instantiation declarations
//   have the effect of suppressing the implicit instantiation of the entity
//   to which they refer.
if (TSK == TSK_ExplicitInstantiationDeclaration &&
    !Var->isUsableInConstantExpressions(getASTContext()))
  return;

// Make sure to pass the instantiated variable to the consumer at the end.
struct PassToConsumerRAII {
  ASTConsumer &Consumer;
  VarDecl *Var;

  PassToConsumerRAII(ASTConsumer &Consumer, VarDecl *Var)
    : Consumer(Consumer), Var(Var) { }

  ~PassToConsumerRAII() {
    Consumer.HandleCXXStaticMemberVarInstantiation(Var);
  }
} PassToConsumerRAII(Consumer, Var);

// If we already have a definition, we're done.
if (VarDecl *Def = Var->getDefinition()) {
  // We may be explicitly instantiating something we've already implicitly
  // instantiated.
  Def->setTemplateSpecializationKind(Var->getTemplateSpecializationKind(),
                                     PointOfInstantiation);
  return;
}

InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
  return;
PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
                                    "instantiating variable definition");

// If we're performing recursive template instantiation, create our own
// queue of pending implicit instantiations that we will instantiate later,
// while we're still within our own instantiation context.
GlobalEagerInstantiationScope GlobalInstantiations(*this,
                                                   /*Enabled=*/Recursive);

// Enter the scope of this instantiation. We don't use
// PushDeclContext because we don't have a scope.
ContextRAII PreviousContext(*this, Var->getDeclContext());
LocalInstantiationScope Local(*this);

LocalEagerInstantiationScope LocalInstantiations(*this);

VarDecl *OldVar = Var;
if (Def->isStaticDataMember() && !Def->isOutOfLine()) {
  // We're instantiating an inline static data member whose definition was
  // provided inside the class.
  InstantiateVariableInitializer(Var, Def, TemplateArgs);
} else if (!VarSpec) {
  Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(),
                                        TemplateArgs));
} else if (Var->isStaticDataMember() &&
           Var->getLexicalDeclContext()->isRecord()) {
  // We need to instantiate the definition of a static data member template,
  // and all we have is the in-class declaration of it. Instantiate a separate
  // declaration of the definition.
  TemplateDeclInstantiator Instantiator(*this, Var->getDeclContext(),
                                        TemplateArgs);
  Var = cast_or_null<VarDecl>(Instantiator.VisitVarTemplateSpecializationDecl(
      VarSpec->getSpecializedTemplate(), Def, nullptr,
      VarSpec->getTemplateArgsInfo(), VarSpec->getTemplateArgs().asArray()));
  if (Var) {
    llvm::PointerUnion<VarTemplateDecl *,
                       VarTemplatePartialSpecializationDecl *> PatternPtr =
        VarSpec->getSpecializedTemplateOrPartial();
    if (VarTemplatePartialSpecializationDecl *Partial =
        PatternPtr.dyn_cast<VarTemplatePartialSpecializationDecl *>())
      cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(
          Partial, &VarSpec->getTemplateInstantiationArgs());

    // Merge the definition with the declaration.
    LookupResult R(*this, Var->getDeclName(), Var->getLocation(),
                   LookupOrdinaryName, forRedeclarationInCurContext());
    R.addDecl(OldVar);
    MergeVarDecl(Var, R);

    // Attach the initializer.
    InstantiateVariableInitializer(Var, Def, TemplateArgs);
  }
} else
  // Complete the existing variable's definition with an appropriately
  // substituted type and initializer.
  Var = CompleteVarTemplateSpecializationDecl(VarSpec, Def, TemplateArgs);

PreviousContext.pop();

if (Var) {
  PassToConsumerRAII.Var = Var;
  Var->setTemplateSpecializationKind(OldVar->getTemplateSpecializationKind(),
                                     OldVar->getPointOfInstantiation());
}

// This variable may have local implicit instantiations that need to be
// instantiated within this scope.
LocalInstantiations.perform();
Local.Exit();
GlobalInstantiations.perform();
4500}

4502void
4503Sema::InstantiateMemInitializers(CXXConstructorDecl *New,
                               const CXXConstructorDecl *Tmpl,
                         const MultiLevelTemplateArgumentList &TemplateArgs) {

SmallVector<CXXCtorInitializer*, 4> NewInits;
bool AnyErrors = Tmpl->isInvalidDecl();

// Instantiate all the initializers.
for (const auto *Init : Tmpl->inits()) {
  // Only instantiate written initializers, let Sema re-construct implicit
  // ones.
  if (!Init->isWritten())
    continue;

  SourceLocation EllipsisLoc;

  if (Init->isPackExpansion()) {
    // This is a pack expansion. We should expand it now.
    TypeLoc BaseTL = Init->getTypeSourceInfo()->getTypeLoc();
    SmallVector<UnexpandedParameterPack, 4> Unexpanded;
    collectUnexpandedParameterPacks(BaseTL, Unexpanded);
    collectUnexpandedParameterPacks(Init->getInit(), Unexpanded);
    bool ShouldExpand = false;
    bool RetainExpansion = false;
    Optional<unsigned> NumExpansions;
    if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(),
                                        BaseTL.getSourceRange(),
                                        Unexpanded,
                                        TemplateArgs, ShouldExpand,
                                        RetainExpansion,
                                        NumExpansions)) {
      AnyErrors = true;
      New->setInvalidDecl();
      continue;
    }
    assert(ShouldExpand && "Partial instantiation of base initializer?")(static_cast <bool> (ShouldExpand && "Partial instantiation of base initializer?"
) ? void (0) : __assert_fail ("ShouldExpand && \"Partial instantiation of base initializer?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4538, __extension__ __PRETTY_FUNCTION__));

    // Loop over all of the arguments in the argument pack(s),
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);

      // Instantiate the initializer.
      ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
                                             /*CXXDirectInit=*/true);
      if (TempInit.isInvalid()) {
        AnyErrors = true;
        break;
      }

      // Instantiate the base type.
      TypeSourceInfo *BaseTInfo = SubstType(Init->getTypeSourceInfo(),
                                            TemplateArgs,
                                            Init->getSourceLocation(),
                                            New->getDeclName());
      if (!BaseTInfo) {
        AnyErrors = true;
        break;
      }

      // Build the initializer.
      MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(),
                                                   BaseTInfo, TempInit.get(),
                                                   New->getParent(),
                                                   SourceLocation());
      if (NewInit.isInvalid()) {
        AnyErrors = true;
        break;
      }

      NewInits.push_back(NewInit.get());
    }

    continue;
  }

  // Instantiate the initializer.
  ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
                                         /*CXXDirectInit=*/true);
  if (TempInit.isInvalid()) {
    AnyErrors = true;
    continue;
  }

  MemInitResult NewInit;
  if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) {
    TypeSourceInfo *TInfo = SubstType(Init->getTypeSourceInfo(),
                                      TemplateArgs,
                                      Init->getSourceLocation(),
                                      New->getDeclName());
    if (!TInfo) {
      AnyErrors = true;
      New->setInvalidDecl();
      continue;
    }

    if (Init->isBaseInitializer())
      NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.get(),
                                     New->getParent(), EllipsisLoc);
    else
      NewInit = BuildDelegatingInitializer(TInfo, TempInit.get(),
                                cast<CXXRecordDecl>(CurContext->getParent()));
  } else if (Init->isMemberInitializer()) {
    FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl(
                                                   Init->getMemberLocation(),
                                                   Init->getMember(),
                                                   TemplateArgs));
    if (!Member) {
      AnyErrors = true;
      New->setInvalidDecl();
      continue;
    }

    NewInit = BuildMemberInitializer(Member, TempInit.get(),
                                     Init->getSourceLocation());
  } else if (Init->isIndirectMemberInitializer()) {
    IndirectFieldDecl *IndirectMember =
       cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl(
                               Init->getMemberLocation(),
                               Init->getIndirectMember(), TemplateArgs));

    if (!IndirectMember) {
      AnyErrors = true;
      New->setInvalidDecl();
      continue;
    }

    NewInit = BuildMemberInitializer(IndirectMember, TempInit.get(),
                                     Init->getSourceLocation());
  }

  if (NewInit.isInvalid()) {
    AnyErrors = true;
    New->setInvalidDecl();
  } else {
    NewInits.push_back(NewInit.get());
  }
}

// Assign all the initializers to the new constructor.
ActOnMemInitializers(New,
                     /*FIXME: ColonLoc */
                     SourceLocation(),
                     NewInits,
                     AnyErrors);
4647}

4649// TODO: this could be templated if the various decl types used the
4650// same method name.
4651static bool isInstantiationOf(ClassTemplateDecl *Pattern,
                            ClassTemplateDecl *Instance) {
Pattern = Pattern->getCanonicalDecl();

do {
  Instance = Instance->getCanonicalDecl();
  if (Pattern == Instance) return true;
  Instance = Instance->getInstantiatedFromMemberTemplate();
} while (Instance);

return false;
4662}

4664static bool isInstantiationOf(FunctionTemplateDecl *Pattern,
                            FunctionTemplateDecl *Instance) {
Pattern = Pattern->getCanonicalDecl();

do {
  Instance = Instance->getCanonicalDecl();
  if (Pattern == Instance) return true;
  Instance = Instance->getInstantiatedFromMemberTemplate();
} while (Instance);

return false;
4675}

4677static bool
4678isInstantiationOf(ClassTemplatePartialSpecializationDecl *Pattern,
                ClassTemplatePartialSpecializationDecl *Instance) {
Pattern
  = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl());
do {
  Instance = cast<ClassTemplatePartialSpecializationDecl>(
                                              Instance->getCanonicalDecl());
  if (Pattern == Instance)
    return true;
  Instance = Instance->getInstantiatedFromMember();
} while (Instance);

return false;
4691}

4693static bool isInstantiationOf(CXXRecordDecl *Pattern,
                            CXXRecordDecl *Instance) {
Pattern = Pattern->getCanonicalDecl();

do {
  Instance = Instance->getCanonicalDecl();
  if (Pattern == Instance) return true;
  Instance = Instance->getInstantiatedFromMemberClass();
} while (Instance);

return false;
4704}

4706static bool isInstantiationOf(FunctionDecl *Pattern,
                            FunctionDecl *Instance) {
Pattern = Pattern->getCanonicalDecl();

do {
  Instance = Instance->getCanonicalDecl();
  if (Pattern == Instance) return true;
  Instance = Instance->getInstantiatedFromMemberFunction();
} while (Instance);

return false;
4717}

4719static bool isInstantiationOf(EnumDecl *Pattern,
                            EnumDecl *Instance) {
Pattern = Pattern->getCanonicalDecl();

do {
  Instance = Instance->getCanonicalDecl();
  if (Pattern == Instance) return true;
  Instance = Instance->getInstantiatedFromMemberEnum();
} while (Instance);

return false;
4730}

4732static bool isInstantiationOf(UsingShadowDecl *Pattern,
                            UsingShadowDecl *Instance,
                            ASTContext &C) {
return declaresSameEntity(C.getInstantiatedFromUsingShadowDecl(Instance),
                          Pattern);
4737}

4739static bool isInstantiationOf(UsingDecl *Pattern, UsingDecl *Instance,
                            ASTContext &C) {
return declaresSameEntity(C.getInstantiatedFromUsingDecl(Instance), Pattern);
4742}

4744template<typename T>
4745static bool isInstantiationOfUnresolvedUsingDecl(T *Pattern, Decl *Other,
                                               ASTContext &Ctx) {
// An unresolved using declaration can instantiate to an unresolved using
// declaration, or to a using declaration or a using declaration pack.
//
// Multiple declarations can claim to be instantiated from an unresolved
// using declaration if it's a pack expansion. We want the UsingPackDecl
// in that case, not the individual UsingDecls within the pack.
bool OtherIsPackExpansion;
NamedDecl *OtherFrom;
if (auto *OtherUUD = dyn_cast<T>(Other)) {
  OtherIsPackExpansion = OtherUUD->isPackExpansion();
  OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUUD);
} else if (auto *OtherUPD = dyn_cast<UsingPackDecl>(Other)) {
  OtherIsPackExpansion = true;
  OtherFrom = OtherUPD->getInstantiatedFromUsingDecl();
} else if (auto *OtherUD = dyn_cast<UsingDecl>(Other)) {
  OtherIsPackExpansion = false;
  OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUD);
} else {
  return false;
}
return Pattern->isPackExpansion() == OtherIsPackExpansion &&
       declaresSameEntity(OtherFrom, Pattern);
4769}

4771static bool isInstantiationOfStaticDataMember(VarDecl *Pattern,
                                            VarDecl *Instance) {
assert(Instance->isStaticDataMember())(static_cast <bool> (Instance->isStaticDataMember())
 ? void (0) : __assert_fail ("Instance->isStaticDataMember()"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4773, __extension__ __PRETTY_FUNCTION__));

Pattern = Pattern->getCanonicalDecl();

do {
  Instance = Instance->getCanonicalDecl();
  if (Pattern == Instance) return true;
  Instance = Instance->getInstantiatedFromStaticDataMember();
} while (Instance);

return false;
4784}

4786// Other is the prospective instantiation
4787// D is the prospective pattern
4788static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) {
if (auto *UUD = dyn_cast<UnresolvedUsingTypenameDecl>(D))
  return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);

if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(D))
  return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);

if (D->getKind() != Other->getKind())
  return false;

if (auto *Record = dyn_cast<CXXRecordDecl>(Other))
  return isInstantiationOf(cast<CXXRecordDecl>(D), Record);

if (auto *Function = dyn_cast<FunctionDecl>(Other))
  return isInstantiationOf(cast<FunctionDecl>(D), Function);

if (auto *Enum = dyn_cast<EnumDecl>(Other))
  return isInstantiationOf(cast<EnumDecl>(D), Enum);

if (auto *Var = dyn_cast<VarDecl>(Other))
  if (Var->isStaticDataMember())
    return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var);

if (auto *Temp = dyn_cast<ClassTemplateDecl>(Other))
  return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp);

if (auto *Temp = dyn_cast<FunctionTemplateDecl>(Other))
  return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp);

if (auto *PartialSpec =
        dyn_cast<ClassTemplatePartialSpecializationDecl>(Other))
  return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D),
                           PartialSpec);

if (auto *Field = dyn_cast<FieldDecl>(Other)) {
  if (!Field->getDeclName()) {
    // This is an unnamed field.
    return declaresSameEntity(Ctx.getInstantiatedFromUnnamedFieldDecl(Field),
                              cast<FieldDecl>(D));
  }
}

if (auto *Using = dyn_cast<UsingDecl>(Other))
  return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx);

if (auto *Shadow = dyn_cast<UsingShadowDecl>(Other))
  return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx);

return D->getDeclName() &&
       D->getDeclName() == cast<NamedDecl>(Other)->getDeclName();
4838}

4840template<typename ForwardIterator>
4841static NamedDecl *findInstantiationOf(ASTContext &Ctx,
                                    NamedDecl *D,
                                    ForwardIterator first,
                                    ForwardIterator last) {
for (; first != last; ++first)
  if (isInstantiationOf(Ctx, D, *first))
    return cast<NamedDecl>(*first);

return nullptr;
4850}

4852/// \brief Finds the instantiation of the given declaration context
4853/// within the current instantiation.
4854///
4855/// \returns NULL if there was an error
4856DeclContext *Sema::FindInstantiatedContext(SourceLocation Loc, DeclContext* DC,
                        const MultiLevelTemplateArgumentList &TemplateArgs) {
if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
  Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs, true);
  return cast_or_null<DeclContext>(ID);
} else return DC;
4862}

4864/// \brief Find the instantiation of the given declaration within the
4865/// current instantiation.
4866///
4867/// This routine is intended to be used when \p D is a declaration
4868/// referenced from within a template, that needs to mapped into the
4869/// corresponding declaration within an instantiation. For example,
4870/// given:
4871///
4872/// \code
4873/// template<typename T>
4874/// struct X {
4875///   enum Kind {
4876///     KnownValue = sizeof(T)
4877///   };
4878///
4879///   bool getKind() const { return KnownValue; }
4880/// };
4881///
4882/// template struct X<int>;
4883/// \endcode
4884///
4885/// In the instantiation of <tt>X<int>::getKind()</tt>, we need to map the
4886/// \p EnumConstantDecl for \p KnownValue (which refers to
4887/// <tt>X<T>::<Kind>::KnownValue</tt>) to its instantiation
4888/// (<tt>X<int>::<Kind>::KnownValue</tt>). \p FindInstantiatedDecl performs
4889/// this mapping from within the instantiation of <tt>X<int></tt>.
4890NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
                        const MultiLevelTemplateArgumentList &TemplateArgs,
                        bool FindingInstantiatedContext) {
DeclContext *ParentDC = D->getDeclContext();
// FIXME: Parmeters of pointer to functions (y below) that are themselves 
// parameters (p below) can have their ParentDC set to the translation-unit
// - thus we can not consistently check if the ParentDC of such a parameter 
// is Dependent or/and a FunctionOrMethod.
// For e.g. this code, during Template argument deduction tries to 
// find an instantiated decl for (T y) when the ParentDC for y is
// the translation unit.  
//   e.g. template <class T> void Foo(auto (*p)(T y) -> decltype(y())) {} 
//   float baz(float(*)()) { return 0.0; }
//   Foo(baz);
// The better fix here is perhaps to ensure that a ParmVarDecl, by the time
// it gets here, always has a FunctionOrMethod as its ParentDC??
// For now:
//  - as long as we have a ParmVarDecl whose parent is non-dependent and
//    whose type is not instantiation dependent, do nothing to the decl
//  - otherwise find its instantiated decl.
if (isa<ParmVarDecl>(D) && !ParentDC->isDependentContext() &&
    !cast<ParmVarDecl>(D)->getType()->isInstantiationDependentType())
  return D;
if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
    isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
    (ParentDC->isFunctionOrMethod() && ParentDC->isDependentContext()) ||
    (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda())) {
  // D is a local of some kind. Look into the map of local
  // declarations to their instantiations.
  if (CurrentInstantiationScope) {
    if (auto Found = CurrentInstantiationScope->findInstantiationOf(D)) {
      if (Decl *FD = Found->dyn_cast<Decl *>())
        return cast<NamedDecl>(FD);

      int PackIdx = ArgumentPackSubstitutionIndex;
      assert(PackIdx != -1 &&(static_cast <bool> (PackIdx != -1 && "found declaration pack but not pack expanding"
) ? void (0) : __assert_fail ("PackIdx != -1 && \"found declaration pack but not pack expanding\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4926, __extension__ __PRETTY_FUNCTION__))
             "found declaration pack but not pack expanding")(static_cast <bool> (PackIdx != -1 && "found declaration pack but not pack expanding"
) ? void (0) : __assert_fail ("PackIdx != -1 && \"found declaration pack but not pack expanding\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4926, __extension__ __PRETTY_FUNCTION__));
      typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
      return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]);
    }
  }

  // If we're performing a partial substitution during template argument
  // deduction, we may not have values for template parameters yet. They
  // just map to themselves.
  if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
      isa<TemplateTemplateParmDecl>(D))
    return D;

  if (D->isInvalidDecl())
    return nullptr;

  // Normally this function only searches for already instantiated declaration
  // however we have to make an exclusion for local types used before
  // definition as in the code:
  //
  //   template<typename T> void f1() {
  //     void g1(struct x1);
  //     struct x1 {};
  //   }
  //
  // In this case instantiation of the type of 'g1' requires definition of
  // 'x1', which is defined later. Error recovery may produce an enum used
  // before definition. In these cases we need to instantiate relevant
  // declarations here.
  bool NeedInstantiate = false;
  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
    NeedInstantiate = RD->isLocalClass();
  else
    NeedInstantiate = isa<EnumDecl>(D);
  if (NeedInstantiate) {
    Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
    CurrentInstantiationScope->InstantiatedLocal(D, Inst);
    return cast<TypeDecl>(Inst);
  }

  // If we didn't find the decl, then we must have a label decl that hasn't
  // been found yet.  Lazily instantiate it and return it now.
  assert(isa<LabelDecl>(D))(static_cast <bool> (isa<LabelDecl>(D)) ? void (0
) : __assert_fail ("isa<LabelDecl>(D)", "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4968, __extension__ __PRETTY_FUNCTION__));

  Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
  assert(Inst && "Failed to instantiate label??")(static_cast <bool> (Inst && "Failed to instantiate label??"
) ? void (0) : __assert_fail ("Inst && \"Failed to instantiate label??\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4971, __extension__ __PRETTY_FUNCTION__));

  CurrentInstantiationScope->InstantiatedLocal(D, Inst);
  return cast<LabelDecl>(Inst);
}

// For variable template specializations, update those that are still
// type-dependent.
if (VarTemplateSpecializationDecl *VarSpec =
        dyn_cast<VarTemplateSpecializationDecl>(D)) {
  bool InstantiationDependent = false;
  const TemplateArgumentListInfo &VarTemplateArgs =
      VarSpec->getTemplateArgsInfo();
  if (TemplateSpecializationType::anyDependentTemplateArguments(
          VarTemplateArgs, InstantiationDependent))
    D = cast<NamedDecl>(
        SubstDecl(D, VarSpec->getDeclContext(), TemplateArgs));
  return D;
}

if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
  if (!Record->isDependentContext())
    return D;

  // Determine whether this record is the "templated" declaration describing
  // a class template or class template partial specialization.
  ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate();
  if (ClassTemplate)
    ClassTemplate = ClassTemplate->getCanonicalDecl();
  else if (ClassTemplatePartialSpecializationDecl *PartialSpec
             = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record))
    ClassTemplate = PartialSpec->getSpecializedTemplate()->getCanonicalDecl();

  // Walk the current context to find either the record or an instantiation of
  // it.
  DeclContext *DC = CurContext;
  while (!DC->isFileContext()) {
    // If we're performing substitution while we're inside the template
    // definition, we'll find our own context. We're done.
    if (DC->Equals(Record))
      return Record;

    if (CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) {
      // Check whether we're in the process of instantiating a class template
      // specialization of the template we're mapping.
      if (ClassTemplateSpecializationDecl *InstSpec
                    = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){
        ClassTemplateDecl *SpecTemplate = InstSpec->getSpecializedTemplate();
        if (ClassTemplate && isInstantiationOf(ClassTemplate, SpecTemplate))
          return InstRecord;
      }

      // Check whether we're in the process of instantiating a member class.
      if (isInstantiationOf(Record, InstRecord))
        return InstRecord;
    }

    // Move to the outer template scope.
    if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) {
      if (FD->getFriendObjectKind() && FD->getDeclContext()->isFileContext()){
        DC = FD->getLexicalDeclContext();
        continue;
      }
      // An implicit deduction guide acts as if it's within the class template
      // specialization described by its name and first N template params.
      auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FD);
      if (Guide && Guide->isImplicit()) {
        TemplateDecl *TD = Guide->getDeducedTemplate();
        // Convert the arguments to an "as-written" list.
        TemplateArgumentListInfo Args(Loc, Loc);
        for (TemplateArgument Arg : TemplateArgs.getInnermost().take_front(
                                      TD->getTemplateParameters()->size())) {
          ArrayRef<TemplateArgument> Unpacked(Arg);
          if (Arg.getKind() == TemplateArgument::Pack)
            Unpacked = Arg.pack_elements();
          for (TemplateArgument UnpackedArg : Unpacked)
            Args.addArgument(
                getTrivialTemplateArgumentLoc(UnpackedArg, QualType(), Loc));
        }
        QualType T = CheckTemplateIdType(TemplateName(TD), Loc, Args);
        if (T.isNull())
          return nullptr;
        auto *SubstRecord = T->getAsCXXRecordDecl();
        assert(SubstRecord && "class template id not a class type?")(static_cast <bool> (SubstRecord && "class template id not a class type?"
) ? void (0) : __assert_fail ("SubstRecord && \"class template id not a class type?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5054, __extension__ __PRETTY_FUNCTION__));
        // Check that this template-id names the primary template and not a
        // partial or explicit specialization. (In the latter cases, it's
        // meaningless to attempt to find an instantiation of D within the
        // specialization.)
        // FIXME: The standard doesn't say what should happen here.
        if (FindingInstantiatedContext &&
            usesPartialOrExplicitSpecialization(
                Loc, cast<ClassTemplateSpecializationDecl>(SubstRecord))) {
          Diag(Loc, diag::err_specialization_not_primary_template)
            << T << (SubstRecord->getTemplateSpecializationKind() ==
                         TSK_ExplicitSpecialization);
          return nullptr;
        }
        DC = SubstRecord;
        continue;
      }
    }

    DC = DC->getParent();
  }

  // Fall through to deal with other dependent record types (e.g.,
  // anonymous unions in class templates).
}

if (!ParentDC->isDependentContext())
  return D;

ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs);
if (!ParentDC)
  return nullptr;

if (ParentDC != D->getDeclContext()) {
  // We performed some kind of instantiation in the parent context,
  // so now we need to look into the instantiated parent context to
  // find the instantiation of the declaration D.

  // If our context used to be dependent, we may need to instantiate
  // it before performing lookup into that context.
  bool IsBeingInstantiated = false;
  if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
    if (!Spec->isDependentContext()) {
      QualType T = Context.getTypeDeclType(Spec);
      const RecordType *Tag = T->getAs<RecordType>();
      assert(Tag && "type of non-dependent record is not a RecordType")(static_cast <bool> (Tag && "type of non-dependent record is not a RecordType"
) ? void (0) : __assert_fail ("Tag && \"type of non-dependent record is not a RecordType\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5099, __extension__ __PRETTY_FUNCTION__));
      if (Tag->isBeingDefined())
        IsBeingInstantiated = true;
      if (!Tag->isBeingDefined() &&
          RequireCompleteType(Loc, T, diag::err_incomplete_type))
        return nullptr;

      ParentDC = Tag->getDecl();
    }
  }

  NamedDecl *Result = nullptr;
  // FIXME: If the name is a dependent name, this lookup won't necessarily
  // find it. Does that ever matter?
  if (auto Name = D->getDeclName()) {
    DeclarationNameInfo NameInfo(Name, D->getLocation());
    Name = SubstDeclarationNameInfo(NameInfo, TemplateArgs).getName();
    if (!Name)
      return nullptr;
    DeclContext::lookup_result Found = ParentDC->lookup(Name);
    Result = findInstantiationOf(Context, D, Found.begin(), Found.end());
  } else {
    // Since we don't have a name for the entity we're looking for,
    // our only option is to walk through all of the declarations to
    // find that name. This will occur in a few cases:
    //
    //   - anonymous struct/union within a template
    //   - unnamed class/struct/union/enum within a template
    //
    // FIXME: Find a better way to find these instantiations!
    Result = findInstantiationOf(Context, D,
                                 ParentDC->decls_begin(),
                                 ParentDC->decls_end());
  }

  if (!Result) {
    if (isa<UsingShadowDecl>(D)) {
      // UsingShadowDecls can instantiate to nothing because of using hiding.
    } else if (Diags.hasErrorOccurred()) {
      // We've already complained about something, so most likely this
      // declaration failed to instantiate. There's no point in complaining
      // further, since this is normal in invalid code.
    } else if (IsBeingInstantiated) {
      // The class in which this member exists is currently being
      // instantiated, and we haven't gotten around to instantiating this
      // member yet. This can happen when the code uses forward declarations
      // of member classes, and introduces ordering dependencies via
      // template instantiation.
      Diag(Loc, diag::err_member_not_yet_instantiated)
        << D->getDeclName()
        << Context.getTypeDeclType(cast<CXXRecordDecl>(ParentDC));
      Diag(D->getLocation(), diag::note_non_instantiated_member_here);
    } else if (EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) {
      // This enumeration constant was found when the template was defined,
      // but can't be found in the instantiation. This can happen if an
      // unscoped enumeration member is explicitly specialized.
      EnumDecl *Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
      EnumDecl *Spec = cast<EnumDecl>(FindInstantiatedDecl(Loc, Enum,
                                                           TemplateArgs));
      assert(Spec->getTemplateSpecializationKind() ==(static_cast <bool> (Spec->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization) ? void (0) : __assert_fail (
"Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5159, __extension__ __PRETTY_FUNCTION__))
               TSK_ExplicitSpecialization)(static_cast <bool> (Spec->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization) ? void (0) : __assert_fail (
"Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5159, __extension__ __PRETTY_FUNCTION__));
      Diag(Loc, diag::err_enumerator_does_not_exist)
        << D->getDeclName()
        << Context.getTypeDeclType(cast<TypeDecl>(Spec->getDeclContext()));
      Diag(Spec->getLocation(), diag::note_enum_specialized_here)
        << Context.getTypeDeclType(Spec);
    } else {
      // We should have found something, but didn't.
      llvm_unreachable("Unable to find instantiation of declaration!")::llvm::llvm_unreachable_internal("Unable to find instantiation of declaration!"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5167);
    }
  }

  D = Result;
}

return D;
5175}

5177/// \brief Performs template instantiation for all implicit template
5178/// instantiations we have seen until this point.
5179void Sema::PerformPendingInstantiations(bool LocalOnly) {
while (!PendingLocalImplicitInstantiations.empty() ||
       (!LocalOnly && !PendingInstantiations.empty())) {
  PendingImplicitInstantiation Inst;

  if (PendingLocalImplicitInstantiations.empty()) {
    Inst = PendingInstantiations.front();
    PendingInstantiations.pop_front();
  } else {
    Inst = PendingLocalImplicitInstantiations.front();
    PendingLocalImplicitInstantiations.pop_front();
  }

  // Instantiate function definitions
  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) {
    bool DefinitionRequired = Function->getTemplateSpecializationKind() ==
                              TSK_ExplicitInstantiationDefinition;
    InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true,
                                  DefinitionRequired, true);
    if (Function->isDefined())
      Function->setInstantiationIsPending(false);
    continue;
  }

  // Instantiate variable definitions
  VarDecl *Var = cast<VarDecl>(Inst.first);

  assert((Var->isStaticDataMember() ||(static_cast <bool> ((Var->isStaticDataMember() || isa
<VarTemplateSpecializationDecl>(Var)) && "Not a static data member, nor a variable template"
 " specialization?") ? void (0) : __assert_fail ("(Var->isStaticDataMember() || isa<VarTemplateSpecializationDecl>(Var)) && \"Not a static data member, nor a variable template\" \" specialization?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5209, __extension__ __PRETTY_FUNCTION__))
          isa<VarTemplateSpecializationDecl>(Var)) &&(static_cast <bool> ((Var->isStaticDataMember() || isa
<VarTemplateSpecializationDecl>(Var)) && "Not a static data member, nor a variable template"
 " specialization?") ? void (0) : __assert_fail ("(Var->isStaticDataMember() || isa<VarTemplateSpecializationDecl>(Var)) && \"Not a static data member, nor a variable template\" \" specialization?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5209, __extension__ __PRETTY_FUNCTION__))
         "Not a static data member, nor a variable template"(static_cast <bool> ((Var->isStaticDataMember() || isa
<VarTemplateSpecializationDecl>(Var)) && "Not a static data member, nor a variable template"
 " specialization?") ? void (0) : __assert_fail ("(Var->isStaticDataMember() || isa<VarTemplateSpecializationDecl>(Var)) && \"Not a static data member, nor a variable template\" \" specialization?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5209, __extension__ __PRETTY_FUNCTION__))
         " specialization?")(static_cast <bool> ((Var->isStaticDataMember() || isa
<VarTemplateSpecializationDecl>(Var)) && "Not a static data member, nor a variable template"
 " specialization?") ? void (0) : __assert_fail ("(Var->isStaticDataMember() || isa<VarTemplateSpecializationDecl>(Var)) && \"Not a static data member, nor a variable template\" \" specialization?\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5209, __extension__ __PRETTY_FUNCTION__));

  // Don't try to instantiate declarations if the most recent redeclaration
  // is invalid.
  if (Var->getMostRecentDecl()->isInvalidDecl())
    continue;

  // Check if the most recent declaration has changed the specialization kind
  // and removed the need for implicit instantiation.
  switch (Var->getMostRecentDecl()->getTemplateSpecializationKind()) {
  case TSK_Undeclared:
    llvm_unreachable("Cannot instantitiate an undeclared specialization.")::llvm::llvm_unreachable_internal("Cannot instantitiate an undeclared specialization."
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5220);
  case TSK_ExplicitInstantiationDeclaration:
  case TSK_ExplicitSpecialization:
    continue;  // No longer need to instantiate this type.
  case TSK_ExplicitInstantiationDefinition:
    // We only need an instantiation if the pending instantiation *is* the
    // explicit instantiation.
    if (Var != Var->getMostRecentDecl())
      continue;
    break;
  case TSK_ImplicitInstantiation:
    break;
  }

  PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
                                      "instantiating variable definition");
  bool DefinitionRequired = Var->getTemplateSpecializationKind() ==
                            TSK_ExplicitInstantiationDefinition;

  // Instantiate static data member definitions or variable template
  // specializations.
  InstantiateVariableDefinition(/*FIXME:*/ Inst.second, Var, true,
                                DefinitionRequired, true);
}
5244}

5246void Sema::PerformDependentDiagnostics(const DeclContext *Pattern,
                     const MultiLevelTemplateArgumentList &TemplateArgs) {
for (auto DD : Pattern->ddiags()) {
  switch (DD->getKind()) {
  case DependentDiagnostic::Access:
    HandleDependentAccessCheck(*DD, TemplateArgs);
    break;
  }
}
5255}

←

/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h

1//===- DeclTemplate.h - Classes for representing C++ templates --*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10/// \file
11/// \brief Defines the C++ template declaration subclasses.
12//
13//===----------------------------------------------------------------------===//

15#ifndef LLVM_CLANG_AST_DECLTEMPLATE_H
16#define LLVM_CLANG_AST_DECLTEMPLATE_H

18#include "clang/AST/Decl.h"
19#include "clang/AST/DeclBase.h"
20#include "clang/AST/DeclCXX.h"
21#include "clang/AST/DeclarationName.h"
22#include "clang/AST/Redeclarable.h"
23#include "clang/AST/TemplateBase.h"
24#include "clang/AST/Type.h"
25#include "clang/Basic/LLVM.h"
26#include "clang/Basic/SourceLocation.h"
27#include "clang/Basic/Specifiers.h"
28#include "llvm/ADT/ArrayRef.h"
29#include "llvm/ADT/FoldingSet.h"
30#include "llvm/ADT/PointerIntPair.h"
31#include "llvm/ADT/PointerUnion.h"
32#include "llvm/ADT/iterator.h"
33#include "llvm/ADT/iterator_range.h"
34#include "llvm/Support/Casting.h"
35#include "llvm/Support/Compiler.h"
36#include "llvm/Support/TrailingObjects.h"
37#include <cassert>
38#include <cstddef>
39#include <cstdint>
40#include <iterator>
41#include <utility>

43namespace clang {

45enum BuiltinTemplateKind : int;
46class ClassTemplateDecl;
47class ClassTemplatePartialSpecializationDecl;
48class Expr;
49class FunctionTemplateDecl;
50class IdentifierInfo;
51class NonTypeTemplateParmDecl;
52class TemplateDecl;
53class TemplateTemplateParmDecl;
54class TemplateTypeParmDecl;
55class UnresolvedSetImpl;
56class VarTemplateDecl;
57class VarTemplatePartialSpecializationDecl;

59/// \brief Stores a template parameter of any kind.
60using TemplateParameter =
  llvm::PointerUnion3<TemplateTypeParmDecl *, NonTypeTemplateParmDecl *,
                      TemplateTemplateParmDecl *>;

64NamedDecl *getAsNamedDecl(TemplateParameter P);

66/// \brief Stores a list of template parameters for a TemplateDecl and its
67/// derived classes.
68class TemplateParameterList final
  : private llvm::TrailingObjects<TemplateParameterList, NamedDecl *,
                                  Expr *> {
/// The location of the 'template' keyword.
SourceLocation TemplateLoc;

/// The locations of the '<' and '>' angle brackets.
SourceLocation LAngleLoc, RAngleLoc;

/// The number of template parameters in this template
/// parameter list.
unsigned NumParams : 30;

/// Whether this template parameter list contains an unexpanded parameter
/// pack.
unsigned ContainsUnexpandedParameterPack : 1;

/// Whether this template parameter list has an associated requires-clause
unsigned HasRequiresClause : 1;

88protected:
TemplateParameterList(SourceLocation TemplateLoc, SourceLocation LAngleLoc,
                      ArrayRef<NamedDecl *> Params, SourceLocation RAngleLoc,
                      Expr *RequiresClause);

size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {
  return NumParams;
}

size_t numTrailingObjects(OverloadToken<Expr *>) const {
  return HasRequiresClause;
}

101public:
template <size_t N, bool HasRequiresClause>
friend class FixedSizeTemplateParameterListStorage;
friend TrailingObjects;

static TemplateParameterList *Create(const ASTContext &C,
                                     SourceLocation TemplateLoc,
                                     SourceLocation LAngleLoc,
                                     ArrayRef<NamedDecl *> Params,
                                     SourceLocation RAngleLoc,
                                     Expr *RequiresClause);

/// \brief Iterates through the template parameters in this list.
using iterator = NamedDecl **;

/// \brief Iterates through the template parameters in this list.
using const_iterator = NamedDecl * const *;

iterator begin() { return getTrailingObjects<NamedDecl *>(); }
const_iterator begin() const { return getTrailingObjects<NamedDecl *>(); }
iterator end() { return begin() + NumParams; }
const_iterator end() const { return begin() + NumParams; }

unsigned size() const { return NumParams; }

ArrayRef<NamedDecl*> asArray() {
  return llvm::makeArrayRef(begin(), end());
}
ArrayRef<const NamedDecl*> asArray() const {
  return llvm::makeArrayRef(begin(), size());
}

NamedDecl* getParam(unsigned Idx) {
  assert(Idx < size() && "Template parameter index out-of-range")(static_cast <bool> (Idx < size() && "Template parameter index out-of-range"
) ? void (0) : __assert_fail ("Idx < size() && \"Template parameter index out-of-range\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 134, __extension__ __PRETTY_FUNCTION__));
  return begin()[Idx];
}
const NamedDecl* getParam(unsigned Idx) const {
  assert(Idx < size() && "Template parameter index out-of-range")(static_cast <bool> (Idx < size() && "Template parameter index out-of-range"
) ? void (0) : __assert_fail ("Idx < size() && \"Template parameter index out-of-range\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 138, __extension__ __PRETTY_FUNCTION__));
  return begin()[Idx];
}

/// \brief Returns the minimum number of arguments needed to form a
/// template specialization.
///
/// This may be fewer than the number of template parameters, if some of
/// the parameters have default arguments or if there is a parameter pack.
unsigned getMinRequiredArguments() const;

/// \brief Get the depth of this template parameter list in the set of
/// template parameter lists.
///
/// The first template parameter list in a declaration will have depth 0,
/// the second template parameter list will have depth 1, etc.
unsigned getDepth() const;

/// \brief Determine whether this template parameter list contains an
/// unexpanded parameter pack.
bool containsUnexpandedParameterPack() const {
  return ContainsUnexpandedParameterPack;
}

/// \brief The constraint-expression of the associated requires-clause.
Expr *getRequiresClause() {
  return HasRequiresClause ? *getTrailingObjects<Expr *>() : nullptr;
}

/// \brief The constraint-expression of the associated requires-clause.
const Expr *getRequiresClause() const {
  return HasRequiresClause ? *getTrailingObjects<Expr *>() : nullptr;
}

SourceLocation getTemplateLoc() const { return TemplateLoc; }
SourceLocation getLAngleLoc() const { return LAngleLoc; }
SourceLocation getRAngleLoc() const { return RAngleLoc; }

SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(TemplateLoc, RAngleLoc);
}

180public:
// FIXME: workaround for MSVC 2013; remove when no longer needed
using FixedSizeStorageOwner = TrailingObjects::FixedSizeStorageOwner;
183};

185/// \brief Stores a list of template parameters and the associated
186/// requires-clause (if any) for a TemplateDecl and its derived classes.
187/// Suitable for creating on the stack.
188template <size_t N, bool HasRequiresClause>
189class FixedSizeTemplateParameterListStorage
  : public TemplateParameterList::FixedSizeStorageOwner {
typename TemplateParameterList::FixedSizeStorage<
    NamedDecl *, Expr *>::with_counts<
    N, HasRequiresClause ? 1u : 0u
    >::type storage;

196public:
FixedSizeTemplateParameterListStorage(SourceLocation TemplateLoc,
                                      SourceLocation LAngleLoc,
                                      ArrayRef<NamedDecl *> Params,
                                      SourceLocation RAngleLoc,
                                      Expr *RequiresClause)
    : FixedSizeStorageOwner(
          (assert(N == Params.size())(static_cast <bool> (N == Params.size()) ? void (0) : __assert_fail
 ("N == Params.size()", "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 203, __extension__ __PRETTY_FUNCTION__)),
           assert(HasRequiresClause == static_cast<bool>(RequiresClause))(static_cast <bool> (HasRequiresClause == static_cast<
bool>(RequiresClause)) ? void (0) : __assert_fail ("HasRequiresClause == static_cast<bool>(RequiresClause)"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 204, __extension__ __PRETTY_FUNCTION__)),
           new (static_cast<void *>(&storage)) TemplateParameterList(
               TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause))) {}
207};

209/// \brief A template argument list.
210class TemplateArgumentList final
  : private llvm::TrailingObjects<TemplateArgumentList, TemplateArgument> {
/// \brief The template argument list.
const TemplateArgument *Arguments;

/// \brief The number of template arguments in this template
/// argument list.
unsigned NumArguments;

// Constructs an instance with an internal Argument list, containing
// a copy of the Args array. (Called by CreateCopy)
TemplateArgumentList(ArrayRef<TemplateArgument> Args);

223public:
friend TrailingObjects;

TemplateArgumentList(const TemplateArgumentList &) = delete;
TemplateArgumentList &operator=(const TemplateArgumentList &) = delete;

/// \brief Type used to indicate that the template argument list itself is a
/// stack object. It does not own its template arguments.
enum OnStackType { OnStack };

/// \brief Create a new template argument list that copies the given set of
/// template arguments.
static TemplateArgumentList *CreateCopy(ASTContext &Context,
                                        ArrayRef<TemplateArgument> Args);

/// \brief Construct a new, temporary template argument list on the stack.
///
/// The template argument list does not own the template arguments
/// provided.
explicit TemplateArgumentList(OnStackType, ArrayRef<TemplateArgument> Args)
    : Arguments(Args.data()), NumArguments(Args.size()) {}

/// \brief Produces a shallow copy of the given template argument list.
///
/// This operation assumes that the input argument list outlives it.
/// This takes the list as a pointer to avoid looking like a copy
/// constructor, since this really really isn't safe to use that
/// way.
explicit TemplateArgumentList(const TemplateArgumentList *Other)
    : Arguments(Other->data()), NumArguments(Other->size()) {}

/// \brief Retrieve the template argument at a given index.
const TemplateArgument &get(unsigned Idx) const {
  assert(Idx < NumArguments && "Invalid template argument index")(static_cast <bool> (Idx < NumArguments && "Invalid template argument index"
) ? void (0) : __assert_fail ("Idx < NumArguments && \"Invalid template argument index\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 256, __extension__ __PRETTY_FUNCTION__));
  return data()[Idx];
}

/// \brief Retrieve the template argument at a given index.
const TemplateArgument &operator[](unsigned Idx) const { return get(Idx); }

/// \brief Produce this as an array ref.
ArrayRef<TemplateArgument> asArray() const {
  return llvm::makeArrayRef(data(), size());
}

/// \brief Retrieve the number of template arguments in this
/// template argument list.
unsigned size() const { return NumArguments; }

/// \brief Retrieve a pointer to the template argument list.
const TemplateArgument *data() const { return Arguments; }
274};

276void *allocateDefaultArgStorageChain(const ASTContext &C);

278/// Storage for a default argument. This is conceptually either empty, or an
279/// argument value, or a pointer to a previous declaration that had a default
280/// argument.
281///
282/// However, this is complicated by modules: while we require all the default
283/// arguments for a template to be equivalent, there may be more than one, and
284/// we need to track all the originating parameters to determine if the default
285/// argument is visible.
286template<typename ParmDecl, typename ArgType>
287class DefaultArgStorage {
/// Storage for both the value *and* another parameter from which we inherit
/// the default argument. This is used when multiple default arguments for a
/// parameter are merged together from different modules.
struct Chain {
  ParmDecl *PrevDeclWithDefaultArg;
  ArgType Value;
};
static_assert(sizeof(Chain) == sizeof(void *) * 2,
              "non-pointer argument type?");

llvm::PointerUnion3<ArgType, ParmDecl*, Chain*> ValueOrInherited;

static ParmDecl *getParmOwningDefaultArg(ParmDecl *Parm) {
  const DefaultArgStorage &Storage = Parm->getDefaultArgStorage();
  if (auto *Prev = Storage.ValueOrInherited.template dyn_cast<ParmDecl*>())
    Parm = Prev;
  assert(!Parm->getDefaultArgStorage()(static_cast <bool> (!Parm->getDefaultArgStorage() .
ValueOrInherited.template is<ParmDecl *>() && "should only be one level of indirection"
) ? void (0) : __assert_fail ("!Parm->getDefaultArgStorage() .ValueOrInherited.template is<ParmDecl *>() && \"should only be one level of indirection\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 306, __extension__ __PRETTY_FUNCTION__))
              .ValueOrInherited.template is<ParmDecl *>() &&(static_cast <bool> (!Parm->getDefaultArgStorage() .
ValueOrInherited.template is<ParmDecl *>() && "should only be one level of indirection"
) ? void (0) : __assert_fail ("!Parm->getDefaultArgStorage() .ValueOrInherited.template is<ParmDecl *>() && \"should only be one level of indirection\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 306, __extension__ __PRETTY_FUNCTION__))
         "should only be one level of indirection")(static_cast <bool> (!Parm->getDefaultArgStorage() .
ValueOrInherited.template is<ParmDecl *>() && "should only be one level of indirection"
) ? void (0) : __assert_fail ("!Parm->getDefaultArgStorage() .ValueOrInherited.template is<ParmDecl *>() && \"should only be one level of indirection\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 306, __extension__ __PRETTY_FUNCTION__));
  return Parm;
}

310public:
DefaultArgStorage() : ValueOrInherited(ArgType()) {}

/// Determine whether there is a default argument for this parameter.
bool isSet() const { return !ValueOrInherited.isNull(); }

/// Determine whether the default argument for this parameter was inherited
/// from a previous declaration of the same entity.
bool isInherited() const { return ValueOrInherited.template is<ParmDecl*>(); }

/// Get the default argument's value. This does not consider whether the
/// default argument is visible.
ArgType get() const {
  const DefaultArgStorage *Storage = this;
  if (auto *Prev = ValueOrInherited.template dyn_cast<ParmDecl*>())
    Storage = &Prev->getDefaultArgStorage();
  if (auto *C = Storage->ValueOrInherited.template dyn_cast<Chain*>())
    return C->Value;
  return Storage->ValueOrInherited.template get<ArgType>();
}

/// Get the parameter from which we inherit the default argument, if any.
/// This is the parameter on which the default argument was actually written.
const ParmDecl *getInheritedFrom() const {
  if (auto *D = ValueOrInherited.template dyn_cast<ParmDecl*>())
    return D;
  if (auto *C = ValueOrInherited.template dyn_cast<Chain*>())
    return C->PrevDeclWithDefaultArg;
  return nullptr;
}

/// Set the default argument.
void set(ArgType Arg) {
  assert(!isSet() && "default argument already set")(static_cast <bool> (!isSet() && "default argument already set"
) ? void (0) : __assert_fail ("!isSet() && \"default argument already set\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 343, __extension__ __PRETTY_FUNCTION__));
  ValueOrInherited = Arg;
}

/// Set that the default argument was inherited from another parameter.
void setInherited(const ASTContext &C, ParmDecl *InheritedFrom) {
  assert(!isInherited() && "default argument already inherited")(static_cast <bool> (!isInherited() && "default argument already inherited"
) ? void (0) : __assert_fail ("!isInherited() && \"default argument already inherited\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 349, __extension__ __PRETTY_FUNCTION__));
  InheritedFrom = getParmOwningDefaultArg(InheritedFrom);
  if (!isSet())
    ValueOrInherited = InheritedFrom;
  else
    ValueOrInherited = new (allocateDefaultArgStorageChain(C))
        Chain{InheritedFrom, ValueOrInherited.template get<ArgType>()};
}

/// Remove the default argument, even if it was inherited.
void clear() {
  ValueOrInherited = ArgType();
}
362};

364//===----------------------------------------------------------------------===//
365// Kinds of Templates
366//===----------------------------------------------------------------------===//

368/// \brief Stores the template parameter list and associated constraints for
369/// \c TemplateDecl objects that track associated constraints.
370class ConstrainedTemplateDeclInfo {
friend TemplateDecl;

373public:
ConstrainedTemplateDeclInfo() = default;

TemplateParameterList *getTemplateParameters() const {
  return TemplateParams;
}

Expr *getAssociatedConstraints() const { return AssociatedConstraints; }

382protected:
void setTemplateParameters(TemplateParameterList *TParams) {
  TemplateParams = TParams;
}

void setAssociatedConstraints(Expr *AC) { AssociatedConstraints = AC; }

TemplateParameterList *TemplateParams = nullptr;
Expr *AssociatedConstraints = nullptr;
391};


394/// \brief The base class of all kinds of template declarations (e.g.,
395/// class, function, etc.).
396///
397/// The TemplateDecl class stores the list of template parameters and a
398/// reference to the templated scoped declaration: the underlying AST node.
399class TemplateDecl : public NamedDecl {
void anchor() override;

402protected:
// Construct a template decl with the given name and parameters.
// Used when there is no templated element (e.g., for tt-params).
TemplateDecl(ConstrainedTemplateDeclInfo *CTDI, Kind DK, DeclContext *DC,
             SourceLocation L, DeclarationName Name,
             TemplateParameterList *Params)
    : NamedDecl(DK, DC, L, Name), TemplatedDecl(nullptr),
      TemplateParams(CTDI) {
  this->setTemplateParameters(Params);
}

TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name,
             TemplateParameterList *Params)
    : TemplateDecl(nullptr, DK, DC, L, Name, Params) {}

// Construct a template decl with name, parameters, and templated element.
TemplateDecl(ConstrainedTemplateDeclInfo *CTDI, Kind DK, DeclContext *DC,
             SourceLocation L, DeclarationName Name,
             TemplateParameterList *Params, NamedDecl *Decl)
    : NamedDecl(DK, DC, L, Name), TemplatedDecl(Decl),
      TemplateParams(CTDI) {
  this->setTemplateParameters(Params);
}

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

430public:
/// Get the list of template parameters
TemplateParameterList *getTemplateParameters() const {
  const auto *const CTDI =
      TemplateParams.dyn_cast<ConstrainedTemplateDeclInfo *>();
  return CTDI ? CTDI->getTemplateParameters()
              : TemplateParams.get<TemplateParameterList *>();
}

/// Get the constraint-expression from the associated requires-clause (if any)
const Expr *getRequiresClause() const {
  const TemplateParameterList *const TP = getTemplateParameters();
  return TP ? TP->getRequiresClause() : nullptr;
}

Expr *getAssociatedConstraints() const {
  const TemplateDecl *const C = cast<TemplateDecl>(getCanonicalDecl());
  const auto *const CTDI =
      C->TemplateParams.dyn_cast<ConstrainedTemplateDeclInfo *>();
  return CTDI ? CTDI->getAssociatedConstraints() : nullptr;
}

/// Get the underlying, templated declaration.
NamedDecl *getTemplatedDecl() const { return TemplatedDecl; }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }

static bool classofKind(Kind K) {
  return K >= firstTemplate && K <= lastTemplate;
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(getTemplateParameters()->getTemplateLoc(),
                     TemplatedDecl->getSourceRange().getEnd());
}

467protected:
NamedDecl *TemplatedDecl;
/// \brief The template parameter list and optional requires-clause
/// associated with this declaration; alternatively, a
/// \c ConstrainedTemplateDeclInfo if the associated constraints of the
/// template are being tracked by this particular declaration.
llvm::PointerUnion<TemplateParameterList *,
                   ConstrainedTemplateDeclInfo *>
    TemplateParams;

void setTemplateParameters(TemplateParameterList *TParams) {
  if (auto *const CTDI =
          TemplateParams.dyn_cast<ConstrainedTemplateDeclInfo *>()) {
    CTDI->setTemplateParameters(TParams);
  } else {
    TemplateParams = TParams;
  }
}

void setAssociatedConstraints(Expr *AC) {
  assert(isCanonicalDecl() &&(static_cast <bool> (isCanonicalDecl() && "Attaching associated constraints to non-canonical Decl"
) ? void (0) : __assert_fail ("isCanonicalDecl() && \"Attaching associated constraints to non-canonical Decl\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 488, __extension__ __PRETTY_FUNCTION__))
         "Attaching associated constraints to non-canonical Decl")(static_cast <bool> (isCanonicalDecl() && "Attaching associated constraints to non-canonical Decl"
) ? void (0) : __assert_fail ("isCanonicalDecl() && \"Attaching associated constraints to non-canonical Decl\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 488, __extension__ __PRETTY_FUNCTION__));
  TemplateParams.get<ConstrainedTemplateDeclInfo *>()
      ->setAssociatedConstraints(AC);
}

493public:
/// \brief Initialize the underlying templated declaration and
/// template parameters.
void init(NamedDecl *templatedDecl, TemplateParameterList* templateParams) {
  assert(!TemplatedDecl && "TemplatedDecl already set!")(static_cast <bool> (!TemplatedDecl && "TemplatedDecl already set!"
) ? void (0) : __assert_fail ("!TemplatedDecl && \"TemplatedDecl already set!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 497, __extension__ __PRETTY_FUNCTION__));
  assert(!TemplateParams && "TemplateParams already set!")(static_cast <bool> (!TemplateParams && "TemplateParams already set!"
) ? void (0) : __assert_fail ("!TemplateParams && \"TemplateParams already set!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 498, __extension__ __PRETTY_FUNCTION__));
  TemplatedDecl = templatedDecl;
  TemplateParams = templateParams;
}
502};

504/// \brief Provides information about a function template specialization,
505/// which is a FunctionDecl that has been explicitly specialization or
506/// instantiated from a function template.
507class FunctionTemplateSpecializationInfo : public llvm::FoldingSetNode {
FunctionTemplateSpecializationInfo(FunctionDecl *FD,
                                   FunctionTemplateDecl *Template,
                                   TemplateSpecializationKind TSK,
                                   const TemplateArgumentList *TemplateArgs,
                     const ASTTemplateArgumentListInfo *TemplateArgsAsWritten,
                                   SourceLocation POI)
    : Function(FD), Template(Template, TSK - 1),
      TemplateArguments(TemplateArgs),
      TemplateArgumentsAsWritten(TemplateArgsAsWritten),
      PointOfInstantiation(POI) {}

519public:
static FunctionTemplateSpecializationInfo *
Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template,
       TemplateSpecializationKind TSK,
       const TemplateArgumentList *TemplateArgs,
       const TemplateArgumentListInfo *TemplateArgsAsWritten,
       SourceLocation POI);

/// \brief The function template specialization that this structure
/// describes.
FunctionDecl *Function;

/// \brief The function template from which this function template
/// specialization was generated.
///
/// The two bits contain the top 4 values of TemplateSpecializationKind.
llvm::PointerIntPair<FunctionTemplateDecl *, 2> Template;

/// \brief The template arguments used to produce the function template
/// specialization from the function template.
const TemplateArgumentList *TemplateArguments;

/// \brief The template arguments as written in the sources, if provided.
const ASTTemplateArgumentListInfo *TemplateArgumentsAsWritten;

/// \brief The point at which this function template specialization was
/// first instantiated.
SourceLocation PointOfInstantiation;

/// \brief Retrieve the template from which this function was specialized.
FunctionTemplateDecl *getTemplate() const { return Template.getPointer(); }

/// \brief Determine what kind of template specialization this is.
TemplateSpecializationKind getTemplateSpecializationKind() const {
  return (TemplateSpecializationKind)(Template.getInt() + 1);
}

bool isExplicitSpecialization() const {
  return getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
}

/// \brief True if this declaration is an explicit specialization,
/// explicit instantiation declaration, or explicit instantiation
/// definition.
bool isExplicitInstantiationOrSpecialization() const {
  return isTemplateExplicitInstantiationOrSpecialization(
      getTemplateSpecializationKind());
}

/// \brief Set the template specialization kind.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
  assert(TSK != TSK_Undeclared &&(static_cast <bool> (TSK != TSK_Undeclared && "Cannot encode TSK_Undeclared for a function template specialization"
) ? void (0) : __assert_fail ("TSK != TSK_Undeclared && \"Cannot encode TSK_Undeclared for a function template specialization\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 571, __extension__ __PRETTY_FUNCTION__))
       "Cannot encode TSK_Undeclared for a function template specialization")(static_cast <bool> (TSK != TSK_Undeclared && "Cannot encode TSK_Undeclared for a function template specialization"
) ? void (0) : __assert_fail ("TSK != TSK_Undeclared && \"Cannot encode TSK_Undeclared for a function template specialization\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 571, __extension__ __PRETTY_FUNCTION__));
  Template.setInt(TSK - 1);
}

/// \brief Retrieve the first point of instantiation of this function
/// template specialization.
///
/// The point of instantiation may be an invalid source location if this
/// function has yet to be instantiated.
SourceLocation getPointOfInstantiation() const {
  return PointOfInstantiation;
}

/// \brief Set the (first) point of instantiation of this function template
/// specialization.
void setPointOfInstantiation(SourceLocation POI) {
  PointOfInstantiation = POI;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, TemplateArguments->asArray(),
          Function->getASTContext());
}

static void
Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
        ASTContext &Context) {
  ID.AddInteger(TemplateArgs.size());
  for (const TemplateArgument &TemplateArg : TemplateArgs)
    TemplateArg.Profile(ID, Context);
}
602};

604/// \brief Provides information a specialization of a member of a class
605/// template, which may be a member function, static data member,
606/// member class or member enumeration.
607class MemberSpecializationInfo {
// The member declaration from which this member was instantiated, and the
// manner in which the instantiation occurred (in the lower two bits).
llvm::PointerIntPair<NamedDecl *, 2> MemberAndTSK;

// The point at which this member was first instantiated.
SourceLocation PointOfInstantiation;

615public:
explicit
MemberSpecializationInfo(NamedDecl *IF, TemplateSpecializationKind TSK,
                         SourceLocation POI = SourceLocation())
    : MemberAndTSK(IF, TSK - 1), PointOfInstantiation(POI) {
  assert(TSK != TSK_Undeclared &&(static_cast <bool> (TSK != TSK_Undeclared && "Cannot encode undeclared template specializations for members"
) ? void (0) : __assert_fail ("TSK != TSK_Undeclared && \"Cannot encode undeclared template specializations for members\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 621, __extension__ __PRETTY_FUNCTION__))
         "Cannot encode undeclared template specializations for members")(static_cast <bool> (TSK != TSK_Undeclared && "Cannot encode undeclared template specializations for members"
) ? void (0) : __assert_fail ("TSK != TSK_Undeclared && \"Cannot encode undeclared template specializations for members\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 621, __extension__ __PRETTY_FUNCTION__));
}

/// \brief Retrieve the member declaration from which this member was
/// instantiated.
NamedDecl *getInstantiatedFrom() const { return MemberAndTSK.getPointer(); }

/// \brief Determine what kind of template specialization this is.
TemplateSpecializationKind getTemplateSpecializationKind() const {
  return (TemplateSpecializationKind)(MemberAndTSK.getInt() + 1);
}

bool isExplicitSpecialization() const {
  return getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
}

/// \brief Set the template specialization kind.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
  assert(TSK != TSK_Undeclared &&(static_cast <bool> (TSK != TSK_Undeclared && "Cannot encode undeclared template specializations for members"
) ? void (0) : __assert_fail ("TSK != TSK_Undeclared && \"Cannot encode undeclared template specializations for members\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 640, __extension__ __PRETTY_FUNCTION__))
         "Cannot encode undeclared template specializations for members")(static_cast <bool> (TSK != TSK_Undeclared && "Cannot encode undeclared template specializations for members"
) ? void (0) : __assert_fail ("TSK != TSK_Undeclared && \"Cannot encode undeclared template specializations for members\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 640, __extension__ __PRETTY_FUNCTION__));
  MemberAndTSK.setInt(TSK - 1);
}

/// \brief Retrieve the first point of instantiation of this member.
/// If the point of instantiation is an invalid location, then this member
/// has not yet been instantiated.
SourceLocation getPointOfInstantiation() const {
  return PointOfInstantiation;
}

/// \brief Set the first point of instantiation.
void setPointOfInstantiation(SourceLocation POI) {
  PointOfInstantiation = POI;
}
655};

657/// \brief Provides information about a dependent function-template
658/// specialization declaration.
659///
660/// Since explicit function template specialization and instantiation
661/// declarations can only appear in namespace scope, and you can only
662/// specialize a member of a fully-specialized class, the only way to
663/// get one of these is in a friend declaration like the following:
664///
665/// \code
666///   template \<class T> void foo(T);
667///   template \<class T> class A {
668///     friend void foo<>(T);
669///   };
670/// \endcode
671class DependentFunctionTemplateSpecializationInfo final
  : private llvm::TrailingObjects<DependentFunctionTemplateSpecializationInfo,
                                  TemplateArgumentLoc,
                                  FunctionTemplateDecl *> {
/// The number of potential template candidates.
unsigned NumTemplates;

/// The number of template arguments.
unsigned NumArgs;

/// The locations of the left and right angle brackets.
SourceRange AngleLocs;

size_t numTrailingObjects(OverloadToken<TemplateArgumentLoc>) const {
  return NumArgs;
}
size_t numTrailingObjects(OverloadToken<FunctionTemplateDecl *>) const {
  return NumTemplates;
}

DependentFunctionTemplateSpecializationInfo(
                               const UnresolvedSetImpl &Templates,
                               const TemplateArgumentListInfo &TemplateArgs);

695public:
friend TrailingObjects;

static DependentFunctionTemplateSpecializationInfo *
Create(ASTContext &Context, const UnresolvedSetImpl &Templates,
       const TemplateArgumentListInfo &TemplateArgs);

/// \brief Returns the number of function templates that this might
/// be a specialization of.
unsigned getNumTemplates() const { return NumTemplates; }

/// \brief Returns the i'th template candidate.
FunctionTemplateDecl *getTemplate(unsigned I) const {
  assert(I < getNumTemplates() && "template index out of range")(static_cast <bool> (I < getNumTemplates() &&
 "template index out of range") ? void (0) : __assert_fail ("I < getNumTemplates() && \"template index out of range\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 708, __extension__ __PRETTY_FUNCTION__));
  return getTrailingObjects<FunctionTemplateDecl *>()[I];
}

/// \brief Returns the explicit template arguments that were given.
const TemplateArgumentLoc *getTemplateArgs() const {
  return getTrailingObjects<TemplateArgumentLoc>();
}

/// \brief Returns the number of explicit template arguments that were given.
unsigned getNumTemplateArgs() const { return NumArgs; }

/// \brief Returns the nth template argument.
const TemplateArgumentLoc &getTemplateArg(unsigned I) const {
  assert(I < getNumTemplateArgs() && "template arg index out of range")(static_cast <bool> (I < getNumTemplateArgs() &&
 "template arg index out of range") ? void (0) : __assert_fail
 ("I < getNumTemplateArgs() && \"template arg index out of range\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 722, __extension__ __PRETTY_FUNCTION__));
  return getTemplateArgs()[I];
}

SourceLocation getLAngleLoc() const {
  return AngleLocs.getBegin();
}

SourceLocation getRAngleLoc() const {
  return AngleLocs.getEnd();
}
733};

735/// Declaration of a redeclarable template.
736class RedeclarableTemplateDecl : public TemplateDecl, 
                               public Redeclarable<RedeclarableTemplateDecl> 
738{
using redeclarable_base = Redeclarable<RedeclarableTemplateDecl>;

RedeclarableTemplateDecl *getNextRedeclarationImpl() override {
  return getNextRedeclaration();
}

RedeclarableTemplateDecl *getPreviousDeclImpl() override {
  return getPreviousDecl();
}

RedeclarableTemplateDecl *getMostRecentDeclImpl() override {
  return getMostRecentDecl();
}

753protected:
template <typename EntryType> struct SpecEntryTraits {
  using DeclType = EntryType;

  static DeclType *getDecl(EntryType *D) {
    return D;
  }

  static ArrayRef<TemplateArgument> getTemplateArgs(EntryType *D) {
    return D->getTemplateArgs().asArray();
  }
};

template <typename EntryType, typename SETraits = SpecEntryTraits<EntryType>,
          typename DeclType = typename SETraits::DeclType>
struct SpecIterator
    : llvm::iterator_adaptor_base<
          SpecIterator<EntryType, SETraits, DeclType>,
          typename llvm::FoldingSetVector<EntryType>::iterator,
          typename std::iterator_traits<typename llvm::FoldingSetVector<
              EntryType>::iterator>::iterator_category,
          DeclType *, ptrdiff_t, DeclType *, DeclType *> {
  SpecIterator() = default;
  explicit SpecIterator(
      typename llvm::FoldingSetVector<EntryType>::iterator SetIter)
      : SpecIterator::iterator_adaptor_base(std::move(SetIter)) {}

  DeclType *operator*() const {
    return SETraits::getDecl(&*this->I)->getMostRecentDecl();
  }

  DeclType *operator->() const { return **this; }
};

template <typename EntryType>
static SpecIterator<EntryType>
makeSpecIterator(llvm::FoldingSetVector<EntryType> &Specs, bool isEnd) {
  return SpecIterator<EntryType>(isEnd ? Specs.end() : Specs.begin());
}

void loadLazySpecializationsImpl() const;

template <class EntryType> typename SpecEntryTraits<EntryType>::DeclType*
findSpecializationImpl(llvm::FoldingSetVector<EntryType> &Specs,
                       ArrayRef<TemplateArgument> Args, void *&InsertPos);

template <class Derived, class EntryType>
void addSpecializationImpl(llvm::FoldingSetVector<EntryType> &Specs,
                           EntryType *Entry, void *InsertPos);

struct CommonBase {
  CommonBase() : InstantiatedFromMember(nullptr, false) {}

  /// \brief The template from which this was most
  /// directly instantiated (or null).
  ///
  /// The boolean value indicates whether this template
  /// was explicitly specialized.
  llvm::PointerIntPair<RedeclarableTemplateDecl*, 1, bool>
    InstantiatedFromMember;

  /// \brief If non-null, points to an array of specializations (including
  /// partial specializations) known only by their external declaration IDs.
  ///
  /// The first value in the array is the number of specializations/partial
  /// specializations that follow.
  uint32_t *LazySpecializations = nullptr;
};

/// \brief Pointer to the common data shared by all declarations of this
/// template.
mutable CommonBase *Common = nullptr;

/// \brief Retrieves the "common" pointer shared by all (re-)declarations of
/// the same template. Calling this routine may implicitly allocate memory
/// for the common pointer.
CommonBase *getCommonPtr() const;

virtual CommonBase *newCommon(ASTContext &C) const = 0;

// Construct a template decl with name, parameters, and templated element.
RedeclarableTemplateDecl(ConstrainedTemplateDeclInfo *CTDI, Kind DK,
                         ASTContext &C, DeclContext *DC, SourceLocation L,
                         DeclarationName Name, TemplateParameterList *Params,
                         NamedDecl *Decl)
    : TemplateDecl(CTDI, DK, DC, L, Name, Params, Decl), redeclarable_base(C)
      {}

RedeclarableTemplateDecl(Kind DK, ASTContext &C, DeclContext *DC,
                         SourceLocation L, DeclarationName Name,
                         TemplateParameterList *Params, NamedDecl *Decl)
    : RedeclarableTemplateDecl(nullptr, DK, C, DC, L, Name, Params, Decl) {}

846public:
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend class ASTReader;
template <class decl_type> friend class RedeclarableTemplate;

/// \brief Retrieves the canonical declaration of this template.
RedeclarableTemplateDecl *getCanonicalDecl() override {
  return getFirstDecl();
}
const RedeclarableTemplateDecl *getCanonicalDecl() const {
  return getFirstDecl();
}

/// \brief Determines whether this template was a specialization of a
/// member template.
///
/// In the following example, the function template \c X<int>::f and the
/// member template \c X<int>::Inner are member specializations.
///
/// \code
/// template<typename T>
/// struct X {
///   template<typename U> void f(T, U);
///   template<typename U> struct Inner;
/// };
///
/// template<> template<typename T>
/// void X<int>::f(int, T);
/// template<> template<typename T>
/// struct X<int>::Inner { /* ... */ };
/// \endcode
bool isMemberSpecialization() const {
  return getCommonPtr()->InstantiatedFromMember.getInt();
}

/// \brief Note that this member template is a specialization.
void setMemberSpecialization() {
  assert(getCommonPtr()->InstantiatedFromMember.getPointer() &&(static_cast <bool> (getCommonPtr()->InstantiatedFromMember
.getPointer() && "Only member templates can be member template specializations"
) ? void (0) : __assert_fail ("getCommonPtr()->InstantiatedFromMember.getPointer() && \"Only member templates can be member template specializations\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 885, __extension__ __PRETTY_FUNCTION__))
         "Only member templates can be member template specializations")(static_cast <bool> (getCommonPtr()->InstantiatedFromMember
.getPointer() && "Only member templates can be member template specializations"
) ? void (0) : __assert_fail ("getCommonPtr()->InstantiatedFromMember.getPointer() && \"Only member templates can be member template specializations\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 885, __extension__ __PRETTY_FUNCTION__));
  getCommonPtr()->InstantiatedFromMember.setInt(true);
}

/// \brief Retrieve the member template from which this template was
/// instantiated, or nullptr if this template was not instantiated from a 
/// member template.
///
/// A template is instantiated from a member template when the member 
/// template itself is part of a class template (or member thereof). For
/// example, given
///
/// \code
/// template<typename T>
/// struct X {
///   template<typename U> void f(T, U);
/// };
///
/// void test(X<int> x) {
///   x.f(1, 'a');
/// };
/// \endcode
///
/// \c X<int>::f is a FunctionTemplateDecl that describes the function
/// template
///
/// \code
/// template<typename U> void X<int>::f(int, U);
/// \endcode
///
/// which was itself created during the instantiation of \c X<int>. Calling
/// getInstantiatedFromMemberTemplate() on this FunctionTemplateDecl will
/// retrieve the FunctionTemplateDecl for the original template \c f within
/// the class template \c X<T>, i.e.,
///
/// \code
/// template<typename T>
/// template<typename U>
/// void X<T>::f(T, U);
/// \endcode
RedeclarableTemplateDecl *getInstantiatedFromMemberTemplate() const {
  return getCommonPtr()->InstantiatedFromMember.getPointer();
}

void setInstantiatedFromMemberTemplate(RedeclarableTemplateDecl *TD) {
  assert(!getCommonPtr()->InstantiatedFromMember.getPointer())(static_cast <bool> (!getCommonPtr()->InstantiatedFromMember
.getPointer()) ? void (0) : __assert_fail ("!getCommonPtr()->InstantiatedFromMember.getPointer()"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 930, __extension__ __PRETTY_FUNCTION__));
  getCommonPtr()->InstantiatedFromMember.setPointer(TD);
}

using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }

static bool classofKind(Kind K) {
  return K >= firstRedeclarableTemplate && K <= lastRedeclarableTemplate;
}
950};

952template <> struct RedeclarableTemplateDecl::
953SpecEntryTraits<FunctionTemplateSpecializationInfo> {
using DeclType = FunctionDecl;

static DeclType *getDecl(FunctionTemplateSpecializationInfo *I) {
  return I->Function;
}

static ArrayRef<TemplateArgument>
getTemplateArgs(FunctionTemplateSpecializationInfo *I) {
  return I->TemplateArguments->asArray();
}
964};

966/// Declaration of a template function.
967class FunctionTemplateDecl : public RedeclarableTemplateDecl {
968protected:
friend class FunctionDecl;

/// \brief Data that is common to all of the declarations of a given
/// function template.
struct Common : CommonBase {
  /// \brief The function template specializations for this function
  /// template, including explicit specializations and instantiations.
  llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> Specializations;

  /// \brief The set of "injected" template arguments used within this
  /// function template.
  ///
  /// This pointer refers to the template arguments (there are as
  /// many template arguments as template parameaters) for the function
  /// template, and is allocated lazily, since most function templates do not
  /// require the use of this information.
  TemplateArgument *InjectedArgs = nullptr;

  Common() = default;
};

FunctionTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
                     DeclarationName Name, TemplateParameterList *Params,
                     NamedDecl *Decl)
    : RedeclarableTemplateDecl(FunctionTemplate, C, DC, L, Name, Params,
                               Decl) {}

CommonBase *newCommon(ASTContext &C) const override;

Common *getCommonPtr() const {
  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
}

/// \brief Retrieve the set of function template specializations of this
/// function template.
llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
getSpecializations() const;

/// \brief Add a specialization of this function template.
///
/// \param InsertPos Insert position in the FoldingSetVector, must have been
///        retrieved by an earlier call to findSpecialization().
void addSpecialization(FunctionTemplateSpecializationInfo* Info,
                       void *InsertPos);

1014public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

/// \brief Load any lazily-loaded specializations from the external source.
void LoadLazySpecializations() const;

/// Get the underlying function declaration of the template.
FunctionDecl *getTemplatedDecl() const {
  return static_cast<FunctionDecl *>(TemplatedDecl);
}

/// Returns whether this template declaration defines the primary
/// pattern.
bool isThisDeclarationADefinition() const {
  return getTemplatedDecl()->isThisDeclarationADefinition();
}

/// \brief Return the specialization with the provided arguments if it exists,
/// otherwise return the insertion point.
FunctionDecl *findSpecialization(ArrayRef<TemplateArgument> Args,
                                 void *&InsertPos);

FunctionTemplateDecl *getCanonicalDecl() override {
  return cast<FunctionTemplateDecl>(
           RedeclarableTemplateDecl::getCanonicalDecl());
}
const FunctionTemplateDecl *getCanonicalDecl() const {
  return cast<FunctionTemplateDecl>(
           RedeclarableTemplateDecl::getCanonicalDecl());
}

/// \brief Retrieve the previous declaration of this function template, or
/// nullptr if no such declaration exists.
FunctionTemplateDecl *getPreviousDecl() {
  return cast_or_null<FunctionTemplateDecl>(
           static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
}
const FunctionTemplateDecl *getPreviousDecl() const {
  return cast_or_null<FunctionTemplateDecl>(
     static_cast<const RedeclarableTemplateDecl *>(this)->getPreviousDecl());
}

FunctionTemplateDecl *getMostRecentDecl() {
  return cast<FunctionTemplateDecl>(
      static_cast<RedeclarableTemplateDecl *>(this)
          ->getMostRecentDecl());
}
const FunctionTemplateDecl *getMostRecentDecl() const {
  return const_cast<FunctionTemplateDecl*>(this)->getMostRecentDecl();
}

FunctionTemplateDecl *getInstantiatedFromMemberTemplate() const {
  return cast_or_null<FunctionTemplateDecl>(
           RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
}

using spec_iterator = SpecIterator<FunctionTemplateSpecializationInfo>;
using spec_range = llvm::iterator_range<spec_iterator>;

spec_range specializations() const {
  return spec_range(spec_begin(), spec_end());
}

spec_iterator spec_begin() const {
  return makeSpecIterator(getSpecializations(), false);
}

spec_iterator spec_end() const {
  return makeSpecIterator(getSpecializations(), true);
}

/// \brief Retrieve the "injected" template arguments that correspond to the
/// template parameters of this function template.
///
/// Although the C++ standard has no notion of the "injected" template
/// arguments for a function template, the notion is convenient when
/// we need to perform substitutions inside the definition of a function
/// template.
ArrayRef<TemplateArgument> getInjectedTemplateArgs();

/// \brief Create a function template node.
static FunctionTemplateDecl *Create(ASTContext &C, DeclContext *DC,
                                    SourceLocation L,
                                    DeclarationName Name,
                                    TemplateParameterList *Params,
                                    NamedDecl *Decl);

/// \brief Create an empty function template node.
static FunctionTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);

// Implement isa/cast/dyncast support
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == FunctionTemplate; }
1108};

1110//===----------------------------------------------------------------------===//
1111// Kinds of Template Parameters
1112//===----------------------------------------------------------------------===//

1114/// \brief Defines the position of a template parameter within a template
1115/// parameter list.
1116///
1117/// Because template parameter can be listed
1118/// sequentially for out-of-line template members, each template parameter is
1119/// given a Depth - the nesting of template parameter scopes - and a Position -
1120/// the occurrence within the parameter list.
1121/// This class is inheritedly privately by different kinds of template
1122/// parameters and is not part of the Decl hierarchy. Just a facility.
1123class TemplateParmPosition {
1124protected:
// FIXME: These probably don't need to be ints. int:5 for depth, int:8 for
// position? Maybe?
unsigned Depth;
unsigned Position;

TemplateParmPosition(unsigned D, unsigned P) : Depth(D), Position(P) {}

1132public:
TemplateParmPosition() = delete;

/// Get the nesting depth of the template parameter.
unsigned getDepth() const { return Depth; }
void setDepth(unsigned D) { Depth = D; }

/// Get the position of the template parameter within its parameter list.
unsigned getPosition() const { return Position; }
void setPosition(unsigned P) { Position = P; }

/// Get the index of the template parameter within its parameter list.
unsigned getIndex() const { return Position; }
1145};

1147/// \brief Declaration of a template type parameter.
1148///
1149/// For example, "T" in
1150/// \code
1151/// template<typename T> class vector;
1152/// \endcode
1153class TemplateTypeParmDecl : public TypeDecl {
/// Sema creates these on the stack during auto type deduction.
friend class Sema;

/// \brief Whether this template type parameter was declaration with
/// the 'typename' keyword.
///
/// If false, it was declared with the 'class' keyword.
bool Typename : 1;

/// \brief The default template argument, if any.
using DefArgStorage =
    DefaultArgStorage<TemplateTypeParmDecl, TypeSourceInfo *>;
DefArgStorage DefaultArgument;

TemplateTypeParmDecl(DeclContext *DC, SourceLocation KeyLoc,
                     SourceLocation IdLoc, IdentifierInfo *Id,
                     bool Typename)
    : TypeDecl(TemplateTypeParm, DC, IdLoc, Id, KeyLoc), Typename(Typename) {}

1173public:
static TemplateTypeParmDecl *Create(const ASTContext &C, DeclContext *DC,
                                    SourceLocation KeyLoc,
                                    SourceLocation NameLoc,
                                    unsigned D, unsigned P,
                                    IdentifierInfo *Id, bool Typename,
                                    bool ParameterPack);
static TemplateTypeParmDecl *CreateDeserialized(const ASTContext &C, 
                                                unsigned ID);

/// \brief Whether this template type parameter was declared with
/// the 'typename' keyword.
///
/// If not, it was declared with the 'class' keyword.
bool wasDeclaredWithTypename() const { return Typename; }

const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }

/// \brief Determine whether this template parameter has a default
/// argument.
bool hasDefaultArgument() const { return DefaultArgument.isSet(); }

/// \brief Retrieve the default argument, if any.
QualType getDefaultArgument() const {
  return DefaultArgument.get()->getType();
}

/// \brief Retrieves the default argument's source information, if any.
TypeSourceInfo *getDefaultArgumentInfo() const {
  return DefaultArgument.get();
}

/// \brief Retrieves the location of the default argument declaration.
SourceLocation getDefaultArgumentLoc() const;

/// \brief Determines whether the default argument was inherited
/// from a previous declaration of this template.
bool defaultArgumentWasInherited() const {
  return DefaultArgument.isInherited();
}

/// \brief Set the default argument for this template parameter.
void setDefaultArgument(TypeSourceInfo *DefArg) {
  DefaultArgument.set(DefArg);
}

/// \brief Set that this default argument was inherited from another
/// parameter.
void setInheritedDefaultArgument(const ASTContext &C,
                                 TemplateTypeParmDecl *Prev) {
  DefaultArgument.setInherited(C, Prev);
}

/// \brief Removes the default argument of this template parameter.
void removeDefaultArgument() {
  DefaultArgument.clear();
}

/// \brief Set whether this template type parameter was declared with
/// the 'typename' or 'class' keyword.
void setDeclaredWithTypename(bool withTypename) { Typename = withTypename; }

/// \brief Retrieve the depth of the template parameter.
unsigned getDepth() const;

/// \brief Retrieve the index of the template parameter.
unsigned getIndex() const;

/// \brief Returns whether this is a parameter pack.
bool isParameterPack() const;

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == TemplateTypeParm; }
1249};

1251/// NonTypeTemplateParmDecl - Declares a non-type template parameter,
1252/// e.g., "Size" in
1253/// @code
1254/// template<int Size> class array { };
1255/// @endcode
1256class NonTypeTemplateParmDecl final
  : public DeclaratorDecl,
    protected TemplateParmPosition,
    private llvm::TrailingObjects<NonTypeTemplateParmDecl,
                                  std::pair<QualType, TypeSourceInfo *>> {
friend class ASTDeclReader;
friend TrailingObjects;

/// \brief The default template argument, if any, and whether or not
/// it was inherited.
using DefArgStorage = DefaultArgStorage<NonTypeTemplateParmDecl, Expr *>;
DefArgStorage DefaultArgument;

// FIXME: Collapse this into TemplateParamPosition; or, just move depth/index
// down here to save memory.

/// \brief Whether this non-type template parameter is a parameter pack.
bool ParameterPack;

/// \brief Whether this non-type template parameter is an "expanded"
/// parameter pack, meaning that its type is a pack expansion and we
/// already know the set of types that expansion expands to.
bool ExpandedParameterPack = false;

/// \brief The number of types in an expanded parameter pack.
unsigned NumExpandedTypes = 0;

size_t numTrailingObjects(
    OverloadToken<std::pair<QualType, TypeSourceInfo *>>) const {
  return NumExpandedTypes;
}

NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
                        SourceLocation IdLoc, unsigned D, unsigned P,
                        IdentifierInfo *Id, QualType T,
                        bool ParameterPack, TypeSourceInfo *TInfo)
    : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
      TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}

NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
                        SourceLocation IdLoc, unsigned D, unsigned P,
                        IdentifierInfo *Id, QualType T,
                        TypeSourceInfo *TInfo,
                        ArrayRef<QualType> ExpandedTypes,
                        ArrayRef<TypeSourceInfo *> ExpandedTInfos);

1302public:
static NonTypeTemplateParmDecl *
Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
       SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
       QualType T, bool ParameterPack, TypeSourceInfo *TInfo);

static 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);

static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C, 
                                                   unsigned ID);
static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C, 
                                                   unsigned ID,
                                                   unsigned NumExpandedTypes);
  
using TemplateParmPosition::getDepth;
using TemplateParmPosition::setDepth;
using TemplateParmPosition::getPosition;
using TemplateParmPosition::setPosition;
using TemplateParmPosition::getIndex;

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }

/// \brief Determine whether this template parameter has a default
/// argument.
bool hasDefaultArgument() const { return DefaultArgument.isSet(); }

/// \brief Retrieve the default argument, if any.
Expr *getDefaultArgument() const { return DefaultArgument.get(); }

/// \brief Retrieve the location of the default argument, if any.
SourceLocation getDefaultArgumentLoc() const;

/// \brief Determines whether the default argument was inherited
/// from a previous declaration of this template.
bool defaultArgumentWasInherited() const {
  return DefaultArgument.isInherited();
}

/// \brief Set the default argument for this template parameter, and
/// whether that default argument was inherited from another
/// declaration.
void setDefaultArgument(Expr *DefArg) { DefaultArgument.set(DefArg); }
void setInheritedDefaultArgument(const ASTContext &C,
                                 NonTypeTemplateParmDecl *Parm) {
  DefaultArgument.setInherited(C, Parm);
}

/// \brief Removes the default argument of this template parameter.
void removeDefaultArgument() { DefaultArgument.clear(); }

/// \brief Whether this parameter is a non-type template parameter pack.
///
/// If the parameter is a parameter pack, the type may be a
/// \c PackExpansionType. In the following example, the \c Dims parameter
/// is a parameter pack (whose type is 'unsigned').
///
/// \code
/// template<typename T, unsigned ...Dims> struct multi_array;
/// \endcode
bool isParameterPack() const { return ParameterPack; }

/// \brief Whether this parameter pack is a pack expansion.
///
/// A non-type template parameter pack is a pack expansion if its type
/// contains an unexpanded parameter pack. In this case, we will have
/// built a PackExpansionType wrapping the type.
bool isPackExpansion() const {
  return ParameterPack && getType()->getAs<PackExpansionType>();
}

/// \brief Whether this parameter is a non-type template parameter pack
/// that has a known list of different types at different positions.
///
/// A parameter pack is an expanded parameter pack when the original
/// parameter pack's type was itself a pack expansion, and that expansion
/// has already been expanded. For example, given:
///
/// \code
/// template<typename ...Types>
/// struct X {
///   template<Types ...Values>
///   struct Y { /* ... */ };
/// };
/// \endcode
///
/// The parameter pack \c Values has a \c PackExpansionType as its type,
/// which expands \c Types. When \c Types is supplied with template arguments
/// by instantiating \c X, the instantiation of \c Values becomes an
/// expanded parameter pack. For example, instantiating
/// \c X<int, unsigned int> results in \c Values being an expanded parameter
/// pack with expansion types \c int and \c unsigned int.
///
/// The \c getExpansionType() and \c getExpansionTypeSourceInfo() functions
/// return the expansion types.
bool isExpandedParameterPack() const { return ExpandedParameterPack; }

/// \brief Retrieves the number of expansion types in an expanded parameter
/// pack.
unsigned getNumExpansionTypes() const {
  assert(ExpandedParameterPack && "Not an expansion parameter pack")(static_cast <bool> (ExpandedParameterPack && "Not an expansion parameter pack"
) ? void (0) : __assert_fail ("ExpandedParameterPack && \"Not an expansion parameter pack\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 1407, __extension__ __PRETTY_FUNCTION__));
  return NumExpandedTypes;
}

/// \brief Retrieve a particular expansion type within an expanded parameter
/// pack.
QualType getExpansionType(unsigned I) const {
  assert(I < NumExpandedTypes && "Out-of-range expansion type index")(static_cast <bool> (I < NumExpandedTypes &&
 "Out-of-range expansion type index") ? void (0) : __assert_fail
 ("I < NumExpandedTypes && \"Out-of-range expansion type index\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 1414, __extension__ __PRETTY_FUNCTION__));
  auto TypesAndInfos =
      getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
  return TypesAndInfos[I].first;
}

/// \brief Retrieve a particular expansion type source info within an
/// expanded parameter pack.
TypeSourceInfo *getExpansionTypeSourceInfo(unsigned I) const {
  assert(I < NumExpandedTypes && "Out-of-range expansion type index")(static_cast <bool> (I < NumExpandedTypes &&
 "Out-of-range expansion type index") ? void (0) : __assert_fail
 ("I < NumExpandedTypes && \"Out-of-range expansion type index\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 1423, __extension__ __PRETTY_FUNCTION__));
  auto TypesAndInfos =
      getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
  return TypesAndInfos[I].second;
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == NonTypeTemplateParm; }
1432};

1434/// TemplateTemplateParmDecl - Declares a template template parameter,
1435/// e.g., "T" in
1436/// @code
1437/// template <template <typename> class T> class container { };
1438/// @endcode
1439/// A template template parameter is a TemplateDecl because it defines the
1440/// name of a template and the template parameters allowable for substitution.
1441class TemplateTemplateParmDecl final
  : public TemplateDecl,
    protected TemplateParmPosition,
    private llvm::TrailingObjects<TemplateTemplateParmDecl,
                                  TemplateParameterList *> {
/// \brief The default template argument, if any.
using DefArgStorage =
    DefaultArgStorage<TemplateTemplateParmDecl, TemplateArgumentLoc *>;
DefArgStorage DefaultArgument;

/// \brief Whether this parameter is a parameter pack.
bool ParameterPack;

/// \brief Whether this template template parameter is an "expanded"
/// parameter pack, meaning that it is a pack expansion and we
/// already know the set of template parameters that expansion expands to.
bool ExpandedParameterPack = false;

/// \brief The number of parameters in an expanded parameter pack.
unsigned NumExpandedParams = 0;

TemplateTemplateParmDecl(DeclContext *DC, SourceLocation L,
                         unsigned D, unsigned P, bool ParameterPack,
                         IdentifierInfo *Id, TemplateParameterList *Params)
    : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
      TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}

TemplateTemplateParmDecl(DeclContext *DC, SourceLocation L,
                         unsigned D, unsigned P,
                         IdentifierInfo *Id, TemplateParameterList *Params,
                         ArrayRef<TemplateParameterList *> Expansions);

void anchor() override;

1475public:
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend TrailingObjects;

static TemplateTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
                                        SourceLocation L, unsigned D,
                                        unsigned P, bool ParameterPack,
                                        IdentifierInfo *Id,
                                        TemplateParameterList *Params);
static TemplateTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
                                        SourceLocation L, unsigned D,
                                        unsigned P,
                                        IdentifierInfo *Id,
                                        TemplateParameterList *Params,
                               ArrayRef<TemplateParameterList *> Expansions);

static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
                                                    unsigned ID);
static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
                                                    unsigned ID,
                                                    unsigned NumExpansions);

using TemplateParmPosition::getDepth;
using TemplateParmPosition::setDepth;
using TemplateParmPosition::getPosition;
using TemplateParmPosition::setPosition;
using TemplateParmPosition::getIndex;

/// \brief Whether this template template parameter is a template
/// parameter pack.
///
/// \code
/// template<template <class T> ...MetaFunctions> struct Apply;
/// \endcode
bool isParameterPack() const { return ParameterPack; }

/// \brief Whether this parameter pack is a pack expansion.
///
/// A template template parameter pack is a pack expansion if its template
/// parameter list contains an unexpanded parameter pack.
bool isPackExpansion() const {
  return ParameterPack &&
         getTemplateParameters()->containsUnexpandedParameterPack();
}

/// \brief Whether this parameter is a template template parameter pack that
/// has a known list of different template parameter lists at different
/// positions.
///
/// A parameter pack is an expanded parameter pack when the original parameter
/// pack's template parameter list was itself a pack expansion, and that
/// expansion has already been expanded. For exampe, given:
///
/// \code
/// template<typename...Types> struct Outer {
///   template<template<Types> class...Templates> struct Inner;
/// };
/// \endcode
///
/// The parameter pack \c Templates is a pack expansion, which expands the
/// pack \c Types. When \c Types is supplied with template arguments by
/// instantiating \c Outer, the instantiation of \c Templates is an expanded
/// parameter pack.
bool isExpandedParameterPack() const { return ExpandedParameterPack; }

/// \brief Retrieves the number of expansion template parameters in
/// an expanded parameter pack.
unsigned getNumExpansionTemplateParameters() const {
  assert(ExpandedParameterPack && "Not an expansion parameter pack")(static_cast <bool> (ExpandedParameterPack && "Not an expansion parameter pack"
) ? void (0) : __assert_fail ("ExpandedParameterPack && \"Not an expansion parameter pack\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 1544, __extension__ __PRETTY_FUNCTION__));
  return NumExpandedParams;
}

/// \brief Retrieve a particular expansion type within an expanded parameter
/// pack.
TemplateParameterList *getExpansionTemplateParameters(unsigned I) const {
  assert(I < NumExpandedParams && "Out-of-range expansion type index")(static_cast <bool> (I < NumExpandedParams &&
 "Out-of-range expansion type index") ? void (0) : __assert_fail
 ("I < NumExpandedParams && \"Out-of-range expansion type index\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 1551, __extension__ __PRETTY_FUNCTION__));
  return getTrailingObjects<TemplateParameterList *>()[I];
}

const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }

/// \brief Determine whether this template parameter has a default
/// argument.
bool hasDefaultArgument() const { return DefaultArgument.isSet(); }

/// \brief Retrieve the default argument, if any.
const TemplateArgumentLoc &getDefaultArgument() const {
  static const TemplateArgumentLoc None;
  return DefaultArgument.isSet() ? *DefaultArgument.get() : None;
}

/// \brief Retrieve the location of the default argument, if any.
SourceLocation getDefaultArgumentLoc() const;

/// \brief Determines whether the default argument was inherited
/// from a previous declaration of this template.
bool defaultArgumentWasInherited() const {
  return DefaultArgument.isInherited();
}

/// \brief Set the default argument for this template parameter, and
/// whether that default argument was inherited from another
/// declaration.
void setDefaultArgument(const ASTContext &C,
                        const TemplateArgumentLoc &DefArg);
void setInheritedDefaultArgument(const ASTContext &C,
                                 TemplateTemplateParmDecl *Prev) {
  DefaultArgument.setInherited(C, Prev);
}

/// \brief Removes the default argument of this template parameter.
void removeDefaultArgument() { DefaultArgument.clear(); }

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  SourceLocation End = getLocation();
  if (hasDefaultArgument() && !defaultArgumentWasInherited())
    End = getDefaultArgument().getSourceRange().getEnd();
  return SourceRange(getTemplateParameters()->getTemplateLoc(), End);
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == TemplateTemplateParm; }
1599};

1601/// \brief Represents the builtin template declaration which is used to
1602/// implement __make_integer_seq and other builtin templates.  It serves
1603/// no real purpose beyond existing as a place to hold template parameters.
1604class BuiltinTemplateDecl : public TemplateDecl {
BuiltinTemplateKind BTK;

BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
                    DeclarationName Name, BuiltinTemplateKind BTK);

void anchor() override;

1612public:
// Implement isa/cast/dyncast support
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == BuiltinTemplate; }

static BuiltinTemplateDecl *Create(const ASTContext &C, DeclContext *DC,
                                   DeclarationName Name,
                                   BuiltinTemplateKind BTK) {
  return new (C, DC) BuiltinTemplateDecl(C, DC, Name, BTK);
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange();
}

BuiltinTemplateKind getBuiltinTemplateKind() const { return BTK; }
1628};

1630/// \brief Represents a class template specialization, which refers to
1631/// a class template with a given set of template arguments.
1632///
1633/// Class template specializations represent both explicit
1634/// specialization of class templates, as in the example below, and
1635/// implicit instantiations of class templates.
1636///
1637/// \code
1638/// template<typename T> class array;
1639///
1640/// template<>
1641/// class array<bool> { }; // class template specialization array<bool>
1642/// \endcode
1643class ClassTemplateSpecializationDecl
: public CXXRecordDecl, public llvm::FoldingSetNode {
/// \brief Structure that stores information about a class template
/// specialization that was instantiated from a class template partial
/// specialization.
struct SpecializedPartialSpecialization {
  /// \brief The class template partial specialization from which this
  /// class template specialization was instantiated.
  ClassTemplatePartialSpecializationDecl *PartialSpecialization;

  /// \brief The template argument list deduced for the class template
  /// partial specialization itself.
  const TemplateArgumentList *TemplateArgs;
};

/// \brief The template that this specialization specializes
llvm::PointerUnion<ClassTemplateDecl *, SpecializedPartialSpecialization *>
  SpecializedTemplate;

/// \brief Further info for explicit template specialization/instantiation.
struct ExplicitSpecializationInfo {
  /// \brief The type-as-written.
  TypeSourceInfo *TypeAsWritten = nullptr;

  /// \brief The location of the extern keyword.
  SourceLocation ExternLoc;

  /// \brief The location of the template keyword.
  SourceLocation TemplateKeywordLoc;

  ExplicitSpecializationInfo() = default;
};

/// \brief Further info for explicit template specialization/instantiation.
/// Does not apply to implicit specializations.
ExplicitSpecializationInfo *ExplicitInfo = nullptr;

/// \brief The template arguments used to describe this specialization.
const TemplateArgumentList *TemplateArgs;

/// \brief The point where this template was instantiated (if any)
SourceLocation PointOfInstantiation;

/// \brief The kind of specialization this declaration refers to.
/// Really a value of type TemplateSpecializationKind.
unsigned SpecializationKind : 3;

1690protected:
ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
                                DeclContext *DC, SourceLocation StartLoc,
                                SourceLocation IdLoc,
                                ClassTemplateDecl *SpecializedTemplate,
                                ArrayRef<TemplateArgument> Args,
                                ClassTemplateSpecializationDecl *PrevDecl);

explicit ClassTemplateSpecializationDecl(ASTContext &C, Kind DK);

1700public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static ClassTemplateSpecializationDecl *
Create(ASTContext &Context, TagKind TK, DeclContext *DC,
       SourceLocation StartLoc, SourceLocation IdLoc,
       ClassTemplateDecl *SpecializedTemplate,
       ArrayRef<TemplateArgument> Args,
       ClassTemplateSpecializationDecl *PrevDecl);
static ClassTemplateSpecializationDecl *
CreateDeserialized(ASTContext &C, unsigned ID);

void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
                          bool Qualified) const override;

// FIXME: This is broken. CXXRecordDecl::getMostRecentDecl() returns a
// different "most recent" declaration from this function for the same
// declaration, because we don't override getMostRecentDeclImpl(). But
// it's not clear that we should override that, because the most recent
// declaration as a CXXRecordDecl sometimes is the injected-class-name.
ClassTemplateSpecializationDecl *getMostRecentDecl() {
  CXXRecordDecl *Recent = static_cast<CXXRecordDecl *>(
                            this)->getMostRecentDecl();
  while (!isa<ClassTemplateSpecializationDecl>(Recent)) {
    // FIXME: Does injected class name need to be in the redeclarations chain?
    assert(Recent->isInjectedClassName() && Recent->getPreviousDecl())(static_cast <bool> (Recent->isInjectedClassName() &&
 Recent->getPreviousDecl()) ? void (0) : __assert_fail ("Recent->isInjectedClassName() && Recent->getPreviousDecl()"
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 1726, __extension__ __PRETTY_FUNCTION__));
    Recent = Recent->getPreviousDecl();
  }
  return cast<ClassTemplateSpecializationDecl>(Recent);
}

/// \brief Retrieve the template that this specialization specializes.
ClassTemplateDecl *getSpecializedTemplate() const;

/// \brief Retrieve the template arguments of the class template
/// specialization.
const TemplateArgumentList &getTemplateArgs() const {
  return *TemplateArgs;
}

/// \brief Determine the kind of specialization that this
/// declaration represents.
TemplateSpecializationKind getSpecializationKind() const {
  return static_cast<TemplateSpecializationKind>(SpecializationKind);
}

bool isExplicitSpecialization() const {
  return getSpecializationKind() == TSK_ExplicitSpecialization;
}

/// \brief True if this declaration is an explicit specialization,
/// explicit instantiation declaration, or explicit instantiation
/// definition.
bool isExplicitInstantiationOrSpecialization() const {
  return isTemplateExplicitInstantiationOrSpecialization(
      getTemplateSpecializationKind());
}

void setSpecializationKind(TemplateSpecializationKind TSK) {
  SpecializationKind = TSK;
}

/// \brief Get the point of instantiation (if any), or null if none.
SourceLocation getPointOfInstantiation() const {
  return PointOfInstantiation;
}

void setPointOfInstantiation(SourceLocation Loc) {
  assert(Loc.isValid() && "point of instantiation must be valid!")(static_cast <bool> (Loc.isValid() && "point of instantiation must be valid!"
) ? void (0) : __assert_fail ("Loc.isValid() && \"point of instantiation must be valid!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 1769, __extension__ __PRETTY_FUNCTION__));
  PointOfInstantiation = Loc;
}

/// \brief If this class template specialization is an instantiation of
/// a template (rather than an explicit specialization), return the
/// class template or class template partial specialization from which it
/// was instantiated.
llvm::PointerUnion<ClassTemplateDecl *,
                   ClassTemplatePartialSpecializationDecl *>
getInstantiatedFrom() const {
  if (!isTemplateInstantiation(getSpecializationKind()))
    return llvm::PointerUnion<ClassTemplateDecl *,
                              ClassTemplatePartialSpecializationDecl *>();

  return getSpecializedTemplateOrPartial();
}

/// \brief Retrieve the class template or class template partial
/// specialization which was specialized by this.
llvm::PointerUnion<ClassTemplateDecl *,
                   ClassTemplatePartialSpecializationDecl *>
getSpecializedTemplateOrPartial() const {
  if (SpecializedPartialSpecialization *PartialSpec
        = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
    return PartialSpec->PartialSpecialization;

  return SpecializedTemplate.get<ClassTemplateDecl*>();
}

/// \brief Retrieve the set of template arguments that should be used
/// to instantiate members of the class template or class template partial
/// specialization from which this class template specialization was
/// instantiated.
///
/// \returns For a class template specialization instantiated from the primary
/// template, this function will return the same template arguments as
/// getTemplateArgs(). For a class template specialization instantiated from
/// a class template partial specialization, this function will return the
/// deduced template arguments for the class template partial specialization
/// itself.
const TemplateArgumentList &getTemplateInstantiationArgs() const {
  if (SpecializedPartialSpecialization *PartialSpec
      = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
    return *PartialSpec->TemplateArgs;

  return getTemplateArgs();
}

/// \brief Note that this class template specialization is actually an
/// instantiation of the given class template partial specialization whose
/// template arguments have been deduced.
void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec,
                        const TemplateArgumentList *TemplateArgs) {
  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&(static_cast <bool> (!SpecializedTemplate.is<SpecializedPartialSpecialization
*>() && "Already set to a class template partial specialization!"
) ? void (0) : __assert_fail ("!SpecializedTemplate.is<SpecializedPartialSpecialization*>() && \"Already set to a class template partial specialization!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 1824, __extension__ __PRETTY_FUNCTION__))
         "Already set to a class template partial specialization!")(static_cast <bool> (!SpecializedTemplate.is<SpecializedPartialSpecialization
*>() && "Already set to a class template partial specialization!"
) ? void (0) : __assert_fail ("!SpecializedTemplate.is<SpecializedPartialSpecialization*>() && \"Already set to a class template partial specialization!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 1824, __extension__ __PRETTY_FUNCTION__));
  SpecializedPartialSpecialization *PS
    = new (getASTContext()) SpecializedPartialSpecialization();
  PS->PartialSpecialization = PartialSpec;
  PS->TemplateArgs = TemplateArgs;
  SpecializedTemplate = PS;
}

/// \brief Note that this class template specialization is an instantiation
/// of the given class template.
void setInstantiationOf(ClassTemplateDecl *TemplDecl) {
  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&(static_cast <bool> (!SpecializedTemplate.is<SpecializedPartialSpecialization
*>() && "Previously set to a class template partial specialization!"
) ? void (0) : __assert_fail ("!SpecializedTemplate.is<SpecializedPartialSpecialization*>() && \"Previously set to a class template partial specialization!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 1836, __extension__ __PRETTY_FUNCTION__))
         "Previously set to a class template partial specialization!")(static_cast <bool> (!SpecializedTemplate.is<SpecializedPartialSpecialization
*>() && "Previously set to a class template partial specialization!"
) ? void (0) : __assert_fail ("!SpecializedTemplate.is<SpecializedPartialSpecialization*>() && \"Previously set to a class template partial specialization!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 1836, __extension__ __PRETTY_FUNCTION__));
  SpecializedTemplate = TemplDecl;
}

/// \brief Sets the type of this specialization as it was written by
/// the user. This will be a class template specialization type.
void setTypeAsWritten(TypeSourceInfo *T) {
  if (!ExplicitInfo)
20
←
Assuming the condition is true→
21
←
Taking true branch→
    ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
22
←
Null pointer value stored to field 'ExplicitInfo'→
  ExplicitInfo->TypeAsWritten = T;
23
←
Access to field 'TypeAsWritten' results in a dereference of a null pointer (loaded from field 'ExplicitInfo')
}

/// \brief Gets the type of this specialization as it was written by
/// the user, if it was so written.
TypeSourceInfo *getTypeAsWritten() const {
  return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
}

/// \brief Gets the location of the extern keyword, if present.
SourceLocation getExternLoc() const {
  return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
}

/// \brief Sets the location of the extern keyword.
void setExternLoc(SourceLocation Loc) {
  if (!ExplicitInfo)
    ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
  ExplicitInfo->ExternLoc = Loc;
}

/// \brief Sets the location of the template keyword.
void setTemplateKeywordLoc(SourceLocation Loc) {
  if (!ExplicitInfo)
    ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
  ExplicitInfo->TemplateKeywordLoc = Loc;
}

/// \brief Gets the location of the template keyword, if present.
SourceLocation getTemplateKeywordLoc() const {
  return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

void Profile(llvm::FoldingSetNodeID &ID) const {
  Profile(ID, TemplateArgs->asArray(), getASTContext());
}

static void
Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
        ASTContext &Context) {
  ID.AddInteger(TemplateArgs.size());
  for (const TemplateArgument &TemplateArg : TemplateArgs)
    TemplateArg.Profile(ID, Context);
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }

static bool classofKind(Kind K) {
  return K >= firstClassTemplateSpecialization &&
         K <= lastClassTemplateSpecialization;
}
1898};

1900class ClassTemplatePartialSpecializationDecl
: public ClassTemplateSpecializationDecl {
/// \brief The list of template parameters
TemplateParameterList* TemplateParams = nullptr;

/// \brief The source info for the template arguments as written.
/// FIXME: redundant with TypeAsWritten?
const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;

/// \brief The class template partial specialization from which this
/// class template partial specialization was instantiated.
///
/// The boolean value will be true to indicate that this class template
/// partial specialization was specialized at this level.
llvm::PointerIntPair<ClassTemplatePartialSpecializationDecl *, 1, bool>
    InstantiatedFromMember;

ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
                                       DeclContext *DC,
                                       SourceLocation StartLoc,
                                       SourceLocation IdLoc,
                                       TemplateParameterList *Params,
                                       ClassTemplateDecl *SpecializedTemplate,
                                       ArrayRef<TemplateArgument> Args,
                             const ASTTemplateArgumentListInfo *ArgsAsWritten,
                             ClassTemplatePartialSpecializationDecl *PrevDecl);

ClassTemplatePartialSpecializationDecl(ASTContext &C)
  : ClassTemplateSpecializationDecl(C, ClassTemplatePartialSpecialization),
    InstantiatedFromMember(nullptr, false) {}

void anchor() override;

1933public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static ClassTemplatePartialSpecializationDecl *
Create(ASTContext &Context, TagKind TK, DeclContext *DC,
       SourceLocation StartLoc, SourceLocation IdLoc,
       TemplateParameterList *Params,
       ClassTemplateDecl *SpecializedTemplate,
       ArrayRef<TemplateArgument> Args,
       const TemplateArgumentListInfo &ArgInfos,
       QualType CanonInjectedType,
       ClassTemplatePartialSpecializationDecl *PrevDecl);

static ClassTemplatePartialSpecializationDecl *
CreateDeserialized(ASTContext &C, unsigned ID);

ClassTemplatePartialSpecializationDecl *getMostRecentDecl() {
  return cast<ClassTemplatePartialSpecializationDecl>(
           static_cast<ClassTemplateSpecializationDecl *>(
             this)->getMostRecentDecl());
}

/// Get the list of template parameters
TemplateParameterList *getTemplateParameters() const {
  return TemplateParams;
}

/// Get the template arguments as written.
const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
  return ArgsAsWritten;
}

/// \brief Retrieve the member class template partial specialization from
/// which this particular class template partial specialization was
/// instantiated.
///
/// \code
/// template<typename T>
/// struct Outer {
///   template<typename U> struct Inner;
///   template<typename U> struct Inner<U*> { }; // #1
/// };
///
/// Outer<float>::Inner<int*> ii;
/// \endcode
///
/// In this example, the instantiation of \c Outer<float>::Inner<int*> will
/// end up instantiating the partial specialization
/// \c Outer<float>::Inner<U*>, which itself was instantiated from the class
/// template partial specialization \c Outer<T>::Inner<U*>. Given
/// \c Outer<float>::Inner<U*>, this function would return
/// \c Outer<T>::Inner<U*>.
ClassTemplatePartialSpecializationDecl *getInstantiatedFromMember() const {
  const ClassTemplatePartialSpecializationDecl *First =
      cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
  return First->InstantiatedFromMember.getPointer();
}
ClassTemplatePartialSpecializationDecl *
getInstantiatedFromMemberTemplate() const {
  return getInstantiatedFromMember();
}

void setInstantiatedFromMember(
                        ClassTemplatePartialSpecializationDecl *PartialSpec) {
  ClassTemplatePartialSpecializationDecl *First =
      cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
  First->InstantiatedFromMember.setPointer(PartialSpec);
}

/// \brief Determines whether this class template partial specialization
/// template was a specialization of a member partial specialization.
///
/// In the following example, the member template partial specialization
/// \c X<int>::Inner<T*> is a member specialization.
///
/// \code
/// template<typename T>
/// struct X {
///   template<typename U> struct Inner;
///   template<typename U> struct Inner<U*>;
/// };
///
/// template<> template<typename T>
/// struct X<int>::Inner<T*> { /* ... */ };
/// \endcode
bool isMemberSpecialization() {
  ClassTemplatePartialSpecializationDecl *First =
      cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
  return First->InstantiatedFromMember.getInt();
}

/// \brief Note that this member template is a specialization.
void setMemberSpecialization() {
  ClassTemplatePartialSpecializationDecl *First =
      cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
  assert(First->InstantiatedFromMember.getPointer() &&(static_cast <bool> (First->InstantiatedFromMember.getPointer
() && "Only member templates can be member template specializations"
) ? void (0) : __assert_fail ("First->InstantiatedFromMember.getPointer() && \"Only member templates can be member template specializations\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 2030, __extension__ __PRETTY_FUNCTION__))
         "Only member templates can be member template specializations")(static_cast <bool> (First->InstantiatedFromMember.getPointer
() && "Only member templates can be member template specializations"
) ? void (0) : __assert_fail ("First->InstantiatedFromMember.getPointer() && \"Only member templates can be member template specializations\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 2030, __extension__ __PRETTY_FUNCTION__));
  return First->InstantiatedFromMember.setInt(true);
}

/// Retrieves the injected specialization type for this partial
/// specialization.  This is not the same as the type-decl-type for
/// this partial specialization, which is an InjectedClassNameType.
QualType getInjectedSpecializationType() const {
  assert(getTypeForDecl() && "partial specialization has no type set!")(static_cast <bool> (getTypeForDecl() && "partial specialization has no type set!"
) ? void (0) : __assert_fail ("getTypeForDecl() && \"partial specialization has no type set!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 2038, __extension__ __PRETTY_FUNCTION__));
  return cast<InjectedClassNameType>(getTypeForDecl())
           ->getInjectedSpecializationType();
}

// FIXME: Add Profile support!

static bool classof(const Decl *D) { return classofKind(D->getKind()); }

static bool classofKind(Kind K) {
  return K == ClassTemplatePartialSpecialization;
}
2050};

2052/// Declaration of a class template.
2053class ClassTemplateDecl : public RedeclarableTemplateDecl {
2054protected:
/// \brief Data that is common to all of the declarations of a given
/// class template.
struct Common : CommonBase {
  /// \brief The class template specializations for this class
  /// template, including explicit specializations and instantiations.
  llvm::FoldingSetVector<ClassTemplateSpecializationDecl> Specializations;

  /// \brief The class template partial specializations for this class
  /// template.
  llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>
    PartialSpecializations;

  /// \brief The injected-class-name type for this class template.
  QualType InjectedClassNameType;

  Common() = default;
};

/// \brief Retrieve the set of specializations of this class template.
llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
getSpecializations() const;

/// \brief Retrieve the set of partial specializations of this class
/// template.
llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
getPartialSpecializations();

ClassTemplateDecl(ConstrainedTemplateDeclInfo *CTDI, ASTContext &C,
                  DeclContext *DC, SourceLocation L, DeclarationName Name,
                  TemplateParameterList *Params, NamedDecl *Decl)
    : RedeclarableTemplateDecl(CTDI, ClassTemplate, C, DC, L, Name, Params,
                               Decl) {}

ClassTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
                  DeclarationName Name, TemplateParameterList *Params,
                  NamedDecl *Decl)
    : ClassTemplateDecl(nullptr, C, DC, L, Name, Params, Decl) {}

CommonBase *newCommon(ASTContext &C) const override;

Common *getCommonPtr() const {
  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
}

2099public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

/// \brief Load any lazily-loaded specializations from the external source.
void LoadLazySpecializations() const;

/// \brief Get the underlying class declarations of the template.
CXXRecordDecl *getTemplatedDecl() const {
  return static_cast<CXXRecordDecl *>(TemplatedDecl);
}

/// \brief Returns whether this template declaration defines the primary
/// class pattern.
bool isThisDeclarationADefinition() const {
  return getTemplatedDecl()->isThisDeclarationADefinition();
}

// FIXME: remove default argument for AssociatedConstraints
/// \brief Create a class template node.
static ClassTemplateDecl *Create(ASTContext &C, DeclContext *DC,
                                 SourceLocation L,
                                 DeclarationName Name,
                                 TemplateParameterList *Params,
                                 NamedDecl *Decl,
                                 Expr *AssociatedConstraints = nullptr);

/// \brief Create an empty class template node.
static ClassTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);

/// \brief Return the specialization with the provided arguments if it exists,
/// otherwise return the insertion point.
ClassTemplateSpecializationDecl *
findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);

/// \brief Insert the specified specialization knowing that it is not already
/// in. InsertPos must be obtained from findSpecialization.
void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos);

ClassTemplateDecl *getCanonicalDecl() override {
  return cast<ClassTemplateDecl>(
           RedeclarableTemplateDecl::getCanonicalDecl());
}
const ClassTemplateDecl *getCanonicalDecl() const {
  return cast<ClassTemplateDecl>(
           RedeclarableTemplateDecl::getCanonicalDecl());
}

/// \brief Retrieve the previous declaration of this class template, or
/// nullptr if no such declaration exists.
ClassTemplateDecl *getPreviousDecl() {
  return cast_or_null<ClassTemplateDecl>(
           static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
}
const ClassTemplateDecl *getPreviousDecl() const {
  return cast_or_null<ClassTemplateDecl>(
           static_cast<const RedeclarableTemplateDecl *>(
             this)->getPreviousDecl());
}

ClassTemplateDecl *getMostRecentDecl() {
  return cast<ClassTemplateDecl>(
      static_cast<RedeclarableTemplateDecl *>(this)->getMostRecentDecl());
}
const ClassTemplateDecl *getMostRecentDecl() const {
  return const_cast<ClassTemplateDecl*>(this)->getMostRecentDecl();
}

ClassTemplateDecl *getInstantiatedFromMemberTemplate() const {
  return cast_or_null<ClassTemplateDecl>(
           RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
}

/// \brief Return the partial specialization with the provided arguments if it
/// exists, otherwise return the insertion point.
ClassTemplatePartialSpecializationDecl *
findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);

/// \brief Insert the specified partial specialization knowing that it is not
/// already in. InsertPos must be obtained from findPartialSpecialization.
void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D,
                              void *InsertPos);

/// \brief Retrieve the partial specializations as an ordered list.
void getPartialSpecializations(
        SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS);

/// \brief Find a class template partial specialization with the given
/// type T.
///
/// \param T a dependent type that names a specialization of this class
/// template.
///
/// \returns the class template partial specialization that exactly matches
/// the type \p T, or nullptr if no such partial specialization exists.
ClassTemplatePartialSpecializationDecl *findPartialSpecialization(QualType T);

/// \brief Find a class template partial specialization which was instantiated
/// from the given member partial specialization.
///
/// \param D a member class template partial specialization.
///
/// \returns the class template partial specialization which was instantiated
/// from the given member partial specialization, or nullptr if no such
/// partial specialization exists.
ClassTemplatePartialSpecializationDecl *
findPartialSpecInstantiatedFromMember(
                                   ClassTemplatePartialSpecializationDecl *D);

/// \brief Retrieve the template specialization type of the
/// injected-class-name for this class template.
///
/// The injected-class-name for a class template \c X is \c
/// X<template-args>, where \c template-args is formed from the
/// template arguments that correspond to the template parameters of
/// \c X. For example:
///
/// \code
/// template<typename T, int N>
/// struct array {
///   typedef array this_type; // "array" is equivalent to "array<T, N>"
/// };
/// \endcode
QualType getInjectedClassNameSpecialization();

using spec_iterator = SpecIterator<ClassTemplateSpecializationDecl>;
using spec_range = llvm::iterator_range<spec_iterator>;

spec_range specializations() const {
  return spec_range(spec_begin(), spec_end());
}

spec_iterator spec_begin() const {
  return makeSpecIterator(getSpecializations(), false);
}

spec_iterator spec_end() const {
  return makeSpecIterator(getSpecializations(), true);
}

// Implement isa/cast/dyncast support
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ClassTemplate; }
2242};

2244/// \brief Declaration of a friend template.
2245///
2246/// For example:
2247/// \code
2248/// template \<typename T> class A {
2249///   friend class MyVector<T>; // not a friend template
2250///   template \<typename U> friend class B; // not a friend template
2251///   template \<typename U> friend class Foo<T>::Nested; // friend template
2252/// };
2253/// \endcode
2254///
2255/// \note This class is not currently in use.  All of the above
2256/// will yield a FriendDecl, not a FriendTemplateDecl.
2257class FriendTemplateDecl : public Decl {
virtual void anchor();

2260public:
using FriendUnion = llvm::PointerUnion<NamedDecl *,TypeSourceInfo *>;

2263private:
// The number of template parameters;  always non-zero.
unsigned NumParams = 0;

// The parameter list.
TemplateParameterList **Params = nullptr;

// The declaration that's a friend of this class.
FriendUnion Friend;

// Location of the 'friend' specifier.
SourceLocation FriendLoc;

FriendTemplateDecl(DeclContext *DC, SourceLocation Loc,
                   MutableArrayRef<TemplateParameterList *> Params,
                   FriendUnion Friend, SourceLocation FriendLoc)
    : Decl(Decl::FriendTemplate, DC, Loc), NumParams(Params.size()),
      Params(Params.data()), Friend(Friend), FriendLoc(FriendLoc) {}

FriendTemplateDecl(EmptyShell Empty) : Decl(Decl::FriendTemplate, Empty) {}

2284public:
friend class ASTDeclReader;

static FriendTemplateDecl *
Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc,
       MutableArrayRef<TemplateParameterList *> Params, FriendUnion Friend,
       SourceLocation FriendLoc);

static FriendTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);

/// If this friend declaration names a templated type (or
/// a dependent member type of a templated type), return that
/// type;  otherwise return null.
TypeSourceInfo *getFriendType() const {
  return Friend.dyn_cast<TypeSourceInfo*>();
}

/// If this friend declaration names a templated function (or
/// a member function of a templated type), return that type;
/// otherwise return null.
NamedDecl *getFriendDecl() const {
  return Friend.dyn_cast<NamedDecl*>();
}

/// \brief Retrieves the location of the 'friend' keyword.
SourceLocation getFriendLoc() const {
  return FriendLoc;
}

TemplateParameterList *getTemplateParameterList(unsigned i) const {
  assert(i <= NumParams)(static_cast <bool> (i <= NumParams) ? void (0) : __assert_fail
 ("i <= NumParams", "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 2314, __extension__ __PRETTY_FUNCTION__));
  return Params[i];
}

unsigned getNumTemplateParameters() const {
  return NumParams;
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Decl::FriendTemplate; }
2325};

2327/// \brief Declaration of an alias template.
2328///
2329/// For example:
2330/// \code
2331/// template \<typename T> using V = std::map<T*, int, MyCompare<T>>;
2332/// \endcode
2333class TypeAliasTemplateDecl : public RedeclarableTemplateDecl {
2334protected:
using Common = CommonBase;

TypeAliasTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
                      DeclarationName Name, TemplateParameterList *Params,
                      NamedDecl *Decl)
    : RedeclarableTemplateDecl(TypeAliasTemplate, C, DC, L, Name, Params,
                               Decl) {}

CommonBase *newCommon(ASTContext &C) const override;

Common *getCommonPtr() {
  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
}

2349public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

/// Get the underlying function declaration of the template.
TypeAliasDecl *getTemplatedDecl() const {
  return static_cast<TypeAliasDecl *>(TemplatedDecl);
}


TypeAliasTemplateDecl *getCanonicalDecl() override {
  return cast<TypeAliasTemplateDecl>(
           RedeclarableTemplateDecl::getCanonicalDecl());
}
const TypeAliasTemplateDecl *getCanonicalDecl() const {
  return cast<TypeAliasTemplateDecl>(
           RedeclarableTemplateDecl::getCanonicalDecl());
}

/// \brief Retrieve the previous declaration of this function template, or
/// nullptr if no such declaration exists.
TypeAliasTemplateDecl *getPreviousDecl() {
  return cast_or_null<TypeAliasTemplateDecl>(
           static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
}
const TypeAliasTemplateDecl *getPreviousDecl() const {
  return cast_or_null<TypeAliasTemplateDecl>(
           static_cast<const RedeclarableTemplateDecl *>(
             this)->getPreviousDecl());
}

TypeAliasTemplateDecl *getInstantiatedFromMemberTemplate() const {
  return cast_or_null<TypeAliasTemplateDecl>(
           RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
}

/// \brief Create a function template node.
static TypeAliasTemplateDecl *Create(ASTContext &C, DeclContext *DC,
                                     SourceLocation L,
                                     DeclarationName Name,
                                     TemplateParameterList *Params,
                                     NamedDecl *Decl);

/// \brief Create an empty alias template node.
static TypeAliasTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);

// Implement isa/cast/dyncast support
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == TypeAliasTemplate; }
2398};

2400/// \brief Declaration of a function specialization at template class scope.
2401///
2402/// This is a non-standard extension needed to support MSVC.
2403///
2404/// For example:
2405/// \code
2406/// template <class T>
2407/// class A {
2408///    template <class U> void foo(U a) { }
2409///    template<> void foo(int a) { }
2410/// }
2411/// \endcode
2412///
2413/// "template<> foo(int a)" will be saved in Specialization as a normal
2414/// CXXMethodDecl. Then during an instantiation of class A, it will be
2415/// transformed into an actual function specialization.
2416class ClassScopeFunctionSpecializationDecl : public Decl {
CXXMethodDecl *Specialization;
bool HasExplicitTemplateArgs;
TemplateArgumentListInfo TemplateArgs;

ClassScopeFunctionSpecializationDecl(DeclContext *DC, SourceLocation Loc,
                                     CXXMethodDecl *FD, bool Args,
                                     TemplateArgumentListInfo TemplArgs)
    : Decl(Decl::ClassScopeFunctionSpecialization, DC, Loc),
      Specialization(FD), HasExplicitTemplateArgs(Args),
      TemplateArgs(std::move(TemplArgs)) {}

ClassScopeFunctionSpecializationDecl(EmptyShell Empty)
    : Decl(Decl::ClassScopeFunctionSpecialization, Empty) {}

virtual void anchor();

2433public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

CXXMethodDecl *getSpecialization() const { return Specialization; }
bool hasExplicitTemplateArgs() const { return HasExplicitTemplateArgs; }
const TemplateArgumentListInfo& templateArgs() const { return TemplateArgs; }

static ClassScopeFunctionSpecializationDecl *Create(ASTContext &C,
                                                    DeclContext *DC,
                                                    SourceLocation Loc,
                                                    CXXMethodDecl *FD,
                                                 bool HasExplicitTemplateArgs,
                                      TemplateArgumentListInfo TemplateArgs) {
  return new (C, DC) ClassScopeFunctionSpecializationDecl(
      DC, Loc, FD, HasExplicitTemplateArgs, std::move(TemplateArgs));
}

static ClassScopeFunctionSpecializationDecl *
CreateDeserialized(ASTContext &Context, unsigned ID);

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }

static bool classofKind(Kind K) {
  return K == Decl::ClassScopeFunctionSpecialization;
}
2460};

2462/// Implementation of inline functions that require the template declarations
2463inline AnyFunctionDecl::AnyFunctionDecl(FunctionTemplateDecl *FTD)
  : Function(FTD) {}

2466/// \brief Represents a variable template specialization, which refers to
2467/// a variable template with a given set of template arguments.
2468///
2469/// Variable template specializations represent both explicit
2470/// specializations of variable templates, as in the example below, and
2471/// implicit instantiations of variable templates.
2472///
2473/// \code
2474/// template<typename T> constexpr T pi = T(3.1415926535897932385);
2475///
2476/// template<>
2477/// constexpr float pi<float>; // variable template specialization pi<float>
2478/// \endcode
2479class VarTemplateSpecializationDecl : public VarDecl,
                                    public llvm::FoldingSetNode {

/// \brief Structure that stores information about a variable template
/// specialization that was instantiated from a variable template partial
/// specialization.
struct SpecializedPartialSpecialization {
  /// \brief The variable template partial specialization from which this
  /// variable template specialization was instantiated.
  VarTemplatePartialSpecializationDecl *PartialSpecialization;

  /// \brief The template argument list deduced for the variable template
  /// partial specialization itself.
  const TemplateArgumentList *TemplateArgs;
};

/// \brief The template that this specialization specializes.
llvm::PointerUnion<VarTemplateDecl *, SpecializedPartialSpecialization *>
SpecializedTemplate;

/// \brief Further info for explicit template specialization/instantiation.
struct ExplicitSpecializationInfo {
  /// \brief The type-as-written.
  TypeSourceInfo *TypeAsWritten = nullptr;

  /// \brief The location of the extern keyword.
  SourceLocation ExternLoc;

  /// \brief The location of the template keyword.
  SourceLocation TemplateKeywordLoc;

  ExplicitSpecializationInfo() = default;
};

/// \brief Further info for explicit template specialization/instantiation.
/// Does not apply to implicit specializations.
ExplicitSpecializationInfo *ExplicitInfo = nullptr;

/// \brief The template arguments used to describe this specialization.
const TemplateArgumentList *TemplateArgs;
TemplateArgumentListInfo TemplateArgsInfo;

/// \brief The point where this template was instantiated (if any).
SourceLocation PointOfInstantiation;

/// \brief The kind of specialization this declaration refers to.
/// Really a value of type TemplateSpecializationKind.
unsigned SpecializationKind : 3;

/// \brief Whether this declaration is a complete definition of the
/// variable template specialization. We can't otherwise tell apart
/// an instantiated declaration from an instantiated definition with
/// no initializer.
unsigned IsCompleteDefinition : 1;

2534protected:
VarTemplateSpecializationDecl(Kind DK, ASTContext &Context, DeclContext *DC,
                              SourceLocation StartLoc, SourceLocation IdLoc,
                              VarTemplateDecl *SpecializedTemplate,
                              QualType T, TypeSourceInfo *TInfo,
                              StorageClass S,
                              ArrayRef<TemplateArgument> Args);

explicit VarTemplateSpecializationDecl(Kind DK, ASTContext &Context);

2544public:
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend class VarDecl;

static VarTemplateSpecializationDecl *
Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
       SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
       TypeSourceInfo *TInfo, StorageClass S,
       ArrayRef<TemplateArgument> Args);
static VarTemplateSpecializationDecl *CreateDeserialized(ASTContext &C,
                                                         unsigned ID);

void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
                          bool Qualified) const override;

VarTemplateSpecializationDecl *getMostRecentDecl() {
  VarDecl *Recent = static_cast<VarDecl *>(this)->getMostRecentDecl();
  return cast<VarTemplateSpecializationDecl>(Recent);
}

/// \brief Retrieve the template that this specialization specializes.
VarTemplateDecl *getSpecializedTemplate() const;

/// \brief Retrieve the template arguments of the variable template
/// specialization.
const TemplateArgumentList &getTemplateArgs() const { return *TemplateArgs; }

// TODO: Always set this when creating the new specialization?
void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo);

const TemplateArgumentListInfo &getTemplateArgsInfo() const {
  return TemplateArgsInfo;
}

/// \brief Determine the kind of specialization that this
/// declaration represents.
TemplateSpecializationKind getSpecializationKind() const {
  return static_cast<TemplateSpecializationKind>(SpecializationKind);
}

bool isExplicitSpecialization() const {
  return getSpecializationKind() == TSK_ExplicitSpecialization;
}

/// \brief True if this declaration is an explicit specialization,
/// explicit instantiation declaration, or explicit instantiation
/// definition.
bool isExplicitInstantiationOrSpecialization() const {
  return isTemplateExplicitInstantiationOrSpecialization(
      getTemplateSpecializationKind());
}

void setSpecializationKind(TemplateSpecializationKind TSK) {
  SpecializationKind = TSK;
}

/// \brief Get the point of instantiation (if any), or null if none.
SourceLocation getPointOfInstantiation() const {
  return PointOfInstantiation;
}

void setPointOfInstantiation(SourceLocation Loc) {
  assert(Loc.isValid() && "point of instantiation must be valid!")(static_cast <bool> (Loc.isValid() && "point of instantiation must be valid!"
) ? void (0) : __assert_fail ("Loc.isValid() && \"point of instantiation must be valid!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 2607, __extension__ __PRETTY_FUNCTION__));
  PointOfInstantiation = Loc;
}

void setCompleteDefinition() { IsCompleteDefinition = true; }

/// \brief If this variable template specialization is an instantiation of
/// a template (rather than an explicit specialization), return the
/// variable template or variable template partial specialization from which
/// it was instantiated.
llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
getInstantiatedFrom() const {
  if (!isTemplateInstantiation(getSpecializationKind()))
    return llvm::PointerUnion<VarTemplateDecl *,
                              VarTemplatePartialSpecializationDecl *>();

  return getSpecializedTemplateOrPartial();
}

/// \brief Retrieve the variable template or variable template partial
/// specialization which was specialized by this.
llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
getSpecializedTemplateOrPartial() const {
  if (SpecializedPartialSpecialization *PartialSpec =
          SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
    return PartialSpec->PartialSpecialization;

  return SpecializedTemplate.get<VarTemplateDecl *>();
}

/// \brief Retrieve the set of template arguments that should be used
/// to instantiate the initializer of the variable template or variable
/// template partial specialization from which this variable template
/// specialization was instantiated.
///
/// \returns For a variable template specialization instantiated from the
/// primary template, this function will return the same template arguments
/// as getTemplateArgs(). For a variable template specialization instantiated
/// from a variable template partial specialization, this function will the
/// return deduced template arguments for the variable template partial
/// specialization itself.
const TemplateArgumentList &getTemplateInstantiationArgs() const {
  if (SpecializedPartialSpecialization *PartialSpec =
          SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
    return *PartialSpec->TemplateArgs;

  return getTemplateArgs();
}

/// \brief Note that this variable template specialization is actually an
/// instantiation of the given variable template partial specialization whose
/// template arguments have been deduced.
void setInstantiationOf(VarTemplatePartialSpecializationDecl *PartialSpec,
                        const TemplateArgumentList *TemplateArgs) {
  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&(static_cast <bool> (!SpecializedTemplate.is<SpecializedPartialSpecialization
 *>() && "Already set to a variable template partial specialization!"
) ? void (0) : __assert_fail ("!SpecializedTemplate.is<SpecializedPartialSpecialization *>() && \"Already set to a variable template partial specialization!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 2662, __extension__ __PRETTY_FUNCTION__))
         "Already set to a variable template partial specialization!")(static_cast <bool> (!SpecializedTemplate.is<SpecializedPartialSpecialization
 *>() && "Already set to a variable template partial specialization!"
) ? void (0) : __assert_fail ("!SpecializedTemplate.is<SpecializedPartialSpecialization *>() && \"Already set to a variable template partial specialization!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 2662, __extension__ __PRETTY_FUNCTION__));
  SpecializedPartialSpecialization *PS =
      new (getASTContext()) SpecializedPartialSpecialization();
  PS->PartialSpecialization = PartialSpec;
  PS->TemplateArgs = TemplateArgs;
  SpecializedTemplate = PS;
}

/// \brief Note that this variable template specialization is an instantiation
/// of the given variable template.
void setInstantiationOf(VarTemplateDecl *TemplDecl) {
  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&(static_cast <bool> (!SpecializedTemplate.is<SpecializedPartialSpecialization
 *>() && "Previously set to a variable template partial specialization!"
) ? void (0) : __assert_fail ("!SpecializedTemplate.is<SpecializedPartialSpecialization *>() && \"Previously set to a variable template partial specialization!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 2674, __extension__ __PRETTY_FUNCTION__))
         "Previously set to a variable template partial specialization!")(static_cast <bool> (!SpecializedTemplate.is<SpecializedPartialSpecialization
 *>() && "Previously set to a variable template partial specialization!"
) ? void (0) : __assert_fail ("!SpecializedTemplate.is<SpecializedPartialSpecialization *>() && \"Previously set to a variable template partial specialization!\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 2674, __extension__ __PRETTY_FUNCTION__));
  SpecializedTemplate = TemplDecl;
}

/// \brief Sets the type of this specialization as it was written by
/// the user.
void setTypeAsWritten(TypeSourceInfo *T) {
  if (!ExplicitInfo)
    ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
  ExplicitInfo->TypeAsWritten = T;
}

/// \brief Gets the type of this specialization as it was written by
/// the user, if it was so written.
TypeSourceInfo *getTypeAsWritten() const {
  return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
}

/// \brief Gets the location of the extern keyword, if present.
SourceLocation getExternLoc() const {
  return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
}

/// \brief Sets the location of the extern keyword.
void setExternLoc(SourceLocation Loc) {
  if (!ExplicitInfo)
    ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
  ExplicitInfo->ExternLoc = Loc;
}

/// \brief Sets the location of the template keyword.
void setTemplateKeywordLoc(SourceLocation Loc) {
  if (!ExplicitInfo)
    ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
  ExplicitInfo->TemplateKeywordLoc = Loc;
}

/// \brief Gets the location of the template keyword, if present.
SourceLocation getTemplateKeywordLoc() const {
  return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
}

void Profile(llvm::FoldingSetNodeID &ID) const {
  Profile(ID, TemplateArgs->asArray(), getASTContext());
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    ArrayRef<TemplateArgument> TemplateArgs,
                    ASTContext &Context) {
  ID.AddInteger(TemplateArgs.size());
  for (const TemplateArgument &TemplateArg : TemplateArgs)
    TemplateArg.Profile(ID, Context);
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }

static bool classofKind(Kind K) {
  return K >= firstVarTemplateSpecialization &&
         K <= lastVarTemplateSpecialization;
}
2734};

2736class VarTemplatePartialSpecializationDecl
  : public VarTemplateSpecializationDecl {
/// \brief The list of template parameters
TemplateParameterList *TemplateParams = nullptr;

/// \brief The source info for the template arguments as written.
/// FIXME: redundant with TypeAsWritten?
const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;

/// \brief The variable template partial specialization from which this
/// variable template partial specialization was instantiated.
///
/// The boolean value will be true to indicate that this variable template
/// partial specialization was specialized at this level.
llvm::PointerIntPair<VarTemplatePartialSpecializationDecl *, 1, bool>
InstantiatedFromMember;

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);

VarTemplatePartialSpecializationDecl(ASTContext &Context)
    : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization,
                                    Context),
      InstantiatedFromMember(nullptr, false) {}

void anchor() override;

2767public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static VarTemplatePartialSpecializationDecl *
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);

static VarTemplatePartialSpecializationDecl *CreateDeserialized(ASTContext &C,
                                                                unsigned ID);

VarTemplatePartialSpecializationDecl *getMostRecentDecl() {
  return cast<VarTemplatePartialSpecializationDecl>(
           static_cast<VarTemplateSpecializationDecl *>(
             this)->getMostRecentDecl());
}

/// Get the list of template parameters
TemplateParameterList *getTemplateParameters() const {
  return TemplateParams;
}

/// Get the template arguments as written.
const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
  return ArgsAsWritten;
}

/// \brief Retrieve the member variable template partial specialization from
/// which this particular variable template partial specialization was
/// instantiated.
///
/// \code
/// template<typename T>
/// struct Outer {
///   template<typename U> U Inner;
///   template<typename U> U* Inner<U*> = (U*)(0); // #1
/// };
///
/// template int* Outer<float>::Inner<int*>;
/// \endcode
///
/// In this example, the instantiation of \c Outer<float>::Inner<int*> will
/// end up instantiating the partial specialization
/// \c Outer<float>::Inner<U*>, which itself was instantiated from the
/// variable template partial specialization \c Outer<T>::Inner<U*>. Given
/// \c Outer<float>::Inner<U*>, this function would return
/// \c Outer<T>::Inner<U*>.
VarTemplatePartialSpecializationDecl *getInstantiatedFromMember() const {
  const VarTemplatePartialSpecializationDecl *First =
      cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
  return First->InstantiatedFromMember.getPointer();
}

void
setInstantiatedFromMember(VarTemplatePartialSpecializationDecl *PartialSpec) {
  VarTemplatePartialSpecializationDecl *First =
      cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
  First->InstantiatedFromMember.setPointer(PartialSpec);
}

/// \brief Determines whether this variable template partial specialization
/// was a specialization of a member partial specialization.
///
/// In the following example, the member template partial specialization
/// \c X<int>::Inner<T*> is a member specialization.
///
/// \code
/// template<typename T>
/// struct X {
///   template<typename U> U Inner;
///   template<typename U> U* Inner<U*> = (U*)(0);
/// };
///
/// template<> template<typename T>
/// U* X<int>::Inner<T*> = (T*)(0) + 1;
/// \endcode
bool isMemberSpecialization() {
  VarTemplatePartialSpecializationDecl *First =
      cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
  return First->InstantiatedFromMember.getInt();
}

/// \brief Note that this member template is a specialization.
void setMemberSpecialization() {
  VarTemplatePartialSpecializationDecl *First =
      cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
  assert(First->InstantiatedFromMember.getPointer() &&(static_cast <bool> (First->InstantiatedFromMember.getPointer
() && "Only member templates can be member template specializations"
) ? void (0) : __assert_fail ("First->InstantiatedFromMember.getPointer() && \"Only member templates can be member template specializations\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 2857, __extension__ __PRETTY_FUNCTION__))
         "Only member templates can be member template specializations")(static_cast <bool> (First->InstantiatedFromMember.getPointer
() && "Only member templates can be member template specializations"
) ? void (0) : __assert_fail ("First->InstantiatedFromMember.getPointer() && \"Only member templates can be member template specializations\""
, "/build/llvm-toolchain-snapshot-7~svn326061/tools/clang/include/clang/AST/DeclTemplate.h"
, 2857, __extension__ __PRETTY_FUNCTION__));
  return First->InstantiatedFromMember.setInt(true);
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }

static bool classofKind(Kind K) {
  return K == VarTemplatePartialSpecialization;
}
2866};

2868/// Declaration of a variable template.
2869class VarTemplateDecl : public RedeclarableTemplateDecl {
2870protected:
/// \brief Data that is common to all of the declarations of a given
/// variable template.
struct Common : CommonBase {
  /// \brief The variable template specializations for this variable
  /// template, including explicit specializations and instantiations.
  llvm::FoldingSetVector<VarTemplateSpecializationDecl> Specializations;

  /// \brief The variable template partial specializations for this variable
  /// template.
  llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl>
  PartialSpecializations;

  Common() = default;
};

/// \brief Retrieve the set of specializations of this variable template.
llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
getSpecializations() const;

/// \brief Retrieve the set of partial specializations of this class
/// template.
llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
getPartialSpecializations();

VarTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
                DeclarationName Name, TemplateParameterList *Params,
                NamedDecl *Decl)
    : RedeclarableTemplateDecl(VarTemplate, C, DC, L, Name, Params, Decl) {}

CommonBase *newCommon(ASTContext &C) const override;

Common *getCommonPtr() const {
  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
}

2906public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

/// \brief Load any lazily-loaded specializations from the external source.
void LoadLazySpecializations() const;

/// \brief Get the underlying variable declarations of the template.
VarDecl *getTemplatedDecl() const {
  return static_cast<VarDecl *>(TemplatedDecl);
}

/// \brief Returns whether this template declaration defines the primary
/// variable pattern.
bool isThisDeclarationADefinition() const {
  return getTemplatedDecl()->isThisDeclarationADefinition();
}

VarTemplateDecl *getDefinition();

/// \brief Create a variable template node.
static VarTemplateDecl *Create(ASTContext &C, DeclContext *DC,
                               SourceLocation L, DeclarationName Name,
                               TemplateParameterList *Params,
                               VarDecl *Decl);

/// \brief Create an empty variable template node.
static VarTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);

/// \brief Return the specialization with the provided arguments if it exists,
/// otherwise return the insertion point.
VarTemplateSpecializationDecl *
findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);

/// \brief Insert the specified specialization knowing that it is not already
/// in. InsertPos must be obtained from findSpecialization.
void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos);

VarTemplateDecl *getCanonicalDecl() override {
  return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
}
const VarTemplateDecl *getCanonicalDecl() const {
  return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
}

/// \brief Retrieve the previous declaration of this variable template, or
/// nullptr if no such declaration exists.
VarTemplateDecl *getPreviousDecl() {
  return cast_or_null<VarTemplateDecl>(
      static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
}
const VarTemplateDecl *getPreviousDecl() const {
  return cast_or_null<VarTemplateDecl>(
          static_cast<const RedeclarableTemplateDecl *>(
            this)->getPreviousDecl());
}

VarTemplateDecl *getMostRecentDecl() {
  return cast<VarTemplateDecl>(
      static_cast<RedeclarableTemplateDecl *>(this)->getMostRecentDecl());
}
const VarTemplateDecl *getMostRecentDecl() const {
  return const_cast<VarTemplateDecl *>(this)->getMostRecentDecl();
}

VarTemplateDecl *getInstantiatedFromMemberTemplate() const {
  return cast_or_null<VarTemplateDecl>(
      RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
}

/// \brief Return the partial specialization with the provided arguments if it
/// exists, otherwise return the insertion point.
VarTemplatePartialSpecializationDecl *
findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);

/// \brief Insert the specified partial specialization knowing that it is not
/// already in. InsertPos must be obtained from findPartialSpecialization.
void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D,
                              void *InsertPos);

/// \brief Retrieve the partial specializations as an ordered list.
void getPartialSpecializations(
    SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS);

/// \brief Find a variable template partial specialization which was
/// instantiated
/// from the given member partial specialization.
///
/// \param D a member variable template partial specialization.
///
/// \returns the variable template partial specialization which was
/// instantiated
/// from the given member partial specialization, or nullptr if no such
/// partial specialization exists.
VarTemplatePartialSpecializationDecl *findPartialSpecInstantiatedFromMember(
    VarTemplatePartialSpecializationDecl *D);

using spec_iterator = SpecIterator<VarTemplateSpecializationDecl>;
using spec_range = llvm::iterator_range<spec_iterator>;

spec_range specializations() const {
  return spec_range(spec_begin(), spec_end());
}

spec_iterator spec_begin() const {
  return makeSpecIterator(getSpecializations(), false);
}

spec_iterator spec_end() const {
  return makeSpecIterator(getSpecializations(), true);
}

// Implement isa/cast/dyncast support
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == VarTemplate; }
3021};

3023inline NamedDecl *getAsNamedDecl(TemplateParameter P) {
if (auto *PD = P.dyn_cast<TemplateTypeParmDecl*>())
  return PD;
if (auto *PD = P.dyn_cast<NonTypeTemplateParmDecl*>())
  return PD;
return P.get<TemplateTemplateParmDecl*>();
3029}

3031inline TemplateDecl *getAsTypeTemplateDecl(Decl *D) {
auto *TD = dyn_cast<TemplateDecl>(D);
return TD && (isa<ClassTemplateDecl>(TD) ||
              isa<ClassTemplatePartialSpecializationDecl>(TD) ||
              isa<TypeAliasTemplateDecl>(TD) ||
              isa<TemplateTemplateParmDecl>(TD))
           ? TD
           : nullptr;
3039}

3041} // namespace clang

3043#endif // LLVM_CLANG_AST_DECLTEMPLATE_H