/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp

Bug Summary

File:	tools/clang/lib/Sema/SemaTemplateInstantiate.cpp
Warning:	line 1827, column 31 Access to field 'PartialSpecialization' results in a dereference of a null pointer (loaded from variable 'PS')

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 SemaTemplateInstantiate.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~svn326551/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn326551/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326551/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326551/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326551/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~svn326551/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-03-02-155150-1477-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp

/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp

→

1//===------- SemaTemplateInstantiate.cpp - C++ Template 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.
10//
11//===----------------------------------------------------------------------===/

13#include "clang/Sema/SemaInternal.h"
14#include "TreeTransform.h"
15#include "clang/AST/ASTConsumer.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/ASTLambda.h"
18#include "clang/AST/ASTMutationListener.h"
19#include "clang/AST/DeclTemplate.h"
20#include "clang/AST/Expr.h"
21#include "clang/Basic/LangOptions.h"
22#include "clang/Sema/DeclSpec.h"
23#include "clang/Sema/Initialization.h"
24#include "clang/Sema/Lookup.h"
25#include "clang/Sema/PrettyDeclStackTrace.h"
26#include "clang/Sema/Template.h"
27#include "clang/Sema/TemplateDeduction.h"
28#include "clang/Sema/TemplateInstCallback.h"

30using namespace clang;
31using namespace sema;

33//===----------------------------------------------------------------------===/
34// Template Instantiation Support
35//===----------------------------------------------------------------------===/

37/// \brief Retrieve the template argument list(s) that should be used to
38/// instantiate the definition of the given declaration.
39///
40/// \param D the declaration for which we are computing template instantiation
41/// arguments.
42///
43/// \param Innermost if non-NULL, the innermost template argument list.
44///
45/// \param RelativeToPrimary true if we should get the template
46/// arguments relative to the primary template, even when we're
47/// dealing with a specialization. This is only relevant for function
48/// template specializations.
49///
50/// \param Pattern If non-NULL, indicates the pattern from which we will be
51/// instantiating the definition of the given declaration, \p D. This is
52/// used to determine the proper set of template instantiation arguments for
53/// friend function template specializations.
54MultiLevelTemplateArgumentList
55Sema::getTemplateInstantiationArgs(NamedDecl *D, 
                                 const TemplateArgumentList *Innermost,
                                 bool RelativeToPrimary,
                                 const FunctionDecl *Pattern) {
// Accumulate the set of template argument lists in this structure.
MultiLevelTemplateArgumentList Result;

if (Innermost)
  Result.addOuterTemplateArguments(Innermost);

DeclContext *Ctx = dyn_cast<DeclContext>(D);
if (!Ctx) {
  Ctx = D->getDeclContext();

  // Add template arguments from a variable template instantiation.
  if (VarTemplateSpecializationDecl *Spec =
          dyn_cast<VarTemplateSpecializationDecl>(D)) {
    // We're done when we hit an explicit specialization.
    if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
        !isa<VarTemplatePartialSpecializationDecl>(Spec))
      return Result;

    Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());

    // If this variable template specialization was instantiated from a
    // specialized member that is a variable template, we're done.
    assert(Spec->getSpecializedTemplate() && "No variable template?")(static_cast <bool> (Spec->getSpecializedTemplate() &&
 "No variable template?") ? void (0) : __assert_fail ("Spec->getSpecializedTemplate() && \"No variable template?\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 81, __extension__ __PRETTY_FUNCTION__));
    llvm::PointerUnion<VarTemplateDecl*,
                       VarTemplatePartialSpecializationDecl*> Specialized
                           = Spec->getSpecializedTemplateOrPartial();
    if (VarTemplatePartialSpecializationDecl *Partial =
            Specialized.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
      if (Partial->isMemberSpecialization())
        return Result;
    } else {
      VarTemplateDecl *Tmpl = Specialized.get<VarTemplateDecl *>();
      if (Tmpl->isMemberSpecialization())
        return Result;
    }
  }

  // If we have a template template parameter with translation unit context,
  // then we're performing substitution into a default template argument of
  // this template template parameter before we've constructed the template
  // that will own this template template parameter. In this case, we
  // use empty template parameter lists for all of the outer templates
  // to avoid performing any substitutions.
  if (Ctx->isTranslationUnit()) {
    if (TemplateTemplateParmDecl *TTP 
                                    = dyn_cast<TemplateTemplateParmDecl>(D)) {
      for (unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I)
        Result.addOuterTemplateArguments(None);
      return Result;
    }
  }
}

while (!Ctx->isFileContext()) {
  // Add template arguments from a class template instantiation.
  if (ClassTemplateSpecializationDecl *Spec
        = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) {
    // We're done when we hit an explicit specialization.
    if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
        !isa<ClassTemplatePartialSpecializationDecl>(Spec))
      break;

    Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
    
    // If this class template specialization was instantiated from a 
    // specialized member that is a class template, we're done.
    assert(Spec->getSpecializedTemplate() && "No class template?")(static_cast <bool> (Spec->getSpecializedTemplate() &&
 "No class template?") ? void (0) : __assert_fail ("Spec->getSpecializedTemplate() && \"No class template?\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 125, __extension__ __PRETTY_FUNCTION__));
    if (Spec->getSpecializedTemplate()->isMemberSpecialization())
      break;
  }
  // Add template arguments from a function template specialization.
  else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
    if (!RelativeToPrimary &&
        (Function->getTemplateSpecializationKind() == 
                                                TSK_ExplicitSpecialization &&
         !Function->getClassScopeSpecializationPattern()))
      break;
        
    if (const TemplateArgumentList *TemplateArgs
          = Function->getTemplateSpecializationArgs()) {
      // Add the template arguments for this specialization.
      Result.addOuterTemplateArguments(TemplateArgs);

      // If this function was instantiated from a specialized member that is
      // a function template, we're done.
      assert(Function->getPrimaryTemplate() && "No function template?")(static_cast <bool> (Function->getPrimaryTemplate() &&
 "No function template?") ? void (0) : __assert_fail ("Function->getPrimaryTemplate() && \"No function template?\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 144, __extension__ __PRETTY_FUNCTION__));
      if (Function->getPrimaryTemplate()->isMemberSpecialization())
        break;

      // If this function is a generic lambda specialization, we are done.
      if (isGenericLambdaCallOperatorSpecialization(Function))
        break;

    } else if (FunctionTemplateDecl *FunTmpl
                                 = Function->getDescribedFunctionTemplate()) {
      // Add the "injected" template arguments.
      Result.addOuterTemplateArguments(FunTmpl->getInjectedTemplateArgs());
    }
    
    // If this is a friend declaration and it declares an entity at
    // namespace scope, take arguments from its lexical parent
    // instead of its semantic parent, unless of course the pattern we're
    // instantiating actually comes from the file's context!
    if (Function->getFriendObjectKind() &&
        Function->getDeclContext()->isFileContext() &&
        (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
      Ctx = Function->getLexicalDeclContext();
      RelativeToPrimary = false;
      continue;
    }
  } else if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
    if (ClassTemplateDecl *ClassTemplate = Rec->getDescribedClassTemplate()) {
      QualType T = ClassTemplate->getInjectedClassNameSpecialization();
      const TemplateSpecializationType *TST =
          cast<TemplateSpecializationType>(Context.getCanonicalType(T));
      Result.addOuterTemplateArguments(
          llvm::makeArrayRef(TST->getArgs(), TST->getNumArgs()));
      if (ClassTemplate->isMemberSpecialization())
        break;
    }
  }

  Ctx = Ctx->getParent();
  RelativeToPrimary = false;
}

return Result;
186}

188bool Sema::CodeSynthesisContext::isInstantiationRecord() const {
switch (Kind) {
case TemplateInstantiation:
case ExceptionSpecInstantiation:
case DefaultTemplateArgumentInstantiation:
case DefaultFunctionArgumentInstantiation:
case ExplicitTemplateArgumentSubstitution:
case DeducedTemplateArgumentSubstitution:
case PriorTemplateArgumentSubstitution:
  return true;

case DefaultTemplateArgumentChecking:
case DeclaringSpecialMember:
case DefiningSynthesizedFunction:
  return false;
     
// This function should never be called when Kind's value is Memoization.
case Memoization:
  break;
}

llvm_unreachable("Invalid SynthesisKind!")::llvm::llvm_unreachable_internal("Invalid SynthesisKind!", "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 209);
210}

212Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,
  SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
  Decl *Entity, NamedDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
  sema::TemplateDeductionInfo *DeductionInfo)
  : SemaRef(SemaRef) {
// Don't allow further instantiation if a fatal error and an uncompilable
// error have occurred. Any diagnostics we might have raised will not be
// visible, and we do not need to construct a correct AST.
if (SemaRef.Diags.hasFatalErrorOccurred() &&
    SemaRef.Diags.hasUncompilableErrorOccurred()) {
  Invalid = true;
  return;
}
Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
if (!Invalid) {
  CodeSynthesisContext Inst;
  Inst.Kind = Kind;
  Inst.PointOfInstantiation = PointOfInstantiation;
  Inst.Entity = Entity;
  Inst.Template = Template;
  Inst.TemplateArgs = TemplateArgs.data();
  Inst.NumTemplateArgs = TemplateArgs.size();
  Inst.DeductionInfo = DeductionInfo;
  Inst.InstantiationRange = InstantiationRange;
  SemaRef.pushCodeSynthesisContext(Inst);

  AlreadyInstantiating =
      !SemaRef.InstantiatingSpecializations
           .insert(std::make_pair(Inst.Entity->getCanonicalDecl(), Inst.Kind))
           .second;
  atTemplateBegin(SemaRef.TemplateInstCallbacks, SemaRef, Inst);
}
245}

247Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, Decl *Entity,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(SemaRef,
                          CodeSynthesisContext::TemplateInstantiation,
                          PointOfInstantiation, InstantiationRange, Entity) {}

254Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, FunctionDecl *Entity,
  ExceptionSpecification, SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef, CodeSynthesisContext::ExceptionSpecInstantiation,
        PointOfInstantiation, InstantiationRange, Entity) {}

261Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateParameter Param,
  TemplateDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::DefaultTemplateArgumentInstantiation,
        PointOfInstantiation, InstantiationRange, getAsNamedDecl(Param),
        Template, TemplateArgs) {}

271Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  FunctionTemplateDecl *FunctionTemplate,
  ArrayRef<TemplateArgument> TemplateArgs,
  CodeSynthesisContext::SynthesisKind Kind,
  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
  : InstantiatingTemplate(SemaRef, Kind, PointOfInstantiation,
                          InstantiationRange, FunctionTemplate, nullptr,
                          TemplateArgs, &DeductionInfo) {
assert((static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
 || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 282, __extension__ __PRETTY_FUNCTION__))
  Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution ||(static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
 || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 282, __extension__ __PRETTY_FUNCTION__))
  Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution)(static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
 || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 282, __extension__ __PRETTY_FUNCTION__));
283}

285Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  TemplateDecl *Template,
  ArrayRef<TemplateArgument> TemplateArgs,
  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
        PointOfInstantiation, InstantiationRange, Template, nullptr,
        TemplateArgs, &DeductionInfo) {}

296Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  ClassTemplatePartialSpecializationDecl *PartialSpec,
  ArrayRef<TemplateArgument> TemplateArgs,
  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
        PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
        TemplateArgs, &DeductionInfo) {}

307Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  VarTemplatePartialSpecializationDecl *PartialSpec,
  ArrayRef<TemplateArgument> TemplateArgs,
  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
        PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
        TemplateArgs, &DeductionInfo) {}

318Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, ParmVarDecl *Param,
  ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::DefaultFunctionArgumentInstantiation,
        PointOfInstantiation, InstantiationRange, Param, nullptr,
        TemplateArgs) {}

327Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
  NonTypeTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::PriorTemplateArgumentSubstitution,
        PointOfInstantiation, InstantiationRange, Param, Template,
        TemplateArgs) {}

337Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
  TemplateTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::PriorTemplateArgumentSubstitution,
        PointOfInstantiation, InstantiationRange, Param, Template,
        TemplateArgs) {}

347Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateDecl *Template,
  NamedDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef, CodeSynthesisContext::DefaultTemplateArgumentChecking,
        PointOfInstantiation, InstantiationRange, Param, Template,
        TemplateArgs) {}

356void Sema::pushCodeSynthesisContext(CodeSynthesisContext Ctx) {
Ctx.SavedInNonInstantiationSFINAEContext = InNonInstantiationSFINAEContext;
InNonInstantiationSFINAEContext = false;

CodeSynthesisContexts.push_back(Ctx);

if (!Ctx.isInstantiationRecord())
  ++NonInstantiationEntries;
364}

366void Sema::popCodeSynthesisContext() {
auto &Active = CodeSynthesisContexts.back();
if (!Active.isInstantiationRecord()) {
  assert(NonInstantiationEntries > 0)(static_cast <bool> (NonInstantiationEntries > 0) ? void
 (0) : __assert_fail ("NonInstantiationEntries > 0", "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 369, __extension__ __PRETTY_FUNCTION__));
  --NonInstantiationEntries;
}

InNonInstantiationSFINAEContext = Active.SavedInNonInstantiationSFINAEContext;

// Name lookup no longer looks in this template's defining module.
assert(CodeSynthesisContexts.size() >=(static_cast <bool> (CodeSynthesisContexts.size() >=
 CodeSynthesisContextLookupModules.size() && "forgot to remove a lookup module for a template instantiation"
) ? void (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 378, __extension__ __PRETTY_FUNCTION__))
           CodeSynthesisContextLookupModules.size() &&(static_cast <bool> (CodeSynthesisContexts.size() >=
 CodeSynthesisContextLookupModules.size() && "forgot to remove a lookup module for a template instantiation"
) ? void (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 378, __extension__ __PRETTY_FUNCTION__))
       "forgot to remove a lookup module for a template instantiation")(static_cast <bool> (CodeSynthesisContexts.size() >=
 CodeSynthesisContextLookupModules.size() && "forgot to remove a lookup module for a template instantiation"
) ? void (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 378, __extension__ __PRETTY_FUNCTION__));
if (CodeSynthesisContexts.size() ==
    CodeSynthesisContextLookupModules.size()) {
  if (Module *M = CodeSynthesisContextLookupModules.back())
    LookupModulesCache.erase(M);
  CodeSynthesisContextLookupModules.pop_back();
}

// If we've left the code synthesis context for the current context stack,
// stop remembering that we've emitted that stack.
if (CodeSynthesisContexts.size() ==
    LastEmittedCodeSynthesisContextDepth)
  LastEmittedCodeSynthesisContextDepth = 0;

CodeSynthesisContexts.pop_back();
393}

395void Sema::InstantiatingTemplate::Clear() {
if (!Invalid) {
  if (!AlreadyInstantiating) {
    auto &Active = SemaRef.CodeSynthesisContexts.back();
    SemaRef.InstantiatingSpecializations.erase(
        std::make_pair(Active.Entity, Active.Kind));
  }

  atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef,
                SemaRef.CodeSynthesisContexts.back());

  SemaRef.popCodeSynthesisContext();
  Invalid = true;
}
409}

411bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
                                      SourceLocation PointOfInstantiation,
                                         SourceRange InstantiationRange) {
assert(SemaRef.NonInstantiationEntries <=(static_cast <bool> (SemaRef.NonInstantiationEntries <=
 SemaRef.CodeSynthesisContexts.size()) ? void (0) : __assert_fail
 ("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 415, __extension__ __PRETTY_FUNCTION__))
       SemaRef.CodeSynthesisContexts.size())(static_cast <bool> (SemaRef.NonInstantiationEntries <=
 SemaRef.CodeSynthesisContexts.size()) ? void (0) : __assert_fail
 ("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 415, __extension__ __PRETTY_FUNCTION__));
if ((SemaRef.CodeSynthesisContexts.size() - 
        SemaRef.NonInstantiationEntries)
      <= SemaRef.getLangOpts().InstantiationDepth)
  return false;

SemaRef.Diag(PointOfInstantiation,
             diag::err_template_recursion_depth_exceeded)
  << SemaRef.getLangOpts().InstantiationDepth
  << InstantiationRange;
SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth)
  << SemaRef.getLangOpts().InstantiationDepth;
return true;
428}

430/// \brief Prints the current instantiation stack through a series of
431/// notes.
432void Sema::PrintInstantiationStack() {
// Determine which template instantiations to skip, if any.
unsigned SkipStart = CodeSynthesisContexts.size(), SkipEnd = SkipStart;
unsigned Limit = Diags.getTemplateBacktraceLimit();
if (Limit && Limit < CodeSynthesisContexts.size()) {
  SkipStart = Limit / 2 + Limit % 2;
  SkipEnd = CodeSynthesisContexts.size() - Limit / 2;
}

// FIXME: In all of these cases, we need to show the template arguments
unsigned InstantiationIdx = 0;
for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator
       Active = CodeSynthesisContexts.rbegin(),
       ActiveEnd = CodeSynthesisContexts.rend();
     Active != ActiveEnd;
     ++Active, ++InstantiationIdx) {
  // Skip this instantiation?
  if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
    if (InstantiationIdx == SkipStart) {
      // Note that we're skipping instantiations.
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_instantiation_contexts_suppressed)
        << unsigned(CodeSynthesisContexts.size() - Limit);
    }
    continue;
  }

  switch (Active->Kind) {
  case CodeSynthesisContext::TemplateInstantiation: {
    Decl *D = Active->Entity;
    if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
      unsigned DiagID = diag::note_template_member_class_here;
      if (isa<ClassTemplateSpecializationDecl>(Record))
        DiagID = diag::note_template_class_instantiation_here;
      Diags.Report(Active->PointOfInstantiation, DiagID)
        << Record << Active->InstantiationRange;
    } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
      unsigned DiagID;
      if (Function->getPrimaryTemplate())
        DiagID = diag::note_function_template_spec_here;
      else
        DiagID = diag::note_template_member_function_here;
      Diags.Report(Active->PointOfInstantiation, DiagID)
        << Function
        << Active->InstantiationRange;
    } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
      Diags.Report(Active->PointOfInstantiation,
                   VD->isStaticDataMember()?
                     diag::note_template_static_data_member_def_here
                   : diag::note_template_variable_def_here)
        << VD
        << Active->InstantiationRange;
    } else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_template_enum_def_here)
        << ED
        << Active->InstantiationRange;
    } else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_template_nsdmi_here)
          << FD << Active->InstantiationRange;
    } else {
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_template_type_alias_instantiation_here)
        << cast<TypeAliasTemplateDecl>(D)
        << Active->InstantiationRange;
    }
    break;
  }

  case CodeSynthesisContext::DefaultTemplateArgumentInstantiation: {
    TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
    SmallVector<char, 128> TemplateArgsStr;
    llvm::raw_svector_ostream OS(TemplateArgsStr);
    Template->printName(OS);
    printTemplateArgumentList(OS, Active->template_arguments(),
                              getPrintingPolicy());
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_default_arg_instantiation_here)
      << OS.str()
      << Active->InstantiationRange;
    break;
  }

  case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution: {
    FunctionTemplateDecl *FnTmpl = cast<FunctionTemplateDecl>(Active->Entity);
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_explicit_template_arg_substitution_here)
      << FnTmpl 
      << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(), 
                                         Active->TemplateArgs, 
                                         Active->NumTemplateArgs)
      << Active->InstantiationRange;
    break;
  }

  case CodeSynthesisContext::DeducedTemplateArgumentSubstitution: {
    if (FunctionTemplateDecl *FnTmpl =
            dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_function_template_deduction_instantiation_here)
        << FnTmpl
        << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(), 
                                           Active->TemplateArgs, 
                                           Active->NumTemplateArgs)
        << Active->InstantiationRange;
    } else {
      bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
                   isa<VarTemplateSpecializationDecl>(Active->Entity);
      bool IsTemplate = false;
      TemplateParameterList *Params;
      if (auto *D = dyn_cast<TemplateDecl>(Active->Entity)) {
        IsTemplate = true;
        Params = D->getTemplateParameters();
      } else if (auto *D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
                     Active->Entity)) {
        Params = D->getTemplateParameters();
      } else if (auto *D = dyn_cast<VarTemplatePartialSpecializationDecl>(
                     Active->Entity)) {
        Params = D->getTemplateParameters();
      } else {
        llvm_unreachable("unexpected template kind")::llvm::llvm_unreachable_internal("unexpected template kind",
 "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 553);
      }

      Diags.Report(Active->PointOfInstantiation,
                   diag::note_deduced_template_arg_substitution_here)
        << IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)
        << getTemplateArgumentBindingsText(Params, Active->TemplateArgs, 
                                           Active->NumTemplateArgs)
        << Active->InstantiationRange;
    }
    break;
  }

  case CodeSynthesisContext::DefaultFunctionArgumentInstantiation: {
    ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
    FunctionDecl *FD = cast<FunctionDecl>(Param->getDeclContext());

    SmallVector<char, 128> TemplateArgsStr;
    llvm::raw_svector_ostream OS(TemplateArgsStr);
    FD->printName(OS);
    printTemplateArgumentList(OS, Active->template_arguments(),
                              getPrintingPolicy());
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_default_function_arg_instantiation_here)
      << OS.str()
      << Active->InstantiationRange;
    break;
  }

  case CodeSynthesisContext::PriorTemplateArgumentSubstitution: {
    NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
    std::string Name;
    if (!Parm->getName().empty())
      Name = std::string(" '") + Parm->getName().str() + "'";

    TemplateParameterList *TemplateParams = nullptr;
    if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
      TemplateParams = Template->getTemplateParameters();
    else
      TemplateParams =
        cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
                                                    ->getTemplateParameters();
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_prior_template_arg_substitution)
      << isa<TemplateTemplateParmDecl>(Parm)
      << Name
      << getTemplateArgumentBindingsText(TemplateParams, 
                                         Active->TemplateArgs, 
                                         Active->NumTemplateArgs)
      << Active->InstantiationRange;
    break;
  }

  case CodeSynthesisContext::DefaultTemplateArgumentChecking: {
    TemplateParameterList *TemplateParams = nullptr;
    if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
      TemplateParams = Template->getTemplateParameters();
    else
      TemplateParams =
        cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
                                                    ->getTemplateParameters();

    Diags.Report(Active->PointOfInstantiation,
                 diag::note_template_default_arg_checking)
      << getTemplateArgumentBindingsText(TemplateParams, 
                                         Active->TemplateArgs, 
                                         Active->NumTemplateArgs)
      << Active->InstantiationRange;
    break;
  }

  case CodeSynthesisContext::ExceptionSpecInstantiation:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_template_exception_spec_instantiation_here)
      << cast<FunctionDecl>(Active->Entity)
      << Active->InstantiationRange;
    break;

  case CodeSynthesisContext::DeclaringSpecialMember:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_in_declaration_of_implicit_special_member)
      << cast<CXXRecordDecl>(Active->Entity) << Active->SpecialMember;
    break;

  case CodeSynthesisContext::DefiningSynthesizedFunction: {
    // FIXME: For synthesized members other than special members, produce a note.
    auto *MD = dyn_cast<CXXMethodDecl>(Active->Entity);
    auto CSM = MD ? getSpecialMember(MD) : CXXInvalid;
    if (CSM != CXXInvalid) {
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_member_synthesized_at)
        << CSM << Context.getTagDeclType(MD->getParent());
    }
    break;
  }

  case CodeSynthesisContext::Memoization:
    break;
  }
}
653}

655Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const {
if (InNonInstantiationSFINAEContext)
  return Optional<TemplateDeductionInfo *>(nullptr);

for (SmallVectorImpl<CodeSynthesisContext>::const_reverse_iterator
       Active = CodeSynthesisContexts.rbegin(),
       ActiveEnd = CodeSynthesisContexts.rend();
     Active != ActiveEnd;
     ++Active) 
{
  switch (Active->Kind) {
  case CodeSynthesisContext::TemplateInstantiation:
    // An instantiation of an alias template may or may not be a SFINAE
    // context, depending on what else is on the stack.
    if (isa<TypeAliasTemplateDecl>(Active->Entity))
      break;
    // Fall through.
  case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
  case CodeSynthesisContext::ExceptionSpecInstantiation:
    // This is a template instantiation, so there is no SFINAE.
    return None;

  case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
  case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
  case CodeSynthesisContext::DefaultTemplateArgumentChecking:
    // A default template argument instantiation and substitution into
    // template parameters with arguments for prior parameters may or may 
    // not be a SFINAE context; look further up the stack.
    break;

  case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
  case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
    // We're either substitution explicitly-specified template arguments
    // or deduced template arguments, so SFINAE applies.
    assert(Active->DeductionInfo && "Missing deduction info pointer")(static_cast <bool> (Active->DeductionInfo &&
 "Missing deduction info pointer") ? void (0) : __assert_fail
 ("Active->DeductionInfo && \"Missing deduction info pointer\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 689, __extension__ __PRETTY_FUNCTION__));
    return Active->DeductionInfo;

  case CodeSynthesisContext::DeclaringSpecialMember:
  case CodeSynthesisContext::DefiningSynthesizedFunction:
    // This happens in a context unrelated to template instantiation, so
    // there is no SFINAE.
    return None;

  case CodeSynthesisContext::Memoization:
    break;
  }

  // The inner context was transparent for SFINAE. If it occurred within a
  // non-instantiation SFINAE context, then SFINAE applies.
  if (Active->SavedInNonInstantiationSFINAEContext)
    return Optional<TemplateDeductionInfo *>(nullptr);
}

return None;
709}

711/// \brief Retrieve the depth and index of a parameter pack.
712static std::pair<unsigned, unsigned> 
713getDepthAndIndex(NamedDecl *ND) {
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
  return std::make_pair(TTP->getDepth(), TTP->getIndex());

if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
  return std::make_pair(NTTP->getDepth(), NTTP->getIndex());

TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
return std::make_pair(TTP->getDepth(), TTP->getIndex());
722}

724//===----------------------------------------------------------------------===/
725// Template Instantiation for Types
726//===----------------------------------------------------------------------===/
727namespace {
class TemplateInstantiator : public TreeTransform<TemplateInstantiator> {
  const MultiLevelTemplateArgumentList &TemplateArgs;
  SourceLocation Loc;
  DeclarationName Entity;

public:
  typedef TreeTransform<TemplateInstantiator> inherited;

  TemplateInstantiator(Sema &SemaRef,
                       const MultiLevelTemplateArgumentList &TemplateArgs,
                       SourceLocation Loc,
                       DeclarationName Entity)
    : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
      Entity(Entity) { }

  /// \brief Determine whether the given type \p T has already been
  /// transformed.
  ///
  /// For the purposes of template instantiation, a type has already been
  /// transformed if it is NULL or if it is not dependent.
  bool AlreadyTransformed(QualType T);

  /// \brief Returns the location of the entity being instantiated, if known.
  SourceLocation getBaseLocation() { return Loc; }

  /// \brief Returns the name of the entity being instantiated, if any.
  DeclarationName getBaseEntity() { return Entity; }

  /// \brief Sets the "base" location and entity when that
  /// information is known based on another transformation.
  void setBase(SourceLocation Loc, DeclarationName Entity) {
    this->Loc = Loc;
    this->Entity = Entity;
  }

  bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
                               SourceRange PatternRange,
                               ArrayRef<UnexpandedParameterPack> Unexpanded,
                               bool &ShouldExpand, bool &RetainExpansion,
                               Optional<unsigned> &NumExpansions) {
    return getSema().CheckParameterPacksForExpansion(EllipsisLoc, 
                                                     PatternRange, Unexpanded,
                                                     TemplateArgs, 
                                                     ShouldExpand,
                                                     RetainExpansion,
                                                     NumExpansions);
  }

  void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { 
    SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(Pack);
  }
  
  TemplateArgument ForgetPartiallySubstitutedPack() {
    TemplateArgument Result;
    if (NamedDecl *PartialPack
          = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){
      MultiLevelTemplateArgumentList &TemplateArgs
        = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
      unsigned Depth, Index;
      std::tie(Depth, Index) = getDepthAndIndex(PartialPack);
      if (TemplateArgs.hasTemplateArgument(Depth, Index)) {
        Result = TemplateArgs(Depth, Index);
        TemplateArgs.setArgument(Depth, Index, TemplateArgument());
      }
    }
    
    return Result;
  }
  
  void RememberPartiallySubstitutedPack(TemplateArgument Arg) {
    if (Arg.isNull())
      return;
    
    if (NamedDecl *PartialPack
          = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){
      MultiLevelTemplateArgumentList &TemplateArgs
      = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
      unsigned Depth, Index;
      std::tie(Depth, Index) = getDepthAndIndex(PartialPack);
      TemplateArgs.setArgument(Depth, Index, Arg);
    }
  }

  /// \brief Transform the given declaration by instantiating a reference to
  /// this declaration.
  Decl *TransformDecl(SourceLocation Loc, Decl *D);

  void transformAttrs(Decl *Old, Decl *New) { 
    SemaRef.InstantiateAttrs(TemplateArgs, Old, New);
  }

  void transformedLocalDecl(Decl *Old, Decl *New) {
    // If we've instantiated the call operator of a lambda or the call
    // operator template of a generic lambda, update the "instantiation of"
    // information.
    auto *NewMD = dyn_cast<CXXMethodDecl>(New);
    if (NewMD && isLambdaCallOperator(NewMD)) {
      auto *OldMD = dyn_cast<CXXMethodDecl>(Old);
      if (auto *NewTD = NewMD->getDescribedFunctionTemplate())
        NewTD->setInstantiatedFromMemberTemplate(
            OldMD->getDescribedFunctionTemplate());
      else
        NewMD->setInstantiationOfMemberFunction(OldMD,
                                                TSK_ImplicitInstantiation);
    }
    
    SemaRef.CurrentInstantiationScope->InstantiatedLocal(Old, New);

    // We recreated a local declaration, but not by instantiating it. There
    // may be pending dependent diagnostics to produce.
    if (auto *DC = dyn_cast<DeclContext>(Old))
      SemaRef.PerformDependentDiagnostics(DC, TemplateArgs);
  }
  
  /// \brief Transform the definition of the given declaration by
  /// instantiating it.
  Decl *TransformDefinition(SourceLocation Loc, Decl *D);

  /// \brief Transform the first qualifier within a scope by instantiating the
  /// declaration.
  NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc);
    
  /// \brief Rebuild the exception declaration and register the declaration
  /// as an instantiated local.
  VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, 
                                TypeSourceInfo *Declarator,
                                SourceLocation StartLoc,
                                SourceLocation NameLoc,
                                IdentifierInfo *Name);

  /// \brief Rebuild the Objective-C exception declaration and register the 
  /// declaration as an instantiated local.
  VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl, 
                                    TypeSourceInfo *TSInfo, QualType T);
    
  /// \brief Check for tag mismatches when instantiating an
  /// elaborated type.
  QualType RebuildElaboratedType(SourceLocation KeywordLoc,
                                 ElaboratedTypeKeyword Keyword,
                                 NestedNameSpecifierLoc QualifierLoc,
                                 QualType T);

  TemplateName
  TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
                        SourceLocation NameLoc,
                        QualType ObjectType = QualType(),
                        NamedDecl *FirstQualifierInScope = nullptr,
                        bool AllowInjectedClassName = false);

  const LoopHintAttr *TransformLoopHintAttr(const LoopHintAttr *LH);

  ExprResult TransformPredefinedExpr(PredefinedExpr *E);
  ExprResult TransformDeclRefExpr(DeclRefExpr *E);
  ExprResult TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E);

  ExprResult TransformTemplateParmRefExpr(DeclRefExpr *E,
                                          NonTypeTemplateParmDecl *D);
  ExprResult TransformSubstNonTypeTemplateParmPackExpr(
                                         SubstNonTypeTemplateParmPackExpr *E);

  /// \brief Rebuild a DeclRefExpr for a ParmVarDecl reference.
  ExprResult RebuildParmVarDeclRefExpr(ParmVarDecl *PD, SourceLocation Loc);

  /// \brief Transform a reference to a function parameter pack.
  ExprResult TransformFunctionParmPackRefExpr(DeclRefExpr *E,
                                              ParmVarDecl *PD);

  /// \brief Transform a FunctionParmPackExpr which was built when we couldn't
  /// expand a function parameter pack reference which refers to an expanded
  /// pack.
  ExprResult TransformFunctionParmPackExpr(FunctionParmPackExpr *E);

  QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
                                      FunctionProtoTypeLoc TL) {
    // Call the base version; it will forward to our overridden version below.
    return inherited::TransformFunctionProtoType(TLB, TL);
  }

  template<typename Fn>
  QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
                                      FunctionProtoTypeLoc TL,
                                      CXXRecordDecl *ThisContext,
                                      unsigned ThisTypeQuals,
                                      Fn TransformExceptionSpec);

  ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
                                          int indexAdjustment,
                                          Optional<unsigned> NumExpansions,
                                          bool ExpectParameterPack);

  /// \brief Transforms a template type parameter type by performing
  /// substitution of the corresponding template type argument.
  QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
                                         TemplateTypeParmTypeLoc TL);

  /// \brief Transforms an already-substituted template type parameter pack
  /// into either itself (if we aren't substituting into its pack expansion)
  /// or the appropriate substituted argument.
  QualType TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
                                         SubstTemplateTypeParmPackTypeLoc TL);

  ExprResult TransformLambdaExpr(LambdaExpr *E) {
    LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
    return TreeTransform<TemplateInstantiator>::TransformLambdaExpr(E);
  }

  TemplateParameterList *TransformTemplateParameterList(
                            TemplateParameterList *OrigTPL)  {
    if (!OrigTPL || !OrigTPL->size()) return OrigTPL;
       
    DeclContext *Owner = OrigTPL->getParam(0)->getDeclContext();
    TemplateDeclInstantiator  DeclInstantiator(getSema(), 
                      /* DeclContext *Owner */ Owner, TemplateArgs);
    return DeclInstantiator.SubstTemplateParams(OrigTPL); 
  }
private:
  ExprResult transformNonTypeTemplateParmRef(NonTypeTemplateParmDecl *parm,
                                             SourceLocation loc,
                                             TemplateArgument arg);
};
948}

950bool TemplateInstantiator::AlreadyTransformed(QualType T) {
if (T.isNull())
  return true;

if (T->isInstantiationDependentType() || T->isVariablyModifiedType())
  return false;

getSema().MarkDeclarationsReferencedInType(Loc, T);
return true;
959}

961static TemplateArgument
962getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg) {
assert(S.ArgumentPackSubstitutionIndex >= 0)(static_cast <bool> (S.ArgumentPackSubstitutionIndex >=
 0) ? void (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex >= 0"
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 963, __extension__ __PRETTY_FUNCTION__));        
assert(S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size())(static_cast <bool> (S.ArgumentPackSubstitutionIndex <
 (int)Arg.pack_size()) ? void (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size()"
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 964, __extension__ __PRETTY_FUNCTION__));
Arg = Arg.pack_begin()[S.ArgumentPackSubstitutionIndex];
if (Arg.isPackExpansion())
  Arg = Arg.getPackExpansionPattern();
return Arg;
969}

971Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
if (!D)
  return nullptr;

if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) {
  if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
    // If the corresponding template argument is NULL or non-existent, it's
    // because we are performing instantiation from explicitly-specified
    // template arguments in a function template, but there were some
    // arguments left unspecified.
    if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
                                          TTP->getPosition()))
      return D;

    TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
    
    if (TTP->isParameterPack()) {
      assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 989, __extension__ __PRETTY_FUNCTION__)) 
             "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 989, __extension__ __PRETTY_FUNCTION__));
      Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
    }

    TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
    assert(!Template.isNull() && Template.getAsTemplateDecl() &&(static_cast <bool> (!Template.isNull() && Template
.getAsTemplateDecl() && "Wrong kind of template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 995, __extension__ __PRETTY_FUNCTION__))
           "Wrong kind of template template argument")(static_cast <bool> (!Template.isNull() && Template
.getAsTemplateDecl() && "Wrong kind of template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 995, __extension__ __PRETTY_FUNCTION__));
    return Template.getAsTemplateDecl();
  }

  // Fall through to find the instantiated declaration for this template
  // template parameter.
}

return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
1004}

1006Decl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) {
Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs);
if (!Inst)
  return nullptr;

getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
return Inst;
1013}

1015NamedDecl *
1016TemplateInstantiator::TransformFirstQualifierInScope(NamedDecl *D, 
                                                   SourceLocation Loc) {
// If the first part of the nested-name-specifier was a template type 
// parameter, instantiate that type parameter down to a tag type.
if (TemplateTypeParmDecl *TTPD = dyn_cast_or_null<TemplateTypeParmDecl>(D)) {
  const TemplateTypeParmType *TTP 
    = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD));
  
  if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
    // FIXME: This needs testing w/ member access expressions.
    TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getIndex());
    
    if (TTP->isParameterPack()) {
      assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1030, __extension__ __PRETTY_FUNCTION__)) 
             "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1030, __extension__ __PRETTY_FUNCTION__));
      
      if (getSema().ArgumentPackSubstitutionIndex == -1)
        return nullptr;

      Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
    }

    QualType T = Arg.getAsType();
    if (T.isNull())
      return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
    
    if (const TagType *Tag = T->getAs<TagType>())
      return Tag->getDecl();
    
    // The resulting type is not a tag; complain.
    getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T;
    return nullptr;
  }
}

return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1052}

1054VarDecl *
1055TemplateInstantiator::RebuildExceptionDecl(VarDecl *ExceptionDecl,
                                         TypeSourceInfo *Declarator,
                                         SourceLocation StartLoc,
                                         SourceLocation NameLoc,
                                         IdentifierInfo *Name) {
VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator,
                                               StartLoc, NameLoc, Name);
if (Var)
  getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
return Var;
1065}

1067VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(VarDecl *ExceptionDecl, 
                                                      TypeSourceInfo *TSInfo, 
                                                      QualType T) {
VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T);
if (Var)
  getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
return Var;
1074}

1076QualType
1077TemplateInstantiator::RebuildElaboratedType(SourceLocation KeywordLoc,
                                          ElaboratedTypeKeyword Keyword,
                                          NestedNameSpecifierLoc QualifierLoc,
                                          QualType T) {
if (const TagType *TT = T->getAs<TagType>()) {
  TagDecl* TD = TT->getDecl();

  SourceLocation TagLocation = KeywordLoc;

  IdentifierInfo *Id = TD->getIdentifier();

  // TODO: should we even warn on struct/class mismatches for this?  Seems
  // like it's likely to produce a lot of spurious errors.
  if (Id && Keyword != ETK_None && Keyword != ETK_Typename) {
    TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
    if (!SemaRef.isAcceptableTagRedeclaration(TD, Kind, /*isDefinition*/false,
                                              TagLocation, Id)) {
      SemaRef.Diag(TagLocation, diag::err_use_with_wrong_tag)
        << Id
        << FixItHint::CreateReplacement(SourceRange(TagLocation),
                                        TD->getKindName());
      SemaRef.Diag(TD->getLocation(), diag::note_previous_use);
    }
  }
}

return TreeTransform<TemplateInstantiator>::RebuildElaboratedType(KeywordLoc,
                                                                  Keyword,
                                                                QualifierLoc,
                                                                  T);
1107}

1109TemplateName TemplateInstantiator::TransformTemplateName(
  CXXScopeSpec &SS, TemplateName Name, SourceLocation NameLoc,
  QualType ObjectType, NamedDecl *FirstQualifierInScope,
  bool AllowInjectedClassName) {
if (TemplateTemplateParmDecl *TTP
     = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) {
  if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
    // If the corresponding template argument is NULL or non-existent, it's
    // because we are performing instantiation from explicitly-specified
    // template arguments in a function template, but there were some
    // arguments left unspecified.
    if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
                                          TTP->getPosition()))
      return Name;
    
    TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
    
    if (TTP->isParameterPack()) {
      assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1128, __extension__ __PRETTY_FUNCTION__)) 
             "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1128, __extension__ __PRETTY_FUNCTION__));
      
      if (getSema().ArgumentPackSubstitutionIndex == -1) {
        // We have the template argument pack to substitute, but we're not
        // actually expanding the enclosing pack expansion yet. So, just
        // keep the entire argument pack.
        return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg);
      }

      Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
    }
    
    TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
    assert(!Template.isNull() && "Null template template argument")(static_cast <bool> (!Template.isNull() && "Null template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && \"Null template template argument\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1141, __extension__ __PRETTY_FUNCTION__));
    assert(!Template.getAsQualifiedTemplateName() &&(static_cast <bool> (!Template.getAsQualifiedTemplateName
() && "template decl to substitute is qualified?") ? void
 (0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1143, __extension__ __PRETTY_FUNCTION__))
           "template decl to substitute is qualified?")(static_cast <bool> (!Template.getAsQualifiedTemplateName
() && "template decl to substitute is qualified?") ? void
 (0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1143, __extension__ __PRETTY_FUNCTION__));

    Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template);
    return Template;
  }
}

if (SubstTemplateTemplateParmPackStorage *SubstPack
    = Name.getAsSubstTemplateTemplateParmPack()) {
  if (getSema().ArgumentPackSubstitutionIndex == -1)
    return Name;
  
  TemplateArgument Arg = SubstPack->getArgumentPack();
  Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
  return Arg.getAsTemplate().getNameToSubstitute();
}

return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
                                        FirstQualifierInScope,
                                        AllowInjectedClassName);
1163}

1165ExprResult 
1166TemplateInstantiator::TransformPredefinedExpr(PredefinedExpr *E) {
if (!E->isTypeDependent())
  return E;

return getSema().BuildPredefinedExpr(E->getLocation(), E->getIdentType());
1171}

1173ExprResult
1174TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
                                             NonTypeTemplateParmDecl *NTTP) {
// If the corresponding template argument is NULL or non-existent, it's
// because we are performing instantiation from explicitly-specified
// template arguments in a function template, but there were some
// arguments left unspecified.
if (!TemplateArgs.hasTemplateArgument(NTTP->getDepth(),
                                      NTTP->getPosition()))
  return E;

TemplateArgument Arg = TemplateArgs(NTTP->getDepth(), NTTP->getPosition());

if (TemplateArgs.getNumLevels() != TemplateArgs.getNumSubstitutedLevels()) {
  // We're performing a partial substitution, so the substituted argument
  // could be dependent. As a result we can't create a SubstNonType*Expr
  // node now, since that represents a fully-substituted argument.
  // FIXME: We should have some AST representation for this.
  if (Arg.getKind() == TemplateArgument::Pack) {
    // FIXME: This won't work for alias templates.
    assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() &&(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in partial substitution"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in partial substitution\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1194, __extension__ __PRETTY_FUNCTION__))
           "unexpected pack arguments in partial substitution")(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in partial substitution"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in partial substitution\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1194, __extension__ __PRETTY_FUNCTION__));
    Arg = Arg.pack_begin()->getPackExpansionPattern();
  }
  assert(Arg.getKind() == TemplateArgument::Expression &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Expression && "unexpected nontype template argument kind in partial substitution"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in partial substitution\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1198, __extension__ __PRETTY_FUNCTION__))
         "unexpected nontype template argument kind in partial substitution")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Expression && "unexpected nontype template argument kind in partial substitution"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in partial substitution\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1198, __extension__ __PRETTY_FUNCTION__));
  return Arg.getAsExpr();
}

if (NTTP->isParameterPack()) {
  assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1204, __extension__ __PRETTY_FUNCTION__)) 
         "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1204, __extension__ __PRETTY_FUNCTION__));
  
  if (getSema().ArgumentPackSubstitutionIndex == -1) {
    // We have an argument pack, but we can't select a particular argument
    // out of it yet. Therefore, we'll build an expression to hold on to that
    // argument pack.
    QualType TargetType = SemaRef.SubstType(NTTP->getType(), TemplateArgs,
                                            E->getLocation(), 
                                            NTTP->getDeclName());
    if (TargetType.isNull())
      return ExprError();

    return new (SemaRef.Context) SubstNonTypeTemplateParmPackExpr(
        TargetType.getNonLValueExprType(SemaRef.Context),
        TargetType->isReferenceType() ? VK_LValue : VK_RValue, NTTP,
        E->getLocation(), Arg);
  }
  
  Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
}

return transformNonTypeTemplateParmRef(NTTP, E->getLocation(), Arg);
1226}

1228const LoopHintAttr *
1229TemplateInstantiator::TransformLoopHintAttr(const LoopHintAttr *LH) {
Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).get();

if (TransformedExpr == LH->getValue())
  return LH;

// Generate error if there is a problem with the value.
if (getSema().CheckLoopHintExpr(TransformedExpr, LH->getLocation()))
  return LH;

// Create new LoopHintValueAttr with integral expression in place of the
// non-type template parameter.
return LoopHintAttr::CreateImplicit(
    getSema().Context, LH->getSemanticSpelling(), LH->getOption(),
    LH->getState(), TransformedExpr, LH->getRange());
1244}

1246ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
                                               NonTypeTemplateParmDecl *parm,
                                               SourceLocation loc,
                                               TemplateArgument arg) {
ExprResult result;
QualType type;

// The template argument itself might be an expression, in which
// case we just return that expression.
if (arg.getKind() == TemplateArgument::Expression) {
  Expr *argExpr = arg.getAsExpr();
  result = argExpr;
  type = argExpr->getType();

} else if (arg.getKind() == TemplateArgument::Declaration ||
           arg.getKind() == TemplateArgument::NullPtr) {
  ValueDecl *VD;
  if (arg.getKind() == TemplateArgument::Declaration) {
    VD = arg.getAsDecl();

    // Find the instantiation of the template argument.  This is
    // required for nested templates.
    VD = cast_or_null<ValueDecl>(
           getSema().FindInstantiatedDecl(loc, VD, TemplateArgs));
    if (!VD)
      return ExprError();
  } else {
    // Propagate NULL template argument.
    VD = nullptr;
  }
  
  // Derive the type we want the substituted decl to have.  This had
  // better be non-dependent, or these checks will have serious problems.
  if (parm->isExpandedParameterPack()) {
    type = parm->getExpansionType(SemaRef.ArgumentPackSubstitutionIndex);
  } else if (parm->isParameterPack() && 
             isa<PackExpansionType>(parm->getType())) {
    type = SemaRef.SubstType(
                      cast<PackExpansionType>(parm->getType())->getPattern(),
                                   TemplateArgs, loc, parm->getDeclName());
  } else {
    type = SemaRef.SubstType(VD ? arg.getParamTypeForDecl() : arg.getNullPtrType(),
                             TemplateArgs, loc, parm->getDeclName());
  }
  assert(!type.isNull() && "type substitution failed for param type")(static_cast <bool> (!type.isNull() && "type substitution failed for param type"
) ? void (0) : __assert_fail ("!type.isNull() && \"type substitution failed for param type\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1290, __extension__ __PRETTY_FUNCTION__));
  assert(!type->isDependentType() && "param type still dependent")(static_cast <bool> (!type->isDependentType() &&
 "param type still dependent") ? void (0) : __assert_fail ("!type->isDependentType() && \"param type still dependent\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1291, __extension__ __PRETTY_FUNCTION__));
  result = SemaRef.BuildExpressionFromDeclTemplateArgument(arg, type, loc);

  if (!result.isInvalid()) type = result.get()->getType();
} else {
  result = SemaRef.BuildExpressionFromIntegralTemplateArgument(arg, loc);

  // Note that this type can be different from the type of 'result',
  // e.g. if it's an enum type.
  type = arg.getIntegralType();
}
if (result.isInvalid()) return ExprError();

Expr *resultExpr = result.get();
return new (SemaRef.Context) SubstNonTypeTemplateParmExpr(
    type, resultExpr->getValueKind(), loc, parm, resultExpr);
1307}
                                                 
1309ExprResult 
1310TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
                                        SubstNonTypeTemplateParmPackExpr *E) {
if (getSema().ArgumentPackSubstitutionIndex == -1) {
  // We aren't expanding the parameter pack, so just return ourselves.
  return E;
}

TemplateArgument Arg = E->getArgumentPack();
Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
return transformNonTypeTemplateParmRef(E->getParameterPack(),
                                       E->getParameterPackLocation(),
                                       Arg);
1322}

1324ExprResult
1325TemplateInstantiator::RebuildParmVarDeclRefExpr(ParmVarDecl *PD,
                                              SourceLocation Loc) {
DeclarationNameInfo NameInfo(PD->getDeclName(), Loc);
return getSema().BuildDeclarationNameExpr(CXXScopeSpec(), NameInfo, PD);
1329}

1331ExprResult
1332TemplateInstantiator::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
if (getSema().ArgumentPackSubstitutionIndex != -1) {
  // We can expand this parameter pack now.
  ParmVarDecl *D = E->getExpansion(getSema().ArgumentPackSubstitutionIndex);
  ValueDecl *VD = cast_or_null<ValueDecl>(TransformDecl(E->getExprLoc(), D));
  if (!VD)
    return ExprError();
  return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(VD), E->getExprLoc());
}

QualType T = TransformType(E->getType());
if (T.isNull())
  return ExprError();

// Transform each of the parameter expansions into the corresponding
// parameters in the instantiation of the function decl.
SmallVector<ParmVarDecl *, 8> Parms;
Parms.reserve(E->getNumExpansions());
for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
     I != End; ++I) {
  ParmVarDecl *D =
      cast_or_null<ParmVarDecl>(TransformDecl(E->getExprLoc(), *I));
  if (!D)
    return ExprError();
  Parms.push_back(D);
}

return FunctionParmPackExpr::Create(getSema().Context, T,
                                    E->getParameterPack(),
                                    E->getParameterPackLocation(), Parms);
1362}

1364ExprResult
1365TemplateInstantiator::TransformFunctionParmPackRefExpr(DeclRefExpr *E,
                                                     ParmVarDecl *PD) {
typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
  = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
assert(Found && "no instantiation for parameter pack")(static_cast <bool> (Found && "no instantiation for parameter pack"
) ? void (0) : __assert_fail ("Found && \"no instantiation for parameter pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1370, __extension__ __PRETTY_FUNCTION__));

Decl *TransformedDecl;
if (DeclArgumentPack *Pack = Found->dyn_cast<DeclArgumentPack *>()) {
  // If this is a reference to a function parameter pack which we can
  // substitute but can't yet expand, build a FunctionParmPackExpr for it.
  if (getSema().ArgumentPackSubstitutionIndex == -1) {
    QualType T = TransformType(E->getType());
    if (T.isNull())
      return ExprError();
    return FunctionParmPackExpr::Create(getSema().Context, T, PD,
                                        E->getExprLoc(), *Pack);
  }

  TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
} else {
  TransformedDecl = Found->get<Decl*>();
}

// We have either an unexpanded pack or a specific expansion.
return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(TransformedDecl),
                                 E->getExprLoc());
1392}

1394ExprResult
1395TemplateInstantiator::TransformDeclRefExpr(DeclRefExpr *E) {
NamedDecl *D = E->getDecl();

// Handle references to non-type template parameters and non-type template
// parameter packs.
if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
  if (NTTP->getDepth() < TemplateArgs.getNumLevels())
    return TransformTemplateParmRefExpr(E, NTTP);
  
  // We have a non-type template parameter that isn't fully substituted;
  // FindInstantiatedDecl will find it in the local instantiation scope.
}

// Handle references to function parameter packs.
if (ParmVarDecl *PD = dyn_cast<ParmVarDecl>(D))
  if (PD->isParameterPack())
    return TransformFunctionParmPackRefExpr(E, PD);

return TreeTransform<TemplateInstantiator>::TransformDeclRefExpr(E);
1414}

1416ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
  CXXDefaultArgExpr *E) {
assert(!cast<FunctionDecl>(E->getParam()->getDeclContext())->(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
 "Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1420, __extension__ __PRETTY_FUNCTION__))
           getDescribedFunctionTemplate() &&(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
 "Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1420, __extension__ __PRETTY_FUNCTION__))
       "Default arg expressions are never formed in dependent cases.")(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
 "Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1420, __extension__ __PRETTY_FUNCTION__));
return SemaRef.BuildCXXDefaultArgExpr(E->getUsedLocation(),
                         cast<FunctionDecl>(E->getParam()->getDeclContext()), 
                                      E->getParam());
1424}

1426template<typename Fn>
1427QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB,
                               FunctionProtoTypeLoc TL,
                               CXXRecordDecl *ThisContext,
                               unsigned ThisTypeQuals,
                               Fn TransformExceptionSpec) {
// We need a local instantiation scope for this function prototype.
LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
return inherited::TransformFunctionProtoType(
    TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
1436}

1438ParmVarDecl *
1439TemplateInstantiator::TransformFunctionTypeParam(ParmVarDecl *OldParm,
                                               int indexAdjustment,
                                             Optional<unsigned> NumExpansions,
                                               bool ExpectParameterPack) {
return SemaRef.SubstParmVarDecl(OldParm, TemplateArgs, indexAdjustment,
                                NumExpansions, ExpectParameterPack);
1445}

1447QualType
1448TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
                                              TemplateTypeParmTypeLoc TL) {
const TemplateTypeParmType *T = TL.getTypePtr();
if (T->getDepth() < TemplateArgs.getNumLevels()) {
  // Replace the template type parameter with its corresponding
  // template argument.

  // If the corresponding template argument is NULL or doesn't exist, it's
  // because we are performing instantiation from explicitly-specified
  // template arguments in a function template class, but there were some
  // arguments left unspecified.
  if (!TemplateArgs.hasTemplateArgument(T->getDepth(), T->getIndex())) {
    TemplateTypeParmTypeLoc NewTL
      = TLB.push<TemplateTypeParmTypeLoc>(TL.getType());
    NewTL.setNameLoc(TL.getNameLoc());
    return TL.getType();
  }

  TemplateArgument Arg = TemplateArgs(T->getDepth(), T->getIndex());
  
  if (T->isParameterPack()) {
    assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1470, __extension__ __PRETTY_FUNCTION__)) 
           "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1470, __extension__ __PRETTY_FUNCTION__));
    
    if (getSema().ArgumentPackSubstitutionIndex == -1) {
      // We have the template argument pack, but we're not expanding the
      // enclosing pack expansion yet. Just save the template argument
      // pack for later substitution.
      QualType Result
        = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg);
      SubstTemplateTypeParmPackTypeLoc NewTL
        = TLB.push<SubstTemplateTypeParmPackTypeLoc>(Result);
      NewTL.setNameLoc(TL.getNameLoc());
      return Result;
    }
    
    Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
  }
  
  assert(Arg.getKind() == TemplateArgument::Type &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "Template argument kind mismatch") ? void (0)
 : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1488, __extension__ __PRETTY_FUNCTION__))
         "Template argument kind mismatch")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "Template argument kind mismatch") ? void (0)
 : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1488, __extension__ __PRETTY_FUNCTION__));

  QualType Replacement = Arg.getAsType();

  // TODO: only do this uniquing once, at the start of instantiation.
  QualType Result
    = getSema().Context.getSubstTemplateTypeParmType(T, Replacement);
  SubstTemplateTypeParmTypeLoc NewTL
    = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
  return Result;
}

// The template type parameter comes from an inner template (e.g.,
// the template parameter list of a member template inside the
// template we are instantiating). Create a new template type
// parameter with the template "level" reduced by one.
TemplateTypeParmDecl *NewTTPDecl = nullptr;
if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl())
  NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
                                TransformDecl(TL.getNameLoc(), OldTTPDecl));

QualType Result = getSema().Context.getTemplateTypeParmType(
    T->getDepth() - TemplateArgs.getNumSubstitutedLevels(), T->getIndex(),
    T->isParameterPack(), NewTTPDecl);
TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return Result;
1516}

1518QualType 
1519TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
                                                          TypeLocBuilder &TLB,
                                       SubstTemplateTypeParmPackTypeLoc TL) {
if (getSema().ArgumentPackSubstitutionIndex == -1) {
  // We aren't expanding the parameter pack, so just return ourselves.
  SubstTemplateTypeParmPackTypeLoc NewTL
    = TLB.push<SubstTemplateTypeParmPackTypeLoc>(TL.getType());
  NewTL.setNameLoc(TL.getNameLoc());
  return TL.getType();
}

TemplateArgument Arg = TL.getTypePtr()->getArgumentPack();
Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
QualType Result = Arg.getAsType();

Result = getSema().Context.getSubstTemplateTypeParmType(
                                    TL.getTypePtr()->getReplacedParameter(),
                                                        Result);
SubstTemplateTypeParmTypeLoc NewTL
  = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return Result;
1541}

1543/// \brief Perform substitution on the type T with a given set of template
1544/// arguments.
1545///
1546/// This routine substitutes the given template arguments into the
1547/// type T and produces the instantiated type.
1548///
1549/// \param T the type into which the template arguments will be
1550/// substituted. If this type is not dependent, it will be returned
1551/// immediately.
1552///
1553/// \param Args the template arguments that will be
1554/// substituted for the top-level template parameters within T.
1555///
1556/// \param Loc the location in the source code where this substitution
1557/// is being performed. It will typically be the location of the
1558/// declarator (if we're instantiating the type of some declaration)
1559/// or the location of the type in the source code (if, e.g., we're
1560/// instantiating the type of a cast expression).
1561///
1562/// \param Entity the name of the entity associated with a declaration
1563/// being instantiated (if any). May be empty to indicate that there
1564/// is no such entity (if, e.g., this is a type that occurs as part of
1565/// a cast expression) or that the entity has no name (e.g., an
1566/// unnamed function parameter).
1567///
1568/// \param AllowDeducedTST Whether a DeducedTemplateSpecializationType is
1569/// acceptable as the top level type of the result.
1570///
1571/// \returns If the instantiation succeeds, the instantiated
1572/// type. Otherwise, produces diagnostics and returns a NULL type.
1573TypeSourceInfo *Sema::SubstType(TypeSourceInfo *T,
                              const MultiLevelTemplateArgumentList &Args,
                              SourceLocation Loc,
                              DeclarationName Entity,
                              bool AllowDeducedTST) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1580, __extension__ __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1580, __extension__ __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1580, __extension__ __PRETTY_FUNCTION__));

if (!T->getType()->isInstantiationDependentType() && 
    !T->getType()->isVariablyModifiedType())
  return T;

TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(T)
                       : Instantiator.TransformType(T);
1589}

1591TypeSourceInfo *Sema::SubstType(TypeLoc TL,
                              const MultiLevelTemplateArgumentList &Args,
                              SourceLocation Loc,
                              DeclarationName Entity) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1597, __extension__ __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1597, __extension__ __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1597, __extension__ __PRETTY_FUNCTION__));

if (TL.getType().isNull())
  return nullptr;

if (!TL.getType()->isInstantiationDependentType() && 
    !TL.getType()->isVariablyModifiedType()) {
  // FIXME: Make a copy of the TypeLoc data here, so that we can
  // return a new TypeSourceInfo. Inefficient!
  TypeLocBuilder TLB;
  TLB.pushFullCopy(TL);
  return TLB.getTypeSourceInfo(Context, TL.getType());
}

TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
TypeLocBuilder TLB;
TLB.reserve(TL.getFullDataSize());
QualType Result = Instantiator.TransformType(TLB, TL);
if (Result.isNull())
  return nullptr;

return TLB.getTypeSourceInfo(Context, Result);
1619}

1621/// Deprecated form of the above.
1622QualType Sema::SubstType(QualType T,
                       const MultiLevelTemplateArgumentList &TemplateArgs,
                       SourceLocation Loc, DeclarationName Entity) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1627, __extension__ __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1627, __extension__ __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1627, __extension__ __PRETTY_FUNCTION__));

// If T is not a dependent type or a variably-modified type, there
// is nothing to do.
if (!T->isInstantiationDependentType() && !T->isVariablyModifiedType())
  return T;

TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, Entity);
return Instantiator.TransformType(T);
1636}

1638static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T) {
if (T->getType()->isInstantiationDependentType() ||
    T->getType()->isVariablyModifiedType())
  return true;

TypeLoc TL = T->getTypeLoc().IgnoreParens();
if (!TL.getAs<FunctionProtoTypeLoc>())
  return false;

FunctionProtoTypeLoc FP = TL.castAs<FunctionProtoTypeLoc>();
for (ParmVarDecl *P : FP.getParams()) {
  // This must be synthesized from a typedef.
  if (!P) continue;

  // If there are any parameters, a new TypeSourceInfo that refers to the
  // instantiated parameters must be built.
  return true;
}

return false;
1658}

1660/// A form of SubstType intended specifically for instantiating the
1661/// type of a FunctionDecl.  Its purpose is solely to force the
1662/// instantiation of default-argument expressions and to avoid
1663/// instantiating an exception-specification.
1664TypeSourceInfo *Sema::SubstFunctionDeclType(TypeSourceInfo *T,
                              const MultiLevelTemplateArgumentList &Args,
                              SourceLocation Loc,
                              DeclarationName Entity,
                              CXXRecordDecl *ThisContext,
                              unsigned ThisTypeQuals) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1672, __extension__ __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1672, __extension__ __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1672, __extension__ __PRETTY_FUNCTION__));

if (!NeedsInstantiationAsFunctionType(T))
  return T;

TemplateInstantiator Instantiator(*this, Args, Loc, Entity);

TypeLocBuilder TLB;

TypeLoc TL = T->getTypeLoc();
TLB.reserve(TL.getFullDataSize());

QualType Result;

if (FunctionProtoTypeLoc Proto =
        TL.IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
  // Instantiate the type, other than its exception specification. The
  // exception specification is instantiated in InitFunctionInstantiation
  // once we've built the FunctionDecl.
  // FIXME: Set the exception specification to EST_Uninstantiated here,
  // instead of rebuilding the function type again later.
  Result = Instantiator.TransformFunctionProtoType(
      TLB, Proto, ThisContext, ThisTypeQuals,
      [](FunctionProtoType::ExceptionSpecInfo &ESI,
         bool &Changed) { return false; });
} else {
  Result = Instantiator.TransformType(TLB, TL);
}
if (Result.isNull())
  return nullptr;

return TLB.getTypeSourceInfo(Context, Result);
1704}

1706bool Sema::SubstExceptionSpec(SourceLocation Loc,
                            FunctionProtoType::ExceptionSpecInfo &ESI,
                            SmallVectorImpl<QualType> &ExceptionStorage,
                            const MultiLevelTemplateArgumentList &Args) {
assert(ESI.Type != EST_Uninstantiated)(static_cast <bool> (ESI.Type != EST_Uninstantiated) ? void
 (0) : __assert_fail ("ESI.Type != EST_Uninstantiated", "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1710, __extension__ __PRETTY_FUNCTION__));

bool Changed = false;
TemplateInstantiator Instantiator(*this, Args, Loc, DeclarationName());
return Instantiator.TransformExceptionSpec(Loc, ESI, ExceptionStorage,
                                           Changed);
1716}

1718void Sema::SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,
                            const MultiLevelTemplateArgumentList &Args) {
FunctionProtoType::ExceptionSpecInfo ESI =
    Proto->getExtProtoInfo().ExceptionSpec;

SmallVector<QualType, 4> ExceptionStorage;
if (SubstExceptionSpec(New->getTypeSourceInfo()->getTypeLoc().getLocEnd(),
                       ESI, ExceptionStorage, Args))
  // On error, recover by dropping the exception specification.
  ESI.Type = EST_None;

UpdateExceptionSpec(New, ESI);
1730}

1732ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm, 
                          const MultiLevelTemplateArgumentList &TemplateArgs,
                                  int indexAdjustment,
                                  Optional<unsigned> NumExpansions,
                                  bool ExpectParameterPack) {
TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
TypeSourceInfo *NewDI = nullptr;

TypeLoc OldTL = OldDI->getTypeLoc();
if (PackExpansionTypeLoc ExpansionTL = OldTL.getAs<PackExpansionTypeLoc>()) {

  // We have a function parameter pack. Substitute into the pattern of the 
  // expansion.
  NewDI = SubstType(ExpansionTL.getPatternLoc(), TemplateArgs, 
                    OldParm->getLocation(), OldParm->getDeclName());
  if (!NewDI)
    return nullptr;

  if (NewDI->getType()->containsUnexpandedParameterPack()) {
    // We still have unexpanded parameter packs, which means that
    // our function parameter is still a function parameter pack.
    // Therefore, make its type a pack expansion type.
    NewDI = CheckPackExpansion(NewDI, ExpansionTL.getEllipsisLoc(),
                               NumExpansions);
  } else if (ExpectParameterPack) {
    // We expected to get a parameter pack but didn't (because the type
    // itself is not a pack expansion type), so complain. This can occur when
    // the substitution goes through an alias template that "loses" the
    // pack expansion.
    Diag(OldParm->getLocation(), 
         diag::err_function_parameter_pack_without_parameter_packs)
      << NewDI->getType();
    return nullptr;
  } 
} else {
  NewDI = SubstType(OldDI, TemplateArgs, OldParm->getLocation(), 
                    OldParm->getDeclName());
}

if (!NewDI)
  return nullptr;

if (NewDI->getType()->isVoidType()) {
  Diag(OldParm->getLocation(), diag::err_param_with_void_type);
  return nullptr;
}

ParmVarDecl *NewParm = CheckParameter(Context.getTranslationUnitDecl(),
                                      OldParm->getInnerLocStart(),
                                      OldParm->getLocation(),
                                      OldParm->getIdentifier(),
                                      NewDI->getType(), NewDI,
                                      OldParm->getStorageClass());
if (!NewParm)
  return nullptr;

// Mark the (new) default argument as uninstantiated (if any).
if (OldParm->hasUninstantiatedDefaultArg()) {
  Expr *Arg = OldParm->getUninstantiatedDefaultArg();
  NewParm->setUninstantiatedDefaultArg(Arg);
} else if (OldParm->hasUnparsedDefaultArg()) {
  NewParm->setUnparsedDefaultArg();
  UnparsedDefaultArgInstantiations[OldParm].push_back(NewParm);
} else if (Expr *Arg = OldParm->getDefaultArg()) {
  FunctionDecl *OwningFunc = cast<FunctionDecl>(OldParm->getDeclContext());
  if (OwningFunc->isLexicallyWithinFunctionOrMethod()) {
    // Instantiate default arguments for methods of local classes (DR1484)
    // and non-defining declarations.
    Sema::ContextRAII SavedContext(*this, OwningFunc);
    LocalInstantiationScope Local(*this, true);
    ExprResult NewArg = SubstExpr(Arg, TemplateArgs);
    if (NewArg.isUsable()) {
      // It would be nice if we still had this.
      SourceLocation EqualLoc = NewArg.get()->getLocStart();
      SetParamDefaultArgument(NewParm, NewArg.get(), EqualLoc);
    }
  } else {
    // FIXME: if we non-lazily instantiated non-dependent default args for
    // non-dependent parameter types we could remove a bunch of duplicate
    // conversion warnings for such arguments.
    NewParm->setUninstantiatedDefaultArg(Arg);
  }
}

NewParm->setHasInheritedDefaultArg(OldParm->hasInheritedDefaultArg());

if (OldParm->isParameterPack() && !NewParm->isParameterPack()) {
  // Add the new parameter to the instantiated parameter pack.
  CurrentInstantiationScope->InstantiatedLocalPackArg(OldParm, NewParm);
} else {
  // Introduce an Old -> New mapping
  CurrentInstantiationScope->InstantiatedLocal(OldParm, NewParm);  
}

// FIXME: OldParm may come from a FunctionProtoType, in which case CurContext
// can be anything, is this right ?
NewParm->setDeclContext(CurContext);

NewParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
                      OldParm->getFunctionScopeIndex() + indexAdjustment);

InstantiateAttrs(TemplateArgs, OldParm, NewParm);

return NewParm;  
1836}

1838/// \brief Substitute the given template arguments into the given set of
1839/// parameters, producing the set of parameter types that would be generated
1840/// from such a substitution.
1841bool Sema::SubstParmTypes(
  SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
  const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
  const MultiLevelTemplateArgumentList &TemplateArgs,
  SmallVectorImpl<QualType> &ParamTypes,
  SmallVectorImpl<ParmVarDecl *> *OutParams,
  ExtParameterInfoBuilder &ParamInfos) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1850, __extension__ __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1850, __extension__ __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1850, __extension__ __PRETTY_FUNCTION__));

TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, 
                                  DeclarationName());
return Instantiator.TransformFunctionTypeParams(
    Loc, Params, nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
1856}

1858/// \brief Perform substitution on the base class specifiers of the
1859/// given class template specialization.
1860///
1861/// Produces a diagnostic and returns true on error, returns false and
1862/// attaches the instantiated base classes to the class template
1863/// specialization if successful.
1864bool
1865Sema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
                        CXXRecordDecl *Pattern,
                        const MultiLevelTemplateArgumentList &TemplateArgs) {
bool Invalid = false;
SmallVector<CXXBaseSpecifier*, 4> InstantiatedBases;
for (const auto &Base : Pattern->bases()) {
  if (!Base.getType()->isDependentType()) {
    if (const CXXRecordDecl *RD = Base.getType()->getAsCXXRecordDecl()) {
      if (RD->isInvalidDecl())
        Instantiation->setInvalidDecl();
    }
    InstantiatedBases.push_back(new (Context) CXXBaseSpecifier(Base));
    continue;
  }

  SourceLocation EllipsisLoc;
  TypeSourceInfo *BaseTypeLoc;
  if (Base.isPackExpansion()) {
    // This is a pack expansion. See whether we should expand it now, or
    // wait until later.
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    collectUnexpandedParameterPacks(Base.getTypeSourceInfo()->getTypeLoc(),
                                    Unexpanded);
    bool ShouldExpand = false;
    bool RetainExpansion = false;
    Optional<unsigned> NumExpansions;
    if (CheckParameterPacksForExpansion(Base.getEllipsisLoc(), 
                                        Base.getSourceRange(),
                                        Unexpanded,
                                        TemplateArgs, ShouldExpand, 
                                        RetainExpansion,
                                        NumExpansions)) {
      Invalid = true;
      continue;
    }
    
    // If we should expand this pack expansion now, do so.
    if (ShouldExpand) {
      for (unsigned I = 0; I != *NumExpansions; ++I) {
          Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
        
        TypeSourceInfo *BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
                                                TemplateArgs,
                                            Base.getSourceRange().getBegin(),
                                                DeclarationName());
        if (!BaseTypeLoc) {
          Invalid = true;
          continue;
        }
        
        if (CXXBaseSpecifier *InstantiatedBase
              = CheckBaseSpecifier(Instantiation,
                                   Base.getSourceRange(),
                                   Base.isVirtual(),
                                   Base.getAccessSpecifierAsWritten(),
                                   BaseTypeLoc,
                                   SourceLocation()))
          InstantiatedBases.push_back(InstantiatedBase);
        else
          Invalid = true;
      }
    
      continue;
    }
    
    // The resulting base specifier will (still) be a pack expansion.
    EllipsisLoc = Base.getEllipsisLoc();
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1);
    BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
                            TemplateArgs,
                            Base.getSourceRange().getBegin(),
                            DeclarationName());
  } else {
    BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
                            TemplateArgs,
                            Base.getSourceRange().getBegin(),
                            DeclarationName());
  }
  
  if (!BaseTypeLoc) {
    Invalid = true;
    continue;
  }

  if (CXXBaseSpecifier *InstantiatedBase
        = CheckBaseSpecifier(Instantiation,
                             Base.getSourceRange(),
                             Base.isVirtual(),
                             Base.getAccessSpecifierAsWritten(),
                             BaseTypeLoc,
                             EllipsisLoc))
    InstantiatedBases.push_back(InstantiatedBase);
  else
    Invalid = true;
}

if (!Invalid && AttachBaseSpecifiers(Instantiation, InstantiatedBases))
  Invalid = true;

return Invalid;
1965}

1967// Defined via #include from SemaTemplateInstantiateDecl.cpp
1968namespace clang {
namespace sema {
  Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S,
                          const MultiLevelTemplateArgumentList &TemplateArgs);
  Attr *instantiateTemplateAttributeForDecl(
      const Attr *At, ASTContext &C, Sema &S,
      const MultiLevelTemplateArgumentList &TemplateArgs);
}
1976}

1978/// \brief Instantiate the definition of a class from a given pattern.
1979///
1980/// \param PointOfInstantiation The point of instantiation within the
1981/// source code.
1982///
1983/// \param Instantiation is the declaration whose definition is being
1984/// instantiated. This will be either a class template specialization
1985/// or a member class of a class template specialization.
1986///
1987/// \param Pattern is the pattern from which the instantiation
1988/// occurs. This will be either the declaration of a class template or
1989/// the declaration of a member class of a class template.
1990///
1991/// \param TemplateArgs The template arguments to be substituted into
1992/// the pattern.
1993///
1994/// \param TSK the kind of implicit or explicit instantiation to perform.
1995///
1996/// \param Complain whether to complain if the class cannot be instantiated due
1997/// to the lack of a definition.
1998///
1999/// \returns true if an error occurred, false otherwise.
2000bool
2001Sema::InstantiateClass(SourceLocation PointOfInstantiation,
                     CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
                     const MultiLevelTemplateArgumentList &TemplateArgs,
                     TemplateSpecializationKind TSK,
                     bool Complain) {
CXXRecordDecl *PatternDef
  = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
                              Instantiation->getInstantiatedFromMemberClass(),
                                   Pattern, PatternDef, TSK, Complain))
  return true;
Pattern = PatternDef;

// \brief Record the point of instantiation.
if (MemberSpecializationInfo *MSInfo 
      = Instantiation->getMemberSpecializationInfo()) {
  MSInfo->setTemplateSpecializationKind(TSK);
  MSInfo->setPointOfInstantiation(PointOfInstantiation);
} else if (ClassTemplateSpecializationDecl *Spec 
      = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
  Spec->setTemplateSpecializationKind(TSK);
  Spec->setPointOfInstantiation(PointOfInstantiation);
}

InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
if (Inst.isInvalid())
  return true;
assert(!Inst.isAlreadyInstantiating() && "should have been caught by caller")(static_cast <bool> (!Inst.isAlreadyInstantiating() &&
 "should have been caught by caller") ? void (0) : __assert_fail
 ("!Inst.isAlreadyInstantiating() && \"should have been caught by caller\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2028, __extension__ __PRETTY_FUNCTION__));
PrettyDeclStackTraceEntry CrashInfo(*this, Instantiation, SourceLocation(),
                                    "instantiating class definition");

// Enter the scope of this instantiation. We don't use
// PushDeclContext because we don't have a scope.
ContextRAII SavedContext(*this, Instantiation);
EnterExpressionEvaluationContext EvalContext(
    *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);

// If this is an instantiation of a local class, merge this local
// instantiation scope with the enclosing scope. Otherwise, every
// instantiation of a class has its own local instantiation scope.
bool MergeWithParentScope = !Instantiation->isDefinedOutsideFunctionOrMethod();
LocalInstantiationScope Scope(*this, MergeWithParentScope);

// Some class state isn't processed immediately but delayed till class
// instantiation completes. We may not be ready to handle any delayed state
// already on the stack as it might correspond to a different class, so save
// it now and put it back later.
SavePendingParsedClassStateRAII SavedPendingParsedClassState(*this);

// Pull attributes from the pattern onto the instantiation.
InstantiateAttrs(TemplateArgs, Pattern, Instantiation);

// Start the definition of this instantiation.
Instantiation->startDefinition();

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

// FIXME: This loses the as-written tag kind for an explicit instantiation.
Instantiation->setTagKind(Pattern->getTagKind());

// Do substitution on the base class specifiers.
if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs))
  Instantiation->setInvalidDecl();

TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
SmallVector<Decl*, 4> Fields;
// Delay instantiation of late parsed attributes.
LateInstantiatedAttrVec LateAttrs;
Instantiator.enableLateAttributeInstantiation(&LateAttrs);

for (auto *Member : Pattern->decls()) {
  // Don't instantiate members not belonging in this semantic context.
  // e.g. for:
  // @code
  //    template <int i> class A {
  //      class B *g;
  //    };
  // @endcode
  // 'class B' has the template as lexical context but semantically it is
  // introduced in namespace scope.
  if (Member->getDeclContext() != Pattern)
    continue;

  if (Member->isInvalidDecl()) {
    Instantiation->setInvalidDecl();
    continue;
  }

  Decl *NewMember = Instantiator.Visit(Member);
  if (NewMember) {
    if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
      Fields.push_back(Field);
    } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) {
      // C++11 [temp.inst]p1: The implicit instantiation of a class template
      // specialization causes the implicit instantiation of the definitions
      // of unscoped member enumerations.
      // Record a point of instantiation for this implicit instantiation.
      if (TSK == TSK_ImplicitInstantiation && !Enum->isScoped() &&
          Enum->isCompleteDefinition()) {
        MemberSpecializationInfo *MSInfo =Enum->getMemberSpecializationInfo();
        assert(MSInfo && "no spec info for member enum specialization")(static_cast <bool> (MSInfo && "no spec info for member enum specialization"
) ? void (0) : __assert_fail ("MSInfo && \"no spec info for member enum specialization\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2103, __extension__ __PRETTY_FUNCTION__));
        MSInfo->setTemplateSpecializationKind(TSK_ImplicitInstantiation);
        MSInfo->setPointOfInstantiation(PointOfInstantiation);
      }
    } else if (StaticAssertDecl *SA = dyn_cast<StaticAssertDecl>(NewMember)) {
      if (SA->isFailed()) {
        // A static_assert failed. Bail out; instantiating this
        // class is probably not meaningful.
        Instantiation->setInvalidDecl();
        break;
      }
    }

    if (NewMember->isInvalidDecl())
      Instantiation->setInvalidDecl();
  } else {
    // FIXME: Eventually, a NULL return will mean that one of the
    // instantiations was a semantic disaster, and we'll want to mark the
    // declaration invalid.
    // For now, we expect to skip some members that we can't yet handle.
  }
}

// See if trivial_abi has to be dropped.
if (Instantiation && Instantiation->hasAttr<TrivialABIAttr>())
  checkIllFormedTrivialABIStruct(*Instantiation);

// Finish checking fields.
ActOnFields(nullptr, Instantiation->getLocation(), Instantiation, Fields,
            SourceLocation(), SourceLocation(), nullptr);
CheckCompletedCXXClass(Instantiation);

// Default arguments are parsed, if not instantiated. We can go instantiate
// default arg exprs for default constructors if necessary now.
ActOnFinishCXXNonNestedClass(Instantiation);

// Instantiate late parsed attributes, and attach them to their decls.
// See Sema::InstantiateAttrs
for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
     E = LateAttrs.end(); I != E; ++I) {
  assert(CurrentInstantiationScope == Instantiator.getStartingScope())(static_cast <bool> (CurrentInstantiationScope == Instantiator
.getStartingScope()) ? void (0) : __assert_fail ("CurrentInstantiationScope == Instantiator.getStartingScope()"
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2143, __extension__ __PRETTY_FUNCTION__));
  CurrentInstantiationScope = I->Scope;

  // Allow 'this' within late-parsed attributes.
  NamedDecl *ND = dyn_cast<NamedDecl>(I->NewDecl);
  CXXRecordDecl *ThisContext =
      dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
  CXXThisScopeRAII ThisScope(*this, ThisContext, /*TypeQuals*/0,
                             ND && ND->isCXXInstanceMember());

  Attr *NewAttr =
    instantiateTemplateAttribute(I->TmplAttr, Context, *this, TemplateArgs);
  I->NewDecl->addAttr(NewAttr);
  LocalInstantiationScope::deleteScopes(I->Scope,
                                        Instantiator.getStartingScope());
}
Instantiator.disableLateAttributeInstantiation();
LateAttrs.clear();

ActOnFinishDelayedMemberInitializers(Instantiation);

// FIXME: We should do something similar for explicit instantiations so they
// end up in the right module.
if (TSK == TSK_ImplicitInstantiation) {
  Instantiation->setLocation(Pattern->getLocation());
  Instantiation->setLocStart(Pattern->getInnerLocStart());
  Instantiation->setBraceRange(Pattern->getBraceRange());
}

if (!Instantiation->isInvalidDecl()) {
  // Perform any dependent diagnostics from the pattern.
  PerformDependentDiagnostics(Pattern, TemplateArgs);

  // Instantiate any out-of-line class template partial
  // specializations now.
  for (TemplateDeclInstantiator::delayed_partial_spec_iterator
            P = Instantiator.delayed_partial_spec_begin(),
         PEnd = Instantiator.delayed_partial_spec_end();
       P != PEnd; ++P) {
    if (!Instantiator.InstantiateClassTemplatePartialSpecialization(
            P->first, P->second)) {
      Instantiation->setInvalidDecl();
      break;
    }
  }

  // Instantiate any out-of-line variable template partial
  // specializations now.
  for (TemplateDeclInstantiator::delayed_var_partial_spec_iterator
            P = Instantiator.delayed_var_partial_spec_begin(),
         PEnd = Instantiator.delayed_var_partial_spec_end();
       P != PEnd; ++P) {
    if (!Instantiator.InstantiateVarTemplatePartialSpecialization(
            P->first, P->second)) {
      Instantiation->setInvalidDecl();
      break;
    }
  }
}

// Exit the scope of this instantiation.
SavedContext.pop();

if (!Instantiation->isInvalidDecl()) {
  Consumer.HandleTagDeclDefinition(Instantiation);

  // Always emit the vtable for an explicit instantiation definition
  // of a polymorphic class template specialization.
  if (TSK == TSK_ExplicitInstantiationDefinition)
    MarkVTableUsed(PointOfInstantiation, Instantiation, true);
}

return Instantiation->isInvalidDecl();
2216}

2218/// \brief Instantiate the definition of an enum from a given pattern.
2219///
2220/// \param PointOfInstantiation The point of instantiation within the
2221///        source code.
2222/// \param Instantiation is the declaration whose definition is being
2223///        instantiated. This will be a member enumeration of a class
2224///        temploid specialization, or a local enumeration within a
2225///        function temploid specialization.
2226/// \param Pattern The templated declaration from which the instantiation
2227///        occurs.
2228/// \param TemplateArgs The template arguments to be substituted into
2229///        the pattern.
2230/// \param TSK The kind of implicit or explicit instantiation to perform.
2231///
2232/// \return \c true if an error occurred, \c false otherwise.
2233bool Sema::InstantiateEnum(SourceLocation PointOfInstantiation,
                         EnumDecl *Instantiation, EnumDecl *Pattern,
                         const MultiLevelTemplateArgumentList &TemplateArgs,
                         TemplateSpecializationKind TSK) {
EnumDecl *PatternDef = Pattern->getDefinition();
if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
                               Instantiation->getInstantiatedFromMemberEnum(),
                                   Pattern, PatternDef, TSK,/*Complain*/true))
  return true;
Pattern = PatternDef;

// Record the point of instantiation.
if (MemberSpecializationInfo *MSInfo
      = Instantiation->getMemberSpecializationInfo()) {
  MSInfo->setTemplateSpecializationKind(TSK);
  MSInfo->setPointOfInstantiation(PointOfInstantiation);
}

InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
if (Inst.isInvalid())
  return true;
if (Inst.isAlreadyInstantiating())
  return false;
PrettyDeclStackTraceEntry CrashInfo(*this, Instantiation, SourceLocation(),
                                    "instantiating enum definition");

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

// Enter the scope of this instantiation. We don't use
// PushDeclContext because we don't have a scope.
ContextRAII SavedContext(*this, Instantiation);
EnterExpressionEvaluationContext EvalContext(
    *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);

LocalInstantiationScope Scope(*this, /*MergeWithParentScope*/true);

// Pull attributes from the pattern onto the instantiation.
InstantiateAttrs(TemplateArgs, Pattern, Instantiation);

TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
Instantiator.InstantiateEnumDefinition(Instantiation, Pattern);

// Exit the scope of this instantiation.
SavedContext.pop();

return Instantiation->isInvalidDecl();
2281}


2284/// \brief Instantiate the definition of a field from the given pattern.
2285///
2286/// \param PointOfInstantiation The point of instantiation within the
2287///        source code.
2288/// \param Instantiation is the declaration whose definition is being
2289///        instantiated. This will be a class of a class temploid
2290///        specialization, or a local enumeration within a function temploid
2291///        specialization.
2292/// \param Pattern The templated declaration from which the instantiation
2293///        occurs.
2294/// \param TemplateArgs The template arguments to be substituted into
2295///        the pattern.
2296///
2297/// \return \c true if an error occurred, \c false otherwise.
2298bool Sema::InstantiateInClassInitializer(
  SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
  FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs) {
// If there is no initializer, we don't need to do anything.
if (!Pattern->hasInClassInitializer())
  return false;

assert(Instantiation->getInClassInitStyle() ==(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2307, __extension__ __PRETTY_FUNCTION__))
           Pattern->getInClassInitStyle() &&(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2307, __extension__ __PRETTY_FUNCTION__))
       "pattern and instantiation disagree about init style")(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2307, __extension__ __PRETTY_FUNCTION__));

// Error out if we haven't parsed the initializer of the pattern yet because
// we are waiting for the closing brace of the outer class.
Expr *OldInit = Pattern->getInClassInitializer();
if (!OldInit) {
  RecordDecl *PatternRD = Pattern->getParent();
  RecordDecl *OutermostClass = PatternRD->getOuterLexicalRecordContext();
  Diag(PointOfInstantiation,
       diag::err_in_class_initializer_not_yet_parsed)
      << OutermostClass << Pattern;
  Diag(Pattern->getLocEnd(), diag::note_in_class_initializer_not_yet_parsed);
  Instantiation->setInvalidDecl();
  return true;
}

InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
if (Inst.isInvalid())
  return true;
if (Inst.isAlreadyInstantiating()) {
  // Error out if we hit an instantiation cycle for this initializer.
  Diag(PointOfInstantiation, diag::err_in_class_initializer_cycle)
    << Instantiation;
  return true;
}
PrettyDeclStackTraceEntry CrashInfo(*this, Instantiation, SourceLocation(),
                                    "instantiating default member init");

// Enter the scope of this instantiation. We don't use PushDeclContext because
// we don't have a scope.
ContextRAII SavedContext(*this, Instantiation->getParent());
EnterExpressionEvaluationContext EvalContext(
    *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);

LocalInstantiationScope Scope(*this, true);

// Instantiate the initializer.
ActOnStartCXXInClassMemberInitializer();
CXXThisScopeRAII ThisScope(*this, Instantiation->getParent(), /*TypeQuals=*/0);

ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs,
                                      /*CXXDirectInit=*/false);
Expr *Init = NewInit.get();
assert((!Init || !isa<ParenListExpr>(Init)) && "call-style init in class")(static_cast <bool> ((!Init || !isa<ParenListExpr>
(Init)) && "call-style init in class") ? void (0) : __assert_fail
 ("(!Init || !isa<ParenListExpr>(Init)) && \"call-style init in class\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2350, __extension__ __PRETTY_FUNCTION__));
ActOnFinishCXXInClassMemberInitializer(
    Instantiation, Init ? Init->getLocStart() : SourceLocation(), Init);

if (auto *L = getASTMutationListener())
  L->DefaultMemberInitializerInstantiated(Instantiation);

// Return true if the in-class initializer is still missing.
return !Instantiation->getInClassInitializer();
2359}

2361namespace {
/// \brief A partial specialization whose template arguments have matched
/// a given template-id.
struct PartialSpecMatchResult {
  ClassTemplatePartialSpecializationDecl *Partial;
  TemplateArgumentList *Args;
};
2368}

2370bool Sema::usesPartialOrExplicitSpecialization(
  SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec) {
if (ClassTemplateSpec->getTemplateSpecializationKind() ==
    TSK_ExplicitSpecialization)
  return true;

SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
ClassTemplateSpec->getSpecializedTemplate()
                 ->getPartialSpecializations(PartialSpecs);
for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
  TemplateDeductionInfo Info(Loc);
  if (!DeduceTemplateArguments(PartialSpecs[I],
                               ClassTemplateSpec->getTemplateArgs(), Info))
    return true;
}

return false;
2387}

2389/// Get the instantiation pattern to use to instantiate the definition of a
2390/// given ClassTemplateSpecializationDecl (either the pattern of the primary
2391/// template or of a partial specialization).
2392static CXXRecordDecl *
2393getPatternForClassTemplateSpecialization(
  Sema &S, SourceLocation PointOfInstantiation,
  ClassTemplateSpecializationDecl *ClassTemplateSpec,
  TemplateSpecializationKind TSK, bool Complain) {
Sema::InstantiatingTemplate Inst(S, PointOfInstantiation, ClassTemplateSpec);
if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
4
←
Taking false branch→
  return nullptr;

ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
CXXRecordDecl *Pattern = nullptr;

// C++ [temp.class.spec.match]p1:
//   When a class template is used in a context that requires an
//   instantiation of the class, it is necessary to determine
//   whether the instantiation is to be generated using the primary
//   template or one of the partial specializations. This is done by
//   matching the template arguments of the class template
//   specialization with the template argument lists of the partial
//   specializations.
typedef PartialSpecMatchResult MatchResult;
SmallVector<MatchResult, 4> Matched;
SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
Template->getPartialSpecializations(PartialSpecs);
TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation);
for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
5
←
Assuming 'I' is equal to 'N'→
6
←
Loop condition is false. Execution continues on line 2439→
  ClassTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
  TemplateDeductionInfo Info(FailedCandidates.getLocation());
  if (Sema::TemplateDeductionResult Result = S.DeduceTemplateArguments(
          Partial, ClassTemplateSpec->getTemplateArgs(), Info)) {
    // Store the failed-deduction information for use in diagnostics, later.
    // TODO: Actually use the failed-deduction info?
    FailedCandidates.addCandidate().set(
        DeclAccessPair::make(Template, AS_public), Partial,
        MakeDeductionFailureInfo(S.Context, Result, Info));
    (void)Result;
  } else {
    Matched.push_back(PartialSpecMatchResult());
    Matched.back().Partial = Partial;
    Matched.back().Args = Info.take();
  }
}

// If we're dealing with a member template where the template parameters
// have been instantiated, this provides the original template parameters
// from which the member template's parameters were instantiated.

if (Matched.size() >= 1) {
7
←
Assuming the condition is true→
8
←
Taking true branch→
  SmallVectorImpl<MatchResult>::iterator Best = Matched.begin();
  if (Matched.size() == 1) {
9
←
Assuming the condition is true→
10
←
Taking true branch→
    //   -- If exactly one matching specialization is found, the
    //      instantiation is generated from that specialization.
    // We don't need to do anything for this.
  } else {
    //   -- If more than one matching specialization is found, the
    //      partial order rules (14.5.4.2) are used to determine
    //      whether one of the specializations is more specialized
    //      than the others. If none of the specializations is more
    //      specialized than all of the other matching
    //      specializations, then the use of the class template is
    //      ambiguous and the program is ill-formed.
    for (SmallVectorImpl<MatchResult>::iterator P = Best + 1,
                                             PEnd = Matched.end();
         P != PEnd; ++P) {
      if (S.getMoreSpecializedPartialSpecialization(
              P->Partial, Best->Partial, PointOfInstantiation) == P->Partial)
        Best = P;
    }
    
    // Determine if the best partial specialization is more specialized than
    // the others.
    bool Ambiguous = false;
    for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(),
                                             PEnd = Matched.end();
         P != PEnd; ++P) {
      if (P != Best &&
          S.getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
                                                    PointOfInstantiation) !=
              Best->Partial) {
        Ambiguous = true;
        break;
      }
    }
     
    if (Ambiguous) {
      // Partial ordering did not produce a clear winner. Complain.
      Inst.Clear();
      ClassTemplateSpec->setInvalidDecl();
      S.Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
        << ClassTemplateSpec;
      
      // Print the matching partial specializations.
      for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(),
                                               PEnd = Matched.end();
           P != PEnd; ++P)
        S.Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
          << S.getTemplateArgumentBindingsText(
                 P->Partial->getTemplateParameters(), *P->Args);

      return nullptr;
    }
  }
  
  // Instantiate using the best class template partial specialization.
  ClassTemplatePartialSpecializationDecl *OrigPartialSpec = Best->Partial;
  while (OrigPartialSpec->getInstantiatedFromMember()) {
11
←
Loop condition is false. Execution continues on line 2506→
    // If we've found an explicit specialization of this class template,
    // stop here and use that as the pattern.
    if (OrigPartialSpec->isMemberSpecialization())
      break;
    
    OrigPartialSpec = OrigPartialSpec->getInstantiatedFromMember();
  }
  
  Pattern = OrigPartialSpec;
  ClassTemplateSpec->setInstantiationOf(Best->Partial, Best->Args);
12
←
Calling 'ClassTemplateSpecializationDecl::setInstantiationOf'→
} else {
  //   -- If no matches are found, the instantiation is generated
  //      from the primary template.
  ClassTemplateDecl *OrigTemplate = Template;
  while (OrigTemplate->getInstantiatedFromMemberTemplate()) {
    // If we've found an explicit specialization of this class template,
    // stop here and use that as the pattern.
    if (OrigTemplate->isMemberSpecialization())
      break;
    
    OrigTemplate = OrigTemplate->getInstantiatedFromMemberTemplate();
  }
  
  Pattern = OrigTemplate->getTemplatedDecl();
}

return Pattern;
2525}

2527bool Sema::InstantiateClassTemplateSpecialization(
  SourceLocation PointOfInstantiation,
  ClassTemplateSpecializationDecl *ClassTemplateSpec,
  TemplateSpecializationKind TSK, bool Complain) {
// Perform the actual instantiation on the canonical declaration.
ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
    ClassTemplateSpec->getCanonicalDecl());
if (ClassTemplateSpec->isInvalidDecl())
1
Assuming the condition is false→
2
←
Taking false branch→
  return true;

CXXRecordDecl *Pattern = getPatternForClassTemplateSpecialization(
3
←
Calling 'getPatternForClassTemplateSpecialization'→
    *this, PointOfInstantiation, ClassTemplateSpec, TSK, Complain);
if (!Pattern)
  return true;

return InstantiateClass(PointOfInstantiation, ClassTemplateSpec, Pattern,
                        getTemplateInstantiationArgs(ClassTemplateSpec), TSK,
                        Complain);
2545}

2547/// \brief Instantiates the definitions of all of the member
2548/// of the given class, which is an instantiation of a class template
2549/// or a member class of a template.
2550void
2551Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation,
                            CXXRecordDecl *Instantiation,
                      const MultiLevelTemplateArgumentList &TemplateArgs,
                            TemplateSpecializationKind TSK) {
// FIXME: We need to notify the ASTMutationListener that we did all of these
// things, in case we have an explicit instantiation definition in a PCM, a
// module, or preamble, and the declaration is in an imported AST.
assert((static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
 || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
 && Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2562, __extension__ __PRETTY_FUNCTION__))
    (TSK == TSK_ExplicitInstantiationDefinition ||(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
 || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
 && Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2562, __extension__ __PRETTY_FUNCTION__))
     TSK == TSK_ExplicitInstantiationDeclaration ||(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
 || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
 && Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2562, __extension__ __PRETTY_FUNCTION__))
     (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) &&(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
 || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
 && Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2562, __extension__ __PRETTY_FUNCTION__))
    "Unexpected template specialization kind!")(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
 || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
 && Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2562, __extension__ __PRETTY_FUNCTION__));
for (auto *D : Instantiation->decls()) {
  bool SuppressNew = false;
  if (auto *Function = dyn_cast<FunctionDecl>(D)) {
    if (FunctionDecl *Pattern
          = Function->getInstantiatedFromMemberFunction()) {
      MemberSpecializationInfo *MSInfo 
        = Function->getMemberSpecializationInfo();
      assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2570, __extension__ __PRETTY_FUNCTION__));
      if (MSInfo->getTemplateSpecializationKind()
                                               == TSK_ExplicitSpecialization)
        continue;
      
      if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK, 
                                                 Function, 
                                      MSInfo->getTemplateSpecializationKind(),
                                            MSInfo->getPointOfInstantiation(),
                                                 SuppressNew) ||
          SuppressNew)
        continue;

      // C++11 [temp.explicit]p8:
      //   An explicit instantiation definition that names a class template
      //   specialization explicitly instantiates the class template
      //   specialization and is only an explicit instantiation definition
      //   of members whose definition is visible at the point of
      //   instantiation.
      if (TSK == TSK_ExplicitInstantiationDefinition && !Pattern->isDefined())
        continue;

      Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);

      if (Function->isDefined()) {
        // Let the ASTConsumer know that this function has been explicitly
        // instantiated now, and its linkage might have changed.
        Consumer.HandleTopLevelDecl(DeclGroupRef(Function));
      } else if (TSK == TSK_ExplicitInstantiationDefinition) {
        InstantiateFunctionDefinition(PointOfInstantiation, Function);
      } else if (TSK == TSK_ImplicitInstantiation) {
        PendingLocalImplicitInstantiations.push_back(
            std::make_pair(Function, PointOfInstantiation));
      }
    }
  } else if (auto *Var = dyn_cast<VarDecl>(D)) {
    if (isa<VarTemplateSpecializationDecl>(Var))
      continue;

    if (Var->isStaticDataMember()) {
      MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo();
      assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2611, __extension__ __PRETTY_FUNCTION__));
      if (MSInfo->getTemplateSpecializationKind()
                                               == TSK_ExplicitSpecialization)
        continue;
      
      if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK, 
                                                 Var, 
                                      MSInfo->getTemplateSpecializationKind(),
                                            MSInfo->getPointOfInstantiation(),
                                                 SuppressNew) ||
          SuppressNew)
        continue;
      
      if (TSK == TSK_ExplicitInstantiationDefinition) {
        // C++0x [temp.explicit]p8:
        //   An explicit instantiation definition that names a class template
        //   specialization explicitly instantiates the class template 
        //   specialization and is only an explicit instantiation definition 
        //   of members whose definition is visible at the point of 
        //   instantiation.
        if (!Var->getInstantiatedFromStaticDataMember()->getDefinition())
          continue;
        
        Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
        InstantiateVariableDefinition(PointOfInstantiation, Var);
      } else {
        Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
      }
    }      
  } else if (auto *Record = dyn_cast<CXXRecordDecl>(D)) {
    // Always skip the injected-class-name, along with any
    // redeclarations of nested classes, since both would cause us
    // to try to instantiate the members of a class twice.
    // Skip closure types; they'll get instantiated when we instantiate
    // the corresponding lambda-expression.
    if (Record->isInjectedClassName() || Record->getPreviousDecl() ||
        Record->isLambda())
      continue;
    
    MemberSpecializationInfo *MSInfo = Record->getMemberSpecializationInfo();
    assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2651, __extension__ __PRETTY_FUNCTION__));
    
    if (MSInfo->getTemplateSpecializationKind()
                                              == TSK_ExplicitSpecialization)
      continue;

    if ((Context.getTargetInfo().getCXXABI().isMicrosoft() ||
         Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment()) &&
        TSK == TSK_ExplicitInstantiationDeclaration) {
      // In MSVC and Windows Itanium mode, explicit instantiation decl of the
      // outer class doesn't affect the inner class.
      continue;
    }

    if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK, 
                                               Record, 
                                      MSInfo->getTemplateSpecializationKind(),
                                            MSInfo->getPointOfInstantiation(),
                                               SuppressNew) ||
        SuppressNew)
      continue;
    
    CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
    assert(Pattern && "Missing instantiated-from-template information")(static_cast <bool> (Pattern && "Missing instantiated-from-template information"
) ? void (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2674, __extension__ __PRETTY_FUNCTION__));
    
    if (!Record->getDefinition()) {
      if (!Pattern->getDefinition()) {
        // C++0x [temp.explicit]p8:
        //   An explicit instantiation definition that names a class template
        //   specialization explicitly instantiates the class template 
        //   specialization and is only an explicit instantiation definition 
        //   of members whose definition is visible at the point of 
        //   instantiation.
        if (TSK == TSK_ExplicitInstantiationDeclaration) {
          MSInfo->setTemplateSpecializationKind(TSK);
          MSInfo->setPointOfInstantiation(PointOfInstantiation);
        }
        
        continue;
      }
      
      InstantiateClass(PointOfInstantiation, Record, Pattern,
                       TemplateArgs,
                       TSK);
    } else {
      if (TSK == TSK_ExplicitInstantiationDefinition &&
          Record->getTemplateSpecializationKind() ==
              TSK_ExplicitInstantiationDeclaration) {
        Record->setTemplateSpecializationKind(TSK);
        MarkVTableUsed(PointOfInstantiation, Record, true);
      }
    }
    
    Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
    if (Pattern)
      InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs, 
                              TSK);
  } else if (auto *Enum = dyn_cast<EnumDecl>(D)) {
    MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo();
    assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2710, __extension__ __PRETTY_FUNCTION__));

    if (MSInfo->getTemplateSpecializationKind()
          == TSK_ExplicitSpecialization)
      continue;

    if (CheckSpecializationInstantiationRedecl(
          PointOfInstantiation, TSK, Enum,
          MSInfo->getTemplateSpecializationKind(),
          MSInfo->getPointOfInstantiation(), SuppressNew) ||
        SuppressNew)
      continue;

    if (Enum->getDefinition())
      continue;

    EnumDecl *Pattern = Enum->getTemplateInstantiationPattern();
    assert(Pattern && "Missing instantiated-from-template information")(static_cast <bool> (Pattern && "Missing instantiated-from-template information"
) ? void (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2727, __extension__ __PRETTY_FUNCTION__));

    if (TSK == TSK_ExplicitInstantiationDefinition) {
      if (!Pattern->getDefinition())
        continue;

      InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
    } else {
      MSInfo->setTemplateSpecializationKind(TSK);
      MSInfo->setPointOfInstantiation(PointOfInstantiation);
    }
  } else if (auto *Field = dyn_cast<FieldDecl>(D)) {
    // No need to instantiate in-class initializers during explicit
    // instantiation.
    if (Field->hasInClassInitializer() && TSK == TSK_ImplicitInstantiation) {
      CXXRecordDecl *ClassPattern =
          Instantiation->getTemplateInstantiationPattern();
      DeclContext::lookup_result Lookup =
          ClassPattern->lookup(Field->getDeclName());
      FieldDecl *Pattern = cast<FieldDecl>(Lookup.front());
      InstantiateInClassInitializer(PointOfInstantiation, Field, Pattern,
                                    TemplateArgs);
    }
  }
}
2752}

2754/// \brief Instantiate the definitions of all of the members of the
2755/// given class template specialization, which was named as part of an
2756/// explicit instantiation.
2757void
2758Sema::InstantiateClassTemplateSpecializationMembers(
                                         SourceLocation PointOfInstantiation,
                          ClassTemplateSpecializationDecl *ClassTemplateSpec,
                                             TemplateSpecializationKind TSK) {
// C++0x [temp.explicit]p7:
//   An explicit instantiation that names a class template
//   specialization is an explicit instantion of the same kind
//   (declaration or definition) of each of its members (not
//   including members inherited from base classes) that has not
//   been previously explicitly specialized in the translation unit
//   containing the explicit instantiation, except as described
//   below.
InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec,
                        getTemplateInstantiationArgs(ClassTemplateSpec),
                        TSK);
2773}

2775StmtResult
2776Sema::SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs) {
if (!S)
  return S;

TemplateInstantiator Instantiator(*this, TemplateArgs,
                                  SourceLocation(),
                                  DeclarationName());
return Instantiator.TransformStmt(S);
2784}

2786ExprResult
2787Sema::SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs) {
if (!E)
  return E;

TemplateInstantiator Instantiator(*this, TemplateArgs,
                                  SourceLocation(),
                                  DeclarationName());
return Instantiator.TransformExpr(E);
2795}

2797ExprResult Sema::SubstInitializer(Expr *Init,
                        const MultiLevelTemplateArgumentList &TemplateArgs,
                        bool CXXDirectInit) {
TemplateInstantiator Instantiator(*this, TemplateArgs,
                                  SourceLocation(),
                                  DeclarationName());
return Instantiator.TransformInitializer(Init, CXXDirectInit);
2804}

2806bool Sema::SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
                    const MultiLevelTemplateArgumentList &TemplateArgs,
                    SmallVectorImpl<Expr *> &Outputs) {
if (Exprs.empty())
  return false;

TemplateInstantiator Instantiator(*this, TemplateArgs,
                                  SourceLocation(),
                                  DeclarationName());
return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
                                   IsCall, Outputs);
2817}

2819NestedNameSpecifierLoc
2820Sema::SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
                      const MultiLevelTemplateArgumentList &TemplateArgs) {  
if (!NNS)
  return NestedNameSpecifierLoc();

TemplateInstantiator Instantiator(*this, TemplateArgs, NNS.getBeginLoc(),
                                  DeclarationName());
return Instantiator.TransformNestedNameSpecifierLoc(NNS);
2828}

2830/// \brief Do template substitution on declaration name info.
2831DeclarationNameInfo
2832Sema::SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
                       const MultiLevelTemplateArgumentList &TemplateArgs) {
TemplateInstantiator Instantiator(*this, TemplateArgs, NameInfo.getLoc(),
                                  NameInfo.getName());
return Instantiator.TransformDeclarationNameInfo(NameInfo);
2837}

2839TemplateName
2840Sema::SubstTemplateName(NestedNameSpecifierLoc QualifierLoc,
                      TemplateName Name, SourceLocation Loc,
                      const MultiLevelTemplateArgumentList &TemplateArgs) {
TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
                                  DeclarationName());
CXXScopeSpec SS;
SS.Adopt(QualifierLoc);
return Instantiator.TransformTemplateName(SS, Name, Loc);
2848}

2850bool Sema::Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
               TemplateArgumentListInfo &Result,
               const MultiLevelTemplateArgumentList &TemplateArgs) {
TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
                                  DeclarationName());

return Instantiator.TransformTemplateArguments(Args, NumArgs, Result);
2857}

2859static const Decl *getCanonicalParmVarDecl(const Decl *D) {
// When storing ParmVarDecls in the local instantiation scope, we always
// want to use the ParmVarDecl from the canonical function declaration,
// since the map is then valid for any redeclaration or definition of that
// function.
if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
    unsigned i = PV->getFunctionScopeIndex();
    // This parameter might be from a freestanding function type within the
    // function and isn't necessarily referring to one of FD's parameters.
    if (FD->getParamDecl(i) == PV)
      return FD->getCanonicalDecl()->getParamDecl(i);
  }
}
return D;
2874}


2877llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
2878LocalInstantiationScope::findInstantiationOf(const Decl *D) {
D = getCanonicalParmVarDecl(D);
for (LocalInstantiationScope *Current = this; Current;
     Current = Current->Outer) {

  // Check if we found something within this scope.
  const Decl *CheckD = D;
  do {
    LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD);
    if (Found != Current->LocalDecls.end())
      return &Found->second;
    
    // If this is a tag declaration, it's possible that we need to look for
    // a previous declaration.
    if (const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
      CheckD = Tag->getPreviousDecl();
    else
      CheckD = nullptr;
  } while (CheckD);
  
  // If we aren't combined with our outer scope, we're done. 
  if (!Current->CombineWithOuterScope)
    break;
}

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

// Local types referenced prior to definition may require instantiation.
if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
  if (RD->isLocalClass())
    return nullptr;

// Enumeration types referenced prior to definition may appear as a result of
// error recovery.
if (isa<EnumDecl>(D))
  return nullptr;

// If we didn't find the decl, then we either have a sema bug, or we have a
// forward reference to a label declaration.  Return null to indicate that
// we have an uninstantiated label.
assert(isa<LabelDecl>(D) && "declaration not instantiated in this scope")(static_cast <bool> (isa<LabelDecl>(D) &&
 "declaration not instantiated in this scope") ? void (0) : __assert_fail
 ("isa<LabelDecl>(D) && \"declaration not instantiated in this scope\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2922, __extension__ __PRETTY_FUNCTION__));
return nullptr;
2924}

2926void LocalInstantiationScope::InstantiatedLocal(const Decl *D, Decl *Inst) {
D = getCanonicalParmVarDecl(D);
llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
if (Stored.isNull()) {
2930#ifndef NDEBUG
  // It should not be present in any surrounding scope either.
  LocalInstantiationScope *Current = this;
  while (Current->CombineWithOuterScope && Current->Outer) {
    Current = Current->Outer;
    assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Instantiated local in inner and outer scopes"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2936, __extension__ __PRETTY_FUNCTION__))
           "Instantiated local in inner and outer scopes")(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Instantiated local in inner and outer scopes"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2936, __extension__ __PRETTY_FUNCTION__));
  }
2938#endif
  Stored = Inst;
} else if (DeclArgumentPack *Pack = Stored.dyn_cast<DeclArgumentPack *>()) {
  Pack->push_back(cast<ParmVarDecl>(Inst));
} else {
  assert(Stored.get<Decl *>() == Inst && "Already instantiated this local")(static_cast <bool> (Stored.get<Decl *>() == Inst
 && "Already instantiated this local") ? void (0) : __assert_fail
 ("Stored.get<Decl *>() == Inst && \"Already instantiated this local\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2943, __extension__ __PRETTY_FUNCTION__));
}
2945}

2947void LocalInstantiationScope::InstantiatedLocalPackArg(const Decl *D,
                                                     ParmVarDecl *Inst) {
D = getCanonicalParmVarDecl(D);
DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>();
Pack->push_back(Inst);
2952}

2954void LocalInstantiationScope::MakeInstantiatedLocalArgPack(const Decl *D) {
2955#ifndef NDEBUG
// This should be the first time we've been told about this decl.
for (LocalInstantiationScope *Current = this;
     Current && Current->CombineWithOuterScope; Current = Current->Outer)
  assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Creating local pack after instantiation of local"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2960, __extension__ __PRETTY_FUNCTION__))
         "Creating local pack after instantiation of local")(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Creating local pack after instantiation of local"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2960, __extension__ __PRETTY_FUNCTION__));
2961#endif

D = getCanonicalParmVarDecl(D);
llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
DeclArgumentPack *Pack = new DeclArgumentPack;
Stored = Pack;
ArgumentPacks.push_back(Pack);
2968}

2970void LocalInstantiationScope::SetPartiallySubstitutedPack(NamedDecl *Pack, 
                                        const TemplateArgument *ExplicitArgs,
                                                  unsigned NumExplicitArgs) {
assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&(static_cast <bool> ((!PartiallySubstitutedPack || PartiallySubstitutedPack
 == Pack) && "Already have a partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2974, __extension__ __PRETTY_FUNCTION__))
       "Already have a partially-substituted pack")(static_cast <bool> ((!PartiallySubstitutedPack || PartiallySubstitutedPack
 == Pack) && "Already have a partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2974, __extension__ __PRETTY_FUNCTION__));
assert((!PartiallySubstitutedPack(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
 == NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2977, __extension__ __PRETTY_FUNCTION__)) 
        || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
 == NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2977, __extension__ __PRETTY_FUNCTION__))
       "Wrong number of arguments in partially-substituted pack")(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
 == NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-7~svn326551/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2977, __extension__ __PRETTY_FUNCTION__));
PartiallySubstitutedPack = Pack;
ArgsInPartiallySubstitutedPack = ExplicitArgs;
NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
2981}

2983NamedDecl *LocalInstantiationScope::getPartiallySubstitutedPack(
                                       const TemplateArgument **ExplicitArgs,
                                            unsigned *NumExplicitArgs) const {
if (ExplicitArgs)
  *ExplicitArgs = nullptr;
if (NumExplicitArgs)
  *NumExplicitArgs = 0;

for (const LocalInstantiationScope *Current = this; Current; 
     Current = Current->Outer) {
  if (Current->PartiallySubstitutedPack) {
    if (ExplicitArgs)
      *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
    if (NumExplicitArgs)
      *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
    
    return Current->PartiallySubstitutedPack;
  }

  if (!Current->CombineWithOuterScope)
    break;
}

return nullptr;
3007}

←

/build/llvm-toolchain-snapshot-7~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/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~svn326551/tools/clang/include/clang/AST/DeclTemplate.h"
, 1824, __extension__ __PRETTY_FUNCTION__));
  SpecializedPartialSpecialization *PS
13
←
'PS' initialized to a null pointer value→
    = new (getASTContext()) SpecializedPartialSpecialization();
  PS->PartialSpecialization = PartialSpec;
14
←
Access to field 'PartialSpecialization' results in a dereference of a null pointer (loaded from variable 'PS')
  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~svn326551/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~svn326551/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)
    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();
}

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