/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp

Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaTemplate.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~svn326246/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326246/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~svn326246/build-llvm/tools/clang/lib/Sema -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-02-28-041547-14988-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp

/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp

→

1//===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===//
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 semantic analysis for C++ templates.
10//===----------------------------------------------------------------------===//

12#include "TreeTransform.h"
13#include "clang/AST/ASTConsumer.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/DeclFriend.h"
16#include "clang/AST/DeclTemplate.h"
17#include "clang/AST/Expr.h"
18#include "clang/AST/ExprCXX.h"
19#include "clang/AST/RecursiveASTVisitor.h"
20#include "clang/AST/TypeVisitor.h"
21#include "clang/Basic/Builtins.h"
22#include "clang/Basic/LangOptions.h"
23#include "clang/Basic/PartialDiagnostic.h"
24#include "clang/Basic/TargetInfo.h"
25#include "clang/Sema/DeclSpec.h"
26#include "clang/Sema/Lookup.h"
27#include "clang/Sema/ParsedTemplate.h"
28#include "clang/Sema/Scope.h"
29#include "clang/Sema/SemaInternal.h"
30#include "clang/Sema/Template.h"
31#include "clang/Sema/TemplateDeduction.h"
32#include "llvm/ADT/SmallBitVector.h"
33#include "llvm/ADT/SmallString.h"
34#include "llvm/ADT/StringExtras.h"

36#include <iterator>
37using namespace clang;
38using namespace sema;

40// Exported for use by Parser.
41SourceRange
42clang::getTemplateParamsRange(TemplateParameterList const * const *Ps,
                            unsigned N) {
if (!N) return SourceRange();
return SourceRange(Ps[0]->getTemplateLoc(), Ps[N-1]->getRAngleLoc());
46}

48namespace clang {
49/// \brief [temp.constr.decl]p2: A template's associated constraints are
50/// defined as a single constraint-expression derived from the introduced
51/// constraint-expressions [ ... ].
52///
53/// \param Params The template parameter list and optional requires-clause.
54///
55/// \param FD The underlying templated function declaration for a function
56/// template.
57static Expr *formAssociatedConstraints(TemplateParameterList *Params,
                                     FunctionDecl *FD);
59}

61static Expr *clang::formAssociatedConstraints(TemplateParameterList *Params,
                                            FunctionDecl *FD) {
// FIXME: Concepts: collect additional introduced constraint-expressions
assert(!FD && "Cannot collect constraints from function declaration yet.")(static_cast <bool> (!FD && "Cannot collect constraints from function declaration yet."
) ? void (0) : __assert_fail ("!FD && \"Cannot collect constraints from function declaration yet.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 64, __extension__ __PRETTY_FUNCTION__));
return Params->getRequiresClause();
66}

68/// \brief Determine whether the declaration found is acceptable as the name
69/// of a template and, if so, return that template declaration. Otherwise,
70/// returns NULL.
71static NamedDecl *isAcceptableTemplateName(ASTContext &Context,
                                         NamedDecl *Orig,
                                         bool AllowFunctionTemplates) {
NamedDecl *D = Orig->getUnderlyingDecl();

if (isa<TemplateDecl>(D)) {
  if (!AllowFunctionTemplates && isa<FunctionTemplateDecl>(D))
    return nullptr;

  return Orig;
}

if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
  // C++ [temp.local]p1:
  //   Like normal (non-template) classes, class templates have an
  //   injected-class-name (Clause 9). The injected-class-name
  //   can be used with or without a template-argument-list. When
  //   it is used without a template-argument-list, it is
  //   equivalent to the injected-class-name followed by the
  //   template-parameters of the class template enclosed in
  //   <>. When it is used with a template-argument-list, it
  //   refers to the specified class template specialization,
  //   which could be the current specialization or another
  //   specialization.
  if (Record->isInjectedClassName()) {
    Record = cast<CXXRecordDecl>(Record->getDeclContext());
    if (Record->getDescribedClassTemplate())
      return Record->getDescribedClassTemplate();

    if (ClassTemplateSpecializationDecl *Spec
          = dyn_cast<ClassTemplateSpecializationDecl>(Record))
      return Spec->getSpecializedTemplate();
  }

  return nullptr;
}

return nullptr;
109}

111void Sema::FilterAcceptableTemplateNames(LookupResult &R,
                                       bool AllowFunctionTemplates) {
// The set of class templates we've already seen.
llvm::SmallPtrSet<ClassTemplateDecl *, 8> ClassTemplates;
LookupResult::Filter filter = R.makeFilter();
while (filter.hasNext()) {
  NamedDecl *Orig = filter.next();
  NamedDecl *Repl = isAcceptableTemplateName(Context, Orig,
                                             AllowFunctionTemplates);
  if (!Repl)
    filter.erase();
  else if (Repl != Orig) {

    // C++ [temp.local]p3:
    //   A lookup that finds an injected-class-name (10.2) can result in an
    //   ambiguity in certain cases (for example, if it is found in more than
    //   one base class). If all of the injected-class-names that are found
    //   refer to specializations of the same class template, and if the name
    //   is used as a template-name, the reference refers to the class
    //   template itself and not a specialization thereof, and is not
    //   ambiguous.
    if (ClassTemplateDecl *ClassTmpl = dyn_cast<ClassTemplateDecl>(Repl))
      if (!ClassTemplates.insert(ClassTmpl).second) {
        filter.erase();
        continue;
      }

    // FIXME: we promote access to public here as a workaround to
    // the fact that LookupResult doesn't let us remember that we
    // found this template through a particular injected class name,
    // which means we end up doing nasty things to the invariants.
    // Pretending that access is public is *much* safer.
    filter.replace(Repl, AS_public);
  }
}
filter.done();
147}

149bool Sema::hasAnyAcceptableTemplateNames(LookupResult &R,
                                       bool AllowFunctionTemplates) {
for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I)
  if (isAcceptableTemplateName(Context, *I, AllowFunctionTemplates))
    return true;

return false;
156}

158TemplateNameKind Sema::isTemplateName(Scope *S,
                                    CXXScopeSpec &SS,
                                    bool hasTemplateKeyword,
                                    UnqualifiedId &Name,
                                    ParsedType ObjectTypePtr,
                                    bool EnteringContext,
                                    TemplateTy &TemplateResult,
                                    bool &MemberOfUnknownSpecialization) {
assert(getLangOpts().CPlusPlus && "No template names in C!")(static_cast <bool> (getLangOpts().CPlusPlus &&
 "No template names in C!") ? void (0) : __assert_fail ("getLangOpts().CPlusPlus && \"No template names in C!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 166, __extension__ __PRETTY_FUNCTION__));

DeclarationName TName;
MemberOfUnknownSpecialization = false;

switch (Name.getKind()) {
case UnqualifiedIdKind::IK_Identifier:
  TName = DeclarationName(Name.Identifier);
  break;

case UnqualifiedIdKind::IK_OperatorFunctionId:
  TName = Context.DeclarationNames.getCXXOperatorName(
                                            Name.OperatorFunctionId.Operator);
  break;

case UnqualifiedIdKind::IK_LiteralOperatorId:
  TName = Context.DeclarationNames.getCXXLiteralOperatorName(Name.Identifier);
  break;

default:
  return TNK_Non_template;
}

QualType ObjectType = ObjectTypePtr.get();

LookupResult R(*this, TName, Name.getLocStart(), LookupOrdinaryName);
LookupTemplateName(R, S, SS, ObjectType, EnteringContext,
                   MemberOfUnknownSpecialization);
if (R.empty()) return TNK_Non_template;
if (R.isAmbiguous()) {
  // Suppress diagnostics;  we'll redo this lookup later.
  R.suppressDiagnostics();

  // FIXME: we might have ambiguous templates, in which case we
  // should at least parse them properly!
  return TNK_Non_template;
}

TemplateName Template;
TemplateNameKind TemplateKind;

unsigned ResultCount = R.end() - R.begin();
if (ResultCount > 1) {
  // We assume that we'll preserve the qualifier from a function
  // template name in other ways.
  Template = Context.getOverloadedTemplateName(R.begin(), R.end());
  TemplateKind = TNK_Function_template;

  // We'll do this lookup again later.
  R.suppressDiagnostics();
} else {
  TemplateDecl *TD = cast<TemplateDecl>((*R.begin())->getUnderlyingDecl());

  if (SS.isSet() && !SS.isInvalid()) {
    NestedNameSpecifier *Qualifier = SS.getScopeRep();
    Template = Context.getQualifiedTemplateName(Qualifier,
                                                hasTemplateKeyword, TD);
  } else {
    Template = TemplateName(TD);
  }

  if (isa<FunctionTemplateDecl>(TD)) {
    TemplateKind = TNK_Function_template;

    // We'll do this lookup again later.
    R.suppressDiagnostics();
  } else {
    assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||(static_cast <bool> (isa<ClassTemplateDecl>(TD) ||
 isa<TemplateTemplateParmDecl>(TD) || isa<TypeAliasTemplateDecl
>(TD) || isa<VarTemplateDecl>(TD) || isa<BuiltinTemplateDecl
>(TD)) ? void (0) : __assert_fail ("isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) || isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) || isa<BuiltinTemplateDecl>(TD)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 235, __extension__ __PRETTY_FUNCTION__))
           isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||(static_cast <bool> (isa<ClassTemplateDecl>(TD) ||
 isa<TemplateTemplateParmDecl>(TD) || isa<TypeAliasTemplateDecl
>(TD) || isa<VarTemplateDecl>(TD) || isa<BuiltinTemplateDecl
>(TD)) ? void (0) : __assert_fail ("isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) || isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) || isa<BuiltinTemplateDecl>(TD)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 235, __extension__ __PRETTY_FUNCTION__))
           isa<BuiltinTemplateDecl>(TD))(static_cast <bool> (isa<ClassTemplateDecl>(TD) ||
 isa<TemplateTemplateParmDecl>(TD) || isa<TypeAliasTemplateDecl
>(TD) || isa<VarTemplateDecl>(TD) || isa<BuiltinTemplateDecl
>(TD)) ? void (0) : __assert_fail ("isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) || isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) || isa<BuiltinTemplateDecl>(TD)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 235, __extension__ __PRETTY_FUNCTION__));
    TemplateKind =
        isa<VarTemplateDecl>(TD) ? TNK_Var_template : TNK_Type_template;
  }
}

TemplateResult = TemplateTy::make(Template);
return TemplateKind;
243}

245bool Sema::isDeductionGuideName(Scope *S, const IdentifierInfo &Name,
                              SourceLocation NameLoc,
                              ParsedTemplateTy *Template) {
CXXScopeSpec SS;
bool MemberOfUnknownSpecialization = false;

// We could use redeclaration lookup here, but we don't need to: the
// syntactic form of a deduction guide is enough to identify it even
// if we can't look up the template name at all.
LookupResult R(*this, DeclarationName(&Name), NameLoc, LookupOrdinaryName);
LookupTemplateName(R, S, SS, /*ObjectType*/QualType(),
                   /*EnteringContext*/false, MemberOfUnknownSpecialization);

if (R.empty()) return false;
if (R.isAmbiguous()) {
  // FIXME: Diagnose an ambiguity if we find at least one template.
  R.suppressDiagnostics();
  return false;
}

// We only treat template-names that name type templates as valid deduction
// guide names.
TemplateDecl *TD = R.getAsSingle<TemplateDecl>();
if (!TD || !getAsTypeTemplateDecl(TD))
  return false;

if (Template)
  *Template = TemplateTy::make(TemplateName(TD));
return true;
274}

276bool Sema::DiagnoseUnknownTemplateName(const IdentifierInfo &II,
                                     SourceLocation IILoc,
                                     Scope *S,
                                     const CXXScopeSpec *SS,
                                     TemplateTy &SuggestedTemplate,
                                     TemplateNameKind &SuggestedKind) {
// We can't recover unless there's a dependent scope specifier preceding the
// template name.
// FIXME: Typo correction?
if (!SS || !SS->isSet() || !isDependentScopeSpecifier(*SS) ||
    computeDeclContext(*SS))
  return false;

// The code is missing a 'template' keyword prior to the dependent template
// name.
NestedNameSpecifier *Qualifier = (NestedNameSpecifier*)SS->getScopeRep();
Diag(IILoc, diag::err_template_kw_missing)
  << Qualifier << II.getName()
  << FixItHint::CreateInsertion(IILoc, "template ");
SuggestedTemplate
  = TemplateTy::make(Context.getDependentTemplateName(Qualifier, &II));
SuggestedKind = TNK_Dependent_template_name;
return true;
299}

301void Sema::LookupTemplateName(LookupResult &Found,
                            Scope *S, CXXScopeSpec &SS,
                            QualType ObjectType,
                            bool EnteringContext,
                            bool &MemberOfUnknownSpecialization) {
// Determine where to perform name lookup
MemberOfUnknownSpecialization = false;
DeclContext *LookupCtx = nullptr;
bool isDependent = false;
if (!ObjectType.isNull()) {
  // This nested-name-specifier occurs in a member access expression, e.g.,
  // x->B::f, and we are looking into the type of the object.
  assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist")(static_cast <bool> (!SS.isSet() && "ObjectType and scope specifier cannot coexist"
) ? void (0) : __assert_fail ("!SS.isSet() && \"ObjectType and scope specifier cannot coexist\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 313, __extension__ __PRETTY_FUNCTION__));
  LookupCtx = computeDeclContext(ObjectType);
  isDependent = ObjectType->isDependentType();
  assert((isDependent || !ObjectType->isIncompleteType() ||(static_cast <bool> ((isDependent || !ObjectType->isIncompleteType
() || ObjectType->castAs<TagType>()->isBeingDefined
()) && "Caller should have completed object type") ? void
 (0) : __assert_fail ("(isDependent || !ObjectType->isIncompleteType() || ObjectType->castAs<TagType>()->isBeingDefined()) && \"Caller should have completed object type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 318, __extension__ __PRETTY_FUNCTION__))
          ObjectType->castAs<TagType>()->isBeingDefined()) &&(static_cast <bool> ((isDependent || !ObjectType->isIncompleteType
() || ObjectType->castAs<TagType>()->isBeingDefined
()) && "Caller should have completed object type") ? void
 (0) : __assert_fail ("(isDependent || !ObjectType->isIncompleteType() || ObjectType->castAs<TagType>()->isBeingDefined()) && \"Caller should have completed object type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 318, __extension__ __PRETTY_FUNCTION__))
         "Caller should have completed object type")(static_cast <bool> ((isDependent || !ObjectType->isIncompleteType
() || ObjectType->castAs<TagType>()->isBeingDefined
()) && "Caller should have completed object type") ? void
 (0) : __assert_fail ("(isDependent || !ObjectType->isIncompleteType() || ObjectType->castAs<TagType>()->isBeingDefined()) && \"Caller should have completed object type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 318, __extension__ __PRETTY_FUNCTION__));

  // Template names cannot appear inside an Objective-C class or object type.
  if (ObjectType->isObjCObjectOrInterfaceType()) {
    Found.clear();
    return;
  }
} else if (SS.isSet()) {
  // This nested-name-specifier occurs after another nested-name-specifier,
  // so long into the context associated with the prior nested-name-specifier.
  LookupCtx = computeDeclContext(SS, EnteringContext);
  isDependent = isDependentScopeSpecifier(SS);

  // The declaration context must be complete.
  if (LookupCtx && RequireCompleteDeclContext(SS, LookupCtx))
    return;
}

bool ObjectTypeSearchedInScope = false;
bool AllowFunctionTemplatesInLookup = true;
if (LookupCtx) {
  // Perform "qualified" name lookup into the declaration context we
  // computed, which is either the type of the base of a member access
  // expression or the declaration context associated with a prior
  // nested-name-specifier.
  LookupQualifiedName(Found, LookupCtx);
  if (!ObjectType.isNull() && Found.empty()) {
    // C++ [basic.lookup.classref]p1:
    //   In a class member access expression (5.2.5), if the . or -> token is
    //   immediately followed by an identifier followed by a <, the
    //   identifier must be looked up to determine whether the < is the
    //   beginning of a template argument list (14.2) or a less-than operator.
    //   The identifier is first looked up in the class of the object
    //   expression. If the identifier is not found, it is then looked up in
    //   the context of the entire postfix-expression and shall name a class
    //   or function template.
    if (S) LookupName(Found, S);
    ObjectTypeSearchedInScope = true;
    AllowFunctionTemplatesInLookup = false;
  }
} else if (isDependent && (!S || ObjectType.isNull())) {
  // We cannot look into a dependent object type or nested nme
  // specifier.
  MemberOfUnknownSpecialization = true;
  return;
} else {
  // Perform unqualified name lookup in the current scope.
  LookupName(Found, S);

  if (!ObjectType.isNull())
    AllowFunctionTemplatesInLookup = false;
}

if (Found.empty() && !isDependent) {
  // If we did not find any names, attempt to correct any typos.
  DeclarationName Name = Found.getLookupName();
  Found.clear();
  // Simple filter callback that, for keywords, only accepts the C++ *_cast
  auto FilterCCC = llvm::make_unique<CorrectionCandidateCallback>();
  FilterCCC->WantTypeSpecifiers = false;
  FilterCCC->WantExpressionKeywords = false;
  FilterCCC->WantRemainingKeywords = false;
  FilterCCC->WantCXXNamedCasts = true;
  if (TypoCorrection Corrected = CorrectTypo(
          Found.getLookupNameInfo(), Found.getLookupKind(), S, &SS,
          std::move(FilterCCC), CTK_ErrorRecovery, LookupCtx)) {
    Found.setLookupName(Corrected.getCorrection());
    if (auto *ND = Corrected.getFoundDecl())
      Found.addDecl(ND);
    FilterAcceptableTemplateNames(Found);
    if (!Found.empty()) {
      if (LookupCtx) {
        std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
        bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
                                Name.getAsString() == CorrectedStr;
        diagnoseTypo(Corrected, PDiag(diag::err_no_member_template_suggest)
                                  << Name << LookupCtx << DroppedSpecifier
                                  << SS.getRange());
      } else {
        diagnoseTypo(Corrected, PDiag(diag::err_no_template_suggest) << Name);
      }
    }
  } else {
    Found.setLookupName(Name);
  }
}

FilterAcceptableTemplateNames(Found, AllowFunctionTemplatesInLookup);
if (Found.empty()) {
  if (isDependent)
    MemberOfUnknownSpecialization = true;
  return;
}

if (S && !ObjectType.isNull() && !ObjectTypeSearchedInScope &&
    !getLangOpts().CPlusPlus11) {
  // C++03 [basic.lookup.classref]p1:
  //   [...] If the lookup in the class of the object expression finds a
  //   template, the name is also looked up in the context of the entire
  //   postfix-expression and [...]
  //
  // Note: C++11 does not perform this second lookup.
  LookupResult FoundOuter(*this, Found.getLookupName(), Found.getNameLoc(),
                          LookupOrdinaryName);
  LookupName(FoundOuter, S);
  FilterAcceptableTemplateNames(FoundOuter, /*AllowFunctionTemplates=*/false);

  if (FoundOuter.empty()) {
    //   - if the name is not found, the name found in the class of the
    //     object expression is used, otherwise
  } else if (!FoundOuter.getAsSingle<ClassTemplateDecl>() ||
             FoundOuter.isAmbiguous()) {
    //   - if the name is found in the context of the entire
    //     postfix-expression and does not name a class template, the name
    //     found in the class of the object expression is used, otherwise
    FoundOuter.clear();
  } else if (!Found.isSuppressingDiagnostics()) {
    //   - if the name found is a class template, it must refer to the same
    //     entity as the one found in the class of the object expression,
    //     otherwise the program is ill-formed.
    if (!Found.isSingleResult() ||
        Found.getFoundDecl()->getCanonicalDecl()
          != FoundOuter.getFoundDecl()->getCanonicalDecl()) {
      Diag(Found.getNameLoc(),
           diag::ext_nested_name_member_ref_lookup_ambiguous)
        << Found.getLookupName()
        << ObjectType;
      Diag(Found.getRepresentativeDecl()->getLocation(),
           diag::note_ambig_member_ref_object_type)
        << ObjectType;
      Diag(FoundOuter.getFoundDecl()->getLocation(),
           diag::note_ambig_member_ref_scope);

      // Recover by taking the template that we found in the object
      // expression's type.
    }
  }
}
456}

458void Sema::diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName,
                                            SourceLocation Less,
                                            SourceLocation Greater) {
if (TemplateName.isInvalid())
  return;

DeclarationNameInfo NameInfo;
CXXScopeSpec SS;
LookupNameKind LookupKind;

DeclContext *LookupCtx = nullptr;
NamedDecl *Found = nullptr;

// Figure out what name we looked up.
if (auto *ME = dyn_cast<MemberExpr>(TemplateName.get())) {
  NameInfo = ME->getMemberNameInfo();
  SS.Adopt(ME->getQualifierLoc());
  LookupKind = LookupMemberName;
  LookupCtx = ME->getBase()->getType()->getAsCXXRecordDecl();
  Found = ME->getMemberDecl();
} else {
  auto *DRE = cast<DeclRefExpr>(TemplateName.get());
  NameInfo = DRE->getNameInfo();
  SS.Adopt(DRE->getQualifierLoc());
  LookupKind = LookupOrdinaryName;
  Found = DRE->getFoundDecl();
}

// Try to correct the name by looking for templates and C++ named casts.
struct TemplateCandidateFilter : CorrectionCandidateCallback {
  TemplateCandidateFilter() {
    WantTypeSpecifiers = false;
    WantExpressionKeywords = false;
    WantRemainingKeywords = false;
    WantCXXNamedCasts = true;
  };
  bool ValidateCandidate(const TypoCorrection &Candidate) override {
    if (auto *ND = Candidate.getCorrectionDecl())
      return isAcceptableTemplateName(ND->getASTContext(), ND, true);
    return Candidate.isKeyword();
  }
};

DeclarationName Name = NameInfo.getName();
if (TypoCorrection Corrected =
        CorrectTypo(NameInfo, LookupKind, S, &SS,
                    llvm::make_unique<TemplateCandidateFilter>(),
                    CTK_ErrorRecovery, LookupCtx)) {
  auto *ND = Corrected.getFoundDecl();
  if (ND)
    ND = isAcceptableTemplateName(Context, ND,
                                  /*AllowFunctionTemplates*/ true);
  if (ND || Corrected.isKeyword()) {
    if (LookupCtx) {
      std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
      bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
                              Name.getAsString() == CorrectedStr;
      diagnoseTypo(Corrected,
                   PDiag(diag::err_non_template_in_member_template_id_suggest)
                       << Name << LookupCtx << DroppedSpecifier
                       << SS.getRange(), false);
    } else {
      diagnoseTypo(Corrected,
                   PDiag(diag::err_non_template_in_template_id_suggest)
                       << Name, false);
    }
    if (Found)
      Diag(Found->getLocation(),
           diag::note_non_template_in_template_id_found);
    return;
  }
}

Diag(NameInfo.getLoc(), diag::err_non_template_in_template_id)
  << Name << SourceRange(Less, Greater);
if (Found)
  Diag(Found->getLocation(), diag::note_non_template_in_template_id_found);
535}

537/// ActOnDependentIdExpression - Handle a dependent id-expression that
538/// was just parsed.  This is only possible with an explicit scope
539/// specifier naming a dependent type.
540ExprResult
541Sema::ActOnDependentIdExpression(const CXXScopeSpec &SS,
                               SourceLocation TemplateKWLoc,
                               const DeclarationNameInfo &NameInfo,
                               bool isAddressOfOperand,
                         const TemplateArgumentListInfo *TemplateArgs) {
DeclContext *DC = getFunctionLevelDeclContext();

// C++11 [expr.prim.general]p12:
//   An id-expression that denotes a non-static data member or non-static
//   member function of a class can only be used:
//   (...)
//   - if that id-expression denotes a non-static data member and it
//     appears in an unevaluated operand.
//
// If this might be the case, form a DependentScopeDeclRefExpr instead of a
// CXXDependentScopeMemberExpr. The former can instantiate to either
// DeclRefExpr or MemberExpr depending on lookup results, while the latter is
// always a MemberExpr.
bool MightBeCxx11UnevalField =
    getLangOpts().CPlusPlus11 && isUnevaluatedContext();

// Check if the nested name specifier is an enum type.
bool IsEnum = false;
if (NestedNameSpecifier *NNS = SS.getScopeRep())
  IsEnum = dyn_cast_or_null<EnumType>(NNS->getAsType());

if (!MightBeCxx11UnevalField && !isAddressOfOperand && !IsEnum &&
    isa<CXXMethodDecl>(DC) && cast<CXXMethodDecl>(DC)->isInstance()) {
  QualType ThisType = cast<CXXMethodDecl>(DC)->getThisType(Context);

  // Since the 'this' expression is synthesized, we don't need to
  // perform the double-lookup check.
  NamedDecl *FirstQualifierInScope = nullptr;

  return CXXDependentScopeMemberExpr::Create(
      Context, /*This*/ nullptr, ThisType, /*IsArrow*/ true,
      /*Op*/ SourceLocation(), SS.getWithLocInContext(Context), TemplateKWLoc,
      FirstQualifierInScope, NameInfo, TemplateArgs);
}

return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
582}

584ExprResult
585Sema::BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
                              SourceLocation TemplateKWLoc,
                              const DeclarationNameInfo &NameInfo,
                              const TemplateArgumentListInfo *TemplateArgs) {
return DependentScopeDeclRefExpr::Create(
    Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
    TemplateArgs);
592}


595/// Determine whether we would be unable to instantiate this template (because
596/// it either has no definition, or is in the process of being instantiated).
597bool Sema::DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation,
                                        NamedDecl *Instantiation,
                                        bool InstantiatedFromMember,
                                        const NamedDecl *Pattern,
                                        const NamedDecl *PatternDef,
                                        TemplateSpecializationKind TSK,
                                        bool Complain /*= true*/) {
assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||(static_cast <bool> (isa<TagDecl>(Instantiation) ||
 isa<FunctionDecl>(Instantiation) || isa<VarDecl>
(Instantiation)) ? void (0) : __assert_fail ("isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) || isa<VarDecl>(Instantiation)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 605, __extension__ __PRETTY_FUNCTION__))
       isa<VarDecl>(Instantiation))(static_cast <bool> (isa<TagDecl>(Instantiation) ||
 isa<FunctionDecl>(Instantiation) || isa<VarDecl>
(Instantiation)) ? void (0) : __assert_fail ("isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) || isa<VarDecl>(Instantiation)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 605, __extension__ __PRETTY_FUNCTION__));

bool IsEntityBeingDefined = false;
if (const TagDecl *TD = dyn_cast_or_null<TagDecl>(PatternDef))
  IsEntityBeingDefined = TD->isBeingDefined();

if (PatternDef && !IsEntityBeingDefined) {
  NamedDecl *SuggestedDef = nullptr;
  if (!hasVisibleDefinition(const_cast<NamedDecl*>(PatternDef), &SuggestedDef,
                            /*OnlyNeedComplete*/false)) {
    // If we're allowed to diagnose this and recover, do so.
    bool Recover = Complain && !isSFINAEContext();
    if (Complain)
      diagnoseMissingImport(PointOfInstantiation, SuggestedDef,
                            Sema::MissingImportKind::Definition, Recover);
    return !Recover;
  }
  return false;
}

if (!Complain || (PatternDef && PatternDef->isInvalidDecl()))
  return true;

llvm::Optional<unsigned> Note;
QualType InstantiationTy;
if (TagDecl *TD = dyn_cast<TagDecl>(Instantiation))
  InstantiationTy = Context.getTypeDeclType(TD);
if (PatternDef) {
  Diag(PointOfInstantiation,
       diag::err_template_instantiate_within_definition)
    << /*implicit|explicit*/(TSK != TSK_ImplicitInstantiation)
    << InstantiationTy;
  // Not much point in noting the template declaration here, since
  // we're lexically inside it.
  Instantiation->setInvalidDecl();
} else if (InstantiatedFromMember) {
  if (isa<FunctionDecl>(Instantiation)) {
    Diag(PointOfInstantiation,
         diag::err_explicit_instantiation_undefined_member)
      << /*member function*/ 1 << Instantiation->getDeclName()
      << Instantiation->getDeclContext();
    Note = diag::note_explicit_instantiation_here;
  } else {
    assert(isa<TagDecl>(Instantiation) && "Must be a TagDecl!")(static_cast <bool> (isa<TagDecl>(Instantiation) &&
 "Must be a TagDecl!") ? void (0) : __assert_fail ("isa<TagDecl>(Instantiation) && \"Must be a TagDecl!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 648, __extension__ __PRETTY_FUNCTION__));
    Diag(PointOfInstantiation,
         diag::err_implicit_instantiate_member_undefined)
      << InstantiationTy;
    Note = diag::note_member_declared_at;
  }
} else {
  if (isa<FunctionDecl>(Instantiation)) {
    Diag(PointOfInstantiation,
         diag::err_explicit_instantiation_undefined_func_template)
      << Pattern;
    Note = diag::note_explicit_instantiation_here;
  } else if (isa<TagDecl>(Instantiation)) {
    Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
      << (TSK != TSK_ImplicitInstantiation)
      << InstantiationTy;
    Note = diag::note_template_decl_here;
  } else {
    assert(isa<VarDecl>(Instantiation) && "Must be a VarDecl!")(static_cast <bool> (isa<VarDecl>(Instantiation) &&
 "Must be a VarDecl!") ? void (0) : __assert_fail ("isa<VarDecl>(Instantiation) && \"Must be a VarDecl!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 666, __extension__ __PRETTY_FUNCTION__));
    if (isa<VarTemplateSpecializationDecl>(Instantiation)) {
      Diag(PointOfInstantiation,
           diag::err_explicit_instantiation_undefined_var_template)
        << Instantiation;
      Instantiation->setInvalidDecl();
    } else
      Diag(PointOfInstantiation,
           diag::err_explicit_instantiation_undefined_member)
        << /*static data member*/ 2 << Instantiation->getDeclName()
        << Instantiation->getDeclContext();
    Note = diag::note_explicit_instantiation_here;
  }
}
if (Note) // Diagnostics were emitted.
  Diag(Pattern->getLocation(), Note.getValue());

// In general, Instantiation isn't marked invalid to get more than one
// error for multiple undefined instantiations. But the code that does
// explicit declaration -> explicit definition conversion can't handle
// invalid declarations, so mark as invalid in that case.
if (TSK == TSK_ExplicitInstantiationDeclaration)
  Instantiation->setInvalidDecl();
return true;
690}

692/// DiagnoseTemplateParameterShadow - Produce a diagnostic complaining
693/// that the template parameter 'PrevDecl' is being shadowed by a new
694/// declaration at location Loc. Returns true to indicate that this is
695/// an error, and false otherwise.
696void Sema::DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl) {
assert(PrevDecl->isTemplateParameter() && "Not a template parameter")(static_cast <bool> (PrevDecl->isTemplateParameter()
 && "Not a template parameter") ? void (0) : __assert_fail
 ("PrevDecl->isTemplateParameter() && \"Not a template parameter\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 697, __extension__ __PRETTY_FUNCTION__));

// Microsoft Visual C++ permits template parameters to be shadowed.
if (getLangOpts().MicrosoftExt)
  return;

// C++ [temp.local]p4:
//   A template-parameter shall not be redeclared within its
//   scope (including nested scopes).
Diag(Loc, diag::err_template_param_shadow)
  << cast<NamedDecl>(PrevDecl)->getDeclName();
Diag(PrevDecl->getLocation(), diag::note_template_param_here);
709}

711/// AdjustDeclIfTemplate - If the given decl happens to be a template, reset
712/// the parameter D to reference the templated declaration and return a pointer
713/// to the template declaration. Otherwise, do nothing to D and return null.
714TemplateDecl *Sema::AdjustDeclIfTemplate(Decl *&D) {
if (TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D)) {
  D = Temp->getTemplatedDecl();
  return Temp;
}
return nullptr;
720}

722ParsedTemplateArgument ParsedTemplateArgument::getTemplatePackExpansion(
                                           SourceLocation EllipsisLoc) const {
assert(Kind == Template &&(static_cast <bool> (Kind == Template && "Only template template arguments can be pack expansions here"
) ? void (0) : __assert_fail ("Kind == Template && \"Only template template arguments can be pack expansions here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 725, __extension__ __PRETTY_FUNCTION__))
       "Only template template arguments can be pack expansions here")(static_cast <bool> (Kind == Template && "Only template template arguments can be pack expansions here"
) ? void (0) : __assert_fail ("Kind == Template && \"Only template template arguments can be pack expansions here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 725, __extension__ __PRETTY_FUNCTION__));
assert(getAsTemplate().get().containsUnexpandedParameterPack() &&(static_cast <bool> (getAsTemplate().get().containsUnexpandedParameterPack
() && "Template template argument pack expansion without packs"
) ? void (0) : __assert_fail ("getAsTemplate().get().containsUnexpandedParameterPack() && \"Template template argument pack expansion without packs\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 727, __extension__ __PRETTY_FUNCTION__))
       "Template template argument pack expansion without packs")(static_cast <bool> (getAsTemplate().get().containsUnexpandedParameterPack
() && "Template template argument pack expansion without packs"
) ? void (0) : __assert_fail ("getAsTemplate().get().containsUnexpandedParameterPack() && \"Template template argument pack expansion without packs\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 727, __extension__ __PRETTY_FUNCTION__));
ParsedTemplateArgument Result(*this);
Result.EllipsisLoc = EllipsisLoc;
return Result;
731}

733static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef,
                                          const ParsedTemplateArgument &Arg) {

switch (Arg.getKind()) {
case ParsedTemplateArgument::Type: {
  TypeSourceInfo *DI;
  QualType T = SemaRef.GetTypeFromParser(Arg.getAsType(), &DI);
  if (!DI)
    DI = SemaRef.Context.getTrivialTypeSourceInfo(T, Arg.getLocation());
  return TemplateArgumentLoc(TemplateArgument(T), DI);
}

case ParsedTemplateArgument::NonType: {
  Expr *E = static_cast<Expr *>(Arg.getAsExpr());
  return TemplateArgumentLoc(TemplateArgument(E), E);
}

case ParsedTemplateArgument::Template: {
  TemplateName Template = Arg.getAsTemplate().get();
  TemplateArgument TArg;
  if (Arg.getEllipsisLoc().isValid())
    TArg = TemplateArgument(Template, Optional<unsigned int>());
  else
    TArg = Template;
  return TemplateArgumentLoc(TArg,
                             Arg.getScopeSpec().getWithLocInContext(
                                                            SemaRef.Context),
                             Arg.getLocation(),
                             Arg.getEllipsisLoc());
}
}

llvm_unreachable("Unhandled parsed template argument")::llvm::llvm_unreachable_internal("Unhandled parsed template argument"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 765);
766}

768/// \brief Translates template arguments as provided by the parser
769/// into template arguments used by semantic analysis.
770void Sema::translateTemplateArguments(const ASTTemplateArgsPtr &TemplateArgsIn,
                                    TemplateArgumentListInfo &TemplateArgs) {
for (unsigned I = 0, Last = TemplateArgsIn.size(); I != Last; ++I)
 TemplateArgs.addArgument(translateTemplateArgument(*this,
                                                    TemplateArgsIn[I]));
775}

777static void maybeDiagnoseTemplateParameterShadow(Sema &SemaRef, Scope *S,
                                               SourceLocation Loc,
                                               IdentifierInfo *Name) {
NamedDecl *PrevDecl = SemaRef.LookupSingleName(
    S, Name, Loc, Sema::LookupOrdinaryName, Sema::ForVisibleRedeclaration);
if (PrevDecl && PrevDecl->isTemplateParameter())
  SemaRef.DiagnoseTemplateParameterShadow(Loc, PrevDecl);
784}

786/// ActOnTypeParameter - Called when a C++ template type parameter
787/// (e.g., "typename T") has been parsed. Typename specifies whether
788/// the keyword "typename" was used to declare the type parameter
789/// (otherwise, "class" was used), and KeyLoc is the location of the
790/// "class" or "typename" keyword. ParamName is the name of the
791/// parameter (NULL indicates an unnamed template parameter) and
792/// ParamNameLoc is the location of the parameter name (if any).
793/// If the type parameter has a default argument, it will be added
794/// later via ActOnTypeParameterDefault.
795NamedDecl *Sema::ActOnTypeParameter(Scope *S, bool Typename,
                             SourceLocation EllipsisLoc,
                             SourceLocation KeyLoc,
                             IdentifierInfo *ParamName,
                             SourceLocation ParamNameLoc,
                             unsigned Depth, unsigned Position,
                             SourceLocation EqualLoc,
                             ParsedType DefaultArg) {
assert(S->isTemplateParamScope() &&(static_cast <bool> (S->isTemplateParamScope() &&
 "Template type parameter not in template parameter scope!") ?
 void (0) : __assert_fail ("S->isTemplateParamScope() && \"Template type parameter not in template parameter scope!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 804, __extension__ __PRETTY_FUNCTION__))
       "Template type parameter not in template parameter scope!")(static_cast <bool> (S->isTemplateParamScope() &&
 "Template type parameter not in template parameter scope!") ?
 void (0) : __assert_fail ("S->isTemplateParamScope() && \"Template type parameter not in template parameter scope!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 804, __extension__ __PRETTY_FUNCTION__));

SourceLocation Loc = ParamNameLoc;
if (!ParamName)
  Loc = KeyLoc;

bool IsParameterPack = EllipsisLoc.isValid();
TemplateTypeParmDecl *Param
  = TemplateTypeParmDecl::Create(Context, Context.getTranslationUnitDecl(),
                                 KeyLoc, Loc, Depth, Position, ParamName,
                                 Typename, IsParameterPack);
Param->setAccess(AS_public);

if (ParamName) {
  maybeDiagnoseTemplateParameterShadow(*this, S, ParamNameLoc, ParamName);

  // Add the template parameter into the current scope.
  S->AddDecl(Param);
  IdResolver.AddDecl(Param);
}

// C++0x [temp.param]p9:
//   A default template-argument may be specified for any kind of
//   template-parameter that is not a template parameter pack.
if (DefaultArg && IsParameterPack) {
  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
  DefaultArg = nullptr;
}

// Handle the default argument, if provided.
if (DefaultArg) {
  TypeSourceInfo *DefaultTInfo;
  GetTypeFromParser(DefaultArg, &DefaultTInfo);

  assert(DefaultTInfo && "expected source information for type")(static_cast <bool> (DefaultTInfo && "expected source information for type"
) ? void (0) : __assert_fail ("DefaultTInfo && \"expected source information for type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 838, __extension__ __PRETTY_FUNCTION__));

  // Check for unexpanded parameter packs.
  if (DiagnoseUnexpandedParameterPack(Loc, DefaultTInfo,
                                      UPPC_DefaultArgument))
    return Param;

  // Check the template argument itself.
  if (CheckTemplateArgument(Param, DefaultTInfo)) {
    Param->setInvalidDecl();
    return Param;
  }

  Param->setDefaultArgument(DefaultTInfo);
}

return Param;
855}

857/// \brief Check that the type of a non-type template parameter is
858/// well-formed.
859///
860/// \returns the (possibly-promoted) parameter type if valid;
861/// otherwise, produces a diagnostic and returns a NULL type.
862QualType Sema::CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,
                                               SourceLocation Loc) {
if (TSI->getType()->isUndeducedType()) {
  // C++1z [temp.dep.expr]p3:
  //   An id-expression is type-dependent if it contains
  //    - an identifier associated by name lookup with a non-type
  //      template-parameter declared with a type that contains a
  //      placeholder type (7.1.7.4),
  TSI = SubstAutoTypeSourceInfo(TSI, Context.DependentTy);
}

return CheckNonTypeTemplateParameterType(TSI->getType(), Loc);
874}

876QualType Sema::CheckNonTypeTemplateParameterType(QualType T,
                                               SourceLocation Loc) {
// We don't allow variably-modified types as the type of non-type template
// parameters.
if (T->isVariablyModifiedType()) {
  Diag(Loc, diag::err_variably_modified_nontype_template_param)
    << T;
  return QualType();
}

// C++ [temp.param]p4:
//
// A non-type template-parameter shall have one of the following
// (optionally cv-qualified) types:
//
//       -- integral or enumeration type,
if (T->isIntegralOrEnumerationType() ||
    //   -- pointer to object or pointer to function,
    T->isPointerType() ||
    //   -- reference to object or reference to function,
    T->isReferenceType() ||
    //   -- pointer to member,
    T->isMemberPointerType() ||
    //   -- std::nullptr_t.
    T->isNullPtrType() ||
    // If T is a dependent type, we can't do the check now, so we
    // assume that it is well-formed.
    T->isDependentType() ||
    // Allow use of auto in template parameter declarations.
    T->isUndeducedType()) {
  // C++ [temp.param]p5: The top-level cv-qualifiers on the template-parameter
  // are ignored when determining its type.
  return T.getUnqualifiedType();
}

// C++ [temp.param]p8:
//
//   A non-type template-parameter of type "array of T" or
//   "function returning T" is adjusted to be of type "pointer to
//   T" or "pointer to function returning T", respectively.
else if (T->isArrayType() || T->isFunctionType())
  return Context.getDecayedType(T);

Diag(Loc, diag::err_template_nontype_parm_bad_type)
  << T;

return QualType();
923}

925NamedDecl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
                                        unsigned Depth,
                                        unsigned Position,
                                        SourceLocation EqualLoc,
                                        Expr *Default) {
TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);

// Check that we have valid decl-specifiers specified.
auto CheckValidDeclSpecifiers = [this, &D] {
  // C++ [temp.param]
  // p1 
  //   template-parameter:
  //     ...
  //     parameter-declaration
  // p2 
  //   ... A storage class shall not be specified in a template-parameter
  //   declaration.
  // [dcl.typedef]p1: 
  //   The typedef specifier [...] shall not be used in the decl-specifier-seq
  //   of a parameter-declaration
  const DeclSpec &DS = D.getDeclSpec();
  auto EmitDiag = [this](SourceLocation Loc) {
    Diag(Loc, diag::err_invalid_decl_specifier_in_nontype_parm)
        << FixItHint::CreateRemoval(Loc);
  };
  if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified)
    EmitDiag(DS.getStorageClassSpecLoc());
  
  if (DS.getThreadStorageClassSpec() != TSCS_unspecified)
    EmitDiag(DS.getThreadStorageClassSpecLoc());
  
  // [dcl.inline]p1: 
  //   The inline specifier can be applied only to the declaration or 
  //   definition of a variable or function.
  
  if (DS.isInlineSpecified())
    EmitDiag(DS.getInlineSpecLoc());
  
  // [dcl.constexpr]p1:
  //   The constexpr specifier shall be applied only to the definition of a 
  //   variable or variable template or the declaration of a function or 
  //   function template.
  
  if (DS.isConstexprSpecified())
    EmitDiag(DS.getConstexprSpecLoc());

  // [dcl.fct.spec]p1:
  //   Function-specifiers can be used only in function declarations.

  if (DS.isVirtualSpecified())
    EmitDiag(DS.getVirtualSpecLoc());

  if (DS.isExplicitSpecified())
    EmitDiag(DS.getExplicitSpecLoc());

  if (DS.isNoreturnSpecified())
    EmitDiag(DS.getNoreturnSpecLoc());
};

CheckValidDeclSpecifiers();

if (TInfo->getType()->isUndeducedType()) {
  Diag(D.getIdentifierLoc(),
       diag::warn_cxx14_compat_template_nontype_parm_auto_type)
    << QualType(TInfo->getType()->getContainedAutoType(), 0);
}

assert(S->isTemplateParamScope() &&(static_cast <bool> (S->isTemplateParamScope() &&
 "Non-type template parameter not in template parameter scope!"
) ? void (0) : __assert_fail ("S->isTemplateParamScope() && \"Non-type template parameter not in template parameter scope!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 993, __extension__ __PRETTY_FUNCTION__))
       "Non-type template parameter not in template parameter scope!")(static_cast <bool> (S->isTemplateParamScope() &&
 "Non-type template parameter not in template parameter scope!"
) ? void (0) : __assert_fail ("S->isTemplateParamScope() && \"Non-type template parameter not in template parameter scope!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 993, __extension__ __PRETTY_FUNCTION__));
bool Invalid = false;

QualType T = CheckNonTypeTemplateParameterType(TInfo, D.getIdentifierLoc());
if (T.isNull()) {
  T = Context.IntTy; // Recover with an 'int' type.
  Invalid = true;
}

IdentifierInfo *ParamName = D.getIdentifier();
bool IsParameterPack = D.hasEllipsis();
NonTypeTemplateParmDecl *Param
  = NonTypeTemplateParmDecl::Create(Context, Context.getTranslationUnitDecl(),
                                    D.getLocStart(),
                                    D.getIdentifierLoc(),
                                    Depth, Position, ParamName, T,
                                    IsParameterPack, TInfo);
Param->setAccess(AS_public);

if (Invalid)
  Param->setInvalidDecl();

if (ParamName) {
  maybeDiagnoseTemplateParameterShadow(*this, S, D.getIdentifierLoc(),
                                       ParamName);

  // Add the template parameter into the current scope.
  S->AddDecl(Param);
  IdResolver.AddDecl(Param);
}

// C++0x [temp.param]p9:
//   A default template-argument may be specified for any kind of
//   template-parameter that is not a template parameter pack.
if (Default && IsParameterPack) {
  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
  Default = nullptr;
}

// Check the well-formedness of the default template argument, if provided.
if (Default) {
  // Check for unexpanded parameter packs.
  if (DiagnoseUnexpandedParameterPack(Default, UPPC_DefaultArgument))
    return Param;

  TemplateArgument Converted;
  ExprResult DefaultRes =
      CheckTemplateArgument(Param, Param->getType(), Default, Converted);
  if (DefaultRes.isInvalid()) {
    Param->setInvalidDecl();
    return Param;
  }
  Default = DefaultRes.get();

  Param->setDefaultArgument(Default);
}

return Param;
1051}

1053/// ActOnTemplateTemplateParameter - Called when a C++ template template
1054/// parameter (e.g. T in template <template \<typename> class T> class array)
1055/// has been parsed. S is the current scope.
1056NamedDecl *Sema::ActOnTemplateTemplateParameter(Scope* S,
                                         SourceLocation TmpLoc,
                                         TemplateParameterList *Params,
                                         SourceLocation EllipsisLoc,
                                         IdentifierInfo *Name,
                                         SourceLocation NameLoc,
                                         unsigned Depth,
                                         unsigned Position,
                                         SourceLocation EqualLoc,
                                         ParsedTemplateArgument Default) {
assert(S->isTemplateParamScope() &&(static_cast <bool> (S->isTemplateParamScope() &&
 "Template template parameter not in template parameter scope!"
) ? void (0) : __assert_fail ("S->isTemplateParamScope() && \"Template template parameter not in template parameter scope!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1067, __extension__ __PRETTY_FUNCTION__))
       "Template template parameter not in template parameter scope!")(static_cast <bool> (S->isTemplateParamScope() &&
 "Template template parameter not in template parameter scope!"
) ? void (0) : __assert_fail ("S->isTemplateParamScope() && \"Template template parameter not in template parameter scope!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1067, __extension__ __PRETTY_FUNCTION__));

// Construct the parameter object.
bool IsParameterPack = EllipsisLoc.isValid();
TemplateTemplateParmDecl *Param =
  TemplateTemplateParmDecl::Create(Context, Context.getTranslationUnitDecl(),
                                   NameLoc.isInvalid()? TmpLoc : NameLoc,
                                   Depth, Position, IsParameterPack,
                                   Name, Params);
Param->setAccess(AS_public);

// If the template template parameter has a name, then link the identifier
// into the scope and lookup mechanisms.
if (Name) {
  maybeDiagnoseTemplateParameterShadow(*this, S, NameLoc, Name);

  S->AddDecl(Param);
  IdResolver.AddDecl(Param);
}

if (Params->size() == 0) {
  Diag(Param->getLocation(), diag::err_template_template_parm_no_parms)
  << SourceRange(Params->getLAngleLoc(), Params->getRAngleLoc());
  Param->setInvalidDecl();
}

// C++0x [temp.param]p9:
//   A default template-argument may be specified for any kind of
//   template-parameter that is not a template parameter pack.
if (IsParameterPack && !Default.isInvalid()) {
  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
  Default = ParsedTemplateArgument();
}

if (!Default.isInvalid()) {
  // Check only that we have a template template argument. We don't want to
  // try to check well-formedness now, because our template template parameter
  // might have dependent types in its template parameters, which we wouldn't
  // be able to match now.
  //
  // If none of the template template parameter's template arguments mention
  // other template parameters, we could actually perform more checking here.
  // However, it isn't worth doing.
  TemplateArgumentLoc DefaultArg = translateTemplateArgument(*this, Default);
  if (DefaultArg.getArgument().getAsTemplate().isNull()) {
    Diag(DefaultArg.getLocation(), diag::err_template_arg_not_valid_template)
      << DefaultArg.getSourceRange();
    return Param;
  }

  // Check for unexpanded parameter packs.
  if (DiagnoseUnexpandedParameterPack(DefaultArg.getLocation(),
                                      DefaultArg.getArgument().getAsTemplate(),
                                      UPPC_DefaultArgument))
    return Param;

  Param->setDefaultArgument(Context, DefaultArg);
}

return Param;
1127}

1129/// ActOnTemplateParameterList - Builds a TemplateParameterList, optionally
1130/// constrained by RequiresClause, that contains the template parameters in
1131/// Params.
1132TemplateParameterList *
1133Sema::ActOnTemplateParameterList(unsigned Depth,
                               SourceLocation ExportLoc,
                               SourceLocation TemplateLoc,
                               SourceLocation LAngleLoc,
                               ArrayRef<NamedDecl *> Params,
                               SourceLocation RAngleLoc,
                               Expr *RequiresClause) {
if (ExportLoc.isValid())
  Diag(ExportLoc, diag::warn_template_export_unsupported);

return TemplateParameterList::Create(
    Context, TemplateLoc, LAngleLoc,
    llvm::makeArrayRef(Params.data(), Params.size()),
    RAngleLoc, RequiresClause);
1147}

1149static void SetNestedNameSpecifier(TagDecl *T, const CXXScopeSpec &SS) {
if (SS.isSet())
  T->setQualifierInfo(SS.getWithLocInContext(T->getASTContext()));
1152}

1154DeclResult
1155Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
                       SourceLocation KWLoc, CXXScopeSpec &SS,
                       IdentifierInfo *Name, SourceLocation NameLoc,
                       AttributeList *Attr,
                       TemplateParameterList *TemplateParams,
                       AccessSpecifier AS, SourceLocation ModulePrivateLoc,
                       SourceLocation FriendLoc,
                       unsigned NumOuterTemplateParamLists,
                       TemplateParameterList** OuterTemplateParamLists,
                       SkipBodyInfo *SkipBody) {
assert(TemplateParams && TemplateParams->size() > 0 &&(static_cast <bool> (TemplateParams && TemplateParams
->size() > 0 && "No template parameters") ? void
 (0) : __assert_fail ("TemplateParams && TemplateParams->size() > 0 && \"No template parameters\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1166, __extension__ __PRETTY_FUNCTION__))
       "No template parameters")(static_cast <bool> (TemplateParams && TemplateParams
->size() > 0 && "No template parameters") ? void
 (0) : __assert_fail ("TemplateParams && TemplateParams->size() > 0 && \"No template parameters\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1166, __extension__ __PRETTY_FUNCTION__));
assert(TUK != TUK_Reference && "Can only declare or define class templates")(static_cast <bool> (TUK != TUK_Reference && "Can only declare or define class templates"
) ? void (0) : __assert_fail ("TUK != TUK_Reference && \"Can only declare or define class templates\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1167, __extension__ __PRETTY_FUNCTION__));
bool Invalid = false;

// Check that we can declare a template here.
if (CheckTemplateDeclScope(S, TemplateParams))
  return true;

TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
assert(Kind != TTK_Enum && "can't build template of enumerated type")(static_cast <bool> (Kind != TTK_Enum && "can't build template of enumerated type"
) ? void (0) : __assert_fail ("Kind != TTK_Enum && \"can't build template of enumerated type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1175, __extension__ __PRETTY_FUNCTION__));

// There is no such thing as an unnamed class template.
if (!Name) {
  Diag(KWLoc, diag::err_template_unnamed_class);
  return true;
}

// Find any previous declaration with this name. For a friend with no
// scope explicitly specified, we only look for tag declarations (per
// C++11 [basic.lookup.elab]p2).
DeclContext *SemanticContext;
LookupResult Previous(*this, Name, NameLoc,
                      (SS.isEmpty() && TUK == TUK_Friend)
                        ? LookupTagName : LookupOrdinaryName,
                      forRedeclarationInCurContext());
if (SS.isNotEmpty() && !SS.isInvalid()) {
  SemanticContext = computeDeclContext(SS, true);
  if (!SemanticContext) {
    // FIXME: Horrible, horrible hack! We can't currently represent this
    // in the AST, and historically we have just ignored such friend
    // class templates, so don't complain here.
    Diag(NameLoc, TUK == TUK_Friend
                      ? diag::warn_template_qualified_friend_ignored
                      : diag::err_template_qualified_declarator_no_match)
        << SS.getScopeRep() << SS.getRange();
    return TUK != TUK_Friend;
  }

  if (RequireCompleteDeclContext(SS, SemanticContext))
    return true;

  // If we're adding a template to a dependent context, we may need to
  // rebuilding some of the types used within the template parameter list,
  // now that we know what the current instantiation is.
  if (SemanticContext->isDependentContext()) {
    ContextRAII SavedContext(*this, SemanticContext);
    if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
      Invalid = true;
  } else if (TUK != TUK_Friend && TUK != TUK_Reference)
    diagnoseQualifiedDeclaration(SS, SemanticContext, Name, NameLoc);

  LookupQualifiedName(Previous, SemanticContext);
} else {
  SemanticContext = CurContext;

  // C++14 [class.mem]p14:
  //   If T is the name of a class, then each of the following shall have a
  //   name different from T:
  //    -- every member template of class T
  if (TUK != TUK_Friend &&
      DiagnoseClassNameShadow(SemanticContext,
                              DeclarationNameInfo(Name, NameLoc)))
    return true;

  LookupName(Previous, S);
}

if (Previous.isAmbiguous())
  return true;

NamedDecl *PrevDecl = nullptr;
if (Previous.begin() != Previous.end())
  PrevDecl = (*Previous.begin())->getUnderlyingDecl();

if (PrevDecl && PrevDecl->isTemplateParameter()) {
  // Maybe we will complain about the shadowed template parameter.
  DiagnoseTemplateParameterShadow(NameLoc, PrevDecl);
  // Just pretend that we didn't see the previous declaration.
  PrevDecl = nullptr;
}

// If there is a previous declaration with the same name, check
// whether this is a valid redeclaration.
ClassTemplateDecl *PrevClassTemplate =
    dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);

// We may have found the injected-class-name of a class template,
// class template partial specialization, or class template specialization.
// In these cases, grab the template that is being defined or specialized.
if (!PrevClassTemplate && PrevDecl && isa<CXXRecordDecl>(PrevDecl) &&
    cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {
  PrevDecl = cast<CXXRecordDecl>(PrevDecl->getDeclContext());
  PrevClassTemplate
    = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();
  if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {
    PrevClassTemplate
      = cast<ClassTemplateSpecializationDecl>(PrevDecl)
          ->getSpecializedTemplate();
  }
}

if (TUK == TUK_Friend) {
  // C++ [namespace.memdef]p3:
  //   [...] When looking for a prior declaration of a class or a function
  //   declared as a friend, and when the name of the friend class or
  //   function is neither a qualified name nor a template-id, scopes outside
  //   the innermost enclosing namespace scope are not considered.
  if (!SS.isSet()) {
    DeclContext *OutermostContext = CurContext;
    while (!OutermostContext->isFileContext())
      OutermostContext = OutermostContext->getLookupParent();

    if (PrevDecl &&
        (OutermostContext->Equals(PrevDecl->getDeclContext()) ||
         OutermostContext->Encloses(PrevDecl->getDeclContext()))) {
      SemanticContext = PrevDecl->getDeclContext();
    } else {
      // Declarations in outer scopes don't matter. However, the outermost
      // context we computed is the semantic context for our new
      // declaration.
      PrevDecl = PrevClassTemplate = nullptr;
      SemanticContext = OutermostContext;

      // Check that the chosen semantic context doesn't already contain a
      // declaration of this name as a non-tag type.
      Previous.clear(LookupOrdinaryName);
      DeclContext *LookupContext = SemanticContext;
      while (LookupContext->isTransparentContext())
        LookupContext = LookupContext->getLookupParent();
      LookupQualifiedName(Previous, LookupContext);

      if (Previous.isAmbiguous())
        return true;

      if (Previous.begin() != Previous.end())
        PrevDecl = (*Previous.begin())->getUnderlyingDecl();
    }
  }
} else if (PrevDecl &&
           !isDeclInScope(Previous.getRepresentativeDecl(), SemanticContext,
                          S, SS.isValid()))
  PrevDecl = PrevClassTemplate = nullptr;

if (auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
        PrevDecl ? Previous.getRepresentativeDecl() : nullptr)) {
  if (SS.isEmpty() &&
      !(PrevClassTemplate &&
        PrevClassTemplate->getDeclContext()->getRedeclContext()->Equals(
            SemanticContext->getRedeclContext()))) {
    Diag(KWLoc, diag::err_using_decl_conflict_reverse);
    Diag(Shadow->getTargetDecl()->getLocation(),
         diag::note_using_decl_target);
    Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
    // Recover by ignoring the old declaration.
    PrevDecl = PrevClassTemplate = nullptr;
  }
}

// TODO Memory management; associated constraints are not always stored.
Expr *const CurAC = formAssociatedConstraints(TemplateParams, nullptr);

if (PrevClassTemplate) {
  // Ensure that the template parameter lists are compatible. Skip this check
  // for a friend in a dependent context: the template parameter list itself
  // could be dependent.
  if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
      !TemplateParameterListsAreEqual(TemplateParams,
                                 PrevClassTemplate->getTemplateParameters(),
                                      /*Complain=*/true,
                                      TPL_TemplateMatch))
    return true;

  // Check for matching associated constraints on redeclarations.
  const Expr *const PrevAC = PrevClassTemplate->getAssociatedConstraints();
  const bool RedeclACMismatch = [&] {
    if (!(CurAC || PrevAC))
      return false; // Nothing to check; no mismatch.
    if (CurAC && PrevAC) {
      llvm::FoldingSetNodeID CurACInfo, PrevACInfo;
      CurAC->Profile(CurACInfo, Context, /*Canonical=*/true);
      PrevAC->Profile(PrevACInfo, Context, /*Canonical=*/true);
      if (CurACInfo == PrevACInfo)
        return false; // All good; no mismatch.
    }
    return true;
  }();

  if (RedeclACMismatch) {
    Diag(CurAC ? CurAC->getLocStart() : NameLoc,
         diag::err_template_different_associated_constraints);
    Diag(PrevAC ? PrevAC->getLocStart() : PrevClassTemplate->getLocation(),
         diag::note_template_prev_declaration) << /*declaration*/0;
    return true;
  }

  // C++ [temp.class]p4:
  //   In a redeclaration, partial specialization, explicit
  //   specialization or explicit instantiation of a class template,
  //   the class-key shall agree in kind with the original class
  //   template declaration (7.1.5.3).
  RecordDecl *PrevRecordDecl = PrevClassTemplate->getTemplatedDecl();
  if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind,
                                    TUK == TUK_Definition,  KWLoc, Name)) {
    Diag(KWLoc, diag::err_use_with_wrong_tag)
      << Name
      << FixItHint::CreateReplacement(KWLoc, PrevRecordDecl->getKindName());
    Diag(PrevRecordDecl->getLocation(), diag::note_previous_use);
    Kind = PrevRecordDecl->getTagKind();
  }

  // Check for redefinition of this class template.
  if (TUK == TUK_Definition) {
    if (TagDecl *Def = PrevRecordDecl->getDefinition()) {
      // If we have a prior definition that is not visible, treat this as
      // simply making that previous definition visible.
      NamedDecl *Hidden = nullptr;
      if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
        SkipBody->ShouldSkip = true;
        auto *Tmpl = cast<CXXRecordDecl>(Hidden)->getDescribedClassTemplate();
        assert(Tmpl && "original definition of a class template is not a "(static_cast <bool> (Tmpl && "original definition of a class template is not a "
 "class template?") ? void (0) : __assert_fail ("Tmpl && \"original definition of a class template is not a \" \"class template?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1386, __extension__ __PRETTY_FUNCTION__))
                       "class template?")(static_cast <bool> (Tmpl && "original definition of a class template is not a "
 "class template?") ? void (0) : __assert_fail ("Tmpl && \"original definition of a class template is not a \" \"class template?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1386, __extension__ __PRETTY_FUNCTION__));
        makeMergedDefinitionVisible(Hidden);
        makeMergedDefinitionVisible(Tmpl);
        return Def;
      }

      Diag(NameLoc, diag::err_redefinition) << Name;
      Diag(Def->getLocation(), diag::note_previous_definition);
      // FIXME: Would it make sense to try to "forget" the previous
      // definition, as part of error recovery?
      return true;
    }
  }
} else if (PrevDecl) {
  // C++ [temp]p5:
  //   A class template shall not have the same name as any other
  //   template, class, function, object, enumeration, enumerator,
  //   namespace, or type in the same scope (3.3), except as specified
  //   in (14.5.4).
  Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
  return true;
}

// Check the template parameter list of this declaration, possibly
// merging in the template parameter list from the previous class
// template declaration. Skip this check for a friend in a dependent
// context, because the template parameter list might be dependent.
if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
    CheckTemplateParameterList(
        TemplateParams,
        PrevClassTemplate ? PrevClassTemplate->getTemplateParameters()
                          : nullptr,
        (SS.isSet() && SemanticContext && SemanticContext->isRecord() &&
         SemanticContext->isDependentContext())
            ? TPC_ClassTemplateMember
            : TUK == TUK_Friend ? TPC_FriendClassTemplate
                                : TPC_ClassTemplate))
  Invalid = true;

if (SS.isSet()) {
  // If the name of the template was qualified, we must be defining the
  // template out-of-line.
  if (!SS.isInvalid() && !Invalid && !PrevClassTemplate) {
    Diag(NameLoc, TUK == TUK_Friend ? diag::err_friend_decl_does_not_match
                                    : diag::err_member_decl_does_not_match)
      << Name << SemanticContext << /*IsDefinition*/true << SS.getRange();
    Invalid = true;
  }
}

// If this is a templated friend in a dependent context we should not put it
// on the redecl chain. In some cases, the templated friend can be the most
// recent declaration tricking the template instantiator to make substitutions
// there.
// FIXME: Figure out how to combine with shouldLinkDependentDeclWithPrevious
bool ShouldAddRedecl
  = !(TUK == TUK_Friend && CurContext->isDependentContext());

CXXRecordDecl *NewClass =
  CXXRecordDecl::Create(Context, Kind, SemanticContext, KWLoc, NameLoc, Name,
                        PrevClassTemplate && ShouldAddRedecl ?
                          PrevClassTemplate->getTemplatedDecl() : nullptr,
                        /*DelayTypeCreation=*/true);
SetNestedNameSpecifier(NewClass, SS);
if (NumOuterTemplateParamLists > 0)
  NewClass->setTemplateParameterListsInfo(
      Context, llvm::makeArrayRef(OuterTemplateParamLists,
                                  NumOuterTemplateParamLists));

// Add alignment attributes if necessary; these attributes are checked when
// the ASTContext lays out the structure.
if (TUK == TUK_Definition) {
  AddAlignmentAttributesForRecord(NewClass);
  AddMsStructLayoutForRecord(NewClass);
}

// Attach the associated constraints when the declaration will not be part of
// a decl chain.
Expr *const ACtoAttach =
    PrevClassTemplate && ShouldAddRedecl ? nullptr : CurAC;

ClassTemplateDecl *NewTemplate
  = ClassTemplateDecl::Create(Context, SemanticContext, NameLoc,
                              DeclarationName(Name), TemplateParams,
                              NewClass, ACtoAttach);

if (ShouldAddRedecl)
  NewTemplate->setPreviousDecl(PrevClassTemplate);

NewClass->setDescribedClassTemplate(NewTemplate);

if (ModulePrivateLoc.isValid())
  NewTemplate->setModulePrivate();

// Build the type for the class template declaration now.
QualType T = NewTemplate->getInjectedClassNameSpecialization();
T = Context.getInjectedClassNameType(NewClass, T);
assert(T->isDependentType() && "Class template type is not dependent?")(static_cast <bool> (T->isDependentType() &&
 "Class template type is not dependent?") ? void (0) : __assert_fail
 ("T->isDependentType() && \"Class template type is not dependent?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1484, __extension__ __PRETTY_FUNCTION__));
(void)T;

// If we are providing an explicit specialization of a member that is a
// class template, make a note of that.
if (PrevClassTemplate &&
    PrevClassTemplate->getInstantiatedFromMemberTemplate())
  PrevClassTemplate->setMemberSpecialization();

// Set the access specifier.
if (!Invalid && TUK != TUK_Friend && NewTemplate->getDeclContext()->isRecord())
  SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS);

// Set the lexical context of these templates
NewClass->setLexicalDeclContext(CurContext);
NewTemplate->setLexicalDeclContext(CurContext);

if (TUK == TUK_Definition)
  NewClass->startDefinition();

if (Attr)
  ProcessDeclAttributeList(S, NewClass, Attr);

if (PrevClassTemplate)
  mergeDeclAttributes(NewClass, PrevClassTemplate->getTemplatedDecl());

AddPushedVisibilityAttribute(NewClass);

if (TUK != TUK_Friend) {
  // Per C++ [basic.scope.temp]p2, skip the template parameter scopes.
  Scope *Outer = S;
  while ((Outer->getFlags() & Scope::TemplateParamScope) != 0)
    Outer = Outer->getParent();
  PushOnScopeChains(NewTemplate, Outer);
} else {
  if (PrevClassTemplate && PrevClassTemplate->getAccess() != AS_none) {
    NewTemplate->setAccess(PrevClassTemplate->getAccess());
    NewClass->setAccess(PrevClassTemplate->getAccess());
  }

  NewTemplate->setObjectOfFriendDecl();

  // Friend templates are visible in fairly strange ways.
  if (!CurContext->isDependentContext()) {
    DeclContext *DC = SemanticContext->getRedeclContext();
    DC->makeDeclVisibleInContext(NewTemplate);
    if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
      PushOnScopeChains(NewTemplate, EnclosingScope,
                        /* AddToContext = */ false);
  }

  FriendDecl *Friend = FriendDecl::Create(
      Context, CurContext, NewClass->getLocation(), NewTemplate, FriendLoc);
  Friend->setAccess(AS_public);
  CurContext->addDecl(Friend);
}

if (PrevClassTemplate)
  CheckRedeclarationModuleOwnership(NewTemplate, PrevClassTemplate);

if (Invalid) {
  NewTemplate->setInvalidDecl();
  NewClass->setInvalidDecl();
}

ActOnDocumentableDecl(NewTemplate);

return NewTemplate;
1552}

1554namespace {
1555/// Transform to convert portions of a constructor declaration into the
1556/// corresponding deduction guide, per C++1z [over.match.class.deduct]p1.
1557struct ConvertConstructorToDeductionGuideTransform {
ConvertConstructorToDeductionGuideTransform(Sema &S,
                                            ClassTemplateDecl *Template)
    : SemaRef(S), Template(Template) {}

Sema &SemaRef;
ClassTemplateDecl *Template;

DeclContext *DC = Template->getDeclContext();
CXXRecordDecl *Primary = Template->getTemplatedDecl();
DeclarationName DeductionGuideName =
    SemaRef.Context.DeclarationNames.getCXXDeductionGuideName(Template);

QualType DeducedType = SemaRef.Context.getTypeDeclType(Primary);

// Index adjustment to apply to convert depth-1 template parameters into
// depth-0 template parameters.
unsigned Depth1IndexAdjustment = Template->getTemplateParameters()->size();

/// Transform a constructor declaration into a deduction guide.
NamedDecl *transformConstructor(FunctionTemplateDecl *FTD,
                                CXXConstructorDecl *CD) {
  SmallVector<TemplateArgument, 16> SubstArgs;

  LocalInstantiationScope Scope(SemaRef);

  // C++ [over.match.class.deduct]p1:
  // -- For each constructor of the class template designated by the
  //    template-name, a function template with the following properties:

  //    -- The template parameters are the template parameters of the class
  //       template followed by the template parameters (including default
  //       template arguments) of the constructor, if any.
  TemplateParameterList *TemplateParams = Template->getTemplateParameters();
  if (FTD) {
    TemplateParameterList *InnerParams = FTD->getTemplateParameters();
    SmallVector<NamedDecl *, 16> AllParams;
    AllParams.reserve(TemplateParams->size() + InnerParams->size());
    AllParams.insert(AllParams.begin(),
                     TemplateParams->begin(), TemplateParams->end());
    SubstArgs.reserve(InnerParams->size());

    // Later template parameters could refer to earlier ones, so build up
    // a list of substituted template arguments as we go.
    for (NamedDecl *Param : *InnerParams) {
      MultiLevelTemplateArgumentList Args;
      Args.addOuterTemplateArguments(SubstArgs);
      Args.addOuterRetainedLevel();
      NamedDecl *NewParam = transformTemplateParameter(Param, Args);
      if (!NewParam)
        return nullptr;
      AllParams.push_back(NewParam);
      SubstArgs.push_back(SemaRef.Context.getCanonicalTemplateArgument(
          SemaRef.Context.getInjectedTemplateArg(NewParam)));
    }
    TemplateParams = TemplateParameterList::Create(
        SemaRef.Context, InnerParams->getTemplateLoc(),
        InnerParams->getLAngleLoc(), AllParams, InnerParams->getRAngleLoc(),
        /*FIXME: RequiresClause*/ nullptr);
  }

  // If we built a new template-parameter-list, track that we need to
  // substitute references to the old parameters into references to the
  // new ones.
  MultiLevelTemplateArgumentList Args;
  if (FTD) {
    Args.addOuterTemplateArguments(SubstArgs);
    Args.addOuterRetainedLevel();
  }

  FunctionProtoTypeLoc FPTL = CD->getTypeSourceInfo()->getTypeLoc()
                                 .getAsAdjusted<FunctionProtoTypeLoc>();
  assert(FPTL && "no prototype for constructor declaration")(static_cast <bool> (FPTL && "no prototype for constructor declaration"
) ? void (0) : __assert_fail ("FPTL && \"no prototype for constructor declaration\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1629, __extension__ __PRETTY_FUNCTION__));

  // Transform the type of the function, adjusting the return type and
  // replacing references to the old parameters with references to the
  // new ones.
  TypeLocBuilder TLB;
  SmallVector<ParmVarDecl*, 8> Params;
  QualType NewType = transformFunctionProtoType(TLB, FPTL, Params, Args);
  if (NewType.isNull())
    return nullptr;
  TypeSourceInfo *NewTInfo = TLB.getTypeSourceInfo(SemaRef.Context, NewType);

  return buildDeductionGuide(TemplateParams, CD->isExplicit(), NewTInfo,
                             CD->getLocStart(), CD->getLocation(),
                             CD->getLocEnd());
}

/// Build a deduction guide with the specified parameter types.
NamedDecl *buildSimpleDeductionGuide(MutableArrayRef<QualType> ParamTypes) {
  SourceLocation Loc = Template->getLocation();

  // Build the requested type.
  FunctionProtoType::ExtProtoInfo EPI;
  EPI.HasTrailingReturn = true;
  QualType Result = SemaRef.BuildFunctionType(DeducedType, ParamTypes, Loc,
                                              DeductionGuideName, EPI);
  TypeSourceInfo *TSI = SemaRef.Context.getTrivialTypeSourceInfo(Result, Loc);

  FunctionProtoTypeLoc FPTL =
      TSI->getTypeLoc().castAs<FunctionProtoTypeLoc>();

  // Build the parameters, needed during deduction / substitution.
  SmallVector<ParmVarDecl*, 4> Params;
  for (auto T : ParamTypes) {
    ParmVarDecl *NewParam = ParmVarDecl::Create(
        SemaRef.Context, DC, Loc, Loc, nullptr, T,
        SemaRef.Context.getTrivialTypeSourceInfo(T, Loc), SC_None, nullptr);
    NewParam->setScopeInfo(0, Params.size());
    FPTL.setParam(Params.size(), NewParam);
    Params.push_back(NewParam);
  }

  return buildDeductionGuide(Template->getTemplateParameters(), false, TSI,
                             Loc, Loc, Loc);
}

1675private:
/// Transform a constructor template parameter into a deduction guide template
/// parameter, rebuilding any internal references to earlier parameters and
/// renumbering as we go.
NamedDecl *transformTemplateParameter(NamedDecl *TemplateParam,
                                      MultiLevelTemplateArgumentList &Args) {
  if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(TemplateParam)) {
    // TemplateTypeParmDecl's index cannot be changed after creation, so
    // substitute it directly.
    auto *NewTTP = TemplateTypeParmDecl::Create(
        SemaRef.Context, DC, TTP->getLocStart(), TTP->getLocation(),
        /*Depth*/0, Depth1IndexAdjustment + TTP->getIndex(),
        TTP->getIdentifier(), TTP->wasDeclaredWithTypename(),
        TTP->isParameterPack());
    if (TTP->hasDefaultArgument()) {
      TypeSourceInfo *InstantiatedDefaultArg =
          SemaRef.SubstType(TTP->getDefaultArgumentInfo(), Args,
                            TTP->getDefaultArgumentLoc(), TTP->getDeclName());
      if (InstantiatedDefaultArg)
        NewTTP->setDefaultArgument(InstantiatedDefaultArg);
    }
    SemaRef.CurrentInstantiationScope->InstantiatedLocal(TemplateParam,
                                                         NewTTP);
    return NewTTP;
  }

  if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(TemplateParam))
    return transformTemplateParameterImpl(TTP, Args);

  return transformTemplateParameterImpl(
      cast<NonTypeTemplateParmDecl>(TemplateParam), Args);
}
template<typename TemplateParmDecl>
TemplateParmDecl *
transformTemplateParameterImpl(TemplateParmDecl *OldParam,
                               MultiLevelTemplateArgumentList &Args) {
  // Ask the template instantiator to do the heavy lifting for us, then adjust
  // the index of the parameter once it's done.
  auto *NewParam =
      cast_or_null<TemplateParmDecl>(SemaRef.SubstDecl(OldParam, DC, Args));
  assert(NewParam->getDepth() == 0 && "unexpected template param depth")(static_cast <bool> (NewParam->getDepth() == 0 &&
 "unexpected template param depth") ? void (0) : __assert_fail
 ("NewParam->getDepth() == 0 && \"unexpected template param depth\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1715, __extension__ __PRETTY_FUNCTION__));
  NewParam->setPosition(NewParam->getPosition() + Depth1IndexAdjustment);
  return NewParam;
}

QualType transformFunctionProtoType(TypeLocBuilder &TLB,
                                    FunctionProtoTypeLoc TL,
                                    SmallVectorImpl<ParmVarDecl*> &Params,
                                    MultiLevelTemplateArgumentList &Args) {
  SmallVector<QualType, 4> ParamTypes;
  const FunctionProtoType *T = TL.getTypePtr();

  //    -- The types of the function parameters are those of the constructor.
  for (auto *OldParam : TL.getParams()) {
    ParmVarDecl *NewParam = transformFunctionTypeParam(OldParam, Args);
    if (!NewParam)
      return QualType();
    ParamTypes.push_back(NewParam->getType());
    Params.push_back(NewParam);
  }

  //    -- The return type is the class template specialization designated by
  //       the template-name and template arguments corresponding to the
  //       template parameters obtained from the class template.
  //
  // We use the injected-class-name type of the primary template instead.
  // This has the convenient property that it is different from any type that
  // the user can write in a deduction-guide (because they cannot enter the
  // context of the template), so implicit deduction guides can never collide
  // with explicit ones.
  QualType ReturnType = DeducedType;
  TLB.pushTypeSpec(ReturnType).setNameLoc(Primary->getLocation());

  // Resolving a wording defect, we also inherit the variadicness of the
  // constructor.
  FunctionProtoType::ExtProtoInfo EPI;
  EPI.Variadic = T->isVariadic();
  EPI.HasTrailingReturn = true;

  QualType Result = SemaRef.BuildFunctionType(
      ReturnType, ParamTypes, TL.getLocStart(), DeductionGuideName, EPI);
  if (Result.isNull())
    return QualType();

  FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
  NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
  NewTL.setLParenLoc(TL.getLParenLoc());
  NewTL.setRParenLoc(TL.getRParenLoc());
  NewTL.setExceptionSpecRange(SourceRange());
  NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
  for (unsigned I = 0, E = NewTL.getNumParams(); I != E; ++I)
    NewTL.setParam(I, Params[I]);

  return Result;
}

ParmVarDecl *
transformFunctionTypeParam(ParmVarDecl *OldParam,
                           MultiLevelTemplateArgumentList &Args) {
  TypeSourceInfo *OldDI = OldParam->getTypeSourceInfo();
  TypeSourceInfo *NewDI;
  if (!Args.getNumLevels())
    NewDI = OldDI;
  else if (auto PackTL = OldDI->getTypeLoc().getAs<PackExpansionTypeLoc>()) {
    // Expand out the one and only element in each inner pack.
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, 0);
    NewDI =
        SemaRef.SubstType(PackTL.getPatternLoc(), Args,
                          OldParam->getLocation(), OldParam->getDeclName());
    if (!NewDI) return nullptr;
    NewDI =
        SemaRef.CheckPackExpansion(NewDI, PackTL.getEllipsisLoc(),
                                   PackTL.getTypePtr()->getNumExpansions());
  } else
    NewDI = SemaRef.SubstType(OldDI, Args, OldParam->getLocation(),
                              OldParam->getDeclName());
  if (!NewDI)
    return nullptr;

  // Canonicalize the type. This (for instance) replaces references to
  // typedef members of the current instantiations with the definitions of
  // those typedefs, avoiding triggering instantiation of the deduced type
  // during deduction.
  // FIXME: It would be preferable to retain type sugar and source
  // information here (and handle this in substitution instead).
  NewDI = SemaRef.Context.getTrivialTypeSourceInfo(
      SemaRef.Context.getCanonicalType(NewDI->getType()),
      OldParam->getLocation());

  // Resolving a wording defect, we also inherit default arguments from the
  // constructor.
  ExprResult NewDefArg;
  if (OldParam->hasDefaultArg()) {
    NewDefArg = Args.getNumLevels()
                    ? SemaRef.SubstExpr(OldParam->getDefaultArg(), Args)
                    : OldParam->getDefaultArg();
    if (NewDefArg.isInvalid())
      return nullptr;
  }

  ParmVarDecl *NewParam = ParmVarDecl::Create(SemaRef.Context, DC,
                                              OldParam->getInnerLocStart(),
                                              OldParam->getLocation(),
                                              OldParam->getIdentifier(),
                                              NewDI->getType(),
                                              NewDI,
                                              OldParam->getStorageClass(),
                                              NewDefArg.get());
  NewParam->setScopeInfo(OldParam->getFunctionScopeDepth(),
                         OldParam->getFunctionScopeIndex());
  return NewParam;
}

NamedDecl *buildDeductionGuide(TemplateParameterList *TemplateParams,
                               bool Explicit, TypeSourceInfo *TInfo,
                               SourceLocation LocStart, SourceLocation Loc,
                               SourceLocation LocEnd) {
  DeclarationNameInfo Name(DeductionGuideName, Loc);
  ArrayRef<ParmVarDecl *> Params =
      TInfo->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams();

  // Build the implicit deduction guide template.
  auto *Guide =
      CXXDeductionGuideDecl::Create(SemaRef.Context, DC, LocStart, Explicit,
                                    Name, TInfo->getType(), TInfo, LocEnd);
  Guide->setImplicit();
  Guide->setParams(Params);

  for (auto *Param : Params)
    Param->setDeclContext(Guide);

  auto *GuideTemplate = FunctionTemplateDecl::Create(
      SemaRef.Context, DC, Loc, DeductionGuideName, TemplateParams, Guide);
  GuideTemplate->setImplicit();
  Guide->setDescribedFunctionTemplate(GuideTemplate);

  if (isa<CXXRecordDecl>(DC)) {
    Guide->setAccess(AS_public);
    GuideTemplate->setAccess(AS_public);
  }

  DC->addDecl(GuideTemplate);
  return GuideTemplate;
}
1859};
1860}

1862void Sema::DeclareImplicitDeductionGuides(TemplateDecl *Template,
                                        SourceLocation Loc) {
DeclContext *DC = Template->getDeclContext();
if (DC->isDependentContext())
  return;

ConvertConstructorToDeductionGuideTransform Transform(
    *this, cast<ClassTemplateDecl>(Template));
if (!isCompleteType(Loc, Transform.DeducedType))
  return;

// Check whether we've already declared deduction guides for this template.
// FIXME: Consider storing a flag on the template to indicate this.
auto Existing = DC->lookup(Transform.DeductionGuideName);
for (auto *D : Existing)
  if (D->isImplicit())
    return;

// In case we were expanding a pack when we attempted to declare deduction
// guides, turn off pack expansion for everything we're about to do.
ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1);
// Create a template instantiation record to track the "instantiation" of
// constructors into deduction guides.
// FIXME: Add a kind for this to give more meaningful diagnostics. But can
// this substitution process actually fail?
InstantiatingTemplate BuildingDeductionGuides(*this, Loc, Template);

// Convert declared constructors into deduction guide templates.
// FIXME: Skip constructors for which deduction must necessarily fail (those
// for which some class template parameter without a default argument never
// appears in a deduced context).
bool AddedAny = false;
for (NamedDecl *D : LookupConstructors(Transform.Primary)) {
  D = D->getUnderlyingDecl();
  if (D->isInvalidDecl() || D->isImplicit())
    continue;
  D = cast<NamedDecl>(D->getCanonicalDecl());

  auto *FTD = dyn_cast<FunctionTemplateDecl>(D);
  auto *CD =
      dyn_cast_or_null<CXXConstructorDecl>(FTD ? FTD->getTemplatedDecl() : D);
  // Class-scope explicit specializations (MS extension) do not result in
  // deduction guides.
  if (!CD || (!FTD && CD->isFunctionTemplateSpecialization()))
    continue;

  Transform.transformConstructor(FTD, CD);
  AddedAny = true;
}

// C++17 [over.match.class.deduct]
//    --  If C is not defined or does not declare any constructors, an
//    additional function template derived as above from a hypothetical
//    constructor C().
if (!AddedAny)
  Transform.buildSimpleDeductionGuide(None);

//    -- An additional function template derived as above from a hypothetical
//    constructor C(C), called the copy deduction candidate.
cast<CXXDeductionGuideDecl>(
    cast<FunctionTemplateDecl>(
        Transform.buildSimpleDeductionGuide(Transform.DeducedType))
        ->getTemplatedDecl())
    ->setIsCopyDeductionCandidate();
1926}

1928/// \brief Diagnose the presence of a default template argument on a
1929/// template parameter, which is ill-formed in certain contexts.
1930///
1931/// \returns true if the default template argument should be dropped.
1932static bool DiagnoseDefaultTemplateArgument(Sema &S,
                                          Sema::TemplateParamListContext TPC,
                                          SourceLocation ParamLoc,
                                          SourceRange DefArgRange) {
switch (TPC) {
case Sema::TPC_ClassTemplate:
case Sema::TPC_VarTemplate:
case Sema::TPC_TypeAliasTemplate:
  return false;

case Sema::TPC_FunctionTemplate:
case Sema::TPC_FriendFunctionTemplateDefinition:
  // C++ [temp.param]p9:
  //   A default template-argument shall not be specified in a
  //   function template declaration or a function template
  //   definition [...]
  //   If a friend function template declaration specifies a default
  //   template-argument, that declaration shall be a definition and shall be
  //   the only declaration of the function template in the translation unit.
  // (C++98/03 doesn't have this wording; see DR226).
  S.Diag(ParamLoc, S.getLangOpts().CPlusPlus11 ?
       diag::warn_cxx98_compat_template_parameter_default_in_function_template
         : diag::ext_template_parameter_default_in_function_template)
    << DefArgRange;
  return false;

case Sema::TPC_ClassTemplateMember:
  // C++0x [temp.param]p9:
  //   A default template-argument shall not be specified in the
  //   template-parameter-lists of the definition of a member of a
  //   class template that appears outside of the member's class.
  S.Diag(ParamLoc, diag::err_template_parameter_default_template_member)
    << DefArgRange;
  return true;

case Sema::TPC_FriendClassTemplate:
case Sema::TPC_FriendFunctionTemplate:
  // C++ [temp.param]p9:
  //   A default template-argument shall not be specified in a
  //   friend template declaration.
  S.Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
    << DefArgRange;
  return true;

  // FIXME: C++0x [temp.param]p9 allows default template-arguments
  // for friend function templates if there is only a single
  // declaration (and it is a definition). Strange!
}

llvm_unreachable("Invalid TemplateParamListContext!")::llvm::llvm_unreachable_internal("Invalid TemplateParamListContext!"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1981);
1982}

1984/// \brief Check for unexpanded parameter packs within the template parameters
1985/// of a template template parameter, recursively.
1986static bool DiagnoseUnexpandedParameterPacks(Sema &S,
                                           TemplateTemplateParmDecl *TTP) {
// A template template parameter which is a parameter pack is also a pack
// expansion.
if (TTP->isParameterPack())
  return false;

TemplateParameterList *Params = TTP->getTemplateParameters();
for (unsigned I = 0, N = Params->size(); I != N; ++I) {
  NamedDecl *P = Params->getParam(I);
  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
    if (!NTTP->isParameterPack() &&
        S.DiagnoseUnexpandedParameterPack(NTTP->getLocation(),
                                          NTTP->getTypeSourceInfo(),
                                    Sema::UPPC_NonTypeTemplateParameterType))
      return true;

    continue;
  }

  if (TemplateTemplateParmDecl *InnerTTP
                                      = dyn_cast<TemplateTemplateParmDecl>(P))
    if (DiagnoseUnexpandedParameterPacks(S, InnerTTP))
      return true;
}

return false;
2013}

2015/// \brief Checks the validity of a template parameter list, possibly
2016/// considering the template parameter list from a previous
2017/// declaration.
2018///
2019/// If an "old" template parameter list is provided, it must be
2020/// equivalent (per TemplateParameterListsAreEqual) to the "new"
2021/// template parameter list.
2022///
2023/// \param NewParams Template parameter list for a new template
2024/// declaration. This template parameter list will be updated with any
2025/// default arguments that are carried through from the previous
2026/// template parameter list.
2027///
2028/// \param OldParams If provided, template parameter list from a
2029/// previous declaration of the same template. Default template
2030/// arguments will be merged from the old template parameter list to
2031/// the new template parameter list.
2032///
2033/// \param TPC Describes the context in which we are checking the given
2034/// template parameter list.
2035///
2036/// \returns true if an error occurred, false otherwise.
2037bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
                                    TemplateParameterList *OldParams,
                                    TemplateParamListContext TPC) {
bool Invalid = false;

// C++ [temp.param]p10:
//   The set of default template-arguments available for use with a
//   template declaration or definition is obtained by merging the
//   default arguments from the definition (if in scope) and all
//   declarations in scope in the same way default function
//   arguments are (8.3.6).
bool SawDefaultArgument = false;
SourceLocation PreviousDefaultArgLoc;

// Dummy initialization to avoid warnings.
TemplateParameterList::iterator OldParam = NewParams->end();
if (OldParams)
  OldParam = OldParams->begin();

bool RemoveDefaultArguments = false;
for (TemplateParameterList::iterator NewParam = NewParams->begin(),
                                  NewParamEnd = NewParams->end();
     NewParam != NewParamEnd; ++NewParam) {
  // Variables used to diagnose redundant default arguments
  bool RedundantDefaultArg = false;
  SourceLocation OldDefaultLoc;
  SourceLocation NewDefaultLoc;

  // Variable used to diagnose missing default arguments
  bool MissingDefaultArg = false;

  // Variable used to diagnose non-final parameter packs
  bool SawParameterPack = false;

  if (TemplateTypeParmDecl *NewTypeParm
        = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
    // Check the presence of a default argument here.
    if (NewTypeParm->hasDefaultArgument() &&
        DiagnoseDefaultTemplateArgument(*this, TPC,
                                        NewTypeParm->getLocation(),
             NewTypeParm->getDefaultArgumentInfo()->getTypeLoc()
                                                     .getSourceRange()))
      NewTypeParm->removeDefaultArgument();

    // Merge default arguments for template type parameters.
    TemplateTypeParmDecl *OldTypeParm
        = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : nullptr;
    if (NewTypeParm->isParameterPack()) {
      assert(!NewTypeParm->hasDefaultArgument() &&(static_cast <bool> (!NewTypeParm->hasDefaultArgument
() && "Parameter packs can't have a default argument!"
) ? void (0) : __assert_fail ("!NewTypeParm->hasDefaultArgument() && \"Parameter packs can't have a default argument!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2086, __extension__ __PRETTY_FUNCTION__))
             "Parameter packs can't have a default argument!")(static_cast <bool> (!NewTypeParm->hasDefaultArgument
() && "Parameter packs can't have a default argument!"
) ? void (0) : __assert_fail ("!NewTypeParm->hasDefaultArgument() && \"Parameter packs can't have a default argument!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2086, __extension__ __PRETTY_FUNCTION__));
      SawParameterPack = true;
    } else if (OldTypeParm && hasVisibleDefaultArgument(OldTypeParm) &&
               NewTypeParm->hasDefaultArgument()) {
      OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc();
      NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
      SawDefaultArgument = true;
      RedundantDefaultArg = true;
      PreviousDefaultArgLoc = NewDefaultLoc;
    } else if (OldTypeParm && OldTypeParm->hasDefaultArgument()) {
      // Merge the default argument from the old declaration to the
      // new declaration.
      NewTypeParm->setInheritedDefaultArgument(Context, OldTypeParm);
      PreviousDefaultArgLoc = OldTypeParm->getDefaultArgumentLoc();
    } else if (NewTypeParm->hasDefaultArgument()) {
      SawDefaultArgument = true;
      PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
    } else if (SawDefaultArgument)
      MissingDefaultArg = true;
  } else if (NonTypeTemplateParmDecl *NewNonTypeParm
             = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
    // Check for unexpanded parameter packs.
    if (!NewNonTypeParm->isParameterPack() &&
        DiagnoseUnexpandedParameterPack(NewNonTypeParm->getLocation(),
                                        NewNonTypeParm->getTypeSourceInfo(),
                                        UPPC_NonTypeTemplateParameterType)) {
      Invalid = true;
      continue;
    }

    // Check the presence of a default argument here.
    if (NewNonTypeParm->hasDefaultArgument() &&
        DiagnoseDefaultTemplateArgument(*this, TPC,
                                        NewNonTypeParm->getLocation(),
                  NewNonTypeParm->getDefaultArgument()->getSourceRange())) {
      NewNonTypeParm->removeDefaultArgument();
    }

    // Merge default arguments for non-type template parameters
    NonTypeTemplateParmDecl *OldNonTypeParm
      = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : nullptr;
    if (NewNonTypeParm->isParameterPack()) {
      assert(!NewNonTypeParm->hasDefaultArgument() &&(static_cast <bool> (!NewNonTypeParm->hasDefaultArgument
() && "Parameter packs can't have a default argument!"
) ? void (0) : __assert_fail ("!NewNonTypeParm->hasDefaultArgument() && \"Parameter packs can't have a default argument!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2129, __extension__ __PRETTY_FUNCTION__))
             "Parameter packs can't have a default argument!")(static_cast <bool> (!NewNonTypeParm->hasDefaultArgument
() && "Parameter packs can't have a default argument!"
) ? void (0) : __assert_fail ("!NewNonTypeParm->hasDefaultArgument() && \"Parameter packs can't have a default argument!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2129, __extension__ __PRETTY_FUNCTION__));
      if (!NewNonTypeParm->isPackExpansion())
        SawParameterPack = true;
    } else if (OldNonTypeParm && hasVisibleDefaultArgument(OldNonTypeParm) &&
               NewNonTypeParm->hasDefaultArgument()) {
      OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc();
      NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
      SawDefaultArgument = true;
      RedundantDefaultArg = true;
      PreviousDefaultArgLoc = NewDefaultLoc;
    } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument()) {
      // Merge the default argument from the old declaration to the
      // new declaration.
      NewNonTypeParm->setInheritedDefaultArgument(Context, OldNonTypeParm);
      PreviousDefaultArgLoc = OldNonTypeParm->getDefaultArgumentLoc();
    } else if (NewNonTypeParm->hasDefaultArgument()) {
      SawDefaultArgument = true;
      PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
    } else if (SawDefaultArgument)
      MissingDefaultArg = true;
  } else {
    TemplateTemplateParmDecl *NewTemplateParm
      = cast<TemplateTemplateParmDecl>(*NewParam);

    // Check for unexpanded parameter packs, recursively.
    if (::DiagnoseUnexpandedParameterPacks(*this, NewTemplateParm)) {
      Invalid = true;
      continue;
    }

    // Check the presence of a default argument here.
    if (NewTemplateParm->hasDefaultArgument() &&
        DiagnoseDefaultTemplateArgument(*this, TPC,
                                        NewTemplateParm->getLocation(),
                   NewTemplateParm->getDefaultArgument().getSourceRange()))
      NewTemplateParm->removeDefaultArgument();

    // Merge default arguments for template template parameters
    TemplateTemplateParmDecl *OldTemplateParm
      = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : nullptr;
    if (NewTemplateParm->isParameterPack()) {
      assert(!NewTemplateParm->hasDefaultArgument() &&(static_cast <bool> (!NewTemplateParm->hasDefaultArgument
() && "Parameter packs can't have a default argument!"
) ? void (0) : __assert_fail ("!NewTemplateParm->hasDefaultArgument() && \"Parameter packs can't have a default argument!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2171, __extension__ __PRETTY_FUNCTION__))
             "Parameter packs can't have a default argument!")(static_cast <bool> (!NewTemplateParm->hasDefaultArgument
() && "Parameter packs can't have a default argument!"
) ? void (0) : __assert_fail ("!NewTemplateParm->hasDefaultArgument() && \"Parameter packs can't have a default argument!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2171, __extension__ __PRETTY_FUNCTION__));
      if (!NewTemplateParm->isPackExpansion())
        SawParameterPack = true;
    } else if (OldTemplateParm &&
               hasVisibleDefaultArgument(OldTemplateParm) &&
               NewTemplateParm->hasDefaultArgument()) {
      OldDefaultLoc = OldTemplateParm->getDefaultArgument().getLocation();
      NewDefaultLoc = NewTemplateParm->getDefaultArgument().getLocation();
      SawDefaultArgument = true;
      RedundantDefaultArg = true;
      PreviousDefaultArgLoc = NewDefaultLoc;
    } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) {
      // Merge the default argument from the old declaration to the
      // new declaration.
      NewTemplateParm->setInheritedDefaultArgument(Context, OldTemplateParm);
      PreviousDefaultArgLoc
        = OldTemplateParm->getDefaultArgument().getLocation();
    } else if (NewTemplateParm->hasDefaultArgument()) {
      SawDefaultArgument = true;
      PreviousDefaultArgLoc
        = NewTemplateParm->getDefaultArgument().getLocation();
    } else if (SawDefaultArgument)
      MissingDefaultArg = true;
  }

  // C++11 [temp.param]p11:
  //   If a template parameter of a primary class template or alias template
  //   is a template parameter pack, it shall be the last template parameter.
  if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
      (TPC == TPC_ClassTemplate || TPC == TPC_VarTemplate ||
       TPC == TPC_TypeAliasTemplate)) {
    Diag((*NewParam)->getLocation(),
         diag::err_template_param_pack_must_be_last_template_parameter);
    Invalid = true;
  }

  if (RedundantDefaultArg) {
    // C++ [temp.param]p12:
    //   A template-parameter shall not be given default arguments
    //   by two different declarations in the same scope.
    Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
    Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
    Invalid = true;
  } else if (MissingDefaultArg && TPC != TPC_FunctionTemplate) {
    // C++ [temp.param]p11:
    //   If a template-parameter of a class template has a default
    //   template-argument, each subsequent template-parameter shall either
    //   have a default template-argument supplied or be a template parameter
    //   pack.
    Diag((*NewParam)->getLocation(),
         diag::err_template_param_default_arg_missing);
    Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
    Invalid = true;
    RemoveDefaultArguments = true;
  }

  // If we have an old template parameter list that we're merging
  // in, move on to the next parameter.
  if (OldParams)
    ++OldParam;
}

// We were missing some default arguments at the end of the list, so remove
// all of the default arguments.
if (RemoveDefaultArguments) {
  for (TemplateParameterList::iterator NewParam = NewParams->begin(),
                                    NewParamEnd = NewParams->end();
       NewParam != NewParamEnd; ++NewParam) {
    if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*NewParam))
      TTP->removeDefaultArgument();
    else if (NonTypeTemplateParmDecl *NTTP
                              = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
      NTTP->removeDefaultArgument();
    else
      cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();
  }
}

return Invalid;
2250}

2252namespace {

2254/// A class which looks for a use of a certain level of template
2255/// parameter.
2256struct DependencyChecker : RecursiveASTVisitor<DependencyChecker> {
typedef RecursiveASTVisitor<DependencyChecker> super;

unsigned Depth;

// Whether we're looking for a use of a template parameter that makes the
// overall construct type-dependent / a dependent type. This is strictly
// best-effort for now; we may fail to match at all for a dependent type
// in some cases if this is set.
bool IgnoreNonTypeDependent;

bool Match;
SourceLocation MatchLoc;

DependencyChecker(unsigned Depth, bool IgnoreNonTypeDependent)
    : Depth(Depth), IgnoreNonTypeDependent(IgnoreNonTypeDependent),
      Match(false) {}

DependencyChecker(TemplateParameterList *Params, bool IgnoreNonTypeDependent)
    : IgnoreNonTypeDependent(IgnoreNonTypeDependent), Match(false) {
  NamedDecl *ND = Params->getParam(0);
  if (TemplateTypeParmDecl *PD = dyn_cast<TemplateTypeParmDecl>(ND)) {
    Depth = PD->getDepth();
  } else if (NonTypeTemplateParmDecl *PD =
               dyn_cast<NonTypeTemplateParmDecl>(ND)) {
    Depth = PD->getDepth();
  } else {
    Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();
  }
}

bool Matches(unsigned ParmDepth, SourceLocation Loc = SourceLocation()) {
  if (ParmDepth >= Depth) {
    Match = true;
    MatchLoc = Loc;
    return true;
  }
  return false;
}

bool TraverseStmt(Stmt *S, DataRecursionQueue *Q = nullptr) {
  // Prune out non-type-dependent expressions if requested. This can
  // sometimes result in us failing to find a template parameter reference
  // (if a value-dependent expression creates a dependent type), but this
  // mode is best-effort only.
  if (auto *E = dyn_cast_or_null<Expr>(S))
    if (IgnoreNonTypeDependent && !E->isTypeDependent())
      return true;
  return super::TraverseStmt(S, Q);
}

bool TraverseTypeLoc(TypeLoc TL) {
  if (IgnoreNonTypeDependent && !TL.isNull() &&
      !TL.getType()->isDependentType())
    return true;
  return super::TraverseTypeLoc(TL);
}

bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
  return !Matches(TL.getTypePtr()->getDepth(), TL.getNameLoc());
}

bool VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
  // For a best-effort search, keep looking until we find a location.
  return IgnoreNonTypeDependent || !Matches(T->getDepth());
}

bool TraverseTemplateName(TemplateName N) {
  if (TemplateTemplateParmDecl *PD =
        dyn_cast_or_null<TemplateTemplateParmDecl>(N.getAsTemplateDecl()))
    if (Matches(PD->getDepth()))
      return false;
  return super::TraverseTemplateName(N);
}

bool VisitDeclRefExpr(DeclRefExpr *E) {
  if (NonTypeTemplateParmDecl *PD =
        dyn_cast<NonTypeTemplateParmDecl>(E->getDecl()))
    if (Matches(PD->getDepth(), E->getExprLoc()))
      return false;
  return super::VisitDeclRefExpr(E);
}

bool VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
  return TraverseType(T->getReplacementType());
}

bool
VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {
  return TraverseTemplateArgument(T->getArgumentPack());
}

bool TraverseInjectedClassNameType(const InjectedClassNameType *T) {
  return TraverseType(T->getInjectedSpecializationType());
}
2351};
2352} // end anonymous namespace

2354/// Determines whether a given type depends on the given parameter
2355/// list.
2356static bool
2357DependsOnTemplateParameters(QualType T, TemplateParameterList *Params) {
DependencyChecker Checker(Params, /*IgnoreNonTypeDependent*/false);
Checker.TraverseType(T);
return Checker.Match;
2361}

2363// Find the source range corresponding to the named type in the given
2364// nested-name-specifier, if any.
2365static SourceRange getRangeOfTypeInNestedNameSpecifier(ASTContext &Context,
                                                     QualType T,
                                                     const CXXScopeSpec &SS) {
NestedNameSpecifierLoc NNSLoc(SS.getScopeRep(), SS.location_data());
while (NestedNameSpecifier *NNS = NNSLoc.getNestedNameSpecifier()) {
  if (const Type *CurType = NNS->getAsType()) {
    if (Context.hasSameUnqualifiedType(T, QualType(CurType, 0)))
      return NNSLoc.getTypeLoc().getSourceRange();
  } else
    break;

  NNSLoc = NNSLoc.getPrefix();
}

return SourceRange();
2380}

2382/// \brief Match the given template parameter lists to the given scope
2383/// specifier, returning the template parameter list that applies to the
2384/// name.
2385///
2386/// \param DeclStartLoc the start of the declaration that has a scope
2387/// specifier or a template parameter list.
2388///
2389/// \param DeclLoc The location of the declaration itself.
2390///
2391/// \param SS the scope specifier that will be matched to the given template
2392/// parameter lists. This scope specifier precedes a qualified name that is
2393/// being declared.
2394///
2395/// \param TemplateId The template-id following the scope specifier, if there
2396/// is one. Used to check for a missing 'template<>'.
2397///
2398/// \param ParamLists the template parameter lists, from the outermost to the
2399/// innermost template parameter lists.
2400///
2401/// \param IsFriend Whether to apply the slightly different rules for
2402/// matching template parameters to scope specifiers in friend
2403/// declarations.
2404///
2405/// \param IsMemberSpecialization will be set true if the scope specifier
2406/// denotes a fully-specialized type, and therefore this is a declaration of
2407/// a member specialization.
2408///
2409/// \returns the template parameter list, if any, that corresponds to the
2410/// name that is preceded by the scope specifier @p SS. This template
2411/// parameter list may have template parameters (if we're declaring a
2412/// template) or may have no template parameters (if we're declaring a
2413/// template specialization), or may be NULL (if what we're declaring isn't
2414/// itself a template).
2415TemplateParameterList *Sema::MatchTemplateParametersToScopeSpecifier(
  SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS,
  TemplateIdAnnotation *TemplateId,
  ArrayRef<TemplateParameterList *> ParamLists, bool IsFriend,
  bool &IsMemberSpecialization, bool &Invalid) {
IsMemberSpecialization = false;
Invalid = false;

// The sequence of nested types to which we will match up the template
// parameter lists. We first build this list by starting with the type named
// by the nested-name-specifier and walking out until we run out of types.
SmallVector<QualType, 4> NestedTypes;
QualType T;
if (SS.getScopeRep()) {
  if (CXXRecordDecl *Record
            = dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, true)))
    T = Context.getTypeDeclType(Record);
  else
    T = QualType(SS.getScopeRep()->getAsType(), 0);
}

// If we found an explicit specialization that prevents us from needing
// 'template<>' headers, this will be set to the location of that
// explicit specialization.
SourceLocation ExplicitSpecLoc;

while (!T.isNull()) {
  NestedTypes.push_back(T);

  // Retrieve the parent of a record type.
  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
    // If this type is an explicit specialization, we're done.
    if (ClassTemplateSpecializationDecl *Spec
        = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
      if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
          Spec->getSpecializationKind() == TSK_ExplicitSpecialization) {
        ExplicitSpecLoc = Spec->getLocation();
        break;
      }
    } else if (Record->getTemplateSpecializationKind()
                                              == TSK_ExplicitSpecialization) {
      ExplicitSpecLoc = Record->getLocation();
      break;
    }

    if (TypeDecl *Parent = dyn_cast<TypeDecl>(Record->getParent()))
      T = Context.getTypeDeclType(Parent);
    else
      T = QualType();
    continue;
  }

  if (const TemplateSpecializationType *TST
                                   = T->getAs<TemplateSpecializationType>()) {
    if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
      if (TypeDecl *Parent = dyn_cast<TypeDecl>(Template->getDeclContext()))
        T = Context.getTypeDeclType(Parent);
      else
        T = QualType();
      continue;
    }
  }

  // Look one step prior in a dependent template specialization type.
  if (const DependentTemplateSpecializationType *DependentTST
                        = T->getAs<DependentTemplateSpecializationType>()) {
    if (NestedNameSpecifier *NNS = DependentTST->getQualifier())
      T = QualType(NNS->getAsType(), 0);
    else
      T = QualType();
    continue;
  }

  // Look one step prior in a dependent name type.
  if (const DependentNameType *DependentName = T->getAs<DependentNameType>()){
    if (NestedNameSpecifier *NNS = DependentName->getQualifier())
      T = QualType(NNS->getAsType(), 0);
    else
      T = QualType();
    continue;
  }

  // Retrieve the parent of an enumeration type.
  if (const EnumType *EnumT = T->getAs<EnumType>()) {
    // FIXME: Forward-declared enums require a TSK_ExplicitSpecialization
    // check here.
    EnumDecl *Enum = EnumT->getDecl();

    // Get to the parent type.
    if (TypeDecl *Parent = dyn_cast<TypeDecl>(Enum->getParent()))
      T = Context.getTypeDeclType(Parent);
    else
      T = QualType();
    continue;
  }

  T = QualType();
}
// Reverse the nested types list, since we want to traverse from the outermost
// to the innermost while checking template-parameter-lists.
std::reverse(NestedTypes.begin(), NestedTypes.end());

// C++0x [temp.expl.spec]p17:
//   A member or a member template may be nested within many
//   enclosing class templates. In an explicit specialization for
//   such a member, the member declaration shall be preceded by a
//   template<> for each enclosing class template that is
//   explicitly specialized.
bool SawNonEmptyTemplateParameterList = false;

auto CheckExplicitSpecialization = [&](SourceRange Range, bool Recovery) {
  if (SawNonEmptyTemplateParameterList) {
    Diag(DeclLoc, diag::err_specialize_member_of_template)
      << !Recovery << Range;
    Invalid = true;
    IsMemberSpecialization = false;
    return true;
  }

  return false;
};

auto DiagnoseMissingExplicitSpecialization = [&] (SourceRange Range) {
  // Check that we can have an explicit specialization here.
  if (CheckExplicitSpecialization(Range, true))
    return true;

  // We don't have a template header, but we should.
  SourceLocation ExpectedTemplateLoc;
  if (!ParamLists.empty())
    ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
  else
    ExpectedTemplateLoc = DeclStartLoc;

  Diag(DeclLoc, diag::err_template_spec_needs_header)
    << Range
    << FixItHint::CreateInsertion(ExpectedTemplateLoc, "template<> ");
  return false;
};

unsigned ParamIdx = 0;
for (unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
     ++TypeIdx) {
  T = NestedTypes[TypeIdx];

  // Whether we expect a 'template<>' header.
  bool NeedEmptyTemplateHeader = false;

  // Whether we expect a template header with parameters.
  bool NeedNonemptyTemplateHeader = false;

  // For a dependent type, the set of template parameters that we
  // expect to see.
  TemplateParameterList *ExpectedTemplateParams = nullptr;

  // C++0x [temp.expl.spec]p15:
  //   A member or a member template may be nested within many enclosing
  //   class templates. In an explicit specialization for such a member, the
  //   member declaration shall be preceded by a template<> for each
  //   enclosing class template that is explicitly specialized.
  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
    if (ClassTemplatePartialSpecializationDecl *Partial
          = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) {
      ExpectedTemplateParams = Partial->getTemplateParameters();
      NeedNonemptyTemplateHeader = true;
    } else if (Record->isDependentType()) {
      if (Record->getDescribedClassTemplate()) {
        ExpectedTemplateParams = Record->getDescribedClassTemplate()
                                                    ->getTemplateParameters();
        NeedNonemptyTemplateHeader = true;
      }
    } else if (ClassTemplateSpecializationDecl *Spec
                   = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
      // C++0x [temp.expl.spec]p4:
      //   Members of an explicitly specialized class template are defined
      //   in the same manner as members of normal classes, and not using
      //   the template<> syntax.
      if (Spec->getSpecializationKind() != TSK_ExplicitSpecialization)
        NeedEmptyTemplateHeader = true;
      else
        continue;
    } else if (Record->getTemplateSpecializationKind()) {
      if (Record->getTemplateSpecializationKind()
                                              != TSK_ExplicitSpecialization &&
          TypeIdx == NumTypes - 1)
        IsMemberSpecialization = true;

      continue;
    }
  } else if (const TemplateSpecializationType *TST
                                   = T->getAs<TemplateSpecializationType>()) {
    if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
      ExpectedTemplateParams = Template->getTemplateParameters();
      NeedNonemptyTemplateHeader = true;
    }
  } else if (T->getAs<DependentTemplateSpecializationType>()) {
    // FIXME:  We actually could/should check the template arguments here
    // against the corresponding template parameter list.
    NeedNonemptyTemplateHeader = false;
  }

  // C++ [temp.expl.spec]p16:
  //   In an explicit specialization declaration for a member of a class
  //   template or a member template that ap- pears in namespace scope, the
  //   member template and some of its enclosing class templates may remain
  //   unspecialized, except that the declaration shall not explicitly
  //   specialize a class member template if its en- closing class templates
  //   are not explicitly specialized as well.
  if (ParamIdx < ParamLists.size()) {
    if (ParamLists[ParamIdx]->size() == 0) {
      if (CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
                                      false))
        return nullptr;
    } else
      SawNonEmptyTemplateParameterList = true;
  }

  if (NeedEmptyTemplateHeader) {
    // If we're on the last of the types, and we need a 'template<>' header
    // here, then it's a member specialization.
    if (TypeIdx == NumTypes - 1)
      IsMemberSpecialization = true;

    if (ParamIdx < ParamLists.size()) {
      if (ParamLists[ParamIdx]->size() > 0) {
        // The header has template parameters when it shouldn't. Complain.
        Diag(ParamLists[ParamIdx]->getTemplateLoc(),
             diag::err_template_param_list_matches_nontemplate)
          << T
          << SourceRange(ParamLists[ParamIdx]->getLAngleLoc(),
                         ParamLists[ParamIdx]->getRAngleLoc())
          << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
        Invalid = true;
        return nullptr;
      }

      // Consume this template header.
      ++ParamIdx;
      continue;
    }

    if (!IsFriend)
      if (DiagnoseMissingExplicitSpecialization(
              getRangeOfTypeInNestedNameSpecifier(Context, T, SS)))
        return nullptr;

    continue;
  }

  if (NeedNonemptyTemplateHeader) {
    // In friend declarations we can have template-ids which don't
    // depend on the corresponding template parameter lists.  But
    // assume that empty parameter lists are supposed to match this
    // template-id.
    if (IsFriend && T->isDependentType()) {
      if (ParamIdx < ParamLists.size() &&
          DependsOnTemplateParameters(T, ParamLists[ParamIdx]))
        ExpectedTemplateParams = nullptr;
      else
        continue;
    }

    if (ParamIdx < ParamLists.size()) {
      // Check the template parameter list, if we can.
      if (ExpectedTemplateParams &&
          !TemplateParameterListsAreEqual(ParamLists[ParamIdx],
                                          ExpectedTemplateParams,
                                          true, TPL_TemplateMatch))
        Invalid = true;

      if (!Invalid &&
          CheckTemplateParameterList(ParamLists[ParamIdx], nullptr,
                                     TPC_ClassTemplateMember))
        Invalid = true;

      ++ParamIdx;
      continue;
    }

    Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
      << T
      << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
    Invalid = true;
    continue;
  }
}

// If there were at least as many template-ids as there were template
// parameter lists, then there are no template parameter lists remaining for
// the declaration itself.
if (ParamIdx >= ParamLists.size()) {
  if (TemplateId && !IsFriend) {
    // We don't have a template header for the declaration itself, but we
    // should.
    DiagnoseMissingExplicitSpecialization(SourceRange(TemplateId->LAngleLoc,
                                                      TemplateId->RAngleLoc));

    // Fabricate an empty template parameter list for the invented header.
    return TemplateParameterList::Create(Context, SourceLocation(),
                                         SourceLocation(), None,
                                         SourceLocation(), nullptr);
  }

  return nullptr;
}

// If there were too many template parameter lists, complain about that now.
if (ParamIdx < ParamLists.size() - 1) {
  bool HasAnyExplicitSpecHeader = false;
  bool AllExplicitSpecHeaders = true;
  for (unsigned I = ParamIdx, E = ParamLists.size() - 1; I != E; ++I) {
    if (ParamLists[I]->size() == 0)
      HasAnyExplicitSpecHeader = true;
    else
      AllExplicitSpecHeaders = false;
  }

  Diag(ParamLists[ParamIdx]->getTemplateLoc(),
       AllExplicitSpecHeaders ? diag::warn_template_spec_extra_headers
                              : diag::err_template_spec_extra_headers)
      << SourceRange(ParamLists[ParamIdx]->getTemplateLoc(),
                     ParamLists[ParamLists.size() - 2]->getRAngleLoc());

  // If there was a specialization somewhere, such that 'template<>' is
  // not required, and there were any 'template<>' headers, note where the
  // specialization occurred.
  if (ExplicitSpecLoc.isValid() && HasAnyExplicitSpecHeader)
    Diag(ExplicitSpecLoc,
         diag::note_explicit_template_spec_does_not_need_header)
      << NestedTypes.back();

  // We have a template parameter list with no corresponding scope, which
  // means that the resulting template declaration can't be instantiated
  // properly (we'll end up with dependent nodes when we shouldn't).
  if (!AllExplicitSpecHeaders)
    Invalid = true;
}

// C++ [temp.expl.spec]p16:
//   In an explicit specialization declaration for a member of a class
//   template or a member template that ap- pears in namespace scope, the
//   member template and some of its enclosing class templates may remain
//   unspecialized, except that the declaration shall not explicitly
//   specialize a class member template if its en- closing class templates
//   are not explicitly specialized as well.
if (ParamLists.back()->size() == 0 &&
    CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
                                false))
  return nullptr;

// Return the last template parameter list, which corresponds to the
// entity being declared.
return ParamLists.back();
2768}

2770void Sema::NoteAllFoundTemplates(TemplateName Name) {
if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
  Diag(Template->getLocation(), diag::note_template_declared_here)
      << (isa<FunctionTemplateDecl>(Template)
              ? 0
              : isa<ClassTemplateDecl>(Template)
                    ? 1
                    : isa<VarTemplateDecl>(Template)
                          ? 2
                          : isa<TypeAliasTemplateDecl>(Template) ? 3 : 4)
      << Template->getDeclName();
  return;
}

if (OverloadedTemplateStorage *OST = Name.getAsOverloadedTemplate()) {
  for (OverloadedTemplateStorage::iterator I = OST->begin(),
                                        IEnd = OST->end();
       I != IEnd; ++I)
    Diag((*I)->getLocation(), diag::note_template_declared_here)
      << 0 << (*I)->getDeclName();

  return;
}
2793}

2795static QualType
2796checkBuiltinTemplateIdType(Sema &SemaRef, BuiltinTemplateDecl *BTD,
                         const SmallVectorImpl<TemplateArgument> &Converted,
                         SourceLocation TemplateLoc,
                         TemplateArgumentListInfo &TemplateArgs) {
ASTContext &Context = SemaRef.getASTContext();
switch (BTD->getBuiltinTemplateKind()) {
case BTK__make_integer_seq: {
  // Specializations of __make_integer_seq<S, T, N> are treated like
  // S<T, 0, ..., N-1>.

  // C++14 [inteseq.intseq]p1:
  //   T shall be an integer type.
  if (!Converted[1].getAsType()->isIntegralType(Context)) {
    SemaRef.Diag(TemplateArgs[1].getLocation(),
                 diag::err_integer_sequence_integral_element_type);
    return QualType();
  }

  // C++14 [inteseq.make]p1:
  //   If N is negative the program is ill-formed.
  TemplateArgument NumArgsArg = Converted[2];
  llvm::APSInt NumArgs = NumArgsArg.getAsIntegral();
  if (NumArgs < 0) {
    SemaRef.Diag(TemplateArgs[2].getLocation(),
                 diag::err_integer_sequence_negative_length);
    return QualType();
  }

  QualType ArgTy = NumArgsArg.getIntegralType();
  TemplateArgumentListInfo SyntheticTemplateArgs;
  // The type argument gets reused as the first template argument in the
  // synthetic template argument list.
  SyntheticTemplateArgs.addArgument(TemplateArgs[1]);
  // Expand N into 0 ... N-1.
  for (llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
       I < NumArgs; ++I) {
    TemplateArgument TA(Context, I, ArgTy);
    SyntheticTemplateArgs.addArgument(SemaRef.getTrivialTemplateArgumentLoc(
        TA, ArgTy, TemplateArgs[2].getLocation()));
  }
  // The first template argument will be reused as the template decl that
  // our synthetic template arguments will be applied to.
  return SemaRef.CheckTemplateIdType(Converted[0].getAsTemplate(),
                                     TemplateLoc, SyntheticTemplateArgs);
}

case BTK__type_pack_element:
  // Specializations of
  //    __type_pack_element<Index, T_1, ..., T_N>
  // are treated like T_Index.
  assert(Converted.size() == 2 &&(static_cast <bool> (Converted.size() == 2 && "__type_pack_element should be given an index and a parameter pack"
) ? void (0) : __assert_fail ("Converted.size() == 2 && \"__type_pack_element should be given an index and a parameter pack\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2847, __extension__ __PRETTY_FUNCTION__))
    "__type_pack_element should be given an index and a parameter pack")(static_cast <bool> (Converted.size() == 2 && "__type_pack_element should be given an index and a parameter pack"
) ? void (0) : __assert_fail ("Converted.size() == 2 && \"__type_pack_element should be given an index and a parameter pack\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2847, __extension__ __PRETTY_FUNCTION__));

  // If the Index is out of bounds, the program is ill-formed.
  TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
  llvm::APSInt Index = IndexArg.getAsIntegral();
  assert(Index >= 0 && "the index used with __type_pack_element should be of "(static_cast <bool> (Index >= 0 && "the index used with __type_pack_element should be of "
 "type std::size_t, and hence be non-negative") ? void (0) : __assert_fail
 ("Index >= 0 && \"the index used with __type_pack_element should be of \" \"type std::size_t, and hence be non-negative\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2853, __extension__ __PRETTY_FUNCTION__))
                       "type std::size_t, and hence be non-negative")(static_cast <bool> (Index >= 0 && "the index used with __type_pack_element should be of "
 "type std::size_t, and hence be non-negative") ? void (0) : __assert_fail
 ("Index >= 0 && \"the index used with __type_pack_element should be of \" \"type std::size_t, and hence be non-negative\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2853, __extension__ __PRETTY_FUNCTION__));
  if (Index >= Ts.pack_size()) {
    SemaRef.Diag(TemplateArgs[0].getLocation(),
                 diag::err_type_pack_element_out_of_bounds);
    return QualType();
  }

  // We simply return the type at index `Index`.
  auto Nth = std::next(Ts.pack_begin(), Index.getExtValue());
  return Nth->getAsType();
}
llvm_unreachable("unexpected BuiltinTemplateDecl!")::llvm::llvm_unreachable_internal("unexpected BuiltinTemplateDecl!"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2864);
2865}

2867/// Determine whether this alias template is "enable_if_t".
2868static bool isEnableIfAliasTemplate(TypeAliasTemplateDecl *AliasTemplate) {
return AliasTemplate->getName().equals("enable_if_t");
2870}

2872/// Collect all of the separable terms in the given condition, which
2873/// might be a conjunction.
2874///
2875/// FIXME: The right answer is to convert the logical expression into
2876/// disjunctive normal form, so we can find the first failed term
2877/// within each possible clause.
2878static void collectConjunctionTerms(Expr *Clause,
                                  SmallVectorImpl<Expr *> &Terms) {
if (auto BinOp = dyn_cast<BinaryOperator>(Clause->IgnoreParenImpCasts())) {
  if (BinOp->getOpcode() == BO_LAnd) {
    collectConjunctionTerms(BinOp->getLHS(), Terms);
    collectConjunctionTerms(BinOp->getRHS(), Terms);
  }

  return;
}

Terms.push_back(Clause);
2890}

2892// The ranges-v3 library uses an odd pattern of a top-level "||" with
2893// a left-hand side that is value-dependent but never true. Identify
2894// the idiom and ignore that term.
2895static Expr *lookThroughRangesV3Condition(Preprocessor &PP, Expr *Cond) {
// Top-level '||'.
auto *BinOp = dyn_cast<BinaryOperator>(Cond->IgnoreParenImpCasts());
if (!BinOp) return Cond;

if (BinOp->getOpcode() != BO_LOr) return Cond;

// With an inner '==' that has a literal on the right-hand side.
Expr *LHS = BinOp->getLHS();
auto *InnerBinOp = dyn_cast<BinaryOperator>(LHS->IgnoreParenImpCasts());
if (!InnerBinOp) return Cond;

if (InnerBinOp->getOpcode() != BO_EQ ||
    !isa<IntegerLiteral>(InnerBinOp->getRHS()))
  return Cond;

// If the inner binary operation came from a macro expansion named
// CONCEPT_REQUIRES or CONCEPT_REQUIRES_, return the right-hand side
// of the '||', which is the real, user-provided condition.
SourceLocation Loc = InnerBinOp->getExprLoc();
if (!Loc.isMacroID()) return Cond;

StringRef MacroName = PP.getImmediateMacroName(Loc);
if (MacroName == "CONCEPT_REQUIRES" || MacroName == "CONCEPT_REQUIRES_")
  return BinOp->getRHS();

return Cond;
2922}

2924std::pair<Expr *, std::string>
2925Sema::findFailedBooleanCondition(Expr *Cond, bool AllowTopLevelCond) {
Cond = lookThroughRangesV3Condition(PP, Cond);

// Separate out all of the terms in a conjunction.
SmallVector<Expr *, 4> Terms;
collectConjunctionTerms(Cond, Terms);

// Determine which term failed.
Expr *FailedCond = nullptr;
for (Expr *Term : Terms) {
  Expr *TermAsWritten = Term->IgnoreParenImpCasts();

  // Literals are uninteresting.
  if (isa<CXXBoolLiteralExpr>(TermAsWritten) ||
      isa<IntegerLiteral>(TermAsWritten))
    continue;

  // The initialization of the parameter from the argument is
  // a constant-evaluated context.
  EnterExpressionEvaluationContext ConstantEvaluated(
    *this, Sema::ExpressionEvaluationContext::ConstantEvaluated);

  bool Succeeded;
  if (Term->EvaluateAsBooleanCondition(Succeeded, Context) &&
      !Succeeded) {
    FailedCond = TermAsWritten;
    break;
  }
}

if (!FailedCond) {
  if (!AllowTopLevelCond)
    return { nullptr, "" };

  FailedCond = Cond->IgnoreParenImpCasts();
}

std::string Description;
{
  llvm::raw_string_ostream Out(Description);
  FailedCond->printPretty(Out, nullptr, getPrintingPolicy());
}
return { FailedCond, Description };
2968}

2970QualType Sema::CheckTemplateIdType(TemplateName Name,
                                 SourceLocation TemplateLoc,
                                 TemplateArgumentListInfo &TemplateArgs) {
DependentTemplateName *DTN
  = Name.getUnderlying().getAsDependentTemplateName();
if (DTN && DTN->isIdentifier())
  // When building a template-id where the template-name is dependent,
  // assume the template is a type template. Either our assumption is
  // correct, or the code is ill-formed and will be diagnosed when the
  // dependent name is substituted.
  return Context.getDependentTemplateSpecializationType(ETK_None,
                                                        DTN->getQualifier(),
                                                        DTN->getIdentifier(),
                                                        TemplateArgs);

TemplateDecl *Template = Name.getAsTemplateDecl();
if (!Template || isa<FunctionTemplateDecl>(Template) ||
    isa<VarTemplateDecl>(Template)) {
  // We might have a substituted template template parameter pack. If so,
  // build a template specialization type for it.
  if (Name.getAsSubstTemplateTemplateParmPack())
    return Context.getTemplateSpecializationType(Name, TemplateArgs);

  Diag(TemplateLoc, diag::err_template_id_not_a_type)
    << Name;
  NoteAllFoundTemplates(Name);
  return QualType();
}

// Check that the template argument list is well-formed for this
// template.
SmallVector<TemplateArgument, 4> Converted;
if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs,
                              false, Converted))
  return QualType();

QualType CanonType;

bool InstantiationDependent = false;
if (TypeAliasTemplateDecl *AliasTemplate =
        dyn_cast<TypeAliasTemplateDecl>(Template)) {
  // Find the canonical type for this type alias template specialization.
  TypeAliasDecl *Pattern = AliasTemplate->getTemplatedDecl();
  if (Pattern->isInvalidDecl())
    return QualType();

  TemplateArgumentList StackTemplateArgs(TemplateArgumentList::OnStack,
                                         Converted);

  // Only substitute for the innermost template argument list.
  MultiLevelTemplateArgumentList TemplateArgLists;
  TemplateArgLists.addOuterTemplateArguments(&StackTemplateArgs);
  unsigned Depth = AliasTemplate->getTemplateParameters()->getDepth();
  for (unsigned I = 0; I < Depth; ++I)
    TemplateArgLists.addOuterTemplateArguments(None);

  LocalInstantiationScope Scope(*this);
  InstantiatingTemplate Inst(*this, TemplateLoc, Template);
  if (Inst.isInvalid())
    return QualType();

  CanonType = SubstType(Pattern->getUnderlyingType(),
                        TemplateArgLists, AliasTemplate->getLocation(),
                        AliasTemplate->getDeclName());
  if (CanonType.isNull()) {
    // If this was enable_if and we failed to find the nested type
    // within enable_if in a SFINAE context, dig out the specific
    // enable_if condition that failed and present that instead.
    if (isEnableIfAliasTemplate(AliasTemplate)) {
      if (auto DeductionInfo = isSFINAEContext()) {
        if (*DeductionInfo &&
            (*DeductionInfo)->hasSFINAEDiagnostic() &&
            (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() ==
              diag::err_typename_nested_not_found_enable_if &&
            TemplateArgs[0].getArgument().getKind()
              == TemplateArgument::Expression) {
          Expr *FailedCond;
          std::string FailedDescription;
          std::tie(FailedCond, FailedDescription) =
            findFailedBooleanCondition(
              TemplateArgs[0].getSourceExpression(),
              /*AllowTopLevelCond=*/true);

          // Remove the old SFINAE diagnostic.
          PartialDiagnosticAt OldDiag =
            {SourceLocation(), PartialDiagnostic::NullDiagnostic()};
          (*DeductionInfo)->takeSFINAEDiagnostic(OldDiag);

          // Add a new SFINAE diagnostic specifying which condition
          // failed.
          (*DeductionInfo)->addSFINAEDiagnostic(
            OldDiag.first,
            PDiag(diag::err_typename_nested_not_found_requirement)
              << FailedDescription
              << FailedCond->getSourceRange());
        }
      }
    }

    return QualType();
  }
} else if (Name.isDependent() ||
           TemplateSpecializationType::anyDependentTemplateArguments(
             TemplateArgs, InstantiationDependent)) {
  // This class template specialization is a dependent
  // type. Therefore, its canonical type is another class template
  // specialization type that contains all of the converted
  // arguments in canonical form. This ensures that, e.g., A<T> and
  // A<T, T> have identical types when A is declared as:
  //
  //   template<typename T, typename U = T> struct A;
  CanonType = Context.getCanonicalTemplateSpecializationType(Name, Converted);

  // This might work out to be a current instantiation, in which
  // case the canonical type needs to be the InjectedClassNameType.
  //
  // TODO: in theory this could be a simple hashtable lookup; most
  // changes to CurContext don't change the set of current
  // instantiations.
  if (isa<ClassTemplateDecl>(Template)) {
    for (DeclContext *Ctx = CurContext; Ctx; Ctx = Ctx->getLookupParent()) {
      // If we get out to a namespace, we're done.
      if (Ctx->isFileContext()) break;

      // If this isn't a record, keep looking.
      CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx);
      if (!Record) continue;

      // Look for one of the two cases with InjectedClassNameTypes
      // and check whether it's the same template.
      if (!isa<ClassTemplatePartialSpecializationDecl>(Record) &&
          !Record->getDescribedClassTemplate())
        continue;

      // Fetch the injected class name type and check whether its
      // injected type is equal to the type we just built.
      QualType ICNT = Context.getTypeDeclType(Record);
      QualType Injected = cast<InjectedClassNameType>(ICNT)
        ->getInjectedSpecializationType();

      if (CanonType != Injected->getCanonicalTypeInternal())
        continue;

      // If so, the canonical type of this TST is the injected
      // class name type of the record we just found.
      assert(ICNT.isCanonical())(static_cast <bool> (ICNT.isCanonical()) ? void (0) : __assert_fail
 ("ICNT.isCanonical()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3115, __extension__ __PRETTY_FUNCTION__));
      CanonType = ICNT;
      break;
    }
  }
} else if (ClassTemplateDecl *ClassTemplate
             = dyn_cast<ClassTemplateDecl>(Template)) {
  // Find the class template specialization declaration that
  // corresponds to these arguments.
  void *InsertPos = nullptr;
  ClassTemplateSpecializationDecl *Decl
    = ClassTemplate->findSpecialization(Converted, InsertPos);
  if (!Decl) {
    // This is the first time we have referenced this class template
    // specialization. Create the canonical declaration and add it to
    // the set of specializations.
    Decl = ClassTemplateSpecializationDecl::Create(Context,
                          ClassTemplate->getTemplatedDecl()->getTagKind(),
                                              ClassTemplate->getDeclContext(),
                          ClassTemplate->getTemplatedDecl()->getLocStart(),
                                              ClassTemplate->getLocation(),
                                                   ClassTemplate,
                                                   Converted, nullptr);
    ClassTemplate->AddSpecialization(Decl, InsertPos);
    if (ClassTemplate->isOutOfLine())
      Decl->setLexicalDeclContext(ClassTemplate->getLexicalDeclContext());
  }

  if (Decl->getSpecializationKind() == TSK_Undeclared) {
    MultiLevelTemplateArgumentList TemplateArgLists;
    TemplateArgLists.addOuterTemplateArguments(Converted);
    InstantiateAttrsForDecl(TemplateArgLists, ClassTemplate->getTemplatedDecl(),
                            Decl);
  }

  // Diagnose uses of this specialization.
  (void)DiagnoseUseOfDecl(Decl, TemplateLoc);

  CanonType = Context.getTypeDeclType(Decl);
  assert(isa<RecordType>(CanonType) &&(static_cast <bool> (isa<RecordType>(CanonType) &&
 "type of non-dependent specialization is not a RecordType") ?
 void (0) : __assert_fail ("isa<RecordType>(CanonType) && \"type of non-dependent specialization is not a RecordType\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3155, __extension__ __PRETTY_FUNCTION__))
         "type of non-dependent specialization is not a RecordType")(static_cast <bool> (isa<RecordType>(CanonType) &&
 "type of non-dependent specialization is not a RecordType") ?
 void (0) : __assert_fail ("isa<RecordType>(CanonType) && \"type of non-dependent specialization is not a RecordType\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3155, __extension__ __PRETTY_FUNCTION__));
} else if (auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
  CanonType = checkBuiltinTemplateIdType(*this, BTD, Converted, TemplateLoc,
                                         TemplateArgs);
}

// Build the fully-sugared type for this class template
// specialization, which refers back to the class template
// specialization we created or found.
return Context.getTemplateSpecializationType(Name, TemplateArgs, CanonType);
3165}

3167TypeResult
3168Sema::ActOnTemplateIdType(CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
                        TemplateTy TemplateD, IdentifierInfo *TemplateII,
                        SourceLocation TemplateIILoc,
                        SourceLocation LAngleLoc,
                        ASTTemplateArgsPtr TemplateArgsIn,
                        SourceLocation RAngleLoc,
                        bool IsCtorOrDtorName, bool IsClassName) {
if (SS.isInvalid())
  return true;

if (!IsCtorOrDtorName && !IsClassName && SS.isSet()) {
  DeclContext *LookupCtx = computeDeclContext(SS, /*EnteringContext*/false);

  // C++ [temp.res]p3:
  //   A qualified-id that refers to a type and in which the
  //   nested-name-specifier depends on a template-parameter (14.6.2)
  //   shall be prefixed by the keyword typename to indicate that the
  //   qualified-id denotes a type, forming an
  //   elaborated-type-specifier (7.1.5.3).
  if (!LookupCtx && isDependentScopeSpecifier(SS)) {
    Diag(SS.getBeginLoc(), diag::err_typename_missing_template)
      << SS.getScopeRep() << TemplateII->getName();
    // Recover as if 'typename' were specified.
    // FIXME: This is not quite correct recovery as we don't transform SS
    // into the corresponding dependent form (and we don't diagnose missing
    // 'template' keywords within SS as a result).
    return ActOnTypenameType(nullptr, SourceLocation(), SS, TemplateKWLoc,
                             TemplateD, TemplateII, TemplateIILoc, LAngleLoc,
                             TemplateArgsIn, RAngleLoc);
  }

  // Per C++ [class.qual]p2, if the template-id was an injected-class-name,
  // it's not actually allowed to be used as a type in most cases. Because
  // we annotate it before we know whether it's valid, we have to check for
  // this case here.
  auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
  if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
    Diag(TemplateIILoc,
         TemplateKWLoc.isInvalid()
             ? diag::err_out_of_line_qualified_id_type_names_constructor
             : diag::ext_out_of_line_qualified_id_type_names_constructor)
      << TemplateII << 0 /*injected-class-name used as template name*/
      << 1 /*if any keyword was present, it was 'template'*/;
  }
}

TemplateName Template = TemplateD.get();

// Translate the parser's template argument list in our AST format.
TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
translateTemplateArguments(TemplateArgsIn, TemplateArgs);

if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
  QualType T
    = Context.getDependentTemplateSpecializationType(ETK_None,
                                                     DTN->getQualifier(),
                                                     DTN->getIdentifier(),
                                                     TemplateArgs);
  // Build type-source information.
  TypeLocBuilder TLB;
  DependentTemplateSpecializationTypeLoc SpecTL
    = TLB.push<DependentTemplateSpecializationTypeLoc>(T);
  SpecTL.setElaboratedKeywordLoc(SourceLocation());
  SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
  SpecTL.setTemplateNameLoc(TemplateIILoc);
  SpecTL.setLAngleLoc(LAngleLoc);
  SpecTL.setRAngleLoc(RAngleLoc);
  for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
    SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
  return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
}

QualType Result = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
if (Result.isNull())
  return true;

// Build type-source information.
TypeLocBuilder TLB;
TemplateSpecializationTypeLoc SpecTL
  = TLB.push<TemplateSpecializationTypeLoc>(Result);
SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
SpecTL.setTemplateNameLoc(TemplateIILoc);
SpecTL.setLAngleLoc(LAngleLoc);
SpecTL.setRAngleLoc(RAngleLoc);
for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
  SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());

// NOTE: avoid constructing an ElaboratedTypeLoc if this is a
// constructor or destructor name (in such a case, the scope specifier
// will be attached to the enclosing Decl or Expr node).
if (SS.isNotEmpty() && !IsCtorOrDtorName) {
  // Create an elaborated-type-specifier containing the nested-name-specifier.
  Result = Context.getElaboratedType(ETK_None, SS.getScopeRep(), Result);
  ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
  ElabTL.setElaboratedKeywordLoc(SourceLocation());
  ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
}

return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
3268}

3270TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK,
                                      TypeSpecifierType TagSpec,
                                      SourceLocation TagLoc,
                                      CXXScopeSpec &SS,
                                      SourceLocation TemplateKWLoc,
                                      TemplateTy TemplateD,
                                      SourceLocation TemplateLoc,
                                      SourceLocation LAngleLoc,
                                      ASTTemplateArgsPtr TemplateArgsIn,
                                      SourceLocation RAngleLoc) {
TemplateName Template = TemplateD.get();

// Translate the parser's template argument list in our AST format.
TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
translateTemplateArguments(TemplateArgsIn, TemplateArgs);

// Determine the tag kind
TagTypeKind TagKind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
ElaboratedTypeKeyword Keyword
  = TypeWithKeyword::getKeywordForTagTypeKind(TagKind);

if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
  QualType T = Context.getDependentTemplateSpecializationType(Keyword,
                                                        DTN->getQualifier(),
                                                        DTN->getIdentifier(),
                                                              TemplateArgs);

  // Build type-source information.
  TypeLocBuilder TLB;
  DependentTemplateSpecializationTypeLoc SpecTL
    = TLB.push<DependentTemplateSpecializationTypeLoc>(T);
  SpecTL.setElaboratedKeywordLoc(TagLoc);
  SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
  SpecTL.setTemplateNameLoc(TemplateLoc);
  SpecTL.setLAngleLoc(LAngleLoc);
  SpecTL.setRAngleLoc(RAngleLoc);
  for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
    SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
  return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
}

if (TypeAliasTemplateDecl *TAT =
      dyn_cast_or_null<TypeAliasTemplateDecl>(Template.getAsTemplateDecl())) {
  // C++0x [dcl.type.elab]p2:
  //   If the identifier resolves to a typedef-name or the simple-template-id
  //   resolves to an alias template specialization, the
  //   elaborated-type-specifier is ill-formed.
  Diag(TemplateLoc, diag::err_tag_reference_non_tag)
      << TAT << NTK_TypeAliasTemplate << TagKind;
  Diag(TAT->getLocation(), diag::note_declared_at);
}

QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
if (Result.isNull())
  return TypeResult(true);

// Check the tag kind
if (const RecordType *RT = Result->getAs<RecordType>()) {
  RecordDecl *D = RT->getDecl();

  IdentifierInfo *Id = D->getIdentifier();
  assert(Id && "templated class must have an identifier")(static_cast <bool> (Id && "templated class must have an identifier"
) ? void (0) : __assert_fail ("Id && \"templated class must have an identifier\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3332, __extension__ __PRETTY_FUNCTION__));

  if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition,
                                    TagLoc, Id)) {
    Diag(TagLoc, diag::err_use_with_wrong_tag)
      << Result
      << FixItHint::CreateReplacement(SourceRange(TagLoc), D->getKindName());
    Diag(D->getLocation(), diag::note_previous_use);
  }
}

// Provide source-location information for the template specialization.
TypeLocBuilder TLB;
TemplateSpecializationTypeLoc SpecTL
  = TLB.push<TemplateSpecializationTypeLoc>(Result);
SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
SpecTL.setTemplateNameLoc(TemplateLoc);
SpecTL.setLAngleLoc(LAngleLoc);
SpecTL.setRAngleLoc(RAngleLoc);
for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
  SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());

// Construct an elaborated type containing the nested-name-specifier (if any)
// and tag keyword.
Result = Context.getElaboratedType(Keyword, SS.getScopeRep(), Result);
ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
ElabTL.setElaboratedKeywordLoc(TagLoc);
ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
3361}

3363static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized,
                                           NamedDecl *PrevDecl,
                                           SourceLocation Loc,
                                           bool IsPartialSpecialization);

3368static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D);

3370static bool isTemplateArgumentTemplateParameter(
  const TemplateArgument &Arg, unsigned Depth, unsigned Index) {
switch (Arg.getKind()) {
case TemplateArgument::Null:
case TemplateArgument::NullPtr:
case TemplateArgument::Integral:
case TemplateArgument::Declaration:
case TemplateArgument::Pack:
case TemplateArgument::TemplateExpansion:
  return false;

case TemplateArgument::Type: {
  QualType Type = Arg.getAsType();
  const TemplateTypeParmType *TPT =
      Arg.getAsType()->getAs<TemplateTypeParmType>();
  return TPT && !Type.hasQualifiers() &&
         TPT->getDepth() == Depth && TPT->getIndex() == Index;
}

case TemplateArgument::Expression: {
  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg.getAsExpr());
  if (!DRE || !DRE->getDecl())
    return false;
  const NonTypeTemplateParmDecl *NTTP =
      dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
  return NTTP && NTTP->getDepth() == Depth && NTTP->getIndex() == Index;
}

case TemplateArgument::Template:
  const TemplateTemplateParmDecl *TTP =
      dyn_cast_or_null<TemplateTemplateParmDecl>(
          Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl());
  return TTP && TTP->getDepth() == Depth && TTP->getIndex() == Index;
}
llvm_unreachable("unexpected kind of template argument")::llvm::llvm_unreachable_internal("unexpected kind of template argument"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3404);
3405}

3407static bool isSameAsPrimaryTemplate(TemplateParameterList *Params,
                                  ArrayRef<TemplateArgument> Args) {
if (Params->size() != Args.size())
  return false;

unsigned Depth = Params->getDepth();

for (unsigned I = 0, N = Args.size(); I != N; ++I) {
  TemplateArgument Arg = Args[I];

  // If the parameter is a pack expansion, the argument must be a pack
  // whose only element is a pack expansion.
  if (Params->getParam(I)->isParameterPack()) {
    if (Arg.getKind() != TemplateArgument::Pack || Arg.pack_size() != 1 ||
        !Arg.pack_begin()->isPackExpansion())
      return false;
    Arg = Arg.pack_begin()->getPackExpansionPattern();
  }

  if (!isTemplateArgumentTemplateParameter(Arg, Depth, I))
    return false;
}

return true;
3431}

3433/// Convert the parser's template argument list representation into our form.
3434static TemplateArgumentListInfo
3435makeTemplateArgumentListInfo(Sema &S, TemplateIdAnnotation &TemplateId) {
TemplateArgumentListInfo TemplateArgs(TemplateId.LAngleLoc,
                                      TemplateId.RAngleLoc);
ASTTemplateArgsPtr TemplateArgsPtr(TemplateId.getTemplateArgs(),
                                   TemplateId.NumArgs);
S.translateTemplateArguments(TemplateArgsPtr, TemplateArgs);
return TemplateArgs;
3442}

3444template<typename PartialSpecDecl>
3445static void checkMoreSpecializedThanPrimary(Sema &S, PartialSpecDecl *Partial) {
if (Partial->getDeclContext()->isDependentContext())
  return;

// FIXME: Get the TDK from deduction in order to provide better diagnostics
// for non-substitution-failure issues?
TemplateDeductionInfo Info(Partial->getLocation());
if (S.isMoreSpecializedThanPrimary(Partial, Info))
  return;

auto *Template = Partial->getSpecializedTemplate();
S.Diag(Partial->getLocation(),
       diag::ext_partial_spec_not_more_specialized_than_primary)
    << isa<VarTemplateDecl>(Template);

if (Info.hasSFINAEDiagnostic()) {
  PartialDiagnosticAt Diag = {SourceLocation(),
                              PartialDiagnostic::NullDiagnostic()};
  Info.takeSFINAEDiagnostic(Diag);
  SmallString<128> SFINAEArgString;
  Diag.second.EmitToString(S.getDiagnostics(), SFINAEArgString);
  S.Diag(Diag.first,
         diag::note_partial_spec_not_more_specialized_than_primary)
    << SFINAEArgString;
}

S.Diag(Template->getLocation(), diag::note_template_decl_here);
3472}

3474static void
3475noteNonDeducibleParameters(Sema &S, TemplateParameterList *TemplateParams,
                         const llvm::SmallBitVector &DeducibleParams) {
for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
  if (!DeducibleParams[I]) {
    NamedDecl *Param = cast<NamedDecl>(TemplateParams->getParam(I));
    if (Param->getDeclName())
      S.Diag(Param->getLocation(), diag::note_non_deducible_parameter)
          << Param->getDeclName();
    else
      S.Diag(Param->getLocation(), diag::note_non_deducible_parameter)
          << "(anonymous)";
  }
}
3488}


3491template<typename PartialSpecDecl>
3492static void checkTemplatePartialSpecialization(Sema &S,
                                             PartialSpecDecl *Partial) {
// C++1z [temp.class.spec]p8: (DR1495)
//   - The specialization shall be more specialized than the primary
//     template (14.5.5.2).
checkMoreSpecializedThanPrimary(S, Partial);

// C++ [temp.class.spec]p8: (DR1315)
//   - Each template-parameter shall appear at least once in the
//     template-id outside a non-deduced context.
// C++1z [temp.class.spec.match]p3 (P0127R2)
//   If the template arguments of a partial specialization cannot be
//   deduced because of the structure of its template-parameter-list
//   and the template-id, the program is ill-formed.
auto *TemplateParams = Partial->getTemplateParameters();
llvm::SmallBitVector DeducibleParams(TemplateParams->size());
S.MarkUsedTemplateParameters(Partial->getTemplateArgs(), true,
                             TemplateParams->getDepth(), DeducibleParams);

if (!DeducibleParams.all()) {
  unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
  S.Diag(Partial->getLocation(), diag::ext_partial_specs_not_deducible)
    << isa<VarTemplatePartialSpecializationDecl>(Partial)
    << (NumNonDeducible > 1)
    << SourceRange(Partial->getLocation(),
                   Partial->getTemplateArgsAsWritten()->RAngleLoc);
  noteNonDeducibleParameters(S, TemplateParams, DeducibleParams);
}
3520}

3522void Sema::CheckTemplatePartialSpecialization(
  ClassTemplatePartialSpecializationDecl *Partial) {
checkTemplatePartialSpecialization(*this, Partial);
3525}

3527void Sema::CheckTemplatePartialSpecialization(
  VarTemplatePartialSpecializationDecl *Partial) {
checkTemplatePartialSpecialization(*this, Partial);
3530}

3532void Sema::CheckDeductionGuideTemplate(FunctionTemplateDecl *TD) {
// C++1z [temp.param]p11:
//   A template parameter of a deduction guide template that does not have a
//   default-argument shall be deducible from the parameter-type-list of the
//   deduction guide template.
auto *TemplateParams = TD->getTemplateParameters();
llvm::SmallBitVector DeducibleParams(TemplateParams->size());
MarkDeducedTemplateParameters(TD, DeducibleParams);
for (unsigned I = 0; I != TemplateParams->size(); ++I) {
  // A parameter pack is deducible (to an empty pack).
  auto *Param = TemplateParams->getParam(I);
  if (Param->isParameterPack() || hasVisibleDefaultArgument(Param))
    DeducibleParams[I] = true;
}

if (!DeducibleParams.all()) {
  unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
  Diag(TD->getLocation(), diag::err_deduction_guide_template_not_deducible)
    << (NumNonDeducible > 1);
  noteNonDeducibleParameters(*this, TemplateParams, DeducibleParams);
}
3553}

3555DeclResult Sema::ActOnVarTemplateSpecialization(
  Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc,
  TemplateParameterList *TemplateParams, StorageClass SC,
  bool IsPartialSpecialization) {
// D must be variable template id.
assert(D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId &&(static_cast <bool> (D.getName().getKind() == UnqualifiedIdKind
::IK_TemplateId && "Variable template specialization is declared with a template it."
) ? void (0) : __assert_fail ("D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId && \"Variable template specialization is declared with a template it.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3561, __extension__ __PRETTY_FUNCTION__))
       "Variable template specialization is declared with a template it.")(static_cast <bool> (D.getName().getKind() == UnqualifiedIdKind
::IK_TemplateId && "Variable template specialization is declared with a template it."
) ? void (0) : __assert_fail ("D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId && \"Variable template specialization is declared with a template it.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3561, __extension__ __PRETTY_FUNCTION__));

TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
TemplateArgumentListInfo TemplateArgs =
    makeTemplateArgumentListInfo(*this, *TemplateId);
SourceLocation TemplateNameLoc = D.getIdentifierLoc();
SourceLocation LAngleLoc = TemplateId->LAngleLoc;
SourceLocation RAngleLoc = TemplateId->RAngleLoc;

TemplateName Name = TemplateId->Template.get();

// The template-id must name a variable template.
VarTemplateDecl *VarTemplate =
    dyn_cast_or_null<VarTemplateDecl>(Name.getAsTemplateDecl());
if (!VarTemplate) {
  NamedDecl *FnTemplate;
  if (auto *OTS = Name.getAsOverloadedTemplate())
    FnTemplate = *OTS->begin();
  else
    FnTemplate = dyn_cast_or_null<FunctionTemplateDecl>(Name.getAsTemplateDecl());
  if (FnTemplate)
    return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template_but_method)
             << FnTemplate->getDeclName();
  return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template)
           << IsPartialSpecialization;
}

// Check for unexpanded parameter packs in any of the template arguments.
for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
  if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
                                      UPPC_PartialSpecialization))
    return true;

// Check that the template argument list is well-formed for this
// template.
SmallVector<TemplateArgument, 4> Converted;
if (CheckTemplateArgumentList(VarTemplate, TemplateNameLoc, TemplateArgs,
                              false, Converted))
  return true;

// Find the variable template (partial) specialization declaration that
// corresponds to these arguments.
if (IsPartialSpecialization) {
  if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, VarTemplate,
                                             TemplateArgs.size(), Converted))
    return true;

  // FIXME: Move these checks to CheckTemplatePartialSpecializationArgs so we
  // also do them during instantiation.
  bool InstantiationDependent;
  if (!Name.isDependent() &&
      !TemplateSpecializationType::anyDependentTemplateArguments(
          TemplateArgs.arguments(),
          InstantiationDependent)) {
    Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
        << VarTemplate->getDeclName();
    IsPartialSpecialization = false;
  }

  if (isSameAsPrimaryTemplate(VarTemplate->getTemplateParameters(),
                              Converted)) {
    // C++ [temp.class.spec]p9b3:
    //
    //   -- The argument list of the specialization shall not be identical
    //      to the implicit argument list of the primary template.
    Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
      << /*variable template*/ 1
      << /*is definition*/(SC != SC_Extern && !CurContext->isRecord())
      << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
    // FIXME: Recover from this by treating the declaration as a redeclaration
    // of the primary template.
    return true;
  }
}

void *InsertPos = nullptr;
VarTemplateSpecializationDecl *PrevDecl = nullptr;

if (IsPartialSpecialization)
  // FIXME: Template parameter list matters too
  PrevDecl = VarTemplate->findPartialSpecialization(Converted, InsertPos);
else
  PrevDecl = VarTemplate->findSpecialization(Converted, InsertPos);

VarTemplateSpecializationDecl *Specialization = nullptr;

// Check whether we can declare a variable template specialization in
// the current scope.
if (CheckTemplateSpecializationScope(*this, VarTemplate, PrevDecl,
                                     TemplateNameLoc,
                                     IsPartialSpecialization))
  return true;

if (PrevDecl && PrevDecl->getSpecializationKind() == TSK_Undeclared) {
  // Since the only prior variable template specialization with these
  // arguments was referenced but not declared,  reuse that
  // declaration node as our own, updating its source location and
  // the list of outer template parameters to reflect our new declaration.
  Specialization = PrevDecl;
  Specialization->setLocation(TemplateNameLoc);
  PrevDecl = nullptr;
} else if (IsPartialSpecialization) {
  // Create a new class template partial specialization declaration node.
  VarTemplatePartialSpecializationDecl *PrevPartial =
      cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
  VarTemplatePartialSpecializationDecl *Partial =
      VarTemplatePartialSpecializationDecl::Create(
          Context, VarTemplate->getDeclContext(), TemplateKWLoc,
          TemplateNameLoc, TemplateParams, VarTemplate, DI->getType(), DI, SC,
          Converted, TemplateArgs);

  if (!PrevPartial)
    VarTemplate->AddPartialSpecialization(Partial, InsertPos);
  Specialization = Partial;

  // If we are providing an explicit specialization of a member variable
  // template specialization, make a note of that.
  if (PrevPartial && PrevPartial->getInstantiatedFromMember())
    PrevPartial->setMemberSpecialization();

  CheckTemplatePartialSpecialization(Partial);
} else {
  // Create a new class template specialization declaration node for
  // this explicit specialization or friend declaration.
  Specialization = VarTemplateSpecializationDecl::Create(
      Context, VarTemplate->getDeclContext(), TemplateKWLoc, TemplateNameLoc,
      VarTemplate, DI->getType(), DI, SC, Converted);
  Specialization->setTemplateArgsInfo(TemplateArgs);

  if (!PrevDecl)
    VarTemplate->AddSpecialization(Specialization, InsertPos);
}

// C++ [temp.expl.spec]p6:
//   If a template, a member template or the member of a class template is
//   explicitly specialized then that specialization shall be declared
//   before the first use of that specialization that would cause an implicit
//   instantiation to take place, in every translation unit in which such a
//   use occurs; no diagnostic is required.
if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
  bool Okay = false;
  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
    // Is there any previous explicit specialization declaration?
    if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
      Okay = true;
      break;
    }
  }

  if (!Okay) {
    SourceRange Range(TemplateNameLoc, RAngleLoc);
    Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
        << Name << Range;

    Diag(PrevDecl->getPointOfInstantiation(),
         diag::note_instantiation_required_here)
        << (PrevDecl->getTemplateSpecializationKind() !=
            TSK_ImplicitInstantiation);
    return true;
  }
}

Specialization->setTemplateKeywordLoc(TemplateKWLoc);
Specialization->setLexicalDeclContext(CurContext);

// Add the specialization into its lexical context, so that it can
// be seen when iterating through the list of declarations in that
// context. However, specializations are not found by name lookup.
CurContext->addDecl(Specialization);

// Note that this is an explicit specialization.
Specialization->setSpecializationKind(TSK_ExplicitSpecialization);

if (PrevDecl) {
  // Check that this isn't a redefinition of this specialization,
  // merging with previous declarations.
  LookupResult PrevSpec(*this, GetNameForDeclarator(D), LookupOrdinaryName,
                        forRedeclarationInCurContext());
  PrevSpec.addDecl(PrevDecl);
  D.setRedeclaration(CheckVariableDeclaration(Specialization, PrevSpec));
} else if (Specialization->isStaticDataMember() &&
           Specialization->isOutOfLine()) {
  Specialization->setAccess(VarTemplate->getAccess());
}

// Link instantiations of static data members back to the template from
// which they were instantiated.
if (Specialization->isStaticDataMember())
  Specialization->setInstantiationOfStaticDataMember(
      VarTemplate->getTemplatedDecl(),
      Specialization->getSpecializationKind());

return Specialization;
3754}

3756namespace {
3757/// \brief A partial specialization whose template arguments have matched
3758/// a given template-id.
3759struct PartialSpecMatchResult {
VarTemplatePartialSpecializationDecl *Partial;
TemplateArgumentList *Args;
3762};
3763} // end anonymous namespace

3765DeclResult
3766Sema::CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc,
                       SourceLocation TemplateNameLoc,
                       const TemplateArgumentListInfo &TemplateArgs) {
assert(Template && "A variable template id without template?")(static_cast <bool> (Template && "A variable template id without template?"
) ? void (0) : __assert_fail ("Template && \"A variable template id without template?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3769, __extension__ __PRETTY_FUNCTION__));

// Check that the template argument list is well-formed for this template.
SmallVector<TemplateArgument, 4> Converted;
if (CheckTemplateArgumentList(
        Template, TemplateNameLoc,
        const_cast<TemplateArgumentListInfo &>(TemplateArgs), false,
        Converted))
  return true;

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

// This is the first time we have referenced this variable template
// specialization. Create the canonical declaration and add it to
// the set of specializations, based on the closest partial specialization
// that it represents. That is,
VarDecl *InstantiationPattern = Template->getTemplatedDecl();
TemplateArgumentList TemplateArgList(TemplateArgumentList::OnStack,
                                     Converted);
TemplateArgumentList *InstantiationArgs = &TemplateArgList;
bool AmbiguousPartialSpec = false;
typedef PartialSpecMatchResult MatchResult;
SmallVector<MatchResult, 4> Matched;
SourceLocation PointOfInstantiation = TemplateNameLoc;
TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation,
                                          /*ForTakingAddress=*/false);

// 1. Attempt to find the closest partial specialization that this
// specializes, if any.
// If any of the template arguments is dependent, then this is probably
// a placeholder for an incomplete declarative context; which must be
// complete by instantiation time. Thus, do not search through the partial
// specializations yet.
// TODO: Unify with InstantiateClassTemplateSpecialization()?
//       Perhaps better after unification of DeduceTemplateArguments() and
//       getMoreSpecializedPartialSpecialization().
bool InstantiationDependent = false;
if (!TemplateSpecializationType::anyDependentTemplateArguments(
        TemplateArgs, InstantiationDependent)) {

  SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
  Template->getPartialSpecializations(PartialSpecs);

  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
    VarTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
    TemplateDeductionInfo Info(FailedCandidates.getLocation());

    if (TemplateDeductionResult Result =
            DeduceTemplateArguments(Partial, TemplateArgList, 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(Context, Result, Info));
      (void)Result;
    } else {
      Matched.push_back(PartialSpecMatchResult());
      Matched.back().Partial = Partial;
      Matched.back().Args = Info.take();
    }
  }

  if (Matched.size() >= 1) {
    SmallVector<MatchResult, 4>::iterator Best = Matched.begin();
    if (Matched.size() == 1) {
      //   -- 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 variable template is
      //      ambiguous and the program is ill-formed.
      for (SmallVector<MatchResult, 4>::iterator P = Best + 1,
                                                 PEnd = Matched.end();
           P != PEnd; ++P) {
        if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
                                                    PointOfInstantiation) ==
            P->Partial)
          Best = P;
      }

      // Determine if the best partial specialization is more specialized than
      // the others.
      for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
                                                 PEnd = Matched.end();
           P != PEnd; ++P) {
        if (P != Best && getMoreSpecializedPartialSpecialization(
                             P->Partial, Best->Partial,
                             PointOfInstantiation) != Best->Partial) {
          AmbiguousPartialSpec = true;
          break;
        }
      }
    }

    // Instantiate using the best variable template partial specialization.
    InstantiationPattern = Best->Partial;
    InstantiationArgs = Best->Args;
  } else {
    //   -- If no match is found, the instantiation is generated
    //      from the primary template.
    // InstantiationPattern = Template->getTemplatedDecl();
  }
}

// 2. Create the canonical declaration.
// Note that we do not instantiate a definition until we see an odr-use
// in DoMarkVarDeclReferenced().
// FIXME: LateAttrs et al.?
VarTemplateSpecializationDecl *Decl = BuildVarTemplateInstantiation(
    Template, InstantiationPattern, *InstantiationArgs, TemplateArgs,
    Converted, TemplateNameLoc, InsertPos /*, LateAttrs, StartingScope*/);
if (!Decl)
  return true;

if (AmbiguousPartialSpec) {
  // Partial ordering did not produce a clear winner. Complain.
  Decl->setInvalidDecl();
  Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
      << Decl;

  // Print the matching partial specializations.
  for (MatchResult P : Matched)
    Diag(P.Partial->getLocation(), diag::note_partial_spec_match)
        << getTemplateArgumentBindingsText(P.Partial->getTemplateParameters(),
                                           *P.Args);
  return true;
}

if (VarTemplatePartialSpecializationDecl *D =
        dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))
  Decl->setInstantiationOf(D, InstantiationArgs);

checkSpecializationVisibility(TemplateNameLoc, Decl);

assert(Decl && "No variable template specialization?")(static_cast <bool> (Decl && "No variable template specialization?"
) ? void (0) : __assert_fail ("Decl && \"No variable template specialization?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3916, __extension__ __PRETTY_FUNCTION__));
return Decl;
3918}

3920ExprResult
3921Sema::CheckVarTemplateId(const CXXScopeSpec &SS,
                       const DeclarationNameInfo &NameInfo,
                       VarTemplateDecl *Template, SourceLocation TemplateLoc,
                       const TemplateArgumentListInfo *TemplateArgs) {

DeclResult Decl = CheckVarTemplateId(Template, TemplateLoc, NameInfo.getLoc(),
                                     *TemplateArgs);
if (Decl.isInvalid())
  return ExprError();

VarDecl *Var = cast<VarDecl>(Decl.get());
if (!Var->getTemplateSpecializationKind())
  Var->setTemplateSpecializationKind(TSK_ImplicitInstantiation,
                                     NameInfo.getLoc());

// Build an ordinary singleton decl ref.
return BuildDeclarationNameExpr(SS, NameInfo, Var,
                                /*FoundD=*/nullptr, TemplateArgs);
3939}

3941ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,
                                   SourceLocation TemplateKWLoc,
                                   LookupResult &R,
                                   bool RequiresADL,
                               const TemplateArgumentListInfo *TemplateArgs) {
// FIXME: Can we do any checking at this point? I guess we could check the
// template arguments that we have against the template name, if the template
// name refers to a single template. That's not a terribly common case,
// though.
// foo<int> could identify a single function unambiguously
// This approach does NOT work, since f<int>(1);
// gets resolved prior to resorting to overload resolution
// i.e., template<class T> void f(double);
//       vs template<class T, class U> void f(U);

// These should be filtered out by our callers.
assert(!R.empty() && "empty lookup results when building templateid")(static_cast <bool> (!R.empty() && "empty lookup results when building templateid"
) ? void (0) : __assert_fail ("!R.empty() && \"empty lookup results when building templateid\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3957, __extension__ __PRETTY_FUNCTION__));
assert(!R.isAmbiguous() && "ambiguous lookup when building templateid")(static_cast <bool> (!R.isAmbiguous() && "ambiguous lookup when building templateid"
) ? void (0) : __assert_fail ("!R.isAmbiguous() && \"ambiguous lookup when building templateid\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3958, __extension__ __PRETTY_FUNCTION__));

// In C++1y, check variable template ids.
bool InstantiationDependent;
if (R.getAsSingle<VarTemplateDecl>() &&
    !TemplateSpecializationType::anyDependentTemplateArguments(
         *TemplateArgs, InstantiationDependent)) {
  return CheckVarTemplateId(SS, R.getLookupNameInfo(),
                            R.getAsSingle<VarTemplateDecl>(),
                            TemplateKWLoc, TemplateArgs);
}

// We don't want lookup warnings at this point.
R.suppressDiagnostics();

UnresolvedLookupExpr *ULE
  = UnresolvedLookupExpr::Create(Context, R.getNamingClass(),
                                 SS.getWithLocInContext(Context),
                                 TemplateKWLoc,
                                 R.getLookupNameInfo(),
                                 RequiresADL, TemplateArgs,
                                 R.begin(), R.end());

return ULE;
3982}

3984// We actually only call this from template instantiation.
3985ExprResult
3986Sema::BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS,
                                 SourceLocation TemplateKWLoc,
                                 const DeclarationNameInfo &NameInfo,
                           const TemplateArgumentListInfo *TemplateArgs) {

assert(TemplateArgs || TemplateKWLoc.isValid())(static_cast <bool> (TemplateArgs || TemplateKWLoc.isValid
()) ? void (0) : __assert_fail ("TemplateArgs || TemplateKWLoc.isValid()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3991, __extension__ __PRETTY_FUNCTION__));
DeclContext *DC;
if (!(DC = computeDeclContext(SS, false)) ||
    DC->isDependentContext() ||
    RequireCompleteDeclContext(SS, DC))
  return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);

bool MemberOfUnknownSpecialization;
LookupResult R(*this, NameInfo, LookupOrdinaryName);
LookupTemplateName(R, (Scope*)nullptr, SS, QualType(), /*Entering*/ false,
                   MemberOfUnknownSpecialization);

if (R.isAmbiguous())
  return ExprError();

if (R.empty()) {
  Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_non_template)
    << NameInfo.getName() << SS.getRange();
  return ExprError();
}

if (ClassTemplateDecl *Temp = R.getAsSingle<ClassTemplateDecl>()) {
  Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_class_template)
    << SS.getScopeRep()
    << NameInfo.getName().getAsString() << SS.getRange();
  Diag(Temp->getLocation(), diag::note_referenced_class_template);
  return ExprError();
}

return BuildTemplateIdExpr(SS, TemplateKWLoc, R, /*ADL*/ false, TemplateArgs);
4021}

4023/// \brief Form a dependent template name.
4024///
4025/// This action forms a dependent template name given the template
4026/// name and its (presumably dependent) scope specifier. For
4027/// example, given "MetaFun::template apply", the scope specifier \p
4028/// SS will be "MetaFun::", \p TemplateKWLoc contains the location
4029/// of the "template" keyword, and "apply" is the \p Name.
4030TemplateNameKind Sema::ActOnDependentTemplateName(Scope *S,
                                                CXXScopeSpec &SS,
                                                SourceLocation TemplateKWLoc,
                                                UnqualifiedId &Name,
                                                ParsedType ObjectType,
                                                bool EnteringContext,
                                                TemplateTy &Result,
                                                bool AllowInjectedClassName) {
if (TemplateKWLoc.isValid() && S && !S->getTemplateParamParent())
  Diag(TemplateKWLoc,
       getLangOpts().CPlusPlus11 ?
         diag::warn_cxx98_compat_template_outside_of_template :
         diag::ext_template_outside_of_template)
    << FixItHint::CreateRemoval(TemplateKWLoc);

DeclContext *LookupCtx = nullptr;
if (SS.isSet())
  LookupCtx = computeDeclContext(SS, EnteringContext);
if (!LookupCtx && ObjectType)
  LookupCtx = computeDeclContext(ObjectType.get());
if (LookupCtx) {
  // C++0x [temp.names]p5:
  //   If a name prefixed by the keyword template is not the name of
  //   a template, the program is ill-formed. [Note: the keyword
  //   template may not be applied to non-template members of class
  //   templates. -end note ] [ Note: as is the case with the
  //   typename prefix, the template prefix is allowed in cases
  //   where it is not strictly necessary; i.e., when the
  //   nested-name-specifier or the expression on the left of the ->
  //   or . is not dependent on a template-parameter, or the use
  //   does not appear in the scope of a template. -end note]
  //
  // Note: C++03 was more strict here, because it banned the use of
  // the "template" keyword prior to a template-name that was not a
  // dependent name. C++ DR468 relaxed this requirement (the
  // "template" keyword is now permitted). We follow the C++0x
  // rules, even in C++03 mode with a warning, retroactively applying the DR.
  bool MemberOfUnknownSpecialization;
  TemplateNameKind TNK = isTemplateName(S, SS, TemplateKWLoc.isValid(), Name,
                                        ObjectType, EnteringContext, Result,
                                        MemberOfUnknownSpecialization);
  if (TNK == TNK_Non_template && LookupCtx->isDependentContext() &&
      isa<CXXRecordDecl>(LookupCtx) &&
      (!cast<CXXRecordDecl>(LookupCtx)->hasDefinition() ||
       cast<CXXRecordDecl>(LookupCtx)->hasAnyDependentBases())) {
    // This is a dependent template. Handle it below.
  } else if (TNK == TNK_Non_template) {
    Diag(Name.getLocStart(),
         diag::err_template_kw_refers_to_non_template)
      << GetNameFromUnqualifiedId(Name).getName()
      << Name.getSourceRange()
      << TemplateKWLoc;
    return TNK_Non_template;
  } else {
    // We found something; return it.
    auto *LookupRD = dyn_cast<CXXRecordDecl>(LookupCtx);
    if (!AllowInjectedClassName && SS.isSet() && LookupRD &&
        Name.getKind() == UnqualifiedIdKind::IK_Identifier &&
        Name.Identifier && LookupRD->getIdentifier() == Name.Identifier) {
      // C++14 [class.qual]p2:
      //   In a lookup in which function names are not ignored and the
      //   nested-name-specifier nominates a class C, if the name specified
      //   [...] is the injected-class-name of C, [...] the name is instead
      //   considered to name the constructor
      //
      // We don't get here if naming the constructor would be valid, so we
      // just reject immediately and recover by treating the
      // injected-class-name as naming the template.
      Diag(Name.getLocStart(),
           diag::ext_out_of_line_qualified_id_type_names_constructor)
        << Name.Identifier << 0 /*injected-class-name used as template name*/
        << 1 /*'template' keyword was used*/;
    }
    return TNK;
  }
}

NestedNameSpecifier *Qualifier = SS.getScopeRep();

switch (Name.getKind()) {
case UnqualifiedIdKind::IK_Identifier:
  Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
                                                            Name.Identifier));
  return TNK_Dependent_template_name;

case UnqualifiedIdKind::IK_OperatorFunctionId:
  Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
                                           Name.OperatorFunctionId.Operator));
  return TNK_Function_template;

case UnqualifiedIdKind::IK_LiteralOperatorId:
  llvm_unreachable("literal operator id cannot have a dependent scope")::llvm::llvm_unreachable_internal("literal operator id cannot have a dependent scope"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4121);

default:
  break;
}

Diag(Name.getLocStart(),
     diag::err_template_kw_refers_to_non_template)
  << GetNameFromUnqualifiedId(Name).getName()
  << Name.getSourceRange()
  << TemplateKWLoc;
return TNK_Non_template;
4133}

4135bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
                                   TemplateArgumentLoc &AL,
                        SmallVectorImpl<TemplateArgument> &Converted) {
const TemplateArgument &Arg = AL.getArgument();
QualType ArgType;
TypeSourceInfo *TSI = nullptr;

// Check template type parameter.
switch(Arg.getKind()) {
case TemplateArgument::Type:
  // C++ [temp.arg.type]p1:
  //   A template-argument for a template-parameter which is a
  //   type shall be a type-id.
  ArgType = Arg.getAsType();
  TSI = AL.getTypeSourceInfo();
  break;
case TemplateArgument::Template: {
  // We have a template type parameter but the template argument
  // is a template without any arguments.
  SourceRange SR = AL.getSourceRange();
  TemplateName Name = Arg.getAsTemplate();
  Diag(SR.getBegin(), diag::err_template_missing_args)
    << (int)getTemplateNameKindForDiagnostics(Name) << Name << SR;
  if (TemplateDecl *Decl = Name.getAsTemplateDecl())
    Diag(Decl->getLocation(), diag::note_template_decl_here);

  return true;
}
case TemplateArgument::Expression: {
  // We have a template type parameter but the template argument is an
  // expression; see if maybe it is missing the "typename" keyword.
  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo;

  if (DeclRefExpr *ArgExpr = dyn_cast<DeclRefExpr>(Arg.getAsExpr())) {
    SS.Adopt(ArgExpr->getQualifierLoc());
    NameInfo = ArgExpr->getNameInfo();
  } else if (DependentScopeDeclRefExpr *ArgExpr =
             dyn_cast<DependentScopeDeclRefExpr>(Arg.getAsExpr())) {
    SS.Adopt(ArgExpr->getQualifierLoc());
    NameInfo = ArgExpr->getNameInfo();
  } else if (CXXDependentScopeMemberExpr *ArgExpr =
             dyn_cast<CXXDependentScopeMemberExpr>(Arg.getAsExpr())) {
    if (ArgExpr->isImplicitAccess()) {
      SS.Adopt(ArgExpr->getQualifierLoc());
      NameInfo = ArgExpr->getMemberNameInfo();
    }
  }

  if (auto *II = NameInfo.getName().getAsIdentifierInfo()) {
    LookupResult Result(*this, NameInfo, LookupOrdinaryName);
    LookupParsedName(Result, CurScope, &SS);

    if (Result.getAsSingle<TypeDecl>() ||
        Result.getResultKind() ==
            LookupResult::NotFoundInCurrentInstantiation) {
      // Suggest that the user add 'typename' before the NNS.
      SourceLocation Loc = AL.getSourceRange().getBegin();
      Diag(Loc, getLangOpts().MSVCCompat
                    ? diag::ext_ms_template_type_arg_missing_typename
                    : diag::err_template_arg_must_be_type_suggest)
          << FixItHint::CreateInsertion(Loc, "typename ");
      Diag(Param->getLocation(), diag::note_template_param_here);

      // Recover by synthesizing a type using the location information that we
      // already have.
      ArgType =
          Context.getDependentNameType(ETK_Typename, SS.getScopeRep(), II);
      TypeLocBuilder TLB;
      DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(ArgType);
      TL.setElaboratedKeywordLoc(SourceLocation(/*synthesized*/));
      TL.setQualifierLoc(SS.getWithLocInContext(Context));
      TL.setNameLoc(NameInfo.getLoc());
      TSI = TLB.getTypeSourceInfo(Context, ArgType);

      // Overwrite our input TemplateArgumentLoc so that we can recover
      // properly.
      AL = TemplateArgumentLoc(TemplateArgument(ArgType),
                               TemplateArgumentLocInfo(TSI));

      break;
    }
  }
  // fallthrough
  LLVM_FALLTHROUGH[[clang::fallthrough]];
}
default: {
  // We have a template type parameter but the template argument
  // is not a type.
  SourceRange SR = AL.getSourceRange();
  Diag(SR.getBegin(), diag::err_template_arg_must_be_type) << SR;
  Diag(Param->getLocation(), diag::note_template_param_here);

  return true;
}
}

if (CheckTemplateArgument(Param, TSI))
  return true;

// Add the converted template type argument.
ArgType = Context.getCanonicalType(ArgType);

// Objective-C ARC:
//   If an explicitly-specified template argument type is a lifetime type
//   with no lifetime qualifier, the __strong lifetime qualifier is inferred.
if (getLangOpts().ObjCAutoRefCount &&
    ArgType->isObjCLifetimeType() &&
    !ArgType.getObjCLifetime()) {
  Qualifiers Qs;
  Qs.setObjCLifetime(Qualifiers::OCL_Strong);
  ArgType = Context.getQualifiedType(ArgType, Qs);
}

Converted.push_back(TemplateArgument(ArgType));
return false;
4251}

4253/// \brief Substitute template arguments into the default template argument for
4254/// the given template type parameter.
4255///
4256/// \param SemaRef the semantic analysis object for which we are performing
4257/// the substitution.
4258///
4259/// \param Template the template that we are synthesizing template arguments
4260/// for.
4261///
4262/// \param TemplateLoc the location of the template name that started the
4263/// template-id we are checking.
4264///
4265/// \param RAngleLoc the location of the right angle bracket ('>') that
4266/// terminates the template-id.
4267///
4268/// \param Param the template template parameter whose default we are
4269/// substituting into.
4270///
4271/// \param Converted the list of template arguments provided for template
4272/// parameters that precede \p Param in the template parameter list.
4273/// \returns the substituted template argument, or NULL if an error occurred.
4274static TypeSourceInfo *
4275SubstDefaultTemplateArgument(Sema &SemaRef,
                           TemplateDecl *Template,
                           SourceLocation TemplateLoc,
                           SourceLocation RAngleLoc,
                           TemplateTypeParmDecl *Param,
                           SmallVectorImpl<TemplateArgument> &Converted) {
TypeSourceInfo *ArgType = Param->getDefaultArgumentInfo();

// If the argument type is dependent, instantiate it now based
// on the previously-computed template arguments.
if (ArgType->getType()->isDependentType()) {
  Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
                                   Param, Template, Converted,
                                   SourceRange(TemplateLoc, RAngleLoc));
  if (Inst.isInvalid())
    return nullptr;

  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);

  // Only substitute for the innermost template argument list.
  MultiLevelTemplateArgumentList TemplateArgLists;
  TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
  for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
    TemplateArgLists.addOuterTemplateArguments(None);

  Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
  ArgType =
      SemaRef.SubstType(ArgType, TemplateArgLists,
                        Param->getDefaultArgumentLoc(), Param->getDeclName());
}

return ArgType;
4307}

4309/// \brief Substitute template arguments into the default template argument for
4310/// the given non-type template parameter.
4311///
4312/// \param SemaRef the semantic analysis object for which we are performing
4313/// the substitution.
4314///
4315/// \param Template the template that we are synthesizing template arguments
4316/// for.
4317///
4318/// \param TemplateLoc the location of the template name that started the
4319/// template-id we are checking.
4320///
4321/// \param RAngleLoc the location of the right angle bracket ('>') that
4322/// terminates the template-id.
4323///
4324/// \param Param the non-type template parameter whose default we are
4325/// substituting into.
4326///
4327/// \param Converted the list of template arguments provided for template
4328/// parameters that precede \p Param in the template parameter list.
4329///
4330/// \returns the substituted template argument, or NULL if an error occurred.
4331static ExprResult
4332SubstDefaultTemplateArgument(Sema &SemaRef,
                           TemplateDecl *Template,
                           SourceLocation TemplateLoc,
                           SourceLocation RAngleLoc,
                           NonTypeTemplateParmDecl *Param,
                      SmallVectorImpl<TemplateArgument> &Converted) {
Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
                                 Param, Template, Converted,
                                 SourceRange(TemplateLoc, RAngleLoc));
if (Inst.isInvalid())
  return ExprError();

TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);

// Only substitute for the innermost template argument list.
MultiLevelTemplateArgumentList TemplateArgLists;
TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
  TemplateArgLists.addOuterTemplateArguments(None);

EnterExpressionEvaluationContext ConstantEvaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
return SemaRef.SubstExpr(Param->getDefaultArgument(), TemplateArgLists);
4355}

4357/// \brief Substitute template arguments into the default template argument for
4358/// the given template template parameter.
4359///
4360/// \param SemaRef the semantic analysis object for which we are performing
4361/// the substitution.
4362///
4363/// \param Template the template that we are synthesizing template arguments
4364/// for.
4365///
4366/// \param TemplateLoc the location of the template name that started the
4367/// template-id we are checking.
4368///
4369/// \param RAngleLoc the location of the right angle bracket ('>') that
4370/// terminates the template-id.
4371///
4372/// \param Param the template template parameter whose default we are
4373/// substituting into.
4374///
4375/// \param Converted the list of template arguments provided for template
4376/// parameters that precede \p Param in the template parameter list.
4377///
4378/// \param QualifierLoc Will be set to the nested-name-specifier (with
4379/// source-location information) that precedes the template name.
4380///
4381/// \returns the substituted template argument, or NULL if an error occurred.
4382static TemplateName
4383SubstDefaultTemplateArgument(Sema &SemaRef,
                           TemplateDecl *Template,
                           SourceLocation TemplateLoc,
                           SourceLocation RAngleLoc,
                           TemplateTemplateParmDecl *Param,
                     SmallVectorImpl<TemplateArgument> &Converted,
                           NestedNameSpecifierLoc &QualifierLoc) {
Sema::InstantiatingTemplate Inst(
    SemaRef, TemplateLoc, TemplateParameter(Param), Template, Converted,
    SourceRange(TemplateLoc, RAngleLoc));
if (Inst.isInvalid())
  return TemplateName();

TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);

// Only substitute for the innermost template argument list.
MultiLevelTemplateArgumentList TemplateArgLists;
TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
  TemplateArgLists.addOuterTemplateArguments(None);

Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
// Substitute into the nested-name-specifier first,
QualifierLoc = Param->getDefaultArgument().getTemplateQualifierLoc();
if (QualifierLoc) {
  QualifierLoc =
      SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgLists);
  if (!QualifierLoc)
    return TemplateName();
}

return SemaRef.SubstTemplateName(
           QualifierLoc,
           Param->getDefaultArgument().getArgument().getAsTemplate(),
           Param->getDefaultArgument().getTemplateNameLoc(),
           TemplateArgLists);
4419}

4421/// \brief If the given template parameter has a default template
4422/// argument, substitute into that default template argument and
4423/// return the corresponding template argument.
4424TemplateArgumentLoc
4425Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
                                            SourceLocation TemplateLoc,
                                            SourceLocation RAngleLoc,
                                            Decl *Param,
                                            SmallVectorImpl<TemplateArgument>
                                              &Converted,
                                            bool &HasDefaultArg) {
HasDefaultArg = false;

if (TemplateTypeParmDecl *TypeParm = dyn_cast<TemplateTypeParmDecl>(Param)) {
  if (!hasVisibleDefaultArgument(TypeParm))
    return TemplateArgumentLoc();

  HasDefaultArg = true;
  TypeSourceInfo *DI = SubstDefaultTemplateArgument(*this, Template,
                                                    TemplateLoc,
                                                    RAngleLoc,
                                                    TypeParm,
                                                    Converted);
  if (DI)
    return TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);

  return TemplateArgumentLoc();
}

if (NonTypeTemplateParmDecl *NonTypeParm
      = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
  if (!hasVisibleDefaultArgument(NonTypeParm))
    return TemplateArgumentLoc();

  HasDefaultArg = true;
  ExprResult Arg = SubstDefaultTemplateArgument(*this, Template,
                                                TemplateLoc,
                                                RAngleLoc,
                                                NonTypeParm,
                                                Converted);
  if (Arg.isInvalid())
    return TemplateArgumentLoc();

  Expr *ArgE = Arg.getAs<Expr>();
  return TemplateArgumentLoc(TemplateArgument(ArgE), ArgE);
}

TemplateTemplateParmDecl *TempTempParm
  = cast<TemplateTemplateParmDecl>(Param);
if (!hasVisibleDefaultArgument(TempTempParm))
  return TemplateArgumentLoc();

HasDefaultArg = true;
NestedNameSpecifierLoc QualifierLoc;
TemplateName TName = SubstDefaultTemplateArgument(*this, Template,
                                                  TemplateLoc,
                                                  RAngleLoc,
                                                  TempTempParm,
                                                  Converted,
                                                  QualifierLoc);
if (TName.isNull())
  return TemplateArgumentLoc();

return TemplateArgumentLoc(TemplateArgument(TName),
              TempTempParm->getDefaultArgument().getTemplateQualifierLoc(),
              TempTempParm->getDefaultArgument().getTemplateNameLoc());
4487}

4489/// Convert a template-argument that we parsed as a type into a template, if
4490/// possible. C++ permits injected-class-names to perform dual service as
4491/// template template arguments and as template type arguments.
4492static TemplateArgumentLoc convertTypeTemplateArgumentToTemplate(TypeLoc TLoc) {
// Extract and step over any surrounding nested-name-specifier.
NestedNameSpecifierLoc QualLoc;
if (auto ETLoc = TLoc.getAs<ElaboratedTypeLoc>()) {
  if (ETLoc.getTypePtr()->getKeyword() != ETK_None)
    return TemplateArgumentLoc();

  QualLoc = ETLoc.getQualifierLoc();
  TLoc = ETLoc.getNamedTypeLoc();
}

// If this type was written as an injected-class-name, it can be used as a
// template template argument.
if (auto InjLoc = TLoc.getAs<InjectedClassNameTypeLoc>())
  return TemplateArgumentLoc(InjLoc.getTypePtr()->getTemplateName(),
                             QualLoc, InjLoc.getNameLoc());

// If this type was written as an injected-class-name, it may have been
// converted to a RecordType during instantiation. If the RecordType is
// *not* wrapped in a TemplateSpecializationType and denotes a class
// template specialization, it must have come from an injected-class-name.
if (auto RecLoc = TLoc.getAs<RecordTypeLoc>())
  if (auto *CTSD =
          dyn_cast<ClassTemplateSpecializationDecl>(RecLoc.getDecl()))
    return TemplateArgumentLoc(TemplateName(CTSD->getSpecializedTemplate()),
                               QualLoc, RecLoc.getNameLoc());

return TemplateArgumentLoc();
4520}

4522/// \brief Check that the given template argument corresponds to the given
4523/// template parameter.
4524///
4525/// \param Param The template parameter against which the argument will be
4526/// checked.
4527///
4528/// \param Arg The template argument, which may be updated due to conversions.
4529///
4530/// \param Template The template in which the template argument resides.
4531///
4532/// \param TemplateLoc The location of the template name for the template
4533/// whose argument list we're matching.
4534///
4535/// \param RAngleLoc The location of the right angle bracket ('>') that closes
4536/// the template argument list.
4537///
4538/// \param ArgumentPackIndex The index into the argument pack where this
4539/// argument will be placed. Only valid if the parameter is a parameter pack.
4540///
4541/// \param Converted The checked, converted argument will be added to the
4542/// end of this small vector.
4543///
4544/// \param CTAK Describes how we arrived at this particular template argument:
4545/// explicitly written, deduced, etc.
4546///
4547/// \returns true on error, false otherwise.
4548bool Sema::CheckTemplateArgument(NamedDecl *Param,
                               TemplateArgumentLoc &Arg,
                               NamedDecl *Template,
                               SourceLocation TemplateLoc,
                               SourceLocation RAngleLoc,
                               unsigned ArgumentPackIndex,
                          SmallVectorImpl<TemplateArgument> &Converted,
                               CheckTemplateArgumentKind CTAK) {
// Check template type parameters.
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
  return CheckTemplateTypeArgument(TTP, Arg, Converted);

// Check non-type template parameters.
if (NonTypeTemplateParmDecl *NTTP =dyn_cast<NonTypeTemplateParmDecl>(Param)) {
  // Do substitution on the type of the non-type template parameter
  // with the template arguments we've seen thus far.  But if the
  // template has a dependent context then we cannot substitute yet.
  QualType NTTPType = NTTP->getType();
  if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
    NTTPType = NTTP->getExpansionType(ArgumentPackIndex);

  if (NTTPType->isDependentType() &&
      !isa<TemplateTemplateParmDecl>(Template) &&
      !Template->getDeclContext()->isDependentContext()) {
    // Do substitution on the type of the non-type template parameter.
    InstantiatingTemplate Inst(*this, TemplateLoc, Template,
                               NTTP, Converted,
                               SourceRange(TemplateLoc, RAngleLoc));
    if (Inst.isInvalid())
      return true;

    TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
                                      Converted);
    NTTPType = SubstType(NTTPType,
                         MultiLevelTemplateArgumentList(TemplateArgs),
                         NTTP->getLocation(),
                         NTTP->getDeclName());
    // If that worked, check the non-type template parameter type
    // for validity.
    if (!NTTPType.isNull())
      NTTPType = CheckNonTypeTemplateParameterType(NTTPType,
                                                   NTTP->getLocation());
    if (NTTPType.isNull())
      return true;
  }

  switch (Arg.getArgument().getKind()) {
  case TemplateArgument::Null:
    llvm_unreachable("Should never see a NULL template argument here")::llvm::llvm_unreachable_internal("Should never see a NULL template argument here"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4596);

  case TemplateArgument::Expression: {
    TemplateArgument Result;
    ExprResult Res =
      CheckTemplateArgument(NTTP, NTTPType, Arg.getArgument().getAsExpr(),
                            Result, CTAK);
    if (Res.isInvalid())
      return true;

    // If the resulting expression is new, then use it in place of the
    // old expression in the template argument.
    if (Res.get() != Arg.getArgument().getAsExpr()) {
      TemplateArgument TA(Res.get());
      Arg = TemplateArgumentLoc(TA, Res.get());
    }

    Converted.push_back(Result);
    break;
  }

  case TemplateArgument::Declaration:
  case TemplateArgument::Integral:
  case TemplateArgument::NullPtr:
    // We've already checked this template argument, so just copy
    // it to the list of converted arguments.
    Converted.push_back(Arg.getArgument());
    break;

  case TemplateArgument::Template:
  case TemplateArgument::TemplateExpansion:
    // We were given a template template argument. It may not be ill-formed;
    // see below.
    if (DependentTemplateName *DTN
          = Arg.getArgument().getAsTemplateOrTemplatePattern()
                                            .getAsDependentTemplateName()) {
      // We have a template argument such as \c T::template X, which we
      // parsed as a template template argument. However, since we now
      // know that we need a non-type template argument, convert this
      // template name into an expression.

      DeclarationNameInfo NameInfo(DTN->getIdentifier(),
                                   Arg.getTemplateNameLoc());

      CXXScopeSpec SS;
      SS.Adopt(Arg.getTemplateQualifierLoc());
      // FIXME: the template-template arg was a DependentTemplateName,
      // so it was provided with a template keyword. However, its source
      // location is not stored in the template argument structure.
      SourceLocation TemplateKWLoc;
      ExprResult E = DependentScopeDeclRefExpr::Create(
          Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
          nullptr);

      // If we parsed the template argument as a pack expansion, create a
      // pack expansion expression.
      if (Arg.getArgument().getKind() == TemplateArgument::TemplateExpansion){
        E = ActOnPackExpansion(E.get(), Arg.getTemplateEllipsisLoc());
        if (E.isInvalid())
          return true;
      }

      TemplateArgument Result;
      E = CheckTemplateArgument(NTTP, NTTPType, E.get(), Result);
      if (E.isInvalid())
        return true;

      Converted.push_back(Result);
      break;
    }

    // We have a template argument that actually does refer to a class
    // template, alias template, or template template parameter, and
    // therefore cannot be a non-type template argument.
    Diag(Arg.getLocation(), diag::err_template_arg_must_be_expr)
      << Arg.getSourceRange();

    Diag(Param->getLocation(), diag::note_template_param_here);
    return true;

  case TemplateArgument::Type: {
    // We have a non-type template parameter but the template
    // argument is a type.

    // C++ [temp.arg]p2:
    //   In a template-argument, an ambiguity between a type-id and
    //   an expression is resolved to a type-id, regardless of the
    //   form of the corresponding template-parameter.
    //
    // We warn specifically about this case, since it can be rather
    // confusing for users.
    QualType T = Arg.getArgument().getAsType();
    SourceRange SR = Arg.getSourceRange();
    if (T->isFunctionType())
      Diag(SR.getBegin(), diag::err_template_arg_nontype_ambig) << SR << T;
    else
      Diag(SR.getBegin(), diag::err_template_arg_must_be_expr) << SR;
    Diag(Param->getLocation(), diag::note_template_param_here);
    return true;
  }

  case TemplateArgument::Pack:
    llvm_unreachable("Caller must expand template argument packs")::llvm::llvm_unreachable_internal("Caller must expand template argument packs"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4698);
  }

  return false;
}


// Check template template parameters.
TemplateTemplateParmDecl *TempParm = cast<TemplateTemplateParmDecl>(Param);

// Substitute into the template parameter list of the template
// template parameter, since previously-supplied template arguments
// may appear within the template template parameter.
{
  // Set up a template instantiation context.
  LocalInstantiationScope Scope(*this);
  InstantiatingTemplate Inst(*this, TemplateLoc, Template,
                             TempParm, Converted,
                             SourceRange(TemplateLoc, RAngleLoc));
  if (Inst.isInvalid())
    return true;

  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
  TempParm = cast_or_null<TemplateTemplateParmDecl>(
                    SubstDecl(TempParm, CurContext,
                              MultiLevelTemplateArgumentList(TemplateArgs)));
  if (!TempParm)
    return true;
}

// C++1z [temp.local]p1: (DR1004)
//   When [the injected-class-name] is used [...] as a template-argument for
//   a template template-parameter [...] it refers to the class template
//   itself.
if (Arg.getArgument().getKind() == TemplateArgument::Type) {
  TemplateArgumentLoc ConvertedArg = convertTypeTemplateArgumentToTemplate(
      Arg.getTypeSourceInfo()->getTypeLoc());
  if (!ConvertedArg.getArgument().isNull())
    Arg = ConvertedArg;
}

switch (Arg.getArgument().getKind()) {
case TemplateArgument::Null:
  llvm_unreachable("Should never see a NULL template argument here")::llvm::llvm_unreachable_internal("Should never see a NULL template argument here"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4741);

case TemplateArgument::Template:
case TemplateArgument::TemplateExpansion:
  if (CheckTemplateArgument(TempParm, Arg, ArgumentPackIndex))
    return true;

  Converted.push_back(Arg.getArgument());
  break;

case TemplateArgument::Expression:
case TemplateArgument::Type:
  // We have a template template parameter but the template
  // argument does not refer to a template.
  Diag(Arg.getLocation(), diag::err_template_arg_must_be_template)
    << getLangOpts().CPlusPlus11;
  return true;

case TemplateArgument::Declaration:
  llvm_unreachable("Declaration argument with template template parameter")::llvm::llvm_unreachable_internal("Declaration argument with template template parameter"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4760);
case TemplateArgument::Integral:
  llvm_unreachable("Integral argument with template template parameter")::llvm::llvm_unreachable_internal("Integral argument with template template parameter"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4762);
case TemplateArgument::NullPtr:
  llvm_unreachable("Null pointer argument with template template parameter")::llvm::llvm_unreachable_internal("Null pointer argument with template template parameter"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4764);

case TemplateArgument::Pack:
  llvm_unreachable("Caller must expand template argument packs")::llvm::llvm_unreachable_internal("Caller must expand template argument packs"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4767);
}

return false;
4771}

4773/// \brief Diagnose an arity mismatch in the
4774static bool diagnoseArityMismatch(Sema &S, TemplateDecl *Template,
                                SourceLocation TemplateLoc,
                                TemplateArgumentListInfo &TemplateArgs) {
TemplateParameterList *Params = Template->getTemplateParameters();
unsigned NumParams = Params->size();
unsigned NumArgs = TemplateArgs.size();

SourceRange Range;
if (NumArgs > NumParams)
  Range = SourceRange(TemplateArgs[NumParams].getLocation(),
                      TemplateArgs.getRAngleLoc());
S.Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
  << (NumArgs > NumParams)
  << (int)S.getTemplateNameKindForDiagnostics(TemplateName(Template))
  << Template << Range;
S.Diag(Template->getLocation(), diag::note_template_decl_here)
  << Params->getSourceRange();
return true;
4792}

4794/// \brief Check whether the template parameter is a pack expansion, and if so,
4795/// determine the number of parameters produced by that expansion. For instance:
4796///
4797/// \code
4798/// template<typename ...Ts> struct A {
4799///   template<Ts ...NTs, template<Ts> class ...TTs, typename ...Us> struct B;
4800/// };
4801/// \endcode
4802///
4803/// In \c A<int,int>::B, \c NTs and \c TTs have expanded pack size 2, and \c Us
4804/// is not a pack expansion, so returns an empty Optional.
4805static Optional<unsigned> getExpandedPackSize(NamedDecl *Param) {
if (NonTypeTemplateParmDecl *NTTP
      = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
  if (NTTP->isExpandedParameterPack())
    return NTTP->getNumExpansionTypes();
}

if (TemplateTemplateParmDecl *TTP
      = dyn_cast<TemplateTemplateParmDecl>(Param)) {
  if (TTP->isExpandedParameterPack())
    return TTP->getNumExpansionTemplateParameters();
}

return None;
4819}

4821/// Diagnose a missing template argument.
4822template<typename TemplateParmDecl>
4823static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc,
                                  TemplateDecl *TD,
                                  const TemplateParmDecl *D,
                                  TemplateArgumentListInfo &Args) {
// Dig out the most recent declaration of the template parameter; there may be
// declarations of the template that are more recent than TD.
D = cast<TemplateParmDecl>(cast<TemplateDecl>(TD->getMostRecentDecl())
                               ->getTemplateParameters()
                               ->getParam(D->getIndex()));

// If there's a default argument that's not visible, diagnose that we're
// missing a module import.
llvm::SmallVector<Module*, 8> Modules;
if (D->hasDefaultArgument() && !S.hasVisibleDefaultArgument(D, &Modules)) {
  S.diagnoseMissingImport(Loc, cast<NamedDecl>(TD),
                          D->getDefaultArgumentLoc(), Modules,
                          Sema::MissingImportKind::DefaultArgument,
                          /*Recover*/true);
  return true;
}

// FIXME: If there's a more recent default argument that *is* visible,
// diagnose that it was declared too late.

return diagnoseArityMismatch(S, TD, Loc, Args);
4848}

4850/// \brief Check that the given template argument list is well-formed
4851/// for specializing the given template.
4852bool Sema::CheckTemplateArgumentList(
  TemplateDecl *Template, SourceLocation TemplateLoc,
  TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs,
  SmallVectorImpl<TemplateArgument> &Converted,
  bool UpdateArgsWithConversions) {
// Make a copy of the template arguments for processing.  Only make the
// changes at the end when successful in matching the arguments to the
// template.
TemplateArgumentListInfo NewArgs = TemplateArgs;

// Make sure we get the template parameter list from the most
// recentdeclaration, since that is the only one that has is guaranteed to
// have all the default template argument information.
TemplateParameterList *Params =
    cast<TemplateDecl>(Template->getMostRecentDecl())
        ->getTemplateParameters();

SourceLocation RAngleLoc = NewArgs.getRAngleLoc();

// C++ [temp.arg]p1:
//   [...] The type and form of each template-argument specified in
//   a template-id shall match the type and form specified for the
//   corresponding parameter declared by the template in its
//   template-parameter-list.
bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);
SmallVector<TemplateArgument, 2> ArgumentPack;
unsigned ArgIdx = 0, NumArgs = NewArgs.size();
LocalInstantiationScope InstScope(*this, true);
for (TemplateParameterList::iterator Param = Params->begin(),
                                     ParamEnd = Params->end();
     Param != ParamEnd; /* increment in loop */) {
  // If we have an expanded parameter pack, make sure we don't have too
  // many arguments.
  if (Optional<unsigned> Expansions = getExpandedPackSize(*Param)) {
    if (*Expansions == ArgumentPack.size()) {
      // We're done with this parameter pack. Pack up its arguments and add
      // them to the list.
      Converted.push_back(
          TemplateArgument::CreatePackCopy(Context, ArgumentPack));
      ArgumentPack.clear();

      // This argument is assigned to the next parameter.
      ++Param;
      continue;
    } else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
      // Not enough arguments for this parameter pack.
      Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
        << false
        << (int)getTemplateNameKindForDiagnostics(TemplateName(Template))
        << Template;
      Diag(Template->getLocation(), diag::note_template_decl_here)
        << Params->getSourceRange();
      return true;
    }
  }

  if (ArgIdx < NumArgs) {
    // Check the template argument we were given.
    if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template,
                              TemplateLoc, RAngleLoc,
                              ArgumentPack.size(), Converted))
      return true;

    bool PackExpansionIntoNonPack =
        NewArgs[ArgIdx].getArgument().isPackExpansion() &&
        (!(*Param)->isTemplateParameterPack() || getExpandedPackSize(*Param));
    if (PackExpansionIntoNonPack && isa<TypeAliasTemplateDecl>(Template)) {
      // Core issue 1430: we have a pack expansion as an argument to an
      // alias template, and it's not part of a parameter pack. This
      // can't be canonicalized, so reject it now.
      Diag(NewArgs[ArgIdx].getLocation(),
           diag::err_alias_template_expansion_into_fixed_list)
        << NewArgs[ArgIdx].getSourceRange();
      Diag((*Param)->getLocation(), diag::note_template_param_here);
      return true;
    }

    // We're now done with this argument.
    ++ArgIdx;

    if ((*Param)->isTemplateParameterPack()) {
      // The template parameter was a template parameter pack, so take the
      // deduced argument and place it on the argument pack. Note that we
      // stay on the same template parameter so that we can deduce more
      // arguments.
      ArgumentPack.push_back(Converted.pop_back_val());
    } else {
      // Move to the next template parameter.
      ++Param;
    }

    // If we just saw a pack expansion into a non-pack, then directly convert
    // the remaining arguments, because we don't know what parameters they'll
    // match up with.
    if (PackExpansionIntoNonPack) {
      if (!ArgumentPack.empty()) {
        // If we were part way through filling in an expanded parameter pack,
        // fall back to just producing individual arguments.
        Converted.insert(Converted.end(),
                         ArgumentPack.begin(), ArgumentPack.end());
        ArgumentPack.clear();
      }

      while (ArgIdx < NumArgs) {
        Converted.push_back(NewArgs[ArgIdx].getArgument());
        ++ArgIdx;
      }

      return false;
    }

    continue;
  }

  // If we're checking a partial template argument list, we're done.
  if (PartialTemplateArgs) {
    if ((*Param)->isTemplateParameterPack() && !ArgumentPack.empty())
      Converted.push_back(
          TemplateArgument::CreatePackCopy(Context, ArgumentPack));

    return false;
  }

  // If we have a template parameter pack with no more corresponding
  // arguments, just break out now and we'll fill in the argument pack below.
  if ((*Param)->isTemplateParameterPack()) {
    assert(!getExpandedPackSize(*Param) &&(static_cast <bool> (!getExpandedPackSize(*Param) &&
 "Should have dealt with this already") ? void (0) : __assert_fail
 ("!getExpandedPackSize(*Param) && \"Should have dealt with this already\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4979, __extension__ __PRETTY_FUNCTION__))
           "Should have dealt with this already")(static_cast <bool> (!getExpandedPackSize(*Param) &&
 "Should have dealt with this already") ? void (0) : __assert_fail
 ("!getExpandedPackSize(*Param) && \"Should have dealt with this already\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4979, __extension__ __PRETTY_FUNCTION__));

    // A non-expanded parameter pack before the end of the parameter list
    // only occurs for an ill-formed template parameter list, unless we've
    // got a partial argument list for a function template, so just bail out.
    if (Param + 1 != ParamEnd)
      return true;

    Converted.push_back(
        TemplateArgument::CreatePackCopy(Context, ArgumentPack));
    ArgumentPack.clear();

    ++Param;
    continue;
  }

  // Check whether we have a default argument.
  TemplateArgumentLoc Arg;

  // Retrieve the default template argument from the template
  // parameter. For each kind of template parameter, we substitute the
  // template arguments provided thus far and any "outer" template arguments
  // (when the template parameter was part of a nested template) into
  // the default argument.
  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
    if (!hasVisibleDefaultArgument(TTP))
      return diagnoseMissingArgument(*this, TemplateLoc, Template, TTP,
                                     NewArgs);

    TypeSourceInfo *ArgType = SubstDefaultTemplateArgument(*this,
                                                           Template,
                                                           TemplateLoc,
                                                           RAngleLoc,
                                                           TTP,
                                                           Converted);
    if (!ArgType)
      return true;

    Arg = TemplateArgumentLoc(TemplateArgument(ArgType->getType()),
                              ArgType);
  } else if (NonTypeTemplateParmDecl *NTTP
               = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
    if (!hasVisibleDefaultArgument(NTTP))
      return diagnoseMissingArgument(*this, TemplateLoc, Template, NTTP,
                                     NewArgs);

    ExprResult E = SubstDefaultTemplateArgument(*this, Template,
                                                            TemplateLoc,
                                                            RAngleLoc,
                                                            NTTP,
                                                            Converted);
    if (E.isInvalid())
      return true;

    Expr *Ex = E.getAs<Expr>();
    Arg = TemplateArgumentLoc(TemplateArgument(Ex), Ex);
  } else {
    TemplateTemplateParmDecl *TempParm
      = cast<TemplateTemplateParmDecl>(*Param);

    if (!hasVisibleDefaultArgument(TempParm))
      return diagnoseMissingArgument(*this, TemplateLoc, Template, TempParm,
                                     NewArgs);

    NestedNameSpecifierLoc QualifierLoc;
    TemplateName Name = SubstDefaultTemplateArgument(*this, Template,
                                                     TemplateLoc,
                                                     RAngleLoc,
                                                     TempParm,
                                                     Converted,
                                                     QualifierLoc);
    if (Name.isNull())
      return true;

    Arg = TemplateArgumentLoc(TemplateArgument(Name), QualifierLoc,
                         TempParm->getDefaultArgument().getTemplateNameLoc());
  }

  // Introduce an instantiation record that describes where we are using
  // the default template argument. We're not actually instantiating a
  // template here, we just create this object to put a note into the
  // context stack.
  InstantiatingTemplate Inst(*this, RAngleLoc, Template, *Param, Converted,
                             SourceRange(TemplateLoc, RAngleLoc));
  if (Inst.isInvalid())
    return true;

  // Check the default template argument.
  if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc,
                            RAngleLoc, 0, Converted))
    return true;

  // Core issue 150 (assumed resolution): if this is a template template
  // parameter, keep track of the default template arguments from the
  // template definition.
  if (isTemplateTemplateParameter)
    NewArgs.addArgument(Arg);

  // Move to the next template parameter and argument.
  ++Param;
  ++ArgIdx;
}

// If we're performing a partial argument substitution, allow any trailing
// pack expansions; they might be empty. This can happen even if
// PartialTemplateArgs is false (the list of arguments is complete but
// still dependent).
if (ArgIdx < NumArgs && CurrentInstantiationScope &&
    CurrentInstantiationScope->getPartiallySubstitutedPack()) {
  while (ArgIdx < NumArgs && NewArgs[ArgIdx].getArgument().isPackExpansion())
    Converted.push_back(NewArgs[ArgIdx++].getArgument());
}

// If we have any leftover arguments, then there were too many arguments.
// Complain and fail.
if (ArgIdx < NumArgs)
  return diagnoseArityMismatch(*this, Template, TemplateLoc, NewArgs);

// No problems found with the new argument list, propagate changes back
// to caller.
if (UpdateArgsWithConversions)
  TemplateArgs = std::move(NewArgs);

return false;
5103}

5105namespace {
class UnnamedLocalNoLinkageFinder
  : public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
{
  Sema &S;
  SourceRange SR;

  typedef TypeVisitor<UnnamedLocalNoLinkageFinder, bool> inherited;

public:
  UnnamedLocalNoLinkageFinder(Sema &S, SourceRange SR) : S(S), SR(SR) { }

  bool Visit(QualType T) {
    return T.isNull() ? false : inherited::Visit(T.getTypePtr());
  }

5121#define TYPE(Class, Parent) \
  bool Visit##Class##Type(const Class##Type *);
5123#define ABSTRACT_TYPE(Class, Parent) \
  bool Visit##Class##Type(const Class##Type *) { return false; }
5125#define NON_CANONICAL_TYPE(Class, Parent) \
  bool Visit##Class##Type(const Class##Type *) { return false; }
5127#include "clang/AST/TypeNodes.def"

  bool VisitTagDecl(const TagDecl *Tag);
  bool VisitNestedNameSpecifier(NestedNameSpecifier *NNS);
};
5132} // end anonymous namespace

5134bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(const BuiltinType*) {
return false;
5136}

5138bool UnnamedLocalNoLinkageFinder::VisitComplexType(const ComplexType* T) {
return Visit(T->getElementType());
5140}

5142bool UnnamedLocalNoLinkageFinder::VisitPointerType(const PointerType* T) {
return Visit(T->getPointeeType());
5144}

5146bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
                                                  const BlockPointerType* T) {
return Visit(T->getPointeeType());
5149}

5151bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
                                              const LValueReferenceType* T) {
return Visit(T->getPointeeType());
5154}

5156bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
                                              const RValueReferenceType* T) {
return Visit(T->getPointeeType());
5159}

5161bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
                                                const MemberPointerType* T) {
return Visit(T->getPointeeType()) || Visit(QualType(T->getClass(), 0));
5164}

5166bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
                                                const ConstantArrayType* T) {
return Visit(T->getElementType());
5169}

5171bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
                                               const IncompleteArrayType* T) {
return Visit(T->getElementType());
5174}

5176bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
                                                 const VariableArrayType* T) {
return Visit(T->getElementType());
5179}

5181bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
                                          const DependentSizedArrayType* T) {
return Visit(T->getElementType());
5184}

5186bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
                                       const DependentSizedExtVectorType* T) {
return Visit(T->getElementType());
5189}

5191bool UnnamedLocalNoLinkageFinder::VisitDependentAddressSpaceType(
  const DependentAddressSpaceType *T) {
return Visit(T->getPointeeType());
5194}

5196bool UnnamedLocalNoLinkageFinder::VisitVectorType(const VectorType* T) {
return Visit(T->getElementType());
5198}

5200bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(const ExtVectorType* T) {
return Visit(T->getElementType());
5202}

5204bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
                                                const FunctionProtoType* T) {
for (const auto &A : T->param_types()) {
  if (Visit(A))
    return true;
}

return Visit(T->getReturnType());
5212}

5214bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
                                             const FunctionNoProtoType* T) {
return Visit(T->getReturnType());
5217}

5219bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
                                                const UnresolvedUsingType*) {
return false;
5222}

5224bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(const TypeOfExprType*) {
return false;
5226}

5228bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(const TypeOfType* T) {
return Visit(T->getUnderlyingType());
5230}

5232bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(const DecltypeType*) {
return false;
5234}

5236bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
                                                  const UnaryTransformType*) {
return false;
5239}

5241bool UnnamedLocalNoLinkageFinder::VisitAutoType(const AutoType *T) {
return Visit(T->getDeducedType());
5243}

5245bool UnnamedLocalNoLinkageFinder::VisitDeducedTemplateSpecializationType(
  const DeducedTemplateSpecializationType *T) {
return Visit(T->getDeducedType());
5248}

5250bool UnnamedLocalNoLinkageFinder::VisitRecordType(const RecordType* T) {
return VisitTagDecl(T->getDecl());
5252}

5254bool UnnamedLocalNoLinkageFinder::VisitEnumType(const EnumType* T) {
return VisitTagDecl(T->getDecl());
5256}

5258bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
                                               const TemplateTypeParmType*) {
return false;
5261}

5263bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
                                      const SubstTemplateTypeParmPackType *) {
return false;
5266}

5268bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
                                          const TemplateSpecializationType*) {
return false;
5271}

5273bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
                                            const InjectedClassNameType* T) {
return VisitTagDecl(T->getDecl());
5276}

5278bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
                                                 const DependentNameType* T) {
return VisitNestedNameSpecifier(T->getQualifier());
5281}

5283bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
                               const DependentTemplateSpecializationType* T) {
return VisitNestedNameSpecifier(T->getQualifier());
5286}

5288bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
                                                 const PackExpansionType* T) {
return Visit(T->getPattern());
5291}

5293bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(const ObjCObjectType *) {
return false;
5295}

5297bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
                                                 const ObjCInterfaceType *) {
return false;
5300}

5302bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
                                              const ObjCObjectPointerType *) {
return false;
5305}

5307bool UnnamedLocalNoLinkageFinder::VisitAtomicType(const AtomicType* T) {
return Visit(T->getValueType());
5309}

5311bool UnnamedLocalNoLinkageFinder::VisitPipeType(const PipeType* T) {
return false;
5313}

5315bool UnnamedLocalNoLinkageFinder::VisitTagDecl(const TagDecl *Tag) {
if (Tag->getDeclContext()->isFunctionOrMethod()) {
  S.Diag(SR.getBegin(),
         S.getLangOpts().CPlusPlus11 ?
           diag::warn_cxx98_compat_template_arg_local_type :
           diag::ext_template_arg_local_type)
    << S.Context.getTypeDeclType(Tag) << SR;
  return true;
}

if (!Tag->hasNameForLinkage()) {
  S.Diag(SR.getBegin(),
         S.getLangOpts().CPlusPlus11 ?
           diag::warn_cxx98_compat_template_arg_unnamed_type :
           diag::ext_template_arg_unnamed_type) << SR;
  S.Diag(Tag->getLocation(), diag::note_template_unnamed_type_here);
  return true;
}

return false;
5335}

5337bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
                                                  NestedNameSpecifier *NNS) {
if (NNS->getPrefix() && VisitNestedNameSpecifier(NNS->getPrefix()))
  return true;

switch (NNS->getKind()) {
case NestedNameSpecifier::Identifier:
case NestedNameSpecifier::Namespace:
case NestedNameSpecifier::NamespaceAlias:
case NestedNameSpecifier::Global:
case NestedNameSpecifier::Super:
  return false;

case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate:
  return Visit(QualType(NNS->getAsType(), 0));
}
llvm_unreachable("Invalid NestedNameSpecifier::Kind!")::llvm::llvm_unreachable_internal("Invalid NestedNameSpecifier::Kind!"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5354);
5355}

5357/// \brief Check a template argument against its corresponding
5358/// template type parameter.
5359///
5360/// This routine implements the semantics of C++ [temp.arg.type]. It
5361/// returns true if an error occurred, and false otherwise.
5362bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param,
                               TypeSourceInfo *ArgInfo) {
assert(ArgInfo && "invalid TypeSourceInfo")(static_cast <bool> (ArgInfo && "invalid TypeSourceInfo"
) ? void (0) : __assert_fail ("ArgInfo && \"invalid TypeSourceInfo\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5364, __extension__ __PRETTY_FUNCTION__));
QualType Arg = ArgInfo->getType();
SourceRange SR = ArgInfo->getTypeLoc().getSourceRange();

if (Arg->isVariablyModifiedType()) {
  return Diag(SR.getBegin(), diag::err_variably_modified_template_arg) << Arg;
} else if (Context.hasSameUnqualifiedType(Arg, Context.OverloadTy)) {
  return Diag(SR.getBegin(), diag::err_template_arg_overload_type) << SR;
}

// C++03 [temp.arg.type]p2:
//   A local type, a type with no linkage, an unnamed type or a type
//   compounded from any of these types shall not be used as a
//   template-argument for a template type-parameter.
//
// C++11 allows these, and even in C++03 we allow them as an extension with
// a warning.
if (LangOpts.CPlusPlus11 || Arg->hasUnnamedOrLocalType()) {
  UnnamedLocalNoLinkageFinder Finder(*this, SR);
  (void)Finder.Visit(Context.getCanonicalType(Arg));
}

return false;
5387}

5389enum NullPointerValueKind {
NPV_NotNullPointer,
NPV_NullPointer,
NPV_Error
5393};

5395/// \brief Determine whether the given template argument is a null pointer
5396/// value of the appropriate type.
5397static NullPointerValueKind
5398isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param,
                                 QualType ParamType, Expr *Arg,
                                 Decl *Entity = nullptr) {
if (Arg->isValueDependent() || Arg->isTypeDependent())
  return NPV_NotNullPointer;

// dllimport'd entities aren't constant but are available inside of template
// arguments.
if (Entity && Entity->hasAttr<DLLImportAttr>())
  return NPV_NotNullPointer;

if (!S.isCompleteType(Arg->getExprLoc(), ParamType))
  llvm_unreachable(::llvm::llvm_unreachable_internal("Incomplete parameter type in isNullPointerValueTemplateArgument!"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5411)
      "Incomplete parameter type in isNullPointerValueTemplateArgument!")::llvm::llvm_unreachable_internal("Incomplete parameter type in isNullPointerValueTemplateArgument!"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5411);

if (!S.getLangOpts().CPlusPlus11)
  return NPV_NotNullPointer;

// Determine whether we have a constant expression.
ExprResult ArgRV = S.DefaultFunctionArrayConversion(Arg);
if (ArgRV.isInvalid())
  return NPV_Error;
Arg = ArgRV.get();

Expr::EvalResult EvalResult;
SmallVector<PartialDiagnosticAt, 8> Notes;
EvalResult.Diag = &Notes;
if (!Arg->EvaluateAsRValue(EvalResult, S.Context) ||
    EvalResult.HasSideEffects) {
  SourceLocation DiagLoc = Arg->getExprLoc();

  // If our only note is the usual "invalid subexpression" note, just point
  // the caret at its location rather than producing an essentially
  // redundant note.
  if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
      diag::note_invalid_subexpr_in_const_expr) {
    DiagLoc = Notes[0].first;
    Notes.clear();
  }

  S.Diag(DiagLoc, diag::err_template_arg_not_address_constant)
    << Arg->getType() << Arg->getSourceRange();
  for (unsigned I = 0, N = Notes.size(); I != N; ++I)
    S.Diag(Notes[I].first, Notes[I].second);

  S.Diag(Param->getLocation(), diag::note_template_param_here);
  return NPV_Error;
}

// C++11 [temp.arg.nontype]p1:
//   - an address constant expression of type std::nullptr_t
if (Arg->getType()->isNullPtrType())
  return NPV_NullPointer;

//   - a constant expression that evaluates to a null pointer value (4.10); or
//   - a constant expression that evaluates to a null member pointer value
//     (4.11); or
if ((EvalResult.Val.isLValue() && !EvalResult.Val.getLValueBase()) ||
    (EvalResult.Val.isMemberPointer() &&
     !EvalResult.Val.getMemberPointerDecl())) {
  // If our expression has an appropriate type, we've succeeded.
  bool ObjCLifetimeConversion;
  if (S.Context.hasSameUnqualifiedType(Arg->getType(), ParamType) ||
      S.IsQualificationConversion(Arg->getType(), ParamType, false,
                                   ObjCLifetimeConversion))
    return NPV_NullPointer;

  // The types didn't match, but we know we got a null pointer; complain,
  // then recover as if the types were correct.
  S.Diag(Arg->getExprLoc(), diag::err_template_arg_wrongtype_null_constant)
    << Arg->getType() << ParamType << Arg->getSourceRange();
  S.Diag(Param->getLocation(), diag::note_template_param_here);
  return NPV_NullPointer;
}

// If we don't have a null pointer value, but we do have a NULL pointer
// constant, suggest a cast to the appropriate type.
if (Arg->isNullPointerConstant(S.Context, Expr::NPC_NeverValueDependent)) {
  std::string Code = "static_cast<" + ParamType.getAsString() + ">(";
  S.Diag(Arg->getExprLoc(), diag::err_template_arg_untyped_null_constant)
      << ParamType << FixItHint::CreateInsertion(Arg->getLocStart(), Code)
      << FixItHint::CreateInsertion(S.getLocForEndOfToken(Arg->getLocEnd()),
                                    ")");
  S.Diag(Param->getLocation(), diag::note_template_param_here);
  return NPV_NullPointer;
}

// FIXME: If we ever want to support general, address-constant expressions
// as non-type template arguments, we should return the ExprResult here to
// be interpreted by the caller.
return NPV_NotNullPointer;
5489}

5491/// \brief Checks whether the given template argument is compatible with its
5492/// template parameter.
5493static bool CheckTemplateArgumentIsCompatibleWithParameter(
  Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn,
  Expr *Arg, QualType ArgType) {
bool ObjCLifetimeConversion;
if (ParamType->isPointerType() &&
    !ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType() &&
    S.IsQualificationConversion(ArgType, ParamType, false,
                                ObjCLifetimeConversion)) {
  // For pointer-to-object types, qualification conversions are
  // permitted.
} else {
  if (const ReferenceType *ParamRef = ParamType->getAs<ReferenceType>()) {
    if (!ParamRef->getPointeeType()->isFunctionType()) {
      // C++ [temp.arg.nontype]p5b3:
      //   For a non-type template-parameter of type reference to
      //   object, no conversions apply. The type referred to by the
      //   reference may be more cv-qualified than the (otherwise
      //   identical) type of the template- argument. The
      //   template-parameter is bound directly to the
      //   template-argument, which shall be an lvalue.

      // FIXME: Other qualifiers?
      unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();
      unsigned ArgQuals = ArgType.getCVRQualifiers();

      if ((ParamQuals | ArgQuals) != ParamQuals) {
        S.Diag(Arg->getLocStart(),
               diag::err_template_arg_ref_bind_ignores_quals)
          << ParamType << Arg->getType() << Arg->getSourceRange();
        S.Diag(Param->getLocation(), diag::note_template_param_here);
        return true;
      }
    }
  }

  // At this point, the template argument refers to an object or
  // function with external linkage. We now need to check whether the
  // argument and parameter types are compatible.
  if (!S.Context.hasSameUnqualifiedType(ArgType,
                                        ParamType.getNonReferenceType())) {
    // We can't perform this conversion or binding.
    if (ParamType->isReferenceType())
      S.Diag(Arg->getLocStart(), diag::err_template_arg_no_ref_bind)
        << ParamType << ArgIn->getType() << Arg->getSourceRange();
    else
      S.Diag(Arg->getLocStart(),  diag::err_template_arg_not_convertible)
        << ArgIn->getType() << ParamType << Arg->getSourceRange();
    S.Diag(Param->getLocation(), diag::note_template_param_here);
    return true;
  }
}

return false;
5546}

5548/// \brief Checks whether the given template argument is the address
5549/// of an object or function according to C++ [temp.arg.nontype]p1.
5550static bool
5551CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S,
                                             NonTypeTemplateParmDecl *Param,
                                             QualType ParamType,
                                             Expr *ArgIn,
                                             TemplateArgument &Converted) {
bool Invalid = false;
Expr *Arg = ArgIn;
QualType ArgType = Arg->getType();

bool AddressTaken = false;
SourceLocation AddrOpLoc;
if (S.getLangOpts().MicrosoftExt) {
  // Microsoft Visual C++ strips all casts, allows an arbitrary number of
  // dereference and address-of operators.
  Arg = Arg->IgnoreParenCasts();

  bool ExtWarnMSTemplateArg = false;
  UnaryOperatorKind FirstOpKind;
  SourceLocation FirstOpLoc;
  while (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
    UnaryOperatorKind UnOpKind = UnOp->getOpcode();
    if (UnOpKind == UO_Deref)
      ExtWarnMSTemplateArg = true;
    if (UnOpKind == UO_AddrOf || UnOpKind == UO_Deref) {
      Arg = UnOp->getSubExpr()->IgnoreParenCasts();
      if (!AddrOpLoc.isValid()) {
        FirstOpKind = UnOpKind;
        FirstOpLoc = UnOp->getOperatorLoc();
      }
    } else
      break;
  }
  if (FirstOpLoc.isValid()) {
    if (ExtWarnMSTemplateArg)
      S.Diag(ArgIn->getLocStart(), diag::ext_ms_deref_template_argument)
        << ArgIn->getSourceRange();

    if (FirstOpKind == UO_AddrOf)
      AddressTaken = true;
    else if (Arg->getType()->isPointerType()) {
      // We cannot let pointers get dereferenced here, that is obviously not a
      // constant expression.
      assert(FirstOpKind == UO_Deref)(static_cast <bool> (FirstOpKind == UO_Deref) ? void (0
) : __assert_fail ("FirstOpKind == UO_Deref", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5593, __extension__ __PRETTY_FUNCTION__));
      S.Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
        << Arg->getSourceRange();
    }
  }
} else {
  // See through any implicit casts we added to fix the type.
  Arg = Arg->IgnoreImpCasts();

  // C++ [temp.arg.nontype]p1:
  //
  //   A template-argument for a non-type, non-template
  //   template-parameter shall be one of: [...]
  //
  //     -- the address of an object or function with external
  //        linkage, including function templates and function
  //        template-ids but excluding non-static class members,
  //        expressed as & id-expression where the & is optional if
  //        the name refers to a function or array, or if the
  //        corresponding template-parameter is a reference; or

  // In C++98/03 mode, give an extension warning on any extra parentheses.
  // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
  bool ExtraParens = false;
  while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
    if (!Invalid && !ExtraParens) {
      S.Diag(Arg->getLocStart(),
             S.getLangOpts().CPlusPlus11
                 ? diag::warn_cxx98_compat_template_arg_extra_parens
                 : diag::ext_template_arg_extra_parens)
          << Arg->getSourceRange();
      ExtraParens = true;
    }

    Arg = Parens->getSubExpr();
  }

  while (SubstNonTypeTemplateParmExpr *subst =
             dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
    Arg = subst->getReplacement()->IgnoreImpCasts();

  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
    if (UnOp->getOpcode() == UO_AddrOf) {
      Arg = UnOp->getSubExpr();
      AddressTaken = true;
      AddrOpLoc = UnOp->getOperatorLoc();
    }
  }

  while (SubstNonTypeTemplateParmExpr *subst =
             dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
    Arg = subst->getReplacement()->IgnoreImpCasts();
}

DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg);
ValueDecl *Entity = DRE ? DRE->getDecl() : nullptr;

// If our parameter has pointer type, check for a null template value.
if (ParamType->isPointerType() || ParamType->isNullPtrType()) {
  switch (isNullPointerValueTemplateArgument(S, Param, ParamType, ArgIn,
                                             Entity)) {
  case NPV_NullPointer:
    S.Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
    Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
                                 /*isNullPtr=*/true);
    return false;

  case NPV_Error:
    return true;

  case NPV_NotNullPointer:
    break;
  }
}

// Stop checking the precise nature of the argument if it is value dependent,
// it should be checked when instantiated.
if (Arg->isValueDependent()) {
  Converted = TemplateArgument(ArgIn);
  return false;
}

if (isa<CXXUuidofExpr>(Arg)) {
  if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType,
                                                     ArgIn, Arg, ArgType))
    return true;

  Converted = TemplateArgument(ArgIn);
  return false;
}

if (!DRE) {
  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
  << Arg->getSourceRange();
  S.Diag(Param->getLocation(), diag::note_template_param_here);
  return true;
}

// Cannot refer to non-static data members
if (isa<FieldDecl>(Entity) || isa<IndirectFieldDecl>(Entity)) {
  S.Diag(Arg->getLocStart(), diag::err_template_arg_field)
    << Entity << Arg->getSourceRange();
  S.Diag(Param->getLocation(), diag::note_template_param_here);
  return true;
}

// Cannot refer to non-static member functions
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Entity)) {
  if (!Method->isStatic()) {
    S.Diag(Arg->getLocStart(), diag::err_template_arg_method)
      << Method << Arg->getSourceRange();
    S.Diag(Param->getLocation(), diag::note_template_param_here);
    return true;
  }
}

FunctionDecl *Func = dyn_cast<FunctionDecl>(Entity);
VarDecl *Var = dyn_cast<VarDecl>(Entity);

// A non-type template argument must refer to an object or function.
if (!Func && !Var) {
  // We found something, but we don't know specifically what it is.
  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_object_or_func)
    << Arg->getSourceRange();
  S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
  return true;
}

// Address / reference template args must have external linkage in C++98.
if (Entity->getFormalLinkage() == InternalLinkage) {
  S.Diag(Arg->getLocStart(), S.getLangOpts().CPlusPlus11 ?
           diag::warn_cxx98_compat_template_arg_object_internal :
           diag::ext_template_arg_object_internal)
    << !Func << Entity << Arg->getSourceRange();
  S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
    << !Func;
} else if (!Entity->hasLinkage()) {
  S.Diag(Arg->getLocStart(), diag::err_template_arg_object_no_linkage)
    << !Func << Entity << Arg->getSourceRange();
  S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
    << !Func;
  return true;
}

if (Func) {
  // If the template parameter has pointer type, the function decays.
  if (ParamType->isPointerType() && !AddressTaken)
    ArgType = S.Context.getPointerType(Func->getType());
  else if (AddressTaken && ParamType->isReferenceType()) {
    // If we originally had an address-of operator, but the
    // parameter has reference type, complain and (if things look
    // like they will work) drop the address-of operator.
    if (!S.Context.hasSameUnqualifiedType(Func->getType(),
                                          ParamType.getNonReferenceType())) {
      S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
        << ParamType;
      S.Diag(Param->getLocation(), diag::note_template_param_here);
      return true;
    }

    S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
      << ParamType
      << FixItHint::CreateRemoval(AddrOpLoc);
    S.Diag(Param->getLocation(), diag::note_template_param_here);

    ArgType = Func->getType();
  }
} else {
  // A value of reference type is not an object.
  if (Var->getType()->isReferenceType()) {
    S.Diag(Arg->getLocStart(),
           diag::err_template_arg_reference_var)
      << Var->getType() << Arg->getSourceRange();
    S.Diag(Param->getLocation(), diag::note_template_param_here);
    return true;
  }

  // A template argument must have static storage duration.
  if (Var->getTLSKind()) {
    S.Diag(Arg->getLocStart(), diag::err_template_arg_thread_local)
      << Arg->getSourceRange();
    S.Diag(Var->getLocation(), diag::note_template_arg_refers_here);
    return true;
  }

  // If the template parameter has pointer type, we must have taken
  // the address of this object.
  if (ParamType->isReferenceType()) {
    if (AddressTaken) {
      // If we originally had an address-of operator, but the
      // parameter has reference type, complain and (if things look
      // like they will work) drop the address-of operator.
      if (!S.Context.hasSameUnqualifiedType(Var->getType(),
                                          ParamType.getNonReferenceType())) {
        S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
          << ParamType;
        S.Diag(Param->getLocation(), diag::note_template_param_here);
        return true;
      }

      S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
        << ParamType
        << FixItHint::CreateRemoval(AddrOpLoc);
      S.Diag(Param->getLocation(), diag::note_template_param_here);

      ArgType = Var->getType();
    }
  } else if (!AddressTaken && ParamType->isPointerType()) {
    if (Var->getType()->isArrayType()) {
      // Array-to-pointer decay.
      ArgType = S.Context.getArrayDecayedType(Var->getType());
    } else {
      // If the template parameter has pointer type but the address of
      // this object was not taken, complain and (possibly) recover by
      // taking the address of the entity.
      ArgType = S.Context.getPointerType(Var->getType());
      if (!S.Context.hasSameUnqualifiedType(ArgType, ParamType)) {
        S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of)
          << ParamType;
        S.Diag(Param->getLocation(), diag::note_template_param_here);
        return true;
      }

      S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of)
        << ParamType
        << FixItHint::CreateInsertion(Arg->getLocStart(), "&");

      S.Diag(Param->getLocation(), diag::note_template_param_here);
    }
  }
}

if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType, ArgIn,
                                                   Arg, ArgType))
  return true;

// Create the template argument.
Converted =
    TemplateArgument(cast<ValueDecl>(Entity->getCanonicalDecl()), ParamType);
S.MarkAnyDeclReferenced(Arg->getLocStart(), Entity, false);
return false;
5834}

5836/// \brief Checks whether the given template argument is a pointer to
5837/// member constant according to C++ [temp.arg.nontype]p1.
5838static bool CheckTemplateArgumentPointerToMember(Sema &S,
                                               NonTypeTemplateParmDecl *Param,
                                               QualType ParamType,
                                               Expr *&ResultArg,
                                               TemplateArgument &Converted) {
bool Invalid = false;

Expr *Arg = ResultArg;
bool ObjCLifetimeConversion;

// C++ [temp.arg.nontype]p1:
//
//   A template-argument for a non-type, non-template
//   template-parameter shall be one of: [...]
//
//     -- a pointer to member expressed as described in 5.3.1.
DeclRefExpr *DRE = nullptr;

// In C++98/03 mode, give an extension warning on any extra parentheses.
// See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
bool ExtraParens = false;
while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
  if (!Invalid && !ExtraParens) {
    S.Diag(Arg->getLocStart(),
           S.getLangOpts().CPlusPlus11 ?
             diag::warn_cxx98_compat_template_arg_extra_parens :
             diag::ext_template_arg_extra_parens)
      << Arg->getSourceRange();
    ExtraParens = true;
  }

  Arg = Parens->getSubExpr();
}

while (SubstNonTypeTemplateParmExpr *subst =
         dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
  Arg = subst->getReplacement()->IgnoreImpCasts();

// A pointer-to-member constant written &Class::member.
if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
  if (UnOp->getOpcode() == UO_AddrOf) {
    DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr());
    if (DRE && !DRE->getQualifier())
      DRE = nullptr;
  }
}
// A constant of pointer-to-member type.
else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) {
  if (ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl())) {
    if (VD->getType()->isMemberPointerType()) {
      if (isa<NonTypeTemplateParmDecl>(VD)) {
        if (Arg->isTypeDependent() || Arg->isValueDependent()) {
          Converted = TemplateArgument(Arg);
        } else {
          VD = cast<ValueDecl>(VD->getCanonicalDecl());
          Converted = TemplateArgument(VD, ParamType);
        }
        return Invalid;
      }
    }
  }

  DRE = nullptr;
}

ValueDecl *Entity = DRE ? DRE->getDecl() : nullptr;

// Check for a null pointer value.
switch (isNullPointerValueTemplateArgument(S, Param, ParamType, ResultArg,
                                           Entity)) {
case NPV_Error:
  return true;
case NPV_NullPointer:
  S.Diag(ResultArg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
  Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
                               /*isNullPtr*/true);
  return false;
case NPV_NotNullPointer:
  break;
}

if (S.IsQualificationConversion(ResultArg->getType(),
                                ParamType.getNonReferenceType(), false,
                                ObjCLifetimeConversion)) {
  ResultArg = S.ImpCastExprToType(ResultArg, ParamType, CK_NoOp,
                                  ResultArg->getValueKind())
                  .get();
} else if (!S.Context.hasSameUnqualifiedType(
               ResultArg->getType(), ParamType.getNonReferenceType())) {
  // We can't perform this conversion.
  S.Diag(ResultArg->getLocStart(), diag::err_template_arg_not_convertible)
      << ResultArg->getType() << ParamType << ResultArg->getSourceRange();
  S.Diag(Param->getLocation(), diag::note_template_param_here);
  return true;
}

if (!DRE)
  return S.Diag(Arg->getLocStart(),
                diag::err_template_arg_not_pointer_to_member_form)
    << Arg->getSourceRange();

if (isa<FieldDecl>(DRE->getDecl()) ||
    isa<IndirectFieldDecl>(DRE->getDecl()) ||
    isa<CXXMethodDecl>(DRE->getDecl())) {
  assert((isa<FieldDecl>(DRE->getDecl()) ||(static_cast <bool> ((isa<FieldDecl>(DRE->getDecl
()) || isa<IndirectFieldDecl>(DRE->getDecl()) || !cast
<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&
 "Only non-static member pointers can make it here") ? void (
0) : __assert_fail ("(isa<FieldDecl>(DRE->getDecl()) || isa<IndirectFieldDecl>(DRE->getDecl()) || !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) && \"Only non-static member pointers can make it here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5945, __extension__ __PRETTY_FUNCTION__))
          isa<IndirectFieldDecl>(DRE->getDecl()) ||(static_cast <bool> ((isa<FieldDecl>(DRE->getDecl
()) || isa<IndirectFieldDecl>(DRE->getDecl()) || !cast
<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&
 "Only non-static member pointers can make it here") ? void (
0) : __assert_fail ("(isa<FieldDecl>(DRE->getDecl()) || isa<IndirectFieldDecl>(DRE->getDecl()) || !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) && \"Only non-static member pointers can make it here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5945, __extension__ __PRETTY_FUNCTION__))
          !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&(static_cast <bool> ((isa<FieldDecl>(DRE->getDecl
()) || isa<IndirectFieldDecl>(DRE->getDecl()) || !cast
<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&
 "Only non-static member pointers can make it here") ? void (
0) : __assert_fail ("(isa<FieldDecl>(DRE->getDecl()) || isa<IndirectFieldDecl>(DRE->getDecl()) || !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) && \"Only non-static member pointers can make it here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5945, __extension__ __PRETTY_FUNCTION__))
         "Only non-static member pointers can make it here")(static_cast <bool> ((isa<FieldDecl>(DRE->getDecl
()) || isa<IndirectFieldDecl>(DRE->getDecl()) || !cast
<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&
 "Only non-static member pointers can make it here") ? void (
0) : __assert_fail ("(isa<FieldDecl>(DRE->getDecl()) || isa<IndirectFieldDecl>(DRE->getDecl()) || !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) && \"Only non-static member pointers can make it here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5945, __extension__ __PRETTY_FUNCTION__));

  // Okay: this is the address of a non-static member, and therefore
  // a member pointer constant.
  if (Arg->isTypeDependent() || Arg->isValueDependent()) {
    Converted = TemplateArgument(Arg);
  } else {
    ValueDecl *D = cast<ValueDecl>(DRE->getDecl()->getCanonicalDecl());
    Converted = TemplateArgument(D, ParamType);
  }
  return Invalid;
}

// We found something else, but we don't know specifically what it is.
S.Diag(Arg->getLocStart(),
       diag::err_template_arg_not_pointer_to_member_form)
  << Arg->getSourceRange();
S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
return true;
5964}

5966/// \brief Check a template argument against its corresponding
5967/// non-type template parameter.
5968///
5969/// This routine implements the semantics of C++ [temp.arg.nontype].
5970/// If an error occurred, it returns ExprError(); otherwise, it
5971/// returns the converted template argument. \p ParamType is the
5972/// type of the non-type template parameter after it has been instantiated.
5973ExprResult Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
                                     QualType ParamType, Expr *Arg,
                                     TemplateArgument &Converted,
                                     CheckTemplateArgumentKind CTAK) {
SourceLocation StartLoc = Arg->getLocStart();

// If the parameter type somehow involves auto, deduce the type now.
if (getLangOpts().CPlusPlus17 && ParamType->isUndeducedType()) {
  // During template argument deduction, we allow 'decltype(auto)' to
  // match an arbitrary dependent argument.
  // FIXME: The language rules don't say what happens in this case.
  // FIXME: We get an opaque dependent type out of decltype(auto) if the
  // expression is merely instantiation-dependent; is this enough?
  if (CTAK == CTAK_Deduced && Arg->isTypeDependent()) {
    auto *AT = dyn_cast<AutoType>(ParamType);
    if (AT && AT->isDecltypeAuto()) {
      Converted = TemplateArgument(Arg);
      return Arg;
    }
  }

  // When checking a deduced template argument, deduce from its type even if
  // the type is dependent, in order to check the types of non-type template
  // arguments line up properly in partial ordering.
  Optional<unsigned> Depth;
  if (CTAK != CTAK_Specified)
    Depth = Param->getDepth() + 1;
  if (DeduceAutoType(
          Context.getTrivialTypeSourceInfo(ParamType, Param->getLocation()),
          Arg, ParamType, Depth) == DAR_Failed) {
    Diag(Arg->getExprLoc(),
         diag::err_non_type_template_parm_type_deduction_failure)
      << Param->getDeclName() << Param->getType() << Arg->getType()
      << Arg->getSourceRange();
    Diag(Param->getLocation(), diag::note_template_param_here);
    return ExprError();
  }
  // CheckNonTypeTemplateParameterType will produce a diagnostic if there's
  // an error. The error message normally references the parameter
  // declaration, but here we'll pass the argument location because that's
  // where the parameter type is deduced.
  ParamType = CheckNonTypeTemplateParameterType(ParamType, Arg->getExprLoc());
  if (ParamType.isNull()) {
    Diag(Param->getLocation(), diag::note_template_param_here);
    return ExprError();
  }
}

// We should have already dropped all cv-qualifiers by now.
assert(!ParamType.hasQualifiers() &&(static_cast <bool> (!ParamType.hasQualifiers() &&
 "non-type template parameter type cannot be qualified") ? void
 (0) : __assert_fail ("!ParamType.hasQualifiers() && \"non-type template parameter type cannot be qualified\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6023, __extension__ __PRETTY_FUNCTION__))
       "non-type template parameter type cannot be qualified")(static_cast <bool> (!ParamType.hasQualifiers() &&
 "non-type template parameter type cannot be qualified") ? void
 (0) : __assert_fail ("!ParamType.hasQualifiers() && \"non-type template parameter type cannot be qualified\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6023, __extension__ __PRETTY_FUNCTION__));

if (CTAK == CTAK_Deduced &&
    !Context.hasSameType(ParamType.getNonLValueExprType(Context),
                         Arg->getType())) {
  // FIXME: If either type is dependent, we skip the check. This isn't
  // correct, since during deduction we're supposed to have replaced each
  // template parameter with some unique (non-dependent) placeholder.
  // FIXME: If the argument type contains 'auto', we carry on and fail the
  // type check in order to force specific types to be more specialized than
  // 'auto'. It's not clear how partial ordering with 'auto' is supposed to
  // work.
  if ((ParamType->isDependentType() || Arg->isTypeDependent()) &&
      !Arg->getType()->getContainedAutoType()) {
    Converted = TemplateArgument(Arg);
    return Arg;
  }
  // FIXME: This attempts to implement C++ [temp.deduct.type]p17. Per DR1770,
  // we should actually be checking the type of the template argument in P,
  // not the type of the template argument deduced from A, against the
  // template parameter type.
  Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)
    << Arg->getType()
    << ParamType.getUnqualifiedType();
  Diag(Param->getLocation(), diag::note_template_param_here);
  return ExprError();
}

// If either the parameter has a dependent type or the argument is
// type-dependent, there's nothing we can check now.
if (ParamType->isDependentType() || Arg->isTypeDependent()) {
  // FIXME: Produce a cloned, canonical expression?
  Converted = TemplateArgument(Arg);
  return Arg;
}

// The initialization of the parameter from the argument is
// a constant-evaluated context.
EnterExpressionEvaluationContext ConstantEvaluated(
    *this, Sema::ExpressionEvaluationContext::ConstantEvaluated);

if (getLangOpts().CPlusPlus17) {
  // C++17 [temp.arg.nontype]p1:
  //   A template-argument for a non-type template parameter shall be
  //   a converted constant expression of the type of the template-parameter.
  APValue Value;
  ExprResult ArgResult = CheckConvertedConstantExpression(
      Arg, ParamType, Value, CCEK_TemplateArg);
  if (ArgResult.isInvalid())
    return ExprError();

  // For a value-dependent argument, CheckConvertedConstantExpression is
  // permitted (and expected) to be unable to determine a value.
  if (ArgResult.get()->isValueDependent()) {
    Converted = TemplateArgument(ArgResult.get());
    return ArgResult;
  }

  QualType CanonParamType = Context.getCanonicalType(ParamType);

  // Convert the APValue to a TemplateArgument.
  switch (Value.getKind()) {
  case APValue::Uninitialized:
    assert(ParamType->isNullPtrType())(static_cast <bool> (ParamType->isNullPtrType()) ? void
 (0) : __assert_fail ("ParamType->isNullPtrType()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6086, __extension__ __PRETTY_FUNCTION__));
    Converted = TemplateArgument(CanonParamType, /*isNullPtr*/true);
    break;
  case APValue::Int:
    assert(ParamType->isIntegralOrEnumerationType())(static_cast <bool> (ParamType->isIntegralOrEnumerationType
()) ? void (0) : __assert_fail ("ParamType->isIntegralOrEnumerationType()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6090, __extension__ __PRETTY_FUNCTION__));
    Converted = TemplateArgument(Context, Value.getInt(), CanonParamType);
    break;
  case APValue::MemberPointer: {
    assert(ParamType->isMemberPointerType())(static_cast <bool> (ParamType->isMemberPointerType(
)) ? void (0) : __assert_fail ("ParamType->isMemberPointerType()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6094, __extension__ __PRETTY_FUNCTION__));

    // FIXME: We need TemplateArgument representation and mangling for these.
    if (!Value.getMemberPointerPath().empty()) {
      Diag(Arg->getLocStart(),
           diag::err_template_arg_member_ptr_base_derived_not_supported)
          << Value.getMemberPointerDecl() << ParamType
          << Arg->getSourceRange();
      return ExprError();
    }

    auto *VD = const_cast<ValueDecl*>(Value.getMemberPointerDecl());
    Converted = VD ? TemplateArgument(VD, CanonParamType)
                   : TemplateArgument(CanonParamType, /*isNullPtr*/true);
    break;
  }
  case APValue::LValue: {
    //   For a non-type template-parameter of pointer or reference type,
    //   the value of the constant expression shall not refer to
    assert(ParamType->isPointerType() || ParamType->isReferenceType() ||(static_cast <bool> (ParamType->isPointerType() || ParamType
->isReferenceType() || ParamType->isNullPtrType()) ? void
 (0) : __assert_fail ("ParamType->isPointerType() || ParamType->isReferenceType() || ParamType->isNullPtrType()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6114, __extension__ __PRETTY_FUNCTION__))
           ParamType->isNullPtrType())(static_cast <bool> (ParamType->isPointerType() || ParamType
->isReferenceType() || ParamType->isNullPtrType()) ? void
 (0) : __assert_fail ("ParamType->isPointerType() || ParamType->isReferenceType() || ParamType->isNullPtrType()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6114, __extension__ __PRETTY_FUNCTION__));
    // -- a temporary object
    // -- a string literal
    // -- the result of a typeid expression, or
    // -- a predefined __func__ variable
    if (auto *E = Value.getLValueBase().dyn_cast<const Expr*>()) {
      if (isa<CXXUuidofExpr>(E)) {
        Converted = TemplateArgument(const_cast<Expr*>(E));
        break;
      }
      Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
        << Arg->getSourceRange();
      return ExprError();
    }
    auto *VD = const_cast<ValueDecl *>(
        Value.getLValueBase().dyn_cast<const ValueDecl *>());
    // -- a subobject
    if (Value.hasLValuePath() && Value.getLValuePath().size() == 1 &&
        VD && VD->getType()->isArrayType() &&
        Value.getLValuePath()[0].ArrayIndex == 0 &&
        !Value.isLValueOnePastTheEnd() && ParamType->isPointerType()) {
      // Per defect report (no number yet):
      //   ... other than a pointer to the first element of a complete array
      //       object.
    } else if (!Value.hasLValuePath() || Value.getLValuePath().size() ||
               Value.isLValueOnePastTheEnd()) {
      Diag(StartLoc, diag::err_non_type_template_arg_subobject)
        << Value.getAsString(Context, ParamType);
      return ExprError();
    }
    assert((VD || !ParamType->isReferenceType()) &&(static_cast <bool> ((VD || !ParamType->isReferenceType
()) && "null reference should not be a constant expression"
) ? void (0) : __assert_fail ("(VD || !ParamType->isReferenceType()) && \"null reference should not be a constant expression\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6145, __extension__ __PRETTY_FUNCTION__))
           "null reference should not be a constant expression")(static_cast <bool> ((VD || !ParamType->isReferenceType
()) && "null reference should not be a constant expression"
) ? void (0) : __assert_fail ("(VD || !ParamType->isReferenceType()) && \"null reference should not be a constant expression\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6145, __extension__ __PRETTY_FUNCTION__));
    assert((!VD || !ParamType->isNullPtrType()) &&(static_cast <bool> ((!VD || !ParamType->isNullPtrType
()) && "non-null value of type nullptr_t?") ? void (0
) : __assert_fail ("(!VD || !ParamType->isNullPtrType()) && \"non-null value of type nullptr_t?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6147, __extension__ __PRETTY_FUNCTION__))
           "non-null value of type nullptr_t?")(static_cast <bool> ((!VD || !ParamType->isNullPtrType
()) && "non-null value of type nullptr_t?") ? void (0
) : __assert_fail ("(!VD || !ParamType->isNullPtrType()) && \"non-null value of type nullptr_t?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6147, __extension__ __PRETTY_FUNCTION__));
    Converted = VD ? TemplateArgument(VD, CanonParamType)
                   : TemplateArgument(CanonParamType, /*isNullPtr*/true);
    break;
  }
  case APValue::AddrLabelDiff:
    return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
  case APValue::Float:
  case APValue::ComplexInt:
  case APValue::ComplexFloat:
  case APValue::Vector:
  case APValue::Array:
  case APValue::Struct:
  case APValue::Union:
    llvm_unreachable("invalid kind for template argument")::llvm::llvm_unreachable_internal("invalid kind for template argument"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6161);
  }

  return ArgResult.get();
}

// C++ [temp.arg.nontype]p5:
//   The following conversions are performed on each expression used
//   as a non-type template-argument. If a non-type
//   template-argument cannot be converted to the type of the
//   corresponding template-parameter then the program is
//   ill-formed.
if (ParamType->isIntegralOrEnumerationType()) {
  // C++11:
  //   -- for a non-type template-parameter of integral or
  //      enumeration type, conversions permitted in a converted
  //      constant expression are applied.
  //
  // C++98:
  //   -- for a non-type template-parameter of integral or
  //      enumeration type, integral promotions (4.5) and integral
  //      conversions (4.7) are applied.

  if (getLangOpts().CPlusPlus11) {
    // C++ [temp.arg.nontype]p1:
    //   A template-argument for a non-type, non-template template-parameter
    //   shall be one of:
    //
    //     -- for a non-type template-parameter of integral or enumeration
    //        type, a converted constant expression of the type of the
    //        template-parameter; or
    llvm::APSInt Value;
    ExprResult ArgResult =
      CheckConvertedConstantExpression(Arg, ParamType, Value,
                                       CCEK_TemplateArg);
    if (ArgResult.isInvalid())
      return ExprError();

    // We can't check arbitrary value-dependent arguments.
    if (ArgResult.get()->isValueDependent()) {
      Converted = TemplateArgument(ArgResult.get());
      return ArgResult;
    }

    // Widen the argument value to sizeof(parameter type). This is almost
    // always a no-op, except when the parameter type is bool. In
    // that case, this may extend the argument from 1 bit to 8 bits.
    QualType IntegerType = ParamType;
    if (const EnumType *Enum = IntegerType->getAs<EnumType>())
      IntegerType = Enum->getDecl()->getIntegerType();
    Value = Value.extOrTrunc(Context.getTypeSize(IntegerType));

    Converted = TemplateArgument(Context, Value,
                                 Context.getCanonicalType(ParamType));
    return ArgResult;
  }

  ExprResult ArgResult = DefaultLvalueConversion(Arg);
  if (ArgResult.isInvalid())
    return ExprError();
  Arg = ArgResult.get();

  QualType ArgType = Arg->getType();

  // C++ [temp.arg.nontype]p1:
  //   A template-argument for a non-type, non-template
  //   template-parameter shall be one of:
  //
  //     -- an integral constant-expression of integral or enumeration
  //        type; or
  //     -- the name of a non-type template-parameter; or
  llvm::APSInt Value;
  if (!ArgType->isIntegralOrEnumerationType()) {
    Diag(Arg->getLocStart(),
         diag::err_template_arg_not_integral_or_enumeral)
      << ArgType << Arg->getSourceRange();
    Diag(Param->getLocation(), diag::note_template_param_here);
    return ExprError();
  } else if (!Arg->isValueDependent()) {
    class TmplArgICEDiagnoser : public VerifyICEDiagnoser {
      QualType T;

    public:
      TmplArgICEDiagnoser(QualType T) : T(T) { }

      void diagnoseNotICE(Sema &S, SourceLocation Loc,
                          SourceRange SR) override {
        S.Diag(Loc, diag::err_template_arg_not_ice) << T << SR;
      }
    } Diagnoser(ArgType);

    Arg = VerifyIntegerConstantExpression(Arg, &Value, Diagnoser,
                                          false).get();
    if (!Arg)
      return ExprError();
  }

  // From here on out, all we care about is the unqualified form
  // of the argument type.
  ArgType = ArgType.getUnqualifiedType();

  // Try to convert the argument to the parameter's type.
  if (Context.hasSameType(ParamType, ArgType)) {
    // Okay: no conversion necessary
  } else if (ParamType->isBooleanType()) {
    // This is an integral-to-boolean conversion.
    Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralToBoolean).get();
  } else if (IsIntegralPromotion(Arg, ArgType, ParamType) ||
             !ParamType->isEnumeralType()) {
    // This is an integral promotion or conversion.
    Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralCast).get();
  } else {
    // We can't perform this conversion.
    Diag(Arg->getLocStart(),
         diag::err_template_arg_not_convertible)
      << Arg->getType() << ParamType << Arg->getSourceRange();
    Diag(Param->getLocation(), diag::note_template_param_here);
    return ExprError();
  }

  // Add the value of this argument to the list of converted
  // arguments. We use the bitwidth and signedness of the template
  // parameter.
  if (Arg->isValueDependent()) {
    // The argument is value-dependent. Create a new
    // TemplateArgument with the converted expression.
    Converted = TemplateArgument(Arg);
    return Arg;
  }

  QualType IntegerType = Context.getCanonicalType(ParamType);
  if (const EnumType *Enum = IntegerType->getAs<EnumType>())
    IntegerType = Context.getCanonicalType(Enum->getDecl()->getIntegerType());

  if (ParamType->isBooleanType()) {
    // Value must be zero or one.
    Value = Value != 0;
    unsigned AllowedBits = Context.getTypeSize(IntegerType);
    if (Value.getBitWidth() != AllowedBits)
      Value = Value.extOrTrunc(AllowedBits);
    Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
  } else {
    llvm::APSInt OldValue = Value;

    // Coerce the template argument's value to the value it will have
    // based on the template parameter's type.
    unsigned AllowedBits = Context.getTypeSize(IntegerType);
    if (Value.getBitWidth() != AllowedBits)
      Value = Value.extOrTrunc(AllowedBits);
    Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());

    // Complain if an unsigned parameter received a negative value.
    if (IntegerType->isUnsignedIntegerOrEnumerationType()
             && (OldValue.isSigned() && OldValue.isNegative())) {
      Diag(Arg->getLocStart(), diag::warn_template_arg_negative)
        << OldValue.toString(10) << Value.toString(10) << Param->getType()
        << Arg->getSourceRange();
      Diag(Param->getLocation(), diag::note_template_param_here);
    }

    // Complain if we overflowed the template parameter's type.
    unsigned RequiredBits;
    if (IntegerType->isUnsignedIntegerOrEnumerationType())
      RequiredBits = OldValue.getActiveBits();
    else if (OldValue.isUnsigned())
      RequiredBits = OldValue.getActiveBits() + 1;
    else
      RequiredBits = OldValue.getMinSignedBits();
    if (RequiredBits > AllowedBits) {
      Diag(Arg->getLocStart(),
           diag::warn_template_arg_too_large)
        << OldValue.toString(10) << Value.toString(10) << Param->getType()
        << Arg->getSourceRange();
      Diag(Param->getLocation(), diag::note_template_param_here);
    }
  }

  Converted = TemplateArgument(Context, Value,
                               ParamType->isEnumeralType()
                                 ? Context.getCanonicalType(ParamType)
                                 : IntegerType);
  return Arg;
}

QualType ArgType = Arg->getType();
DeclAccessPair FoundResult; // temporary for ResolveOverloadedFunction

// Handle pointer-to-function, reference-to-function, and
// pointer-to-member-function all in (roughly) the same way.
if (// -- For a non-type template-parameter of type pointer to
    //    function, only the function-to-pointer conversion (4.3) is
    //    applied. If the template-argument represents a set of
    //    overloaded functions (or a pointer to such), the matching
    //    function is selected from the set (13.4).
    (ParamType->isPointerType() &&
     ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType()) ||
    // -- For a non-type template-parameter of type reference to
    //    function, no conversions apply. If the template-argument
    //    represents a set of overloaded functions, the matching
    //    function is selected from the set (13.4).
    (ParamType->isReferenceType() &&
     ParamType->getAs<ReferenceType>()->getPointeeType()->isFunctionType()) ||
    // -- For a non-type template-parameter of type pointer to
    //    member function, no conversions apply. If the
    //    template-argument represents a set of overloaded member
    //    functions, the matching member function is selected from
    //    the set (13.4).
    (ParamType->isMemberPointerType() &&
     ParamType->getAs<MemberPointerType>()->getPointeeType()
       ->isFunctionType())) {

  if (Arg->getType() == Context.OverloadTy) {
    if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg, ParamType,
                                                              true,
                                                              FoundResult)) {
      if (DiagnoseUseOfDecl(Fn, Arg->getLocStart()))
        return ExprError();

      Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
      ArgType = Arg->getType();
    } else
      return ExprError();
  }

  if (!ParamType->isMemberPointerType()) {
    if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
                                                       ParamType,
                                                       Arg, Converted))
      return ExprError();
    return Arg;
  }

  if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
                                           Converted))
    return ExprError();
  return Arg;
}

if (ParamType->isPointerType()) {
  //   -- for a non-type template-parameter of type pointer to
  //      object, qualification conversions (4.4) and the
  //      array-to-pointer conversion (4.2) are applied.
  // C++0x also allows a value of std::nullptr_t.
  assert(ParamType->getPointeeType()->isIncompleteOrObjectType() &&(static_cast <bool> (ParamType->getPointeeType()->
isIncompleteOrObjectType() && "Only object pointers allowed here"
) ? void (0) : __assert_fail ("ParamType->getPointeeType()->isIncompleteOrObjectType() && \"Only object pointers allowed here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6405, __extension__ __PRETTY_FUNCTION__))
         "Only object pointers allowed here")(static_cast <bool> (ParamType->getPointeeType()->
isIncompleteOrObjectType() && "Only object pointers allowed here"
) ? void (0) : __assert_fail ("ParamType->getPointeeType()->isIncompleteOrObjectType() && \"Only object pointers allowed here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6405, __extension__ __PRETTY_FUNCTION__));

  if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
                                                     ParamType,
                                                     Arg, Converted))
    return ExprError();
  return Arg;
}

if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) {
  //   -- For a non-type template-parameter of type reference to
  //      object, no conversions apply. The type referred to by the
  //      reference may be more cv-qualified than the (otherwise
  //      identical) type of the template-argument. The
  //      template-parameter is bound directly to the
  //      template-argument, which must be an lvalue.
  assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&(static_cast <bool> (ParamRefType->getPointeeType()->
isIncompleteOrObjectType() && "Only object references allowed here"
) ? void (0) : __assert_fail ("ParamRefType->getPointeeType()->isIncompleteOrObjectType() && \"Only object references allowed here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6422, __extension__ __PRETTY_FUNCTION__))
         "Only object references allowed here")(static_cast <bool> (ParamRefType->getPointeeType()->
isIncompleteOrObjectType() && "Only object references allowed here"
) ? void (0) : __assert_fail ("ParamRefType->getPointeeType()->isIncompleteOrObjectType() && \"Only object references allowed here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6422, __extension__ __PRETTY_FUNCTION__));

  if (Arg->getType() == Context.OverloadTy) {
    if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg,
                                               ParamRefType->getPointeeType(),
                                                              true,
                                                              FoundResult)) {
      if (DiagnoseUseOfDecl(Fn, Arg->getLocStart()))
        return ExprError();

      Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
      ArgType = Arg->getType();
    } else
      return ExprError();
  }

  if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
                                                     ParamType,
                                                     Arg, Converted))
    return ExprError();
  return Arg;
}

// Deal with parameters of type std::nullptr_t.
if (ParamType->isNullPtrType()) {
  if (Arg->isTypeDependent() || Arg->isValueDependent()) {
    Converted = TemplateArgument(Arg);
    return Arg;
  }

  switch (isNullPointerValueTemplateArgument(*this, Param, ParamType, Arg)) {
  case NPV_NotNullPointer:
    Diag(Arg->getExprLoc(), diag::err_template_arg_not_convertible)
      << Arg->getType() << ParamType;
    Diag(Param->getLocation(), diag::note_template_param_here);
    return ExprError();

  case NPV_Error:
    return ExprError();

  case NPV_NullPointer:
    Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
    Converted = TemplateArgument(Context.getCanonicalType(ParamType),
                                 /*isNullPtr*/true);
    return Arg;
  }
}

//     -- For a non-type template-parameter of type pointer to data
//        member, qualification conversions (4.4) are applied.
assert(ParamType->isMemberPointerType() && "Only pointers to members remain")(static_cast <bool> (ParamType->isMemberPointerType(
) && "Only pointers to members remain") ? void (0) : __assert_fail
 ("ParamType->isMemberPointerType() && \"Only pointers to members remain\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6472, __extension__ __PRETTY_FUNCTION__));

if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
                                         Converted))
  return ExprError();
return Arg;
6478}

6480static void DiagnoseTemplateParameterListArityMismatch(
  Sema &S, TemplateParameterList *New, TemplateParameterList *Old,
  Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc);

6484/// \brief Check a template argument against its corresponding
6485/// template template parameter.
6486///
6487/// This routine implements the semantics of C++ [temp.arg.template].
6488/// It returns true if an error occurred, and false otherwise.
6489bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param,
                               TemplateArgumentLoc &Arg,
                               unsigned ArgumentPackIndex) {
TemplateName Name = Arg.getArgument().getAsTemplateOrTemplatePattern();
TemplateDecl *Template = Name.getAsTemplateDecl();
if (!Template) {
  // Any dependent template name is fine.
  assert(Name.isDependent() && "Non-dependent template isn't a declaration?")(static_cast <bool> (Name.isDependent() && "Non-dependent template isn't a declaration?"
) ? void (0) : __assert_fail ("Name.isDependent() && \"Non-dependent template isn't a declaration?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6496, __extension__ __PRETTY_FUNCTION__));
  return false;
}

if (Template->isInvalidDecl())
  return true;

// C++0x [temp.arg.template]p1:
//   A template-argument for a template template-parameter shall be
//   the name of a class template or an alias template, expressed as an
//   id-expression. When the template-argument names a class template, only
//   primary class templates are considered when matching the
//   template template argument with the corresponding parameter;
//   partial specializations are not considered even if their
//   parameter lists match that of the template template parameter.
//
// Note that we also allow template template parameters here, which
// will happen when we are dealing with, e.g., class template
// partial specializations.
if (!isa<ClassTemplateDecl>(Template) &&
    !isa<TemplateTemplateParmDecl>(Template) &&
    !isa<TypeAliasTemplateDecl>(Template) &&
    !isa<BuiltinTemplateDecl>(Template)) {
  assert(isa<FunctionTemplateDecl>(Template) &&(static_cast <bool> (isa<FunctionTemplateDecl>(Template
) && "Only function templates are possible here") ? void
 (0) : __assert_fail ("isa<FunctionTemplateDecl>(Template) && \"Only function templates are possible here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6520, __extension__ __PRETTY_FUNCTION__))
         "Only function templates are possible here")(static_cast <bool> (isa<FunctionTemplateDecl>(Template
) && "Only function templates are possible here") ? void
 (0) : __assert_fail ("isa<FunctionTemplateDecl>(Template) && \"Only function templates are possible here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6520, __extension__ __PRETTY_FUNCTION__));
  Diag(Arg.getLocation(), diag::err_template_arg_not_valid_template);
  Diag(Template->getLocation(), diag::note_template_arg_refers_here_func)
    << Template;
}

TemplateParameterList *Params = Param->getTemplateParameters();
if (Param->isExpandedParameterPack())
  Params = Param->getExpansionTemplateParameters(ArgumentPackIndex);

// C++1z [temp.arg.template]p3: (DR 150)
//   A template-argument matches a template template-parameter P when P
//   is at least as specialized as the template-argument A.
if (getLangOpts().RelaxedTemplateTemplateArgs) {
  // Quick check for the common case:
  //   If P contains a parameter pack, then A [...] matches P if each of A's
  //   template parameters matches the corresponding template parameter in
  //   the template-parameter-list of P.
  if (TemplateParameterListsAreEqual(
          Template->getTemplateParameters(), Params, false,
          TPL_TemplateTemplateArgumentMatch, Arg.getLocation()))
    return false;

  if (isTemplateTemplateParameterAtLeastAsSpecializedAs(Params, Template,
                                                        Arg.getLocation()))
    return false;
  // FIXME: Produce better diagnostics for deduction failures.
}

return !TemplateParameterListsAreEqual(Template->getTemplateParameters(),
                                       Params,
                                       true,
                                       TPL_TemplateTemplateArgumentMatch,
                                       Arg.getLocation());
6554}

6556/// \brief Given a non-type template argument that refers to a
6557/// declaration and the type of its corresponding non-type template
6558/// parameter, produce an expression that properly refers to that
6559/// declaration.
6560ExprResult
6561Sema::BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
                                            QualType ParamType,
                                            SourceLocation Loc) {
// C++ [temp.param]p8:
//
//   A non-type template-parameter of type "array of T" or
//   "function returning T" is adjusted to be of type "pointer to
//   T" or "pointer to function returning T", respectively.
if (ParamType->isArrayType())
  ParamType = Context.getArrayDecayedType(ParamType);
else if (ParamType->isFunctionType())
  ParamType = Context.getPointerType(ParamType);

// For a NULL non-type template argument, return nullptr casted to the
// parameter's type.
if (Arg.getKind() == TemplateArgument::NullPtr) {
  return ImpCastExprToType(
           new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc),
                           ParamType,
                           ParamType->getAs<MemberPointerType>()
                             ? CK_NullToMemberPointer
                             : CK_NullToPointer);
}
assert(Arg.getKind() == TemplateArgument::Declaration &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Declaration && "Only declaration template arguments permitted here"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Declaration && \"Only declaration template arguments permitted here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6585, __extension__ __PRETTY_FUNCTION__))
       "Only declaration template arguments permitted here")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Declaration && "Only declaration template arguments permitted here"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Declaration && \"Only declaration template arguments permitted here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6585, __extension__ __PRETTY_FUNCTION__));

ValueDecl *VD = cast<ValueDecl>(Arg.getAsDecl());

if (VD->getDeclContext()->isRecord() &&
    (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD) ||
     isa<IndirectFieldDecl>(VD))) {
  // If the value is a class member, we might have a pointer-to-member.
  // Determine whether the non-type template template parameter is of
  // pointer-to-member type. If so, we need to build an appropriate
  // expression for a pointer-to-member, since a "normal" DeclRefExpr
  // would refer to the member itself.
  if (ParamType->isMemberPointerType()) {
    QualType ClassType
      = Context.getTypeDeclType(cast<RecordDecl>(VD->getDeclContext()));
    NestedNameSpecifier *Qualifier
      = NestedNameSpecifier::Create(Context, nullptr, false,
                                    ClassType.getTypePtr());
    CXXScopeSpec SS;
    SS.MakeTrivial(Context, Qualifier, Loc);

    // The actual value-ness of this is unimportant, but for
    // internal consistency's sake, references to instance methods
    // are r-values.
    ExprValueKind VK = VK_LValue;
    if (isa<CXXMethodDecl>(VD) && cast<CXXMethodDecl>(VD)->isInstance())
      VK = VK_RValue;

    ExprResult RefExpr = BuildDeclRefExpr(VD,
                                          VD->getType().getNonReferenceType(),
                                          VK,
                                          Loc,
                                          &SS);
    if (RefExpr.isInvalid())
      return ExprError();

    RefExpr = CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());

    // We might need to perform a trailing qualification conversion, since
    // the element type on the parameter could be more qualified than the
    // element type in the expression we constructed.
    bool ObjCLifetimeConversion;
    if (IsQualificationConversion(((Expr*) RefExpr.get())->getType(),
                                  ParamType.getUnqualifiedType(), false,
                                  ObjCLifetimeConversion))
      RefExpr = ImpCastExprToType(RefExpr.get(), ParamType.getUnqualifiedType(), CK_NoOp);

    assert(!RefExpr.isInvalid() &&(static_cast <bool> (!RefExpr.isInvalid() && Context
.hasSameType(((Expr*) RefExpr.get())->getType(), ParamType
.getUnqualifiedType())) ? void (0) : __assert_fail ("!RefExpr.isInvalid() && Context.hasSameType(((Expr*) RefExpr.get())->getType(), ParamType.getUnqualifiedType())"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6634, __extension__ __PRETTY_FUNCTION__))
           Context.hasSameType(((Expr*) RefExpr.get())->getType(),(static_cast <bool> (!RefExpr.isInvalid() && Context
.hasSameType(((Expr*) RefExpr.get())->getType(), ParamType
.getUnqualifiedType())) ? void (0) : __assert_fail ("!RefExpr.isInvalid() && Context.hasSameType(((Expr*) RefExpr.get())->getType(), ParamType.getUnqualifiedType())"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6634, __extension__ __PRETTY_FUNCTION__))
                               ParamType.getUnqualifiedType()))(static_cast <bool> (!RefExpr.isInvalid() && Context
.hasSameType(((Expr*) RefExpr.get())->getType(), ParamType
.getUnqualifiedType())) ? void (0) : __assert_fail ("!RefExpr.isInvalid() && Context.hasSameType(((Expr*) RefExpr.get())->getType(), ParamType.getUnqualifiedType())"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6634, __extension__ __PRETTY_FUNCTION__));
    return RefExpr;
  }
}

QualType T = VD->getType().getNonReferenceType();

if (ParamType->isPointerType()) {
  // When the non-type template parameter is a pointer, take the
  // address of the declaration.
  ExprResult RefExpr = BuildDeclRefExpr(VD, T, VK_LValue, Loc);
  if (RefExpr.isInvalid())
    return ExprError();

  if (!Context.hasSameUnqualifiedType(ParamType->getPointeeType(), T) &&
      (T->isFunctionType() || T->isArrayType())) {
    // Decay functions and arrays unless we're forming a pointer to array.
    RefExpr = DefaultFunctionArrayConversion(RefExpr.get());
    if (RefExpr.isInvalid())
      return ExprError();

    return RefExpr;
  }

  // Take the address of everything else
  return CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
}

ExprValueKind VK = VK_RValue;

// If the non-type template parameter has reference type, qualify the
// resulting declaration reference with the extra qualifiers on the
// type that the reference refers to.
if (const ReferenceType *TargetRef = ParamType->getAs<ReferenceType>()) {
  VK = VK_LValue;
  T = Context.getQualifiedType(T,
                            TargetRef->getPointeeType().getQualifiers());
} else if (isa<FunctionDecl>(VD)) {
  // References to functions are always lvalues.
  VK = VK_LValue;
}

return BuildDeclRefExpr(VD, T, VK, Loc);
6677}

6679/// \brief Construct a new expression that refers to the given
6680/// integral template argument with the given source-location
6681/// information.
6682///
6683/// This routine takes care of the mapping from an integral template
6684/// argument (which may have any integral type) to the appropriate
6685/// literal value.
6686ExprResult
6687Sema::BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
                                                SourceLocation Loc) {
assert(Arg.getKind() == TemplateArgument::Integral &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Integral && "Operation is only valid for integral template arguments"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Integral && \"Operation is only valid for integral template arguments\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6690, __extension__ __PRETTY_FUNCTION__))
       "Operation is only valid for integral template arguments")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Integral && "Operation is only valid for integral template arguments"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Integral && \"Operation is only valid for integral template arguments\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6690, __extension__ __PRETTY_FUNCTION__));
QualType OrigT = Arg.getIntegralType();

// If this is an enum type that we're instantiating, we need to use an integer
// type the same size as the enumerator.  We don't want to build an
// IntegerLiteral with enum type.  The integer type of an enum type can be of
// any integral type with C++11 enum classes, make sure we create the right
// type of literal for it.
QualType T = OrigT;
if (const EnumType *ET = OrigT->getAs<EnumType>())
  T = ET->getDecl()->getIntegerType();

Expr *E;
if (T->isAnyCharacterType()) {
  // This does not need to handle u8 character literals because those are
  // of type char, and so can also be covered by an ASCII character literal.
  CharacterLiteral::CharacterKind Kind;
  if (T->isWideCharType())
    Kind = CharacterLiteral::Wide;
  else if (T->isChar16Type())
    Kind = CharacterLiteral::UTF16;
  else if (T->isChar32Type())
    Kind = CharacterLiteral::UTF32;
  else
    Kind = CharacterLiteral::Ascii;

  E = new (Context) CharacterLiteral(Arg.getAsIntegral().getZExtValue(),
                                     Kind, T, Loc);
} else if (T->isBooleanType()) {
  E = new (Context) CXXBoolLiteralExpr(Arg.getAsIntegral().getBoolValue(),
                                       T, Loc);
} else if (T->isNullPtrType()) {
  E = new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc);
} else {
  E = IntegerLiteral::Create(Context, Arg.getAsIntegral(), T, Loc);
}

if (OrigT->isEnumeralType()) {
  // FIXME: This is a hack. We need a better way to handle substituted
  // non-type template parameters.
  E = CStyleCastExpr::Create(Context, OrigT, VK_RValue, CK_IntegralCast, E,
                             nullptr,
                             Context.getTrivialTypeSourceInfo(OrigT, Loc),
                             Loc, Loc);
}

return E;
6737}

6739/// \brief Match two template parameters within template parameter lists.
6740static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, NamedDecl *Old,
                                     bool Complain,
                                   Sema::TemplateParameterListEqualKind Kind,
                                     SourceLocation TemplateArgLoc) {
// Check the actual kind (type, non-type, template).
if (Old->getKind() != New->getKind()) {
  if (Complain) {
    unsigned NextDiag = diag::err_template_param_different_kind;
    if (TemplateArgLoc.isValid()) {
      S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
      NextDiag = diag::note_template_param_different_kind;
    }
    S.Diag(New->getLocation(), NextDiag)
      << (Kind != Sema::TPL_TemplateMatch);
    S.Diag(Old->getLocation(), diag::note_template_prev_declaration)
      << (Kind != Sema::TPL_TemplateMatch);
  }

  return false;
}

// Check that both are parameter packs or neither are parameter packs.
// However, if we are matching a template template argument to a
// template template parameter, the template template parameter can have
// a parameter pack where the template template argument does not.
if (Old->isTemplateParameterPack() != New->isTemplateParameterPack() &&
    !(Kind == Sema::TPL_TemplateTemplateArgumentMatch &&
      Old->isTemplateParameterPack())) {
  if (Complain) {
    unsigned NextDiag = diag::err_template_parameter_pack_non_pack;
    if (TemplateArgLoc.isValid()) {
      S.Diag(TemplateArgLoc,
           diag::err_template_arg_template_params_mismatch);
      NextDiag = diag::note_template_parameter_pack_non_pack;
    }

    unsigned ParamKind = isa<TemplateTypeParmDecl>(New)? 0
                    : isa<NonTypeTemplateParmDecl>(New)? 1
                    : 2;
    S.Diag(New->getLocation(), NextDiag)
      << ParamKind << New->isParameterPack();
    S.Diag(Old->getLocation(), diag::note_template_parameter_pack_here)
      << ParamKind << Old->isParameterPack();
  }

  return false;
}

// For non-type template parameters, check the type of the parameter.
if (NonTypeTemplateParmDecl *OldNTTP
                                  = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
  NonTypeTemplateParmDecl *NewNTTP = cast<NonTypeTemplateParmDecl>(New);

  // If we are matching a template template argument to a template
  // template parameter and one of the non-type template parameter types
  // is dependent, then we must wait until template instantiation time
  // to actually compare the arguments.
  if (Kind == Sema::TPL_TemplateTemplateArgumentMatch &&
      (OldNTTP->getType()->isDependentType() ||
       NewNTTP->getType()->isDependentType()))
    return true;

  if (!S.Context.hasSameType(OldNTTP->getType(), NewNTTP->getType())) {
    if (Complain) {
      unsigned NextDiag = diag::err_template_nontype_parm_different_type;
      if (TemplateArgLoc.isValid()) {
        S.Diag(TemplateArgLoc,
               diag::err_template_arg_template_params_mismatch);
        NextDiag = diag::note_template_nontype_parm_different_type;
      }
      S.Diag(NewNTTP->getLocation(), NextDiag)
        << NewNTTP->getType()
        << (Kind != Sema::TPL_TemplateMatch);
      S.Diag(OldNTTP->getLocation(),
             diag::note_template_nontype_parm_prev_declaration)
        << OldNTTP->getType();
    }

    return false;
  }

  return true;
}

// For template template parameters, check the template parameter types.
// The template parameter lists of template template
// parameters must agree.
if (TemplateTemplateParmDecl *OldTTP
                                  = dyn_cast<TemplateTemplateParmDecl>(Old)) {
  TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(New);
  return S.TemplateParameterListsAreEqual(NewTTP->getTemplateParameters(),
                                          OldTTP->getTemplateParameters(),
                                          Complain,
                                      (Kind == Sema::TPL_TemplateMatch
                                         ? Sema::TPL_TemplateTemplateParmMatch
                                         : Kind),
                                          TemplateArgLoc);
}

return true;
6840}

6842/// \brief Diagnose a known arity mismatch when comparing template argument
6843/// lists.
6844static
6845void DiagnoseTemplateParameterListArityMismatch(Sema &S,
                                              TemplateParameterList *New,
                                              TemplateParameterList *Old,
                                    Sema::TemplateParameterListEqualKind Kind,
                                              SourceLocation TemplateArgLoc) {
unsigned NextDiag = diag::err_template_param_list_different_arity;
if (TemplateArgLoc.isValid()) {
  S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
  NextDiag = diag::note_template_param_list_different_arity;
}
S.Diag(New->getTemplateLoc(), NextDiag)
  << (New->size() > Old->size())
  << (Kind != Sema::TPL_TemplateMatch)
  << SourceRange(New->getTemplateLoc(), New->getRAngleLoc());
S.Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration)
  << (Kind != Sema::TPL_TemplateMatch)
  << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc());
6862}

6864/// \brief Determine whether the given template parameter lists are
6865/// equivalent.
6866///
6867/// \param New  The new template parameter list, typically written in the
6868/// source code as part of a new template declaration.
6869///
6870/// \param Old  The old template parameter list, typically found via
6871/// name lookup of the template declared with this template parameter
6872/// list.
6873///
6874/// \param Complain  If true, this routine will produce a diagnostic if
6875/// the template parameter lists are not equivalent.
6876///
6877/// \param Kind describes how we are to match the template parameter lists.
6878///
6879/// \param TemplateArgLoc If this source location is valid, then we
6880/// are actually checking the template parameter list of a template
6881/// argument (New) against the template parameter list of its
6882/// corresponding template template parameter (Old). We produce
6883/// slightly different diagnostics in this scenario.
6884///
6885/// \returns True if the template parameter lists are equal, false
6886/// otherwise.
6887bool
6888Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
                                   TemplateParameterList *Old,
                                   bool Complain,
                                   TemplateParameterListEqualKind Kind,
                                   SourceLocation TemplateArgLoc) {
if (Old->size() != New->size() && Kind != TPL_TemplateTemplateArgumentMatch) {
  if (Complain)
    DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
                                               TemplateArgLoc);

  return false;
}

// C++0x [temp.arg.template]p3:
//   A template-argument matches a template template-parameter (call it P)
//   when each of the template parameters in the template-parameter-list of
//   the template-argument's corresponding class template or alias template
//   (call it A) matches the corresponding template parameter in the
//   template-parameter-list of P. [...]
TemplateParameterList::iterator NewParm = New->begin();
TemplateParameterList::iterator NewParmEnd = New->end();
for (TemplateParameterList::iterator OldParm = Old->begin(),
                                  OldParmEnd = Old->end();
     OldParm != OldParmEnd; ++OldParm) {
  if (Kind != TPL_TemplateTemplateArgumentMatch ||
      !(*OldParm)->isTemplateParameterPack()) {
    if (NewParm == NewParmEnd) {
      if (Complain)
        DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
                                                   TemplateArgLoc);

      return false;
    }

    if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
                                    Kind, TemplateArgLoc))
      return false;

    ++NewParm;
    continue;
  }

  // C++0x [temp.arg.template]p3:
  //   [...] When P's template- parameter-list contains a template parameter
  //   pack (14.5.3), the template parameter pack will match zero or more
  //   template parameters or template parameter packs in the
  //   template-parameter-list of A with the same type and form as the
  //   template parameter pack in P (ignoring whether those template
  //   parameters are template parameter packs).
  for (; NewParm != NewParmEnd; ++NewParm) {
    if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
                                    Kind, TemplateArgLoc))
      return false;
  }
}

// Make sure we exhausted all of the arguments.
if (NewParm != NewParmEnd) {
  if (Complain)
    DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
                                               TemplateArgLoc);

  return false;
}

return true;
6954}

6956/// \brief Check whether a template can be declared within this scope.
6957///
6958/// If the template declaration is valid in this scope, returns
6959/// false. Otherwise, issues a diagnostic and returns true.
6960bool
6961Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) {
if (!S)
  return false;

// Find the nearest enclosing declaration scope.
while ((S->getFlags() & Scope::DeclScope) == 0 ||
       (S->getFlags() & Scope::TemplateParamScope) != 0)
  S = S->getParent();

// C++ [temp]p4:
//   A template [...] shall not have C linkage.
DeclContext *Ctx = S->getEntity();
if (Ctx && Ctx->isExternCContext()) {
  Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage)
      << TemplateParams->getSourceRange();
  if (const LinkageSpecDecl *LSD = Ctx->getExternCContext())
    Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
  return true;
}
Ctx = Ctx->getRedeclContext();

// C++ [temp]p2:
//   A template-declaration can appear only as a namespace scope or
//   class scope declaration.
if (Ctx) {
  if (Ctx->isFileContext())
    return false;
  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Ctx)) {
    // C++ [temp.mem]p2:
    //   A local class shall not have member templates.
    if (RD->isLocalClass())
      return Diag(TemplateParams->getTemplateLoc(),
                  diag::err_template_inside_local_class)
        << TemplateParams->getSourceRange();
    else
      return false;
  }
}

return Diag(TemplateParams->getTemplateLoc(),
            diag::err_template_outside_namespace_or_class_scope)
  << TemplateParams->getSourceRange();
7003}

7005/// \brief Determine what kind of template specialization the given declaration
7006/// is.
7007static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D) {
if (!D)
  return TSK_Undeclared;

if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D))
  return Record->getTemplateSpecializationKind();
if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D))
  return Function->getTemplateSpecializationKind();
if (VarDecl *Var = dyn_cast<VarDecl>(D))
  return Var->getTemplateSpecializationKind();

return TSK_Undeclared;
7019}

7021/// \brief Check whether a specialization is well-formed in the current
7022/// context.
7023///
7024/// This routine determines whether a template specialization can be declared
7025/// in the current context (C++ [temp.expl.spec]p2).
7026///
7027/// \param S the semantic analysis object for which this check is being
7028/// performed.
7029///
7030/// \param Specialized the entity being specialized or instantiated, which
7031/// may be a kind of template (class template, function template, etc.) or
7032/// a member of a class template (member function, static data member,
7033/// member class).
7034///
7035/// \param PrevDecl the previous declaration of this entity, if any.
7036///
7037/// \param Loc the location of the explicit specialization or instantiation of
7038/// this entity.
7039///
7040/// \param IsPartialSpecialization whether this is a partial specialization of
7041/// a class template.
7042///
7043/// \returns true if there was an error that we cannot recover from, false
7044/// otherwise.
7045static bool CheckTemplateSpecializationScope(Sema &S,
                                           NamedDecl *Specialized,
                                           NamedDecl *PrevDecl,
                                           SourceLocation Loc,
                                           bool IsPartialSpecialization) {
// Keep these "kind" numbers in sync with the %select statements in the
// various diagnostics emitted by this routine.
int EntityKind = 0;
if (isa<ClassTemplateDecl>(Specialized))
  EntityKind = IsPartialSpecialization? 1 : 0;
else if (isa<VarTemplateDecl>(Specialized))
  EntityKind = IsPartialSpecialization ? 3 : 2;
else if (isa<FunctionTemplateDecl>(Specialized))
  EntityKind = 4;
else if (isa<CXXMethodDecl>(Specialized))
  EntityKind = 5;
else if (isa<VarDecl>(Specialized))
  EntityKind = 6;
else if (isa<RecordDecl>(Specialized))
  EntityKind = 7;
else if (isa<EnumDecl>(Specialized) && S.getLangOpts().CPlusPlus11)
  EntityKind = 8;
else {
  S.Diag(Loc, diag::err_template_spec_unknown_kind)
    << S.getLangOpts().CPlusPlus11;
  S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
  return true;
}

// C++ [temp.expl.spec]p2:
//   An explicit specialization shall be declared in the namespace
//   of which the template is a member, or, for member templates, in
//   the namespace of which the enclosing class or enclosing class
//   template is a member. An explicit specialization of a member
//   function, member class or static data member of a class
//   template shall be declared in the namespace of which the class
//   template is a member. Such a declaration may also be a
//   definition. If the declaration is not a definition, the
//   specialization may be defined later in the name- space in which
//   the explicit specialization was declared, or in a namespace
//   that encloses the one in which the explicit specialization was
//   declared.
if (S.CurContext->getRedeclContext()->isFunctionOrMethod()) {
  S.Diag(Loc, diag::err_template_spec_decl_function_scope)
    << Specialized;
  return true;
}

if (S.CurContext->isRecord() && !IsPartialSpecialization) {
  if (S.getLangOpts().MicrosoftExt) {
    // Do not warn for class scope explicit specialization during
    // instantiation, warning was already emitted during pattern
    // semantic analysis.
    if (!S.inTemplateInstantiation())
      S.Diag(Loc, diag::ext_function_specialization_in_class)
        << Specialized;
  } else {
    S.Diag(Loc, diag::err_template_spec_decl_class_scope)
      << Specialized;
    return true;
  }
}

if (S.CurContext->isRecord() &&
    !S.CurContext->Equals(Specialized->getDeclContext())) {
  // Make sure that we're specializing in the right record context.
  // Otherwise, things can go horribly wrong.
  S.Diag(Loc, diag::err_template_spec_decl_class_scope)
    << Specialized;
  return true;
}

// C++ [temp.class.spec]p6:
//   A class template partial specialization may be declared or redeclared
//   in any namespace scope in which its definition may be defined (14.5.1
//   and 14.5.2).
DeclContext *SpecializedContext
  = Specialized->getDeclContext()->getEnclosingNamespaceContext();
DeclContext *DC = S.CurContext->getEnclosingNamespaceContext();

// Make sure that this redeclaration (or definition) occurs in an enclosing
// namespace.
// Note that HandleDeclarator() performs this check for explicit
// specializations of function templates, static data members, and member
// functions, so we skip the check here for those kinds of entities.
// FIXME: HandleDeclarator's diagnostics aren't quite as good, though.
// Should we refactor that check, so that it occurs later?
if (!DC->Encloses(SpecializedContext) &&
    !(isa<FunctionTemplateDecl>(Specialized) ||
      isa<FunctionDecl>(Specialized) ||
      isa<VarTemplateDecl>(Specialized) ||
      isa<VarDecl>(Specialized))) {
  if (isa<TranslationUnitDecl>(SpecializedContext))
    S.Diag(Loc, diag::err_template_spec_redecl_global_scope)
      << EntityKind << Specialized;
  else if (isa<NamespaceDecl>(SpecializedContext)) {
    int Diag = diag::err_template_spec_redecl_out_of_scope;
    if (S.getLangOpts().MicrosoftExt)
      Diag = diag::ext_ms_template_spec_redecl_out_of_scope;
    S.Diag(Loc, Diag) << EntityKind << Specialized
                      << cast<NamedDecl>(SpecializedContext);
  } else
    llvm_unreachable("unexpected namespace context for specialization")::llvm::llvm_unreachable_internal("unexpected namespace context for specialization"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7147);

  S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
} else if ((!PrevDecl ||
            getTemplateSpecializationKind(PrevDecl) == TSK_Undeclared ||
            getTemplateSpecializationKind(PrevDecl) ==
                TSK_ImplicitInstantiation)) {
  // C++ [temp.exp.spec]p2:
  //   An explicit specialization shall be declared in the namespace of which
  //   the template is a member, or, for member templates, in the namespace
  //   of which the enclosing class or enclosing class template is a member.
  //   An explicit specialization of a member function, member class or
  //   static data member of a class template shall be declared in the
  //   namespace of which the class template is a member.
  //
  // C++11 [temp.expl.spec]p2:
  //   An explicit specialization shall be declared in a namespace enclosing
  //   the specialized template.
  // C++11 [temp.explicit]p3:
  //   An explicit instantiation shall appear in an enclosing namespace of its
  //   template.
  if (!DC->InEnclosingNamespaceSetOf(SpecializedContext)) {
    bool IsCPlusPlus11Extension = DC->Encloses(SpecializedContext);
    if (isa<TranslationUnitDecl>(SpecializedContext)) {
      assert(!IsCPlusPlus11Extension &&(static_cast <bool> (!IsCPlusPlus11Extension &&
 "DC encloses TU but isn't in enclosing namespace set") ? void
 (0) : __assert_fail ("!IsCPlusPlus11Extension && \"DC encloses TU but isn't in enclosing namespace set\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7172, __extension__ __PRETTY_FUNCTION__))
             "DC encloses TU but isn't in enclosing namespace set")(static_cast <bool> (!IsCPlusPlus11Extension &&
 "DC encloses TU but isn't in enclosing namespace set") ? void
 (0) : __assert_fail ("!IsCPlusPlus11Extension && \"DC encloses TU but isn't in enclosing namespace set\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7172, __extension__ __PRETTY_FUNCTION__));
      S.Diag(Loc, diag::err_template_spec_decl_out_of_scope_global)
        << EntityKind << Specialized;
    } else if (isa<NamespaceDecl>(SpecializedContext)) {
      int Diag;
      if (!IsCPlusPlus11Extension)
        Diag = diag::err_template_spec_decl_out_of_scope;
      else if (!S.getLangOpts().CPlusPlus11)
        Diag = diag::ext_template_spec_decl_out_of_scope;
      else
        Diag = diag::warn_cxx98_compat_template_spec_decl_out_of_scope;
      S.Diag(Loc, Diag)
        << EntityKind << Specialized << cast<NamedDecl>(SpecializedContext);
    }

    S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
  }
}

return false;
7192}

7194static SourceRange findTemplateParameterInType(unsigned Depth, Expr *E) {
if (!E->isTypeDependent())
  return SourceLocation();
DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
Checker.TraverseStmt(E);
if (Checker.MatchLoc.isInvalid())
  return E->getSourceRange();
return Checker.MatchLoc;
7202}

7204static SourceRange findTemplateParameter(unsigned Depth, TypeLoc TL) {
if (!TL.getType()->isDependentType())
  return SourceLocation();
DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
Checker.TraverseTypeLoc(TL);
if (Checker.MatchLoc.isInvalid())
  return TL.getSourceRange();
return Checker.MatchLoc;
7212}

7214/// \brief Subroutine of Sema::CheckTemplatePartialSpecializationArgs
7215/// that checks non-type template partial specialization arguments.
7216static bool CheckNonTypeTemplatePartialSpecializationArgs(
  Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param,
  const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument) {
for (unsigned I = 0; I != NumArgs; ++I) {
  if (Args[I].getKind() == TemplateArgument::Pack) {
    if (CheckNonTypeTemplatePartialSpecializationArgs(
            S, TemplateNameLoc, Param, Args[I].pack_begin(),
            Args[I].pack_size(), IsDefaultArgument))
      return true;

    continue;
  }

  if (Args[I].getKind() != TemplateArgument::Expression)
    continue;

  Expr *ArgExpr = Args[I].getAsExpr();

  // We can have a pack expansion of any of the bullets below.
  if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(ArgExpr))
    ArgExpr = Expansion->getPattern();

  // Strip off any implicit casts we added as part of type checking.
  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
    ArgExpr = ICE->getSubExpr();

  // C++ [temp.class.spec]p8:
  //   A non-type argument is non-specialized if it is the name of a
  //   non-type parameter. All other non-type arguments are
  //   specialized.
  //
  // Below, we check the two conditions that only apply to
  // specialized non-type arguments, so skip any non-specialized
  // arguments.
  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
    if (isa<NonTypeTemplateParmDecl>(DRE->getDecl()))
      continue;

  // C++ [temp.class.spec]p9:
  //   Within the argument list of a class template partial
  //   specialization, the following restrictions apply:
  //     -- A partially specialized non-type argument expression
  //        shall not involve a template parameter of the partial
  //        specialization except when the argument expression is a
  //        simple identifier.
  //     -- The type of a template parameter corresponding to a
  //        specialized non-type argument shall not be dependent on a
  //        parameter of the specialization.
  // DR1315 removes the first bullet, leaving an incoherent set of rules.
  // We implement a compromise between the original rules and DR1315:
  //     --  A specialized non-type template argument shall not be
  //         type-dependent and the corresponding template parameter
  //         shall have a non-dependent type.
  SourceRange ParamUseRange =
      findTemplateParameterInType(Param->getDepth(), ArgExpr);
  if (ParamUseRange.isValid()) {
    if (IsDefaultArgument) {
      S.Diag(TemplateNameLoc,
             diag::err_dependent_non_type_arg_in_partial_spec);
      S.Diag(ParamUseRange.getBegin(),
             diag::note_dependent_non_type_default_arg_in_partial_spec)
        << ParamUseRange;
    } else {
      S.Diag(ParamUseRange.getBegin(),
             diag::err_dependent_non_type_arg_in_partial_spec)
        << ParamUseRange;
    }
    return true;
  }

  ParamUseRange = findTemplateParameter(
      Param->getDepth(), Param->getTypeSourceInfo()->getTypeLoc());
  if (ParamUseRange.isValid()) {
    S.Diag(IsDefaultArgument ? TemplateNameLoc : ArgExpr->getLocStart(),
           diag::err_dependent_typed_non_type_arg_in_partial_spec)
      << Param->getType();
    S.Diag(Param->getLocation(), diag::note_template_param_here)
      << (IsDefaultArgument ? ParamUseRange : SourceRange())
      << ParamUseRange;
    return true;
  }
}

return false;
7300}

7302/// \brief Check the non-type template arguments of a class template
7303/// partial specialization according to C++ [temp.class.spec]p9.
7304///
7305/// \param TemplateNameLoc the location of the template name.
7306/// \param PrimaryTemplate the template parameters of the primary class
7307///        template.
7308/// \param NumExplicit the number of explicitly-specified template arguments.
7309/// \param TemplateArgs the template arguments of the class template
7310///        partial specialization.
7311///
7312/// \returns \c true if there was an error, \c false otherwise.
7313bool Sema::CheckTemplatePartialSpecializationArgs(
  SourceLocation TemplateNameLoc, TemplateDecl *PrimaryTemplate,
  unsigned NumExplicit, ArrayRef<TemplateArgument> TemplateArgs) {
// We have to be conservative when checking a template in a dependent
// context.
if (PrimaryTemplate->getDeclContext()->isDependentContext())
  return false;

TemplateParameterList *TemplateParams =
    PrimaryTemplate->getTemplateParameters();
for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
  NonTypeTemplateParmDecl *Param
    = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(I));
  if (!Param)
    continue;

  if (CheckNonTypeTemplatePartialSpecializationArgs(*this, TemplateNameLoc,
                                                    Param, &TemplateArgs[I],
                                                    1, I >= NumExplicit))
    return true;
}

return false;
7336}

7338DeclResult
7339Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
                                     TagUseKind TUK,
                                     SourceLocation KWLoc,
                                     SourceLocation ModulePrivateLoc,
                                     TemplateIdAnnotation &TemplateId,
                                     AttributeList *Attr,
                                     MultiTemplateParamsArg
                                         TemplateParameterLists,
                                     SkipBodyInfo *SkipBody) {
assert(TUK != TUK_Reference && "References are not specializations")(static_cast <bool> (TUK != TUK_Reference && "References are not specializations"
) ? void (0) : __assert_fail ("TUK != TUK_Reference && \"References are not specializations\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7348, __extension__ __PRETTY_FUNCTION__));

CXXScopeSpec &SS = TemplateId.SS;

// NOTE: KWLoc is the location of the tag keyword. This will instead
// store the location of the outermost template keyword in the declaration.
SourceLocation TemplateKWLoc = TemplateParameterLists.size() > 0
1
Assuming the condition is false→
2
←
'?' condition is false→
  ? TemplateParameterLists[0]->getTemplateLoc() : KWLoc;
SourceLocation TemplateNameLoc = TemplateId.TemplateNameLoc;
SourceLocation LAngleLoc = TemplateId.LAngleLoc;
SourceLocation RAngleLoc = TemplateId.RAngleLoc;

// Find the class template we're specializing
TemplateName Name = TemplateId.Template.get();
ClassTemplateDecl *ClassTemplate
  = dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl());

if (!ClassTemplate) {
3
←
Assuming 'ClassTemplate' is non-null→
4
←
Taking false branch→
  Diag(TemplateNameLoc, diag::err_not_class_template_specialization)
    << (Name.getAsTemplateDecl() &&
        isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()));
  return true;
}

bool isMemberSpecialization = false;
bool isPartialSpecialization = false;

// Check the validity of the template headers that introduce this
// template.
// FIXME: We probably shouldn't complain about these headers for
// friend declarations.
bool Invalid = false;
TemplateParameterList *TemplateParams =
    MatchTemplateParametersToScopeSpecifier(
        KWLoc, TemplateNameLoc, SS, &TemplateId,
        TemplateParameterLists, TUK == TUK_Friend, isMemberSpecialization,
5
←
Assuming 'TUK' is not equal to TUK_Friend→
        Invalid);
if (Invalid)
6
←
Assuming 'Invalid' is 0→
7
←
Taking false branch→
  return true;

if (TemplateParams && TemplateParams->size() > 0) {
8
←
Assuming 'TemplateParams' is non-null→
9
←
Assuming the condition is false→
10
←
Taking false branch→
  isPartialSpecialization = true;

  if (TUK == TUK_Friend) {
    Diag(KWLoc, diag::err_partial_specialization_friend)
      << SourceRange(LAngleLoc, RAngleLoc);
    return true;
  }

  // C++ [temp.class.spec]p10:
  //   The template parameter list of a specialization shall not
  //   contain default template argument values.
  for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
    Decl *Param = TemplateParams->getParam(I);
    if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
      if (TTP->hasDefaultArgument()) {
        Diag(TTP->getDefaultArgumentLoc(),
             diag::err_default_arg_in_partial_spec);
        TTP->removeDefaultArgument();
      }
    } else if (NonTypeTemplateParmDecl *NTTP
                 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
      if (Expr *DefArg = NTTP->getDefaultArgument()) {
        Diag(NTTP->getDefaultArgumentLoc(),
             diag::err_default_arg_in_partial_spec)
          << DefArg->getSourceRange();
        NTTP->removeDefaultArgument();
      }
    } else {
      TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Param);
      if (TTP->hasDefaultArgument()) {
        Diag(TTP->getDefaultArgument().getLocation(),
             diag::err_default_arg_in_partial_spec)
          << TTP->getDefaultArgument().getSourceRange();
        TTP->removeDefaultArgument();
      }
    }
  }
} else if (TemplateParams) {
11
←
Taking true branch→
  if (TUK == TUK_Friend)
12
←
Taking false branch→
    Diag(KWLoc, diag::err_template_spec_friend)
      << FixItHint::CreateRemoval(
                              SourceRange(TemplateParams->getTemplateLoc(),
                                          TemplateParams->getRAngleLoc()))
      << SourceRange(LAngleLoc, RAngleLoc);
} else {
  assert(TUK == TUK_Friend && "should have a 'template<>' for this decl")(static_cast <bool> (TUK == TUK_Friend && "should have a 'template<>' for this decl"
) ? void (0) : __assert_fail ("TUK == TUK_Friend && \"should have a 'template<>' for this decl\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7434, __extension__ __PRETTY_FUNCTION__));
}

// Check that the specialization uses the same tag kind as the
// original template.
TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
assert(Kind != TTK_Enum && "Invalid enum tag in class template spec!")(static_cast <bool> (Kind != TTK_Enum && "Invalid enum tag in class template spec!"
) ? void (0) : __assert_fail ("Kind != TTK_Enum && \"Invalid enum tag in class template spec!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7440, __extension__ __PRETTY_FUNCTION__));
if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
14
←
Assuming the condition is false→
15
←
Taking false branch→
                                  Kind, TUK == TUK_Definition, KWLoc,
13
←
Assuming 'TUK' is not equal to TUK_Definition→
                                  ClassTemplate->getIdentifier())) {
  Diag(KWLoc, diag::err_use_with_wrong_tag)
    << ClassTemplate
    << FixItHint::CreateReplacement(KWLoc,
                          ClassTemplate->getTemplatedDecl()->getKindName());
  Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
       diag::note_previous_use);
  Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
}

// Translate the parser's template argument list in our AST format.
TemplateArgumentListInfo TemplateArgs =
    makeTemplateArgumentListInfo(*this, TemplateId);

// Check for unexpanded parameter packs in any of the template arguments.
for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
16
←
Assuming 'I' is equal to 'N'→
17
←
Loop condition is false. Execution continues on line 7465→
  if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
                                      UPPC_PartialSpecialization))
    return true;

// Check that the template argument list is well-formed for this
// template.
SmallVector<TemplateArgument, 4> Converted;
if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
18
←
Taking false branch→
                              TemplateArgs, false, Converted))
  return true;

// Find the class template (partial) specialization declaration that
// corresponds to these arguments.
if (isPartialSpecialization) {
19
←
Taking false branch→
  if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, ClassTemplate,
                                             TemplateArgs.size(), Converted))
    return true;

  // FIXME: Move this to CheckTemplatePartialSpecializationArgs so we
  // also do it during instantiation.
  bool InstantiationDependent;
  if (!Name.isDependent() &&
      !TemplateSpecializationType::anyDependentTemplateArguments(
          TemplateArgs.arguments(), InstantiationDependent)) {
    Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
      << ClassTemplate->getDeclName();
    isPartialSpecialization = false;
  }
}

void *InsertPos = nullptr;
ClassTemplateSpecializationDecl *PrevDecl = nullptr;

if (isPartialSpecialization)
20
←
Taking false branch→
  // FIXME: Template parameter list matters, too
  PrevDecl = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
else
  PrevDecl = ClassTemplate->findSpecialization(Converted, InsertPos);

ClassTemplateSpecializationDecl *Specialization = nullptr;

// Check whether we can declare a class template specialization in
// the current scope.
if (TUK != TUK_Friend &&
21
←
Taking false branch→
    CheckTemplateSpecializationScope(*this, ClassTemplate, PrevDecl,
                                     TemplateNameLoc,
                                     isPartialSpecialization))
  return true;

// The canonical type
QualType CanonType;
if (isPartialSpecialization) {
22
←
Taking false branch→
  // Build the canonical type that describes the converted template
  // arguments of the class template partial specialization.
  TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
  CanonType = Context.getTemplateSpecializationType(CanonTemplate,
                                                    Converted);

  if (Context.hasSameType(CanonType,
                      ClassTemplate->getInjectedClassNameSpecialization())) {
    // C++ [temp.class.spec]p9b3:
    //
    //   -- The argument list of the specialization shall not be identical
    //      to the implicit argument list of the primary template.
    //
    // This rule has since been removed, because it's redundant given DR1495,
    // but we keep it because it produces better diagnostics and recovery.
    Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
      << /*class template*/0 << (TUK == TUK_Definition)
      << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
    return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS,
                              ClassTemplate->getIdentifier(),
                              TemplateNameLoc,
                              Attr,
                              TemplateParams,
                              AS_none, /*ModulePrivateLoc=*/SourceLocation(),
                              /*FriendLoc*/SourceLocation(),
                              TemplateParameterLists.size() - 1,
                              TemplateParameterLists.data());
  }

  // Create a new class template partial specialization declaration node.
  ClassTemplatePartialSpecializationDecl *PrevPartial
    = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
  ClassTemplatePartialSpecializationDecl *Partial
    = ClassTemplatePartialSpecializationDecl::Create(Context, Kind,
                                           ClassTemplate->getDeclContext(),
                                                     KWLoc, TemplateNameLoc,
                                                     TemplateParams,
                                                     ClassTemplate,
                                                     Converted,
                                                     TemplateArgs,
                                                     CanonType,
                                                     PrevPartial);
  SetNestedNameSpecifier(Partial, SS);
  if (TemplateParameterLists.size() > 1 && SS.isSet()) {
    Partial->setTemplateParameterListsInfo(
        Context, TemplateParameterLists.drop_back(1));
  }

  if (!PrevPartial)
    ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
  Specialization = Partial;

  // If we are providing an explicit specialization of a member class
  // template specialization, make a note of that.
  if (PrevPartial && PrevPartial->getInstantiatedFromMember())
    PrevPartial->setMemberSpecialization();

  CheckTemplatePartialSpecialization(Partial);
} else {
  // Create a new class template specialization declaration node for
  // this explicit specialization or friend declaration.
  Specialization
    = ClassTemplateSpecializationDecl::Create(Context, Kind,
                                           ClassTemplate->getDeclContext(),
                                              KWLoc, TemplateNameLoc,
                                              ClassTemplate,
                                              Converted,
                                              PrevDecl);
  SetNestedNameSpecifier(Specialization, SS);
  if (TemplateParameterLists.size() > 0) {
23
←
Assuming the condition is false→
24
←
Taking false branch→
    Specialization->setTemplateParameterListsInfo(Context,
                                                  TemplateParameterLists);
  }

  if (!PrevDecl)
25
←
Taking false branch→
    ClassTemplate->AddSpecialization(Specialization, InsertPos);

  if (CurContext->isDependentContext()) {
26
←
Assuming the condition is false→
27
←
Taking false branch→
    // -fms-extensions permits specialization of nested classes without
    // fully specializing the outer class(es).
    assert(getLangOpts().MicrosoftExt &&(static_cast <bool> (getLangOpts().MicrosoftExt &&
 "Only possible with -fms-extensions!") ? void (0) : __assert_fail
 ("getLangOpts().MicrosoftExt && \"Only possible with -fms-extensions!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7592, __extension__ __PRETTY_FUNCTION__))
           "Only possible with -fms-extensions!")(static_cast <bool> (getLangOpts().MicrosoftExt &&
 "Only possible with -fms-extensions!") ? void (0) : __assert_fail
 ("getLangOpts().MicrosoftExt && \"Only possible with -fms-extensions!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7592, __extension__ __PRETTY_FUNCTION__));
    TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
    CanonType = Context.getTemplateSpecializationType(
        CanonTemplate, Converted);
  } else {
    CanonType = Context.getTypeDeclType(Specialization);
28
←
Calling 'ASTContext::getTypeDeclType'→
33
←
Returning from 'ASTContext::getTypeDeclType'→
  }
}

// C++ [temp.expl.spec]p6:
//   If a template, a member template or the member of a class template is
//   explicitly specialized then that specialization shall be declared
//   before the first use of that specialization that would cause an implicit
//   instantiation to take place, in every translation unit in which such a
//   use occurs; no diagnostic is required.
if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
34
←
Taking false branch→
  bool Okay = false;
  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
    // Is there any previous explicit specialization declaration?
    if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
      Okay = true;
      break;
    }
  }

  if (!Okay) {
    SourceRange Range(TemplateNameLoc, RAngleLoc);
    Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
      << Context.getTypeDeclType(Specialization) << Range;

    Diag(PrevDecl->getPointOfInstantiation(),
         diag::note_instantiation_required_here)
      << (PrevDecl->getTemplateSpecializationKind()
                                              != TSK_ImplicitInstantiation);
    return true;
  }
}

// If this is not a friend, note that this is an explicit specialization.
if (TUK != TUK_Friend)
35
←
Taking true branch→
  Specialization->setSpecializationKind(TSK_ExplicitSpecialization);

// Check that this isn't a redefinition of this specialization.
if (TUK == TUK_Definition) {
36
←
Taking false branch→
  RecordDecl *Def = Specialization->getDefinition();
  NamedDecl *Hidden = nullptr;
  if (Def && SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
    SkipBody->ShouldSkip = true;
    makeMergedDefinitionVisible(Hidden);
    // From here on out, treat this as just a redeclaration.
    TUK = TUK_Declaration;
  } else if (Def) {
    SourceRange Range(TemplateNameLoc, RAngleLoc);
    Diag(TemplateNameLoc, diag::err_redefinition) << Specialization << Range;
    Diag(Def->getLocation(), diag::note_previous_definition);
    Specialization->setInvalidDecl();
    return true;
  }
}

if (Attr)
37
←
Assuming 'Attr' is null→
38
←
Taking false branch→
  ProcessDeclAttributeList(S, Specialization, Attr);

// Add alignment attributes if necessary; these attributes are checked when
// the ASTContext lays out the structure.
if (TUK == TUK_Definition) {
39
←
Taking false branch→
  AddAlignmentAttributesForRecord(Specialization);
  AddMsStructLayoutForRecord(Specialization);
}

if (ModulePrivateLoc.isValid())
40
←
Taking false branch→
  Diag(Specialization->getLocation(), diag::err_module_private_specialization)
    << (isPartialSpecialization? 1 : 0)
    << FixItHint::CreateRemoval(ModulePrivateLoc);

// Build the fully-sugared type for this class template
// specialization as the user wrote in the specialization
// itself. This means that we'll pretty-print the type retrieved
// from the specialization's declaration the way that the user
// actually wrote the specialization, rather than formatting the
// name based on the "canonical" representation used to store the
// template arguments in the specialization.
TypeSourceInfo *WrittenTy
  = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
                                              TemplateArgs, CanonType);
if (TUK != TUK_Friend) {
41
←
Taking true branch→
  Specialization->setTypeAsWritten(WrittenTy);
42
←
Calling 'ClassTemplateSpecializationDecl::setTypeAsWritten'→
  Specialization->setTemplateKeywordLoc(TemplateKWLoc);
}

// C++ [temp.expl.spec]p9:
//   A template explicit specialization is in the scope of the
//   namespace in which the template was defined.
//
// We actually implement this paragraph where we set the semantic
// context (in the creation of the ClassTemplateSpecializationDecl),
// but we also maintain the lexical context where the actual
// definition occurs.
Specialization->setLexicalDeclContext(CurContext);

// We may be starting the definition of this specialization.
if (TUK == TUK_Definition)
  Specialization->startDefinition();

if (TUK == TUK_Friend) {
  FriendDecl *Friend = FriendDecl::Create(Context, CurContext,
                                          TemplateNameLoc,
                                          WrittenTy,
                                          /*FIXME:*/KWLoc);
  Friend->setAccess(AS_public);
  CurContext->addDecl(Friend);
} else {
  // Add the specialization into its lexical context, so that it can
  // be seen when iterating through the list of declarations in that
  // context. However, specializations are not found by name lookup.
  CurContext->addDecl(Specialization);
}
return Specialization;
7710}

7712Decl *Sema::ActOnTemplateDeclarator(Scope *S,
                            MultiTemplateParamsArg TemplateParameterLists,
                                  Declarator &D) {
Decl *NewDecl = HandleDeclarator(S, D, TemplateParameterLists);
ActOnDocumentableDecl(NewDecl);
return NewDecl;
7718}

7720/// \brief Strips various properties off an implicit instantiation
7721/// that has just been explicitly specialized.
7722static void StripImplicitInstantiation(NamedDecl *D) {
D->dropAttr<DLLImportAttr>();
D->dropAttr<DLLExportAttr>();

if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
  FD->setInlineSpecified(false);
7728}

7730/// \brief Compute the diagnostic location for an explicit instantiation
7731//  declaration or definition.
7732static SourceLocation DiagLocForExplicitInstantiation(
  NamedDecl* D, SourceLocation PointOfInstantiation) {
// Explicit instantiations following a specialization have no effect and
// hence no PointOfInstantiation. In that case, walk decl backwards
// until a valid name loc is found.
SourceLocation PrevDiagLoc = PointOfInstantiation;
for (Decl *Prev = D; Prev && !PrevDiagLoc.isValid();
     Prev = Prev->getPreviousDecl()) {
  PrevDiagLoc = Prev->getLocation();
}
assert(PrevDiagLoc.isValid() &&(static_cast <bool> (PrevDiagLoc.isValid() && "Explicit instantiation without point of instantiation?"
) ? void (0) : __assert_fail ("PrevDiagLoc.isValid() && \"Explicit instantiation without point of instantiation?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7743, __extension__ __PRETTY_FUNCTION__))
       "Explicit instantiation without point of instantiation?")(static_cast <bool> (PrevDiagLoc.isValid() && "Explicit instantiation without point of instantiation?"
) ? void (0) : __assert_fail ("PrevDiagLoc.isValid() && \"Explicit instantiation without point of instantiation?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7743, __extension__ __PRETTY_FUNCTION__));
return PrevDiagLoc;
7745}

7747/// \brief Diagnose cases where we have an explicit template specialization
7748/// before/after an explicit template instantiation, producing diagnostics
7749/// for those cases where they are required and determining whether the
7750/// new specialization/instantiation will have any effect.
7751///
7752/// \param NewLoc the location of the new explicit specialization or
7753/// instantiation.
7754///
7755/// \param NewTSK the kind of the new explicit specialization or instantiation.
7756///
7757/// \param PrevDecl the previous declaration of the entity.
7758///
7759/// \param PrevTSK the kind of the old explicit specialization or instantiatin.
7760///
7761/// \param PrevPointOfInstantiation if valid, indicates where the previus
7762/// declaration was instantiated (either implicitly or explicitly).
7763///
7764/// \param HasNoEffect will be set to true to indicate that the new
7765/// specialization or instantiation has no effect and should be ignored.
7766///
7767/// \returns true if there was an error that should prevent the introduction of
7768/// the new declaration into the AST, false otherwise.
7769bool
7770Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
                                           TemplateSpecializationKind NewTSK,
                                           NamedDecl *PrevDecl,
                                           TemplateSpecializationKind PrevTSK,
                                      SourceLocation PrevPointOfInstantiation,
                                           bool &HasNoEffect) {
HasNoEffect = false;

switch (NewTSK) {
case TSK_Undeclared:
case TSK_ImplicitInstantiation:
  assert((static_cast <bool> ((PrevTSK == TSK_Undeclared || PrevTSK
 == TSK_ImplicitInstantiation) && "previous declaration must be implicit!"
) ? void (0) : __assert_fail ("(PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) && \"previous declaration must be implicit!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7783, __extension__ __PRETTY_FUNCTION__))
      (PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) &&(static_cast <bool> ((PrevTSK == TSK_Undeclared || PrevTSK
 == TSK_ImplicitInstantiation) && "previous declaration must be implicit!"
) ? void (0) : __assert_fail ("(PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) && \"previous declaration must be implicit!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7783, __extension__ __PRETTY_FUNCTION__))
      "previous declaration must be implicit!")(static_cast <bool> ((PrevTSK == TSK_Undeclared || PrevTSK
 == TSK_ImplicitInstantiation) && "previous declaration must be implicit!"
) ? void (0) : __assert_fail ("(PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) && \"previous declaration must be implicit!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7783, __extension__ __PRETTY_FUNCTION__));
  return false;

case TSK_ExplicitSpecialization:
  switch (PrevTSK) {
  case TSK_Undeclared:
  case TSK_ExplicitSpecialization:
    // Okay, we're just specializing something that is either already
    // explicitly specialized or has merely been mentioned without any
    // instantiation.
    return false;

  case TSK_ImplicitInstantiation:
    if (PrevPointOfInstantiation.isInvalid()) {
      // The declaration itself has not actually been instantiated, so it is
      // still okay to specialize it.
      StripImplicitInstantiation(PrevDecl);
      return false;
    }
    // Fall through
    LLVM_FALLTHROUGH[[clang::fallthrough]];

  case TSK_ExplicitInstantiationDeclaration:
  case TSK_ExplicitInstantiationDefinition:
    assert((PrevTSK == TSK_ImplicitInstantiation ||(static_cast <bool> ((PrevTSK == TSK_ImplicitInstantiation
 || PrevPointOfInstantiation.isValid()) && "Explicit instantiation without point of instantiation?"
) ? void (0) : __assert_fail ("(PrevTSK == TSK_ImplicitInstantiation || PrevPointOfInstantiation.isValid()) && \"Explicit instantiation without point of instantiation?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7809, __extension__ __PRETTY_FUNCTION__))
            PrevPointOfInstantiation.isValid()) &&(static_cast <bool> ((PrevTSK == TSK_ImplicitInstantiation
 || PrevPointOfInstantiation.isValid()) && "Explicit instantiation without point of instantiation?"
) ? void (0) : __assert_fail ("(PrevTSK == TSK_ImplicitInstantiation || PrevPointOfInstantiation.isValid()) && \"Explicit instantiation without point of instantiation?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7809, __extension__ __PRETTY_FUNCTION__))
           "Explicit instantiation without point of instantiation?")(static_cast <bool> ((PrevTSK == TSK_ImplicitInstantiation
 || PrevPointOfInstantiation.isValid()) && "Explicit instantiation without point of instantiation?"
) ? void (0) : __assert_fail ("(PrevTSK == TSK_ImplicitInstantiation || PrevPointOfInstantiation.isValid()) && \"Explicit instantiation without point of instantiation?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7809, __extension__ __PRETTY_FUNCTION__));

    // C++ [temp.expl.spec]p6:
    //   If a template, a member template or the member of a class template
    //   is explicitly specialized then that specialization shall be declared
    //   before the first use of that specialization that would cause an
    //   implicit instantiation to take place, in every translation unit in
    //   which such a use occurs; no diagnostic is required.
    for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
      // Is there any previous explicit specialization declaration?
      if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization)
        return false;
    }

    Diag(NewLoc, diag::err_specialization_after_instantiation)
      << PrevDecl;
    Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
      << (PrevTSK != TSK_ImplicitInstantiation);

    return true;
  }
  llvm_unreachable("The switch over PrevTSK must be exhaustive.")::llvm::llvm_unreachable_internal("The switch over PrevTSK must be exhaustive."
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7830);

case TSK_ExplicitInstantiationDeclaration:
  switch (PrevTSK) {
  case TSK_ExplicitInstantiationDeclaration:
    // This explicit instantiation declaration is redundant (that's okay).
    HasNoEffect = true;
    return false;

  case TSK_Undeclared:
  case TSK_ImplicitInstantiation:
    // We're explicitly instantiating something that may have already been
    // implicitly instantiated; that's fine.
    return false;

  case TSK_ExplicitSpecialization:
    // C++0x [temp.explicit]p4:
    //   For a given set of template parameters, if an explicit instantiation
    //   of a template appears after a declaration of an explicit
    //   specialization for that template, the explicit instantiation has no
    //   effect.
    HasNoEffect = true;
    return false;

  case TSK_ExplicitInstantiationDefinition:
    // C++0x [temp.explicit]p10:
    //   If an entity is the subject of both an explicit instantiation
    //   declaration and an explicit instantiation definition in the same
    //   translation unit, the definition shall follow the declaration.
    Diag(NewLoc,
         diag::err_explicit_instantiation_declaration_after_definition);

    // Explicit instantiations following a specialization have no effect and
    // hence no PrevPointOfInstantiation. In that case, walk decl backwards
    // until a valid name loc is found.
    Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
         diag::note_explicit_instantiation_definition_here);
    HasNoEffect = true;
    return false;
  }

case TSK_ExplicitInstantiationDefinition:
  switch (PrevTSK) {
  case TSK_Undeclared:
  case TSK_ImplicitInstantiation:
    // We're explicitly instantiating something that may have already been
    // implicitly instantiated; that's fine.
    return false;

  case TSK_ExplicitSpecialization:
    // C++ DR 259, C++0x [temp.explicit]p4:
    //   For a given set of template parameters, if an explicit
    //   instantiation of a template appears after a declaration of
    //   an explicit specialization for that template, the explicit
    //   instantiation has no effect.
    Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization)
      << PrevDecl;
    Diag(PrevDecl->getLocation(),
         diag::note_previous_template_specialization);
    HasNoEffect = true;
    return false;

  case TSK_ExplicitInstantiationDeclaration:
    // We're explicity instantiating a definition for something for which we
    // were previously asked to suppress instantiations. That's fine.

    // C++0x [temp.explicit]p4:
    //   For a given set of template parameters, if an explicit instantiation
    //   of a template appears after a declaration of an explicit
    //   specialization for that template, the explicit instantiation has no
    //   effect.
    for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
      // Is there any previous explicit specialization declaration?
      if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
        HasNoEffect = true;
        break;
      }
    }

    return false;

  case TSK_ExplicitInstantiationDefinition:
    // C++0x [temp.spec]p5:
    //   For a given template and a given set of template-arguments,
    //     - an explicit instantiation definition shall appear at most once
    //       in a program,

    // MSVCCompat: MSVC silently ignores duplicate explicit instantiations.
    Diag(NewLoc, (getLangOpts().MSVCCompat)
                     ? diag::ext_explicit_instantiation_duplicate
                     : diag::err_explicit_instantiation_duplicate)
        << PrevDecl;
    Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
         diag::note_previous_explicit_instantiation);
    HasNoEffect = true;
    return false;
  }
}

llvm_unreachable("Missing specialization/instantiation case?")::llvm::llvm_unreachable_internal("Missing specialization/instantiation case?"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7929);
7930}

7932/// \brief Perform semantic analysis for the given dependent function
7933/// template specialization.
7934///
7935/// The only possible way to get a dependent function template specialization
7936/// is with a friend declaration, like so:
7937///
7938/// \code
7939///   template \<class T> void foo(T);
7940///   template \<class T> class A {
7941///     friend void foo<>(T);
7942///   };
7943/// \endcode
7944///
7945/// There really isn't any useful analysis we can do here, so we
7946/// just store the information.
7947bool
7948Sema::CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,
                 const TemplateArgumentListInfo &ExplicitTemplateArgs,
                                                 LookupResult &Previous) {
// Remove anything from Previous that isn't a function template in
// the correct context.
DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
LookupResult::Filter F = Previous.makeFilter();
while (F.hasNext()) {
  NamedDecl *D = F.next()->getUnderlyingDecl();
  if (!isa<FunctionTemplateDecl>(D) ||
      !FDLookupContext->InEnclosingNamespaceSetOf(
                            D->getDeclContext()->getRedeclContext()))
    F.erase();
}
F.done();

// Should this be diagnosed here?
if (Previous.empty()) return true;

FD->setDependentTemplateSpecialization(Context, Previous.asUnresolvedSet(),
                                       ExplicitTemplateArgs);
return false;
7970}

7972/// \brief Perform semantic analysis for the given function template
7973/// specialization.
7974///
7975/// This routine performs all of the semantic analysis required for an
7976/// explicit function template specialization. On successful completion,
7977/// the function declaration \p FD will become a function template
7978/// specialization.
7979///
7980/// \param FD the function declaration, which will be updated to become a
7981/// function template specialization.
7982///
7983/// \param ExplicitTemplateArgs the explicitly-provided template arguments,
7984/// if any. Note that this may be valid info even when 0 arguments are
7985/// explicitly provided as in, e.g., \c void sort<>(char*, char*);
7986/// as it anyway contains info on the angle brackets locations.
7987///
7988/// \param Previous the set of declarations that may be specialized by
7989/// this function specialization.
7990bool Sema::CheckFunctionTemplateSpecialization(
  FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,
  LookupResult &Previous) {
// The set of function template specializations that could match this
// explicit function template specialization.
UnresolvedSet<8> Candidates;
TemplateSpecCandidateSet FailedCandidates(FD->getLocation(),
                                          /*ForTakingAddress=*/false);

llvm::SmallDenseMap<FunctionDecl *, TemplateArgumentListInfo, 8>
    ConvertedTemplateArgs;

DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
       I != E; ++I) {
  NamedDecl *Ovl = (*I)->getUnderlyingDecl();
  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Ovl)) {
    // Only consider templates found within the same semantic lookup scope as
    // FD.
    if (!FDLookupContext->InEnclosingNamespaceSetOf(
                              Ovl->getDeclContext()->getRedeclContext()))
      continue;

    // When matching a constexpr member function template specialization
    // against the primary template, we don't yet know whether the
    // specialization has an implicit 'const' (because we don't know whether
    // it will be a static member function until we know which template it
    // specializes), so adjust it now assuming it specializes this template.
    QualType FT = FD->getType();
    if (FD->isConstexpr()) {
      CXXMethodDecl *OldMD =
        dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
      if (OldMD && OldMD->isConst()) {
        const FunctionProtoType *FPT = FT->castAs<FunctionProtoType>();
        FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
        EPI.TypeQuals |= Qualifiers::Const;
        FT = Context.getFunctionType(FPT->getReturnType(),
                                     FPT->getParamTypes(), EPI);
      }
    }

    TemplateArgumentListInfo Args;
    if (ExplicitTemplateArgs)
      Args = *ExplicitTemplateArgs;

    // C++ [temp.expl.spec]p11:
    //   A trailing template-argument can be left unspecified in the
    //   template-id naming an explicit function template specialization
    //   provided it can be deduced from the function argument type.
    // Perform template argument deduction to determine whether we may be
    // specializing this template.
    // FIXME: It is somewhat wasteful to build
    TemplateDeductionInfo Info(FailedCandidates.getLocation());
    FunctionDecl *Specialization = nullptr;
    if (TemplateDeductionResult TDK = DeduceTemplateArguments(
            cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),
            ExplicitTemplateArgs ? &Args : nullptr, FT, Specialization,
            Info)) {
      // Template argument deduction failed; record why it failed, so
      // that we can provide nifty diagnostics.
      FailedCandidates.addCandidate().set(
          I.getPair(), FunTmpl->getTemplatedDecl(),
          MakeDeductionFailureInfo(Context, TDK, Info));
      (void)TDK;
      continue;
    }

    // Target attributes are part of the cuda function signature, so
    // the deduced template's cuda target must match that of the
    // specialization.  Given that C++ template deduction does not
    // take target attributes into account, we reject candidates
    // here that have a different target.
    if (LangOpts.CUDA &&
        IdentifyCUDATarget(Specialization,
                           /* IgnoreImplicitHDAttributes = */ true) !=
            IdentifyCUDATarget(FD, /* IgnoreImplicitHDAttributes = */ true)) {
      FailedCandidates.addCandidate().set(
          I.getPair(), FunTmpl->getTemplatedDecl(),
          MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
      continue;
    }

    // Record this candidate.
    if (ExplicitTemplateArgs)
      ConvertedTemplateArgs[Specialization] = std::move(Args);
    Candidates.addDecl(Specialization, I.getAccess());
  }
}

// Find the most specialized function template.
UnresolvedSetIterator Result = getMostSpecialized(
    Candidates.begin(), Candidates.end(), FailedCandidates,
    FD->getLocation(),
    PDiag(diag::err_function_template_spec_no_match) << FD->getDeclName(),
    PDiag(diag::err_function_template_spec_ambiguous)
        << FD->getDeclName() << (ExplicitTemplateArgs != nullptr),
    PDiag(diag::note_function_template_spec_matched));

if (Result == Candidates.end())
  return true;

// Ignore access information;  it doesn't figure into redeclaration checking.
FunctionDecl *Specialization = cast<FunctionDecl>(*Result);

FunctionTemplateSpecializationInfo *SpecInfo
  = Specialization->getTemplateSpecializationInfo();
assert(SpecInfo && "Function template specialization info missing?")(static_cast <bool> (SpecInfo && "Function template specialization info missing?"
) ? void (0) : __assert_fail ("SpecInfo && \"Function template specialization info missing?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8096, __extension__ __PRETTY_FUNCTION__));

// Note: do not overwrite location info if previous template
// specialization kind was explicit.
TemplateSpecializationKind TSK = SpecInfo->getTemplateSpecializationKind();
if (TSK == TSK_Undeclared || TSK == TSK_ImplicitInstantiation) {
  Specialization->setLocation(FD->getLocation());
  Specialization->setLexicalDeclContext(FD->getLexicalDeclContext());
  // C++11 [dcl.constexpr]p1: An explicit specialization of a constexpr
  // function can differ from the template declaration with respect to
  // the constexpr specifier.
  // FIXME: We need an update record for this AST mutation.
  // FIXME: What if there are multiple such prior declarations (for instance,
  // from different modules)?
  Specialization->setConstexpr(FD->isConstexpr());
}

// FIXME: Check if the prior specialization has a point of instantiation.
// If so, we have run afoul of .

// If this is a friend declaration, then we're not really declaring
// an explicit specialization.
bool isFriend = (FD->getFriendObjectKind() != Decl::FOK_None);

// Check the scope of this explicit specialization.
if (!isFriend &&
    CheckTemplateSpecializationScope(*this,
                                     Specialization->getPrimaryTemplate(),
                                     Specialization, FD->getLocation(),
                                     false))
  return true;

// C++ [temp.expl.spec]p6:
//   If a template, a member template or the member of a class template is
//   explicitly specialized then that specialization shall be declared
//   before the first use of that specialization that would cause an implicit
//   instantiation to take place, in every translation unit in which such a
//   use occurs; no diagnostic is required.
bool HasNoEffect = false;
if (!isFriend &&
    CheckSpecializationInstantiationRedecl(FD->getLocation(),
                                           TSK_ExplicitSpecialization,
                                           Specialization,
                                 SpecInfo->getTemplateSpecializationKind(),
                                       SpecInfo->getPointOfInstantiation(),
                                           HasNoEffect))
  return true;

// Mark the prior declaration as an explicit specialization, so that later
// clients know that this is an explicit specialization.
if (!isFriend) {
  // Since explicit specializations do not inherit '=delete' from their
  // primary function template - check if the 'specialization' that was
  // implicitly generated (during template argument deduction for partial
  // ordering) from the most specialized of all the function templates that
  // 'FD' could have been specializing, has a 'deleted' definition.  If so,
  // first check that it was implicitly generated during template argument
  // deduction by making sure it wasn't referenced, and then reset the deleted
  // flag to not-deleted, so that we can inherit that information from 'FD'.
  if (Specialization->isDeleted() && !SpecInfo->isExplicitSpecialization() &&
      !Specialization->getCanonicalDecl()->isReferenced()) {
    // FIXME: This assert will not hold in the presence of modules.
    assert((static_cast <bool> (Specialization->getCanonicalDecl
() == Specialization && "This must be the only existing declaration of this specialization"
) ? void (0) : __assert_fail ("Specialization->getCanonicalDecl() == Specialization && \"This must be the only existing declaration of this specialization\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8160, __extension__ __PRETTY_FUNCTION__))
        Specialization->getCanonicalDecl() == Specialization &&(static_cast <bool> (Specialization->getCanonicalDecl
() == Specialization && "This must be the only existing declaration of this specialization"
) ? void (0) : __assert_fail ("Specialization->getCanonicalDecl() == Specialization && \"This must be the only existing declaration of this specialization\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8160, __extension__ __PRETTY_FUNCTION__))
        "This must be the only existing declaration of this specialization")(static_cast <bool> (Specialization->getCanonicalDecl
() == Specialization && "This must be the only existing declaration of this specialization"
) ? void (0) : __assert_fail ("Specialization->getCanonicalDecl() == Specialization && \"This must be the only existing declaration of this specialization\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8160, __extension__ __PRETTY_FUNCTION__));
    // FIXME: We need an update record for this AST mutation.
    Specialization->setDeletedAsWritten(false);
  }
  // FIXME: We need an update record for this AST mutation.
  SpecInfo->setTemplateSpecializationKind(TSK_ExplicitSpecialization);
  MarkUnusedFileScopedDecl(Specialization);
}

// Turn the given function declaration into a function template
// specialization, with the template arguments from the previous
// specialization.
// Take copies of (semantic and syntactic) template argument lists.
const TemplateArgumentList* TemplArgs = new (Context)
  TemplateArgumentList(Specialization->getTemplateSpecializationArgs());
FD->setFunctionTemplateSpecialization(
    Specialization->getPrimaryTemplate(), TemplArgs, /*InsertPos=*/nullptr,
    SpecInfo->getTemplateSpecializationKind(),
    ExplicitTemplateArgs ? &ConvertedTemplateArgs[Specialization] : nullptr);

// A function template specialization inherits the target attributes
// of its template.  (We require the attributes explicitly in the
// code to match, but a template may have implicit attributes by
// virtue e.g. of being constexpr, and it passes these implicit
// attributes on to its specializations.)
if (LangOpts.CUDA)
  inheritCUDATargetAttrs(FD, *Specialization->getPrimaryTemplate());

// The "previous declaration" for this function template specialization is
// the prior function template specialization.
Previous.clear();
Previous.addDecl(Specialization);
return false;
8193}

8195/// \brief Perform semantic analysis for the given non-template member
8196/// specialization.
8197///
8198/// This routine performs all of the semantic analysis required for an
8199/// explicit member function specialization. On successful completion,
8200/// the function declaration \p FD will become a member function
8201/// specialization.
8202///
8203/// \param Member the member declaration, which will be updated to become a
8204/// specialization.
8205///
8206/// \param Previous the set of declarations, one of which may be specialized
8207/// by this function specialization;  the set will be modified to contain the
8208/// redeclared member.
8209bool
8210Sema::CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous) {
assert(!isa<TemplateDecl>(Member) && "Only for non-template members")(static_cast <bool> (!isa<TemplateDecl>(Member) &&
 "Only for non-template members") ? void (0) : __assert_fail (
"!isa<TemplateDecl>(Member) && \"Only for non-template members\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8211, __extension__ __PRETTY_FUNCTION__));

// Try to find the member we are instantiating.
NamedDecl *FoundInstantiation = nullptr;
NamedDecl *Instantiation = nullptr;
NamedDecl *InstantiatedFrom = nullptr;
MemberSpecializationInfo *MSInfo = nullptr;

if (Previous.empty()) {
  // Nowhere to look anyway.
} else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Member)) {
  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
         I != E; ++I) {
    NamedDecl *D = (*I)->getUnderlyingDecl();
    if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
      QualType Adjusted = Function->getType();
      if (!hasExplicitCallingConv(Adjusted))
        Adjusted = adjustCCAndNoReturn(Adjusted, Method->getType());
      if (Context.hasSameType(Adjusted, Method->getType())) {
        FoundInstantiation = *I;
        Instantiation = Method;
        InstantiatedFrom = Method->getInstantiatedFromMemberFunction();
        MSInfo = Method->getMemberSpecializationInfo();
        break;
      }
    }
  }
} else if (isa<VarDecl>(Member)) {
  VarDecl *PrevVar;
  if (Previous.isSingleResult() &&
      (PrevVar = dyn_cast<VarDecl>(Previous.getFoundDecl())))
    if (PrevVar->isStaticDataMember()) {
      FoundInstantiation = Previous.getRepresentativeDecl();
      Instantiation = PrevVar;
      InstantiatedFrom = PrevVar->getInstantiatedFromStaticDataMember();
      MSInfo = PrevVar->getMemberSpecializationInfo();
    }
} else if (isa<RecordDecl>(Member)) {
  CXXRecordDecl *PrevRecord;
  if (Previous.isSingleResult() &&
      (PrevRecord = dyn_cast<CXXRecordDecl>(Previous.getFoundDecl()))) {
    FoundInstantiation = Previous.getRepresentativeDecl();
    Instantiation = PrevRecord;
    InstantiatedFrom = PrevRecord->getInstantiatedFromMemberClass();
    MSInfo = PrevRecord->getMemberSpecializationInfo();
  }
} else if (isa<EnumDecl>(Member)) {
  EnumDecl *PrevEnum;
  if (Previous.isSingleResult() &&
      (PrevEnum = dyn_cast<EnumDecl>(Previous.getFoundDecl()))) {
    FoundInstantiation = Previous.getRepresentativeDecl();
    Instantiation = PrevEnum;
    InstantiatedFrom = PrevEnum->getInstantiatedFromMemberEnum();
    MSInfo = PrevEnum->getMemberSpecializationInfo();
  }
}

if (!Instantiation) {
  // There is no previous declaration that matches. Since member
  // specializations are always out-of-line, the caller will complain about
  // this mismatch later.
  return false;
}

// A member specialization in a friend declaration isn't really declaring
// an explicit specialization, just identifying a specific (possibly implicit)
// specialization. Don't change the template specialization kind.
//
// FIXME: Is this really valid? Other compilers reject.
if (Member->getFriendObjectKind() != Decl::FOK_None) {
  // Preserve instantiation information.
  if (InstantiatedFrom && isa<CXXMethodDecl>(Member)) {
    cast<CXXMethodDecl>(Member)->setInstantiationOfMemberFunction(
                                    cast<CXXMethodDecl>(InstantiatedFrom),
      cast<CXXMethodDecl>(Instantiation)->getTemplateSpecializationKind());
  } else if (InstantiatedFrom && isa<CXXRecordDecl>(Member)) {
    cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass(
                                    cast<CXXRecordDecl>(InstantiatedFrom),
      cast<CXXRecordDecl>(Instantiation)->getTemplateSpecializationKind());
  }

  Previous.clear();
  Previous.addDecl(FoundInstantiation);
  return false;
}

// Make sure that this is a specialization of a member.
if (!InstantiatedFrom) {
  Diag(Member->getLocation(), diag::err_spec_member_not_instantiated)
    << Member;
  Diag(Instantiation->getLocation(), diag::note_specialized_decl);
  return true;
}

// C++ [temp.expl.spec]p6:
//   If a template, a member template or the member of a class template is
//   explicitly specialized then that specialization shall be declared
//   before the first use of that specialization that would cause an implicit
//   instantiation to take place, in every translation unit in which such a
//   use occurs; no diagnostic is required.
assert(MSInfo && "Member specialization info missing?")(static_cast <bool> (MSInfo && "Member specialization info missing?"
) ? void (0) : __assert_fail ("MSInfo && \"Member specialization info missing?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8311, __extension__ __PRETTY_FUNCTION__));

bool HasNoEffect = false;
if (CheckSpecializationInstantiationRedecl(Member->getLocation(),
                                           TSK_ExplicitSpecialization,
                                           Instantiation,
                                   MSInfo->getTemplateSpecializationKind(),
                                         MSInfo->getPointOfInstantiation(),
                                           HasNoEffect))
  return true;

// Check the scope of this explicit specialization.
if (CheckTemplateSpecializationScope(*this,
                                     InstantiatedFrom,
                                     Instantiation, Member->getLocation(),
                                     false))
  return true;

// Note that this member specialization is an "instantiation of" the
// corresponding member of the original template.
if (auto *MemberFunction = dyn_cast<FunctionDecl>(Member)) {
  FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation);
  if (InstantiationFunction->getTemplateSpecializationKind() ==
        TSK_ImplicitInstantiation) {
    // Explicit specializations of member functions of class templates do not
    // inherit '=delete' from the member function they are specializing.
    if (InstantiationFunction->isDeleted()) {
      // FIXME: This assert will not hold in the presence of modules.
      assert(InstantiationFunction->getCanonicalDecl() ==(static_cast <bool> (InstantiationFunction->getCanonicalDecl
() == InstantiationFunction) ? void (0) : __assert_fail ("InstantiationFunction->getCanonicalDecl() == InstantiationFunction"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8340, __extension__ __PRETTY_FUNCTION__))
             InstantiationFunction)(static_cast <bool> (InstantiationFunction->getCanonicalDecl
() == InstantiationFunction) ? void (0) : __assert_fail ("InstantiationFunction->getCanonicalDecl() == InstantiationFunction"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8340, __extension__ __PRETTY_FUNCTION__));
      // FIXME: We need an update record for this AST mutation.
      InstantiationFunction->setDeletedAsWritten(false);
    }
  }

  MemberFunction->setInstantiationOfMemberFunction(
      cast<CXXMethodDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
} else if (auto *MemberVar = dyn_cast<VarDecl>(Member)) {
  MemberVar->setInstantiationOfStaticDataMember(
      cast<VarDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
} else if (auto *MemberClass = dyn_cast<CXXRecordDecl>(Member)) {
  MemberClass->setInstantiationOfMemberClass(
      cast<CXXRecordDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
} else if (auto *MemberEnum = dyn_cast<EnumDecl>(Member)) {
  MemberEnum->setInstantiationOfMemberEnum(
      cast<EnumDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
} else {
  llvm_unreachable("unknown member specialization kind")::llvm::llvm_unreachable_internal("unknown member specialization kind"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8358);
}

// Save the caller the trouble of having to figure out which declaration
// this specialization matches.
Previous.clear();
Previous.addDecl(FoundInstantiation);
return false;
8366}

8368/// Complete the explicit specialization of a member of a class template by
8369/// updating the instantiated member to be marked as an explicit specialization.
8370///
8371/// \param OrigD The member declaration instantiated from the template.
8372/// \param Loc The location of the explicit specialization of the member.
8373template<typename DeclT>
8374static void completeMemberSpecializationImpl(Sema &S, DeclT *OrigD,
                                           SourceLocation Loc) {
if (OrigD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)
  return;

// FIXME: Inform AST mutation listeners of this AST mutation.
// FIXME: If there are multiple in-class declarations of the member (from
// multiple modules, or a declaration and later definition of a member type),
// should we update all of them?
OrigD->setTemplateSpecializationKind(TSK_ExplicitSpecialization);
OrigD->setLocation(Loc);
8385}

8387void Sema::CompleteMemberSpecialization(NamedDecl *Member,
                                      LookupResult &Previous) {
NamedDecl *Instantiation = cast<NamedDecl>(Member->getCanonicalDecl());
if (Instantiation == Member)
  return;

if (auto *Function = dyn_cast<CXXMethodDecl>(Instantiation))
  completeMemberSpecializationImpl(*this, Function, Member->getLocation());
else if (auto *Var = dyn_cast<VarDecl>(Instantiation))
  completeMemberSpecializationImpl(*this, Var, Member->getLocation());
else if (auto *Record = dyn_cast<CXXRecordDecl>(Instantiation))
  completeMemberSpecializationImpl(*this, Record, Member->getLocation());
else if (auto *Enum = dyn_cast<EnumDecl>(Instantiation))
  completeMemberSpecializationImpl(*this, Enum, Member->getLocation());
else
  llvm_unreachable("unknown member specialization kind")::llvm::llvm_unreachable_internal("unknown member specialization kind"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8402);
8403}

8405/// \brief Check the scope of an explicit instantiation.
8406///
8407/// \returns true if a serious error occurs, false otherwise.
8408static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D,
                                          SourceLocation InstLoc,
                                          bool WasQualifiedName) {
DeclContext *OrigContext= D->getDeclContext()->getEnclosingNamespaceContext();
DeclContext *CurContext = S.CurContext->getRedeclContext();

if (CurContext->isRecord()) {
  S.Diag(InstLoc, diag::err_explicit_instantiation_in_class)
    << D;
  return true;
}

// C++11 [temp.explicit]p3:
//   An explicit instantiation shall appear in an enclosing namespace of its
//   template. If the name declared in the explicit instantiation is an
//   unqualified name, the explicit instantiation shall appear in the
//   namespace where its template is declared or, if that namespace is inline
//   (7.3.1), any namespace from its enclosing namespace set.
//
// This is DR275, which we do not retroactively apply to C++98/03.
if (WasQualifiedName) {
  if (CurContext->Encloses(OrigContext))
    return false;
} else {
  if (CurContext->InEnclosingNamespaceSetOf(OrigContext))
    return false;
}

if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext)) {
  if (WasQualifiedName)
    S.Diag(InstLoc,
           S.getLangOpts().CPlusPlus11?
             diag::err_explicit_instantiation_out_of_scope :
             diag::warn_explicit_instantiation_out_of_scope_0x)
      << D << NS;
  else
    S.Diag(InstLoc,
           S.getLangOpts().CPlusPlus11?
             diag::err_explicit_instantiation_unqualified_wrong_namespace :
             diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)
      << D << NS;
} else
  S.Diag(InstLoc,
         S.getLangOpts().CPlusPlus11?
           diag::err_explicit_instantiation_must_be_global :
           diag::warn_explicit_instantiation_must_be_global_0x)
    << D;
S.Diag(D->getLocation(), diag::note_explicit_instantiation_here);
return false;
8457}

8459/// \brief Determine whether the given scope specifier has a template-id in it.
8460static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS) {
if (!SS.isSet())
  return false;

// C++11 [temp.explicit]p3:
//   If the explicit instantiation is for a member function, a member class
//   or a static data member of a class template specialization, the name of
//   the class template specialization in the qualified-id for the member
//   name shall be a simple-template-id.
//
// C++98 has the same restriction, just worded differently.
for (NestedNameSpecifier *NNS = SS.getScopeRep(); NNS;
     NNS = NNS->getPrefix())
  if (const Type *T = NNS->getAsType())
    if (isa<TemplateSpecializationType>(T))
      return true;

return false;
8478}

8480/// Make a dllexport or dllimport attr on a class template specialization take
8481/// effect.
8482static void dllExportImportClassTemplateSpecialization(
  Sema &S, ClassTemplateSpecializationDecl *Def) {
auto *A = cast_or_null<InheritableAttr>(getDLLAttr(Def));
assert(A && "dllExportImportClassTemplateSpecialization called "(static_cast <bool> (A && "dllExportImportClassTemplateSpecialization called "
 "on Def without dllexport or dllimport") ? void (0) : __assert_fail
 ("A && \"dllExportImportClassTemplateSpecialization called \" \"on Def without dllexport or dllimport\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8486, __extension__ __PRETTY_FUNCTION__))
            "on Def without dllexport or dllimport")(static_cast <bool> (A && "dllExportImportClassTemplateSpecialization called "
 "on Def without dllexport or dllimport") ? void (0) : __assert_fail
 ("A && \"dllExportImportClassTemplateSpecialization called \" \"on Def without dllexport or dllimport\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8486, __extension__ __PRETTY_FUNCTION__));

// We reject explicit instantiations in class scope, so there should
// never be any delayed exported classes to worry about.
assert(S.DelayedDllExportClasses.empty() &&(static_cast <bool> (S.DelayedDllExportClasses.empty() &&
 "delayed exports present at explicit instantiation") ? void (
0) : __assert_fail ("S.DelayedDllExportClasses.empty() && \"delayed exports present at explicit instantiation\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8491, __extension__ __PRETTY_FUNCTION__))
       "delayed exports present at explicit instantiation")(static_cast <bool> (S.DelayedDllExportClasses.empty() &&
 "delayed exports present at explicit instantiation") ? void (
0) : __assert_fail ("S.DelayedDllExportClasses.empty() && \"delayed exports present at explicit instantiation\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8491, __extension__ __PRETTY_FUNCTION__));
S.checkClassLevelDLLAttribute(Def);

// Propagate attribute to base class templates.
for (auto &B : Def->bases()) {
  if (auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
          B.getType()->getAsCXXRecordDecl()))
    S.propagateDLLAttrToBaseClassTemplate(Def, A, BT, B.getLocStart());
}

S.referenceDLLExportedClassMethods();
8502}

8504// Explicit instantiation of a class template specialization
8505DeclResult
8506Sema::ActOnExplicitInstantiation(Scope *S,
                               SourceLocation ExternLoc,
                               SourceLocation TemplateLoc,
                               unsigned TagSpec,
                               SourceLocation KWLoc,
                               const CXXScopeSpec &SS,
                               TemplateTy TemplateD,
                               SourceLocation TemplateNameLoc,
                               SourceLocation LAngleLoc,
                               ASTTemplateArgsPtr TemplateArgsIn,
                               SourceLocation RAngleLoc,
                               AttributeList *Attr) {
// Find the class template we're specializing
TemplateName Name = TemplateD.get();
TemplateDecl *TD = Name.getAsTemplateDecl();
// Check that the specialization uses the same tag kind as the
// original template.
TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
assert(Kind != TTK_Enum &&(static_cast <bool> (Kind != TTK_Enum && "Invalid enum tag in class template explicit instantiation!"
) ? void (0) : __assert_fail ("Kind != TTK_Enum && \"Invalid enum tag in class template explicit instantiation!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8525, __extension__ __PRETTY_FUNCTION__))
       "Invalid enum tag in class template explicit instantiation!")(static_cast <bool> (Kind != TTK_Enum && "Invalid enum tag in class template explicit instantiation!"
) ? void (0) : __assert_fail ("Kind != TTK_Enum && \"Invalid enum tag in class template explicit instantiation!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8525, __extension__ __PRETTY_FUNCTION__));

ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(TD);

if (!ClassTemplate) {
  NonTagKind NTK = getNonTagTypeDeclKind(TD, Kind);
  Diag(TemplateNameLoc, diag::err_tag_reference_non_tag) << TD << NTK << Kind;
  Diag(TD->getLocation(), diag::note_previous_use);
  return true;
}

if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
                                  Kind, /*isDefinition*/false, KWLoc,
                                  ClassTemplate->getIdentifier())) {
  Diag(KWLoc, diag::err_use_with_wrong_tag)
    << ClassTemplate
    << FixItHint::CreateReplacement(KWLoc,
                          ClassTemplate->getTemplatedDecl()->getKindName());
  Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
       diag::note_previous_use);
  Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
}

// C++0x [temp.explicit]p2:
//   There are two forms of explicit instantiation: an explicit instantiation
//   definition and an explicit instantiation declaration. An explicit
//   instantiation declaration begins with the extern keyword. [...]
TemplateSpecializationKind TSK = ExternLoc.isInvalid()
                                     ? TSK_ExplicitInstantiationDefinition
                                     : TSK_ExplicitInstantiationDeclaration;

if (TSK == TSK_ExplicitInstantiationDeclaration) {
  // Check for dllexport class template instantiation declarations.
  for (AttributeList *A = Attr; A; A = A->getNext()) {
    if (A->getKind() == AttributeList::AT_DLLExport) {
      Diag(ExternLoc,
           diag::warn_attribute_dllexport_explicit_instantiation_decl);
      Diag(A->getLoc(), diag::note_attribute);
      break;
    }
  }

  if (auto *A = ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {
    Diag(ExternLoc,
         diag::warn_attribute_dllexport_explicit_instantiation_decl);
    Diag(A->getLocation(), diag::note_attribute);
  }
}

// In MSVC mode, dllimported explicit instantiation definitions are treated as
// instantiation declarations for most purposes.
bool DLLImportExplicitInstantiationDef = false;
if (TSK == TSK_ExplicitInstantiationDefinition &&
    Context.getTargetInfo().getCXXABI().isMicrosoft()) {
  // Check for dllimport class template instantiation definitions.
  bool DLLImport =
      ClassTemplate->getTemplatedDecl()->getAttr<DLLImportAttr>();
  for (AttributeList *A = Attr; A; A = A->getNext()) {
    if (A->getKind() == AttributeList::AT_DLLImport)
      DLLImport = true;
    if (A->getKind() == AttributeList::AT_DLLExport) {
      // dllexport trumps dllimport here.
      DLLImport = false;
      break;
    }
  }
  if (DLLImport) {
    TSK = TSK_ExplicitInstantiationDeclaration;
    DLLImportExplicitInstantiationDef = true;
  }
}

// Translate the parser's template argument list in our AST format.
TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
translateTemplateArguments(TemplateArgsIn, TemplateArgs);

// Check that the template argument list is well-formed for this
// template.
SmallVector<TemplateArgument, 4> Converted;
if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
                              TemplateArgs, false, Converted))
  return true;

// Find the class template specialization declaration that
// corresponds to these arguments.
void *InsertPos = nullptr;
ClassTemplateSpecializationDecl *PrevDecl
  = ClassTemplate->findSpecialization(Converted, InsertPos);

TemplateSpecializationKind PrevDecl_TSK
  = PrevDecl ? PrevDecl->getTemplateSpecializationKind() : TSK_Undeclared;

// C++0x [temp.explicit]p2:
//   [...] An explicit instantiation shall appear in an enclosing
//   namespace of its template. [...]
//
// This is C++ DR 275.
if (CheckExplicitInstantiationScope(*this, ClassTemplate, TemplateNameLoc,
                                    SS.isSet()))
  return true;

ClassTemplateSpecializationDecl *Specialization = nullptr;

bool HasNoEffect = false;
if (PrevDecl) {
  if (CheckSpecializationInstantiationRedecl(TemplateNameLoc, TSK,
                                             PrevDecl, PrevDecl_TSK,
                                          PrevDecl->getPointOfInstantiation(),
                                             HasNoEffect))
    return PrevDecl;

  // Even though HasNoEffect == true means that this explicit instantiation
  // has no effect on semantics, we go on to put its syntax in the AST.

  if (PrevDecl_TSK == TSK_ImplicitInstantiation ||
      PrevDecl_TSK == TSK_Undeclared) {
    // Since the only prior class template specialization with these
    // arguments was referenced but not declared, reuse that
    // declaration node as our own, updating the source location
    // for the template name to reflect our new declaration.
    // (Other source locations will be updated later.)
    Specialization = PrevDecl;
    Specialization->setLocation(TemplateNameLoc);
    PrevDecl = nullptr;
  }

  if (PrevDecl_TSK == TSK_ExplicitInstantiationDeclaration &&
      DLLImportExplicitInstantiationDef) {
    // The new specialization might add a dllimport attribute.
    HasNoEffect = false;
  }
}

if (!Specialization) {
  // Create a new class template specialization declaration node for
  // this explicit specialization.
  Specialization
    = ClassTemplateSpecializationDecl::Create(Context, Kind,
                                           ClassTemplate->getDeclContext(),
                                              KWLoc, TemplateNameLoc,
                                              ClassTemplate,
                                              Converted,
                                              PrevDecl);
  SetNestedNameSpecifier(Specialization, SS);

  if (!HasNoEffect && !PrevDecl) {
    // Insert the new specialization.
    ClassTemplate->AddSpecialization(Specialization, InsertPos);
  }
}

// Build the fully-sugared type for this explicit instantiation as
// the user wrote in the explicit instantiation itself. This means
// that we'll pretty-print the type retrieved from the
// specialization's declaration the way that the user actually wrote
// the explicit instantiation, rather than formatting the name based
// on the "canonical" representation used to store the template
// arguments in the specialization.
TypeSourceInfo *WrittenTy
  = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
                                              TemplateArgs,
                                Context.getTypeDeclType(Specialization));
Specialization->setTypeAsWritten(WrittenTy);

// Set source locations for keywords.
Specialization->setExternLoc(ExternLoc);
Specialization->setTemplateKeywordLoc(TemplateLoc);
Specialization->setBraceRange(SourceRange());

bool PreviouslyDLLExported = Specialization->hasAttr<DLLExportAttr>();
if (Attr)
  ProcessDeclAttributeList(S, Specialization, Attr);

// Add the explicit instantiation into its lexical context. However,
// since explicit instantiations are never found by name lookup, we
// just put it into the declaration context directly.
Specialization->setLexicalDeclContext(CurContext);
CurContext->addDecl(Specialization);

// Syntax is now OK, so return if it has no other effect on semantics.
if (HasNoEffect) {
  // Set the template specialization kind.
  Specialization->setTemplateSpecializationKind(TSK);
  return Specialization;
}

// C++ [temp.explicit]p3:
//   A definition of a class template or class member template
//   shall be in scope at the point of the explicit instantiation of
//   the class template or class member template.
//
// This check comes when we actually try to perform the
// instantiation.
ClassTemplateSpecializationDecl *Def
  = cast_or_null<ClassTemplateSpecializationDecl>(
                                            Specialization->getDefinition());
if (!Def)
  InstantiateClassTemplateSpecialization(TemplateNameLoc, Specialization, TSK);
else if (TSK == TSK_ExplicitInstantiationDefinition) {
  MarkVTableUsed(TemplateNameLoc, Specialization, true);
  Specialization->setPointOfInstantiation(Def->getPointOfInstantiation());
}

// Instantiate the members of this class template specialization.
Def = cast_or_null<ClassTemplateSpecializationDecl>(
                                     Specialization->getDefinition());
if (Def) {
  TemplateSpecializationKind Old_TSK = Def->getTemplateSpecializationKind();
  // Fix a TSK_ExplicitInstantiationDeclaration followed by a
  // TSK_ExplicitInstantiationDefinition
  if (Old_TSK == TSK_ExplicitInstantiationDeclaration &&
      (TSK == TSK_ExplicitInstantiationDefinition ||
       DLLImportExplicitInstantiationDef)) {
    // FIXME: Need to notify the ASTMutationListener that we did this.
    Def->setTemplateSpecializationKind(TSK);

    if (!getDLLAttr(Def) && getDLLAttr(Specialization) &&
        (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
         Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
      // In the MS ABI, an explicit instantiation definition can add a dll
      // attribute to a template with a previous instantiation declaration.
      // MinGW doesn't allow this.
      auto *A = cast<InheritableAttr>(
          getDLLAttr(Specialization)->clone(getASTContext()));
      A->setInherited(true);
      Def->addAttr(A);
      dllExportImportClassTemplateSpecialization(*this, Def);
    }
  }

  // Fix a TSK_ImplicitInstantiation followed by a
  // TSK_ExplicitInstantiationDefinition
  bool NewlyDLLExported =
      !PreviouslyDLLExported && Specialization->hasAttr<DLLExportAttr>();
  if (Old_TSK == TSK_ImplicitInstantiation && NewlyDLLExported &&
      (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
       Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
    // In the MS ABI, an explicit instantiation definition can add a dll
    // attribute to a template with a previous implicit instantiation.
    // MinGW doesn't allow this. We limit clang to only adding dllexport, to
    // avoid potentially strange codegen behavior.  For example, if we extend
    // this conditional to dllimport, and we have a source file calling a
    // method on an implicitly instantiated template class instance and then
    // declaring a dllimport explicit instantiation definition for the same
    // template class, the codegen for the method call will not respect the
    // dllimport, while it will with cl. The Def will already have the DLL
    // attribute, since the Def and Specialization will be the same in the
    // case of Old_TSK == TSK_ImplicitInstantiation, and we already added the
    // attribute to the Specialization; we just need to make it take effect.
    assert(Def == Specialization &&(static_cast <bool> (Def == Specialization && "Def and Specialization should match for implicit instantiation"
) ? void (0) : __assert_fail ("Def == Specialization && \"Def and Specialization should match for implicit instantiation\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8775, __extension__ __PRETTY_FUNCTION__))
           "Def and Specialization should match for implicit instantiation")(static_cast <bool> (Def == Specialization && "Def and Specialization should match for implicit instantiation"
) ? void (0) : __assert_fail ("Def == Specialization && \"Def and Specialization should match for implicit instantiation\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8775, __extension__ __PRETTY_FUNCTION__));
    dllExportImportClassTemplateSpecialization(*this, Def);
  }

  // Set the template specialization kind. Make sure it is set before
  // instantiating the members which will trigger ASTConsumer callbacks.
  Specialization->setTemplateSpecializationKind(TSK);
  InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK);
} else {

  // Set the template specialization kind.
  Specialization->setTemplateSpecializationKind(TSK);
}

return Specialization;
8790}

8792// Explicit instantiation of a member class of a class template.
8793DeclResult
8794Sema::ActOnExplicitInstantiation(Scope *S,
                               SourceLocation ExternLoc,
                               SourceLocation TemplateLoc,
                               unsigned TagSpec,
                               SourceLocation KWLoc,
                               CXXScopeSpec &SS,
                               IdentifierInfo *Name,
                               SourceLocation NameLoc,
                               AttributeList *Attr) {

bool Owned = false;
bool IsDependent = false;
Decl *TagD = ActOnTag(S, TagSpec, Sema::TUK_Reference,
                      KWLoc, SS, Name, NameLoc, Attr, AS_none,
                      /*ModulePrivateLoc=*/SourceLocation(),
                      MultiTemplateParamsArg(), Owned, IsDependent,
                      SourceLocation(), false, TypeResult(),
                      /*IsTypeSpecifier*/false,
                      /*IsTemplateParamOrArg*/false);
assert(!IsDependent && "explicit instantiation of dependent name not yet handled")(static_cast <bool> (!IsDependent && "explicit instantiation of dependent name not yet handled"
) ? void (0) : __assert_fail ("!IsDependent && \"explicit instantiation of dependent name not yet handled\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8813, __extension__ __PRETTY_FUNCTION__));

if (!TagD)
  return true;

TagDecl *Tag = cast<TagDecl>(TagD);
assert(!Tag->isEnum() && "shouldn't see enumerations here")(static_cast <bool> (!Tag->isEnum() && "shouldn't see enumerations here"
) ? void (0) : __assert_fail ("!Tag->isEnum() && \"shouldn't see enumerations here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8819, __extension__ __PRETTY_FUNCTION__));

if (Tag->isInvalidDecl())
  return true;

CXXRecordDecl *Record = cast<CXXRecordDecl>(Tag);
CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
if (!Pattern) {
  Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)
    << Context.getTypeDeclType(Record);
  Diag(Record->getLocation(), diag::note_nontemplate_decl_here);
  return true;
}

// C++0x [temp.explicit]p2:
//   If the explicit instantiation is for a class or member class, the
//   elaborated-type-specifier in the declaration shall include a
//   simple-template-id.
//
// C++98 has the same restriction, just worded differently.
if (!ScopeSpecifierHasTemplateId(SS))
  Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)
    << Record << SS.getRange();

// C++0x [temp.explicit]p2:
//   There are two forms of explicit instantiation: an explicit instantiation
//   definition and an explicit instantiation declaration. An explicit
//   instantiation declaration begins with the extern keyword. [...]
TemplateSpecializationKind TSK
  = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
                         : TSK_ExplicitInstantiationDeclaration;

// C++0x [temp.explicit]p2:
//   [...] An explicit instantiation shall appear in an enclosing
//   namespace of its template. [...]
//
// This is C++ DR 275.
CheckExplicitInstantiationScope(*this, Record, NameLoc, true);

// Verify that it is okay to explicitly instantiate here.
CXXRecordDecl *PrevDecl
  = cast_or_null<CXXRecordDecl>(Record->getPreviousDecl());
if (!PrevDecl && Record->getDefinition())
  PrevDecl = Record;
if (PrevDecl) {
  MemberSpecializationInfo *MSInfo = PrevDecl->getMemberSpecializationInfo();
  bool HasNoEffect = false;
  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~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8866, __extension__ __PRETTY_FUNCTION__));
  if (CheckSpecializationInstantiationRedecl(TemplateLoc, TSK,
                                             PrevDecl,
                                      MSInfo->getTemplateSpecializationKind(),
                                           MSInfo->getPointOfInstantiation(),
                                             HasNoEffect))
    return true;
  if (HasNoEffect)
    return TagD;
}

CXXRecordDecl *RecordDef
  = cast_or_null<CXXRecordDecl>(Record->getDefinition());
if (!RecordDef) {
  // C++ [temp.explicit]p3:
  //   A definition of a member class of a class template shall be in scope
  //   at the point of an explicit instantiation of the member class.
  CXXRecordDecl *Def
    = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
  if (!Def) {
    Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
      << 0 << Record->getDeclName() << Record->getDeclContext();
    Diag(Pattern->getLocation(), diag::note_forward_declaration)
      << Pattern;
    return true;
  } else {
    if (InstantiateClass(NameLoc, Record, Def,
                         getTemplateInstantiationArgs(Record),
                         TSK))
      return true;

    RecordDef = cast_or_null<CXXRecordDecl>(Record->getDefinition());
    if (!RecordDef)
      return true;
  }
}

// Instantiate all of the members of the class.
InstantiateClassMembers(NameLoc, RecordDef,
                        getTemplateInstantiationArgs(Record), TSK);

if (TSK == TSK_ExplicitInstantiationDefinition)
  MarkVTableUsed(NameLoc, RecordDef, true);

// FIXME: We don't have any representation for explicit instantiations of
// member classes. Such a representation is not needed for compilation, but it
// should be available for clients that want to see all of the declarations in
// the source code.
return TagD;
8915}

8917DeclResult Sema::ActOnExplicitInstantiation(Scope *S,
                                          SourceLocation ExternLoc,
                                          SourceLocation TemplateLoc,
                                          Declarator &D) {
// Explicit instantiations always require a name.
// TODO: check if/when DNInfo should replace Name.
DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
DeclarationName Name = NameInfo.getName();
if (!Name) {
  if (!D.isInvalidType())
    Diag(D.getDeclSpec().getLocStart(),
         diag::err_explicit_instantiation_requires_name)
      << D.getDeclSpec().getSourceRange()
      << D.getSourceRange();

  return true;
}

// The scope passed in may not be a decl scope.  Zip up the scope tree until
// we find one that is.
while ((S->getFlags() & Scope::DeclScope) == 0 ||
       (S->getFlags() & Scope::TemplateParamScope) != 0)
  S = S->getParent();

// Determine the type of the declaration.
TypeSourceInfo *T = GetTypeForDeclarator(D, S);
QualType R = T->getType();
if (R.isNull())
  return true;

// C++ [dcl.stc]p1:
//   A storage-class-specifier shall not be specified in [...] an explicit
//   instantiation (14.7.2) directive.
if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef)
    << Name;
  return true;
} else if (D.getDeclSpec().getStorageClassSpec()
                                              != DeclSpec::SCS_unspecified) {
  // Complain about then remove the storage class specifier.
  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_storage_class)
    << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());

  D.getMutableDeclSpec().ClearStorageClassSpecs();
}

// C++0x [temp.explicit]p1:
//   [...] An explicit instantiation of a function template shall not use the
//   inline or constexpr specifiers.
// Presumably, this also applies to member functions of class templates as
// well.
if (D.getDeclSpec().isInlineSpecified())
  Diag(D.getDeclSpec().getInlineSpecLoc(),
       getLangOpts().CPlusPlus11 ?
         diag::err_explicit_instantiation_inline :
         diag::warn_explicit_instantiation_inline_0x)
    << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
if (D.getDeclSpec().isConstexprSpecified() && R->isFunctionType())
  // FIXME: Add a fix-it to remove the 'constexpr' and add a 'const' if one is
  // not already specified.
  Diag(D.getDeclSpec().getConstexprSpecLoc(),
       diag::err_explicit_instantiation_constexpr);

// A deduction guide is not on the list of entities that can be explicitly
// instantiated.
if (Name.getNameKind() == DeclarationName::CXXDeductionGuideName) {
  Diag(D.getDeclSpec().getLocStart(), diag::err_deduction_guide_specialized)
    << /*explicit instantiation*/ 0;
  return true;
}

// C++0x [temp.explicit]p2:
//   There are two forms of explicit instantiation: an explicit instantiation
//   definition and an explicit instantiation declaration. An explicit
//   instantiation declaration begins with the extern keyword. [...]
TemplateSpecializationKind TSK
  = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
                         : TSK_ExplicitInstantiationDeclaration;

LookupResult Previous(*this, NameInfo, LookupOrdinaryName);
LookupParsedName(Previous, S, &D.getCXXScopeSpec());

if (!R->isFunctionType()) {
  // C++ [temp.explicit]p1:
  //   A [...] static data member of a class template can be explicitly
  //   instantiated from the member definition associated with its class
  //   template.
  // C++1y [temp.explicit]p1:
  //   A [...] variable [...] template specialization can be explicitly
  //   instantiated from its template.
  if (Previous.isAmbiguous())
    return true;

  VarDecl *Prev = Previous.getAsSingle<VarDecl>();
  VarTemplateDecl *PrevTemplate = Previous.getAsSingle<VarTemplateDecl>();

  if (!PrevTemplate) {
    if (!Prev || !Prev->isStaticDataMember()) {
      // We expect to see a data data member here.
      Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)
          << Name;
      for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
           P != PEnd; ++P)
        Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
      return true;
    }

    if (!Prev->getInstantiatedFromStaticDataMember()) {
      // FIXME: Check for explicit specialization?
      Diag(D.getIdentifierLoc(),
           diag::err_explicit_instantiation_data_member_not_instantiated)
          << Prev;
      Diag(Prev->getLocation(), diag::note_explicit_instantiation_here);
      // FIXME: Can we provide a note showing where this was declared?
      return true;
    }
  } else {
    // Explicitly instantiate a variable template.

    // C++1y [dcl.spec.auto]p6:
    //   ... A program that uses auto or decltype(auto) in a context not
    //   explicitly allowed in this section is ill-formed.
    //
    // This includes auto-typed variable template instantiations.
    if (R->isUndeducedType()) {
      Diag(T->getTypeLoc().getLocStart(),
           diag::err_auto_not_allowed_var_inst);
      return true;
    }

    if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {
      // C++1y [temp.explicit]p3:
      //   If the explicit instantiation is for a variable, the unqualified-id
      //   in the declaration shall be a template-id.
      Diag(D.getIdentifierLoc(),
           diag::err_explicit_instantiation_without_template_id)
        << PrevTemplate;
      Diag(PrevTemplate->getLocation(),
           diag::note_explicit_instantiation_here);
      return true;
    }

    // Translate the parser's template argument list into our AST format.
    TemplateArgumentListInfo TemplateArgs =
        makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);

    DeclResult Res = CheckVarTemplateId(PrevTemplate, TemplateLoc,
                                        D.getIdentifierLoc(), TemplateArgs);
    if (Res.isInvalid())
      return true;

    // Ignore access control bits, we don't need them for redeclaration
    // checking.
    Prev = cast<VarDecl>(Res.get());
  }

  // C++0x [temp.explicit]p2:
  //   If the explicit instantiation is for a member function, a member class
  //   or a static data member of a class template specialization, the name of
  //   the class template specialization in the qualified-id for the member
  //   name shall be a simple-template-id.
  //
  // C++98 has the same restriction, just worded differently.
  //
  // This does not apply to variable template specializations, where the
  // template-id is in the unqualified-id instead.
  if (!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()) && !PrevTemplate)
    Diag(D.getIdentifierLoc(),
         diag::ext_explicit_instantiation_without_qualified_id)
      << Prev << D.getCXXScopeSpec().getRange();

  // Check the scope of this explicit instantiation.
  CheckExplicitInstantiationScope(*this, Prev, D.getIdentifierLoc(), true);

  // Verify that it is okay to explicitly instantiate here.
  TemplateSpecializationKind PrevTSK = Prev->getTemplateSpecializationKind();
  SourceLocation POI = Prev->getPointOfInstantiation();
  bool HasNoEffect = false;
  if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
                                             PrevTSK, POI, HasNoEffect))
    return true;

  if (!HasNoEffect) {
    // Instantiate static data member or variable template.
    Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
    if (PrevTemplate) {
      // Merge attributes.
      if (AttributeList *Attr = D.getDeclSpec().getAttributes().getList())
        ProcessDeclAttributeList(S, Prev, Attr);
    }
    if (TSK == TSK_ExplicitInstantiationDefinition)
      InstantiateVariableDefinition(D.getIdentifierLoc(), Prev);
  }

  // Check the new variable specialization against the parsed input.
  if (PrevTemplate && Prev && !Context.hasSameType(Prev->getType(), R)) {
    Diag(T->getTypeLoc().getLocStart(),
         diag::err_invalid_var_template_spec_type)
        << 0 << PrevTemplate << R << Prev->getType();
    Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
        << 2 << PrevTemplate->getDeclName();
    return true;
  }

  // FIXME: Create an ExplicitInstantiation node?
  return (Decl*) nullptr;
}

// If the declarator is a template-id, translate the parser's template
// argument list into our AST format.
bool HasExplicitTemplateArgs = false;
TemplateArgumentListInfo TemplateArgs;
if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {
  TemplateArgs = makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);
  HasExplicitTemplateArgs = true;
}

// C++ [temp.explicit]p1:
//   A [...] function [...] can be explicitly instantiated from its template.
//   A member function [...] of a class template can be explicitly
//  instantiated from the member definition associated with its class
//  template.
UnresolvedSet<8> TemplateMatches;
FunctionDecl *NonTemplateMatch = nullptr;
AttributeList *Attr = D.getDeclSpec().getAttributes().getList();
TemplateSpecCandidateSet FailedCandidates(D.getIdentifierLoc());
for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
     P != PEnd; ++P) {
  NamedDecl *Prev = *P;
  if (!HasExplicitTemplateArgs) {
    if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) {
      QualType Adjusted = adjustCCAndNoReturn(R, Method->getType(),
                                              /*AdjustExceptionSpec*/true);
      if (Context.hasSameUnqualifiedType(Method->getType(), Adjusted)) {
        if (Method->getPrimaryTemplate()) {
          TemplateMatches.addDecl(Method, P.getAccess());
        } else {
          // FIXME: Can this assert ever happen?  Needs a test.
          assert(!NonTemplateMatch && "Multiple NonTemplateMatches")(static_cast <bool> (!NonTemplateMatch && "Multiple NonTemplateMatches"
) ? void (0) : __assert_fail ("!NonTemplateMatch && \"Multiple NonTemplateMatches\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9155, __extension__ __PRETTY_FUNCTION__));
          NonTemplateMatch = Method;
        }
      }
    }
  }

  FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Prev);
  if (!FunTmpl)
    continue;

  TemplateDeductionInfo Info(FailedCandidates.getLocation());
  FunctionDecl *Specialization = nullptr;
  if (TemplateDeductionResult TDK
        = DeduceTemplateArguments(FunTmpl,
                             (HasExplicitTemplateArgs ? &TemplateArgs
                                                      : nullptr),
                                  R, Specialization, Info)) {
    // Keep track of almost-matches.
    FailedCandidates.addCandidate()
        .set(P.getPair(), FunTmpl->getTemplatedDecl(),
             MakeDeductionFailureInfo(Context, TDK, Info));
    (void)TDK;
    continue;
  }

  // Target attributes are part of the cuda function signature, so
  // the cuda target of the instantiated function must match that of its
  // template.  Given that C++ template deduction does not take
  // target attributes into account, we reject candidates here that
  // have a different target.
  if (LangOpts.CUDA &&
      IdentifyCUDATarget(Specialization,
                         /* IgnoreImplicitHDAttributes = */ true) !=
          IdentifyCUDATarget(Attr)) {
    FailedCandidates.addCandidate().set(
        P.getPair(), FunTmpl->getTemplatedDecl(),
        MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
    continue;
  }

  TemplateMatches.addDecl(Specialization, P.getAccess());
}

FunctionDecl *Specialization = NonTemplateMatch;
if (!Specialization) {
  // Find the most specialized function template specialization.
  UnresolvedSetIterator Result = getMostSpecialized(
      TemplateMatches.begin(), TemplateMatches.end(), FailedCandidates,
      D.getIdentifierLoc(),
      PDiag(diag::err_explicit_instantiation_not_known) << Name,
      PDiag(diag::err_explicit_instantiation_ambiguous) << Name,
      PDiag(diag::note_explicit_instantiation_candidate));

  if (Result == TemplateMatches.end())
    return true;

  // Ignore access control bits, we don't need them for redeclaration checking.
  Specialization = cast<FunctionDecl>(*Result);
}

// C++11 [except.spec]p4
// In an explicit instantiation an exception-specification may be specified,
// but is not required.
// If an exception-specification is specified in an explicit instantiation
// directive, it shall be compatible with the exception-specifications of
// other declarations of that function.
if (auto *FPT = R->getAs<FunctionProtoType>())
  if (FPT->hasExceptionSpec()) {
    unsigned DiagID =
        diag::err_mismatched_exception_spec_explicit_instantiation;
    if (getLangOpts().MicrosoftExt)
      DiagID = diag::ext_mismatched_exception_spec_explicit_instantiation;
    bool Result = CheckEquivalentExceptionSpec(
        PDiag(DiagID) << Specialization->getType(),
        PDiag(diag::note_explicit_instantiation_here),
        Specialization->getType()->getAs<FunctionProtoType>(),
        Specialization->getLocation(), FPT, D.getLocStart());
    // In Microsoft mode, mismatching exception specifications just cause a
    // warning.
    if (!getLangOpts().MicrosoftExt && Result)
      return true;
  }

if (Specialization->getTemplateSpecializationKind() == TSK_Undeclared) {
  Diag(D.getIdentifierLoc(),
       diag::err_explicit_instantiation_member_function_not_instantiated)
    << Specialization
    << (Specialization->getTemplateSpecializationKind() ==
        TSK_ExplicitSpecialization);
  Diag(Specialization->getLocation(), diag::note_explicit_instantiation_here);
  return true;
}

FunctionDecl *PrevDecl = Specialization->getPreviousDecl();
if (!PrevDecl && Specialization->isThisDeclarationADefinition())
  PrevDecl = Specialization;

if (PrevDecl) {
  bool HasNoEffect = false;
  if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK,
                                             PrevDecl,
                                   PrevDecl->getTemplateSpecializationKind(),
                                        PrevDecl->getPointOfInstantiation(),
                                             HasNoEffect))
    return true;

  // FIXME: We may still want to build some representation of this
  // explicit specialization.
  if (HasNoEffect)
    return (Decl*) nullptr;
}

if (Attr)
  ProcessDeclAttributeList(S, Specialization, Attr);

// In MSVC mode, dllimported explicit instantiation definitions are treated as
// instantiation declarations.
if (TSK == TSK_ExplicitInstantiationDefinition &&
    Specialization->hasAttr<DLLImportAttr>() &&
    Context.getTargetInfo().getCXXABI().isMicrosoft())
  TSK = TSK_ExplicitInstantiationDeclaration;

Specialization->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());

if (Specialization->isDefined()) {
  // Let the ASTConsumer know that this function has been explicitly
  // instantiated now, and its linkage might have changed.
  Consumer.HandleTopLevelDecl(DeclGroupRef(Specialization));
} else if (TSK == TSK_ExplicitInstantiationDefinition)
  InstantiateFunctionDefinition(D.getIdentifierLoc(), Specialization);

// C++0x [temp.explicit]p2:
//   If the explicit instantiation is for a member function, a member class
//   or a static data member of a class template specialization, the name of
//   the class template specialization in the qualified-id for the member
//   name shall be a simple-template-id.
//
// C++98 has the same restriction, just worded differently.
FunctionTemplateDecl *FunTmpl = Specialization->getPrimaryTemplate();
if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId && !FunTmpl &&
    D.getCXXScopeSpec().isSet() &&
    !ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()))
  Diag(D.getIdentifierLoc(),
       diag::ext_explicit_instantiation_without_qualified_id)
  << Specialization << D.getCXXScopeSpec().getRange();

CheckExplicitInstantiationScope(*this,
                 FunTmpl? (NamedDecl *)FunTmpl
                        : Specialization->getInstantiatedFromMemberFunction(),
                                D.getIdentifierLoc(),
                                D.getCXXScopeSpec().isSet());

// FIXME: Create some kind of ExplicitInstantiationDecl here.
return (Decl*) nullptr;
9310}

9312TypeResult
9313Sema::ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
                      const CXXScopeSpec &SS, IdentifierInfo *Name,
                      SourceLocation TagLoc, SourceLocation NameLoc) {
// This has to hold, because SS is expected to be defined.
assert(Name && "Expected a name in a dependent tag")(static_cast <bool> (Name && "Expected a name in a dependent tag"
) ? void (0) : __assert_fail ("Name && \"Expected a name in a dependent tag\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9317, __extension__ __PRETTY_FUNCTION__));

NestedNameSpecifier *NNS = SS.getScopeRep();
if (!NNS)
  return true;

TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);

if (TUK == TUK_Declaration || TUK == TUK_Definition) {
  Diag(NameLoc, diag::err_dependent_tag_decl)
    << (TUK == TUK_Definition) << Kind << SS.getRange();
  return true;
}

// Create the resulting type.
ElaboratedTypeKeyword Kwd = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
QualType Result = Context.getDependentNameType(Kwd, NNS, Name);

// Create type-source location information for this type.
TypeLocBuilder TLB;
DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(Result);
TL.setElaboratedKeywordLoc(TagLoc);
TL.setQualifierLoc(SS.getWithLocInContext(Context));
TL.setNameLoc(NameLoc);
return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
9342}

9344TypeResult
9345Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
                      const CXXScopeSpec &SS, const IdentifierInfo &II,
                      SourceLocation IdLoc) {
if (SS.isInvalid())
  return true;

if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
  Diag(TypenameLoc,
       getLangOpts().CPlusPlus11 ?
         diag::warn_cxx98_compat_typename_outside_of_template :
         diag::ext_typename_outside_of_template)
    << FixItHint::CreateRemoval(TypenameLoc);

NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
QualType T = CheckTypenameType(TypenameLoc.isValid()? ETK_Typename : ETK_None,
                               TypenameLoc, QualifierLoc, II, IdLoc);
if (T.isNull())
  return true;

TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
if (isa<DependentNameType>(T)) {
  DependentNameTypeLoc TL = TSI->getTypeLoc().castAs<DependentNameTypeLoc>();
  TL.setElaboratedKeywordLoc(TypenameLoc);
  TL.setQualifierLoc(QualifierLoc);
  TL.setNameLoc(IdLoc);
} else {
  ElaboratedTypeLoc TL = TSI->getTypeLoc().castAs<ElaboratedTypeLoc>();
  TL.setElaboratedKeywordLoc(TypenameLoc);
  TL.setQualifierLoc(QualifierLoc);
  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
}

return CreateParsedType(T, TSI);
9378}

9380TypeResult
9381Sema::ActOnTypenameType(Scope *S,
                      SourceLocation TypenameLoc,
                      const CXXScopeSpec &SS,
                      SourceLocation TemplateKWLoc,
                      TemplateTy TemplateIn,
                      IdentifierInfo *TemplateII,
                      SourceLocation TemplateIILoc,
                      SourceLocation LAngleLoc,
                      ASTTemplateArgsPtr TemplateArgsIn,
                      SourceLocation RAngleLoc) {
if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
  Diag(TypenameLoc,
       getLangOpts().CPlusPlus11 ?
         diag::warn_cxx98_compat_typename_outside_of_template :
         diag::ext_typename_outside_of_template)
    << FixItHint::CreateRemoval(TypenameLoc);

// Strangely, non-type results are not ignored by this lookup, so the
// program is ill-formed if it finds an injected-class-name.
if (TypenameLoc.isValid()) {
  auto *LookupRD =
      dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, false));
  if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
    Diag(TemplateIILoc,
         diag::ext_out_of_line_qualified_id_type_names_constructor)
      << TemplateII << 0 /*injected-class-name used as template name*/
      << (TemplateKWLoc.isValid() ? 1 : 0 /*'template'/'typename' keyword*/);
  }
}

// Translate the parser's template argument list in our AST format.
TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
translateTemplateArguments(TemplateArgsIn, TemplateArgs);

TemplateName Template = TemplateIn.get();
if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
  // Construct a dependent template specialization type.
  assert(DTN && "dependent template has non-dependent name?")(static_cast <bool> (DTN && "dependent template has non-dependent name?"
) ? void (0) : __assert_fail ("DTN && \"dependent template has non-dependent name?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9418, __extension__ __PRETTY_FUNCTION__));
  assert(DTN->getQualifier() == SS.getScopeRep())(static_cast <bool> (DTN->getQualifier() == SS.getScopeRep
()) ? void (0) : __assert_fail ("DTN->getQualifier() == SS.getScopeRep()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9419, __extension__ __PRETTY_FUNCTION__));
  QualType T = Context.getDependentTemplateSpecializationType(ETK_Typename,
                                                        DTN->getQualifier(),
                                                        DTN->getIdentifier(),
                                                              TemplateArgs);

  // Create source-location information for this type.
  TypeLocBuilder Builder;
  DependentTemplateSpecializationTypeLoc SpecTL
  = Builder.push<DependentTemplateSpecializationTypeLoc>(T);
  SpecTL.setElaboratedKeywordLoc(TypenameLoc);
  SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
  SpecTL.setTemplateNameLoc(TemplateIILoc);
  SpecTL.setLAngleLoc(LAngleLoc);
  SpecTL.setRAngleLoc(RAngleLoc);
  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
    SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
  return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
}

QualType T = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
if (T.isNull())
  return true;

// Provide source-location information for the template specialization type.
TypeLocBuilder Builder;
TemplateSpecializationTypeLoc SpecTL
  = Builder.push<TemplateSpecializationTypeLoc>(T);
SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
SpecTL.setTemplateNameLoc(TemplateIILoc);
SpecTL.setLAngleLoc(LAngleLoc);
SpecTL.setRAngleLoc(RAngleLoc);
for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());

T = Context.getElaboratedType(ETK_Typename, SS.getScopeRep(), T);
ElaboratedTypeLoc TL = Builder.push<ElaboratedTypeLoc>(T);
TL.setElaboratedKeywordLoc(TypenameLoc);
TL.setQualifierLoc(SS.getWithLocInContext(Context));

TypeSourceInfo *TSI = Builder.getTypeSourceInfo(Context, T);
return CreateParsedType(T, TSI);
9462}


9465/// Determine whether this failed name lookup should be treated as being
9466/// disabled by a usage of std::enable_if.
9467static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II,
                     SourceRange &CondRange, Expr *&Cond) {
// We must be looking for a ::type...
if (!II.isStr("type"))
  return false;

// ... within an explicitly-written template specialization...
if (!NNS || !NNS.getNestedNameSpecifier()->getAsType())
  return false;
TypeLoc EnableIfTy = NNS.getTypeLoc();
TemplateSpecializationTypeLoc EnableIfTSTLoc =
    EnableIfTy.getAs<TemplateSpecializationTypeLoc>();
if (!EnableIfTSTLoc || EnableIfTSTLoc.getNumArgs() == 0)
  return false;
const TemplateSpecializationType *EnableIfTST =
  cast<TemplateSpecializationType>(EnableIfTSTLoc.getTypePtr());

// ... which names a complete class template declaration...
const TemplateDecl *EnableIfDecl =
  EnableIfTST->getTemplateName().getAsTemplateDecl();
if (!EnableIfDecl || EnableIfTST->isIncompleteType())
  return false;

// ... called "enable_if".
const IdentifierInfo *EnableIfII =
  EnableIfDecl->getDeclName().getAsIdentifierInfo();
if (!EnableIfII || !EnableIfII->isStr("enable_if"))
  return false;

// Assume the first template argument is the condition.
CondRange = EnableIfTSTLoc.getArgLoc(0).getSourceRange();

// Dig out the condition.
Cond = nullptr;
if (EnableIfTSTLoc.getArgLoc(0).getArgument().getKind()
      != TemplateArgument::Expression)
  return true;

Cond = EnableIfTSTLoc.getArgLoc(0).getSourceExpression();

// Ignore Boolean literals; they add no value.
if (isa<CXXBoolLiteralExpr>(Cond->IgnoreParenCasts()))
  Cond = nullptr;

return true;
9512}

9514/// \brief Build the type that describes a C++ typename specifier,
9515/// e.g., "typename T::type".
9516QualType
9517Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword,
                      SourceLocation KeywordLoc,
                      NestedNameSpecifierLoc QualifierLoc,
                      const IdentifierInfo &II,
                      SourceLocation IILoc) {
CXXScopeSpec SS;
SS.Adopt(QualifierLoc);

DeclContext *Ctx = computeDeclContext(SS);
if (!Ctx) {
  // If the nested-name-specifier is dependent and couldn't be
  // resolved to a type, build a typename type.
  assert(QualifierLoc.getNestedNameSpecifier()->isDependent())(static_cast <bool> (QualifierLoc.getNestedNameSpecifier
()->isDependent()) ? void (0) : __assert_fail ("QualifierLoc.getNestedNameSpecifier()->isDependent()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9529, __extension__ __PRETTY_FUNCTION__));
  return Context.getDependentNameType(Keyword,
                                      QualifierLoc.getNestedNameSpecifier(),
                                      &II);
}

// If the nested-name-specifier refers to the current instantiation,
// the "typename" keyword itself is superfluous. In C++03, the
// program is actually ill-formed. However, DR 382 (in C++0x CD1)
// allows such extraneous "typename" keywords, and we retroactively
// apply this DR to C++03 code with only a warning. In any case we continue.

if (RequireCompleteDeclContext(SS, Ctx))
  return QualType();

DeclarationName Name(&II);
LookupResult Result(*this, Name, IILoc, LookupOrdinaryName);
LookupQualifiedName(Result, Ctx, SS);
unsigned DiagID = 0;
Decl *Referenced = nullptr;
switch (Result.getResultKind()) {
case LookupResult::NotFound: {
  // If we're looking up 'type' within a template named 'enable_if', produce
  // a more specific diagnostic.
  SourceRange CondRange;
  Expr *Cond = nullptr;
  if (isEnableIf(QualifierLoc, II, CondRange, Cond)) {
    // If we have a condition, narrow it down to the specific failed
    // condition.
    if (Cond) {
      Expr *FailedCond;
      std::string FailedDescription;
      std::tie(FailedCond, FailedDescription) =
        findFailedBooleanCondition(Cond, /*AllowTopLevelCond=*/true);

      Diag(FailedCond->getExprLoc(),
           diag::err_typename_nested_not_found_requirement)
        << FailedDescription
        << FailedCond->getSourceRange();
      return QualType();
    }

    Diag(CondRange.getBegin(), diag::err_typename_nested_not_found_enable_if)
        << Ctx << CondRange;
    return QualType();
  }

  DiagID = diag::err_typename_nested_not_found;
  break;
}

case LookupResult::FoundUnresolvedValue: {
  // We found a using declaration that is a value. Most likely, the using
  // declaration itself is meant to have the 'typename' keyword.
  SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
                        IILoc);
  Diag(IILoc, diag::err_typename_refers_to_using_value_decl)
    << Name << Ctx << FullRange;
  if (UnresolvedUsingValueDecl *Using
        = dyn_cast<UnresolvedUsingValueDecl>(Result.getRepresentativeDecl())){
    SourceLocation Loc = Using->getQualifierLoc().getBeginLoc();
    Diag(Loc, diag::note_using_value_decl_missing_typename)
      << FixItHint::CreateInsertion(Loc, "typename ");
  }
}
// Fall through to create a dependent typename type, from which we can recover
// better.
LLVM_FALLTHROUGH[[clang::fallthrough]];

case LookupResult::NotFoundInCurrentInstantiation:
  // Okay, it's a member of an unknown instantiation.
  return Context.getDependentNameType(Keyword,
                                      QualifierLoc.getNestedNameSpecifier(),
                                      &II);

case LookupResult::Found:
  if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) {
    // C++ [class.qual]p2:
    //   In a lookup in which function names are not ignored and the
    //   nested-name-specifier nominates a class C, if the name specified
    //   after the nested-name-specifier, when looked up in C, is the
    //   injected-class-name of C [...] then the name is instead considered
    //   to name the constructor of class C.
    //
    // Unlike in an elaborated-type-specifier, function names are not ignored
    // in typename-specifier lookup. However, they are ignored in all the
    // contexts where we form a typename type with no keyword (that is, in
    // mem-initializer-ids, base-specifiers, and elaborated-type-specifiers).
    //
    // FIXME: That's not strictly true: mem-initializer-id lookup does not
    // ignore functions, but that appears to be an oversight.
    auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(Ctx);
    auto *FoundRD = dyn_cast<CXXRecordDecl>(Type);
    if (Keyword == ETK_Typename && LookupRD && FoundRD &&
        FoundRD->isInjectedClassName() &&
        declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))
      Diag(IILoc, diag::ext_out_of_line_qualified_id_type_names_constructor)
          << &II << 1 << 0 /*'typename' keyword used*/;

    // We found a type. Build an ElaboratedType, since the
    // typename-specifier was just sugar.
    MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
    return Context.getElaboratedType(Keyword,
                                     QualifierLoc.getNestedNameSpecifier(),
                                     Context.getTypeDeclType(Type));
  }

  // C++ [dcl.type.simple]p2:
  //   A type-specifier of the form
  //     typename[opt] nested-name-specifier[opt] template-name
  //   is a placeholder for a deduced class type [...].
  if (getLangOpts().CPlusPlus17) {
    if (auto *TD = getAsTypeTemplateDecl(Result.getFoundDecl())) {
      return Context.getElaboratedType(
          Keyword, QualifierLoc.getNestedNameSpecifier(),
          Context.getDeducedTemplateSpecializationType(TemplateName(TD),
                                                       QualType(), false));
    }
  }

  DiagID = diag::err_typename_nested_not_type;
  Referenced = Result.getFoundDecl();
  break;

case LookupResult::FoundOverloaded:
  DiagID = diag::err_typename_nested_not_type;
  Referenced = *Result.begin();
  break;

case LookupResult::Ambiguous:
  return QualType();
}

// If we get here, it's because name lookup did not find a
// type. Emit an appropriate diagnostic and return an error.
SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
                      IILoc);
Diag(IILoc, DiagID) << FullRange << Name << Ctx;
if (Referenced)
  Diag(Referenced->getLocation(), diag::note_typename_refers_here)
    << Name;
return QualType();
9671}

9673namespace {
// See Sema::RebuildTypeInCurrentInstantiation
class CurrentInstantiationRebuilder
  : public TreeTransform<CurrentInstantiationRebuilder> {
  SourceLocation Loc;
  DeclarationName Entity;

public:
  typedef TreeTransform<CurrentInstantiationRebuilder> inherited;

  CurrentInstantiationRebuilder(Sema &SemaRef,
                                SourceLocation Loc,
                                DeclarationName Entity)
  : TreeTransform<CurrentInstantiationRebuilder>(SemaRef),
    Loc(Loc), Entity(Entity) { }

  /// \brief Determine whether the given type \p T has already been
  /// transformed.
  ///
  /// For the purposes of type reconstruction, a type has already been
  /// transformed if it is NULL or if it is not dependent.
  bool AlreadyTransformed(QualType T) {
    return T.isNull() || !T->isDependentType();
  }

  /// \brief Returns the location of the entity whose type is being
  /// rebuilt.
  SourceLocation getBaseLocation() { return Loc; }

  /// \brief Returns the name of the entity whose type is being rebuilt.
  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;
  }

  ExprResult TransformLambdaExpr(LambdaExpr *E) {
    // Lambdas never need to be transformed.
    return E;
  }
};
9717} // end anonymous namespace

9719/// \brief Rebuilds a type within the context of the current instantiation.
9720///
9721/// The type \p T is part of the type of an out-of-line member definition of
9722/// a class template (or class template partial specialization) that was parsed
9723/// and constructed before we entered the scope of the class template (or
9724/// partial specialization thereof). This routine will rebuild that type now
9725/// that we have entered the declarator's scope, which may produce different
9726/// canonical types, e.g.,
9727///
9728/// \code
9729/// template<typename T>
9730/// struct X {
9731///   typedef T* pointer;
9732///   pointer data();
9733/// };
9734///
9735/// template<typename T>
9736/// typename X<T>::pointer X<T>::data() { ... }
9737/// \endcode
9738///
9739/// Here, the type "typename X<T>::pointer" will be created as a DependentNameType,
9740/// since we do not know that we can look into X<T> when we parsed the type.
9741/// This function will rebuild the type, performing the lookup of "pointer"
9742/// in X<T> and returning an ElaboratedType whose canonical type is the same
9743/// as the canonical type of T*, allowing the return types of the out-of-line
9744/// definition and the declaration to match.
9745TypeSourceInfo *Sema::RebuildTypeInCurrentInstantiation(TypeSourceInfo *T,
                                                      SourceLocation Loc,
                                                      DeclarationName Name) {
if (!T || !T->getType()->isDependentType())
  return T;

CurrentInstantiationRebuilder Rebuilder(*this, Loc, Name);
return Rebuilder.TransformType(T);
9753}

9755ExprResult Sema::RebuildExprInCurrentInstantiation(Expr *E) {
CurrentInstantiationRebuilder Rebuilder(*this, E->getExprLoc(),
                                        DeclarationName());
return Rebuilder.TransformExpr(E);
9759}

9761bool Sema::RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS) {
if (SS.isInvalid())
  return true;

NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
CurrentInstantiationRebuilder Rebuilder(*this, SS.getRange().getBegin(),
                                        DeclarationName());
NestedNameSpecifierLoc Rebuilt
  = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);
if (!Rebuilt)
  return true;

SS.Adopt(Rebuilt);
return false;
9775}

9777/// \brief Rebuild the template parameters now that we know we're in a current
9778/// instantiation.
9779bool Sema::RebuildTemplateParamsInCurrentInstantiation(
                                             TemplateParameterList *Params) {
for (unsigned I = 0, N = Params->size(); I != N; ++I) {
  Decl *Param = Params->getParam(I);

  // There is nothing to rebuild in a type parameter.
  if (isa<TemplateTypeParmDecl>(Param))
    continue;

  // Rebuild the template parameter list of a template template parameter.
  if (TemplateTemplateParmDecl *TTP
      = dyn_cast<TemplateTemplateParmDecl>(Param)) {
    if (RebuildTemplateParamsInCurrentInstantiation(
          TTP->getTemplateParameters()))
      return true;

    continue;
  }

  // Rebuild the type of a non-type template parameter.
  NonTypeTemplateParmDecl *NTTP = cast<NonTypeTemplateParmDecl>(Param);
  TypeSourceInfo *NewTSI
    = RebuildTypeInCurrentInstantiation(NTTP->getTypeSourceInfo(),
                                        NTTP->getLocation(),
                                        NTTP->getDeclName());
  if (!NewTSI)
    return true;

  if (NewTSI != NTTP->getTypeSourceInfo()) {
    NTTP->setTypeSourceInfo(NewTSI);
    NTTP->setType(NewTSI->getType());
  }
}

return false;
9814}

9816/// \brief Produces a formatted string that describes the binding of
9817/// template parameters to template arguments.
9818std::string
9819Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params,
                                    const TemplateArgumentList &Args) {
return getTemplateArgumentBindingsText(Params, Args.data(), Args.size());
9822}

9824std::string
9825Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params,
                                    const TemplateArgument *Args,
                                    unsigned NumArgs) {
SmallString<128> Str;
llvm::raw_svector_ostream Out(Str);

if (!Params || Params->size() == 0 || NumArgs == 0)
  return std::string();

for (unsigned I = 0, N = Params->size(); I != N; ++I) {
  if (I >= NumArgs)
    break;

  if (I == 0)
    Out << "[with ";
  else
    Out << ", ";

  if (const IdentifierInfo *Id = Params->getParam(I)->getIdentifier()) {
    Out << Id->getName();
  } else {
    Out << '$' << I;
  }

  Out << " = ";
  Args[I].print(getPrintingPolicy(), Out);
}

Out << ']';
return Out.str();
9855}

9857void Sema::MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD,
                                  CachedTokens &Toks) {
if (!FD)
  return;

auto LPT = llvm::make_unique<LateParsedTemplate>();

// Take tokens to avoid allocations
LPT->Toks.swap(Toks);
LPT->D = FnD;
LateParsedTemplateMap.insert(std::make_pair(FD, std::move(LPT)));

FD->setLateTemplateParsed(true);
9870}

9872void Sema::UnmarkAsLateParsedTemplate(FunctionDecl *FD) {
if (!FD)
  return;
FD->setLateTemplateParsed(false);
9876}

9878bool Sema::IsInsideALocalClassWithinATemplateFunction() {
DeclContext *DC = CurContext;

while (DC) {
  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(CurContext)) {
    const FunctionDecl *FD = RD->isLocalClass();
    return (FD && FD->getTemplatedKind() != FunctionDecl::TK_NonTemplate);
  } else if (DC->isTranslationUnit() || DC->isNamespace())
    return false;

  DC = DC->getParent();
}
return false;
9891}

9893namespace {
9894/// \brief Walk the path from which a declaration was instantiated, and check
9895/// that every explicit specialization along that path is visible. This enforces
9896/// C++ [temp.expl.spec]/6:
9897///
9898///   If a template, a member template or a member of a class template is
9899///   explicitly specialized then that specialization shall be declared before
9900///   the first use of that specialization that would cause an implicit
9901///   instantiation to take place, in every translation unit in which such a
9902///   use occurs; no diagnostic is required.
9903///
9904/// and also C++ [temp.class.spec]/1:
9905///
9906///   A partial specialization shall be declared before the first use of a
9907///   class template specialization that would make use of the partial
9908///   specialization as the result of an implicit or explicit instantiation
9909///   in every translation unit in which such a use occurs; no diagnostic is
9910///   required.
9911class ExplicitSpecializationVisibilityChecker {
Sema &S;
SourceLocation Loc;
llvm::SmallVector<Module *, 8> Modules;

9916public:
ExplicitSpecializationVisibilityChecker(Sema &S, SourceLocation Loc)
    : S(S), Loc(Loc) {}

void check(NamedDecl *ND) {
  if (auto *FD = dyn_cast<FunctionDecl>(ND))
    return checkImpl(FD);
  if (auto *RD = dyn_cast<CXXRecordDecl>(ND))
    return checkImpl(RD);
  if (auto *VD = dyn_cast<VarDecl>(ND))
    return checkImpl(VD);
  if (auto *ED = dyn_cast<EnumDecl>(ND))
    return checkImpl(ED);
}

9931private:
void diagnose(NamedDecl *D, bool IsPartialSpec) {
  auto Kind = IsPartialSpec ? Sema::MissingImportKind::PartialSpecialization
                            : Sema::MissingImportKind::ExplicitSpecialization;
  const bool Recover = true;

  // If we got a custom set of modules (because only a subset of the
  // declarations are interesting), use them, otherwise let
  // diagnoseMissingImport intelligently pick some.
  if (Modules.empty())
    S.diagnoseMissingImport(Loc, D, Kind, Recover);
  else
    S.diagnoseMissingImport(Loc, D, D->getLocation(), Modules, Kind, Recover);
}

// Check a specific declaration. There are three problematic cases:
//
//  1) The declaration is an explicit specialization of a template
//     specialization.
//  2) The declaration is an explicit specialization of a member of an
//     templated class.
//  3) The declaration is an instantiation of a template, and that template
//     is an explicit specialization of a member of a templated class.
//
// We don't need to go any deeper than that, as the instantiation of the
// surrounding class / etc is not triggered by whatever triggered this
// instantiation, and thus should be checked elsewhere.
template<typename SpecDecl>
void checkImpl(SpecDecl *Spec) {
  bool IsHiddenExplicitSpecialization = false;
  if (Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {
    IsHiddenExplicitSpecialization =
        Spec->getMemberSpecializationInfo()
            ? !S.hasVisibleMemberSpecialization(Spec, &Modules)
            : !S.hasVisibleExplicitSpecialization(Spec, &Modules);
  } else {
    checkInstantiated(Spec);
  }

  if (IsHiddenExplicitSpecialization)
    diagnose(Spec->getMostRecentDecl(), false);
}

void checkInstantiated(FunctionDecl *FD) {
  if (auto *TD = FD->getPrimaryTemplate())
    checkTemplate(TD);
}

void checkInstantiated(CXXRecordDecl *RD) {
  auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
  if (!SD)
    return;

  auto From = SD->getSpecializedTemplateOrPartial();
  if (auto *TD = From.dyn_cast<ClassTemplateDecl *>())
    checkTemplate(TD);
  else if (auto *TD =
               From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
    if (!S.hasVisibleDeclaration(TD))
      diagnose(TD, true);
    checkTemplate(TD);
  }
}

void checkInstantiated(VarDecl *RD) {
  auto *SD = dyn_cast<VarTemplateSpecializationDecl>(RD);
  if (!SD)
    return;

  auto From = SD->getSpecializedTemplateOrPartial();
  if (auto *TD = From.dyn_cast<VarTemplateDecl *>())
    checkTemplate(TD);
  else if (auto *TD =
               From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
    if (!S.hasVisibleDeclaration(TD))
      diagnose(TD, true);
    checkTemplate(TD);
  }
}

void checkInstantiated(EnumDecl *FD) {}

template<typename TemplDecl>
void checkTemplate(TemplDecl *TD) {
  if (TD->isMemberSpecialization()) {
    if (!S.hasVisibleMemberSpecialization(TD, &Modules))
      diagnose(TD->getMostRecentDecl(), false);
  }
}
10020};
10021} // end anonymous namespace

10023void Sema::checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec) {
if (!getLangOpts().Modules)
  return;

ExplicitSpecializationVisibilityChecker(*this, Loc).check(Spec);
10028}

10030/// \brief Check whether a template partial specialization that we've discovered
10031/// is hidden, and produce suitable diagnostics if so.
10032void Sema::checkPartialSpecializationVisibility(SourceLocation Loc,
                                              NamedDecl *Spec) {
llvm::SmallVector<Module *, 8> Modules;
if (!hasVisibleDeclaration(Spec, &Modules))
  diagnoseMissingImport(Loc, Spec, Spec->getLocation(), Modules,
                        MissingImportKind::PartialSpecialization,
                        /*Recover*/true);
10039}

←

/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h

→

1//===- ASTContext.h - Context to hold long-lived AST nodes ------*- 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 clang::ASTContext interface.
12//
13//===----------------------------------------------------------------------===//

15#ifndef LLVM_CLANG_AST_ASTCONTEXT_H
16#define LLVM_CLANG_AST_ASTCONTEXT_H

18#include "clang/AST/ASTTypeTraits.h"
19#include "clang/AST/CanonicalType.h"
20#include "clang/AST/CommentCommandTraits.h"
21#include "clang/AST/Decl.h"
22#include "clang/AST/DeclBase.h"
23#include "clang/AST/DeclarationName.h"
24#include "clang/AST/ExternalASTSource.h"
25#include "clang/AST/NestedNameSpecifier.h"
26#include "clang/AST/PrettyPrinter.h"
27#include "clang/AST/RawCommentList.h"
28#include "clang/AST/TemplateBase.h"
29#include "clang/AST/TemplateName.h"
30#include "clang/AST/Type.h"
31#include "clang/Basic/AddressSpaces.h"
32#include "clang/Basic/IdentifierTable.h"
33#include "clang/Basic/LLVM.h"
34#include "clang/Basic/LangOptions.h"
35#include "clang/Basic/Linkage.h"
36#include "clang/Basic/OperatorKinds.h"
37#include "clang/Basic/PartialDiagnostic.h"
38#include "clang/Basic/SanitizerBlacklist.h"
39#include "clang/Basic/SourceLocation.h"
40#include "clang/Basic/Specifiers.h"
41#include "clang/Basic/TargetInfo.h"
42#include "clang/Basic/XRayLists.h"
43#include "llvm/ADT/APSInt.h"
44#include "llvm/ADT/ArrayRef.h"
45#include "llvm/ADT/DenseMap.h"
46#include "llvm/ADT/FoldingSet.h"
47#include "llvm/ADT/IntrusiveRefCntPtr.h"
48#include "llvm/ADT/MapVector.h"
49#include "llvm/ADT/None.h"
50#include "llvm/ADT/Optional.h"
51#include "llvm/ADT/PointerIntPair.h"
52#include "llvm/ADT/PointerUnion.h"
53#include "llvm/ADT/SmallVector.h"
54#include "llvm/ADT/StringMap.h"
55#include "llvm/ADT/StringRef.h"
56#include "llvm/ADT/TinyPtrVector.h"
57#include "llvm/ADT/Triple.h"
58#include "llvm/ADT/iterator_range.h"
59#include "llvm/Support/AlignOf.h"
60#include "llvm/Support/Allocator.h"
61#include "llvm/Support/Casting.h"
62#include "llvm/Support/Compiler.h"
63#include <cassert>
64#include <cstddef>
65#include <cstdint>
66#include <iterator>
67#include <memory>
68#include <string>
69#include <type_traits>
70#include <utility>
71#include <vector>

73namespace llvm {

75struct fltSemantics;

77} // namespace llvm

79namespace clang {

81class APValue;
82class ASTMutationListener;
83class ASTRecordLayout;
84class AtomicExpr;
85class BlockExpr;
86class BuiltinTemplateDecl;
87class CharUnits;
88class CXXABI;
89class CXXConstructorDecl;
90class CXXMethodDecl;
91class CXXRecordDecl;
92class DiagnosticsEngine;
93class Expr;
94class MangleContext;
95class MangleNumberingContext;
96class MaterializeTemporaryExpr;
97class MemberSpecializationInfo;
98class Module;
99class ObjCCategoryDecl;
100class ObjCCategoryImplDecl;
101class ObjCContainerDecl;
102class ObjCImplDecl;
103class ObjCImplementationDecl;
104class ObjCInterfaceDecl;
105class ObjCIvarDecl;
106class ObjCMethodDecl;
107class ObjCPropertyDecl;
108class ObjCPropertyImplDecl;
109class ObjCProtocolDecl;
110class ObjCTypeParamDecl;
111class Preprocessor;
112class Stmt;
113class StoredDeclsMap;
114class TemplateDecl;
115class TemplateParameterList;
116class TemplateTemplateParmDecl;
117class TemplateTypeParmDecl;
118class UnresolvedSetIterator;
119class UsingShadowDecl;
120class VarTemplateDecl;
121class VTableContextBase;

123namespace Builtin {

125class Context;

127} // namespace Builtin

129enum BuiltinTemplateKind : int;

131namespace comments {

133class FullComment;

135} // namespace comments

137struct TypeInfo {
uint64_t Width = 0;
unsigned Align = 0;
bool AlignIsRequired : 1;

TypeInfo() : AlignIsRequired(false) {}
TypeInfo(uint64_t Width, unsigned Align, bool AlignIsRequired)
    : Width(Width), Align(Align), AlignIsRequired(AlignIsRequired) {}
145};

147/// \brief Holds long-lived AST nodes (such as types and decls) that can be
148/// referred to throughout the semantic analysis of a file.
149class ASTContext : public RefCountedBase<ASTContext> {
friend class NestedNameSpecifier;

mutable SmallVector<Type *, 0> Types;
mutable llvm::FoldingSet<ExtQuals> ExtQualNodes;
mutable llvm::FoldingSet<ComplexType> ComplexTypes;
mutable llvm::FoldingSet<PointerType> PointerTypes;
mutable llvm::FoldingSet<AdjustedType> AdjustedTypes;
mutable llvm::FoldingSet<BlockPointerType> BlockPointerTypes;
mutable llvm::FoldingSet<LValueReferenceType> LValueReferenceTypes;
mutable llvm::FoldingSet<RValueReferenceType> RValueReferenceTypes;
mutable llvm::FoldingSet<MemberPointerType> MemberPointerTypes;
mutable llvm::FoldingSet<ConstantArrayType> ConstantArrayTypes;
mutable llvm::FoldingSet<IncompleteArrayType> IncompleteArrayTypes;
mutable std::vector<VariableArrayType*> VariableArrayTypes;
mutable llvm::FoldingSet<DependentSizedArrayType> DependentSizedArrayTypes;
mutable llvm::FoldingSet<DependentSizedExtVectorType>
  DependentSizedExtVectorTypes;
mutable llvm::FoldingSet<DependentAddressSpaceType>
    DependentAddressSpaceTypes;
mutable llvm::FoldingSet<VectorType> VectorTypes;
mutable llvm::FoldingSet<FunctionNoProtoType> FunctionNoProtoTypes;
mutable llvm::ContextualFoldingSet<FunctionProtoType, ASTContext&>
  FunctionProtoTypes;
mutable llvm::FoldingSet<DependentTypeOfExprType> DependentTypeOfExprTypes;
mutable llvm::FoldingSet<DependentDecltypeType> DependentDecltypeTypes;
mutable llvm::FoldingSet<TemplateTypeParmType> TemplateTypeParmTypes;
mutable llvm::FoldingSet<ObjCTypeParamType> ObjCTypeParamTypes;
mutable llvm::FoldingSet<SubstTemplateTypeParmType>
  SubstTemplateTypeParmTypes;
mutable llvm::FoldingSet<SubstTemplateTypeParmPackType>
  SubstTemplateTypeParmPackTypes;
mutable llvm::ContextualFoldingSet<TemplateSpecializationType, ASTContext&>
  TemplateSpecializationTypes;
mutable llvm::FoldingSet<ParenType> ParenTypes;
mutable llvm::FoldingSet<ElaboratedType> ElaboratedTypes;
mutable llvm::FoldingSet<DependentNameType> DependentNameTypes;
mutable llvm::ContextualFoldingSet<DependentTemplateSpecializationType,
                                   ASTContext&>
  DependentTemplateSpecializationTypes;
llvm::FoldingSet<PackExpansionType> PackExpansionTypes;
mutable llvm::FoldingSet<ObjCObjectTypeImpl> ObjCObjectTypes;
mutable llvm::FoldingSet<ObjCObjectPointerType> ObjCObjectPointerTypes;
mutable llvm::FoldingSet<DependentUnaryTransformType>
  DependentUnaryTransformTypes;
mutable llvm::FoldingSet<AutoType> AutoTypes;
mutable llvm::FoldingSet<DeducedTemplateSpecializationType>
  DeducedTemplateSpecializationTypes;
mutable llvm::FoldingSet<AtomicType> AtomicTypes;
llvm::FoldingSet<AttributedType> AttributedTypes;
mutable llvm::FoldingSet<PipeType> PipeTypes;

mutable llvm::FoldingSet<QualifiedTemplateName> QualifiedTemplateNames;
mutable llvm::FoldingSet<DependentTemplateName> DependentTemplateNames;
mutable llvm::FoldingSet<SubstTemplateTemplateParmStorage>
  SubstTemplateTemplateParms;
mutable llvm::ContextualFoldingSet<SubstTemplateTemplateParmPackStorage,
                                   ASTContext&>
  SubstTemplateTemplateParmPacks;

/// \brief The set of nested name specifiers.
///
/// This set is managed by the NestedNameSpecifier class.
mutable llvm::FoldingSet<NestedNameSpecifier> NestedNameSpecifiers;
mutable NestedNameSpecifier *GlobalNestedNameSpecifier = nullptr;

/// \brief A cache mapping from RecordDecls to ASTRecordLayouts.
///
/// This is lazily created.  This is intentionally not serialized.
mutable llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>
  ASTRecordLayouts;
mutable llvm::DenseMap<const ObjCContainerDecl*, const ASTRecordLayout*>
  ObjCLayouts;

/// \brief A cache from types to size and alignment information.
using TypeInfoMap = llvm::DenseMap<const Type *, struct TypeInfo>;
mutable TypeInfoMap MemoizedTypeInfo;

/// \brief A cache mapping from CXXRecordDecls to key functions.
llvm::DenseMap<const CXXRecordDecl*, LazyDeclPtr> KeyFunctions;

/// \brief Mapping from ObjCContainers to their ObjCImplementations.
llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*> ObjCImpls;

/// \brief Mapping from ObjCMethod to its duplicate declaration in the same
/// interface.
llvm::DenseMap<const ObjCMethodDecl*,const ObjCMethodDecl*> ObjCMethodRedecls;

/// \brief Mapping from __block VarDecls to their copy initialization expr.
llvm::DenseMap<const VarDecl*, Expr*> BlockVarCopyInits;

/// \brief Mapping from class scope functions specialization to their
/// template patterns.
llvm::DenseMap<const FunctionDecl*, FunctionDecl*>
  ClassScopeSpecializationPattern;

/// \brief Mapping from materialized temporaries with static storage duration
/// that appear in constant initializers to their evaluated values.  These are
/// allocated in a std::map because their address must be stable.
llvm::DenseMap<const MaterializeTemporaryExpr *, APValue *>
  MaterializedTemporaryValues;

/// \brief Representation of a "canonical" template template parameter that
/// is used in canonical template names.
class CanonicalTemplateTemplateParm : public llvm::FoldingSetNode {
  TemplateTemplateParmDecl *Parm;

public:
  CanonicalTemplateTemplateParm(TemplateTemplateParmDecl *Parm)
      : Parm(Parm) {}

  TemplateTemplateParmDecl *getParam() const { return Parm; }

  void Profile(llvm::FoldingSetNodeID &ID) { Profile(ID, Parm); }

  static void Profile(llvm::FoldingSetNodeID &ID,
                      TemplateTemplateParmDecl *Parm);
};
mutable llvm::FoldingSet<CanonicalTemplateTemplateParm>
  CanonTemplateTemplateParms;

TemplateTemplateParmDecl *
  getCanonicalTemplateTemplateParmDecl(TemplateTemplateParmDecl *TTP) const;

/// \brief The typedef for the __int128_t type.
mutable TypedefDecl *Int128Decl = nullptr;

/// \brief The typedef for the __uint128_t type.
mutable TypedefDecl *UInt128Decl = nullptr;

/// \brief The typedef for the target specific predefined
/// __builtin_va_list type.
mutable TypedefDecl *BuiltinVaListDecl = nullptr;

/// The typedef for the predefined \c __builtin_ms_va_list type.
mutable TypedefDecl *BuiltinMSVaListDecl = nullptr;

/// \brief The typedef for the predefined \c id type.
mutable TypedefDecl *ObjCIdDecl = nullptr;

/// \brief The typedef for the predefined \c SEL type.
mutable TypedefDecl *ObjCSelDecl = nullptr;

/// \brief The typedef for the predefined \c Class type.
mutable TypedefDecl *ObjCClassDecl = nullptr;

/// \brief The typedef for the predefined \c Protocol class in Objective-C.
mutable ObjCInterfaceDecl *ObjCProtocolClassDecl = nullptr;

/// \brief The typedef for the predefined 'BOOL' type.
mutable TypedefDecl *BOOLDecl = nullptr;

// Typedefs which may be provided defining the structure of Objective-C
// pseudo-builtins
QualType ObjCIdRedefinitionType;
QualType ObjCClassRedefinitionType;
QualType ObjCSelRedefinitionType;

/// The identifier 'bool'.
mutable IdentifierInfo *BoolName = nullptr;

/// The identifier 'NSObject'.
IdentifierInfo *NSObjectName = nullptr;

/// The identifier 'NSCopying'.
IdentifierInfo *NSCopyingName = nullptr;

/// The identifier '__make_integer_seq'.
mutable IdentifierInfo *MakeIntegerSeqName = nullptr;

/// The identifier '__type_pack_element'.
mutable IdentifierInfo *TypePackElementName = nullptr;

QualType ObjCConstantStringType;
mutable RecordDecl *CFConstantStringTagDecl = nullptr;
mutable TypedefDecl *CFConstantStringTypeDecl = nullptr;

mutable QualType ObjCSuperType;

QualType ObjCNSStringType;

/// \brief The typedef declaration for the Objective-C "instancetype" type.
TypedefDecl *ObjCInstanceTypeDecl = nullptr;

/// \brief The type for the C FILE type.
TypeDecl *FILEDecl = nullptr;

/// \brief The type for the C jmp_buf type.
TypeDecl *jmp_bufDecl = nullptr;

/// \brief The type for the C sigjmp_buf type.
TypeDecl *sigjmp_bufDecl = nullptr;

/// \brief The type for the C ucontext_t type.
TypeDecl *ucontext_tDecl = nullptr;

/// \brief Type for the Block descriptor for Blocks CodeGen.
///
/// Since this is only used for generation of debug info, it is not
/// serialized.
mutable RecordDecl *BlockDescriptorType = nullptr;

/// \brief Type for the Block descriptor for Blocks CodeGen.
///
/// Since this is only used for generation of debug info, it is not
/// serialized.
mutable RecordDecl *BlockDescriptorExtendedType = nullptr;

/// \brief Declaration for the CUDA cudaConfigureCall function.
FunctionDecl *cudaConfigureCallDecl = nullptr;

/// \brief Keeps track of all declaration attributes.
///
/// Since so few decls have attrs, we keep them in a hash map instead of
/// wasting space in the Decl class.
llvm::DenseMap<const Decl*, AttrVec*> DeclAttrs;

/// \brief A mapping from non-redeclarable declarations in modules that were
/// merged with other declarations to the canonical declaration that they were
/// merged into.
llvm::DenseMap<Decl*, Decl*> MergedDecls;

/// \brief A mapping from a defining declaration to a list of modules (other
/// than the owning module of the declaration) that contain merged
/// definitions of that entity.
llvm::DenseMap<NamedDecl*, llvm::TinyPtrVector<Module*>> MergedDefModules;

/// \brief Initializers for a module, in order. Each Decl will be either
/// something that has a semantic effect on startup (such as a variable with
/// a non-constant initializer), or an ImportDecl (which recursively triggers
/// initialization of another module).
struct PerModuleInitializers {
  llvm::SmallVector<Decl*, 4> Initializers;
  llvm::SmallVector<uint32_t, 4> LazyInitializers;

  void resolve(ASTContext &Ctx);
};
llvm::DenseMap<Module*, PerModuleInitializers*> ModuleInitializers;

ASTContext &this_() { return *this; }

390public:
/// \brief A type synonym for the TemplateOrInstantiation mapping.
using TemplateOrSpecializationInfo =
    llvm::PointerUnion<VarTemplateDecl *, MemberSpecializationInfo *>;

395private:
friend class ASTDeclReader;
friend class ASTReader;
friend class ASTWriter;
friend class CXXRecordDecl;

/// \brief A mapping to contain the template or declaration that
/// a variable declaration describes or was instantiated from,
/// respectively.
///
/// For non-templates, this value will be NULL. For variable
/// declarations that describe a variable template, this will be a
/// pointer to a VarTemplateDecl. For static data members
/// of class template specializations, this will be the
/// MemberSpecializationInfo referring to the member variable that was
/// instantiated or specialized. Thus, the mapping will keep track of
/// the static data member templates from which static data members of
/// class template specializations were instantiated.
///
/// Given the following example:
///
/// \code
/// template<typename T>
/// struct X {
///   static T value;
/// };
///
/// template<typename T>
///   T X<T>::value = T(17);
///
/// int *x = &X<int>::value;
/// \endcode
///
/// This mapping will contain an entry that maps from the VarDecl for
/// X<int>::value to the corresponding VarDecl for X<T>::value (within the
/// class template X) and will be marked TSK_ImplicitInstantiation.
llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>
TemplateOrInstantiation;

/// \brief Keeps track of the declaration from which a using declaration was
/// created during instantiation.
///
/// The source and target declarations are always a UsingDecl, an
/// UnresolvedUsingValueDecl, or an UnresolvedUsingTypenameDecl.
///
/// For example:
/// \code
/// template<typename T>
/// struct A {
///   void f();
/// };
///
/// template<typename T>
/// struct B : A<T> {
///   using A<T>::f;
/// };
///
/// template struct B<int>;
/// \endcode
///
/// This mapping will contain an entry that maps from the UsingDecl in
/// B<int> to the UnresolvedUsingDecl in B<T>.
llvm::DenseMap<NamedDecl *, NamedDecl *> InstantiatedFromUsingDecl;

llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>
  InstantiatedFromUsingShadowDecl;

llvm::DenseMap<FieldDecl *, FieldDecl *> InstantiatedFromUnnamedFieldDecl;

/// \brief Mapping that stores the methods overridden by a given C++
/// member function.
///
/// Since most C++ member functions aren't virtual and therefore
/// don't override anything, we store the overridden functions in
/// this map on the side rather than within the CXXMethodDecl structure.
using CXXMethodVector = llvm::TinyPtrVector<const CXXMethodDecl *>;
llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector> OverriddenMethods;

/// \brief Mapping from each declaration context to its corresponding
/// mangling numbering context (used for constructs like lambdas which
/// need to be consistently numbered for the mangler).
llvm::DenseMap<const DeclContext *, std::unique_ptr<MangleNumberingContext>>
    MangleNumberingContexts;

/// \brief Side-table of mangling numbers for declarations which rarely
/// need them (like static local vars).
llvm::MapVector<const NamedDecl *, unsigned> MangleNumbers;
llvm::MapVector<const VarDecl *, unsigned> StaticLocalNumbers;

/// \brief Mapping that stores parameterIndex values for ParmVarDecls when
/// that value exceeds the bitfield size of ParmVarDeclBits.ParameterIndex.
using ParameterIndexTable = llvm::DenseMap<const VarDecl *, unsigned>;
ParameterIndexTable ParamIndices;

ImportDecl *FirstLocalImport = nullptr;
ImportDecl *LastLocalImport = nullptr;

TranslationUnitDecl *TUDecl;
mutable ExternCContextDecl *ExternCContext = nullptr;
mutable BuiltinTemplateDecl *MakeIntegerSeqDecl = nullptr;
mutable BuiltinTemplateDecl *TypePackElementDecl = nullptr;

/// \brief The associated SourceManager object.
SourceManager &SourceMgr;

/// \brief The language options used to create the AST associated with
///  this ASTContext object.
LangOptions &LangOpts;

/// \brief Blacklist object that is used by sanitizers to decide which
/// entities should not be instrumented.
std::unique_ptr<SanitizerBlacklist> SanitizerBL;

/// \brief Function filtering mechanism to determine whether a given function
/// should be imbued with the XRay "always" or "never" attributes.
std::unique_ptr<XRayFunctionFilter> XRayFilter;

/// \brief The allocator used to create AST objects.
///
/// AST objects are never destructed; rather, all memory associated with the
/// AST objects will be released when the ASTContext itself is destroyed.
mutable llvm::BumpPtrAllocator BumpAlloc;

/// \brief Allocator for partial diagnostics.
PartialDiagnostic::StorageAllocator DiagAllocator;

/// \brief The current C++ ABI.
std::unique_ptr<CXXABI> ABI;
CXXABI *createCXXABI(const TargetInfo &T);

/// \brief The logical -> physical address space map.
const LangASMap *AddrSpaceMap = nullptr;

/// \brief Address space map mangling must be used with language specific
/// address spaces (e.g. OpenCL/CUDA)
bool AddrSpaceMapMangling;

const TargetInfo *Target = nullptr;
const TargetInfo *AuxTarget = nullptr;
clang::PrintingPolicy PrintingPolicy;

536public:
IdentifierTable &Idents;
SelectorTable &Selectors;
Builtin::Context &BuiltinInfo;
mutable DeclarationNameTable DeclarationNames;
IntrusiveRefCntPtr<ExternalASTSource> ExternalSource;
ASTMutationListener *Listener = nullptr;

/// \brief Contains parents of a node.
using ParentVector = llvm::SmallVector<ast_type_traits::DynTypedNode, 2>;

/// \brief Maps from a node to its parents. This is used for nodes that have
/// pointer identity only, which are more common and we can save space by
/// only storing a unique pointer to them.
using ParentMapPointers =
    llvm::DenseMap<const void *,
                   llvm::PointerUnion4<const Decl *, const Stmt *,
                                       ast_type_traits::DynTypedNode *,
                                       ParentVector *>>;

/// Parent map for nodes without pointer identity. We store a full
/// DynTypedNode for all keys.
using ParentMapOtherNodes =
    llvm::DenseMap<ast_type_traits::DynTypedNode,
                   llvm::PointerUnion4<const Decl *, const Stmt *,
                                       ast_type_traits::DynTypedNode *,
                                       ParentVector *>>;

/// Container for either a single DynTypedNode or for an ArrayRef to
/// DynTypedNode. For use with ParentMap.
class DynTypedNodeList {
  using DynTypedNode = ast_type_traits::DynTypedNode;

  llvm::AlignedCharArrayUnion<ast_type_traits::DynTypedNode,
                              ArrayRef<DynTypedNode>> Storage;
  bool IsSingleNode;

public:
  DynTypedNodeList(const DynTypedNode &N) : IsSingleNode(true) {
    new (Storage.buffer) DynTypedNode(N);
  }

  DynTypedNodeList(ArrayRef<DynTypedNode> A) : IsSingleNode(false) {
    new (Storage.buffer) ArrayRef<DynTypedNode>(A);
  }

  const ast_type_traits::DynTypedNode *begin() const {
    if (!IsSingleNode)
      return reinterpret_cast<const ArrayRef<DynTypedNode> *>(Storage.buffer)
          ->begin();
    return reinterpret_cast<const DynTypedNode *>(Storage.buffer);
  }

  const ast_type_traits::DynTypedNode *end() const {
    if (!IsSingleNode)
      return reinterpret_cast<const ArrayRef<DynTypedNode> *>(Storage.buffer)
          ->end();
    return reinterpret_cast<const DynTypedNode *>(Storage.buffer) + 1;
  }

  size_t size() const { return end() - begin(); }
  bool empty() const { return begin() == end(); }

  const DynTypedNode &operator[](size_t N) const {
    assert(N < size() && "Out of bounds!")(static_cast <bool> (N < size() && "Out of bounds!"
) ? void (0) : __assert_fail ("N < size() && \"Out of bounds!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 600, __extension__ __PRETTY_FUNCTION__));
    return *(begin() + N);
  }
};

/// \brief Returns the parents of the given node.
///
/// Note that this will lazily compute the parents of all nodes
/// and store them for later retrieval. Thus, the first call is O(n)
/// in the number of AST nodes.
///
/// Caveats and FIXMEs:
/// Calculating the parent map over all AST nodes will need to load the
/// full AST. This can be undesirable in the case where the full AST is
/// expensive to create (for example, when using precompiled header
/// preambles). Thus, there are good opportunities for optimization here.
/// One idea is to walk the given node downwards, looking for references
/// to declaration contexts - once a declaration context is found, compute
/// the parent map for the declaration context; if that can satisfy the
/// request, loading the whole AST can be avoided. Note that this is made
/// more complex by statements in templates having multiple parents - those
/// problems can be solved by building closure over the templated parts of
/// the AST, which also avoids touching large parts of the AST.
/// Additionally, we will want to add an interface to already give a hint
/// where to search for the parents, for example when looking at a statement
/// inside a certain function.
///
/// 'NodeT' can be one of Decl, Stmt, Type, TypeLoc,
/// NestedNameSpecifier or NestedNameSpecifierLoc.
template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node) {
  return getParents(ast_type_traits::DynTypedNode::create(Node));
}

DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node);

const clang::PrintingPolicy &getPrintingPolicy() const {
  return PrintingPolicy;
}

void setPrintingPolicy(const clang::PrintingPolicy &Policy) {
  PrintingPolicy = Policy;
}

SourceManager& getSourceManager() { return SourceMgr; }
const SourceManager& getSourceManager() const { return SourceMgr; }

llvm::BumpPtrAllocator &getAllocator() const {
  return BumpAlloc;
}

void *Allocate(size_t Size, unsigned Align = 8) const {
  return BumpAlloc.Allocate(Size, Align);
}
template <typename T> T *Allocate(size_t Num = 1) const {
  return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
}
void Deallocate(void *Ptr) const {}

/// Return the total amount of physical memory allocated for representing
/// AST nodes and type information.
size_t getASTAllocatedMemory() const {
  return BumpAlloc.getTotalMemory();
}

/// Return the total memory used for various side tables.
size_t getSideTableAllocatedMemory() const;

PartialDiagnostic::StorageAllocator &getDiagAllocator() {
  return DiagAllocator;
}

const TargetInfo &getTargetInfo() const { return *Target; }
const TargetInfo *getAuxTargetInfo() const { return AuxTarget; }

/// getIntTypeForBitwidth -
/// sets integer QualTy according to specified details:
/// bitwidth, signed/unsigned.
/// Returns empty type if there is no appropriate target types.
QualType getIntTypeForBitwidth(unsigned DestWidth,
                               unsigned Signed) const;

/// getRealTypeForBitwidth -
/// sets floating point QualTy according to specified bitwidth.
/// Returns empty type if there is no appropriate target types.
QualType getRealTypeForBitwidth(unsigned DestWidth) const;

bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const;

const LangOptions& getLangOpts() const { return LangOpts; }

const SanitizerBlacklist &getSanitizerBlacklist() const {
  return *SanitizerBL;
}

const XRayFunctionFilter &getXRayFilter() const {
  return *XRayFilter;
}

DiagnosticsEngine &getDiagnostics() const;

FullSourceLoc getFullLoc(SourceLocation Loc) const {
  return FullSourceLoc(Loc,SourceMgr);
}

/// \brief All comments in this translation unit.
RawCommentList Comments;

/// \brief True if comments are already loaded from ExternalASTSource.
mutable bool CommentsLoaded = false;

class RawCommentAndCacheFlags {
public:
  enum Kind {
    /// We searched for a comment attached to the particular declaration, but
    /// didn't find any.
    ///
    /// getRaw() == 0.
    NoCommentInDecl = 0,

    /// We have found a comment attached to this particular declaration.
    ///
    /// getRaw() != 0.
    FromDecl,

    /// This declaration does not have an attached comment, and we have
    /// searched the redeclaration chain.
    ///
    /// If getRaw() == 0, the whole redeclaration chain does not have any
    /// comments.
    ///
    /// If getRaw() != 0, it is a comment propagated from other
    /// redeclaration.
    FromRedecl
  };

  Kind getKind() const LLVM_READONLY__attribute__((__pure__)) {
    return Data.getInt();
  }

  void setKind(Kind K) {
    Data.setInt(K);
  }

  const RawComment *getRaw() const LLVM_READONLY__attribute__((__pure__)) {
    return Data.getPointer();
  }

  void setRaw(const RawComment *RC) {
    Data.setPointer(RC);
  }

  const Decl *getOriginalDecl() const LLVM_READONLY__attribute__((__pure__)) {
    return OriginalDecl;
  }

  void setOriginalDecl(const Decl *Orig) {
    OriginalDecl = Orig;
  }

private:
  llvm::PointerIntPair<const RawComment *, 2, Kind> Data;
  const Decl *OriginalDecl;
};

/// \brief Mapping from declarations to comments attached to any
/// redeclaration.
///
/// Raw comments are owned by Comments list.  This mapping is populated
/// lazily.
mutable llvm::DenseMap<const Decl *, RawCommentAndCacheFlags> RedeclComments;

/// \brief Mapping from declarations to parsed comments attached to any
/// redeclaration.
mutable llvm::DenseMap<const Decl *, comments::FullComment *> ParsedComments;

/// \brief Return the documentation comment attached to a given declaration,
/// without looking into cache.
RawComment *getRawCommentForDeclNoCache(const Decl *D) const;

779public:
RawCommentList &getRawCommentList() {
  return Comments;
}

void addComment(const RawComment &RC) {
  assert(LangOpts.RetainCommentsFromSystemHeaders ||(static_cast <bool> (LangOpts.RetainCommentsFromSystemHeaders
 || !SourceMgr.isInSystemHeader(RC.getSourceRange().getBegin(
))) ? void (0) : __assert_fail ("LangOpts.RetainCommentsFromSystemHeaders || !SourceMgr.isInSystemHeader(RC.getSourceRange().getBegin())"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 786, __extension__ __PRETTY_FUNCTION__))
         !SourceMgr.isInSystemHeader(RC.getSourceRange().getBegin()))(static_cast <bool> (LangOpts.RetainCommentsFromSystemHeaders
 || !SourceMgr.isInSystemHeader(RC.getSourceRange().getBegin(
))) ? void (0) : __assert_fail ("LangOpts.RetainCommentsFromSystemHeaders || !SourceMgr.isInSystemHeader(RC.getSourceRange().getBegin())"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 786, __extension__ __PRETTY_FUNCTION__));
  Comments.addComment(RC, BumpAlloc);
}

/// \brief Return the documentation comment attached to a given declaration.
/// Returns nullptr if no comment is attached.
///
/// \param OriginalDecl if not nullptr, is set to declaration AST node that
/// had the comment, if the comment we found comes from a redeclaration.
const RawComment *
getRawCommentForAnyRedecl(const Decl *D,
                          const Decl **OriginalDecl = nullptr) const;

/// Return parsed documentation comment attached to a given declaration.
/// Returns nullptr if no comment is attached.
///
/// \param PP the Preprocessor used with this TU.  Could be nullptr if
/// preprocessor is not available.
comments::FullComment *getCommentForDecl(const Decl *D,
                                         const Preprocessor *PP) const;

/// Return parsed documentation comment attached to a given declaration.
/// Returns nullptr if no comment is attached. Does not look at any
/// redeclarations of the declaration.
comments::FullComment *getLocalCommentForDeclUncached(const Decl *D) const;

comments::FullComment *cloneFullComment(comments::FullComment *FC,
                                       const Decl *D) const;

815private:
mutable comments::CommandTraits CommentCommandTraits;

/// \brief Iterator that visits import declarations.
class import_iterator {
  ImportDecl *Import = nullptr;

public:
  using value_type = ImportDecl *;
  using reference = ImportDecl *;
  using pointer = ImportDecl *;
  using difference_type = int;
  using iterator_category = std::forward_iterator_tag;

  import_iterator() = default;
  explicit import_iterator(ImportDecl *Import) : Import(Import) {}

  reference operator*() const { return Import; }
  pointer operator->() const { return Import; }

  import_iterator &operator++() {
    Import = ASTContext::getNextLocalImport(Import);
    return *this;
  }

  import_iterator operator++(int) {
    import_iterator Other(*this);
    ++(*this);
    return Other;
  }

  friend bool operator==(import_iterator X, import_iterator Y) {
    return X.Import == Y.Import;
  }

  friend bool operator!=(import_iterator X, import_iterator Y) {
    return X.Import != Y.Import;
  }
};

855public:
comments::CommandTraits &getCommentCommandTraits() const {
  return CommentCommandTraits;
}

/// \brief Retrieve the attributes for the given declaration.
AttrVec& getDeclAttrs(const Decl *D);

/// \brief Erase the attributes corresponding to the given declaration.
void eraseDeclAttrs(const Decl *D);

/// \brief If this variable is an instantiated static data member of a
/// class template specialization, returns the templated static data member
/// from which it was instantiated.
// FIXME: Remove ?
MemberSpecializationInfo *getInstantiatedFromStaticDataMember(
                                                         const VarDecl *Var);

TemplateOrSpecializationInfo
getTemplateOrSpecializationInfo(const VarDecl *Var);

FunctionDecl *getClassScopeSpecializationPattern(const FunctionDecl *FD);

void setClassScopeSpecializationPattern(FunctionDecl *FD,
                                        FunctionDecl *Pattern);

/// \brief Note that the static data member \p Inst is an instantiation of
/// the static data member template \p Tmpl of a class template.
void setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl,
                                         TemplateSpecializationKind TSK,
                      SourceLocation PointOfInstantiation = SourceLocation());

void setTemplateOrSpecializationInfo(VarDecl *Inst,
                                     TemplateOrSpecializationInfo TSI);

/// \brief If the given using decl \p Inst is an instantiation of a
/// (possibly unresolved) using decl from a template instantiation,
/// return it.
NamedDecl *getInstantiatedFromUsingDecl(NamedDecl *Inst);

/// \brief Remember that the using decl \p Inst is an instantiation
/// of the using decl \p Pattern of a class template.
void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern);

void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
                                        UsingShadowDecl *Pattern);
UsingShadowDecl *getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst);

FieldDecl *getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field);

void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl);

// Access to the set of methods overridden by the given C++ method.
using overridden_cxx_method_iterator = CXXMethodVector::const_iterator;
overridden_cxx_method_iterator
overridden_methods_begin(const CXXMethodDecl *Method) const;

overridden_cxx_method_iterator
overridden_methods_end(const CXXMethodDecl *Method) const;

unsigned overridden_methods_size(const CXXMethodDecl *Method) const;

using overridden_method_range =
    llvm::iterator_range<overridden_cxx_method_iterator>;

overridden_method_range overridden_methods(const CXXMethodDecl *Method) const;

/// \brief Note that the given C++ \p Method overrides the given \p
/// Overridden method.
void addOverriddenMethod(const CXXMethodDecl *Method,
                         const CXXMethodDecl *Overridden);

/// \brief Return C++ or ObjC overridden methods for the given \p Method.
///
/// An ObjC method is considered to override any method in the class's
/// base classes, its protocols, or its categories' protocols, that has
/// the same selector and is of the same kind (class or instance).
/// A method in an implementation is not considered as overriding the same
/// method in the interface or its categories.
void getOverriddenMethods(
                      const NamedDecl *Method,
                      SmallVectorImpl<const NamedDecl *> &Overridden) const;

/// \brief Notify the AST context that a new import declaration has been
/// parsed or implicitly created within this translation unit.
void addedLocalImportDecl(ImportDecl *Import);

static ImportDecl *getNextLocalImport(ImportDecl *Import) {
  return Import->NextLocalImport;
}

using import_range = llvm::iterator_range<import_iterator>;

import_range local_imports() const {
  return import_range(import_iterator(FirstLocalImport), import_iterator());
}

Decl *getPrimaryMergedDecl(Decl *D) {
  Decl *Result = MergedDecls.lookup(D);
  return Result ? Result : D;
}
void setPrimaryMergedDecl(Decl *D, Decl *Primary) {
  MergedDecls[D] = Primary;
}

/// \brief Note that the definition \p ND has been merged into module \p M,
/// and should be visible whenever \p M is visible.
void mergeDefinitionIntoModule(NamedDecl *ND, Module *M,
                               bool NotifyListeners = true);

/// \brief Clean up the merged definition list. Call this if you might have
/// added duplicates into the list.
void deduplicateMergedDefinitonsFor(NamedDecl *ND);

/// \brief Get the additional modules in which the definition \p Def has
/// been merged.
ArrayRef<Module*> getModulesWithMergedDefinition(const NamedDecl *Def) {
  auto MergedIt = MergedDefModules.find(Def);
  if (MergedIt == MergedDefModules.end())
    return None;
  return MergedIt->second;
}

/// Add a declaration to the list of declarations that are initialized
/// for a module. This will typically be a global variable (with internal
/// linkage) that runs module initializers, such as the iostream initializer,
/// or an ImportDecl nominating another module that has initializers.
void addModuleInitializer(Module *M, Decl *Init);

void addLazyModuleInitializers(Module *M, ArrayRef<uint32_t> IDs);

/// Get the initializations to perform when importing a module, if any.
ArrayRef<Decl*> getModuleInitializers(Module *M);

TranslationUnitDecl *getTranslationUnitDecl() const { return TUDecl; }

ExternCContextDecl *getExternCContextDecl() const;
BuiltinTemplateDecl *getMakeIntegerSeqDecl() const;
BuiltinTemplateDecl *getTypePackElementDecl() const;

// Builtin Types.
CanQualType VoidTy;
CanQualType BoolTy;
CanQualType CharTy;
CanQualType WCharTy;  // [C++ 3.9.1p5].
CanQualType WideCharTy; // Same as WCharTy in C++, integer type in C99.
CanQualType WIntTy;   // [C99 7.24.1], integer type unchanged by default promotions.
CanQualType Char16Ty; // [C++0x 3.9.1p5], integer type in C99.
CanQualType Char32Ty; // [C++0x 3.9.1p5], integer type in C99.
CanQualType SignedCharTy, ShortTy, IntTy, LongTy, LongLongTy, Int128Ty;
CanQualType UnsignedCharTy, UnsignedShortTy, UnsignedIntTy, UnsignedLongTy;
CanQualType UnsignedLongLongTy, UnsignedInt128Ty;
CanQualType FloatTy, DoubleTy, LongDoubleTy, Float128Ty;
CanQualType HalfTy; // [OpenCL 6.1.1.1], ARM NEON
CanQualType Float16Ty; // C11 extension ISO/IEC TS 18661-3
CanQualType FloatComplexTy, DoubleComplexTy, LongDoubleComplexTy;
CanQualType Float128ComplexTy;
CanQualType VoidPtrTy, NullPtrTy;
CanQualType DependentTy, OverloadTy, BoundMemberTy, UnknownAnyTy;
CanQualType BuiltinFnTy;
CanQualType PseudoObjectTy, ARCUnbridgedCastTy;
CanQualType ObjCBuiltinIdTy, ObjCBuiltinClassTy, ObjCBuiltinSelTy;
CanQualType ObjCBuiltinBoolTy;
1018#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
CanQualType SingletonId;
1020#include "clang/Basic/OpenCLImageTypes.def"
CanQualType OCLSamplerTy, OCLEventTy, OCLClkEventTy;
CanQualType OCLQueueTy, OCLReserveIDTy;
CanQualType OMPArraySectionTy;

// Types for deductions in C++0x [stmt.ranged]'s desugaring. Built on demand.
mutable QualType AutoDeductTy;     // Deduction against 'auto'.
mutable QualType AutoRRefDeductTy; // Deduction against 'auto &&'.

// Decl used to help define __builtin_va_list for some targets.
// The decl is built when constructing 'BuiltinVaListDecl'.
mutable Decl *VaListTagDecl;

ASTContext(LangOptions &LOpts, SourceManager &SM, IdentifierTable &idents,
           SelectorTable &sels, Builtin::Context &builtins);
ASTContext(const ASTContext &) = delete;
ASTContext &operator=(const ASTContext &) = delete;
~ASTContext();

/// \brief Attach an external AST source to the AST context.
///
/// The external AST source provides the ability to load parts of
/// the abstract syntax tree as needed from some external storage,
/// e.g., a precompiled header.
void setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source);

/// \brief Retrieve a pointer to the external AST source associated
/// with this AST context, if any.
ExternalASTSource *getExternalSource() const {
  return ExternalSource.get();
}

/// \brief Attach an AST mutation listener to the AST context.
///
/// The AST mutation listener provides the ability to track modifications to
/// the abstract syntax tree entities committed after they were initially
/// created.
void setASTMutationListener(ASTMutationListener *Listener) {
  this->Listener = Listener;
}

/// \brief Retrieve a pointer to the AST mutation listener associated
/// with this AST context, if any.
ASTMutationListener *getASTMutationListener() const { return Listener; }

void PrintStats() const;
const SmallVectorImpl<Type *>& getTypes() const { return Types; }

BuiltinTemplateDecl *buildBuiltinTemplateDecl(BuiltinTemplateKind BTK,
                                              const IdentifierInfo *II) const;

/// \brief Create a new implicit TU-level CXXRecordDecl or RecordDecl
/// declaration.
RecordDecl *buildImplicitRecord(StringRef Name,
                                RecordDecl::TagKind TK = TTK_Struct) const;

/// \brief Create a new implicit TU-level typedef declaration.
TypedefDecl *buildImplicitTypedef(QualType T, StringRef Name) const;

/// \brief Retrieve the declaration for the 128-bit signed integer type.
TypedefDecl *getInt128Decl() const;

/// \brief Retrieve the declaration for the 128-bit unsigned integer type.
TypedefDecl *getUInt128Decl() const;

//===--------------------------------------------------------------------===//
//                           Type Constructors
//===--------------------------------------------------------------------===//

1089private:
/// \brief Return a type with extended qualifiers.
QualType getExtQualType(const Type *Base, Qualifiers Quals) const;

QualType getTypeDeclTypeSlow(const TypeDecl *Decl) const;

QualType getPipeType(QualType T, bool ReadOnly) const;

1097public:
/// \brief Return the uniqued reference to the type for an address space
/// qualified type with the specified type and address space.
///
/// The resulting type has a union of the qualifiers from T and the address
/// space. If T already has an address space specifier, it is silently
/// replaced.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const;

/// \brief Remove any existing address space on the type and returns the type
/// with qualifiers intact (or that's the idea anyway)
///
/// The return type should be T with all prior qualifiers minus the address
/// space.
QualType removeAddrSpaceQualType(QualType T) const;

/// \brief Apply Objective-C protocol qualifiers to the given type.
/// \param allowOnPointerType specifies if we can apply protocol
/// qualifiers on ObjCObjectPointerType. It can be set to true when
/// contructing the canonical type of a Objective-C type parameter.
QualType applyObjCProtocolQualifiers(QualType type,
    ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
    bool allowOnPointerType = false) const;

/// \brief Return the uniqued reference to the type for an Objective-C
/// gc-qualified type.
///
/// The retulting type has a union of the qualifiers from T and the gc
/// attribute.
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const;

/// \brief Return the uniqued reference to the type for a \c restrict
/// qualified type.
///
/// The resulting type has a union of the qualifiers from \p T and
/// \c restrict.
QualType getRestrictType(QualType T) const {
  return T.withFastQualifiers(Qualifiers::Restrict);
}

/// \brief Return the uniqued reference to the type for a \c volatile
/// qualified type.
///
/// The resulting type has a union of the qualifiers from \p T and
/// \c volatile.
QualType getVolatileType(QualType T) const {
  return T.withFastQualifiers(Qualifiers::Volatile);
}

/// \brief Return the uniqued reference to the type for a \c const
/// qualified type.
///
/// The resulting type has a union of the qualifiers from \p T and \c const.
///
/// It can be reasonably expected that this will always be equivalent to
/// calling T.withConst().
QualType getConstType(QualType T) const { return T.withConst(); }

/// \brief Change the ExtInfo on a function type.
const FunctionType *adjustFunctionType(const FunctionType *Fn,
                                       FunctionType::ExtInfo EInfo);

/// Adjust the given function result type.
CanQualType getCanonicalFunctionResultType(QualType ResultType) const;

/// \brief Change the result type of a function type once it is deduced.
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType);

/// Get a function type and produce the equivalent function type with the
/// specified exception specification. Type sugar that can be present on a
/// declaration of a function with an exception specification is permitted
/// and preserved. Other type sugar (for instance, typedefs) is not.
QualType getFunctionTypeWithExceptionSpec(
    QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI);

/// \brief Determine whether two function types are the same, ignoring
/// exception specifications in cases where they're part of the type.
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U);

/// \brief Change the exception specification on a function once it is
/// delay-parsed, instantiated, or computed.
void adjustExceptionSpec(FunctionDecl *FD,
                         const FunctionProtoType::ExceptionSpecInfo &ESI,
                         bool AsWritten = false);

/// Determine whether a type is a class that should be detructed in the
/// callee function.
bool isParamDestroyedInCallee(QualType T) const;

/// \brief Return the uniqued reference to the type for a complex
/// number with the specified element type.
QualType getComplexType(QualType T) const;
CanQualType getComplexType(CanQualType T) const {
  return CanQualType::CreateUnsafe(getComplexType((QualType) T));
}

/// \brief Return the uniqued reference to the type for a pointer to
/// the specified type.
QualType getPointerType(QualType T) const;
CanQualType getPointerType(CanQualType T) const {
  return CanQualType::CreateUnsafe(getPointerType((QualType) T));
}

/// \brief Return the uniqued reference to a type adjusted from the original
/// type to a new type.
QualType getAdjustedType(QualType Orig, QualType New) const;
CanQualType getAdjustedType(CanQualType Orig, CanQualType New) const {
  return CanQualType::CreateUnsafe(
      getAdjustedType((QualType)Orig, (QualType)New));
}

/// \brief Return the uniqued reference to the decayed version of the given
/// type.  Can only be called on array and function types which decay to
/// pointer types.
QualType getDecayedType(QualType T) const;
CanQualType getDecayedType(CanQualType T) const {
  return CanQualType::CreateUnsafe(getDecayedType((QualType) T));
}

/// \brief Return the uniqued reference to the atomic type for the specified
/// type.
QualType getAtomicType(QualType T) const;

/// \brief Return the uniqued reference to the type for a block of the
/// specified type.
QualType getBlockPointerType(QualType T) const;

/// Gets the struct used to keep track of the descriptor for pointer to
/// blocks.
QualType getBlockDescriptorType() const;

/// \brief Return a read_only pipe type for the specified type.
QualType getReadPipeType(QualType T) const;

/// \brief Return a write_only pipe type for the specified type.
QualType getWritePipeType(QualType T) const;

/// Gets the struct used to keep track of the extended descriptor for
/// pointer to blocks.
QualType getBlockDescriptorExtendedType() const;

/// Map an AST Type to an OpenCLTypeKind enum value.
TargetInfo::OpenCLTypeKind getOpenCLTypeKind(const Type *T) const;

/// Get address space for OpenCL type.
LangAS getOpenCLTypeAddrSpace(const Type *T) const;

void setcudaConfigureCallDecl(FunctionDecl *FD) {
  cudaConfigureCallDecl = FD;
}

FunctionDecl *getcudaConfigureCallDecl() {
  return cudaConfigureCallDecl;
}

/// Returns true iff we need copy/dispose helpers for the given type.
bool BlockRequiresCopying(QualType Ty, const VarDecl *D);

/// Returns true, if given type has a known lifetime. HasByrefExtendedLayout is set
/// to false in this case. If HasByrefExtendedLayout returns true, byref variable
/// has extended lifetime.
bool getByrefLifetime(QualType Ty,
                      Qualifiers::ObjCLifetime &Lifetime,
                      bool &HasByrefExtendedLayout) const;

/// \brief Return the uniqued reference to the type for an lvalue reference
/// to the specified type.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue = true)
  const;

/// \brief Return the uniqued reference to the type for an rvalue reference
/// to the specified type.
QualType getRValueReferenceType(QualType T) const;

/// \brief Return the uniqued reference to the type for a member pointer to
/// the specified type in the specified class.
///
/// The class \p Cls is a \c Type because it could be a dependent name.
QualType getMemberPointerType(QualType T, const Type *Cls) const;

/// \brief Return a non-unique reference to the type for a variable array of
/// the specified element type.
QualType getVariableArrayType(QualType EltTy, Expr *NumElts,
                              ArrayType::ArraySizeModifier ASM,
                              unsigned IndexTypeQuals,
                              SourceRange Brackets) const;

/// \brief Return a non-unique reference to the type for a dependently-sized
/// array of the specified element type.
///
/// FIXME: We will need these to be uniqued, or at least comparable, at some
/// point.
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts,
                                    ArrayType::ArraySizeModifier ASM,
                                    unsigned IndexTypeQuals,
                                    SourceRange Brackets) const;

/// \brief Return a unique reference to the type for an incomplete array of
/// the specified element type.
QualType getIncompleteArrayType(QualType EltTy,
                                ArrayType::ArraySizeModifier ASM,
                                unsigned IndexTypeQuals) const;

/// \brief Return the unique reference to the type for a constant array of
/// the specified element type.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize,
                              ArrayType::ArraySizeModifier ASM,
                              unsigned IndexTypeQuals) const;

/// \brief Returns a vla type where known sizes are replaced with [*].
QualType getVariableArrayDecayedType(QualType Ty) const;

/// \brief Return the unique reference to a vector type of the specified
/// element type and size.
///
/// \pre \p VectorType must be a built-in type.
QualType getVectorType(QualType VectorType, unsigned NumElts,
                       VectorType::VectorKind VecKind) const;

/// \brief Return the unique reference to an extended vector type
/// of the specified element type and size.
///
/// \pre \p VectorType must be a built-in type.
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const;

/// \pre Return a non-unique reference to the type for a dependently-sized
/// vector of the specified element type.
///
/// FIXME: We will need these to be uniqued, or at least comparable, at some
/// point.
QualType getDependentSizedExtVectorType(QualType VectorType,
                                        Expr *SizeExpr,
                                        SourceLocation AttrLoc) const;

QualType getDependentAddressSpaceType(QualType PointeeType,
                                      Expr *AddrSpaceExpr,
                                      SourceLocation AttrLoc) const;

/// \brief Return a K&R style C function type like 'int()'.
QualType getFunctionNoProtoType(QualType ResultTy,
                                const FunctionType::ExtInfo &Info) const;

QualType getFunctionNoProtoType(QualType ResultTy) const {
  return getFunctionNoProtoType(ResultTy, FunctionType::ExtInfo());
}

/// \brief Return a normal function type with a typed argument list.
QualType getFunctionType(QualType ResultTy, ArrayRef<QualType> Args,
                         const FunctionProtoType::ExtProtoInfo &EPI) const {
  return getFunctionTypeInternal(ResultTy, Args, EPI, false);
}

1349private:
/// \brief Return a normal function type with a typed argument list.
QualType getFunctionTypeInternal(QualType ResultTy, ArrayRef<QualType> Args,
                                 const FunctionProtoType::ExtProtoInfo &EPI,
                                 bool OnlyWantCanonical) const;

1355public:
/// \brief Return the unique reference to the type for the specified type
/// declaration.
QualType getTypeDeclType(const TypeDecl *Decl,
                         const TypeDecl *PrevDecl = nullptr) const {
  assert(Decl && "Passed null for Decl param")(static_cast <bool> (Decl && "Passed null for Decl param"
) ? void (0) : __assert_fail ("Decl && \"Passed null for Decl param\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 1360, __extension__ __PRETTY_FUNCTION__));
29
←
Within the expansion of the macro 'assert':
→
a
Assuming 'Decl' is non-null
  if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
30
←
Assuming the condition is false→
31
←
Taking false branch→

  if (PrevDecl) {
32
←
Taking false branch→
    assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl")(static_cast <bool> (PrevDecl->TypeForDecl &&
 "previous decl has no TypeForDecl") ? void (0) : __assert_fail
 ("PrevDecl->TypeForDecl && \"previous decl has no TypeForDecl\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 1364, __extension__ __PRETTY_FUNCTION__));
    Decl->TypeForDecl = PrevDecl->TypeForDecl;
    return QualType(PrevDecl->TypeForDecl, 0);
  }

  return getTypeDeclTypeSlow(Decl);
}

/// \brief Return the unique reference to the type for the specified
/// typedef-name decl.
QualType getTypedefType(const TypedefNameDecl *Decl,
                        QualType Canon = QualType()) const;

QualType getRecordType(const RecordDecl *Decl) const;

QualType getEnumType(const EnumDecl *Decl) const;

QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const;

QualType getAttributedType(AttributedType::Kind attrKind,
                           QualType modifiedType,
                           QualType equivalentType);

QualType getSubstTemplateTypeParmType(const TemplateTypeParmType *Replaced,
                                      QualType Replacement) const;
QualType getSubstTemplateTypeParmPackType(
                                        const TemplateTypeParmType *Replaced,
                                          const TemplateArgument &ArgPack);

QualType
getTemplateTypeParmType(unsigned Depth, unsigned Index,
                        bool ParameterPack,
                        TemplateTypeParmDecl *ParmDecl = nullptr) const;

QualType getTemplateSpecializationType(TemplateName T,
                                       ArrayRef<TemplateArgument> Args,
                                       QualType Canon = QualType()) const;

QualType
getCanonicalTemplateSpecializationType(TemplateName T,
                                       ArrayRef<TemplateArgument> Args) const;

QualType getTemplateSpecializationType(TemplateName T,
                                       const TemplateArgumentListInfo &Args,
                                       QualType Canon = QualType()) const;

TypeSourceInfo *
getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc,
                                  const TemplateArgumentListInfo &Args,
                                  QualType Canon = QualType()) const;

QualType getParenType(QualType NamedType) const;

QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
                           NestedNameSpecifier *NNS,
                           QualType NamedType) const;
QualType getDependentNameType(ElaboratedTypeKeyword Keyword,
                              NestedNameSpecifier *NNS,
                              const IdentifierInfo *Name,
                              QualType Canon = QualType()) const;

QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
                                                NestedNameSpecifier *NNS,
                                                const IdentifierInfo *Name,
                                  const TemplateArgumentListInfo &Args) const;
QualType getDependentTemplateSpecializationType(
    ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
    const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args) const;

TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl);

/// Get a template argument list with one argument per template parameter
/// in a template parameter list, such as for the injected class name of
/// a class template.
void getInjectedTemplateArgs(const TemplateParameterList *Params,
                             SmallVectorImpl<TemplateArgument> &Args);

QualType getPackExpansionType(QualType Pattern,
                              Optional<unsigned> NumExpansions);

QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl,
                              ObjCInterfaceDecl *PrevDecl = nullptr) const;

/// Legacy interface: cannot provide type arguments or __kindof.
QualType getObjCObjectType(QualType Base,
                           ObjCProtocolDecl * const *Protocols,
                           unsigned NumProtocols) const;

QualType getObjCObjectType(QualType Base,
                           ArrayRef<QualType> typeArgs,
                           ArrayRef<ObjCProtocolDecl *> protocols,
                           bool isKindOf) const;

QualType getObjCTypeParamType(const ObjCTypeParamDecl *Decl,
                              ArrayRef<ObjCProtocolDecl *> protocols,
                              QualType Canonical = QualType()) const;

bool ObjCObjectAdoptsQTypeProtocols(QualType QT, ObjCInterfaceDecl *Decl);

/// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in
/// QT's qualified-id protocol list adopt all protocols in IDecl's list
/// of protocols.
bool QIdProtocolsAdoptObjCObjectProtocols(QualType QT,
                                          ObjCInterfaceDecl *IDecl);

/// \brief Return a ObjCObjectPointerType type for the given ObjCObjectType.
QualType getObjCObjectPointerType(QualType OIT) const;

/// \brief GCC extension.
QualType getTypeOfExprType(Expr *e) const;
QualType getTypeOfType(QualType t) const;

/// \brief C++11 decltype.
QualType getDecltypeType(Expr *e, QualType UnderlyingType) const;

/// \brief Unary type transforms
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType,
                               UnaryTransformType::UTTKind UKind) const;

/// \brief C++11 deduced auto type.
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
                     bool IsDependent) const;

/// \brief C++11 deduction pattern for 'auto' type.
QualType getAutoDeductType() const;

/// \brief C++11 deduction pattern for 'auto &&' type.
QualType getAutoRRefDeductType() const;

/// \brief C++17 deduced class template specialization type.
QualType getDeducedTemplateSpecializationType(TemplateName Template,
                                              QualType DeducedType,
                                              bool IsDependent) const;

/// \brief Return the unique reference to the type for the specified TagDecl
/// (struct/union/class/enum) decl.
QualType getTagDeclType(const TagDecl *Decl) const;

/// \brief Return the unique type for "size_t" (C99 7.17), defined in
/// <stddef.h>.
///
/// The sizeof operator requires this (C99 6.5.3.4p4).
CanQualType getSizeType() const;

/// \brief Return the unique signed counterpart of 
/// the integer type corresponding to size_t.
CanQualType getSignedSizeType() const;

/// \brief Return the unique type for "intmax_t" (C99 7.18.1.5), defined in
/// <stdint.h>.
CanQualType getIntMaxType() const;

/// \brief Return the unique type for "uintmax_t" (C99 7.18.1.5), defined in
/// <stdint.h>.
CanQualType getUIntMaxType() const;

/// \brief Return the unique wchar_t type available in C++ (and available as
/// __wchar_t as a Microsoft extension).
QualType getWCharType() const { return WCharTy; }

/// \brief Return the type of wide characters. In C++, this returns the
/// unique wchar_t type. In C99, this returns a type compatible with the type
/// defined in <stddef.h> as defined by the target.
QualType getWideCharType() const { return WideCharTy; }

/// \brief Return the type of "signed wchar_t".
///
/// Used when in C++, as a GCC extension.
QualType getSignedWCharType() const;

/// \brief Return the type of "unsigned wchar_t".
///
/// Used when in C++, as a GCC extension.
QualType getUnsignedWCharType() const;

/// \brief In C99, this returns a type compatible with the type
/// defined in <stddef.h> as defined by the target.
QualType getWIntType() const { return WIntTy; }

/// \brief Return a type compatible with "intptr_t" (C99 7.18.1.4),
/// as defined by the target.
QualType getIntPtrType() const;

/// \brief Return a type compatible with "uintptr_t" (C99 7.18.1.4),
/// as defined by the target.
QualType getUIntPtrType() const;

/// \brief Return the unique type for "ptrdiff_t" (C99 7.17) defined in
/// <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
QualType getPointerDiffType() const;

/// \brief Return the unique unsigned counterpart of "ptrdiff_t"
/// integer type. The standard (C11 7.21.6.1p7) refers to this type
/// in the definition of %tu format specifier.
QualType getUnsignedPointerDiffType() const;

/// \brief Return the unique type for "pid_t" defined in
/// <sys/types.h>. We need this to compute the correct type for vfork().
QualType getProcessIDType() const;

/// \brief Return the C structure type used to represent constant CFStrings.
QualType getCFConstantStringType() const;

/// \brief Returns the C struct type for objc_super
QualType getObjCSuperType() const;
void setObjCSuperType(QualType ST) { ObjCSuperType = ST; }

/// Get the structure type used to representation CFStrings, or NULL
/// if it hasn't yet been built.
QualType getRawCFConstantStringType() const {
  if (CFConstantStringTypeDecl)
    return getTypedefType(CFConstantStringTypeDecl);
  return QualType();
}
void setCFConstantStringType(QualType T);
TypedefDecl *getCFConstantStringDecl() const;
RecordDecl *getCFConstantStringTagDecl() const;

// This setter/getter represents the ObjC type for an NSConstantString.
void setObjCConstantStringInterface(ObjCInterfaceDecl *Decl);
QualType getObjCConstantStringInterface() const {
  return ObjCConstantStringType;
}

QualType getObjCNSStringType() const {
  return ObjCNSStringType;
}

void setObjCNSStringType(QualType T) {
  ObjCNSStringType = T;
}

/// \brief Retrieve the type that \c id has been defined to, which may be
/// different from the built-in \c id if \c id has been typedef'd.
QualType getObjCIdRedefinitionType() const {
  if (ObjCIdRedefinitionType.isNull())
    return getObjCIdType();
  return ObjCIdRedefinitionType;
}

/// \brief Set the user-written type that redefines \c id.
void setObjCIdRedefinitionType(QualType RedefType) {
  ObjCIdRedefinitionType = RedefType;
}

/// \brief Retrieve the type that \c Class has been defined to, which may be
/// different from the built-in \c Class if \c Class has been typedef'd.
QualType getObjCClassRedefinitionType() const {
  if (ObjCClassRedefinitionType.isNull())
    return getObjCClassType();
  return ObjCClassRedefinitionType;
}

/// \brief Set the user-written type that redefines 'SEL'.
void setObjCClassRedefinitionType(QualType RedefType) {
  ObjCClassRedefinitionType = RedefType;
}

/// \brief Retrieve the type that 'SEL' has been defined to, which may be
/// different from the built-in 'SEL' if 'SEL' has been typedef'd.
QualType getObjCSelRedefinitionType() const {
  if (ObjCSelRedefinitionType.isNull())
    return getObjCSelType();
  return ObjCSelRedefinitionType;
}

/// \brief Set the user-written type that redefines 'SEL'.
void setObjCSelRedefinitionType(QualType RedefType) {
  ObjCSelRedefinitionType = RedefType;
}

/// Retrieve the identifier 'NSObject'.
IdentifierInfo *getNSObjectName() {
  if (!NSObjectName) {
    NSObjectName = &Idents.get("NSObject");
  }

  return NSObjectName;
}

/// Retrieve the identifier 'NSCopying'.
IdentifierInfo *getNSCopyingName() {
  if (!NSCopyingName) {
    NSCopyingName = &Idents.get("NSCopying");
  }

  return NSCopyingName;
}

CanQualType getNSUIntegerType() const {
  assert(Target && "Expected target to be initialized")(static_cast <bool> (Target && "Expected target to be initialized"
) ? void (0) : __assert_fail ("Target && \"Expected target to be initialized\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 1654, __extension__ __PRETTY_FUNCTION__));
  const llvm::Triple &T = Target->getTriple();
  // Windows is LLP64 rather than LP64
  if (T.isOSWindows() && T.isArch64Bit())
    return UnsignedLongLongTy;
  return UnsignedLongTy;
}

CanQualType getNSIntegerType() const {
  assert(Target && "Expected target to be initialized")(static_cast <bool> (Target && "Expected target to be initialized"
) ? void (0) : __assert_fail ("Target && \"Expected target to be initialized\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 1663, __extension__ __PRETTY_FUNCTION__));
  const llvm::Triple &T = Target->getTriple();
  // Windows is LLP64 rather than LP64
  if (T.isOSWindows() && T.isArch64Bit())
    return LongLongTy;
  return LongTy;
}

/// Retrieve the identifier 'bool'.
IdentifierInfo *getBoolName() const {
  if (!BoolName)
    BoolName = &Idents.get("bool");
  return BoolName;
}

IdentifierInfo *getMakeIntegerSeqName() const {
  if (!MakeIntegerSeqName)
    MakeIntegerSeqName = &Idents.get("__make_integer_seq");
  return MakeIntegerSeqName;
}

IdentifierInfo *getTypePackElementName() const {
  if (!TypePackElementName)
    TypePackElementName = &Idents.get("__type_pack_element");
  return TypePackElementName;
}

/// \brief Retrieve the Objective-C "instancetype" type, if already known;
/// otherwise, returns a NULL type;
QualType getObjCInstanceType() {
  return getTypeDeclType(getObjCInstanceTypeDecl());
}

/// \brief Retrieve the typedef declaration corresponding to the Objective-C
/// "instancetype" type.
TypedefDecl *getObjCInstanceTypeDecl();

/// \brief Set the type for the C FILE type.
void setFILEDecl(TypeDecl *FILEDecl) { this->FILEDecl = FILEDecl; }

/// \brief Retrieve the C FILE type.
QualType getFILEType() const {
  if (FILEDecl)
    return getTypeDeclType(FILEDecl);
  return QualType();
}

/// \brief Set the type for the C jmp_buf type.
void setjmp_bufDecl(TypeDecl *jmp_bufDecl) {
  this->jmp_bufDecl = jmp_bufDecl;
}

/// \brief Retrieve the C jmp_buf type.
QualType getjmp_bufType() const {
  if (jmp_bufDecl)
    return getTypeDeclType(jmp_bufDecl);
  return QualType();
}

/// \brief Set the type for the C sigjmp_buf type.
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl) {
  this->sigjmp_bufDecl = sigjmp_bufDecl;
}

/// \brief Retrieve the C sigjmp_buf type.
QualType getsigjmp_bufType() const {
  if (sigjmp_bufDecl)
    return getTypeDeclType(sigjmp_bufDecl);
  return QualType();
}

/// \brief Set the type for the C ucontext_t type.
void setucontext_tDecl(TypeDecl *ucontext_tDecl) {
  this->ucontext_tDecl = ucontext_tDecl;
}

/// \brief Retrieve the C ucontext_t type.
QualType getucontext_tType() const {
  if (ucontext_tDecl)
    return getTypeDeclType(ucontext_tDecl);
  return QualType();
}

/// \brief The result type of logical operations, '<', '>', '!=', etc.
QualType getLogicalOperationType() const {
  return getLangOpts().CPlusPlus ? BoolTy : IntTy;
}

/// \brief Emit the Objective-CC type encoding for the given type \p T into
/// \p S.
///
/// If \p Field is specified then record field names are also encoded.
void getObjCEncodingForType(QualType T, std::string &S,
                            const FieldDecl *Field=nullptr,
                            QualType *NotEncodedT=nullptr) const;

/// \brief Emit the Objective-C property type encoding for the given
/// type \p T into \p S.
void getObjCEncodingForPropertyType(QualType T, std::string &S) const;

void getLegacyIntegralTypeEncoding(QualType &t) const;

/// \brief Put the string version of the type qualifiers \p QT into \p S.
void getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
                                     std::string &S) const;

/// \brief Emit the encoded type for the function \p Decl into \p S.
///
/// This is in the same format as Objective-C method encodings.
///
/// \returns true if an error occurred (e.g., because one of the parameter
/// types is incomplete), false otherwise.
std::string getObjCEncodingForFunctionDecl(const FunctionDecl *Decl) const;

/// \brief Emit the encoded type for the method declaration \p Decl into
/// \p S.
std::string getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl,
                                         bool Extended = false) const;

/// \brief Return the encoded type for this block declaration.
std::string getObjCEncodingForBlock(const BlockExpr *blockExpr) const;

/// getObjCEncodingForPropertyDecl - Return the encoded type for
/// this method declaration. If non-NULL, Container must be either
/// an ObjCCategoryImplDecl or ObjCImplementationDecl; it should
/// only be NULL when getting encodings for protocol properties.
std::string getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD,
                                           const Decl *Container) const;

bool ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
                                    ObjCProtocolDecl *rProto) const;

ObjCPropertyImplDecl *getObjCPropertyImplDeclForPropertyDecl(
                                                const ObjCPropertyDecl *PD,
                                                const Decl *Container) const;

/// \brief Return the size of type \p T for Objective-C encoding purpose,
/// in characters.
CharUnits getObjCEncodingTypeSize(QualType T) const;

/// \brief Retrieve the typedef corresponding to the predefined \c id type
/// in Objective-C.
TypedefDecl *getObjCIdDecl() const;

/// \brief Represents the Objective-CC \c id type.
///
/// This is set up lazily, by Sema.  \c id is always a (typedef for a)
/// pointer type, a pointer to a struct.
QualType getObjCIdType() const {
  return getTypeDeclType(getObjCIdDecl());
}

/// \brief Retrieve the typedef corresponding to the predefined 'SEL' type
/// in Objective-C.
TypedefDecl *getObjCSelDecl() const;

/// \brief Retrieve the type that corresponds to the predefined Objective-C
/// 'SEL' type.
QualType getObjCSelType() const {
  return getTypeDeclType(getObjCSelDecl());
}

/// \brief Retrieve the typedef declaration corresponding to the predefined
/// Objective-C 'Class' type.
TypedefDecl *getObjCClassDecl() const;

/// \brief Represents the Objective-C \c Class type.
///
/// This is set up lazily, by Sema.  \c Class is always a (typedef for a)
/// pointer type, a pointer to a struct.
QualType getObjCClassType() const {
  return getTypeDeclType(getObjCClassDecl());
}

/// \brief Retrieve the Objective-C class declaration corresponding to
/// the predefined \c Protocol class.
ObjCInterfaceDecl *getObjCProtocolDecl() const;

/// \brief Retrieve declaration of 'BOOL' typedef
TypedefDecl *getBOOLDecl() const {
  return BOOLDecl;
}

/// \brief Save declaration of 'BOOL' typedef
void setBOOLDecl(TypedefDecl *TD) {
  BOOLDecl = TD;
}

/// \brief type of 'BOOL' type.
QualType getBOOLType() const {
  return getTypeDeclType(getBOOLDecl());
}

/// \brief Retrieve the type of the Objective-C \c Protocol class.
QualType getObjCProtoType() const {
  return getObjCInterfaceType(getObjCProtocolDecl());
}

/// \brief Retrieve the C type declaration corresponding to the predefined
/// \c __builtin_va_list type.
TypedefDecl *getBuiltinVaListDecl() const;

/// \brief Retrieve the type of the \c __builtin_va_list type.
QualType getBuiltinVaListType() const {
  return getTypeDeclType(getBuiltinVaListDecl());
}

/// \brief Retrieve the C type declaration corresponding to the predefined
/// \c __va_list_tag type used to help define the \c __builtin_va_list type
/// for some targets.
Decl *getVaListTagDecl() const;

/// Retrieve the C type declaration corresponding to the predefined
/// \c __builtin_ms_va_list type.
TypedefDecl *getBuiltinMSVaListDecl() const;

/// Retrieve the type of the \c __builtin_ms_va_list type.
QualType getBuiltinMSVaListType() const {
  return getTypeDeclType(getBuiltinMSVaListDecl());
}

/// \brief Return a type with additional \c const, \c volatile, or
/// \c restrict qualifiers.
QualType getCVRQualifiedType(QualType T, unsigned CVR) const {
  return getQualifiedType(T, Qualifiers::fromCVRMask(CVR));
}

/// \brief Un-split a SplitQualType.
QualType getQualifiedType(SplitQualType split) const {
  return getQualifiedType(split.Ty, split.Quals);
}

/// \brief Return a type with additional qualifiers.
QualType getQualifiedType(QualType T, Qualifiers Qs) const {
  if (!Qs.hasNonFastQualifiers())
    return T.withFastQualifiers(Qs.getFastQualifiers());
  QualifierCollector Qc(Qs);
  const Type *Ptr = Qc.strip(T);
  return getExtQualType(Ptr, Qc);
}

/// \brief Return a type with additional qualifiers.
QualType getQualifiedType(const Type *T, Qualifiers Qs) const {
  if (!Qs.hasNonFastQualifiers())
    return QualType(T, Qs.getFastQualifiers());
  return getExtQualType(T, Qs);
}

/// \brief Return a type with the given lifetime qualifier.
///
/// \pre Neither type.ObjCLifetime() nor \p lifetime may be \c OCL_None.
QualType getLifetimeQualifiedType(QualType type,
                                  Qualifiers::ObjCLifetime lifetime) {
  assert(type.getObjCLifetime() == Qualifiers::OCL_None)(static_cast <bool> (type.getObjCLifetime() == Qualifiers
::OCL_None) ? void (0) : __assert_fail ("type.getObjCLifetime() == Qualifiers::OCL_None"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 1916, __extension__ __PRETTY_FUNCTION__));
  assert(lifetime != Qualifiers::OCL_None)(static_cast <bool> (lifetime != Qualifiers::OCL_None) ?
 void (0) : __assert_fail ("lifetime != Qualifiers::OCL_None"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 1917, __extension__ __PRETTY_FUNCTION__));

  Qualifiers qs;
  qs.addObjCLifetime(lifetime);
  return getQualifiedType(type, qs);
}

/// getUnqualifiedObjCPointerType - Returns version of
/// Objective-C pointer type with lifetime qualifier removed.
QualType getUnqualifiedObjCPointerType(QualType type) const {
  if (!type.getTypePtr()->isObjCObjectPointerType() ||
      !type.getQualifiers().hasObjCLifetime())
    return type;
  Qualifiers Qs = type.getQualifiers();
  Qs.removeObjCLifetime();
  return getQualifiedType(type.getUnqualifiedType(), Qs);
}

DeclarationNameInfo getNameForTemplate(TemplateName Name,
                                       SourceLocation NameLoc) const;

TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin,
                                       UnresolvedSetIterator End) const;

TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS,
                                      bool TemplateKeyword,
                                      TemplateDecl *Template) const;

TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
                                      const IdentifierInfo *Name) const;
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
                                      OverloadedOperatorKind Operator) const;
TemplateName getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param,
                                          TemplateName replacement) const;
TemplateName getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param,
                                      const TemplateArgument &ArgPack) const;

enum GetBuiltinTypeError {
  /// No error
  GE_None,

  /// Missing a type from <stdio.h>
  GE_Missing_stdio,

  /// Missing a type from <setjmp.h>
  GE_Missing_setjmp,

  /// Missing a type from <ucontext.h>
  GE_Missing_ucontext
};

/// \brief Return the type for the specified builtin.
///
/// If \p IntegerConstantArgs is non-null, it is filled in with a bitmask of
/// arguments to the builtin that are required to be integer constant
/// expressions.
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error,
                        unsigned *IntegerConstantArgs = nullptr) const;

1976private:
CanQualType getFromTargetType(unsigned Type) const;
TypeInfo getTypeInfoImpl(const Type *T) const;

//===--------------------------------------------------------------------===//
//                         Type Predicates.
//===--------------------------------------------------------------------===//

1984public:
/// \brief Return one of the GCNone, Weak or Strong Objective-C garbage
/// collection attributes.
Qualifiers::GC getObjCGCAttrKind(QualType Ty) const;

/// \brief Return true if the given vector types are of the same unqualified
/// type or if they are equivalent to the same GCC vector type.
///
/// \note This ignores whether they are target-specific (AltiVec or Neon)
/// types.
bool areCompatibleVectorTypes(QualType FirstVec, QualType SecondVec);

/// \brief Return true if this is an \c NSObject object with its \c NSObject
/// attribute set.
static bool isObjCNSObjectType(QualType Ty) {
  return Ty->isObjCNSObjectType();
}

//===--------------------------------------------------------------------===//
//                         Type Sizing and Analysis
//===--------------------------------------------------------------------===//

/// \brief Return the APFloat 'semantics' for the specified scalar floating
/// point type.
const llvm::fltSemantics &getFloatTypeSemantics(QualType T) const;

/// \brief Get the size and alignment of the specified complete type in bits.
TypeInfo getTypeInfo(const Type *T) const;
TypeInfo getTypeInfo(QualType T) const { return getTypeInfo(T.getTypePtr()); }

/// \brief Get default simd alignment of the specified complete type in bits.
unsigned getOpenMPDefaultSimdAlign(QualType T) const;

/// \brief Return the size of the specified (complete) type \p T, in bits.
uint64_t getTypeSize(QualType T) const { return getTypeInfo(T).Width; }
uint64_t getTypeSize(const Type *T) const { return getTypeInfo(T).Width; }

/// \brief Return the size of the character type, in bits.
uint64_t getCharWidth() const {
  return getTypeSize(CharTy);
}

/// \brief Convert a size in bits to a size in characters.
CharUnits toCharUnitsFromBits(int64_t BitSize) const;

/// \brief Convert a size in characters to a size in bits.
int64_t toBits(CharUnits CharSize) const;

/// \brief Return the size of the specified (complete) type \p T, in
/// characters.
CharUnits getTypeSizeInChars(QualType T) const;
CharUnits getTypeSizeInChars(const Type *T) const;

/// \brief Return the ABI-specified alignment of a (complete) type \p T, in
/// bits.
unsigned getTypeAlign(QualType T) const { return getTypeInfo(T).Align; }
unsigned getTypeAlign(const Type *T) const { return getTypeInfo(T).Align; }

/// \brief Return the ABI-specified alignment of a type, in bits, or 0 if
/// the type is incomplete and we cannot determine the alignment (for
/// example, from alignment attributes).
unsigned getTypeAlignIfKnown(QualType T) const;

/// \brief Return the ABI-specified alignment of a (complete) type \p T, in
/// characters.
CharUnits getTypeAlignInChars(QualType T) const;
CharUnits getTypeAlignInChars(const Type *T) const;

// getTypeInfoDataSizeInChars - Return the size of a type, in chars. If the
// type is a record, its data size is returned.
std::pair<CharUnits, CharUnits> getTypeInfoDataSizeInChars(QualType T) const;

std::pair<CharUnits, CharUnits> getTypeInfoInChars(const Type *T) const;
std::pair<CharUnits, CharUnits> getTypeInfoInChars(QualType T) const;

/// \brief Determine if the alignment the type has was required using an
/// alignment attribute.
bool isAlignmentRequired(const Type *T) const;
bool isAlignmentRequired(QualType T) const;

/// \brief Return the "preferred" alignment of the specified type \p T for
/// the current target, in bits.
///
/// This can be different than the ABI alignment in cases where it is
/// beneficial for performance to overalign a data type.
unsigned getPreferredTypeAlign(const Type *T) const;

/// \brief Return the default alignment for __attribute__((aligned)) on
/// this target, to be used if no alignment value is specified.
unsigned getTargetDefaultAlignForAttributeAligned() const;

/// \brief Return the alignment in bits that should be given to a
/// global variable with type \p T.
unsigned getAlignOfGlobalVar(QualType T) const;

/// \brief Return the alignment in characters that should be given to a
/// global variable with type \p T.
CharUnits getAlignOfGlobalVarInChars(QualType T) const;

/// \brief Return a conservative estimate of the alignment of the specified
/// decl \p D.
///
/// \pre \p D must not be a bitfield type, as bitfields do not have a valid
/// alignment.
///
/// If \p ForAlignof, references are treated like their underlying type
/// and  large arrays don't get any special treatment. If not \p ForAlignof
/// it computes the value expected by CodeGen: references are treated like
/// pointers and large arrays get extra alignment.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof = false) const;

/// \brief Get or compute information about the layout of the specified
/// record (struct/union/class) \p D, which indicates its size and field
/// position information.
const ASTRecordLayout &getASTRecordLayout(const RecordDecl *D) const;

/// \brief Get or compute information about the layout of the specified
/// Objective-C interface.
const ASTRecordLayout &getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D)
  const;

void DumpRecordLayout(const RecordDecl *RD, raw_ostream &OS,
                      bool Simple = false) const;

/// \brief Get or compute information about the layout of the specified
/// Objective-C implementation.
///
/// This may differ from the interface if synthesized ivars are present.
const ASTRecordLayout &
getASTObjCImplementationLayout(const ObjCImplementationDecl *D) const;

/// \brief Get our current best idea for the key function of the
/// given record decl, or nullptr if there isn't one.
///
/// The key function is, according to the Itanium C++ ABI section 5.2.3:
///   ...the first non-pure virtual function that is not inline at the
///   point of class definition.
///
/// Other ABIs use the same idea.  However, the ARM C++ ABI ignores
/// virtual functions that are defined 'inline', which means that
/// the result of this computation can change.
const CXXMethodDecl *getCurrentKeyFunction(const CXXRecordDecl *RD);

/// \brief Observe that the given method cannot be a key function.
/// Checks the key-function cache for the method's class and clears it
/// if matches the given declaration.
///
/// This is used in ABIs where out-of-line definitions marked
/// inline are not considered to be key functions.
///
/// \param method should be the declaration from the class definition
void setNonKeyFunction(const CXXMethodDecl *method);

/// Loading virtual member pointers using the virtual inheritance model
/// always results in an adjustment using the vbtable even if the index is
/// zero.
///
/// This is usually OK because the first slot in the vbtable points
/// backwards to the top of the MDC.  However, the MDC might be reusing a
/// vbptr from an nv-base.  In this case, the first slot in the vbtable
/// points to the start of the nv-base which introduced the vbptr and *not*
/// the MDC.  Modify the NonVirtualBaseAdjustment to account for this.
CharUnits getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const;

/// Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
uint64_t getFieldOffset(const ValueDecl *FD) const;

/// Get the offset of an ObjCIvarDecl in bits.
uint64_t lookupFieldBitOffset(const ObjCInterfaceDecl *OID,
                              const ObjCImplementationDecl *ID,
                              const ObjCIvarDecl *Ivar) const;

bool isNearlyEmpty(const CXXRecordDecl *RD) const;

VTableContextBase *getVTableContext();

MangleContext *createMangleContext();

void DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, bool leafClass,
                          SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const;

unsigned CountNonClassIvars(const ObjCInterfaceDecl *OI) const;
void CollectInheritedProtocols(const Decl *CDecl,
                        llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols);

/// \brief Return true if the specified type has unique object representations
/// according to (C++17 [meta.unary.prop]p9)
bool hasUniqueObjectRepresentations(QualType Ty) const;

//===--------------------------------------------------------------------===//
//                            Type Operators
//===--------------------------------------------------------------------===//

/// \brief Return the canonical (structural) type corresponding to the
/// specified potentially non-canonical type \p T.
///
/// The non-canonical version of a type may have many "decorated" versions of
/// types.  Decorators can include typedefs, 'typeof' operators, etc. The
/// returned type is guaranteed to be free of any of these, allowing two
/// canonical types to be compared for exact equality with a simple pointer
/// comparison.
CanQualType getCanonicalType(QualType T) const {
  return CanQualType::CreateUnsafe(T.getCanonicalType());
}

const Type *getCanonicalType(const Type *T) const {
  return T->getCanonicalTypeInternal().getTypePtr();
}

/// \brief Return the canonical parameter type corresponding to the specific
/// potentially non-canonical one.
///
/// Qualifiers are stripped off, functions are turned into function
/// pointers, and arrays decay one level into pointers.
CanQualType getCanonicalParamType(QualType T) const;

/// \brief Determine whether the given types \p T1 and \p T2 are equivalent.
bool hasSameType(QualType T1, QualType T2) const {
  return getCanonicalType(T1) == getCanonicalType(T2);
}
bool hasSameType(const Type *T1, const Type *T2) const {
  return getCanonicalType(T1) == getCanonicalType(T2);
}

/// \brief Return this type as a completely-unqualified array type,
/// capturing the qualifiers in \p Quals.
///
/// This will remove the minimal amount of sugaring from the types, similar
/// to the behavior of QualType::getUnqualifiedType().
///
/// \param T is the qualified type, which may be an ArrayType
///
/// \param Quals will receive the full set of qualifiers that were
/// applied to the array.
///
/// \returns if this is an array type, the completely unqualified array type
/// that corresponds to it. Otherwise, returns T.getUnqualifiedType().
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals);

/// \brief Determine whether the given types are equivalent after
/// cvr-qualifiers have been removed.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const {
  return getCanonicalType(T1).getTypePtr() ==
         getCanonicalType(T2).getTypePtr();
}

bool hasSameNullabilityTypeQualifier(QualType SubT, QualType SuperT,
                                     bool IsParam) const {
  auto SubTnullability = SubT->getNullability(*this);
  auto SuperTnullability = SuperT->getNullability(*this);
  if (SubTnullability.hasValue() == SuperTnullability.hasValue()) {
    // Neither has nullability; return true
    if (!SubTnullability)
      return true;
    // Both have nullability qualifier.
    if (*SubTnullability == *SuperTnullability ||
        *SubTnullability == NullabilityKind::Unspecified ||
        *SuperTnullability == NullabilityKind::Unspecified)
      return true;

    if (IsParam) {
      // Ok for the superclass method parameter to be "nonnull" and the subclass
      // method parameter to be "nullable"
      return (*SuperTnullability == NullabilityKind::NonNull &&
              *SubTnullability == NullabilityKind::Nullable);
    }
    else {
      // For the return type, it's okay for the superclass method to specify
      // "nullable" and the subclass method specify "nonnull"
      return (*SuperTnullability == NullabilityKind::Nullable &&
              *SubTnullability == NullabilityKind::NonNull);
    }
  }
  return true;
}

bool ObjCMethodsAreEqual(const ObjCMethodDecl *MethodDecl,
                         const ObjCMethodDecl *MethodImp);

bool UnwrapSimilarPointerTypes(QualType &T1, QualType &T2);

/// \brief Retrieves the "canonical" nested name specifier for a
/// given nested name specifier.
///
/// The canonical nested name specifier is a nested name specifier
/// that uniquely identifies a type or namespace within the type
/// system. For example, given:
///
/// \code
/// namespace N {
///   struct S {
///     template<typename T> struct X { typename T* type; };
///   };
/// }
///
/// template<typename T> struct Y {
///   typename N::S::X<T>::type member;
/// };
/// \endcode
///
/// Here, the nested-name-specifier for N::S::X<T>:: will be
/// S::X<template-param-0-0>, since 'S' and 'X' are uniquely defined
/// by declarations in the type system and the canonical type for
/// the template type parameter 'T' is template-param-0-0.
NestedNameSpecifier *
getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const;

/// \brief Retrieves the default calling convention for the current target.
CallingConv getDefaultCallingConvention(bool IsVariadic,
                                        bool IsCXXMethod) const;

/// \brief Retrieves the "canonical" template name that refers to a
/// given template.
///
/// The canonical template name is the simplest expression that can
/// be used to refer to a given template. For most templates, this
/// expression is just the template declaration itself. For example,
/// the template std::vector can be referred to via a variety of
/// names---std::vector, \::std::vector, vector (if vector is in
/// scope), etc.---but all of these names map down to the same
/// TemplateDecl, which is used to form the canonical template name.
///
/// Dependent template names are more interesting. Here, the
/// template name could be something like T::template apply or
/// std::allocator<T>::template rebind, where the nested name
/// specifier itself is dependent. In this case, the canonical
/// template name uses the shortest form of the dependent
/// nested-name-specifier, which itself contains all canonical
/// types, values, and templates.
TemplateName getCanonicalTemplateName(TemplateName Name) const;

/// \brief Determine whether the given template names refer to the same
/// template.
bool hasSameTemplateName(TemplateName X, TemplateName Y);

/// \brief Retrieve the "canonical" template argument.
///
/// The canonical template argument is the simplest template argument
/// (which may be a type, value, expression, or declaration) that
/// expresses the value of the argument.
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg)
  const;

/// Type Query functions.  If the type is an instance of the specified class,
/// return the Type pointer for the underlying maximally pretty type.  This
/// is a member of ASTContext because this may need to do some amount of
/// canonicalization, e.g. to move type qualifiers into the element type.
const ArrayType *getAsArrayType(QualType T) const;
const ConstantArrayType *getAsConstantArrayType(QualType T) const {
  return dyn_cast_or_null<ConstantArrayType>(getAsArrayType(T));
}
const VariableArrayType *getAsVariableArrayType(QualType T) const {
  return dyn_cast_or_null<VariableArrayType>(getAsArrayType(T));
}
const IncompleteArrayType *getAsIncompleteArrayType(QualType T) const {
  return dyn_cast_or_null<IncompleteArrayType>(getAsArrayType(T));
}
const DependentSizedArrayType *getAsDependentSizedArrayType(QualType T)
  const {
  return dyn_cast_or_null<DependentSizedArrayType>(getAsArrayType(T));
}

/// \brief Return the innermost element type of an array type.
///
/// For example, will return "int" for int[m][n]
QualType getBaseElementType(const ArrayType *VAT) const;

/// \brief Return the innermost element type of a type (which needn't
/// actually be an array type).
QualType getBaseElementType(QualType QT) const;

/// \brief Return number of constant array elements.
uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const;

/// \brief Perform adjustment on the parameter type of a function.
///
/// This routine adjusts the given parameter type @p T to the actual
/// parameter type used by semantic analysis (C99 6.7.5.3p[7,8],
/// C++ [dcl.fct]p3). The adjusted parameter type is returned.
QualType getAdjustedParameterType(QualType T) const;

/// \brief Retrieve the parameter type as adjusted for use in the signature
/// of a function, decaying array and function types and removing top-level
/// cv-qualifiers.
QualType getSignatureParameterType(QualType T) const;

QualType getExceptionObjectType(QualType T) const;

/// \brief Return the properly qualified result of decaying the specified
/// array type to a pointer.
///
/// This operation is non-trivial when handling typedefs etc.  The canonical
/// type of \p T must be an array type, this returns a pointer to a properly
/// qualified element of the array.
///
/// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
QualType getArrayDecayedType(QualType T) const;

/// \brief Return the type that \p PromotableType will promote to: C99
/// 6.3.1.1p2, assuming that \p PromotableType is a promotable integer type.
QualType getPromotedIntegerType(QualType PromotableType) const;

/// \brief Recurses in pointer/array types until it finds an Objective-C
/// retainable type and returns its ownership.
Qualifiers::ObjCLifetime getInnerObjCOwnership(QualType T) const;

/// \brief Whether this is a promotable bitfield reference according
/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
///
/// \returns the type this bit-field will promote to, or NULL if no
/// promotion occurs.
QualType isPromotableBitField(Expr *E) const;

/// \brief Return the highest ranked integer type, see C99 6.3.1.8p1.
///
/// If \p LHS > \p RHS, returns 1.  If \p LHS == \p RHS, returns 0.  If
/// \p LHS < \p RHS, return -1.
int getIntegerTypeOrder(QualType LHS, QualType RHS) const;

/// \brief Compare the rank of the two specified floating point types,
/// ignoring the domain of the type (i.e. 'double' == '_Complex double').
///
/// If \p LHS > \p RHS, returns 1.  If \p LHS == \p RHS, returns 0.  If
/// \p LHS < \p RHS, return -1.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const;

/// \brief Return a real floating point or a complex type (based on
/// \p typeDomain/\p typeSize).
///
/// \param typeDomain a real floating point or complex type.
/// \param typeSize a real floating point or complex type.
QualType getFloatingTypeOfSizeWithinDomain(QualType typeSize,
                                           QualType typeDomain) const;

unsigned getTargetAddressSpace(QualType T) const {
  return getTargetAddressSpace(T.getQualifiers());
}

unsigned getTargetAddressSpace(Qualifiers Q) const {
  return getTargetAddressSpace(Q.getAddressSpace());
}

unsigned getTargetAddressSpace(LangAS AS) const;

/// Get target-dependent integer value for null pointer which is used for
/// constant folding.
uint64_t getTargetNullPointerValue(QualType QT) const;

bool addressSpaceMapManglingFor(LangAS AS) const {
  return AddrSpaceMapMangling || isTargetAddressSpace(AS);
}

2436private:
// Helper for integer ordering
unsigned getIntegerRank(const Type *T) const;

2440public:
//===--------------------------------------------------------------------===//
//                    Type Compatibility Predicates
//===--------------------------------------------------------------------===//

/// Compatibility predicates used to check assignment expressions.
bool typesAreCompatible(QualType T1, QualType T2,
                        bool CompareUnqualified = false); // C99 6.2.7p1

bool propertyTypesAreCompatible(QualType, QualType);
bool typesAreBlockPointerCompatible(QualType, QualType);

bool isObjCIdType(QualType T) const {
  return T == getObjCIdType();
}

bool isObjCClassType(QualType T) const {
  return T == getObjCClassType();
}

bool isObjCSelType(QualType T) const {
  return T == getObjCSelType();
}

bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS,
                                       bool ForCompare);

bool ObjCQualifiedClassTypesAreCompatible(QualType LHS, QualType RHS);

// Check the safety of assignment from LHS to RHS
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
                             const ObjCObjectPointerType *RHSOPT);
bool canAssignObjCInterfaces(const ObjCObjectType *LHS,
                             const ObjCObjectType *RHS);
bool canAssignObjCInterfacesInBlockPointer(
                                        const ObjCObjectPointerType *LHSOPT,
                                        const ObjCObjectPointerType *RHSOPT,
                                        bool BlockReturnType);
bool areComparableObjCPointerTypes(QualType LHS, QualType RHS);
QualType areCommonBaseCompatible(const ObjCObjectPointerType *LHSOPT,
                                 const ObjCObjectPointerType *RHSOPT);
bool canBindObjCObjectType(QualType To, QualType From);

// Functions for calculating composite types
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false,
                    bool Unqualified = false, bool BlockReturnType = false);
QualType mergeFunctionTypes(QualType, QualType, bool OfBlockPointer=false,
                            bool Unqualified = false);
QualType mergeFunctionParameterTypes(QualType, QualType,
                                     bool OfBlockPointer = false,
                                     bool Unqualified = false);
QualType mergeTransparentUnionType(QualType, QualType,
                                   bool OfBlockPointer=false,
                                   bool Unqualified = false);

QualType mergeObjCGCQualifiers(QualType, QualType);

/// This function merges the ExtParameterInfo lists of two functions. It
/// returns true if the lists are compatible. The merged list is returned in
/// NewParamInfos.
///
/// \param FirstFnType The type of the first function.
///
/// \param SecondFnType The type of the second function.
///
/// \param CanUseFirst This flag is set to true if the first function's
/// ExtParameterInfo list can be used as the composite list of
/// ExtParameterInfo.
///
/// \param CanUseSecond This flag is set to true if the second function's
/// ExtParameterInfo list can be used as the composite list of
/// ExtParameterInfo.
///
/// \param NewParamInfos The composite list of ExtParameterInfo. The list is
/// empty if none of the flags are set.
///
bool mergeExtParameterInfo(
    const FunctionProtoType *FirstFnType,
    const FunctionProtoType *SecondFnType,
    bool &CanUseFirst, bool &CanUseSecond,
    SmallVectorImpl<FunctionProtoType::ExtParameterInfo> &NewParamInfos);

void ResetObjCLayout(const ObjCContainerDecl *CD);

//===--------------------------------------------------------------------===//
//                    Integer Predicates
//===--------------------------------------------------------------------===//

// The width of an integer, as defined in C99 6.2.6.2. This is the number
// of bits in an integer type excluding any padding bits.
unsigned getIntWidth(QualType T) const;

// Per C99 6.2.5p6, for every signed integer type, there is a corresponding
// unsigned integer type.  This method takes a signed type, and returns the
// corresponding unsigned integer type.
QualType getCorrespondingUnsignedType(QualType T) const;

//===--------------------------------------------------------------------===//
//                    Integer Values
//===--------------------------------------------------------------------===//

/// \brief Make an APSInt of the appropriate width and signedness for the
/// given \p Value and integer \p Type.
llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const {
  // If Type is a signed integer type larger than 64 bits, we need to be sure
  // to sign extend Res appropriately.
  llvm::APSInt Res(64, !Type->isSignedIntegerOrEnumerationType());
  Res = Value;
  unsigned Width = getIntWidth(Type);
  if (Width != Res.getBitWidth())
    return Res.extOrTrunc(Width);
  return Res;
}

bool isSentinelNullExpr(const Expr *E);

/// \brief Get the implementation of the ObjCInterfaceDecl \p D, or nullptr if
/// none exists.
ObjCImplementationDecl *getObjCImplementation(ObjCInterfaceDecl *D);

/// \brief Get the implementation of the ObjCCategoryDecl \p D, or nullptr if
/// none exists.
ObjCCategoryImplDecl *getObjCImplementation(ObjCCategoryDecl *D);

/// \brief Return true if there is at least one \@implementation in the TU.
bool AnyObjCImplementation() {
  return !ObjCImpls.empty();
}

/// \brief Set the implementation of ObjCInterfaceDecl.
void setObjCImplementation(ObjCInterfaceDecl *IFaceD,
                           ObjCImplementationDecl *ImplD);

/// \brief Set the implementation of ObjCCategoryDecl.
void setObjCImplementation(ObjCCategoryDecl *CatD,
                           ObjCCategoryImplDecl *ImplD);

/// \brief Get the duplicate declaration of a ObjCMethod in the same
/// interface, or null if none exists.
const ObjCMethodDecl *
getObjCMethodRedeclaration(const ObjCMethodDecl *MD) const;

void setObjCMethodRedeclaration(const ObjCMethodDecl *MD,
                                const ObjCMethodDecl *Redecl);

/// \brief Returns the Objective-C interface that \p ND belongs to if it is
/// an Objective-C method/property/ivar etc. that is part of an interface,
/// otherwise returns null.
const ObjCInterfaceDecl *getObjContainingInterface(const NamedDecl *ND) const;

/// \brief Set the copy inialization expression of a block var decl.
void setBlockVarCopyInits(VarDecl*VD, Expr* Init);

/// \brief Get the copy initialization expression of the VarDecl \p VD, or
/// nullptr if none exists.
Expr *getBlockVarCopyInits(const VarDecl* VD);

/// \brief Allocate an uninitialized TypeSourceInfo.
///
/// The caller should initialize the memory held by TypeSourceInfo using
/// the TypeLoc wrappers.
///
/// \param T the type that will be the basis for type source info. This type
/// should refer to how the declarator was written in source code, not to
/// what type semantic analysis resolved the declarator to.
///
/// \param Size the size of the type info to create, or 0 if the size
/// should be calculated based on the type.
TypeSourceInfo *CreateTypeSourceInfo(QualType T, unsigned Size = 0) const;

/// \brief Allocate a TypeSourceInfo where all locations have been
/// initialized to a given location, which defaults to the empty
/// location.
TypeSourceInfo *
getTrivialTypeSourceInfo(QualType T,
                         SourceLocation Loc = SourceLocation()) const;

/// \brief Add a deallocation callback that will be invoked when the
/// ASTContext is destroyed.
///
/// \param Callback A callback function that will be invoked on destruction.
///
/// \param Data Pointer data that will be provided to the callback function
/// when it is called.
void AddDeallocation(void (*Callback)(void*), void *Data);

/// If T isn't trivially destructible, calls AddDeallocation to register it
/// for destruction.
template <typename T>
void addDestruction(T *Ptr) {
  if (!std::is_trivially_destructible<T>::value) {
    auto DestroyPtr = [](void *V) { static_cast<T *>(V)->~T(); };
    AddDeallocation(DestroyPtr, Ptr);
  }
}

GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const;
GVALinkage GetGVALinkageForVariable(const VarDecl *VD);

/// \brief Determines if the decl can be CodeGen'ed or deserialized from PCH
/// lazily, only when used; this is only relevant for function or file scoped
/// var definitions.
///
/// \returns true if the function/var must be CodeGen'ed/deserialized even if
/// it is not used.
bool DeclMustBeEmitted(const Decl *D);

/// \brief Visits all versions of a multiversioned function with the passed
/// predicate.
void forEachMultiversionedFunctionVersion(
    const FunctionDecl *FD,
    llvm::function_ref<void(const FunctionDecl *)> Pred) const;

const CXXConstructorDecl *
getCopyConstructorForExceptionObject(CXXRecordDecl *RD);

void addCopyConstructorForExceptionObject(CXXRecordDecl *RD,
                                          CXXConstructorDecl *CD);

void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND);

TypedefNameDecl *getTypedefNameForUnnamedTagDecl(const TagDecl *TD);

void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD);

DeclaratorDecl *getDeclaratorForUnnamedTagDecl(const TagDecl *TD);

void setManglingNumber(const NamedDecl *ND, unsigned Number);
unsigned getManglingNumber(const NamedDecl *ND) const;

void setStaticLocalNumber(const VarDecl *VD, unsigned Number);
unsigned getStaticLocalNumber(const VarDecl *VD) const;

/// \brief Retrieve the context for computing mangling numbers in the given
/// DeclContext.
MangleNumberingContext &getManglingNumberContext(const DeclContext *DC);

std::unique_ptr<MangleNumberingContext> createMangleNumberingContext() const;

/// \brief Used by ParmVarDecl to store on the side the
/// index of the parameter when it exceeds the size of the normal bitfield.
void setParameterIndex(const ParmVarDecl *D, unsigned index);

/// \brief Used by ParmVarDecl to retrieve on the side the
/// index of the parameter when it exceeds the size of the normal bitfield.
unsigned getParameterIndex(const ParmVarDecl *D) const;

/// \brief Get the storage for the constant value of a materialized temporary
/// of static storage duration.
APValue *getMaterializedTemporaryValue(const MaterializeTemporaryExpr *E,
                                       bool MayCreate);

//===--------------------------------------------------------------------===//
//                    Statistics
//===--------------------------------------------------------------------===//

/// \brief The number of implicitly-declared default constructors.
static unsigned NumImplicitDefaultConstructors;

/// \brief The number of implicitly-declared default constructors for
/// which declarations were built.
static unsigned NumImplicitDefaultConstructorsDeclared;

/// \brief The number of implicitly-declared copy constructors.
static unsigned NumImplicitCopyConstructors;

/// \brief The number of implicitly-declared copy constructors for
/// which declarations were built.
static unsigned NumImplicitCopyConstructorsDeclared;

/// \brief The number of implicitly-declared move constructors.
static unsigned NumImplicitMoveConstructors;

/// \brief The number of implicitly-declared move constructors for
/// which declarations were built.
static unsigned NumImplicitMoveConstructorsDeclared;

/// \brief The number of implicitly-declared copy assignment operators.
static unsigned NumImplicitCopyAssignmentOperators;

/// \brief The number of implicitly-declared copy assignment operators for
/// which declarations were built.
static unsigned NumImplicitCopyAssignmentOperatorsDeclared;

/// \brief The number of implicitly-declared move assignment operators.
static unsigned NumImplicitMoveAssignmentOperators;

/// \brief The number of implicitly-declared move assignment operators for
/// which declarations were built.
static unsigned NumImplicitMoveAssignmentOperatorsDeclared;

/// \brief The number of implicitly-declared destructors.
static unsigned NumImplicitDestructors;

/// \brief The number of implicitly-declared destructors for which
/// declarations were built.
static unsigned NumImplicitDestructorsDeclared;

2738public:
/// \brief Initialize built-in types.
///
/// This routine may only be invoked once for a given ASTContext object.
/// It is normally invoked after ASTContext construction.
///
/// \param Target The target
void InitBuiltinTypes(const TargetInfo &Target,
                      const TargetInfo *AuxTarget = nullptr);

2748private:
void InitBuiltinType(CanQualType &R, BuiltinType::Kind K);

// Return the Objective-C type encoding for a given type.
void getObjCEncodingForTypeImpl(QualType t, std::string &S,
                                bool ExpandPointedToStructures,
                                bool ExpandStructures,
                                const FieldDecl *Field,
                                bool OutermostType = false,
                                bool EncodingProperty = false,
                                bool StructField = false,
                                bool EncodeBlockParameters = false,
                                bool EncodeClassNames = false,
                                bool EncodePointerToObjCTypedef = false,
                                QualType *NotEncodedT=nullptr) const;

// Adds the encoding of the structure's members.
void getObjCEncodingForStructureImpl(RecordDecl *RD, std::string &S,
                                     const FieldDecl *Field,
                                     bool includeVBases = true,
                                     QualType *NotEncodedT=nullptr) const;

2770public:
// Adds the encoding of a method parameter or return type.
void getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT,
                                       QualType T, std::string& S,
                                       bool Extended) const;

/// \brief Returns true if this is an inline-initialized static data member
/// which is treated as a definition for MSVC compatibility.
bool isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const;

enum class InlineVariableDefinitionKind {
  /// Not an inline variable.
  None,

  /// Weak definition of inline variable.
  Weak,

  /// Weak for now, might become strong later in this TU.
  WeakUnknown,

  /// Strong definition.
  Strong
};

/// \brief Determine whether a definition of this inline variable should
/// be treated as a weak or strong definition. For compatibility with
/// C++14 and before, for a constexpr static data member, if there is an
/// out-of-line declaration of the member, we may promote it from weak to
/// strong.
InlineVariableDefinitionKind
getInlineVariableDefinitionKind(const VarDecl *VD) const;

2802private:
friend class DeclarationNameTable;
friend class DeclContext;

const ASTRecordLayout &
getObjCLayout(const ObjCInterfaceDecl *D,
              const ObjCImplementationDecl *Impl) const;

/// \brief A set of deallocations that should be performed when the
/// ASTContext is destroyed.
// FIXME: We really should have a better mechanism in the ASTContext to
// manage running destructors for types which do variable sized allocation
// within the AST. In some places we thread the AST bump pointer allocator
// into the datastructures which avoids this mess during deallocation but is
// wasteful of memory, and here we require a lot of error prone book keeping
// in order to track and run destructors while we're tearing things down.
using DeallocationFunctionsAndArguments =
    llvm::SmallVector<std::pair<void (*)(void *), void *>, 16>;
DeallocationFunctionsAndArguments Deallocations;

// FIXME: This currently contains the set of StoredDeclMaps used
// by DeclContext objects.  This probably should not be in ASTContext,
// but we include it here so that ASTContext can quickly deallocate them.
llvm::PointerIntPair<StoredDeclsMap *, 1> LastSDM;

std::unique_ptr<ParentMapPointers> PointerParents;
std::unique_ptr<ParentMapOtherNodes> OtherParents;

std::unique_ptr<VTableContextBase> VTContext;

void ReleaseDeclContextMaps();
void ReleaseParentMapEntries();

2835public:
enum PragmaSectionFlag : unsigned {
  PSF_None = 0,
  PSF_Read = 0x1,
  PSF_Write = 0x2,
  PSF_Execute = 0x4,
  PSF_Implicit = 0x8,
  PSF_Invalid = 0x80000000U,
};

struct SectionInfo {
  DeclaratorDecl *Decl;
  SourceLocation PragmaSectionLocation;
  int SectionFlags;

  SectionInfo() = default;
  SectionInfo(DeclaratorDecl *Decl,
              SourceLocation PragmaSectionLocation,
              int SectionFlags)
      : Decl(Decl), PragmaSectionLocation(PragmaSectionLocation),
        SectionFlags(SectionFlags) {}
};

llvm::StringMap<SectionInfo> SectionInfos;
2859};

2861/// \brief Utility function for constructing a nullary selector.
2862inline Selector GetNullarySelector(StringRef name, ASTContext &Ctx) {
IdentifierInfo* II = &Ctx.Idents.get(name);
return Ctx.Selectors.getSelector(0, &II);
2865}

2867/// \brief Utility function for constructing an unary selector.
2868inline Selector GetUnarySelector(StringRef name, ASTContext &Ctx) {
IdentifierInfo* II = &Ctx.Idents.get(name);
return Ctx.Selectors.getSelector(1, &II);
2871}

2873} // namespace clang

2875// operator new and delete aren't allowed inside namespaces.

2877/// @brief Placement new for using the ASTContext's allocator.
2878///
2879/// This placement form of operator new uses the ASTContext's allocator for
2880/// obtaining memory.
2881///
2882/// IMPORTANT: These are also declared in clang/AST/AttrIterator.h! Any changes
2883/// here need to also be made there.
2884///
2885/// We intentionally avoid using a nothrow specification here so that the calls
2886/// to this operator will not perform a null check on the result -- the
2887/// underlying allocator never returns null pointers.
2888///
2889/// Usage looks like this (assuming there's an ASTContext 'Context' in scope):
2890/// @code
2891/// // Default alignment (8)
2892/// IntegerLiteral *Ex = new (Context) IntegerLiteral(arguments);
2893/// // Specific alignment
2894/// IntegerLiteral *Ex2 = new (Context, 4) IntegerLiteral(arguments);
2895/// @endcode
2896/// Memory allocated through this placement new operator does not need to be
2897/// explicitly freed, as ASTContext will free all of this memory when it gets
2898/// destroyed. Please note that you cannot use delete on the pointer.
2899///
2900/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
2901/// @param C The ASTContext that provides the allocator.
2902/// @param Alignment The alignment of the allocated memory (if the underlying
2903///                  allocator supports it).
2904/// @return The allocated memory. Could be nullptr.
2905inline void *operator new(size_t Bytes, const clang::ASTContext &C,
                        size_t Alignment) {
return C.Allocate(Bytes, Alignment);
2908}

2910/// @brief Placement delete companion to the new above.
2911///
2912/// This operator is just a companion to the new above. There is no way of
2913/// invoking it directly; see the new operator for more details. This operator
2914/// is called implicitly by the compiler if a placement new expression using
2915/// the ASTContext throws in the object constructor.
2916inline void operator delete(void *Ptr, const clang::ASTContext &C, size_t) {
C.Deallocate(Ptr);
2918}

2920/// This placement form of operator new[] uses the ASTContext's allocator for
2921/// obtaining memory.
2922///
2923/// We intentionally avoid using a nothrow specification here so that the calls
2924/// to this operator will not perform a null check on the result -- the
2925/// underlying allocator never returns null pointers.
2926///
2927/// Usage looks like this (assuming there's an ASTContext 'Context' in scope):
2928/// @code
2929/// // Default alignment (8)
2930/// char *data = new (Context) char[10];
2931/// // Specific alignment
2932/// char *data = new (Context, 4) char[10];
2933/// @endcode
2934/// Memory allocated through this placement new[] operator does not need to be
2935/// explicitly freed, as ASTContext will free all of this memory when it gets
2936/// destroyed. Please note that you cannot use delete on the pointer.
2937///
2938/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
2939/// @param C The ASTContext that provides the allocator.
2940/// @param Alignment The alignment of the allocated memory (if the underlying
2941///                  allocator supports it).
2942/// @return The allocated memory. Could be nullptr.
2943inline void *operator new[](size_t Bytes, const clang::ASTContext& C,
                          size_t Alignment = 8) {
return C.Allocate(Bytes, Alignment);
2946}

2948/// @brief Placement delete[] companion to the new[] above.
2949///
2950/// This operator is just a companion to the new[] above. There is no way of
2951/// invoking it directly; see the new[] operator for more details. This operator
2952/// is called implicitly by the compiler if a placement new[] expression using
2953/// the ASTContext throws in the object constructor.
2954inline void operator delete[](void *Ptr, const clang::ASTContext &C, size_t) {
C.Deallocate(Ptr);
2956}

2958/// \brief Create the representation of a LazyGenerationalUpdatePtr.
2959template <typename Owner, typename T,
        void (clang::ExternalASTSource::*Update)(Owner)>
2961typename clang::LazyGenerationalUpdatePtr<Owner, T, Update>::ValueType
  clang::LazyGenerationalUpdatePtr<Owner, T, Update>::makeValue(
      const clang::ASTContext &Ctx, T Value) {
// Note, this is implemented here so that ExternalASTSource.h doesn't need to
// include ASTContext.h. We explicitly instantiate it for all relevant types
// in ASTContext.cpp.
if (auto *Source = Ctx.getExternalSource())
  return new (Ctx) LazyData(Source, Value);
return Value;
2970}

2972#endif // LLVM_CLANG_AST_ASTCONTEXT_H

←

/build/llvm-toolchain-snapshot-7~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/tools/clang/include/clang/AST/DeclTemplate.h"
, 1824, __extension__ __PRETTY_FUNCTION__));
  SpecializedPartialSpecialization *PS
    = new (getASTContext()) SpecializedPartialSpecialization();
  PS->PartialSpecialization = PartialSpec;
  PS->TemplateArgs = TemplateArgs;
  SpecializedTemplate = PS;
}

/// \brief Note that this class template specialization is an instantiation
/// of the given class template.
void setInstantiationOf(ClassTemplateDecl *TemplDecl) {
  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&(static_cast <bool> (!SpecializedTemplate.is<SpecializedPartialSpecialization
*>() && "Previously set to a class template partial specialization!"
) ? void (0) : __assert_fail ("!SpecializedTemplate.is<SpecializedPartialSpecialization*>() && \"Previously set to a class template partial specialization!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/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~svn326246/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)
43
←
Assuming the condition is true→
44
←
Taking true branch→
    ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
45
←
Null pointer value stored to field 'ExplicitInfo'→
  ExplicitInfo->TypeAsWritten = T;
46
←
Access to field 'TypeAsWritten' results in a dereference of a null pointer (loaded from field 'ExplicitInfo')
}

/// \brief Gets the type of this specialization as it was written by
/// the user, if it was so written.
TypeSourceInfo *getTypeAsWritten() const {
  return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
}

/// \brief Gets the location of the extern keyword, if present.
SourceLocation getExternLoc() const {
  return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
}

/// \brief Sets the location of the extern keyword.
void setExternLoc(SourceLocation Loc) {
  if (!ExplicitInfo)
    ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
  ExplicitInfo->ExternLoc = Loc;
}

/// \brief Sets the location of the template keyword.
void setTemplateKeywordLoc(SourceLocation Loc) {
  if (!ExplicitInfo)
    ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
  ExplicitInfo->TemplateKeywordLoc = Loc;
}

/// \brief Gets the location of the template keyword, if present.
SourceLocation getTemplateKeywordLoc() const {
  return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

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

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

static bool classof(const Decl *D) { return classofKind(D->getKind()); }

static bool classofKind(Kind K) {
  return K >= firstClassTemplateSpecialization &&
         K <= lastClassTemplateSpecialization;
}
1898};

1900class ClassTemplatePartialSpecializationDecl
: public ClassTemplateSpecializationDecl {
/// \brief The list of template parameters
TemplateParameterList* TemplateParams = nullptr;

/// \brief The source info for the template arguments as written.
/// FIXME: redundant with TypeAsWritten?
const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;

/// \brief The class template partial specialization from which this
/// class template partial specialization was instantiated.
///
/// The boolean value will be true to indicate that this class template
/// partial specialization was specialized at this level.
llvm::PointerIntPair<ClassTemplatePartialSpecializationDecl *, 1, bool>
    InstantiatedFromMember;

ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
                                       DeclContext *DC,
                                       SourceLocation StartLoc,
                                       SourceLocation IdLoc,
                                       TemplateParameterList *Params,
                                       ClassTemplateDecl *SpecializedTemplate,
                                       ArrayRef<TemplateArgument> Args,
                             const ASTTemplateArgumentListInfo *ArgsAsWritten,
                             ClassTemplatePartialSpecializationDecl *PrevDecl);

ClassTemplatePartialSpecializationDecl(ASTContext &C)
  : ClassTemplateSpecializationDecl(C, ClassTemplatePartialSpecialization),
    InstantiatedFromMember(nullptr, false) {}

void anchor() override;

1933public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static ClassTemplatePartialSpecializationDecl *
Create(ASTContext &Context, TagKind TK, DeclContext *DC,
       SourceLocation StartLoc, SourceLocation IdLoc,
       TemplateParameterList *Params,
       ClassTemplateDecl *SpecializedTemplate,
       ArrayRef<TemplateArgument> Args,
       const TemplateArgumentListInfo &ArgInfos,
       QualType CanonInjectedType,
       ClassTemplatePartialSpecializationDecl *PrevDecl);

static ClassTemplatePartialSpecializationDecl *
CreateDeserialized(ASTContext &C, unsigned ID);

ClassTemplatePartialSpecializationDecl *getMostRecentDecl() {
  return cast<ClassTemplatePartialSpecializationDecl>(
           static_cast<ClassTemplateSpecializationDecl *>(
             this)->getMostRecentDecl());
}

/// Get the list of template parameters
TemplateParameterList *getTemplateParameters() const {
  return TemplateParams;
}

/// Get the template arguments as written.
const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
  return ArgsAsWritten;
}

/// \brief Retrieve the member class template partial specialization from
/// which this particular class template partial specialization was
/// instantiated.
///
/// \code
/// template<typename T>
/// struct Outer {
///   template<typename U> struct Inner;
///   template<typename U> struct Inner<U*> { }; // #1
/// };
///
/// Outer<float>::Inner<int*> ii;
/// \endcode
///
/// In this example, the instantiation of \c Outer<float>::Inner<int*> will
/// end up instantiating the partial specialization
/// \c Outer<float>::Inner<U*>, which itself was instantiated from the class
/// template partial specialization \c Outer<T>::Inner<U*>. Given
/// \c Outer<float>::Inner<U*>, this function would return
/// \c Outer<T>::Inner<U*>.
ClassTemplatePartialSpecializationDecl *getInstantiatedFromMember() const {
  const ClassTemplatePartialSpecializationDecl *First =
      cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
  return First->InstantiatedFromMember.getPointer();
}
ClassTemplatePartialSpecializationDecl *
getInstantiatedFromMemberTemplate() const {
  return getInstantiatedFromMember();
}

void setInstantiatedFromMember(
                        ClassTemplatePartialSpecializationDecl *PartialSpec) {
  ClassTemplatePartialSpecializationDecl *First =
      cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
  First->InstantiatedFromMember.setPointer(PartialSpec);
}

/// \brief Determines whether this class template partial specialization
/// template was a specialization of a member partial specialization.
///
/// In the following example, the member template partial specialization
/// \c X<int>::Inner<T*> is a member specialization.
///
/// \code
/// template<typename T>
/// struct X {
///   template<typename U> struct Inner;
///   template<typename U> struct Inner<U*>;
/// };
///
/// template<> template<typename T>
/// struct X<int>::Inner<T*> { /* ... */ };
/// \endcode
bool isMemberSpecialization() {
  ClassTemplatePartialSpecializationDecl *First =
      cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
  return First->InstantiatedFromMember.getInt();
}

/// \brief Note that this member template is a specialization.
void setMemberSpecialization() {
  ClassTemplatePartialSpecializationDecl *First =
      cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
  assert(First->InstantiatedFromMember.getPointer() &&(static_cast <bool> (First->InstantiatedFromMember.getPointer
() && "Only member templates can be member template specializations"
) ? void (0) : __assert_fail ("First->InstantiatedFromMember.getPointer() && \"Only member templates can be member template specializations\""
, "/build/llvm-toolchain-snapshot-7~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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~svn326246/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