contrib/llvm/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 //===----------------------------------------------------------------------===//
  11
  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"
  35
  36 #include <iterator>
  37 using namespace clang;
  38 using namespace sema;
  39
  40 // Exported for use by Parser.
  41 SourceRange
  42 clang::getTemplateParamsRange(TemplateParameterList const * const *Ps,
  43                               unsigned N) {
  44   if (!N) return SourceRange();
  45   return SourceRange(Ps[0]->getTemplateLoc(), Ps[N-1]->getRAngleLoc());
  46 }
  47
  48 /// \brief Determine whether the declaration found is acceptable as the name
  49 /// of a template and, if so, return that template declaration. Otherwise,
  50 /// returns NULL.
  51 static NamedDecl *isAcceptableTemplateName(ASTContext &Context,
  52                                            NamedDecl *Orig,
  53                                            bool AllowFunctionTemplates) {
  54   NamedDecl *D = Orig->getUnderlyingDecl();
  55
  56   if (isa<TemplateDecl>(D)) {
  57     if (!AllowFunctionTemplates && isa<FunctionTemplateDecl>(D))
  58       return nullptr;
  59
  60     return Orig;
  61   }
  62
  63   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
  64     // C++ [temp.local]p1:
  65     //   Like normal (non-template) classes, class templates have an
  66     //   injected-class-name (Clause 9). The injected-class-name
  67     //   can be used with or without a template-argument-list. When
  68     //   it is used without a template-argument-list, it is
  69     //   equivalent to the injected-class-name followed by the
  70     //   template-parameters of the class template enclosed in
  71     //   <>. When it is used with a template-argument-list, it
  72     //   refers to the specified class template specialization,
  73     //   which could be the current specialization or another
  74     //   specialization.
  75     if (Record->isInjectedClassName()) {
  76       Record = cast<CXXRecordDecl>(Record->getDeclContext());
  77       if (Record->getDescribedClassTemplate())
  78         return Record->getDescribedClassTemplate();
  79
  80       if (ClassTemplateSpecializationDecl *Spec
  81             = dyn_cast<ClassTemplateSpecializationDecl>(Record))
  82         return Spec->getSpecializedTemplate();
  83     }
  84
  85     return nullptr;
  86   }
  87
  88   return nullptr;
  89 }
  90
  91 void Sema::FilterAcceptableTemplateNames(LookupResult &R,
  92                                          bool AllowFunctionTemplates) {
  93   // The set of class templates we've already seen.
  94   llvm::SmallPtrSet<ClassTemplateDecl *, 8> ClassTemplates;
  95   LookupResult::Filter filter = R.makeFilter();
  96   while (filter.hasNext()) {
  97     NamedDecl *Orig = filter.next();
  98     NamedDecl *Repl = isAcceptableTemplateName(Context, Orig,
  99                                                AllowFunctionTemplates);
 100     if (!Repl)
 101       filter.erase();
 102     else if (Repl != Orig) {
 103
 104       // C++ [temp.local]p3:
 105       //   A lookup that finds an injected-class-name (10.2) can result in an
 106       //   ambiguity in certain cases (for example, if it is found in more than
 107       //   one base class). If all of the injected-class-names that are found
 108       //   refer to specializations of the same class template, and if the name
 109       //   is used as a template-name, the reference refers to the class
 110       //   template itself and not a specialization thereof, and is not
 111       //   ambiguous.
 112       if (ClassTemplateDecl *ClassTmpl = dyn_cast<ClassTemplateDecl>(Repl))
 113         if (!ClassTemplates.insert(ClassTmpl).second) {
 114           filter.erase();
 115           continue;
 116         }
 117
 118       // FIXME: we promote access to public here as a workaround to
 119       // the fact that LookupResult doesn't let us remember that we
 120       // found this template through a particular injected class name,
 121       // which means we end up doing nasty things to the invariants.
 122       // Pretending that access is public is *much* safer.
 123       filter.replace(Repl, AS_public);
 124     }
 125   }
 126   filter.done();
 127 }
 128
 129 bool Sema::hasAnyAcceptableTemplateNames(LookupResult &R,
 130                                          bool AllowFunctionTemplates) {
 131   for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I)
 132     if (isAcceptableTemplateName(Context, *I, AllowFunctionTemplates))
 133       return true;
 134
 135   return false;
 136 }
 137
 138 TemplateNameKind Sema::isTemplateName(Scope *S,
 139                                       CXXScopeSpec &SS,
 140                                       bool hasTemplateKeyword,
 141                                       UnqualifiedId &Name,
 142                                       ParsedType ObjectTypePtr,
 143                                       bool EnteringContext,
 144                                       TemplateTy &TemplateResult,
 145                                       bool &MemberOfUnknownSpecialization) {
 146   assert(getLangOpts().CPlusPlus && "No template names in C!");
 147
 148   DeclarationName TName;
 149   MemberOfUnknownSpecialization = false;
 150
 151   switch (Name.getKind()) {
 152   case UnqualifiedId::IK_Identifier:
 153     TName = DeclarationName(Name.Identifier);
 154     break;
 155
 156   case UnqualifiedId::IK_OperatorFunctionId:
 157     TName = Context.DeclarationNames.getCXXOperatorName(
 158                                               Name.OperatorFunctionId.Operator);
 159     break;
 160
 161   case UnqualifiedId::IK_LiteralOperatorId:
 162     TName = Context.DeclarationNames.getCXXLiteralOperatorName(Name.Identifier);
 163     break;
 164
 165   default:
 166     return TNK_Non_template;
 167   }
 168
 169   QualType ObjectType = ObjectTypePtr.get();
 170
 171   LookupResult R(*this, TName, Name.getLocStart(), LookupOrdinaryName);
 172   LookupTemplateName(R, S, SS, ObjectType, EnteringContext,
 173                      MemberOfUnknownSpecialization);
 174   if (R.empty()) return TNK_Non_template;
 175   if (R.isAmbiguous()) {
 176     // Suppress diagnostics;  we'll redo this lookup later.
 177     R.suppressDiagnostics();
 178
 179     // FIXME: we might have ambiguous templates, in which case we
 180     // should at least parse them properly!
 181     return TNK_Non_template;
 182   }
 183
 184   TemplateName Template;
 185   TemplateNameKind TemplateKind;
 186
 187   unsigned ResultCount = R.end() - R.begin();
 188   if (ResultCount > 1) {
 189     // We assume that we'll preserve the qualifier from a function
 190     // template name in other ways.
 191     Template = Context.getOverloadedTemplateName(R.begin(), R.end());
 192     TemplateKind = TNK_Function_template;
 193
 194     // We'll do this lookup again later.
 195     R.suppressDiagnostics();
 196   } else {
 197     TemplateDecl *TD = cast<TemplateDecl>((*R.begin())->getUnderlyingDecl());
 198
 199     if (SS.isSet() && !SS.isInvalid()) {
 200       NestedNameSpecifier *Qualifier = SS.getScopeRep();
 201       Template = Context.getQualifiedTemplateName(Qualifier,
 202                                                   hasTemplateKeyword, TD);
 203     } else {
 204       Template = TemplateName(TD);
 205     }
 206
 207     if (isa<FunctionTemplateDecl>(TD)) {
 208       TemplateKind = TNK_Function_template;
 209
 210       // We'll do this lookup again later.
 211       R.suppressDiagnostics();
 212     } else {
 213       assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||
 214              isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||
 215              isa<BuiltinTemplateDecl>(TD));
 216       TemplateKind =
 217           isa<VarTemplateDecl>(TD) ? TNK_Var_template : TNK_Type_template;
 218     }
 219   }
 220
 221   TemplateResult = TemplateTy::make(Template);
 222   return TemplateKind;
 223 }
 224
 225 bool Sema::DiagnoseUnknownTemplateName(const IdentifierInfo &II,
 226                                        SourceLocation IILoc,
 227                                        Scope *S,
 228                                        const CXXScopeSpec *SS,
 229                                        TemplateTy &SuggestedTemplate,
 230                                        TemplateNameKind &SuggestedKind) {
 231   // We can't recover unless there's a dependent scope specifier preceding the
 232   // template name.
 233   // FIXME: Typo correction?
 234   if (!SS || !SS->isSet() || !isDependentScopeSpecifier(*SS) ||
 235       computeDeclContext(*SS))
 236     return false;
 237
 238   // The code is missing a 'template' keyword prior to the dependent template
 239   // name.
 240   NestedNameSpecifier *Qualifier = (NestedNameSpecifier*)SS->getScopeRep();
 241   Diag(IILoc, diag::err_template_kw_missing)
 242     << Qualifier << II.getName()
 243     << FixItHint::CreateInsertion(IILoc, "template ");
 244   SuggestedTemplate
 245     = TemplateTy::make(Context.getDependentTemplateName(Qualifier, &II));
 246   SuggestedKind = TNK_Dependent_template_name;
 247   return true;
 248 }
 249
 250 void Sema::LookupTemplateName(LookupResult &Found,
 251                               Scope *S, CXXScopeSpec &SS,
 252                               QualType ObjectType,
 253                               bool EnteringContext,
 254                               bool &MemberOfUnknownSpecialization) {
 255   // Determine where to perform name lookup
 256   MemberOfUnknownSpecialization = false;
 257   DeclContext *LookupCtx = nullptr;
 258   bool isDependent = false;
 259   if (!ObjectType.isNull()) {
 260     // This nested-name-specifier occurs in a member access expression, e.g.,
 261     // x->B::f, and we are looking into the type of the object.
 262     assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
 263     LookupCtx = computeDeclContext(ObjectType);
 264     isDependent = ObjectType->isDependentType();
 265     assert((isDependent || !ObjectType->isIncompleteType() ||
 266             ObjectType->castAs<TagType>()->isBeingDefined()) &&
 267            "Caller should have completed object type");
 268
 269     // Template names cannot appear inside an Objective-C class or object type.
 270     if (ObjectType->isObjCObjectOrInterfaceType()) {
 271       Found.clear();
 272       return;
 273     }
 274   } else if (SS.isSet()) {
 275     // This nested-name-specifier occurs after another nested-name-specifier,
 276     // so long into the context associated with the prior nested-name-specifier.
 277     LookupCtx = computeDeclContext(SS, EnteringContext);
 278     isDependent = isDependentScopeSpecifier(SS);
 279
 280     // The declaration context must be complete.
 281     if (LookupCtx && RequireCompleteDeclContext(SS, LookupCtx))
 282       return;
 283   }
 284
 285   bool ObjectTypeSearchedInScope = false;
 286   bool AllowFunctionTemplatesInLookup = true;
 287   if (LookupCtx) {
 288     // Perform "qualified" name lookup into the declaration context we
 289     // computed, which is either the type of the base of a member access
 290     // expression or the declaration context associated with a prior
 291     // nested-name-specifier.
 292     LookupQualifiedName(Found, LookupCtx);
 293     if (!ObjectType.isNull() && Found.empty()) {
 294       // C++ [basic.lookup.classref]p1:
 295       //   In a class member access expression (5.2.5), if the . or -> token is
 296       //   immediately followed by an identifier followed by a <, the
 297       //   identifier must be looked up to determine whether the < is the
 298       //   beginning of a template argument list (14.2) or a less-than operator.
 299       //   The identifier is first looked up in the class of the object
 300       //   expression. If the identifier is not found, it is then looked up in
 301       //   the context of the entire postfix-expression and shall name a class
 302       //   or function template.
 303       if (S) LookupName(Found, S);
 304       ObjectTypeSearchedInScope = true;
 305       AllowFunctionTemplatesInLookup = false;
 306     }
 307   } else if (isDependent && (!S || ObjectType.isNull())) {
 308     // We cannot look into a dependent object type or nested nme
 309     // specifier.
 310     MemberOfUnknownSpecialization = true;
 311     return;
 312   } else {
 313     // Perform unqualified name lookup in the current scope.
 314     LookupName(Found, S);
 315
 316     if (!ObjectType.isNull())
 317       AllowFunctionTemplatesInLookup = false;
 318   }
 319
 320   if (Found.empty() && !isDependent) {
 321     // If we did not find any names, attempt to correct any typos.
 322     DeclarationName Name = Found.getLookupName();
 323     Found.clear();
 324     // Simple filter callback that, for keywords, only accepts the C++ *_cast
 325     auto FilterCCC = llvm::make_unique<CorrectionCandidateCallback>();
 326     FilterCCC->WantTypeSpecifiers = false;
 327     FilterCCC->WantExpressionKeywords = false;
 328     FilterCCC->WantRemainingKeywords = false;
 329     FilterCCC->WantCXXNamedCasts = true;
 330     if (TypoCorrection Corrected = CorrectTypo(
 331             Found.getLookupNameInfo(), Found.getLookupKind(), S, &SS,
 332             std::move(FilterCCC), CTK_ErrorRecovery, LookupCtx)) {
 333       Found.setLookupName(Corrected.getCorrection());
 334       if (auto *ND = Corrected.getFoundDecl())
 335         Found.addDecl(ND);
 336       FilterAcceptableTemplateNames(Found);
 337       if (!Found.empty()) {
 338         if (LookupCtx) {
 339           std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
 340           bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
 341                                   Name.getAsString() == CorrectedStr;
 342           diagnoseTypo(Corrected, PDiag(diag::err_no_member_template_suggest)
 343                                     << Name << LookupCtx << DroppedSpecifier
 344                                     << SS.getRange());
 345         } else {
 346           diagnoseTypo(Corrected, PDiag(diag::err_no_template_suggest) << Name);
 347         }
 348       }
 349     } else {
 350       Found.setLookupName(Name);
 351     }
 352   }
 353
 354   FilterAcceptableTemplateNames(Found, AllowFunctionTemplatesInLookup);
 355   if (Found.empty()) {
 356     if (isDependent)
 357       MemberOfUnknownSpecialization = true;
 358     return;
 359   }
 360
 361   if (S && !ObjectType.isNull() && !ObjectTypeSearchedInScope &&
 362       !getLangOpts().CPlusPlus11) {
 363     // C++03 [basic.lookup.classref]p1:
 364     //   [...] If the lookup in the class of the object expression finds a
 365     //   template, the name is also looked up in the context of the entire
 366     //   postfix-expression and [...]
 367     //
 368     // Note: C++11 does not perform this second lookup.
 369     LookupResult FoundOuter(*this, Found.getLookupName(), Found.getNameLoc(),
 370                             LookupOrdinaryName);
 371     LookupName(FoundOuter, S);
 372     FilterAcceptableTemplateNames(FoundOuter, /*AllowFunctionTemplates=*/false);
 373
 374     if (FoundOuter.empty()) {
 375       //   - if the name is not found, the name found in the class of the
 376       //     object expression is used, otherwise
 377     } else if (!FoundOuter.getAsSingle<ClassTemplateDecl>() ||
 378                FoundOuter.isAmbiguous()) {
 379       //   - if the name is found in the context of the entire
 380       //     postfix-expression and does not name a class template, the name
 381       //     found in the class of the object expression is used, otherwise
 382       FoundOuter.clear();
 383     } else if (!Found.isSuppressingDiagnostics()) {
 384       //   - if the name found is a class template, it must refer to the same
 385       //     entity as the one found in the class of the object expression,
 386       //     otherwise the program is ill-formed.
 387       if (!Found.isSingleResult() ||
 388           Found.getFoundDecl()->getCanonicalDecl()
 389             != FoundOuter.getFoundDecl()->getCanonicalDecl()) {
 390         Diag(Found.getNameLoc(),
 391              diag::ext_nested_name_member_ref_lookup_ambiguous)
 392           << Found.getLookupName()
 393           << ObjectType;
 394         Diag(Found.getRepresentativeDecl()->getLocation(),
 395              diag::note_ambig_member_ref_object_type)
 396           << ObjectType;
 397         Diag(FoundOuter.getFoundDecl()->getLocation(),
 398              diag::note_ambig_member_ref_scope);
 399
 400         // Recover by taking the template that we found in the object
 401         // expression's type.
 402       }
 403     }
 404   }
 405 }
 406
 407 /// ActOnDependentIdExpression - Handle a dependent id-expression that
 408 /// was just parsed.  This is only possible with an explicit scope
 409 /// specifier naming a dependent type.
 410 ExprResult
 411 Sema::ActOnDependentIdExpression(const CXXScopeSpec &SS,
 412                                  SourceLocation TemplateKWLoc,
 413                                  const DeclarationNameInfo &NameInfo,
 414                                  bool isAddressOfOperand,
 415                            const TemplateArgumentListInfo *TemplateArgs) {
 416   DeclContext *DC = getFunctionLevelDeclContext();
 417
 418   // C++11 [expr.prim.general]p12:
 419   //   An id-expression that denotes a non-static data member or non-static
 420   //   member function of a class can only be used:
 421   //   (...)
 422   //   - if that id-expression denotes a non-static data member and it
 423   //     appears in an unevaluated operand.
 424   //
 425   // If this might be the case, form a DependentScopeDeclRefExpr instead of a
 426   // CXXDependentScopeMemberExpr. The former can instantiate to either
 427   // DeclRefExpr or MemberExpr depending on lookup results, while the latter is
 428   // always a MemberExpr.
 429   bool MightBeCxx11UnevalField =
 430       getLangOpts().CPlusPlus11 && isUnevaluatedContext();
 431
 432   // Check if the nested name specifier is an enum type.
 433   bool IsEnum = false;
 434   if (NestedNameSpecifier *NNS = SS.getScopeRep())
 435     IsEnum = dyn_cast_or_null<EnumType>(NNS->getAsType());
 436
 437   if (!MightBeCxx11UnevalField && !isAddressOfOperand && !IsEnum &&
 438       isa<CXXMethodDecl>(DC) && cast<CXXMethodDecl>(DC)->isInstance()) {
 439     QualType ThisType = cast<CXXMethodDecl>(DC)->getThisType(Context);
 440
 441     // Since the 'this' expression is synthesized, we don't need to
 442     // perform the double-lookup check.
 443     NamedDecl *FirstQualifierInScope = nullptr;
 444
 445     return CXXDependentScopeMemberExpr::Create(
 446         Context, /*This*/ nullptr, ThisType, /*IsArrow*/ true,
 447         /*Op*/ SourceLocation(), SS.getWithLocInContext(Context), TemplateKWLoc,
 448         FirstQualifierInScope, NameInfo, TemplateArgs);
 449   }
 450
 451   return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
 452 }
 453
 454 ExprResult
 455 Sema::BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
 456                                 SourceLocation TemplateKWLoc,
 457                                 const DeclarationNameInfo &NameInfo,
 458                                 const TemplateArgumentListInfo *TemplateArgs) {
 459   return DependentScopeDeclRefExpr::Create(
 460       Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
 461       TemplateArgs);
 462 }
 463
 464
 465 /// Determine whether we would be unable to instantiate this template (because
 466 /// it either has no definition, or is in the process of being instantiated).
 467 bool Sema::DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation,
 468                                           NamedDecl *Instantiation,
 469                                           bool InstantiatedFromMember,
 470                                           const NamedDecl *Pattern,
 471                                           const NamedDecl *PatternDef,
 472                                           TemplateSpecializationKind TSK,
 473                                           bool Complain /*= true*/) {
 474   assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||
 475          isa<VarDecl>(Instantiation));
 476
 477   bool IsEntityBeingDefined = false;
 478   if (const TagDecl *TD = dyn_cast_or_null<TagDecl>(PatternDef))
 479     IsEntityBeingDefined = TD->isBeingDefined();
 480
 481   if (PatternDef && !IsEntityBeingDefined) {
 482     NamedDecl *SuggestedDef = nullptr;
 483     if (!hasVisibleDefinition(const_cast<NamedDecl*>(PatternDef), &SuggestedDef,
 484                               /*OnlyNeedComplete*/false)) {
 485       // If we're allowed to diagnose this and recover, do so.
 486       bool Recover = Complain && !isSFINAEContext();
 487       if (Complain)
 488         diagnoseMissingImport(PointOfInstantiation, SuggestedDef,
 489                               Sema::MissingImportKind::Definition, Recover);
 490       return !Recover;
 491     }
 492     return false;
 493   }
 494
 495   if (!Complain || (PatternDef && PatternDef->isInvalidDecl()))
 496     return true;
 497
 498   llvm::Optional<unsigned> Note;
 499   QualType InstantiationTy;
 500   if (TagDecl *TD = dyn_cast<TagDecl>(Instantiation))
 501     InstantiationTy = Context.getTypeDeclType(TD);
 502   if (PatternDef) {
 503     Diag(PointOfInstantiation,
 504          diag::err_template_instantiate_within_definition)
 505       << /*implicit|explicit*/(TSK != TSK_ImplicitInstantiation)
 506       << InstantiationTy;
 507     // Not much point in noting the template declaration here, since
 508     // we're lexically inside it.
 509     Instantiation->setInvalidDecl();
 510   } else if (InstantiatedFromMember) {
 511     if (isa<FunctionDecl>(Instantiation)) {
 512       Diag(PointOfInstantiation,
 513            diag::err_explicit_instantiation_undefined_member)
 514         << /*member function*/ 1 << Instantiation->getDeclName()
 515         << Instantiation->getDeclContext();
 516       Note = diag::note_explicit_instantiation_here;
 517     } else {
 518       assert(isa<TagDecl>(Instantiation) && "Must be a TagDecl!");
 519       Diag(PointOfInstantiation,
 520            diag::err_implicit_instantiate_member_undefined)
 521         << InstantiationTy;
 522       Note = diag::note_member_declared_at;
 523     }
 524   } else {
 525     if (isa<FunctionDecl>(Instantiation)) {
 526       Diag(PointOfInstantiation,
 527            diag::err_explicit_instantiation_undefined_func_template)
 528         << Pattern;
 529       Note = diag::note_explicit_instantiation_here;
 530     } else if (isa<TagDecl>(Instantiation)) {
 531       Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
 532         << (TSK != TSK_ImplicitInstantiation)
 533         << InstantiationTy;
 534       Note = diag::note_template_decl_here;
 535     } else {
 536       assert(isa<VarDecl>(Instantiation) && "Must be a VarDecl!");
 537       if (isa<VarTemplateSpecializationDecl>(Instantiation)) {
 538         Diag(PointOfInstantiation,
 539              diag::err_explicit_instantiation_undefined_var_template)
 540           << Instantiation;
 541         Instantiation->setInvalidDecl();
 542       } else
 543         Diag(PointOfInstantiation,
 544              diag::err_explicit_instantiation_undefined_member)
 545           << /*static data member*/ 2 << Instantiation->getDeclName()
 546           << Instantiation->getDeclContext();
 547       Note = diag::note_explicit_instantiation_here;
 548     }
 549   }
 550   if (Note) // Diagnostics were emitted.
 551     Diag(Pattern->getLocation(), Note.getValue());
 552
 553   // In general, Instantiation isn't marked invalid to get more than one
 554   // error for multiple undefined instantiations. But the code that does
 555   // explicit declaration -> explicit definition conversion can't handle
 556   // invalid declarations, so mark as invalid in that case.
 557   if (TSK == TSK_ExplicitInstantiationDeclaration)
 558     Instantiation->setInvalidDecl();
 559   return true;
 560 }
 561
 562 /// DiagnoseTemplateParameterShadow - Produce a diagnostic complaining
 563 /// that the template parameter 'PrevDecl' is being shadowed by a new
 564 /// declaration at location Loc. Returns true to indicate that this is
 565 /// an error, and false otherwise.
 566 void Sema::DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl) {
 567   assert(PrevDecl->isTemplateParameter() && "Not a template parameter");
 568
 569   // Microsoft Visual C++ permits template parameters to be shadowed.
 570   if (getLangOpts().MicrosoftExt)
 571     return;
 572
 573   // C++ [temp.local]p4:
 574   //   A template-parameter shall not be redeclared within its
 575   //   scope (including nested scopes).
 576   Diag(Loc, diag::err_template_param_shadow)
 577     << cast<NamedDecl>(PrevDecl)->getDeclName();
 578   Diag(PrevDecl->getLocation(), diag::note_template_param_here);
 579 }
 580
 581 /// AdjustDeclIfTemplate - If the given decl happens to be a template, reset
 582 /// the parameter D to reference the templated declaration and return a pointer
 583 /// to the template declaration. Otherwise, do nothing to D and return null.
 584 TemplateDecl *Sema::AdjustDeclIfTemplate(Decl *&D) {
 585   if (TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D)) {
 586     D = Temp->getTemplatedDecl();
 587     return Temp;
 588   }
 589   return nullptr;
 590 }
 591
 592 ParsedTemplateArgument ParsedTemplateArgument::getTemplatePackExpansion(
 593                                              SourceLocation EllipsisLoc) const {
 594   assert(Kind == Template &&
 595          "Only template template arguments can be pack expansions here");
 596   assert(getAsTemplate().get().containsUnexpandedParameterPack() &&
 597          "Template template argument pack expansion without packs");
 598   ParsedTemplateArgument Result(*this);
 599   Result.EllipsisLoc = EllipsisLoc;
 600   return Result;
 601 }
 602
 603 static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef,
 604                                             const ParsedTemplateArgument &Arg) {
 605
 606   switch (Arg.getKind()) {
 607   case ParsedTemplateArgument::Type: {
 608     TypeSourceInfo *DI;
 609     QualType T = SemaRef.GetTypeFromParser(Arg.getAsType(), &DI);
 610     if (!DI)
 611       DI = SemaRef.Context.getTrivialTypeSourceInfo(T, Arg.getLocation());
 612     return TemplateArgumentLoc(TemplateArgument(T), DI);
 613   }
 614
 615   case ParsedTemplateArgument::NonType: {
 616     Expr *E = static_cast<Expr *>(Arg.getAsExpr());
 617     return TemplateArgumentLoc(TemplateArgument(E), E);
 618   }
 619
 620   case ParsedTemplateArgument::Template: {
 621     TemplateName Template = Arg.getAsTemplate().get();
 622     TemplateArgument TArg;
 623     if (Arg.getEllipsisLoc().isValid())
 624       TArg = TemplateArgument(Template, Optional<unsigned int>());
 625     else
 626       TArg = Template;
 627     return TemplateArgumentLoc(TArg,
 628                                Arg.getScopeSpec().getWithLocInContext(
 629                                                               SemaRef.Context),
 630                                Arg.getLocation(),
 631                                Arg.getEllipsisLoc());
 632   }
 633   }
 634
 635   llvm_unreachable("Unhandled parsed template argument");
 636 }
 637
 638 /// \brief Translates template arguments as provided by the parser
 639 /// into template arguments used by semantic analysis.
 640 void Sema::translateTemplateArguments(const ASTTemplateArgsPtr &TemplateArgsIn,
 641                                       TemplateArgumentListInfo &TemplateArgs) {
 642  for (unsigned I = 0, Last = TemplateArgsIn.size(); I != Last; ++I)
 643    TemplateArgs.addArgument(translateTemplateArgument(*this,
 644                                                       TemplateArgsIn[I]));
 645 }
 646
 647 static void maybeDiagnoseTemplateParameterShadow(Sema &SemaRef, Scope *S,
 648                                                  SourceLocation Loc,
 649                                                  IdentifierInfo *Name) {
 650   NamedDecl *PrevDecl = SemaRef.LookupSingleName(
 651       S, Name, Loc, Sema::LookupOrdinaryName, Sema::ForRedeclaration);
 652   if (PrevDecl && PrevDecl->isTemplateParameter())
 653     SemaRef.DiagnoseTemplateParameterShadow(Loc, PrevDecl);
 654 }
 655
 656 /// ActOnTypeParameter - Called when a C++ template type parameter
 657 /// (e.g., "typename T") has been parsed. Typename specifies whether
 658 /// the keyword "typename" was used to declare the type parameter
 659 /// (otherwise, "class" was used), and KeyLoc is the location of the
 660 /// "class" or "typename" keyword. ParamName is the name of the
 661 /// parameter (NULL indicates an unnamed template parameter) and
 662 /// ParamNameLoc is the location of the parameter name (if any).
 663 /// If the type parameter has a default argument, it will be added
 664 /// later via ActOnTypeParameterDefault.
 665 Decl *Sema::ActOnTypeParameter(Scope *S, bool Typename,
 666                                SourceLocation EllipsisLoc,
 667                                SourceLocation KeyLoc,
 668                                IdentifierInfo *ParamName,
 669                                SourceLocation ParamNameLoc,
 670                                unsigned Depth, unsigned Position,
 671                                SourceLocation EqualLoc,
 672                                ParsedType DefaultArg) {
 673   assert(S->isTemplateParamScope() &&
 674          "Template type parameter not in template parameter scope!");
 675
 676   SourceLocation Loc = ParamNameLoc;
 677   if (!ParamName)
 678     Loc = KeyLoc;
 679
 680   bool IsParameterPack = EllipsisLoc.isValid();
 681   TemplateTypeParmDecl *Param
 682     = TemplateTypeParmDecl::Create(Context, Context.getTranslationUnitDecl(),
 683                                    KeyLoc, Loc, Depth, Position, ParamName,
 684                                    Typename, IsParameterPack);
 685   Param->setAccess(AS_public);
 686
 687   if (ParamName) {
 688     maybeDiagnoseTemplateParameterShadow(*this, S, ParamNameLoc, ParamName);
 689
 690     // Add the template parameter into the current scope.
 691     S->AddDecl(Param);
 692     IdResolver.AddDecl(Param);
 693   }
 694
 695   // C++0x [temp.param]p9:
 696   //   A default template-argument may be specified for any kind of
 697   //   template-parameter that is not a template parameter pack.
 698   if (DefaultArg && IsParameterPack) {
 699     Diag(EqualLoc, diag::err_template_param_pack_default_arg);
 700     DefaultArg = nullptr;
 701   }
 702
 703   // Handle the default argument, if provided.
 704   if (DefaultArg) {
 705     TypeSourceInfo *DefaultTInfo;
 706     GetTypeFromParser(DefaultArg, &DefaultTInfo);
 707
 708     assert(DefaultTInfo && "expected source information for type");
 709
 710     // Check for unexpanded parameter packs.
 711     if (DiagnoseUnexpandedParameterPack(Loc, DefaultTInfo,
 712                                         UPPC_DefaultArgument))
 713       return Param;
 714
 715     // Check the template argument itself.
 716     if (CheckTemplateArgument(Param, DefaultTInfo)) {
 717       Param->setInvalidDecl();
 718       return Param;
 719     }
 720
 721     Param->setDefaultArgument(DefaultTInfo);
 722   }
 723
 724   return Param;
 725 }
 726
 727 /// \brief Check that the type of a non-type template parameter is
 728 /// well-formed.
 729 ///
 730 /// \returns the (possibly-promoted) parameter type if valid;
 731 /// otherwise, produces a diagnostic and returns a NULL type.
 732 QualType Sema::CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,
 733                                                  SourceLocation Loc) {
 734   if (TSI->getType()->isUndeducedType()) {
 735     // C++1z [temp.dep.expr]p3:
 736     //   An id-expression is type-dependent if it contains
 737     //    - an identifier associated by name lookup with a non-type
 738     //      template-parameter declared with a type that contains a
 739     //      placeholder type (7.1.7.4),
 740     TSI = SubstAutoTypeSourceInfo(TSI, Context.DependentTy);
 741   }
 742
 743   return CheckNonTypeTemplateParameterType(TSI->getType(), Loc);
 744 }
 745
 746 QualType Sema::CheckNonTypeTemplateParameterType(QualType T,
 747                                                  SourceLocation Loc) {
 748   // We don't allow variably-modified types as the type of non-type template
 749   // parameters.
 750   if (T->isVariablyModifiedType()) {
 751     Diag(Loc, diag::err_variably_modified_nontype_template_param)
 752       << T;
 753     return QualType();
 754   }
 755
 756   // C++ [temp.param]p4:
 757   //
 758   // A non-type template-parameter shall have one of the following
 759   // (optionally cv-qualified) types:
 760   //
 761   //       -- integral or enumeration type,
 762   if (T->isIntegralOrEnumerationType() ||
 763       //   -- pointer to object or pointer to function,
 764       T->isPointerType() ||
 765       //   -- reference to object or reference to function,
 766       T->isReferenceType() ||
 767       //   -- pointer to member,
 768       T->isMemberPointerType() ||
 769       //   -- std::nullptr_t.
 770       T->isNullPtrType() ||
 771       // If T is a dependent type, we can't do the check now, so we
 772       // assume that it is well-formed.
 773       T->isDependentType() ||
 774       // Allow use of auto in template parameter declarations.
 775       T->isUndeducedType()) {
 776     // C++ [temp.param]p5: The top-level cv-qualifiers on the template-parameter
 777     // are ignored when determining its type.
 778     return T.getUnqualifiedType();
 779   }
 780
 781   // C++ [temp.param]p8:
 782   //
 783   //   A non-type template-parameter of type "array of T" or
 784   //   "function returning T" is adjusted to be of type "pointer to
 785   //   T" or "pointer to function returning T", respectively.
 786   else if (T->isArrayType() || T->isFunctionType())
 787     return Context.getDecayedType(T);
 788
 789   Diag(Loc, diag::err_template_nontype_parm_bad_type)
 790     << T;
 791
 792   return QualType();
 793 }
 794
 795 Decl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
 796                                           unsigned Depth,
 797                                           unsigned Position,
 798                                           SourceLocation EqualLoc,
 799                                           Expr *Default) {
 800   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
 801
 802   if (TInfo->getType()->isUndeducedType()) {
 803     Diag(D.getIdentifierLoc(),
 804          diag::warn_cxx14_compat_template_nontype_parm_auto_type)
 805       << QualType(TInfo->getType()->getContainedAutoType(), 0);
 806   }
 807
 808   assert(S->isTemplateParamScope() &&
 809          "Non-type template parameter not in template parameter scope!");
 810   bool Invalid = false;
 811
 812   QualType T = CheckNonTypeTemplateParameterType(TInfo, D.getIdentifierLoc());
 813   if (T.isNull()) {
 814     T = Context.IntTy; // Recover with an 'int' type.
 815     Invalid = true;
 816   }
 817
 818   IdentifierInfo *ParamName = D.getIdentifier();
 819   bool IsParameterPack = D.hasEllipsis();
 820   NonTypeTemplateParmDecl *Param
 821     = NonTypeTemplateParmDecl::Create(Context, Context.getTranslationUnitDecl(),
 822                                       D.getLocStart(),
 823                                       D.getIdentifierLoc(),
 824                                       Depth, Position, ParamName, T,
 825                                       IsParameterPack, TInfo);
 826   Param->setAccess(AS_public);
 827
 828   if (Invalid)
 829     Param->setInvalidDecl();
 830
 831   if (ParamName) {
 832     maybeDiagnoseTemplateParameterShadow(*this, S, D.getIdentifierLoc(),
 833                                          ParamName);
 834
 835     // Add the template parameter into the current scope.
 836     S->AddDecl(Param);
 837     IdResolver.AddDecl(Param);
 838   }
 839
 840   // C++0x [temp.param]p9:
 841   //   A default template-argument may be specified for any kind of
 842   //   template-parameter that is not a template parameter pack.
 843   if (Default && IsParameterPack) {
 844     Diag(EqualLoc, diag::err_template_param_pack_default_arg);
 845     Default = nullptr;
 846   }
 847
 848   // Check the well-formedness of the default template argument, if provided.
 849   if (Default) {
 850     // Check for unexpanded parameter packs.
 851     if (DiagnoseUnexpandedParameterPack(Default, UPPC_DefaultArgument))
 852       return Param;
 853
 854     TemplateArgument Converted;
 855     ExprResult DefaultRes =
 856         CheckTemplateArgument(Param, Param->getType(), Default, Converted);
 857     if (DefaultRes.isInvalid()) {
 858       Param->setInvalidDecl();
 859       return Param;
 860     }
 861     Default = DefaultRes.get();
 862
 863     Param->setDefaultArgument(Default);
 864   }
 865
 866   return Param;
 867 }
 868
 869 /// ActOnTemplateTemplateParameter - Called when a C++ template template
 870 /// parameter (e.g. T in template <template \<typename> class T> class array)
 871 /// has been parsed. S is the current scope.
 872 Decl *Sema::ActOnTemplateTemplateParameter(Scope* S,
 873                                            SourceLocation TmpLoc,
 874                                            TemplateParameterList *Params,
 875                                            SourceLocation EllipsisLoc,
 876                                            IdentifierInfo *Name,
 877                                            SourceLocation NameLoc,
 878                                            unsigned Depth,
 879                                            unsigned Position,
 880                                            SourceLocation EqualLoc,
 881                                            ParsedTemplateArgument Default) {
 882   assert(S->isTemplateParamScope() &&
 883          "Template template parameter not in template parameter scope!");
 884
 885   // Construct the parameter object.
 886   bool IsParameterPack = EllipsisLoc.isValid();
 887   TemplateTemplateParmDecl *Param =
 888     TemplateTemplateParmDecl::Create(Context, Context.getTranslationUnitDecl(),
 889                                      NameLoc.isInvalid()? TmpLoc : NameLoc,
 890                                      Depth, Position, IsParameterPack,
 891                                      Name, Params);
 892   Param->setAccess(AS_public);
 893
 894   // If the template template parameter has a name, then link the identifier
 895   // into the scope and lookup mechanisms.
 896   if (Name) {
 897     maybeDiagnoseTemplateParameterShadow(*this, S, NameLoc, Name);
 898
 899     S->AddDecl(Param);
 900     IdResolver.AddDecl(Param);
 901   }
 902
 903   if (Params->size() == 0) {
 904     Diag(Param->getLocation(), diag::err_template_template_parm_no_parms)
 905     << SourceRange(Params->getLAngleLoc(), Params->getRAngleLoc());
 906     Param->setInvalidDecl();
 907   }
 908
 909   // C++0x [temp.param]p9:
 910   //   A default template-argument may be specified for any kind of
 911   //   template-parameter that is not a template parameter pack.
 912   if (IsParameterPack && !Default.isInvalid()) {
 913     Diag(EqualLoc, diag::err_template_param_pack_default_arg);
 914     Default = ParsedTemplateArgument();
 915   }
 916
 917   if (!Default.isInvalid()) {
 918     // Check only that we have a template template argument. We don't want to
 919     // try to check well-formedness now, because our template template parameter
 920     // might have dependent types in its template parameters, which we wouldn't
 921     // be able to match now.
 922     //
 923     // If none of the template template parameter's template arguments mention
 924     // other template parameters, we could actually perform more checking here.
 925     // However, it isn't worth doing.
 926     TemplateArgumentLoc DefaultArg = translateTemplateArgument(*this, Default);
 927     if (DefaultArg.getArgument().getAsTemplate().isNull()) {
 928       Diag(DefaultArg.getLocation(), diag::err_template_arg_not_valid_template)
 929         << DefaultArg.getSourceRange();
 930       return Param;
 931     }
 932
 933     // Check for unexpanded parameter packs.
 934     if (DiagnoseUnexpandedParameterPack(DefaultArg.getLocation(),
 935                                         DefaultArg.getArgument().getAsTemplate(),
 936                                         UPPC_DefaultArgument))
 937       return Param;
 938
 939     Param->setDefaultArgument(Context, DefaultArg);
 940   }
 941
 942   return Param;
 943 }
 944
 945 /// ActOnTemplateParameterList - Builds a TemplateParameterList, optionally
 946 /// constrained by RequiresClause, that contains the template parameters in
 947 /// Params.
 948 TemplateParameterList *
 949 Sema::ActOnTemplateParameterList(unsigned Depth,
 950                                  SourceLocation ExportLoc,
 951                                  SourceLocation TemplateLoc,
 952                                  SourceLocation LAngleLoc,
 953                                  ArrayRef<Decl *> Params,
 954                                  SourceLocation RAngleLoc,
 955                                  Expr *RequiresClause) {
 956   if (ExportLoc.isValid())
 957     Diag(ExportLoc, diag::warn_template_export_unsupported);
 958
 959   return TemplateParameterList::Create(
 960       Context, TemplateLoc, LAngleLoc,
 961       llvm::makeArrayRef((NamedDecl *const *)Params.data(), Params.size()),
 962       RAngleLoc, RequiresClause);
 963 }
 964
 965 static void SetNestedNameSpecifier(TagDecl *T, const CXXScopeSpec &SS) {
 966   if (SS.isSet())
 967     T->setQualifierInfo(SS.getWithLocInContext(T->getASTContext()));
 968 }
 969
 970 DeclResult
 971 Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
 972                          SourceLocation KWLoc, CXXScopeSpec &SS,
 973                          IdentifierInfo *Name, SourceLocation NameLoc,
 974                          AttributeList *Attr,
 975                          TemplateParameterList *TemplateParams,
 976                          AccessSpecifier AS, SourceLocation ModulePrivateLoc,
 977                          SourceLocation FriendLoc,
 978                          unsigned NumOuterTemplateParamLists,
 979                          TemplateParameterList** OuterTemplateParamLists,
 980                          SkipBodyInfo *SkipBody) {
 981   assert(TemplateParams && TemplateParams->size() > 0 &&
 982          "No template parameters");
 983   assert(TUK != TUK_Reference && "Can only declare or define class templates");
 984   bool Invalid = false;
 985
 986   // Check that we can declare a template here.
 987   if (CheckTemplateDeclScope(S, TemplateParams))
 988     return true;
 989
 990   TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
 991   assert(Kind != TTK_Enum && "can't build template of enumerated type");
 992
 993   // There is no such thing as an unnamed class template.
 994   if (!Name) {
 995     Diag(KWLoc, diag::err_template_unnamed_class);
 996     return true;
 997   }
 998
 999   // Find any previous declaration with this name. For a friend with no
1000   // scope explicitly specified, we only look for tag declarations (per
1001   // C++11 [basic.lookup.elab]p2).
1002   DeclContext *SemanticContext;
1003   LookupResult Previous(*this, Name, NameLoc,
1004                         (SS.isEmpty() && TUK == TUK_Friend)
1005                           ? LookupTagName : LookupOrdinaryName,
1006                         ForRedeclaration);
1007   if (SS.isNotEmpty() && !SS.isInvalid()) {
1008     SemanticContext = computeDeclContext(SS, true);
1009     if (!SemanticContext) {
1010       // FIXME: Horrible, horrible hack! We can't currently represent this
1011       // in the AST, and historically we have just ignored such friend
1012       // class templates, so don't complain here.
1013       Diag(NameLoc, TUK == TUK_Friend
1014                         ? diag::warn_template_qualified_friend_ignored
1015                         : diag::err_template_qualified_declarator_no_match)
1016           << SS.getScopeRep() << SS.getRange();
1017       return TUK != TUK_Friend;
1018     }
1019
1020     if (RequireCompleteDeclContext(SS, SemanticContext))
1021       return true;
1022
1023     // If we're adding a template to a dependent context, we may need to
1024     // rebuilding some of the types used within the template parameter list,
1025     // now that we know what the current instantiation is.
1026     if (SemanticContext->isDependentContext()) {
1027       ContextRAII SavedContext(*this, SemanticContext);
1028       if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
1029         Invalid = true;
1030     } else if (TUK != TUK_Friend && TUK != TUK_Reference)
1031       diagnoseQualifiedDeclaration(SS, SemanticContext, Name, NameLoc);
1032
1033     LookupQualifiedName(Previous, SemanticContext);
1034   } else {
1035     SemanticContext = CurContext;
1036
1037     // C++14 [class.mem]p14:
1038     //   If T is the name of a class, then each of the following shall have a
1039     //   name different from T:
1040     //    -- every member template of class T
1041     if (TUK != TUK_Friend &&
1042         DiagnoseClassNameShadow(SemanticContext,
1043                                 DeclarationNameInfo(Name, NameLoc)))
1044       return true;
1045
1046     LookupName(Previous, S);
1047   }
1048
1049   if (Previous.isAmbiguous())
1050     return true;
1051
1052   NamedDecl *PrevDecl = nullptr;
1053   if (Previous.begin() != Previous.end())
1054     PrevDecl = (*Previous.begin())->getUnderlyingDecl();
1055
1056   if (PrevDecl && PrevDecl->isTemplateParameter()) {
1057     // Maybe we will complain about the shadowed template parameter.
1058     DiagnoseTemplateParameterShadow(NameLoc, PrevDecl);
1059     // Just pretend that we didn't see the previous declaration.
1060     PrevDecl = nullptr;
1061   }
1062
1063   // If there is a previous declaration with the same name, check
1064   // whether this is a valid redeclaration.
1065   ClassTemplateDecl *PrevClassTemplate
1066     = dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);
1067
1068   // We may have found the injected-class-name of a class template,
1069   // class template partial specialization, or class template specialization.
1070   // In these cases, grab the template that is being defined or specialized.
1071   if (!PrevClassTemplate && PrevDecl && isa<CXXRecordDecl>(PrevDecl) &&
1072       cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {
1073     PrevDecl = cast<CXXRecordDecl>(PrevDecl->getDeclContext());
1074     PrevClassTemplate
1075       = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();
1076     if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {
1077       PrevClassTemplate
1078         = cast<ClassTemplateSpecializationDecl>(PrevDecl)
1079             ->getSpecializedTemplate();
1080     }
1081   }
1082
1083   if (TUK == TUK_Friend) {
1084     // C++ [namespace.memdef]p3:
1085     //   [...] When looking for a prior declaration of a class or a function
1086     //   declared as a friend, and when the name of the friend class or
1087     //   function is neither a qualified name nor a template-id, scopes outside
1088     //   the innermost enclosing namespace scope are not considered.
1089     if (!SS.isSet()) {
1090       DeclContext *OutermostContext = CurContext;
1091       while (!OutermostContext->isFileContext())
1092         OutermostContext = OutermostContext->getLookupParent();
1093
1094       if (PrevDecl &&
1095           (OutermostContext->Equals(PrevDecl->getDeclContext()) ||
1096            OutermostContext->Encloses(PrevDecl->getDeclContext()))) {
1097         SemanticContext = PrevDecl->getDeclContext();
1098       } else {
1099         // Declarations in outer scopes don't matter. However, the outermost
1100         // context we computed is the semantic context for our new
1101         // declaration.
1102         PrevDecl = PrevClassTemplate = nullptr;
1103         SemanticContext = OutermostContext;
1104
1105         // Check that the chosen semantic context doesn't already contain a
1106         // declaration of this name as a non-tag type.
1107         Previous.clear(LookupOrdinaryName);
1108         DeclContext *LookupContext = SemanticContext;
1109         while (LookupContext->isTransparentContext())
1110           LookupContext = LookupContext->getLookupParent();
1111         LookupQualifiedName(Previous, LookupContext);
1112
1113         if (Previous.isAmbiguous())
1114           return true;
1115
1116         if (Previous.begin() != Previous.end())
1117           PrevDecl = (*Previous.begin())->getUnderlyingDecl();
1118       }
1119     }
1120   } else if (PrevDecl &&
1121              !isDeclInScope(Previous.getRepresentativeDecl(), SemanticContext,
1122                             S, SS.isValid()))
1123     PrevDecl = PrevClassTemplate = nullptr;
1124
1125   if (auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
1126           PrevDecl ? Previous.getRepresentativeDecl() : nullptr)) {
1127     if (SS.isEmpty() &&
1128         !(PrevClassTemplate &&
1129           PrevClassTemplate->getDeclContext()->getRedeclContext()->Equals(
1130               SemanticContext->getRedeclContext()))) {
1131       Diag(KWLoc, diag::err_using_decl_conflict_reverse);
1132       Diag(Shadow->getTargetDecl()->getLocation(),
1133            diag::note_using_decl_target);
1134       Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
1135       // Recover by ignoring the old declaration.
1136       PrevDecl = PrevClassTemplate = nullptr;
1137     }
1138   }
1139
1140   if (PrevClassTemplate) {
1141     // Ensure that the template parameter lists are compatible. Skip this check
1142     // for a friend in a dependent context: the template parameter list itself
1143     // could be dependent.
1144     if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
1145         !TemplateParameterListsAreEqual(TemplateParams,
1146                                    PrevClassTemplate->getTemplateParameters(),
1147                                         /*Complain=*/true,
1148                                         TPL_TemplateMatch))
1149       return true;
1150
1151     // C++ [temp.class]p4:
1152     //   In a redeclaration, partial specialization, explicit
1153     //   specialization or explicit instantiation of a class template,
1154     //   the class-key shall agree in kind with the original class
1155     //   template declaration (7.1.5.3).
1156     RecordDecl *PrevRecordDecl = PrevClassTemplate->getTemplatedDecl();
1157     if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind,
1158                                       TUK == TUK_Definition,  KWLoc, Name)) {
1159       Diag(KWLoc, diag::err_use_with_wrong_tag)
1160         << Name
1161         << FixItHint::CreateReplacement(KWLoc, PrevRecordDecl->getKindName());
1162       Diag(PrevRecordDecl->getLocation(), diag::note_previous_use);
1163       Kind = PrevRecordDecl->getTagKind();
1164     }
1165
1166     // Check for redefinition of this class template.
1167     if (TUK == TUK_Definition) {
1168       if (TagDecl *Def = PrevRecordDecl->getDefinition()) {
1169         // If we have a prior definition that is not visible, treat this as
1170         // simply making that previous definition visible.
1171         NamedDecl *Hidden = nullptr;
1172         if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
1173           SkipBody->ShouldSkip = true;
1174           auto *Tmpl = cast<CXXRecordDecl>(Hidden)->getDescribedClassTemplate();
1175           assert(Tmpl && "original definition of a class template is not a "
1176                          "class template?");
1177           makeMergedDefinitionVisible(Hidden, KWLoc);
1178           makeMergedDefinitionVisible(Tmpl, KWLoc);
1179           return Def;
1180         }
1181
1182         Diag(NameLoc, diag::err_redefinition) << Name;
1183         Diag(Def->getLocation(), diag::note_previous_definition);
1184         // FIXME: Would it make sense to try to "forget" the previous
1185         // definition, as part of error recovery?
1186         return true;
1187       }
1188     }
1189   } else if (PrevDecl) {
1190     // C++ [temp]p5:
1191     //   A class template shall not have the same name as any other
1192     //   template, class, function, object, enumeration, enumerator,
1193     //   namespace, or type in the same scope (3.3), except as specified
1194     //   in (14.5.4).
1195     Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
1196     Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1197     return true;
1198   }
1199
1200   // Check the template parameter list of this declaration, possibly
1201   // merging in the template parameter list from the previous class
1202   // template declaration. Skip this check for a friend in a dependent
1203   // context, because the template parameter list might be dependent.
1204   if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
1205       CheckTemplateParameterList(
1206           TemplateParams,
1207           PrevClassTemplate ? PrevClassTemplate->getTemplateParameters()
1208                             : nullptr,
1209           (SS.isSet() && SemanticContext && SemanticContext->isRecord() &&
1210            SemanticContext->isDependentContext())
1211               ? TPC_ClassTemplateMember
1212               : TUK == TUK_Friend ? TPC_FriendClassTemplate
1213                                   : TPC_ClassTemplate))
1214     Invalid = true;
1215
1216   if (SS.isSet()) {
1217     // If the name of the template was qualified, we must be defining the
1218     // template out-of-line.
1219     if (!SS.isInvalid() && !Invalid && !PrevClassTemplate) {
1220       Diag(NameLoc, TUK == TUK_Friend ? diag::err_friend_decl_does_not_match
1221                                       : diag::err_member_decl_does_not_match)
1222         << Name << SemanticContext << /*IsDefinition*/true << SS.getRange();
1223       Invalid = true;
1224     }
1225   }
1226
1227   CXXRecordDecl *NewClass =
1228     CXXRecordDecl::Create(Context, Kind, SemanticContext, KWLoc, NameLoc, Name,
1229                           PrevClassTemplate?
1230                             PrevClassTemplate->getTemplatedDecl() : nullptr,
1231                           /*DelayTypeCreation=*/true);
1232   SetNestedNameSpecifier(NewClass, SS);
1233   if (NumOuterTemplateParamLists > 0)
1234     NewClass->setTemplateParameterListsInfo(
1235         Context, llvm::makeArrayRef(OuterTemplateParamLists,
1236                                     NumOuterTemplateParamLists));
1237
1238   // Add alignment attributes if necessary; these attributes are checked when
1239   // the ASTContext lays out the structure.
1240   if (TUK == TUK_Definition) {
1241     AddAlignmentAttributesForRecord(NewClass);
1242     AddMsStructLayoutForRecord(NewClass);
1243   }
1244
1245   ClassTemplateDecl *NewTemplate
1246     = ClassTemplateDecl::Create(Context, SemanticContext, NameLoc,
1247                                 DeclarationName(Name), TemplateParams,
1248                                 NewClass, PrevClassTemplate);
1249   NewClass->setDescribedClassTemplate(NewTemplate);
1250
1251   if (ModulePrivateLoc.isValid())
1252     NewTemplate->setModulePrivate();
1253
1254   // Build the type for the class template declaration now.
1255   QualType T = NewTemplate->getInjectedClassNameSpecialization();
1256   T = Context.getInjectedClassNameType(NewClass, T);
1257   assert(T->isDependentType() && "Class template type is not dependent?");
1258   (void)T;
1259
1260   // If we are providing an explicit specialization of a member that is a
1261   // class template, make a note of that.
1262   if (PrevClassTemplate &&
1263       PrevClassTemplate->getInstantiatedFromMemberTemplate())
1264     PrevClassTemplate->setMemberSpecialization();
1265
1266   // Set the access specifier.
1267   if (!Invalid && TUK != TUK_Friend && NewTemplate->getDeclContext()->isRecord())
1268     SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS);
1269
1270   // Set the lexical context of these templates
1271   NewClass->setLexicalDeclContext(CurContext);
1272   NewTemplate->setLexicalDeclContext(CurContext);
1273
1274   if (TUK == TUK_Definition)
1275     NewClass->startDefinition();
1276
1277   if (Attr)
1278     ProcessDeclAttributeList(S, NewClass, Attr);
1279
1280   if (PrevClassTemplate)
1281     mergeDeclAttributes(NewClass, PrevClassTemplate->getTemplatedDecl());
1282
1283   AddPushedVisibilityAttribute(NewClass);
1284
1285   if (TUK != TUK_Friend) {
1286     // Per C++ [basic.scope.temp]p2, skip the template parameter scopes.
1287     Scope *Outer = S;
1288     while ((Outer->getFlags() & Scope::TemplateParamScope) != 0)
1289       Outer = Outer->getParent();
1290     PushOnScopeChains(NewTemplate, Outer);
1291   } else {
1292     if (PrevClassTemplate && PrevClassTemplate->getAccess() != AS_none) {
1293       NewTemplate->setAccess(PrevClassTemplate->getAccess());
1294       NewClass->setAccess(PrevClassTemplate->getAccess());
1295     }
1296
1297     NewTemplate->setObjectOfFriendDecl();
1298
1299     // Friend templates are visible in fairly strange ways.
1300     if (!CurContext->isDependentContext()) {
1301       DeclContext *DC = SemanticContext->getRedeclContext();
1302       DC->makeDeclVisibleInContext(NewTemplate);
1303       if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
1304         PushOnScopeChains(NewTemplate, EnclosingScope,
1305                           /* AddToContext = */ false);
1306     }
1307
1308     FriendDecl *Friend = FriendDecl::Create(
1309         Context, CurContext, NewClass->getLocation(), NewTemplate, FriendLoc);
1310     Friend->setAccess(AS_public);
1311     CurContext->addDecl(Friend);
1312   }
1313
1314   if (Invalid) {
1315     NewTemplate->setInvalidDecl();
1316     NewClass->setInvalidDecl();
1317   }
1318
1319   ActOnDocumentableDecl(NewTemplate);
1320
1321   return NewTemplate;
1322 }
1323
1324 /// \brief Diagnose the presence of a default template argument on a
1325 /// template parameter, which is ill-formed in certain contexts.
1326 ///
1327 /// \returns true if the default template argument should be dropped.
1328 static bool DiagnoseDefaultTemplateArgument(Sema &S,
1329                                             Sema::TemplateParamListContext TPC,
1330                                             SourceLocation ParamLoc,
1331                                             SourceRange DefArgRange) {
1332   switch (TPC) {
1333   case Sema::TPC_ClassTemplate:
1334   case Sema::TPC_VarTemplate:
1335   case Sema::TPC_TypeAliasTemplate:
1336     return false;
1337
1338   case Sema::TPC_FunctionTemplate:
1339   case Sema::TPC_FriendFunctionTemplateDefinition:
1340     // C++ [temp.param]p9:
1341     //   A default template-argument shall not be specified in a
1342     //   function template declaration or a function template
1343     //   definition [...]
1344     //   If a friend function template declaration specifies a default
1345     //   template-argument, that declaration shall be a definition and shall be
1346     //   the only declaration of the function template in the translation unit.
1347     // (C++98/03 doesn't have this wording; see DR226).
1348     S.Diag(ParamLoc, S.getLangOpts().CPlusPlus11 ?
1349          diag::warn_cxx98_compat_template_parameter_default_in_function_template
1350            : diag::ext_template_parameter_default_in_function_template)
1351       << DefArgRange;
1352     return false;
1353
1354   case Sema::TPC_ClassTemplateMember:
1355     // C++0x [temp.param]p9:
1356     //   A default template-argument shall not be specified in the
1357     //   template-parameter-lists of the definition of a member of a
1358     //   class template that appears outside of the member's class.
1359     S.Diag(ParamLoc, diag::err_template_parameter_default_template_member)
1360       << DefArgRange;
1361     return true;
1362
1363   case Sema::TPC_FriendClassTemplate:
1364   case Sema::TPC_FriendFunctionTemplate:
1365     // C++ [temp.param]p9:
1366     //   A default template-argument shall not be specified in a
1367     //   friend template declaration.
1368     S.Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
1369       << DefArgRange;
1370     return true;
1371
1372     // FIXME: C++0x [temp.param]p9 allows default template-arguments
1373     // for friend function templates if there is only a single
1374     // declaration (and it is a definition). Strange!
1375   }
1376
1377   llvm_unreachable("Invalid TemplateParamListContext!");
1378 }
1379
1380 /// \brief Check for unexpanded parameter packs within the template parameters
1381 /// of a template template parameter, recursively.
1382 static bool DiagnoseUnexpandedParameterPacks(Sema &S,
1383                                              TemplateTemplateParmDecl *TTP) {
1384   // A template template parameter which is a parameter pack is also a pack
1385   // expansion.
1386   if (TTP->isParameterPack())
1387     return false;
1388
1389   TemplateParameterList *Params = TTP->getTemplateParameters();
1390   for (unsigned I = 0, N = Params->size(); I != N; ++I) {
1391     NamedDecl *P = Params->getParam(I);
1392     if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
1393       if (!NTTP->isParameterPack() &&
1394           S.DiagnoseUnexpandedParameterPack(NTTP->getLocation(),
1395                                             NTTP->getTypeSourceInfo(),
1396                                       Sema::UPPC_NonTypeTemplateParameterType))
1397         return true;
1398
1399       continue;
1400     }
1401
1402     if (TemplateTemplateParmDecl *InnerTTP
1403                                         = dyn_cast<TemplateTemplateParmDecl>(P))
1404       if (DiagnoseUnexpandedParameterPacks(S, InnerTTP))
1405         return true;
1406   }
1407
1408   return false;
1409 }
1410
1411 /// \brief Checks the validity of a template parameter list, possibly
1412 /// considering the template parameter list from a previous
1413 /// declaration.
1414 ///
1415 /// If an "old" template parameter list is provided, it must be
1416 /// equivalent (per TemplateParameterListsAreEqual) to the "new"
1417 /// template parameter list.
1418 ///
1419 /// \param NewParams Template parameter list for a new template
1420 /// declaration. This template parameter list will be updated with any
1421 /// default arguments that are carried through from the previous
1422 /// template parameter list.
1423 ///
1424 /// \param OldParams If provided, template parameter list from a
1425 /// previous declaration of the same template. Default template
1426 /// arguments will be merged from the old template parameter list to
1427 /// the new template parameter list.
1428 ///
1429 /// \param TPC Describes the context in which we are checking the given
1430 /// template parameter list.
1431 ///
1432 /// \returns true if an error occurred, false otherwise.
1433 bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
1434                                       TemplateParameterList *OldParams,
1435                                       TemplateParamListContext TPC) {
1436   bool Invalid = false;
1437
1438   // C++ [temp.param]p10:
1439   //   The set of default template-arguments available for use with a
1440   //   template declaration or definition is obtained by merging the
1441   //   default arguments from the definition (if in scope) and all
1442   //   declarations in scope in the same way default function
1443   //   arguments are (8.3.6).
1444   bool SawDefaultArgument = false;
1445   SourceLocation PreviousDefaultArgLoc;
1446
1447   // Dummy initialization to avoid warnings.
1448   TemplateParameterList::iterator OldParam = NewParams->end();
1449   if (OldParams)
1450     OldParam = OldParams->begin();
1451
1452   bool RemoveDefaultArguments = false;
1453   for (TemplateParameterList::iterator NewParam = NewParams->begin(),
1454                                     NewParamEnd = NewParams->end();
1455        NewParam != NewParamEnd; ++NewParam) {
1456     // Variables used to diagnose redundant default arguments
1457     bool RedundantDefaultArg = false;
1458     SourceLocation OldDefaultLoc;
1459     SourceLocation NewDefaultLoc;
1460
1461     // Variable used to diagnose missing default arguments
1462     bool MissingDefaultArg = false;
1463
1464     // Variable used to diagnose non-final parameter packs
1465     bool SawParameterPack = false;
1466
1467     if (TemplateTypeParmDecl *NewTypeParm
1468           = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
1469       // Check the presence of a default argument here.
1470       if (NewTypeParm->hasDefaultArgument() &&
1471           DiagnoseDefaultTemplateArgument(*this, TPC,
1472                                           NewTypeParm->getLocation(),
1473                NewTypeParm->getDefaultArgumentInfo()->getTypeLoc()
1474                                                        .getSourceRange()))
1475         NewTypeParm->removeDefaultArgument();
1476
1477       // Merge default arguments for template type parameters.
1478       TemplateTypeParmDecl *OldTypeParm
1479           = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : nullptr;
1480       if (NewTypeParm->isParameterPack()) {
1481         assert(!NewTypeParm->hasDefaultArgument() &&
1482                "Parameter packs can't have a default argument!");
1483         SawParameterPack = true;
1484       } else if (OldTypeParm && hasVisibleDefaultArgument(OldTypeParm) &&
1485                  NewTypeParm->hasDefaultArgument()) {
1486         OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc();
1487         NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
1488         SawDefaultArgument = true;
1489         RedundantDefaultArg = true;
1490         PreviousDefaultArgLoc = NewDefaultLoc;
1491       } else if (OldTypeParm && OldTypeParm->hasDefaultArgument()) {
1492         // Merge the default argument from the old declaration to the
1493         // new declaration.
1494         NewTypeParm->setInheritedDefaultArgument(Context, OldTypeParm);
1495         PreviousDefaultArgLoc = OldTypeParm->getDefaultArgumentLoc();
1496       } else if (NewTypeParm->hasDefaultArgument()) {
1497         SawDefaultArgument = true;
1498         PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
1499       } else if (SawDefaultArgument)
1500         MissingDefaultArg = true;
1501     } else if (NonTypeTemplateParmDecl *NewNonTypeParm
1502                = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
1503       // Check for unexpanded parameter packs.
1504       if (!NewNonTypeParm->isParameterPack() &&
1505           DiagnoseUnexpandedParameterPack(NewNonTypeParm->getLocation(),
1506                                           NewNonTypeParm->getTypeSourceInfo(),
1507                                           UPPC_NonTypeTemplateParameterType)) {
1508         Invalid = true;
1509         continue;
1510       }
1511
1512       // Check the presence of a default argument here.
1513       if (NewNonTypeParm->hasDefaultArgument() &&
1514           DiagnoseDefaultTemplateArgument(*this, TPC,
1515                                           NewNonTypeParm->getLocation(),
1516                     NewNonTypeParm->getDefaultArgument()->getSourceRange())) {
1517         NewNonTypeParm->removeDefaultArgument();
1518       }
1519
1520       // Merge default arguments for non-type template parameters
1521       NonTypeTemplateParmDecl *OldNonTypeParm
1522         = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : nullptr;
1523       if (NewNonTypeParm->isParameterPack()) {
1524         assert(!NewNonTypeParm->hasDefaultArgument() &&
1525                "Parameter packs can't have a default argument!");
1526         if (!NewNonTypeParm->isPackExpansion())
1527           SawParameterPack = true;
1528       } else if (OldNonTypeParm && hasVisibleDefaultArgument(OldNonTypeParm) &&
1529                  NewNonTypeParm->hasDefaultArgument()) {
1530         OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc();
1531         NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
1532         SawDefaultArgument = true;
1533         RedundantDefaultArg = true;
1534         PreviousDefaultArgLoc = NewDefaultLoc;
1535       } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument()) {
1536         // Merge the default argument from the old declaration to the
1537         // new declaration.
1538         NewNonTypeParm->setInheritedDefaultArgument(Context, OldNonTypeParm);
1539         PreviousDefaultArgLoc = OldNonTypeParm->getDefaultArgumentLoc();
1540       } else if (NewNonTypeParm->hasDefaultArgument()) {
1541         SawDefaultArgument = true;
1542         PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
1543       } else if (SawDefaultArgument)
1544         MissingDefaultArg = true;
1545     } else {
1546       TemplateTemplateParmDecl *NewTemplateParm
1547         = cast<TemplateTemplateParmDecl>(*NewParam);
1548
1549       // Check for unexpanded parameter packs, recursively.
1550       if (::DiagnoseUnexpandedParameterPacks(*this, NewTemplateParm)) {
1551         Invalid = true;
1552         continue;
1553       }
1554
1555       // Check the presence of a default argument here.
1556       if (NewTemplateParm->hasDefaultArgument() &&
1557           DiagnoseDefaultTemplateArgument(*this, TPC,
1558                                           NewTemplateParm->getLocation(),
1559                      NewTemplateParm->getDefaultArgument().getSourceRange()))
1560         NewTemplateParm->removeDefaultArgument();
1561
1562       // Merge default arguments for template template parameters
1563       TemplateTemplateParmDecl *OldTemplateParm
1564         = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : nullptr;
1565       if (NewTemplateParm->isParameterPack()) {
1566         assert(!NewTemplateParm->hasDefaultArgument() &&
1567                "Parameter packs can't have a default argument!");
1568         if (!NewTemplateParm->isPackExpansion())
1569           SawParameterPack = true;
1570       } else if (OldTemplateParm &&
1571                  hasVisibleDefaultArgument(OldTemplateParm) &&
1572                  NewTemplateParm->hasDefaultArgument()) {
1573         OldDefaultLoc = OldTemplateParm->getDefaultArgument().getLocation();
1574         NewDefaultLoc = NewTemplateParm->getDefaultArgument().getLocation();
1575         SawDefaultArgument = true;
1576         RedundantDefaultArg = true;
1577         PreviousDefaultArgLoc = NewDefaultLoc;
1578       } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) {
1579         // Merge the default argument from the old declaration to the
1580         // new declaration.
1581         NewTemplateParm->setInheritedDefaultArgument(Context, OldTemplateParm);
1582         PreviousDefaultArgLoc
1583           = OldTemplateParm->getDefaultArgument().getLocation();
1584       } else if (NewTemplateParm->hasDefaultArgument()) {
1585         SawDefaultArgument = true;
1586         PreviousDefaultArgLoc
1587           = NewTemplateParm->getDefaultArgument().getLocation();
1588       } else if (SawDefaultArgument)
1589         MissingDefaultArg = true;
1590     }
1591
1592     // C++11 [temp.param]p11:
1593     //   If a template parameter of a primary class template or alias template
1594     //   is a template parameter pack, it shall be the last template parameter.
1595     if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
1596         (TPC == TPC_ClassTemplate || TPC == TPC_VarTemplate ||
1597          TPC == TPC_TypeAliasTemplate)) {
1598       Diag((*NewParam)->getLocation(),
1599            diag::err_template_param_pack_must_be_last_template_parameter);
1600       Invalid = true;
1601     }
1602
1603     if (RedundantDefaultArg) {
1604       // C++ [temp.param]p12:
1605       //   A template-parameter shall not be given default arguments
1606       //   by two different declarations in the same scope.
1607       Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
1608       Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
1609       Invalid = true;
1610     } else if (MissingDefaultArg && TPC != TPC_FunctionTemplate) {
1611       // C++ [temp.param]p11:
1612       //   If a template-parameter of a class template has a default
1613       //   template-argument, each subsequent template-parameter shall either
1614       //   have a default template-argument supplied or be a template parameter
1615       //   pack.
1616       Diag((*NewParam)->getLocation(),
1617            diag::err_template_param_default_arg_missing);
1618       Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
1619       Invalid = true;
1620       RemoveDefaultArguments = true;
1621     }
1622
1623     // If we have an old template parameter list that we're merging
1624     // in, move on to the next parameter.
1625     if (OldParams)
1626       ++OldParam;
1627   }
1628
1629   // We were missing some default arguments at the end of the list, so remove
1630   // all of the default arguments.
1631   if (RemoveDefaultArguments) {
1632     for (TemplateParameterList::iterator NewParam = NewParams->begin(),
1633                                       NewParamEnd = NewParams->end();
1634          NewParam != NewParamEnd; ++NewParam) {
1635       if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*NewParam))
1636         TTP->removeDefaultArgument();
1637       else if (NonTypeTemplateParmDecl *NTTP
1638                                 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
1639         NTTP->removeDefaultArgument();
1640       else
1641         cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();
1642     }
1643   }
1644
1645   return Invalid;
1646 }
1647
1648 namespace {
1649
1650 /// A class which looks for a use of a certain level of template
1651 /// parameter.
1652 struct DependencyChecker : RecursiveASTVisitor<DependencyChecker> {
1653   typedef RecursiveASTVisitor<DependencyChecker> super;
1654
1655   unsigned Depth;
1656
1657   // Whether we're looking for a use of a template parameter that makes the
1658   // overall construct type-dependent / a dependent type. This is strictly
1659   // best-effort for now; we may fail to match at all for a dependent type
1660   // in some cases if this is set.
1661   bool IgnoreNonTypeDependent;
1662
1663   bool Match;
1664   SourceLocation MatchLoc;
1665
1666   DependencyChecker(unsigned Depth, bool IgnoreNonTypeDependent)
1667       : Depth(Depth), IgnoreNonTypeDependent(IgnoreNonTypeDependent),
1668         Match(false) {}
1669
1670   DependencyChecker(TemplateParameterList *Params, bool IgnoreNonTypeDependent)
1671       : IgnoreNonTypeDependent(IgnoreNonTypeDependent), Match(false) {
1672     NamedDecl *ND = Params->getParam(0);
1673     if (TemplateTypeParmDecl *PD = dyn_cast<TemplateTypeParmDecl>(ND)) {
1674       Depth = PD->getDepth();
1675     } else if (NonTypeTemplateParmDecl *PD =
1676                  dyn_cast<NonTypeTemplateParmDecl>(ND)) {
1677       Depth = PD->getDepth();
1678     } else {
1679       Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();
1680     }
1681   }
1682
1683   bool Matches(unsigned ParmDepth, SourceLocation Loc = SourceLocation()) {
1684     if (ParmDepth >= Depth) {
1685       Match = true;
1686       MatchLoc = Loc;
1687       return true;
1688     }
1689     return false;
1690   }
1691
1692   bool TraverseStmt(Stmt *S, DataRecursionQueue *Q = nullptr) {
1693     // Prune out non-type-dependent expressions if requested. This can
1694     // sometimes result in us failing to find a template parameter reference
1695     // (if a value-dependent expression creates a dependent type), but this
1696     // mode is best-effort only.
1697     if (auto *E = dyn_cast_or_null<Expr>(S))
1698       if (IgnoreNonTypeDependent && !E->isTypeDependent())
1699         return true;
1700     return super::TraverseStmt(S, Q);
1701   }
1702
1703   bool TraverseTypeLoc(TypeLoc TL) {
1704     if (IgnoreNonTypeDependent && !TL.isNull() &&
1705         !TL.getType()->isDependentType())
1706       return true;
1707     return super::TraverseTypeLoc(TL);
1708   }
1709
1710   bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
1711     return !Matches(TL.getTypePtr()->getDepth(), TL.getNameLoc());
1712   }
1713
1714   bool VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
1715     // For a best-effort search, keep looking until we find a location.
1716     return IgnoreNonTypeDependent || !Matches(T->getDepth());
1717   }
1718
1719   bool TraverseTemplateName(TemplateName N) {
1720     if (TemplateTemplateParmDecl *PD =
1721           dyn_cast_or_null<TemplateTemplateParmDecl>(N.getAsTemplateDecl()))
1722       if (Matches(PD->getDepth()))
1723         return false;
1724     return super::TraverseTemplateName(N);
1725   }
1726
1727   bool VisitDeclRefExpr(DeclRefExpr *E) {
1728     if (NonTypeTemplateParmDecl *PD =
1729           dyn_cast<NonTypeTemplateParmDecl>(E->getDecl()))
1730       if (Matches(PD->getDepth(), E->getExprLoc()))
1731         return false;
1732     return super::VisitDeclRefExpr(E);
1733   }
1734
1735   bool VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
1736     return TraverseType(T->getReplacementType());
1737   }
1738
1739   bool
1740   VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {
1741     return TraverseTemplateArgument(T->getArgumentPack());
1742   }
1743
1744   bool TraverseInjectedClassNameType(const InjectedClassNameType *T) {
1745     return TraverseType(T->getInjectedSpecializationType());
1746   }
1747 };
1748 } // end anonymous namespace
1749
1750 /// Determines whether a given type depends on the given parameter
1751 /// list.
1752 static bool
1753 DependsOnTemplateParameters(QualType T, TemplateParameterList *Params) {
1754   DependencyChecker Checker(Params, /*IgnoreNonTypeDependent*/false);
1755   Checker.TraverseType(T);
1756   return Checker.Match;
1757 }
1758
1759 // Find the source range corresponding to the named type in the given
1760 // nested-name-specifier, if any.
1761 static SourceRange getRangeOfTypeInNestedNameSpecifier(ASTContext &Context,
1762                                                        QualType T,
1763                                                        const CXXScopeSpec &SS) {
1764   NestedNameSpecifierLoc NNSLoc(SS.getScopeRep(), SS.location_data());
1765   while (NestedNameSpecifier *NNS = NNSLoc.getNestedNameSpecifier()) {
1766     if (const Type *CurType = NNS->getAsType()) {
1767       if (Context.hasSameUnqualifiedType(T, QualType(CurType, 0)))
1768         return NNSLoc.getTypeLoc().getSourceRange();
1769     } else
1770       break;
1771
1772     NNSLoc = NNSLoc.getPrefix();
1773   }
1774
1775   return SourceRange();
1776 }
1777
1778 /// \brief Match the given template parameter lists to the given scope
1779 /// specifier, returning the template parameter list that applies to the
1780 /// name.
1781 ///
1782 /// \param DeclStartLoc the start of the declaration that has a scope
1783 /// specifier or a template parameter list.
1784 ///
1785 /// \param DeclLoc The location of the declaration itself.
1786 ///
1787 /// \param SS the scope specifier that will be matched to the given template
1788 /// parameter lists. This scope specifier precedes a qualified name that is
1789 /// being declared.
1790 ///
1791 /// \param TemplateId The template-id following the scope specifier, if there
1792 /// is one. Used to check for a missing 'template<>'.
1793 ///
1794 /// \param ParamLists the template parameter lists, from the outermost to the
1795 /// innermost template parameter lists.
1796 ///
1797 /// \param IsFriend Whether to apply the slightly different rules for
1798 /// matching template parameters to scope specifiers in friend
1799 /// declarations.
1800 ///
1801 /// \param IsExplicitSpecialization will be set true if the entity being
1802 /// declared is an explicit specialization, false otherwise.
1803 ///
1804 /// \returns the template parameter list, if any, that corresponds to the
1805 /// name that is preceded by the scope specifier @p SS. This template
1806 /// parameter list may have template parameters (if we're declaring a
1807 /// template) or may have no template parameters (if we're declaring a
1808 /// template specialization), or may be NULL (if what we're declaring isn't
1809 /// itself a template).
1810 TemplateParameterList *Sema::MatchTemplateParametersToScopeSpecifier(
1811     SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS,
1812     TemplateIdAnnotation *TemplateId,
1813     ArrayRef<TemplateParameterList *> ParamLists, bool IsFriend,
1814     bool &IsExplicitSpecialization, bool &Invalid) {
1815   IsExplicitSpecialization = false;
1816   Invalid = false;
1817
1818   // The sequence of nested types to which we will match up the template
1819   // parameter lists. We first build this list by starting with the type named
1820   // by the nested-name-specifier and walking out until we run out of types.
1821   SmallVector<QualType, 4> NestedTypes;
1822   QualType T;
1823   if (SS.getScopeRep()) {
1824     if (CXXRecordDecl *Record
1825               = dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, true)))
1826       T = Context.getTypeDeclType(Record);
1827     else
1828       T = QualType(SS.getScopeRep()->getAsType(), 0);
1829   }
1830
1831   // If we found an explicit specialization that prevents us from needing
1832   // 'template<>' headers, this will be set to the location of that
1833   // explicit specialization.
1834   SourceLocation ExplicitSpecLoc;
1835
1836   while (!T.isNull()) {
1837     NestedTypes.push_back(T);
1838
1839     // Retrieve the parent of a record type.
1840     if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
1841       // If this type is an explicit specialization, we're done.
1842       if (ClassTemplateSpecializationDecl *Spec
1843           = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
1844         if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
1845             Spec->getSpecializationKind() == TSK_ExplicitSpecialization) {
1846           ExplicitSpecLoc = Spec->getLocation();
1847           break;
1848         }
1849       } else if (Record->getTemplateSpecializationKind()
1850                                                 == TSK_ExplicitSpecialization) {
1851         ExplicitSpecLoc = Record->getLocation();
1852         break;
1853       }
1854
1855       if (TypeDecl *Parent = dyn_cast<TypeDecl>(Record->getParent()))
1856         T = Context.getTypeDeclType(Parent);
1857       else
1858         T = QualType();
1859       continue;
1860     }
1861
1862     if (const TemplateSpecializationType *TST
1863                                      = T->getAs<TemplateSpecializationType>()) {
1864       if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
1865         if (TypeDecl *Parent = dyn_cast<TypeDecl>(Template->getDeclContext()))
1866           T = Context.getTypeDeclType(Parent);
1867         else
1868           T = QualType();
1869         continue;
1870       }
1871     }
1872
1873     // Look one step prior in a dependent template specialization type.
1874     if (const DependentTemplateSpecializationType *DependentTST
1875                           = T->getAs<DependentTemplateSpecializationType>()) {
1876       if (NestedNameSpecifier *NNS = DependentTST->getQualifier())
1877         T = QualType(NNS->getAsType(), 0);
1878       else
1879         T = QualType();
1880       continue;
1881     }
1882
1883     // Look one step prior in a dependent name type.
1884     if (const DependentNameType *DependentName = T->getAs<DependentNameType>()){
1885       if (NestedNameSpecifier *NNS = DependentName->getQualifier())
1886         T = QualType(NNS->getAsType(), 0);
1887       else
1888         T = QualType();
1889       continue;
1890     }
1891
1892     // Retrieve the parent of an enumeration type.
1893     if (const EnumType *EnumT = T->getAs<EnumType>()) {
1894       // FIXME: Forward-declared enums require a TSK_ExplicitSpecialization
1895       // check here.
1896       EnumDecl *Enum = EnumT->getDecl();
1897
1898       // Get to the parent type.
1899       if (TypeDecl *Parent = dyn_cast<TypeDecl>(Enum->getParent()))
1900         T = Context.getTypeDeclType(Parent);
1901       else
1902         T = QualType();
1903       continue;
1904     }
1905
1906     T = QualType();
1907   }
1908   // Reverse the nested types list, since we want to traverse from the outermost
1909   // to the innermost while checking template-parameter-lists.
1910   std::reverse(NestedTypes.begin(), NestedTypes.end());
1911
1912   // C++0x [temp.expl.spec]p17:
1913   //   A member or a member template may be nested within many
1914   //   enclosing class templates. In an explicit specialization for
1915   //   such a member, the member declaration shall be preceded by a
1916   //   template<> for each enclosing class template that is
1917   //   explicitly specialized.
1918   bool SawNonEmptyTemplateParameterList = false;
1919
1920   auto CheckExplicitSpecialization = [&](SourceRange Range, bool Recovery) {
1921     if (SawNonEmptyTemplateParameterList) {
1922       Diag(DeclLoc, diag::err_specialize_member_of_template)
1923         << !Recovery << Range;
1924       Invalid = true;
1925       IsExplicitSpecialization = false;
1926       return true;
1927     }
1928
1929     return false;
1930   };
1931
1932   auto DiagnoseMissingExplicitSpecialization = [&] (SourceRange Range) {
1933     // Check that we can have an explicit specialization here.
1934     if (CheckExplicitSpecialization(Range, true))
1935       return true;
1936
1937     // We don't have a template header, but we should.
1938     SourceLocation ExpectedTemplateLoc;
1939     if (!ParamLists.empty())
1940       ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
1941     else
1942       ExpectedTemplateLoc = DeclStartLoc;
1943
1944     Diag(DeclLoc, diag::err_template_spec_needs_header)
1945       << Range
1946       << FixItHint::CreateInsertion(ExpectedTemplateLoc, "template<> ");
1947     return false;
1948   };
1949
1950   unsigned ParamIdx = 0;
1951   for (unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
1952        ++TypeIdx) {
1953     T = NestedTypes[TypeIdx];
1954
1955     // Whether we expect a 'template<>' header.
1956     bool NeedEmptyTemplateHeader = false;
1957
1958     // Whether we expect a template header with parameters.
1959     bool NeedNonemptyTemplateHeader = false;
1960
1961     // For a dependent type, the set of template parameters that we
1962     // expect to see.
1963     TemplateParameterList *ExpectedTemplateParams = nullptr;
1964
1965     // C++0x [temp.expl.spec]p15:
1966     //   A member or a member template may be nested within many enclosing
1967     //   class templates. In an explicit specialization for such a member, the
1968     //   member declaration shall be preceded by a template<> for each
1969     //   enclosing class template that is explicitly specialized.
1970     if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
1971       if (ClassTemplatePartialSpecializationDecl *Partial
1972             = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) {
1973         ExpectedTemplateParams = Partial->getTemplateParameters();
1974         NeedNonemptyTemplateHeader = true;
1975       } else if (Record->isDependentType()) {
1976         if (Record->getDescribedClassTemplate()) {
1977           ExpectedTemplateParams = Record->getDescribedClassTemplate()
1978                                                       ->getTemplateParameters();
1979           NeedNonemptyTemplateHeader = true;
1980         }
1981       } else if (ClassTemplateSpecializationDecl *Spec
1982                      = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
1983         // C++0x [temp.expl.spec]p4:
1984         //   Members of an explicitly specialized class template are defined
1985         //   in the same manner as members of normal classes, and not using
1986         //   the template<> syntax.
1987         if (Spec->getSpecializationKind() != TSK_ExplicitSpecialization)
1988           NeedEmptyTemplateHeader = true;
1989         else
1990           continue;
1991       } else if (Record->getTemplateSpecializationKind()) {
1992         if (Record->getTemplateSpecializationKind()
1993                                                 != TSK_ExplicitSpecialization &&
1994             TypeIdx == NumTypes - 1)
1995           IsExplicitSpecialization = true;
1996
1997         continue;
1998       }
1999     } else if (const TemplateSpecializationType *TST
2000                                      = T->getAs<TemplateSpecializationType>()) {
2001       if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
2002         ExpectedTemplateParams = Template->getTemplateParameters();
2003         NeedNonemptyTemplateHeader = true;
2004       }
2005     } else if (T->getAs<DependentTemplateSpecializationType>()) {
2006       // FIXME:  We actually could/should check the template arguments here
2007       // against the corresponding template parameter list.
2008       NeedNonemptyTemplateHeader = false;
2009     }
2010
2011     // C++ [temp.expl.spec]p16:
2012     //   In an explicit specialization declaration for a member of a class
2013     //   template or a member template that ap- pears in namespace scope, the
2014     //   member template and some of its enclosing class templates may remain
2015     //   unspecialized, except that the declaration shall not explicitly
2016     //   specialize a class member template if its en- closing class templates
2017     //   are not explicitly specialized as well.
2018     if (ParamIdx < ParamLists.size()) {
2019       if (ParamLists[ParamIdx]->size() == 0) {
2020         if (CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
2021                                         false))
2022           return nullptr;
2023       } else
2024         SawNonEmptyTemplateParameterList = true;
2025     }
2026
2027     if (NeedEmptyTemplateHeader) {
2028       // If we're on the last of the types, and we need a 'template<>' header
2029       // here, then it's an explicit specialization.
2030       if (TypeIdx == NumTypes - 1)
2031         IsExplicitSpecialization = true;
2032
2033       if (ParamIdx < ParamLists.size()) {
2034         if (ParamLists[ParamIdx]->size() > 0) {
2035           // The header has template parameters when it shouldn't. Complain.
2036           Diag(ParamLists[ParamIdx]->getTemplateLoc(),
2037                diag::err_template_param_list_matches_nontemplate)
2038             << T
2039             << SourceRange(ParamLists[ParamIdx]->getLAngleLoc(),
2040                            ParamLists[ParamIdx]->getRAngleLoc())
2041             << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
2042           Invalid = true;
2043           return nullptr;
2044         }
2045
2046         // Consume this template header.
2047         ++ParamIdx;
2048         continue;
2049       }
2050
2051       if (!IsFriend)
2052         if (DiagnoseMissingExplicitSpecialization(
2053                 getRangeOfTypeInNestedNameSpecifier(Context, T, SS)))
2054           return nullptr;
2055
2056       continue;
2057     }
2058
2059     if (NeedNonemptyTemplateHeader) {
2060       // In friend declarations we can have template-ids which don't
2061       // depend on the corresponding template parameter lists.  But
2062       // assume that empty parameter lists are supposed to match this
2063       // template-id.
2064       if (IsFriend && T->isDependentType()) {
2065         if (ParamIdx < ParamLists.size() &&
2066             DependsOnTemplateParameters(T, ParamLists[ParamIdx]))
2067           ExpectedTemplateParams = nullptr;
2068         else
2069           continue;
2070       }
2071
2072       if (ParamIdx < ParamLists.size()) {
2073         // Check the template parameter list, if we can.
2074         if (ExpectedTemplateParams &&
2075             !TemplateParameterListsAreEqual(ParamLists[ParamIdx],
2076                                             ExpectedTemplateParams,
2077                                             true, TPL_TemplateMatch))
2078           Invalid = true;
2079
2080         if (!Invalid &&
2081             CheckTemplateParameterList(ParamLists[ParamIdx], nullptr,
2082                                        TPC_ClassTemplateMember))
2083           Invalid = true;
2084
2085         ++ParamIdx;
2086         continue;
2087       }
2088
2089       Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
2090         << T
2091         << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
2092       Invalid = true;
2093       continue;
2094     }
2095   }
2096
2097   // If there were at least as many template-ids as there were template
2098   // parameter lists, then there are no template parameter lists remaining for
2099   // the declaration itself.
2100   if (ParamIdx >= ParamLists.size()) {
2101     if (TemplateId && !IsFriend) {
2102       // We don't have a template header for the declaration itself, but we
2103       // should.
2104       IsExplicitSpecialization = true;
2105       DiagnoseMissingExplicitSpecialization(SourceRange(TemplateId->LAngleLoc,
2106                                                         TemplateId->RAngleLoc));
2107
2108       // Fabricate an empty template parameter list for the invented header.
2109       return TemplateParameterList::Create(Context, SourceLocation(),
2110                                            SourceLocation(), None,
2111                                            SourceLocation(), nullptr);
2112     }
2113
2114     return nullptr;
2115   }
2116
2117   // If there were too many template parameter lists, complain about that now.
2118   if (ParamIdx < ParamLists.size() - 1) {
2119     bool HasAnyExplicitSpecHeader = false;
2120     bool AllExplicitSpecHeaders = true;
2121     for (unsigned I = ParamIdx, E = ParamLists.size() - 1; I != E; ++I) {
2122       if (ParamLists[I]->size() == 0)
2123         HasAnyExplicitSpecHeader = true;
2124       else
2125         AllExplicitSpecHeaders = false;
2126     }
2127
2128     Diag(ParamLists[ParamIdx]->getTemplateLoc(),
2129          AllExplicitSpecHeaders ? diag::warn_template_spec_extra_headers
2130                                 : diag::err_template_spec_extra_headers)
2131         << SourceRange(ParamLists[ParamIdx]->getTemplateLoc(),
2132                        ParamLists[ParamLists.size() - 2]->getRAngleLoc());
2133
2134     // If there was a specialization somewhere, such that 'template<>' is
2135     // not required, and there were any 'template<>' headers, note where the
2136     // specialization occurred.
2137     if (ExplicitSpecLoc.isValid() && HasAnyExplicitSpecHeader)
2138       Diag(ExplicitSpecLoc,
2139            diag::note_explicit_template_spec_does_not_need_header)
2140         << NestedTypes.back();
2141
2142     // We have a template parameter list with no corresponding scope, which
2143     // means that the resulting template declaration can't be instantiated
2144     // properly (we'll end up with dependent nodes when we shouldn't).
2145     if (!AllExplicitSpecHeaders)
2146       Invalid = true;
2147   }
2148
2149   // C++ [temp.expl.spec]p16:
2150   //   In an explicit specialization declaration for a member of a class
2151   //   template or a member template that ap- pears in namespace scope, the
2152   //   member template and some of its enclosing class templates may remain
2153   //   unspecialized, except that the declaration shall not explicitly
2154   //   specialize a class member template if its en- closing class templates
2155   //   are not explicitly specialized as well.
2156   if (ParamLists.back()->size() == 0 &&
2157       CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
2158                                   false))
2159     return nullptr;
2160
2161   // Return the last template parameter list, which corresponds to the
2162   // entity being declared.
2163   return ParamLists.back();
2164 }
2165
2166 void Sema::NoteAllFoundTemplates(TemplateName Name) {
2167   if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
2168     Diag(Template->getLocation(), diag::note_template_declared_here)
2169         << (isa<FunctionTemplateDecl>(Template)
2170                 ? 0
2171                 : isa<ClassTemplateDecl>(Template)
2172                       ? 1
2173                       : isa<VarTemplateDecl>(Template)
2174                             ? 2
2175                             : isa<TypeAliasTemplateDecl>(Template) ? 3 : 4)
2176         << Template->getDeclName();
2177     return;
2178   }
2179
2180   if (OverloadedTemplateStorage *OST = Name.getAsOverloadedTemplate()) {
2181     for (OverloadedTemplateStorage::iterator I = OST->begin(),
2182                                           IEnd = OST->end();
2183          I != IEnd; ++I)
2184       Diag((*I)->getLocation(), diag::note_template_declared_here)
2185         << 0 << (*I)->getDeclName();
2186
2187     return;
2188   }
2189 }
2190
2191 static QualType
2192 checkBuiltinTemplateIdType(Sema &SemaRef, BuiltinTemplateDecl *BTD,
2193                            const SmallVectorImpl<TemplateArgument> &Converted,
2194                            SourceLocation TemplateLoc,
2195                            TemplateArgumentListInfo &TemplateArgs) {
2196   ASTContext &Context = SemaRef.getASTContext();
2197   switch (BTD->getBuiltinTemplateKind()) {
2198   case BTK__make_integer_seq: {
2199     // Specializations of __make_integer_seq<S, T, N> are treated like
2200     // S<T, 0, ..., N-1>.
2201
2202     // C++14 [inteseq.intseq]p1:
2203     //   T shall be an integer type.
2204     if (!Converted[1].getAsType()->isIntegralType(Context)) {
2205       SemaRef.Diag(TemplateArgs[1].getLocation(),
2206                    diag::err_integer_sequence_integral_element_type);
2207       return QualType();
2208     }
2209
2210     // C++14 [inteseq.make]p1:
2211     //   If N is negative the program is ill-formed.
2212     TemplateArgument NumArgsArg = Converted[2];
2213     llvm::APSInt NumArgs = NumArgsArg.getAsIntegral();
2214     if (NumArgs < 0) {
2215       SemaRef.Diag(TemplateArgs[2].getLocation(),
2216                    diag::err_integer_sequence_negative_length);
2217       return QualType();
2218     }
2219
2220     QualType ArgTy = NumArgsArg.getIntegralType();
2221     TemplateArgumentListInfo SyntheticTemplateArgs;
2222     // The type argument gets reused as the first template argument in the
2223     // synthetic template argument list.
2224     SyntheticTemplateArgs.addArgument(TemplateArgs[1]);
2225     // Expand N into 0 ... N-1.
2226     for (llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
2227          I < NumArgs; ++I) {
2228       TemplateArgument TA(Context, I, ArgTy);
2229       SyntheticTemplateArgs.addArgument(SemaRef.getTrivialTemplateArgumentLoc(
2230           TA, ArgTy, TemplateArgs[2].getLocation()));
2231     }
2232     // The first template argument will be reused as the template decl that
2233     // our synthetic template arguments will be applied to.
2234     return SemaRef.CheckTemplateIdType(Converted[0].getAsTemplate(),
2235                                        TemplateLoc, SyntheticTemplateArgs);
2236   }
2237
2238   case BTK__type_pack_element:
2239     // Specializations of
2240     //    __type_pack_element<Index, T_1, ..., T_N>
2241     // are treated like T_Index.
2242     assert(Converted.size() == 2 &&
2243       "__type_pack_element should be given an index and a parameter pack");
2244
2245     // If the Index is out of bounds, the program is ill-formed.
2246     TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
2247     llvm::APSInt Index = IndexArg.getAsIntegral();
2248     assert(Index >= 0 && "the index used with __type_pack_element should be of "
2249                          "type std::size_t, and hence be non-negative");
2250     if (Index >= Ts.pack_size()) {
2251       SemaRef.Diag(TemplateArgs[0].getLocation(),
2252                    diag::err_type_pack_element_out_of_bounds);
2253       return QualType();
2254     }
2255
2256     // We simply return the type at index `Index`.
2257     auto Nth = std::next(Ts.pack_begin(), Index.getExtValue());
2258     return Nth->getAsType();
2259   }
2260   llvm_unreachable("unexpected BuiltinTemplateDecl!");
2261 }
2262
2263 QualType Sema::CheckTemplateIdType(TemplateName Name,
2264                                    SourceLocation TemplateLoc,
2265                                    TemplateArgumentListInfo &TemplateArgs) {
2266   DependentTemplateName *DTN
2267     = Name.getUnderlying().getAsDependentTemplateName();
2268   if (DTN && DTN->isIdentifier())
2269     // When building a template-id where the template-name is dependent,
2270     // assume the template is a type template. Either our assumption is
2271     // correct, or the code is ill-formed and will be diagnosed when the
2272     // dependent name is substituted.
2273     return Context.getDependentTemplateSpecializationType(ETK_None,
2274                                                           DTN->getQualifier(),
2275                                                           DTN->getIdentifier(),
2276                                                           TemplateArgs);
2277
2278   TemplateDecl *Template = Name.getAsTemplateDecl();
2279   if (!Template || isa<FunctionTemplateDecl>(Template) ||
2280       isa<VarTemplateDecl>(Template)) {
2281     // We might have a substituted template template parameter pack. If so,
2282     // build a template specialization type for it.
2283     if (Name.getAsSubstTemplateTemplateParmPack())
2284       return Context.getTemplateSpecializationType(Name, TemplateArgs);
2285
2286     Diag(TemplateLoc, diag::err_template_id_not_a_type)
2287       << Name;
2288     NoteAllFoundTemplates(Name);
2289     return QualType();
2290   }
2291
2292   // Check that the template argument list is well-formed for this
2293   // template.
2294   SmallVector<TemplateArgument, 4> Converted;
2295   if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs,
2296                                 false, Converted))
2297     return QualType();
2298
2299   QualType CanonType;
2300
2301   bool InstantiationDependent = false;
2302   if (TypeAliasTemplateDecl *AliasTemplate =
2303           dyn_cast<TypeAliasTemplateDecl>(Template)) {
2304     // Find the canonical type for this type alias template specialization.
2305     TypeAliasDecl *Pattern = AliasTemplate->getTemplatedDecl();
2306     if (Pattern->isInvalidDecl())
2307       return QualType();
2308
2309     TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
2310                                       Converted);
2311
2312     // Only substitute for the innermost template argument list.
2313     MultiLevelTemplateArgumentList TemplateArgLists;
2314     TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
2315     unsigned Depth = AliasTemplate->getTemplateParameters()->getDepth();
2316     for (unsigned I = 0; I < Depth; ++I)
2317       TemplateArgLists.addOuterTemplateArguments(None);
2318
2319     LocalInstantiationScope Scope(*this);
2320     InstantiatingTemplate Inst(*this, TemplateLoc, Template);
2321     if (Inst.isInvalid())
2322       return QualType();
2323
2324     CanonType = SubstType(Pattern->getUnderlyingType(),
2325                           TemplateArgLists, AliasTemplate->getLocation(),
2326                           AliasTemplate->getDeclName());
2327     if (CanonType.isNull())
2328       return QualType();
2329   } else if (Name.isDependent() ||
2330              TemplateSpecializationType::anyDependentTemplateArguments(
2331                TemplateArgs, InstantiationDependent)) {
2332     // This class template specialization is a dependent
2333     // type. Therefore, its canonical type is another class template
2334     // specialization type that contains all of the converted
2335     // arguments in canonical form. This ensures that, e.g., A<T> and
2336     // A<T, T> have identical types when A is declared as:
2337     //
2338     //   template<typename T, typename U = T> struct A;
2339     TemplateName CanonName = Context.getCanonicalTemplateName(Name);
2340     CanonType = Context.getTemplateSpecializationType(CanonName,
2341                                                       Converted);
2342
2343     // FIXME: CanonType is not actually the canonical type, and unfortunately
2344     // it is a TemplateSpecializationType that we will never use again.
2345     // In the future, we need to teach getTemplateSpecializationType to only
2346     // build the canonical type and return that to us.
2347     CanonType = Context.getCanonicalType(CanonType);
2348
2349     // This might work out to be a current instantiation, in which
2350     // case the canonical type needs to be the InjectedClassNameType.
2351     //
2352     // TODO: in theory this could be a simple hashtable lookup; most
2353     // changes to CurContext don't change the set of current
2354     // instantiations.
2355     if (isa<ClassTemplateDecl>(Template)) {
2356       for (DeclContext *Ctx = CurContext; Ctx; Ctx = Ctx->getLookupParent()) {
2357         // If we get out to a namespace, we're done.
2358         if (Ctx->isFileContext()) break;
2359
2360         // If this isn't a record, keep looking.
2361         CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx);
2362         if (!Record) continue;
2363
2364         // Look for one of the two cases with InjectedClassNameTypes
2365         // and check whether it's the same template.
2366         if (!isa<ClassTemplatePartialSpecializationDecl>(Record) &&
2367             !Record->getDescribedClassTemplate())
2368           continue;
2369
2370         // Fetch the injected class name type and check whether its
2371         // injected type is equal to the type we just built.
2372         QualType ICNT = Context.getTypeDeclType(Record);
2373         QualType Injected = cast<InjectedClassNameType>(ICNT)
2374           ->getInjectedSpecializationType();
2375
2376         if (CanonType != Injected->getCanonicalTypeInternal())
2377           continue;
2378
2379         // If so, the canonical type of this TST is the injected
2380         // class name type of the record we just found.
2381         assert(ICNT.isCanonical());
2382         CanonType = ICNT;
2383         break;
2384       }
2385     }
2386   } else if (ClassTemplateDecl *ClassTemplate
2387                = dyn_cast<ClassTemplateDecl>(Template)) {
2388     // Find the class template specialization declaration that
2389     // corresponds to these arguments.
2390     void *InsertPos = nullptr;
2391     ClassTemplateSpecializationDecl *Decl
2392       = ClassTemplate->findSpecialization(Converted, InsertPos);
2393     if (!Decl) {
2394       // This is the first time we have referenced this class template
2395       // specialization. Create the canonical declaration and add it to
2396       // the set of specializations.
2397       Decl = ClassTemplateSpecializationDecl::Create(Context,
2398                             ClassTemplate->getTemplatedDecl()->getTagKind(),
2399                                                 ClassTemplate->getDeclContext(),
2400                             ClassTemplate->getTemplatedDecl()->getLocStart(),
2401                                                 ClassTemplate->getLocation(),
2402                                                      ClassTemplate,
2403                                                      Converted, nullptr);
2404       ClassTemplate->AddSpecialization(Decl, InsertPos);
2405       if (ClassTemplate->isOutOfLine())
2406         Decl->setLexicalDeclContext(ClassTemplate->getLexicalDeclContext());
2407     }
2408
2409     // Diagnose uses of this specialization.
2410     (void)DiagnoseUseOfDecl(Decl, TemplateLoc);
2411
2412     CanonType = Context.getTypeDeclType(Decl);
2413     assert(isa<RecordType>(CanonType) &&
2414            "type of non-dependent specialization is not a RecordType");
2415   } else if (auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
2416     CanonType = checkBuiltinTemplateIdType(*this, BTD, Converted, TemplateLoc,
2417                                            TemplateArgs);
2418   }
2419
2420   // Build the fully-sugared type for this class template
2421   // specialization, which refers back to the class template
2422   // specialization we created or found.
2423   return Context.getTemplateSpecializationType(Name, TemplateArgs, CanonType);
2424 }
2425
2426 TypeResult
2427 Sema::ActOnTemplateIdType(CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
2428                           TemplateTy TemplateD, SourceLocation TemplateLoc,
2429                           SourceLocation LAngleLoc,
2430                           ASTTemplateArgsPtr TemplateArgsIn,
2431                           SourceLocation RAngleLoc,
2432                           bool IsCtorOrDtorName) {
2433   if (SS.isInvalid())
2434     return true;
2435
2436   TemplateName Template = TemplateD.get();
2437
2438   // Translate the parser's template argument list in our AST format.
2439   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
2440   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
2441
2442   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
2443     QualType T
2444       = Context.getDependentTemplateSpecializationType(ETK_None,
2445                                                        DTN->getQualifier(),
2446                                                        DTN->getIdentifier(),
2447                                                        TemplateArgs);
2448     // Build type-source information.
2449     TypeLocBuilder TLB;
2450     DependentTemplateSpecializationTypeLoc SpecTL
2451       = TLB.push<DependentTemplateSpecializationTypeLoc>(T);
2452     SpecTL.setElaboratedKeywordLoc(SourceLocation());
2453     SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
2454     SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
2455     SpecTL.setTemplateNameLoc(TemplateLoc);
2456     SpecTL.setLAngleLoc(LAngleLoc);
2457     SpecTL.setRAngleLoc(RAngleLoc);
2458     for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
2459       SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
2460     return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
2461   }
2462
2463   QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
2464
2465   if (Result.isNull())
2466     return true;
2467
2468   // Build type-source information.
2469   TypeLocBuilder TLB;
2470   TemplateSpecializationTypeLoc SpecTL
2471     = TLB.push<TemplateSpecializationTypeLoc>(Result);
2472   SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
2473   SpecTL.setTemplateNameLoc(TemplateLoc);
2474   SpecTL.setLAngleLoc(LAngleLoc);
2475   SpecTL.setRAngleLoc(RAngleLoc);
2476   for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
2477     SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
2478
2479   // NOTE: avoid constructing an ElaboratedTypeLoc if this is a
2480   // constructor or destructor name (in such a case, the scope specifier
2481   // will be attached to the enclosing Decl or Expr node).
2482   if (SS.isNotEmpty() && !IsCtorOrDtorName) {
2483     // Create an elaborated-type-specifier containing the nested-name-specifier.
2484     Result = Context.getElaboratedType(ETK_None, SS.getScopeRep(), Result);
2485     ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
2486     ElabTL.setElaboratedKeywordLoc(SourceLocation());
2487     ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
2488   }
2489
2490   return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
2491 }
2492
2493 TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK,
2494                                         TypeSpecifierType TagSpec,
2495                                         SourceLocation TagLoc,
2496                                         CXXScopeSpec &SS,
2497                                         SourceLocation TemplateKWLoc,
2498                                         TemplateTy TemplateD,
2499                                         SourceLocation TemplateLoc,
2500                                         SourceLocation LAngleLoc,
2501                                         ASTTemplateArgsPtr TemplateArgsIn,
2502                                         SourceLocation RAngleLoc) {
2503   TemplateName Template = TemplateD.get();
2504
2505   // Translate the parser's template argument list in our AST format.
2506   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
2507   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
2508
2509   // Determine the tag kind
2510   TagTypeKind TagKind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
2511   ElaboratedTypeKeyword Keyword
2512     = TypeWithKeyword::getKeywordForTagTypeKind(TagKind);
2513
2514   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
2515     QualType T = Context.getDependentTemplateSpecializationType(Keyword,
2516                                                           DTN->getQualifier(),
2517                                                           DTN->getIdentifier(),
2518                                                                 TemplateArgs);
2519
2520     // Build type-source information.
2521     TypeLocBuilder TLB;
2522     DependentTemplateSpecializationTypeLoc SpecTL
2523       = TLB.push<DependentTemplateSpecializationTypeLoc>(T);
2524     SpecTL.setElaboratedKeywordLoc(TagLoc);
2525     SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
2526     SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
2527     SpecTL.setTemplateNameLoc(TemplateLoc);
2528     SpecTL.setLAngleLoc(LAngleLoc);
2529     SpecTL.setRAngleLoc(RAngleLoc);
2530     for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
2531       SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
2532     return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
2533   }
2534
2535   if (TypeAliasTemplateDecl *TAT =
2536         dyn_cast_or_null<TypeAliasTemplateDecl>(Template.getAsTemplateDecl())) {
2537     // C++0x [dcl.type.elab]p2:
2538     //   If the identifier resolves to a typedef-name or the simple-template-id
2539     //   resolves to an alias template specialization, the
2540     //   elaborated-type-specifier is ill-formed.
2541     Diag(TemplateLoc, diag::err_tag_reference_non_tag)
2542         << TAT << NTK_TypeAliasTemplate << TagKind;
2543     Diag(TAT->getLocation(), diag::note_declared_at);
2544   }
2545
2546   QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
2547   if (Result.isNull())
2548     return TypeResult(true);
2549
2550   // Check the tag kind
2551   if (const RecordType *RT = Result->getAs<RecordType>()) {
2552     RecordDecl *D = RT->getDecl();
2553
2554     IdentifierInfo *Id = D->getIdentifier();
2555     assert(Id && "templated class must have an identifier");
2556
2557     if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition,
2558                                       TagLoc, Id)) {
2559       Diag(TagLoc, diag::err_use_with_wrong_tag)
2560         << Result
2561         << FixItHint::CreateReplacement(SourceRange(TagLoc), D->getKindName());
2562       Diag(D->getLocation(), diag::note_previous_use);
2563     }
2564   }
2565
2566   // Provide source-location information for the template specialization.
2567   TypeLocBuilder TLB;
2568   TemplateSpecializationTypeLoc SpecTL
2569     = TLB.push<TemplateSpecializationTypeLoc>(Result);
2570   SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
2571   SpecTL.setTemplateNameLoc(TemplateLoc);
2572   SpecTL.setLAngleLoc(LAngleLoc);
2573   SpecTL.setRAngleLoc(RAngleLoc);
2574   for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
2575     SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
2576
2577   // Construct an elaborated type containing the nested-name-specifier (if any)
2578   // and tag keyword.
2579   Result = Context.getElaboratedType(Keyword, SS.getScopeRep(), Result);
2580   ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
2581   ElabTL.setElaboratedKeywordLoc(TagLoc);
2582   ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
2583   return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
2584 }
2585
2586 static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized,
2587                                              NamedDecl *PrevDecl,
2588                                              SourceLocation Loc,
2589                                              bool IsPartialSpecialization);
2590
2591 static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D);
2592
2593 static bool isTemplateArgumentTemplateParameter(
2594     const TemplateArgument &Arg, unsigned Depth, unsigned Index) {
2595   switch (Arg.getKind()) {
2596   case TemplateArgument::Null:
2597   case TemplateArgument::NullPtr:
2598   case TemplateArgument::Integral:
2599   case TemplateArgument::Declaration:
2600   case TemplateArgument::Pack:
2601   case TemplateArgument::TemplateExpansion:
2602     return false;
2603
2604   case TemplateArgument::Type: {
2605     QualType Type = Arg.getAsType();
2606     const TemplateTypeParmType *TPT =
2607         Arg.getAsType()->getAs<TemplateTypeParmType>();
2608     return TPT && !Type.hasQualifiers() &&
2609            TPT->getDepth() == Depth && TPT->getIndex() == Index;
2610   }
2611
2612   case TemplateArgument::Expression: {
2613     DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg.getAsExpr());
2614     if (!DRE || !DRE->getDecl())
2615       return false;
2616     const NonTypeTemplateParmDecl *NTTP =
2617         dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
2618     return NTTP && NTTP->getDepth() == Depth && NTTP->getIndex() == Index;
2619   }
2620
2621   case TemplateArgument::Template:
2622     const TemplateTemplateParmDecl *TTP =
2623         dyn_cast_or_null<TemplateTemplateParmDecl>(
2624             Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl());
2625     return TTP && TTP->getDepth() == Depth && TTP->getIndex() == Index;
2626   }
2627   llvm_unreachable("unexpected kind of template argument");
2628 }
2629
2630 static bool isSameAsPrimaryTemplate(TemplateParameterList *Params,
2631                                     ArrayRef<TemplateArgument> Args) {
2632   if (Params->size() != Args.size())
2633     return false;
2634
2635   unsigned Depth = Params->getDepth();
2636
2637   for (unsigned I = 0, N = Args.size(); I != N; ++I) {
2638     TemplateArgument Arg = Args[I];
2639
2640     // If the parameter is a pack expansion, the argument must be a pack
2641     // whose only element is a pack expansion.
2642     if (Params->getParam(I)->isParameterPack()) {
2643       if (Arg.getKind() != TemplateArgument::Pack || Arg.pack_size() != 1 ||
2644           !Arg.pack_begin()->isPackExpansion())
2645         return false;
2646       Arg = Arg.pack_begin()->getPackExpansionPattern();
2647     }
2648
2649     if (!isTemplateArgumentTemplateParameter(Arg, Depth, I))
2650       return false;
2651   }
2652
2653   return true;
2654 }
2655
2656 /// Convert the parser's template argument list representation into our form.
2657 static TemplateArgumentListInfo
2658 makeTemplateArgumentListInfo(Sema &S, TemplateIdAnnotation &TemplateId) {
2659   TemplateArgumentListInfo TemplateArgs(TemplateId.LAngleLoc,
2660                                         TemplateId.RAngleLoc);
2661   ASTTemplateArgsPtr TemplateArgsPtr(TemplateId.getTemplateArgs(),
2662                                      TemplateId.NumArgs);
2663   S.translateTemplateArguments(TemplateArgsPtr, TemplateArgs);
2664   return TemplateArgs;
2665 }
2666
2667 template<typename PartialSpecDecl>
2668 static void checkMoreSpecializedThanPrimary(Sema &S, PartialSpecDecl *Partial) {
2669   if (Partial->getDeclContext()->isDependentContext())
2670     return;
2671
2672   // FIXME: Get the TDK from deduction in order to provide better diagnostics
2673   // for non-substitution-failure issues?
2674   TemplateDeductionInfo Info(Partial->getLocation());
2675   if (S.isMoreSpecializedThanPrimary(Partial, Info))
2676     return;
2677
2678   auto *Template = Partial->getSpecializedTemplate();
2679   S.Diag(Partial->getLocation(),
2680          diag::ext_partial_spec_not_more_specialized_than_primary)
2681       << isa<VarTemplateDecl>(Template);
2682
2683   if (Info.hasSFINAEDiagnostic()) {
2684     PartialDiagnosticAt Diag = {SourceLocation(),
2685                                 PartialDiagnostic::NullDiagnostic()};
2686     Info.takeSFINAEDiagnostic(Diag);
2687     SmallString<128> SFINAEArgString;
2688     Diag.second.EmitToString(S.getDiagnostics(), SFINAEArgString);
2689     S.Diag(Diag.first,
2690            diag::note_partial_spec_not_more_specialized_than_primary)
2691       << SFINAEArgString;
2692   }
2693
2694   S.Diag(Template->getLocation(), diag::note_template_decl_here);
2695 }
2696
2697 template<typename PartialSpecDecl>
2698 static void checkTemplatePartialSpecialization(Sema &S,
2699                                                PartialSpecDecl *Partial) {
2700   // C++1z [temp.class.spec]p8: (DR1495)
2701   //   - The specialization shall be more specialized than the primary
2702   //     template (14.5.5.2).
2703   checkMoreSpecializedThanPrimary(S, Partial);
2704
2705   // C++ [temp.class.spec]p8: (DR1315)
2706   //   - Each template-parameter shall appear at least once in the
2707   //     template-id outside a non-deduced context.
2708   // C++1z [temp.class.spec.match]p3 (P0127R2)
2709   //   If the template arguments of a partial specialization cannot be
2710   //   deduced because of the structure of its template-parameter-list
2711   //   and the template-id, the program is ill-formed.
2712   auto *TemplateParams = Partial->getTemplateParameters();
2713   llvm::SmallBitVector DeducibleParams(TemplateParams->size());
2714   S.MarkUsedTemplateParameters(Partial->getTemplateArgs(), true,
2715                                TemplateParams->getDepth(), DeducibleParams);
2716
2717   if (!DeducibleParams.all()) {
2718     unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
2719     S.Diag(Partial->getLocation(), diag::ext_partial_specs_not_deducible)
2720       << isa<VarTemplatePartialSpecializationDecl>(Partial)
2721       << (NumNonDeducible > 1)
2722       << SourceRange(Partial->getLocation(),
2723                      Partial->getTemplateArgsAsWritten()->RAngleLoc);
2724     for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
2725       if (!DeducibleParams[I]) {
2726         NamedDecl *Param = cast<NamedDecl>(TemplateParams->getParam(I));
2727         if (Param->getDeclName())
2728           S.Diag(Param->getLocation(),
2729                  diag::note_partial_spec_unused_parameter)
2730             << Param->getDeclName();
2731         else
2732           S.Diag(Param->getLocation(),
2733                  diag::note_partial_spec_unused_parameter)
2734             << "(anonymous)";
2735       }
2736     }
2737   }
2738 }
2739
2740 void Sema::CheckTemplatePartialSpecialization(
2741     ClassTemplatePartialSpecializationDecl *Partial) {
2742   checkTemplatePartialSpecialization(*this, Partial);
2743 }
2744
2745 void Sema::CheckTemplatePartialSpecialization(
2746     VarTemplatePartialSpecializationDecl *Partial) {
2747   checkTemplatePartialSpecialization(*this, Partial);
2748 }
2749
2750 DeclResult Sema::ActOnVarTemplateSpecialization(
2751     Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc,
2752     TemplateParameterList *TemplateParams, StorageClass SC,
2753     bool IsPartialSpecialization) {
2754   // D must be variable template id.
2755   assert(D.getName().getKind() == UnqualifiedId::IK_TemplateId &&
2756          "Variable template specialization is declared with a template it.");
2757
2758   TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
2759   TemplateArgumentListInfo TemplateArgs =
2760       makeTemplateArgumentListInfo(*this, *TemplateId);
2761   SourceLocation TemplateNameLoc = D.getIdentifierLoc();
2762   SourceLocation LAngleLoc = TemplateId->LAngleLoc;
2763   SourceLocation RAngleLoc = TemplateId->RAngleLoc;
2764
2765   TemplateName Name = TemplateId->Template.get();
2766
2767   // The template-id must name a variable template.
2768   VarTemplateDecl *VarTemplate =
2769       dyn_cast_or_null<VarTemplateDecl>(Name.getAsTemplateDecl());
2770   if (!VarTemplate) {
2771     NamedDecl *FnTemplate;
2772     if (auto *OTS = Name.getAsOverloadedTemplate())
2773       FnTemplate = *OTS->begin();
2774     else
2775       FnTemplate = dyn_cast_or_null<FunctionTemplateDecl>(Name.getAsTemplateDecl());
2776     if (FnTemplate)
2777       return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template_but_method)
2778                << FnTemplate->getDeclName();
2779     return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template)
2780              << IsPartialSpecialization;
2781   }
2782
2783   // Check for unexpanded parameter packs in any of the template arguments.
2784   for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
2785     if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
2786                                         UPPC_PartialSpecialization))
2787       return true;
2788
2789   // Check that the template argument list is well-formed for this
2790   // template.
2791   SmallVector<TemplateArgument, 4> Converted;
2792   if (CheckTemplateArgumentList(VarTemplate, TemplateNameLoc, TemplateArgs,
2793                                 false, Converted))
2794     return true;
2795
2796   // Find the variable template (partial) specialization declaration that
2797   // corresponds to these arguments.
2798   if (IsPartialSpecialization) {
2799     if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, VarTemplate,
2800                                                TemplateArgs.size(), Converted))
2801       return true;
2802
2803     // FIXME: Move these checks to CheckTemplatePartialSpecializationArgs so we
2804     // also do them during instantiation.
2805     bool InstantiationDependent;
2806     if (!Name.isDependent() &&
2807         !TemplateSpecializationType::anyDependentTemplateArguments(
2808             TemplateArgs.arguments(),
2809             InstantiationDependent)) {
2810       Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
2811           << VarTemplate->getDeclName();
2812       IsPartialSpecialization = false;
2813     }
2814
2815     if (isSameAsPrimaryTemplate(VarTemplate->getTemplateParameters(),
2816                                 Converted)) {
2817       // C++ [temp.class.spec]p9b3:
2818       //
2819       //   -- The argument list of the specialization shall not be identical
2820       //      to the implicit argument list of the primary template.
2821       Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
2822         << /*variable template*/ 1
2823         << /*is definition*/(SC != SC_Extern && !CurContext->isRecord())
2824         << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
2825       // FIXME: Recover from this by treating the declaration as a redeclaration
2826       // of the primary template.
2827       return true;
2828     }
2829   }
2830
2831   void *InsertPos = nullptr;
2832   VarTemplateSpecializationDecl *PrevDecl = nullptr;
2833
2834   if (IsPartialSpecialization)
2835     // FIXME: Template parameter list matters too
2836     PrevDecl = VarTemplate->findPartialSpecialization(Converted, InsertPos);
2837   else
2838     PrevDecl = VarTemplate->findSpecialization(Converted, InsertPos);
2839
2840   VarTemplateSpecializationDecl *Specialization = nullptr;
2841
2842   // Check whether we can declare a variable template specialization in
2843   // the current scope.
2844   if (CheckTemplateSpecializationScope(*this, VarTemplate, PrevDecl,
2845                                        TemplateNameLoc,
2846                                        IsPartialSpecialization))
2847     return true;
2848
2849   if (PrevDecl && PrevDecl->getSpecializationKind() == TSK_Undeclared) {
2850     // Since the only prior variable template specialization with these
2851     // arguments was referenced but not declared,  reuse that
2852     // declaration node as our own, updating its source location and
2853     // the list of outer template parameters to reflect our new declaration.
2854     Specialization = PrevDecl;
2855     Specialization->setLocation(TemplateNameLoc);
2856     PrevDecl = nullptr;
2857   } else if (IsPartialSpecialization) {
2858     // Create a new class template partial specialization declaration node.
2859     VarTemplatePartialSpecializationDecl *PrevPartial =
2860         cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
2861     VarTemplatePartialSpecializationDecl *Partial =
2862         VarTemplatePartialSpecializationDecl::Create(
2863             Context, VarTemplate->getDeclContext(), TemplateKWLoc,
2864             TemplateNameLoc, TemplateParams, VarTemplate, DI->getType(), DI, SC,
2865             Converted, TemplateArgs);
2866
2867     if (!PrevPartial)
2868       VarTemplate->AddPartialSpecialization(Partial, InsertPos);
2869     Specialization = Partial;
2870
2871     // If we are providing an explicit specialization of a member variable
2872     // template specialization, make a note of that.
2873     if (PrevPartial && PrevPartial->getInstantiatedFromMember())
2874       PrevPartial->setMemberSpecialization();
2875
2876     CheckTemplatePartialSpecialization(Partial);
2877   } else {
2878     // Create a new class template specialization declaration node for
2879     // this explicit specialization or friend declaration.
2880     Specialization = VarTemplateSpecializationDecl::Create(
2881         Context, VarTemplate->getDeclContext(), TemplateKWLoc, TemplateNameLoc,
2882         VarTemplate, DI->getType(), DI, SC, Converted);
2883     Specialization->setTemplateArgsInfo(TemplateArgs);
2884
2885     if (!PrevDecl)
2886       VarTemplate->AddSpecialization(Specialization, InsertPos);
2887   }
2888
2889   // C++ [temp.expl.spec]p6:
2890   //   If a template, a member template or the member of a class template is
2891   //   explicitly specialized then that specialization shall be declared
2892   //   before the first use of that specialization that would cause an implicit
2893   //   instantiation to take place, in every translation unit in which such a
2894   //   use occurs; no diagnostic is required.
2895   if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
2896     bool Okay = false;
2897     for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
2898       // Is there any previous explicit specialization declaration?
2899       if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
2900         Okay = true;
2901         break;
2902       }
2903     }
2904
2905     if (!Okay) {
2906       SourceRange Range(TemplateNameLoc, RAngleLoc);
2907       Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
2908           << Name << Range;
2909
2910       Diag(PrevDecl->getPointOfInstantiation(),
2911            diag::note_instantiation_required_here)
2912           << (PrevDecl->getTemplateSpecializationKind() !=
2913               TSK_ImplicitInstantiation);
2914       return true;
2915     }
2916   }
2917
2918   Specialization->setTemplateKeywordLoc(TemplateKWLoc);
2919   Specialization->setLexicalDeclContext(CurContext);
2920
2921   // Add the specialization into its lexical context, so that it can
2922   // be seen when iterating through the list of declarations in that
2923   // context. However, specializations are not found by name lookup.
2924   CurContext->addDecl(Specialization);
2925
2926   // Note that this is an explicit specialization.
2927   Specialization->setSpecializationKind(TSK_ExplicitSpecialization);
2928
2929   if (PrevDecl) {
2930     // Check that this isn't a redefinition of this specialization,
2931     // merging with previous declarations.
2932     LookupResult PrevSpec(*this, GetNameForDeclarator(D), LookupOrdinaryName,
2933                           ForRedeclaration);
2934     PrevSpec.addDecl(PrevDecl);
2935     D.setRedeclaration(CheckVariableDeclaration(Specialization, PrevSpec));
2936   } else if (Specialization->isStaticDataMember() &&
2937              Specialization->isOutOfLine()) {
2938     Specialization->setAccess(VarTemplate->getAccess());
2939   }
2940
2941   // Link instantiations of static data members back to the template from
2942   // which they were instantiated.
2943   if (Specialization->isStaticDataMember())
2944     Specialization->setInstantiationOfStaticDataMember(
2945         VarTemplate->getTemplatedDecl(),
2946         Specialization->getSpecializationKind());
2947
2948   return Specialization;
2949 }
2950
2951 namespace {
2952 /// \brief A partial specialization whose template arguments have matched
2953 /// a given template-id.
2954 struct PartialSpecMatchResult {
2955   VarTemplatePartialSpecializationDecl *Partial;
2956   TemplateArgumentList *Args;
2957 };
2958 } // end anonymous namespace
2959
2960 DeclResult
2961 Sema::CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc,
2962                          SourceLocation TemplateNameLoc,
2963                          const TemplateArgumentListInfo &TemplateArgs) {
2964   assert(Template && "A variable template id without template?");
2965
2966   // Check that the template argument list is well-formed for this template.
2967   SmallVector<TemplateArgument, 4> Converted;
2968   if (CheckTemplateArgumentList(
2969           Template, TemplateNameLoc,
2970           const_cast<TemplateArgumentListInfo &>(TemplateArgs), false,
2971           Converted))
2972     return true;
2973
2974   // Find the variable template specialization declaration that
2975   // corresponds to these arguments.
2976   void *InsertPos = nullptr;
2977   if (VarTemplateSpecializationDecl *Spec = Template->findSpecialization(
2978           Converted, InsertPos)) {
2979     checkSpecializationVisibility(TemplateNameLoc, Spec);
2980     // If we already have a variable template specialization, return it.
2981     return Spec;
2982   }
2983
2984   // This is the first time we have referenced this variable template
2985   // specialization. Create the canonical declaration and add it to
2986   // the set of specializations, based on the closest partial specialization
2987   // that it represents. That is,
2988   VarDecl *InstantiationPattern = Template->getTemplatedDecl();
2989   TemplateArgumentList TemplateArgList(TemplateArgumentList::OnStack,
2990                                        Converted);
2991   TemplateArgumentList *InstantiationArgs = &TemplateArgList;
2992   bool AmbiguousPartialSpec = false;
2993   typedef PartialSpecMatchResult MatchResult;
2994   SmallVector<MatchResult, 4> Matched;
2995   SourceLocation PointOfInstantiation = TemplateNameLoc;
2996   TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation,
2997                                             /*ForTakingAddress=*/false);
2998
2999   // 1. Attempt to find the closest partial specialization that this
3000   // specializes, if any.
3001   // If any of the template arguments is dependent, then this is probably
3002   // a placeholder for an incomplete declarative context; which must be
3003   // complete by instantiation time. Thus, do not search through the partial
3004   // specializations yet.
3005   // TODO: Unify with InstantiateClassTemplateSpecialization()?
3006   //       Perhaps better after unification of DeduceTemplateArguments() and
3007   //       getMoreSpecializedPartialSpecialization().
3008   bool InstantiationDependent = false;
3009   if (!TemplateSpecializationType::anyDependentTemplateArguments(
3010           TemplateArgs, InstantiationDependent)) {
3011
3012     SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
3013     Template->getPartialSpecializations(PartialSpecs);
3014
3015     for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
3016       VarTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
3017       TemplateDeductionInfo Info(FailedCandidates.getLocation());
3018
3019       if (TemplateDeductionResult Result =
3020               DeduceTemplateArguments(Partial, TemplateArgList, Info)) {
3021         // Store the failed-deduction information for use in diagnostics, later.
3022         // TODO: Actually use the failed-deduction info?
3023         FailedCandidates.addCandidate().set(
3024             DeclAccessPair::make(Template, AS_public), Partial,
3025             MakeDeductionFailureInfo(Context, Result, Info));
3026         (void)Result;
3027       } else {
3028         Matched.push_back(PartialSpecMatchResult());
3029         Matched.back().Partial = Partial;
3030         Matched.back().Args = Info.take();
3031       }
3032     }
3033
3034     if (Matched.size() >= 1) {
3035       SmallVector<MatchResult, 4>::iterator Best = Matched.begin();
3036       if (Matched.size() == 1) {
3037         //   -- If exactly one matching specialization is found, the
3038         //      instantiation is generated from that specialization.
3039         // We don't need to do anything for this.
3040       } else {
3041         //   -- If more than one matching specialization is found, the
3042         //      partial order rules (14.5.4.2) are used to determine
3043         //      whether one of the specializations is more specialized
3044         //      than the others. If none of the specializations is more
3045         //      specialized than all of the other matching
3046         //      specializations, then the use of the variable template is
3047         //      ambiguous and the program is ill-formed.
3048         for (SmallVector<MatchResult, 4>::iterator P = Best + 1,
3049                                                    PEnd = Matched.end();
3050              P != PEnd; ++P) {
3051           if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
3052                                                       PointOfInstantiation) ==
3053               P->Partial)
3054             Best = P;
3055         }
3056
3057         // Determine if the best partial specialization is more specialized than
3058         // the others.
3059         for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
3060                                                    PEnd = Matched.end();
3061              P != PEnd; ++P) {
3062           if (P != Best && getMoreSpecializedPartialSpecialization(
3063                                P->Partial, Best->Partial,
3064                                PointOfInstantiation) != Best->Partial) {
3065             AmbiguousPartialSpec = true;
3066             break;
3067           }
3068         }
3069       }
3070
3071       // Instantiate using the best variable template partial specialization.
3072       InstantiationPattern = Best->Partial;
3073       InstantiationArgs = Best->Args;
3074     } else {
3075       //   -- If no match is found, the instantiation is generated
3076       //      from the primary template.
3077       // InstantiationPattern = Template->getTemplatedDecl();
3078     }
3079   }
3080
3081   // 2. Create the canonical declaration.
3082   // Note that we do not instantiate a definition until we see an odr-use
3083   // in DoMarkVarDeclReferenced().
3084   // FIXME: LateAttrs et al.?
3085   VarTemplateSpecializationDecl *Decl = BuildVarTemplateInstantiation(
3086       Template, InstantiationPattern, *InstantiationArgs, TemplateArgs,
3087       Converted, TemplateNameLoc, InsertPos /*, LateAttrs, StartingScope*/);
3088   if (!Decl)
3089     return true;
3090
3091   if (AmbiguousPartialSpec) {
3092     // Partial ordering did not produce a clear winner. Complain.
3093     Decl->setInvalidDecl();
3094     Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
3095         << Decl;
3096
3097     // Print the matching partial specializations.
3098     for (MatchResult P : Matched)
3099       Diag(P.Partial->getLocation(), diag::note_partial_spec_match)
3100           << getTemplateArgumentBindingsText(P.Partial->getTemplateParameters(),
3101                                              *P.Args);
3102     return true;
3103   }
3104
3105   if (VarTemplatePartialSpecializationDecl *D =
3106           dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))
3107     Decl->setInstantiationOf(D, InstantiationArgs);
3108
3109   checkSpecializationVisibility(TemplateNameLoc, Decl);
3110
3111   assert(Decl && "No variable template specialization?");
3112   return Decl;
3113 }
3114
3115 ExprResult
3116 Sema::CheckVarTemplateId(const CXXScopeSpec &SS,
3117                          const DeclarationNameInfo &NameInfo,
3118                          VarTemplateDecl *Template, SourceLocation TemplateLoc,
3119                          const TemplateArgumentListInfo *TemplateArgs) {
3120
3121   DeclResult Decl = CheckVarTemplateId(Template, TemplateLoc, NameInfo.getLoc(),
3122                                        *TemplateArgs);
3123   if (Decl.isInvalid())
3124     return ExprError();
3125
3126   VarDecl *Var = cast<VarDecl>(Decl.get());
3127   if (!Var->getTemplateSpecializationKind())
3128     Var->setTemplateSpecializationKind(TSK_ImplicitInstantiation,
3129                                        NameInfo.getLoc());
3130
3131   // Build an ordinary singleton decl ref.
3132   return BuildDeclarationNameExpr(SS, NameInfo, Var,
3133                                   /*FoundD=*/nullptr, TemplateArgs);
3134 }
3135
3136 ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,
3137                                      SourceLocation TemplateKWLoc,
3138                                      LookupResult &R,
3139                                      bool RequiresADL,
3140                                  const TemplateArgumentListInfo *TemplateArgs) {
3141   // FIXME: Can we do any checking at this point? I guess we could check the
3142   // template arguments that we have against the template name, if the template
3143   // name refers to a single template. That's not a terribly common case,
3144   // though.
3145   // foo<int> could identify a single function unambiguously
3146   // This approach does NOT work, since f<int>(1);
3147   // gets resolved prior to resorting to overload resolution
3148   // i.e., template<class T> void f(double);
3149   //       vs template<class T, class U> void f(U);
3150
3151   // These should be filtered out by our callers.
3152   assert(!R.empty() && "empty lookup results when building templateid");
3153   assert(!R.isAmbiguous() && "ambiguous lookup when building templateid");
3154
3155   // In C++1y, check variable template ids.
3156   bool InstantiationDependent;
3157   if (R.getAsSingle<VarTemplateDecl>() &&
3158       !TemplateSpecializationType::anyDependentTemplateArguments(
3159            *TemplateArgs, InstantiationDependent)) {
3160     return CheckVarTemplateId(SS, R.getLookupNameInfo(),
3161                               R.getAsSingle<VarTemplateDecl>(),
3162                               TemplateKWLoc, TemplateArgs);
3163   }
3164
3165   // We don't want lookup warnings at this point.
3166   R.suppressDiagnostics();
3167
3168   UnresolvedLookupExpr *ULE
3169     = UnresolvedLookupExpr::Create(Context, R.getNamingClass(),
3170                                    SS.getWithLocInContext(Context),
3171                                    TemplateKWLoc,
3172                                    R.getLookupNameInfo(),
3173                                    RequiresADL, TemplateArgs,
3174                                    R.begin(), R.end());
3175
3176   return ULE;
3177 }
3178
3179 // We actually only call this from template instantiation.
3180 ExprResult
3181 Sema::BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS,
3182                                    SourceLocation TemplateKWLoc,
3183                                    const DeclarationNameInfo &NameInfo,
3184                              const TemplateArgumentListInfo *TemplateArgs) {
3185
3186   assert(TemplateArgs || TemplateKWLoc.isValid());
3187   DeclContext *DC;
3188   if (!(DC = computeDeclContext(SS, false)) ||
3189       DC->isDependentContext() ||
3190       RequireCompleteDeclContext(SS, DC))
3191     return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
3192
3193   bool MemberOfUnknownSpecialization;
3194   LookupResult R(*this, NameInfo, LookupOrdinaryName);
3195   LookupTemplateName(R, (Scope*)nullptr, SS, QualType(), /*Entering*/ false,
3196                      MemberOfUnknownSpecialization);
3197
3198   if (R.isAmbiguous())
3199     return ExprError();
3200
3201   if (R.empty()) {
3202     Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_non_template)
3203       << NameInfo.getName() << SS.getRange();
3204     return ExprError();
3205   }
3206
3207   if (ClassTemplateDecl *Temp = R.getAsSingle<ClassTemplateDecl>()) {
3208     Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_class_template)
3209       << SS.getScopeRep()
3210       << NameInfo.getName().getAsString() << SS.getRange();
3211     Diag(Temp->getLocation(), diag::note_referenced_class_template);
3212     return ExprError();
3213   }
3214
3215   return BuildTemplateIdExpr(SS, TemplateKWLoc, R, /*ADL*/ false, TemplateArgs);
3216 }
3217
3218 /// \brief Form a dependent template name.
3219 ///
3220 /// This action forms a dependent template name given the template
3221 /// name and its (presumably dependent) scope specifier. For
3222 /// example, given "MetaFun::template apply", the scope specifier \p
3223 /// SS will be "MetaFun::", \p TemplateKWLoc contains the location
3224 /// of the "template" keyword, and "apply" is the \p Name.
3225 TemplateNameKind Sema::ActOnDependentTemplateName(Scope *S,
3226                                                   CXXScopeSpec &SS,
3227                                                   SourceLocation TemplateKWLoc,
3228                                                   UnqualifiedId &Name,
3229                                                   ParsedType ObjectType,
3230                                                   bool EnteringContext,
3231                                                   TemplateTy &Result) {
3232   if (TemplateKWLoc.isValid() && S && !S->getTemplateParamParent())
3233     Diag(TemplateKWLoc,
3234          getLangOpts().CPlusPlus11 ?
3235            diag::warn_cxx98_compat_template_outside_of_template :
3236            diag::ext_template_outside_of_template)
3237       << FixItHint::CreateRemoval(TemplateKWLoc);
3238
3239   DeclContext *LookupCtx = nullptr;
3240   if (SS.isSet())
3241     LookupCtx = computeDeclContext(SS, EnteringContext);
3242   if (!LookupCtx && ObjectType)
3243     LookupCtx = computeDeclContext(ObjectType.get());
3244   if (LookupCtx) {
3245     // C++0x [temp.names]p5:
3246     //   If a name prefixed by the keyword template is not the name of
3247     //   a template, the program is ill-formed. [Note: the keyword
3248     //   template may not be applied to non-template members of class
3249     //   templates. -end note ] [ Note: as is the case with the
3250     //   typename prefix, the template prefix is allowed in cases
3251     //   where it is not strictly necessary; i.e., when the
3252     //   nested-name-specifier or the expression on the left of the ->
3253     //   or . is not dependent on a template-parameter, or the use
3254     //   does not appear in the scope of a template. -end note]
3255     //
3256     // Note: C++03 was more strict here, because it banned the use of
3257     // the "template" keyword prior to a template-name that was not a
3258     // dependent name. C++ DR468 relaxed this requirement (the
3259     // "template" keyword is now permitted). We follow the C++0x
3260     // rules, even in C++03 mode with a warning, retroactively applying the DR.
3261     bool MemberOfUnknownSpecialization;
3262     TemplateNameKind TNK = isTemplateName(S, SS, TemplateKWLoc.isValid(), Name,
3263                                           ObjectType, EnteringContext, Result,
3264                                           MemberOfUnknownSpecialization);
3265     if (TNK == TNK_Non_template && LookupCtx->isDependentContext() &&
3266         isa<CXXRecordDecl>(LookupCtx) &&
3267         (!cast<CXXRecordDecl>(LookupCtx)->hasDefinition() ||
3268          cast<CXXRecordDecl>(LookupCtx)->hasAnyDependentBases())) {
3269       // This is a dependent template. Handle it below.
3270     } else if (TNK == TNK_Non_template) {
3271       Diag(Name.getLocStart(),
3272            diag::err_template_kw_refers_to_non_template)
3273         << GetNameFromUnqualifiedId(Name).getName()
3274         << Name.getSourceRange()
3275         << TemplateKWLoc;
3276       return TNK_Non_template;
3277     } else {
3278       // We found something; return it.
3279       return TNK;
3280     }
3281   }
3282
3283   NestedNameSpecifier *Qualifier = SS.getScopeRep();
3284
3285   switch (Name.getKind()) {
3286   case UnqualifiedId::IK_Identifier:
3287     Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
3288                                                               Name.Identifier));
3289     return TNK_Dependent_template_name;
3290
3291   case UnqualifiedId::IK_OperatorFunctionId:
3292     Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
3293                                              Name.OperatorFunctionId.Operator));
3294     return TNK_Function_template;
3295
3296   case UnqualifiedId::IK_LiteralOperatorId:
3297     llvm_unreachable("literal operator id cannot have a dependent scope");
3298
3299   default:
3300     break;
3301   }
3302
3303   Diag(Name.getLocStart(),
3304        diag::err_template_kw_refers_to_non_template)
3305     << GetNameFromUnqualifiedId(Name).getName()
3306     << Name.getSourceRange()
3307     << TemplateKWLoc;
3308   return TNK_Non_template;
3309 }
3310
3311 bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
3312                                      TemplateArgumentLoc &AL,
3313                           SmallVectorImpl<TemplateArgument> &Converted) {
3314   const TemplateArgument &Arg = AL.getArgument();
3315   QualType ArgType;
3316   TypeSourceInfo *TSI = nullptr;
3317
3318   // Check template type parameter.
3319   switch(Arg.getKind()) {
3320   case TemplateArgument::Type:
3321     // C++ [temp.arg.type]p1:
3322     //   A template-argument for a template-parameter which is a
3323     //   type shall be a type-id.
3324     ArgType = Arg.getAsType();
3325     TSI = AL.getTypeSourceInfo();
3326     break;
3327   case TemplateArgument::Template: {
3328     // We have a template type parameter but the template argument
3329     // is a template without any arguments.
3330     SourceRange SR = AL.getSourceRange();
3331     TemplateName Name = Arg.getAsTemplate();
3332     Diag(SR.getBegin(), diag::err_template_missing_args)
3333       << Name << SR;
3334     if (TemplateDecl *Decl = Name.getAsTemplateDecl())
3335       Diag(Decl->getLocation(), diag::note_template_decl_here);
3336
3337     return true;
3338   }
3339   case TemplateArgument::Expression: {
3340     // We have a template type parameter but the template argument is an
3341     // expression; see if maybe it is missing the "typename" keyword.
3342     CXXScopeSpec SS;
3343     DeclarationNameInfo NameInfo;
3344
3345     if (DeclRefExpr *ArgExpr = dyn_cast<DeclRefExpr>(Arg.getAsExpr())) {
3346       SS.Adopt(ArgExpr->getQualifierLoc());
3347       NameInfo = ArgExpr->getNameInfo();
3348     } else if (DependentScopeDeclRefExpr *ArgExpr =
3349                dyn_cast<DependentScopeDeclRefExpr>(Arg.getAsExpr())) {
3350       SS.Adopt(ArgExpr->getQualifierLoc());
3351       NameInfo = ArgExpr->getNameInfo();
3352     } else if (CXXDependentScopeMemberExpr *ArgExpr =
3353                dyn_cast<CXXDependentScopeMemberExpr>(Arg.getAsExpr())) {
3354       if (ArgExpr->isImplicitAccess()) {
3355         SS.Adopt(ArgExpr->getQualifierLoc());
3356         NameInfo = ArgExpr->getMemberNameInfo();
3357       }
3358     }
3359
3360     if (auto *II = NameInfo.getName().getAsIdentifierInfo()) {
3361       LookupResult Result(*this, NameInfo, LookupOrdinaryName);
3362       LookupParsedName(Result, CurScope, &SS);
3363
3364       if (Result.getAsSingle<TypeDecl>() ||
3365           Result.getResultKind() ==
3366               LookupResult::NotFoundInCurrentInstantiation) {
3367         // Suggest that the user add 'typename' before the NNS.
3368         SourceLocation Loc = AL.getSourceRange().getBegin();
3369         Diag(Loc, getLangOpts().MSVCCompat
3370                       ? diag::ext_ms_template_type_arg_missing_typename
3371                       : diag::err_template_arg_must_be_type_suggest)
3372             << FixItHint::CreateInsertion(Loc, "typename ");
3373         Diag(Param->getLocation(), diag::note_template_param_here);
3374
3375         // Recover by synthesizing a type using the location information that we
3376         // already have.
3377         ArgType =
3378             Context.getDependentNameType(ETK_Typename, SS.getScopeRep(), II);
3379         TypeLocBuilder TLB;
3380         DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(ArgType);
3381         TL.setElaboratedKeywordLoc(SourceLocation(/*synthesized*/));
3382         TL.setQualifierLoc(SS.getWithLocInContext(Context));
3383         TL.setNameLoc(NameInfo.getLoc());
3384         TSI = TLB.getTypeSourceInfo(Context, ArgType);
3385
3386         // Overwrite our input TemplateArgumentLoc so that we can recover
3387         // properly.
3388         AL = TemplateArgumentLoc(TemplateArgument(ArgType),
3389                                  TemplateArgumentLocInfo(TSI));
3390
3391         break;
3392       }
3393     }
3394     // fallthrough
3395   }
3396   default: {
3397     // We have a template type parameter but the template argument
3398     // is not a type.
3399     SourceRange SR = AL.getSourceRange();
3400     Diag(SR.getBegin(), diag::err_template_arg_must_be_type) << SR;
3401     Diag(Param->getLocation(), diag::note_template_param_here);
3402
3403     return true;
3404   }
3405   }
3406
3407   if (CheckTemplateArgument(Param, TSI))
3408     return true;
3409
3410   // Add the converted template type argument.
3411   ArgType = Context.getCanonicalType(ArgType);
3412
3413   // Objective-C ARC:
3414   //   If an explicitly-specified template argument type is a lifetime type
3415   //   with no lifetime qualifier, the __strong lifetime qualifier is inferred.
3416   if (getLangOpts().ObjCAutoRefCount &&
3417       ArgType->isObjCLifetimeType() &&
3418       !ArgType.getObjCLifetime()) {
3419     Qualifiers Qs;
3420     Qs.setObjCLifetime(Qualifiers::OCL_Strong);
3421     ArgType = Context.getQualifiedType(ArgType, Qs);
3422   }
3423
3424   Converted.push_back(TemplateArgument(ArgType));
3425   return false;
3426 }
3427
3428 /// \brief Substitute template arguments into the default template argument for
3429 /// the given template type parameter.
3430 ///
3431 /// \param SemaRef the semantic analysis object for which we are performing
3432 /// the substitution.
3433 ///
3434 /// \param Template the template that we are synthesizing template arguments
3435 /// for.
3436 ///
3437 /// \param TemplateLoc the location of the template name that started the
3438 /// template-id we are checking.
3439 ///
3440 /// \param RAngleLoc the location of the right angle bracket ('>') that
3441 /// terminates the template-id.
3442 ///
3443 /// \param Param the template template parameter whose default we are
3444 /// substituting into.
3445 ///
3446 /// \param Converted the list of template arguments provided for template
3447 /// parameters that precede \p Param in the template parameter list.
3448 /// \returns the substituted template argument, or NULL if an error occurred.
3449 static TypeSourceInfo *
3450 SubstDefaultTemplateArgument(Sema &SemaRef,
3451                              TemplateDecl *Template,
3452                              SourceLocation TemplateLoc,
3453                              SourceLocation RAngleLoc,
3454                              TemplateTypeParmDecl *Param,
3455                          SmallVectorImpl<TemplateArgument> &Converted) {
3456   TypeSourceInfo *ArgType = Param->getDefaultArgumentInfo();
3457
3458   // If the argument type is dependent, instantiate it now based
3459   // on the previously-computed template arguments.
3460   if (ArgType->getType()->isDependentType()) {
3461     Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
3462                                      Param, Template, Converted,
3463                                      SourceRange(TemplateLoc, RAngleLoc));
3464     if (Inst.isInvalid())
3465       return nullptr;
3466
3467     TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
3468
3469     // Only substitute for the innermost template argument list.
3470     MultiLevelTemplateArgumentList TemplateArgLists;
3471     TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
3472     for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
3473       TemplateArgLists.addOuterTemplateArguments(None);
3474
3475     Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
3476     ArgType =
3477         SemaRef.SubstType(ArgType, TemplateArgLists,
3478                           Param->getDefaultArgumentLoc(), Param->getDeclName());
3479   }
3480
3481   return ArgType;
3482 }
3483
3484 /// \brief Substitute template arguments into the default template argument for
3485 /// the given non-type template parameter.
3486 ///
3487 /// \param SemaRef the semantic analysis object for which we are performing
3488 /// the substitution.
3489 ///
3490 /// \param Template the template that we are synthesizing template arguments
3491 /// for.
3492 ///
3493 /// \param TemplateLoc the location of the template name that started the
3494 /// template-id we are checking.
3495 ///
3496 /// \param RAngleLoc the location of the right angle bracket ('>') that
3497 /// terminates the template-id.
3498 ///
3499 /// \param Param the non-type template parameter whose default we are
3500 /// substituting into.
3501 ///
3502 /// \param Converted the list of template arguments provided for template
3503 /// parameters that precede \p Param in the template parameter list.
3504 ///
3505 /// \returns the substituted template argument, or NULL if an error occurred.
3506 static ExprResult
3507 SubstDefaultTemplateArgument(Sema &SemaRef,
3508                              TemplateDecl *Template,
3509                              SourceLocation TemplateLoc,
3510                              SourceLocation RAngleLoc,
3511                              NonTypeTemplateParmDecl *Param,
3512                         SmallVectorImpl<TemplateArgument> &Converted) {
3513   Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
3514                                    Param, Template, Converted,
3515                                    SourceRange(TemplateLoc, RAngleLoc));
3516   if (Inst.isInvalid())
3517     return ExprError();
3518
3519   TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
3520
3521   // Only substitute for the innermost template argument list.
3522   MultiLevelTemplateArgumentList TemplateArgLists;
3523   TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
3524   for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
3525     TemplateArgLists.addOuterTemplateArguments(None);
3526
3527   EnterExpressionEvaluationContext ConstantEvaluated(SemaRef,
3528                                                      Sema::ConstantEvaluated);
3529   return SemaRef.SubstExpr(Param->getDefaultArgument(), TemplateArgLists);
3530 }
3531
3532 /// \brief Substitute template arguments into the default template argument for
3533 /// the given template template parameter.
3534 ///
3535 /// \param SemaRef the semantic analysis object for which we are performing
3536 /// the substitution.
3537 ///
3538 /// \param Template the template that we are synthesizing template arguments
3539 /// for.
3540 ///
3541 /// \param TemplateLoc the location of the template name that started the
3542 /// template-id we are checking.
3543 ///
3544 /// \param RAngleLoc the location of the right angle bracket ('>') that
3545 /// terminates the template-id.
3546 ///
3547 /// \param Param the template template parameter whose default we are
3548 /// substituting into.
3549 ///
3550 /// \param Converted the list of template arguments provided for template
3551 /// parameters that precede \p Param in the template parameter list.
3552 ///
3553 /// \param QualifierLoc Will be set to the nested-name-specifier (with
3554 /// source-location information) that precedes the template name.
3555 ///
3556 /// \returns the substituted template argument, or NULL if an error occurred.
3557 static TemplateName
3558 SubstDefaultTemplateArgument(Sema &SemaRef,
3559                              TemplateDecl *Template,
3560                              SourceLocation TemplateLoc,
3561                              SourceLocation RAngleLoc,
3562                              TemplateTemplateParmDecl *Param,
3563                        SmallVectorImpl<TemplateArgument> &Converted,
3564                              NestedNameSpecifierLoc &QualifierLoc) {
3565   Sema::InstantiatingTemplate Inst(
3566       SemaRef, TemplateLoc, TemplateParameter(Param), Template, Converted,
3567       SourceRange(TemplateLoc, RAngleLoc));
3568   if (Inst.isInvalid())
3569     return TemplateName();
3570
3571   TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
3572
3573   // Only substitute for the innermost template argument list.
3574   MultiLevelTemplateArgumentList TemplateArgLists;
3575   TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
3576   for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
3577     TemplateArgLists.addOuterTemplateArguments(None);
3578
3579   Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
3580   // Substitute into the nested-name-specifier first,
3581   QualifierLoc = Param->getDefaultArgument().getTemplateQualifierLoc();
3582   if (QualifierLoc) {
3583     QualifierLoc =
3584         SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgLists);
3585     if (!QualifierLoc)
3586       return TemplateName();
3587   }
3588
3589   return SemaRef.SubstTemplateName(
3590              QualifierLoc,
3591              Param->getDefaultArgument().getArgument().getAsTemplate(),
3592              Param->getDefaultArgument().getTemplateNameLoc(),
3593              TemplateArgLists);
3594 }
3595
3596 /// \brief If the given template parameter has a default template
3597 /// argument, substitute into that default template argument and
3598 /// return the corresponding template argument.
3599 TemplateArgumentLoc
3600 Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
3601                                               SourceLocation TemplateLoc,
3602                                               SourceLocation RAngleLoc,
3603                                               Decl *Param,
3604                                               SmallVectorImpl<TemplateArgument>
3605                                                 &Converted,
3606                                               bool &HasDefaultArg) {
3607   HasDefaultArg = false;
3608
3609   if (TemplateTypeParmDecl *TypeParm = dyn_cast<TemplateTypeParmDecl>(Param)) {
3610     if (!hasVisibleDefaultArgument(TypeParm))
3611       return TemplateArgumentLoc();
3612
3613     HasDefaultArg = true;
3614     TypeSourceInfo *DI = SubstDefaultTemplateArgument(*this, Template,
3615                                                       TemplateLoc,
3616                                                       RAngleLoc,
3617                                                       TypeParm,
3618                                                       Converted);
3619     if (DI)
3620       return TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
3621
3622     return TemplateArgumentLoc();
3623   }
3624
3625   if (NonTypeTemplateParmDecl *NonTypeParm
3626         = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
3627     if (!hasVisibleDefaultArgument(NonTypeParm))
3628       return TemplateArgumentLoc();
3629
3630     HasDefaultArg = true;
3631     ExprResult Arg = SubstDefaultTemplateArgument(*this, Template,
3632                                                   TemplateLoc,
3633                                                   RAngleLoc,
3634                                                   NonTypeParm,
3635                                                   Converted);
3636     if (Arg.isInvalid())
3637       return TemplateArgumentLoc();
3638
3639     Expr *ArgE = Arg.getAs<Expr>();
3640     return TemplateArgumentLoc(TemplateArgument(ArgE), ArgE);
3641   }
3642
3643   TemplateTemplateParmDecl *TempTempParm
3644     = cast<TemplateTemplateParmDecl>(Param);
3645   if (!hasVisibleDefaultArgument(TempTempParm))
3646     return TemplateArgumentLoc();
3647
3648   HasDefaultArg = true;
3649   NestedNameSpecifierLoc QualifierLoc;
3650   TemplateName TName = SubstDefaultTemplateArgument(*this, Template,
3651                                                     TemplateLoc,
3652                                                     RAngleLoc,
3653                                                     TempTempParm,
3654                                                     Converted,
3655                                                     QualifierLoc);
3656   if (TName.isNull())
3657     return TemplateArgumentLoc();
3658
3659   return TemplateArgumentLoc(TemplateArgument(TName),
3660                 TempTempParm->getDefaultArgument().getTemplateQualifierLoc(),
3661                 TempTempParm->getDefaultArgument().getTemplateNameLoc());
3662 }
3663
3664 /// \brief Check that the given template argument corresponds to the given
3665 /// template parameter.
3666 ///
3667 /// \param Param The template parameter against which the argument will be
3668 /// checked.
3669 ///
3670 /// \param Arg The template argument, which may be updated due to conversions.
3671 ///
3672 /// \param Template The template in which the template argument resides.
3673 ///
3674 /// \param TemplateLoc The location of the template name for the template
3675 /// whose argument list we're matching.
3676 ///
3677 /// \param RAngleLoc The location of the right angle bracket ('>') that closes
3678 /// the template argument list.
3679 ///
3680 /// \param ArgumentPackIndex The index into the argument pack where this
3681 /// argument will be placed. Only valid if the parameter is a parameter pack.
3682 ///
3683 /// \param Converted The checked, converted argument will be added to the
3684 /// end of this small vector.
3685 ///
3686 /// \param CTAK Describes how we arrived at this particular template argument:
3687 /// explicitly written, deduced, etc.
3688 ///
3689 /// \returns true on error, false otherwise.
3690 bool Sema::CheckTemplateArgument(NamedDecl *Param,
3691                                  TemplateArgumentLoc &Arg,
3692                                  NamedDecl *Template,
3693                                  SourceLocation TemplateLoc,
3694                                  SourceLocation RAngleLoc,
3695                                  unsigned ArgumentPackIndex,
3696                             SmallVectorImpl<TemplateArgument> &Converted,
3697                                  CheckTemplateArgumentKind CTAK) {
3698   // Check template type parameters.
3699   if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
3700     return CheckTemplateTypeArgument(TTP, Arg, Converted);
3701
3702   // Check non-type template parameters.
3703   if (NonTypeTemplateParmDecl *NTTP =dyn_cast<NonTypeTemplateParmDecl>(Param)) {
3704     // Do substitution on the type of the non-type template parameter
3705     // with the template arguments we've seen thus far.  But if the
3706     // template has a dependent context then we cannot substitute yet.
3707     QualType NTTPType = NTTP->getType();
3708     if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
3709       NTTPType = NTTP->getExpansionType(ArgumentPackIndex);
3710
3711     if (NTTPType->isDependentType() &&
3712         !isa<TemplateTemplateParmDecl>(Template) &&
3713         !Template->getDeclContext()->isDependentContext()) {
3714       // Do substitution on the type of the non-type template parameter.
3715       InstantiatingTemplate Inst(*this, TemplateLoc, Template,
3716                                  NTTP, Converted,
3717                                  SourceRange(TemplateLoc, RAngleLoc));
3718       if (Inst.isInvalid())
3719         return true;
3720
3721       TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
3722                                         Converted);
3723       NTTPType = SubstType(NTTPType,
3724                            MultiLevelTemplateArgumentList(TemplateArgs),
3725                            NTTP->getLocation(),
3726                            NTTP->getDeclName());
3727       // If that worked, check the non-type template parameter type
3728       // for validity.
3729       if (!NTTPType.isNull())
3730         NTTPType = CheckNonTypeTemplateParameterType(NTTPType,
3731                                                      NTTP->getLocation());
3732       if (NTTPType.isNull())
3733         return true;
3734     }
3735
3736     switch (Arg.getArgument().getKind()) {
3737     case TemplateArgument::Null:
3738       llvm_unreachable("Should never see a NULL template argument here");
3739
3740     case TemplateArgument::Expression: {
3741       TemplateArgument Result;
3742       ExprResult Res =
3743         CheckTemplateArgument(NTTP, NTTPType, Arg.getArgument().getAsExpr(),
3744                               Result, CTAK);
3745       if (Res.isInvalid())
3746         return true;
3747
3748       // If the resulting expression is new, then use it in place of the
3749       // old expression in the template argument.
3750       if (Res.get() != Arg.getArgument().getAsExpr()) {
3751         TemplateArgument TA(Res.get());
3752         Arg = TemplateArgumentLoc(TA, Res.get());
3753       }
3754
3755       Converted.push_back(Result);
3756       break;
3757     }
3758
3759     case TemplateArgument::Declaration:
3760     case TemplateArgument::Integral:
3761     case TemplateArgument::NullPtr:
3762       // We've already checked this template argument, so just copy
3763       // it to the list of converted arguments.
3764       Converted.push_back(Arg.getArgument());
3765       break;
3766
3767     case TemplateArgument::Template:
3768     case TemplateArgument::TemplateExpansion:
3769       // We were given a template template argument. It may not be ill-formed;
3770       // see below.
3771       if (DependentTemplateName *DTN
3772             = Arg.getArgument().getAsTemplateOrTemplatePattern()
3773                                               .getAsDependentTemplateName()) {
3774         // We have a template argument such as \c T::template X, which we
3775         // parsed as a template template argument. However, since we now
3776         // know that we need a non-type template argument, convert this
3777         // template name into an expression.
3778
3779         DeclarationNameInfo NameInfo(DTN->getIdentifier(),
3780                                      Arg.getTemplateNameLoc());
3781
3782         CXXScopeSpec SS;
3783         SS.Adopt(Arg.getTemplateQualifierLoc());
3784         // FIXME: the template-template arg was a DependentTemplateName,
3785         // so it was provided with a template keyword. However, its source
3786         // location is not stored in the template argument structure.
3787         SourceLocation TemplateKWLoc;
3788         ExprResult E = DependentScopeDeclRefExpr::Create(
3789             Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
3790             nullptr);
3791
3792         // If we parsed the template argument as a pack expansion, create a
3793         // pack expansion expression.
3794         if (Arg.getArgument().getKind() == TemplateArgument::TemplateExpansion){
3795           E = ActOnPackExpansion(E.get(), Arg.getTemplateEllipsisLoc());
3796           if (E.isInvalid())
3797             return true;
3798         }
3799
3800         TemplateArgument Result;
3801         E = CheckTemplateArgument(NTTP, NTTPType, E.get(), Result);
3802         if (E.isInvalid())
3803           return true;
3804
3805         Converted.push_back(Result);
3806         break;
3807       }
3808
3809       // We have a template argument that actually does refer to a class
3810       // template, alias template, or template template parameter, and
3811       // therefore cannot be a non-type template argument.
3812       Diag(Arg.getLocation(), diag::err_template_arg_must_be_expr)
3813         << Arg.getSourceRange();
3814
3815       Diag(Param->getLocation(), diag::note_template_param_here);
3816       return true;
3817
3818     case TemplateArgument::Type: {
3819       // We have a non-type template parameter but the template
3820       // argument is a type.
3821
3822       // C++ [temp.arg]p2:
3823       //   In a template-argument, an ambiguity between a type-id and
3824       //   an expression is resolved to a type-id, regardless of the
3825       //   form of the corresponding template-parameter.
3826       //
3827       // We warn specifically about this case, since it can be rather
3828       // confusing for users.
3829       QualType T = Arg.getArgument().getAsType();
3830       SourceRange SR = Arg.getSourceRange();
3831       if (T->isFunctionType())
3832         Diag(SR.getBegin(), diag::err_template_arg_nontype_ambig) << SR << T;
3833       else
3834         Diag(SR.getBegin(), diag::err_template_arg_must_be_expr) << SR;
3835       Diag(Param->getLocation(), diag::note_template_param_here);
3836       return true;
3837     }
3838
3839     case TemplateArgument::Pack:
3840       llvm_unreachable("Caller must expand template argument packs");
3841     }
3842
3843     return false;
3844   }
3845
3846
3847   // Check template template parameters.
3848   TemplateTemplateParmDecl *TempParm = cast<TemplateTemplateParmDecl>(Param);
3849
3850   // Substitute into the template parameter list of the template
3851   // template parameter, since previously-supplied template arguments
3852   // may appear within the template template parameter.
3853   {
3854     // Set up a template instantiation context.
3855     LocalInstantiationScope Scope(*this);
3856     InstantiatingTemplate Inst(*this, TemplateLoc, Template,
3857                                TempParm, Converted,
3858                                SourceRange(TemplateLoc, RAngleLoc));
3859     if (Inst.isInvalid())
3860       return true;
3861
3862     TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
3863     TempParm = cast_or_null<TemplateTemplateParmDecl>(
3864                       SubstDecl(TempParm, CurContext,
3865                                 MultiLevelTemplateArgumentList(TemplateArgs)));
3866     if (!TempParm)
3867       return true;
3868   }
3869
3870   switch (Arg.getArgument().getKind()) {
3871   case TemplateArgument::Null:
3872     llvm_unreachable("Should never see a NULL template argument here");
3873
3874   case TemplateArgument::Template:
3875   case TemplateArgument::TemplateExpansion:
3876     if (CheckTemplateArgument(TempParm, Arg, ArgumentPackIndex))
3877       return true;
3878
3879     Converted.push_back(Arg.getArgument());
3880     break;
3881
3882   case TemplateArgument::Expression:
3883   case TemplateArgument::Type:
3884     // We have a template template parameter but the template
3885     // argument does not refer to a template.
3886     Diag(Arg.getLocation(), diag::err_template_arg_must_be_template)
3887       << getLangOpts().CPlusPlus11;
3888     return true;
3889
3890   case TemplateArgument::Declaration:
3891     llvm_unreachable("Declaration argument with template template parameter");
3892   case TemplateArgument::Integral:
3893     llvm_unreachable("Integral argument with template template parameter");
3894   case TemplateArgument::NullPtr:
3895     llvm_unreachable("Null pointer argument with template template parameter");
3896
3897   case TemplateArgument::Pack:
3898     llvm_unreachable("Caller must expand template argument packs");
3899   }
3900
3901   return false;
3902 }
3903
3904 /// \brief Diagnose an arity mismatch in the
3905 static bool diagnoseArityMismatch(Sema &S, TemplateDecl *Template,
3906                                   SourceLocation TemplateLoc,
3907                                   TemplateArgumentListInfo &TemplateArgs) {
3908   TemplateParameterList *Params = Template->getTemplateParameters();
3909   unsigned NumParams = Params->size();
3910   unsigned NumArgs = TemplateArgs.size();
3911
3912   SourceRange Range;
3913   if (NumArgs > NumParams)
3914     Range = SourceRange(TemplateArgs[NumParams].getLocation(),
3915                         TemplateArgs.getRAngleLoc());
3916   S.Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
3917     << (NumArgs > NumParams)
3918     << (isa<ClassTemplateDecl>(Template)? 0 :
3919         isa<FunctionTemplateDecl>(Template)? 1 :
3920         isa<TemplateTemplateParmDecl>(Template)? 2 : 3)
3921     << Template << Range;
3922   S.Diag(Template->getLocation(), diag::note_template_decl_here)
3923     << Params->getSourceRange();
3924   return true;
3925 }
3926
3927 /// \brief Check whether the template parameter is a pack expansion, and if so,
3928 /// determine the number of parameters produced by that expansion. For instance:
3929 ///
3930 /// \code
3931 /// template<typename ...Ts> struct A {
3932 ///   template<Ts ...NTs, template<Ts> class ...TTs, typename ...Us> struct B;
3933 /// };
3934 /// \endcode
3935 ///
3936 /// In \c A<int,int>::B, \c NTs and \c TTs have expanded pack size 2, and \c Us
3937 /// is not a pack expansion, so returns an empty Optional.
3938 static Optional<unsigned> getExpandedPackSize(NamedDecl *Param) {
3939   if (NonTypeTemplateParmDecl *NTTP
3940         = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
3941     if (NTTP->isExpandedParameterPack())
3942       return NTTP->getNumExpansionTypes();
3943   }
3944
3945   if (TemplateTemplateParmDecl *TTP
3946         = dyn_cast<TemplateTemplateParmDecl>(Param)) {
3947     if (TTP->isExpandedParameterPack())
3948       return TTP->getNumExpansionTemplateParameters();
3949   }
3950
3951   return None;
3952 }
3953
3954 /// Diagnose a missing template argument.
3955 template<typename TemplateParmDecl>
3956 static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc,
3957                                     TemplateDecl *TD,
3958                                     const TemplateParmDecl *D,
3959                                     TemplateArgumentListInfo &Args) {
3960   // Dig out the most recent declaration of the template parameter; there may be
3961   // declarations of the template that are more recent than TD.
3962   D = cast<TemplateParmDecl>(cast<TemplateDecl>(TD->getMostRecentDecl())
3963                                  ->getTemplateParameters()
3964                                  ->getParam(D->getIndex()));
3965
3966   // If there's a default argument that's not visible, diagnose that we're
3967   // missing a module import.
3968   llvm::SmallVector<Module*, 8> Modules;
3969   if (D->hasDefaultArgument() && !S.hasVisibleDefaultArgument(D, &Modules)) {
3970     S.diagnoseMissingImport(Loc, cast<NamedDecl>(TD),
3971                             D->getDefaultArgumentLoc(), Modules,
3972                             Sema::MissingImportKind::DefaultArgument,
3973                             /*Recover*/true);
3974     return true;
3975   }
3976
3977   // FIXME: If there's a more recent default argument that *is* visible,
3978   // diagnose that it was declared too late.
3979
3980   return diagnoseArityMismatch(S, TD, Loc, Args);
3981 }
3982
3983 /// \brief Check that the given template argument list is well-formed
3984 /// for specializing the given template.
3985 bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
3986                                      SourceLocation TemplateLoc,
3987                                      TemplateArgumentListInfo &TemplateArgs,
3988                                      bool PartialTemplateArgs,
3989                           SmallVectorImpl<TemplateArgument> &Converted) {
3990   // Make a copy of the template arguments for processing.  Only make the
3991   // changes at the end when successful in matching the arguments to the
3992   // template.
3993   TemplateArgumentListInfo NewArgs = TemplateArgs;
3994
3995   TemplateParameterList *Params = Template->getTemplateParameters();
3996
3997   SourceLocation RAngleLoc = NewArgs.getRAngleLoc();
3998
3999   // C++ [temp.arg]p1:
4000   //   [...] The type and form of each template-argument specified in
4001   //   a template-id shall match the type and form specified for the
4002   //   corresponding parameter declared by the template in its
4003   //   template-parameter-list.
4004   bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);
4005   SmallVector<TemplateArgument, 2> ArgumentPack;
4006   unsigned ArgIdx = 0, NumArgs = NewArgs.size();
4007   LocalInstantiationScope InstScope(*this, true);
4008   for (TemplateParameterList::iterator Param = Params->begin(),
4009                                        ParamEnd = Params->end();
4010        Param != ParamEnd; /* increment in loop */) {
4011     // If we have an expanded parameter pack, make sure we don't have too
4012     // many arguments.
4013     if (Optional<unsigned> Expansions = getExpandedPackSize(*Param)) {
4014       if (*Expansions == ArgumentPack.size()) {
4015         // We're done with this parameter pack. Pack up its arguments and add
4016         // them to the list.
4017         Converted.push_back(
4018             TemplateArgument::CreatePackCopy(Context, ArgumentPack));
4019         ArgumentPack.clear();
4020
4021         // This argument is assigned to the next parameter.
4022         ++Param;
4023         continue;
4024       } else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
4025         // Not enough arguments for this parameter pack.
4026         Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
4027           << false
4028           << (isa<ClassTemplateDecl>(Template)? 0 :
4029               isa<FunctionTemplateDecl>(Template)? 1 :
4030               isa<TemplateTemplateParmDecl>(Template)? 2 : 3)
4031           << Template;
4032         Diag(Template->getLocation(), diag::note_template_decl_here)
4033           << Params->getSourceRange();
4034         return true;
4035       }
4036     }
4037
4038     if (ArgIdx < NumArgs) {
4039       // Check the template argument we were given.
4040       if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template,
4041                                 TemplateLoc, RAngleLoc,
4042                                 ArgumentPack.size(), Converted))
4043         return true;
4044
4045       bool PackExpansionIntoNonPack =
4046           NewArgs[ArgIdx].getArgument().isPackExpansion() &&
4047           (!(*Param)->isTemplateParameterPack() || getExpandedPackSize(*Param));
4048       if (PackExpansionIntoNonPack && isa<TypeAliasTemplateDecl>(Template)) {
4049         // Core issue 1430: we have a pack expansion as an argument to an
4050         // alias template, and it's not part of a parameter pack. This
4051         // can't be canonicalized, so reject it now.
4052         Diag(NewArgs[ArgIdx].getLocation(),
4053              diag::err_alias_template_expansion_into_fixed_list)
4054           << NewArgs[ArgIdx].getSourceRange();
4055         Diag((*Param)->getLocation(), diag::note_template_param_here);
4056         return true;
4057       }
4058
4059       // We're now done with this argument.
4060       ++ArgIdx;
4061
4062       if ((*Param)->isTemplateParameterPack()) {
4063         // The template parameter was a template parameter pack, so take the
4064         // deduced argument and place it on the argument pack. Note that we
4065         // stay on the same template parameter so that we can deduce more
4066         // arguments.
4067         ArgumentPack.push_back(Converted.pop_back_val());
4068       } else {
4069         // Move to the next template parameter.
4070         ++Param;
4071       }
4072
4073       // If we just saw a pack expansion into a non-pack, then directly convert
4074       // the remaining arguments, because we don't know what parameters they'll
4075       // match up with.
4076       if (PackExpansionIntoNonPack) {
4077         if (!ArgumentPack.empty()) {
4078           // If we were part way through filling in an expanded parameter pack,
4079           // fall back to just producing individual arguments.
4080           Converted.insert(Converted.end(),
4081                            ArgumentPack.begin(), ArgumentPack.end());
4082           ArgumentPack.clear();
4083         }
4084
4085         while (ArgIdx < NumArgs) {
4086           Converted.push_back(NewArgs[ArgIdx].getArgument());
4087           ++ArgIdx;
4088         }
4089
4090         return false;
4091       }
4092
4093       continue;
4094     }
4095
4096     // If we're checking a partial template argument list, we're done.
4097     if (PartialTemplateArgs) {
4098       if ((*Param)->isTemplateParameterPack() && !ArgumentPack.empty())
4099         Converted.push_back(
4100             TemplateArgument::CreatePackCopy(Context, ArgumentPack));
4101
4102       return false;
4103     }
4104
4105     // If we have a template parameter pack with no more corresponding
4106     // arguments, just break out now and we'll fill in the argument pack below.
4107     if ((*Param)->isTemplateParameterPack()) {
4108       assert(!getExpandedPackSize(*Param) &&
4109              "Should have dealt with this already");
4110
4111       // A non-expanded parameter pack before the end of the parameter list
4112       // only occurs for an ill-formed template parameter list, unless we've
4113       // got a partial argument list for a function template, so just bail out.
4114       if (Param + 1 != ParamEnd)
4115         return true;
4116
4117       Converted.push_back(
4118           TemplateArgument::CreatePackCopy(Context, ArgumentPack));
4119       ArgumentPack.clear();
4120
4121       ++Param;
4122       continue;
4123     }
4124
4125     // Check whether we have a default argument.
4126     TemplateArgumentLoc Arg;
4127
4128     // Retrieve the default template argument from the template
4129     // parameter. For each kind of template parameter, we substitute the
4130     // template arguments provided thus far and any "outer" template arguments
4131     // (when the template parameter was part of a nested template) into
4132     // the default argument.
4133     if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
4134       if (!hasVisibleDefaultArgument(TTP))
4135         return diagnoseMissingArgument(*this, TemplateLoc, Template, TTP,
4136                                        NewArgs);
4137
4138       TypeSourceInfo *ArgType = SubstDefaultTemplateArgument(*this,
4139                                                              Template,
4140                                                              TemplateLoc,
4141                                                              RAngleLoc,
4142                                                              TTP,
4143                                                              Converted);
4144       if (!ArgType)
4145         return true;
4146
4147       Arg = TemplateArgumentLoc(TemplateArgument(ArgType->getType()),
4148                                 ArgType);
4149     } else if (NonTypeTemplateParmDecl *NTTP
4150                  = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
4151       if (!hasVisibleDefaultArgument(NTTP))
4152         return diagnoseMissingArgument(*this, TemplateLoc, Template, NTTP,
4153                                        NewArgs);
4154
4155       ExprResult E = SubstDefaultTemplateArgument(*this, Template,
4156                                                               TemplateLoc,
4157                                                               RAngleLoc,
4158                                                               NTTP,
4159                                                               Converted);
4160       if (E.isInvalid())
4161         return true;
4162
4163       Expr *Ex = E.getAs<Expr>();
4164       Arg = TemplateArgumentLoc(TemplateArgument(Ex), Ex);
4165     } else {
4166       TemplateTemplateParmDecl *TempParm
4167         = cast<TemplateTemplateParmDecl>(*Param);
4168
4169       if (!hasVisibleDefaultArgument(TempParm))
4170         return diagnoseMissingArgument(*this, TemplateLoc, Template, TempParm,
4171                                        NewArgs);
4172
4173       NestedNameSpecifierLoc QualifierLoc;
4174       TemplateName Name = SubstDefaultTemplateArgument(*this, Template,
4175                                                        TemplateLoc,
4176                                                        RAngleLoc,
4177                                                        TempParm,
4178                                                        Converted,
4179                                                        QualifierLoc);
4180       if (Name.isNull())
4181         return true;
4182
4183       Arg = TemplateArgumentLoc(TemplateArgument(Name), QualifierLoc,
4184                            TempParm->getDefaultArgument().getTemplateNameLoc());
4185     }
4186
4187     // Introduce an instantiation record that describes where we are using
4188     // the default template argument. We're not actually instantiating a
4189     // template here, we just create this object to put a note into the
4190     // context stack.
4191     InstantiatingTemplate Inst(*this, RAngleLoc, Template, *Param, Converted,
4192                                SourceRange(TemplateLoc, RAngleLoc));
4193     if (Inst.isInvalid())
4194       return true;
4195
4196     // Check the default template argument.
4197     if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc,
4198                               RAngleLoc, 0, Converted))
4199       return true;
4200
4201     // Core issue 150 (assumed resolution): if this is a template template
4202     // parameter, keep track of the default template arguments from the
4203     // template definition.
4204     if (isTemplateTemplateParameter)
4205       NewArgs.addArgument(Arg);
4206
4207     // Move to the next template parameter and argument.
4208     ++Param;
4209     ++ArgIdx;
4210   }
4211
4212   // If we're performing a partial argument substitution, allow any trailing
4213   // pack expansions; they might be empty. This can happen even if
4214   // PartialTemplateArgs is false (the list of arguments is complete but
4215   // still dependent).
4216   if (ArgIdx < NumArgs && CurrentInstantiationScope &&
4217       CurrentInstantiationScope->getPartiallySubstitutedPack()) {
4218     while (ArgIdx < NumArgs && NewArgs[ArgIdx].getArgument().isPackExpansion())
4219       Converted.push_back(NewArgs[ArgIdx++].getArgument());
4220   }
4221
4222   // If we have any leftover arguments, then there were too many arguments.
4223   // Complain and fail.
4224   if (ArgIdx < NumArgs)
4225     return diagnoseArityMismatch(*this, Template, TemplateLoc, NewArgs);
4226
4227   // No problems found with the new argument list, propagate changes back
4228   // to caller.
4229   TemplateArgs = std::move(NewArgs);
4230
4231   return false;
4232 }
4233
4234 namespace {
4235   class UnnamedLocalNoLinkageFinder
4236     : public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
4237   {
4238     Sema &S;
4239     SourceRange SR;
4240
4241     typedef TypeVisitor<UnnamedLocalNoLinkageFinder, bool> inherited;
4242
4243   public:
4244     UnnamedLocalNoLinkageFinder(Sema &S, SourceRange SR) : S(S), SR(SR) { }
4245
4246     bool Visit(QualType T) {
4247       return T.isNull() ? false : inherited::Visit(T.getTypePtr());
4248     }
4249
4250 #define TYPE(Class, Parent) \
4251     bool Visit##Class##Type(const Class##Type *);
4252 #define ABSTRACT_TYPE(Class, Parent) \
4253     bool Visit##Class##Type(const Class##Type *) { return false; }
4254 #define NON_CANONICAL_TYPE(Class, Parent) \
4255     bool Visit##Class##Type(const Class##Type *) { return false; }
4256 #include "clang/AST/TypeNodes.def"
4257
4258     bool VisitTagDecl(const TagDecl *Tag);
4259     bool VisitNestedNameSpecifier(NestedNameSpecifier *NNS);
4260   };
4261 } // end anonymous namespace
4262
4263 bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(const BuiltinType*) {
4264   return false;
4265 }
4266
4267 bool UnnamedLocalNoLinkageFinder::VisitComplexType(const ComplexType* T) {
4268   return Visit(T->getElementType());
4269 }
4270
4271 bool UnnamedLocalNoLinkageFinder::VisitPointerType(const PointerType* T) {
4272   return Visit(T->getPointeeType());
4273 }
4274
4275 bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
4276                                                     const BlockPointerType* T) {
4277   return Visit(T->getPointeeType());
4278 }
4279
4280 bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
4281                                                 const LValueReferenceType* T) {
4282   return Visit(T->getPointeeType());
4283 }
4284
4285 bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
4286                                                 const RValueReferenceType* T) {
4287   return Visit(T->getPointeeType());
4288 }
4289
4290 bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
4291                                                   const MemberPointerType* T) {
4292   return Visit(T->getPointeeType()) || Visit(QualType(T->getClass(), 0));
4293 }
4294
4295 bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
4296                                                   const ConstantArrayType* T) {
4297   return Visit(T->getElementType());
4298 }
4299
4300 bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
4301                                                  const IncompleteArrayType* T) {
4302   return Visit(T->getElementType());
4303 }
4304
4305 bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
4306                                                    const VariableArrayType* T) {
4307   return Visit(T->getElementType());
4308 }
4309
4310 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
4311                                             const DependentSizedArrayType* T) {
4312   return Visit(T->getElementType());
4313 }
4314
4315 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
4316                                          const DependentSizedExtVectorType* T) {
4317   return Visit(T->getElementType());
4318 }
4319
4320 bool UnnamedLocalNoLinkageFinder::VisitVectorType(const VectorType* T) {
4321   return Visit(T->getElementType());
4322 }
4323
4324 bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(const ExtVectorType* T) {
4325   return Visit(T->getElementType());
4326 }
4327
4328 bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
4329                                                   const FunctionProtoType* T) {
4330   for (const auto &A : T->param_types()) {
4331     if (Visit(A))
4332       return true;
4333   }
4334
4335   return Visit(T->getReturnType());
4336 }
4337
4338 bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
4339                                                const FunctionNoProtoType* T) {
4340   return Visit(T->getReturnType());
4341 }
4342
4343 bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
4344                                                   const UnresolvedUsingType*) {
4345   return false;
4346 }
4347
4348 bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(const TypeOfExprType*) {
4349   return false;
4350 }
4351
4352 bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(const TypeOfType* T) {
4353   return Visit(T->getUnderlyingType());
4354 }
4355
4356 bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(const DecltypeType*) {
4357   return false;
4358 }
4359
4360 bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
4361                                                     const UnaryTransformType*) {
4362   return false;
4363 }
4364
4365 bool UnnamedLocalNoLinkageFinder::VisitAutoType(const AutoType *T) {
4366   return Visit(T->getDeducedType());
4367 }
4368
4369 bool UnnamedLocalNoLinkageFinder::VisitRecordType(const RecordType* T) {
4370   return VisitTagDecl(T->getDecl());
4371 }
4372
4373 bool UnnamedLocalNoLinkageFinder::VisitEnumType(const EnumType* T) {
4374   return VisitTagDecl(T->getDecl());
4375 }
4376
4377 bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
4378                                                  const TemplateTypeParmType*) {
4379   return false;
4380 }
4381
4382 bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
4383                                         const SubstTemplateTypeParmPackType *) {
4384   return false;
4385 }
4386
4387 bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
4388                                             const TemplateSpecializationType*) {
4389   return false;
4390 }
4391
4392 bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
4393                                               const InjectedClassNameType* T) {
4394   return VisitTagDecl(T->getDecl());
4395 }
4396
4397 bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
4398                                                    const DependentNameType* T) {
4399   return VisitNestedNameSpecifier(T->getQualifier());
4400 }
4401
4402 bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
4403                                  const DependentTemplateSpecializationType* T) {
4404   return VisitNestedNameSpecifier(T->getQualifier());
4405 }
4406
4407 bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
4408                                                    const PackExpansionType* T) {
4409   return Visit(T->getPattern());
4410 }
4411
4412 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(const ObjCObjectType *) {
4413   return false;
4414 }
4415
4416 bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
4417                                                    const ObjCInterfaceType *) {
4418   return false;
4419 }
4420
4421 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
4422                                                 const ObjCObjectPointerType *) {
4423   return false;
4424 }
4425
4426 bool UnnamedLocalNoLinkageFinder::VisitAtomicType(const AtomicType* T) {
4427   return Visit(T->getValueType());
4428 }
4429
4430 bool UnnamedLocalNoLinkageFinder::VisitPipeType(const PipeType* T) {
4431   return false;
4432 }
4433
4434 bool UnnamedLocalNoLinkageFinder::VisitTagDecl(const TagDecl *Tag) {
4435   if (Tag->getDeclContext()->isFunctionOrMethod()) {
4436     S.Diag(SR.getBegin(),
4437            S.getLangOpts().CPlusPlus11 ?
4438              diag::warn_cxx98_compat_template_arg_local_type :
4439              diag::ext_template_arg_local_type)
4440       << S.Context.getTypeDeclType(Tag) << SR;
4441     return true;
4442   }
4443
4444   if (!Tag->hasNameForLinkage()) {
4445     S.Diag(SR.getBegin(),
4446            S.getLangOpts().CPlusPlus11 ?
4447              diag::warn_cxx98_compat_template_arg_unnamed_type :
4448              diag::ext_template_arg_unnamed_type) << SR;
4449     S.Diag(Tag->getLocation(), diag::note_template_unnamed_type_here);
4450     return true;
4451   }
4452
4453   return false;
4454 }
4455
4456 bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
4457                                                     NestedNameSpecifier *NNS) {
4458   if (NNS->getPrefix() && VisitNestedNameSpecifier(NNS->getPrefix()))
4459     return true;
4460
4461   switch (NNS->getKind()) {
4462   case NestedNameSpecifier::Identifier:
4463   case NestedNameSpecifier::Namespace:
4464   case NestedNameSpecifier::NamespaceAlias:
4465   case NestedNameSpecifier::Global:
4466   case NestedNameSpecifier::Super:
4467     return false;
4468
4469   case NestedNameSpecifier::TypeSpec:
4470   case NestedNameSpecifier::TypeSpecWithTemplate:
4471     return Visit(QualType(NNS->getAsType(), 0));
4472   }
4473   llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
4474 }
4475
4476 /// \brief Check a template argument against its corresponding
4477 /// template type parameter.
4478 ///
4479 /// This routine implements the semantics of C++ [temp.arg.type]. It
4480 /// returns true if an error occurred, and false otherwise.
4481 bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param,
4482                                  TypeSourceInfo *ArgInfo) {
4483   assert(ArgInfo && "invalid TypeSourceInfo");
4484   QualType Arg = ArgInfo->getType();
4485   SourceRange SR = ArgInfo->getTypeLoc().getSourceRange();
4486
4487   if (Arg->isVariablyModifiedType()) {
4488     return Diag(SR.getBegin(), diag::err_variably_modified_template_arg) << Arg;
4489   } else if (Context.hasSameUnqualifiedType(Arg, Context.OverloadTy)) {
4490     return Diag(SR.getBegin(), diag::err_template_arg_overload_type) << SR;
4491   }
4492
4493   // C++03 [temp.arg.type]p2:
4494   //   A local type, a type with no linkage, an unnamed type or a type
4495   //   compounded from any of these types shall not be used as a
4496   //   template-argument for a template type-parameter.
4497   //
4498   // C++11 allows these, and even in C++03 we allow them as an extension with
4499   // a warning.
4500   if (LangOpts.CPlusPlus11 || Arg->hasUnnamedOrLocalType()) {
4501     UnnamedLocalNoLinkageFinder Finder(*this, SR);
4502     (void)Finder.Visit(Context.getCanonicalType(Arg));
4503   }
4504
4505   return false;
4506 }
4507
4508 enum NullPointerValueKind {
4509   NPV_NotNullPointer,
4510   NPV_NullPointer,
4511   NPV_Error
4512 };
4513
4514 /// \brief Determine whether the given template argument is a null pointer
4515 /// value of the appropriate type.
4516 static NullPointerValueKind
4517 isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param,
4518                                    QualType ParamType, Expr *Arg) {
4519   if (Arg->isValueDependent() || Arg->isTypeDependent())
4520     return NPV_NotNullPointer;
4521
4522   if (!S.isCompleteType(Arg->getExprLoc(), ParamType))
4523     llvm_unreachable(
4524         "Incomplete parameter type in isNullPointerValueTemplateArgument!");
4525
4526   if (!S.getLangOpts().CPlusPlus11)
4527     return NPV_NotNullPointer;
4528
4529   // Determine whether we have a constant expression.
4530   ExprResult ArgRV = S.DefaultFunctionArrayConversion(Arg);
4531   if (ArgRV.isInvalid())
4532     return NPV_Error;
4533   Arg = ArgRV.get();
4534
4535   Expr::EvalResult EvalResult;
4536   SmallVector<PartialDiagnosticAt, 8> Notes;
4537   EvalResult.Diag = &Notes;
4538   if (!Arg->EvaluateAsRValue(EvalResult, S.Context) ||
4539       EvalResult.HasSideEffects) {
4540     SourceLocation DiagLoc = Arg->getExprLoc();
4541
4542     // If our only note is the usual "invalid subexpression" note, just point
4543     // the caret at its location rather than producing an essentially
4544     // redundant note.
4545     if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
4546         diag::note_invalid_subexpr_in_const_expr) {
4547       DiagLoc = Notes[0].first;
4548       Notes.clear();
4549     }
4550
4551     S.Diag(DiagLoc, diag::err_template_arg_not_address_constant)
4552       << Arg->getType() << Arg->getSourceRange();
4553     for (unsigned I = 0, N = Notes.size(); I != N; ++I)
4554       S.Diag(Notes[I].first, Notes[I].second);
4555
4556     S.Diag(Param->getLocation(), diag::note_template_param_here);
4557     return NPV_Error;
4558   }
4559
4560   // C++11 [temp.arg.nontype]p1:
4561   //   - an address constant expression of type std::nullptr_t
4562   if (Arg->getType()->isNullPtrType())
4563     return NPV_NullPointer;
4564
4565   //   - a constant expression that evaluates to a null pointer value (4.10); or
4566   //   - a constant expression that evaluates to a null member pointer value
4567   //     (4.11); or
4568   if ((EvalResult.Val.isLValue() && !EvalResult.Val.getLValueBase()) ||
4569       (EvalResult.Val.isMemberPointer() &&
4570        !EvalResult.Val.getMemberPointerDecl())) {
4571     // If our expression has an appropriate type, we've succeeded.
4572     bool ObjCLifetimeConversion;
4573     if (S.Context.hasSameUnqualifiedType(Arg->getType(), ParamType) ||
4574         S.IsQualificationConversion(Arg->getType(), ParamType, false,
4575                                      ObjCLifetimeConversion))
4576       return NPV_NullPointer;
4577
4578     // The types didn't match, but we know we got a null pointer; complain,
4579     // then recover as if the types were correct.
4580     S.Diag(Arg->getExprLoc(), diag::err_template_arg_wrongtype_null_constant)
4581       << Arg->getType() << ParamType << Arg->getSourceRange();
4582     S.Diag(Param->getLocation(), diag::note_template_param_here);
4583     return NPV_NullPointer;
4584   }
4585
4586   // If we don't have a null pointer value, but we do have a NULL pointer
4587   // constant, suggest a cast to the appropriate type.
4588   if (Arg->isNullPointerConstant(S.Context, Expr::NPC_NeverValueDependent)) {
4589     std::string Code = "static_cast<" + ParamType.getAsString() + ">(";
4590     S.Diag(Arg->getExprLoc(), diag::err_template_arg_untyped_null_constant)
4591         << ParamType << FixItHint::CreateInsertion(Arg->getLocStart(), Code)
4592         << FixItHint::CreateInsertion(S.getLocForEndOfToken(Arg->getLocEnd()),
4593                                       ")");
4594     S.Diag(Param->getLocation(), diag::note_template_param_here);
4595     return NPV_NullPointer;
4596   }
4597
4598   // FIXME: If we ever want to support general, address-constant expressions
4599   // as non-type template arguments, we should return the ExprResult here to
4600   // be interpreted by the caller.
4601   return NPV_NotNullPointer;
4602 }
4603
4604 /// \brief Checks whether the given template argument is compatible with its
4605 /// template parameter.
4606 static bool CheckTemplateArgumentIsCompatibleWithParameter(
4607     Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn,
4608     Expr *Arg, QualType ArgType) {
4609   bool ObjCLifetimeConversion;
4610   if (ParamType->isPointerType() &&
4611       !ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType() &&
4612       S.IsQualificationConversion(ArgType, ParamType, false,
4613                                   ObjCLifetimeConversion)) {
4614     // For pointer-to-object types, qualification conversions are
4615     // permitted.
4616   } else {
4617     if (const ReferenceType *ParamRef = ParamType->getAs<ReferenceType>()) {
4618       if (!ParamRef->getPointeeType()->isFunctionType()) {
4619         // C++ [temp.arg.nontype]p5b3:
4620         //   For a non-type template-parameter of type reference to
4621         //   object, no conversions apply. The type referred to by the
4622         //   reference may be more cv-qualified than the (otherwise
4623         //   identical) type of the template- argument. The
4624         //   template-parameter is bound directly to the
4625         //   template-argument, which shall be an lvalue.
4626
4627         // FIXME: Other qualifiers?
4628         unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();
4629         unsigned ArgQuals = ArgType.getCVRQualifiers();
4630
4631         if ((ParamQuals | ArgQuals) != ParamQuals) {
4632           S.Diag(Arg->getLocStart(),
4633                  diag::err_template_arg_ref_bind_ignores_quals)
4634             << ParamType << Arg->getType() << Arg->getSourceRange();
4635           S.Diag(Param->getLocation(), diag::note_template_param_here);
4636           return true;
4637         }
4638       }
4639     }
4640
4641     // At this point, the template argument refers to an object or
4642     // function with external linkage. We now need to check whether the
4643     // argument and parameter types are compatible.
4644     if (!S.Context.hasSameUnqualifiedType(ArgType,
4645                                           ParamType.getNonReferenceType())) {
4646       // We can't perform this conversion or binding.
4647       if (ParamType->isReferenceType())
4648         S.Diag(Arg->getLocStart(), diag::err_template_arg_no_ref_bind)
4649           << ParamType << ArgIn->getType() << Arg->getSourceRange();
4650       else
4651         S.Diag(Arg->getLocStart(),  diag::err_template_arg_not_convertible)
4652           << ArgIn->getType() << ParamType << Arg->getSourceRange();
4653       S.Diag(Param->getLocation(), diag::note_template_param_here);
4654       return true;
4655     }
4656   }
4657
4658   return false;
4659 }
4660
4661 /// \brief Checks whether the given template argument is the address
4662 /// of an object or function according to C++ [temp.arg.nontype]p1.
4663 static bool
4664 CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S,
4665                                                NonTypeTemplateParmDecl *Param,
4666                                                QualType ParamType,
4667                                                Expr *ArgIn,
4668                                                TemplateArgument &Converted) {
4669   bool Invalid = false;
4670   Expr *Arg = ArgIn;
4671   QualType ArgType = Arg->getType();
4672
4673   bool AddressTaken = false;
4674   SourceLocation AddrOpLoc;
4675   if (S.getLangOpts().MicrosoftExt) {
4676     // Microsoft Visual C++ strips all casts, allows an arbitrary number of
4677     // dereference and address-of operators.
4678     Arg = Arg->IgnoreParenCasts();
4679
4680     bool ExtWarnMSTemplateArg = false;
4681     UnaryOperatorKind FirstOpKind;
4682     SourceLocation FirstOpLoc;
4683     while (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
4684       UnaryOperatorKind UnOpKind = UnOp->getOpcode();
4685       if (UnOpKind == UO_Deref)
4686         ExtWarnMSTemplateArg = true;
4687       if (UnOpKind == UO_AddrOf || UnOpKind == UO_Deref) {
4688         Arg = UnOp->getSubExpr()->IgnoreParenCasts();
4689         if (!AddrOpLoc.isValid()) {
4690           FirstOpKind = UnOpKind;
4691           FirstOpLoc = UnOp->getOperatorLoc();
4692         }
4693       } else
4694         break;
4695     }
4696     if (FirstOpLoc.isValid()) {
4697       if (ExtWarnMSTemplateArg)
4698         S.Diag(ArgIn->getLocStart(), diag::ext_ms_deref_template_argument)
4699           << ArgIn->getSourceRange();
4700
4701       if (FirstOpKind == UO_AddrOf)
4702         AddressTaken = true;
4703       else if (Arg->getType()->isPointerType()) {
4704         // We cannot let pointers get dereferenced here, that is obviously not a
4705         // constant expression.
4706         assert(FirstOpKind == UO_Deref);
4707         S.Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
4708           << Arg->getSourceRange();
4709       }
4710     }
4711   } else {
4712     // See through any implicit casts we added to fix the type.
4713     Arg = Arg->IgnoreImpCasts();
4714
4715     // C++ [temp.arg.nontype]p1:
4716     //
4717     //   A template-argument for a non-type, non-template
4718     //   template-parameter shall be one of: [...]
4719     //
4720     //     -- the address of an object or function with external
4721     //        linkage, including function templates and function
4722     //        template-ids but excluding non-static class members,
4723     //        expressed as & id-expression where the & is optional if
4724     //        the name refers to a function or array, or if the
4725     //        corresponding template-parameter is a reference; or
4726
4727     // In C++98/03 mode, give an extension warning on any extra parentheses.
4728     // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
4729     bool ExtraParens = false;
4730     while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
4731       if (!Invalid && !ExtraParens) {
4732         S.Diag(Arg->getLocStart(),
4733                S.getLangOpts().CPlusPlus11
4734                    ? diag::warn_cxx98_compat_template_arg_extra_parens
4735                    : diag::ext_template_arg_extra_parens)
4736             << Arg->getSourceRange();
4737         ExtraParens = true;
4738       }
4739
4740       Arg = Parens->getSubExpr();
4741     }
4742
4743     while (SubstNonTypeTemplateParmExpr *subst =
4744                dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
4745       Arg = subst->getReplacement()->IgnoreImpCasts();
4746
4747     if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
4748       if (UnOp->getOpcode() == UO_AddrOf) {
4749         Arg = UnOp->getSubExpr();
4750         AddressTaken = true;
4751         AddrOpLoc = UnOp->getOperatorLoc();
4752       }
4753     }
4754
4755     while (SubstNonTypeTemplateParmExpr *subst =
4756                dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
4757       Arg = subst->getReplacement()->IgnoreImpCasts();
4758   }
4759
4760   DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg);
4761   ValueDecl *Entity = DRE ? DRE->getDecl() : nullptr;
4762
4763   // If our parameter has pointer type, check for a null template value.
4764   if (ParamType->isPointerType() || ParamType->isNullPtrType()) {
4765     NullPointerValueKind NPV;
4766     // dllimport'd entities aren't constant but are available inside of template
4767     // arguments.
4768     if (Entity && Entity->hasAttr<DLLImportAttr>())
4769       NPV = NPV_NotNullPointer;
4770     else
4771       NPV = isNullPointerValueTemplateArgument(S, Param, ParamType, ArgIn);
4772     switch (NPV) {
4773     case NPV_NullPointer:
4774       S.Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
4775       Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
4776                                    /*isNullPtr=*/true);
4777       return false;
4778
4779     case NPV_Error:
4780       return true;
4781
4782     case NPV_NotNullPointer:
4783       break;
4784     }
4785   }
4786
4787   // Stop checking the precise nature of the argument if it is value dependent,
4788   // it should be checked when instantiated.
4789   if (Arg->isValueDependent()) {
4790     Converted = TemplateArgument(ArgIn);
4791     return false;
4792   }
4793
4794   if (isa<CXXUuidofExpr>(Arg)) {
4795     if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType,
4796                                                        ArgIn, Arg, ArgType))
4797       return true;
4798
4799     Converted = TemplateArgument(ArgIn);
4800     return false;
4801   }
4802
4803   if (!DRE) {
4804     S.Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
4805     << Arg->getSourceRange();
4806     S.Diag(Param->getLocation(), diag::note_template_param_here);
4807     return true;
4808   }
4809
4810   // Cannot refer to non-static data members
4811   if (isa<FieldDecl>(Entity) || isa<IndirectFieldDecl>(Entity)) {
4812     S.Diag(Arg->getLocStart(), diag::err_template_arg_field)
4813       << Entity << Arg->getSourceRange();
4814     S.Diag(Param->getLocation(), diag::note_template_param_here);
4815     return true;
4816   }
4817
4818   // Cannot refer to non-static member functions
4819   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Entity)) {
4820     if (!Method->isStatic()) {
4821       S.Diag(Arg->getLocStart(), diag::err_template_arg_method)
4822         << Method << Arg->getSourceRange();
4823       S.Diag(Param->getLocation(), diag::note_template_param_here);
4824       return true;
4825     }
4826   }
4827
4828   FunctionDecl *Func = dyn_cast<FunctionDecl>(Entity);
4829   VarDecl *Var = dyn_cast<VarDecl>(Entity);
4830
4831   // A non-type template argument must refer to an object or function.
4832   if (!Func && !Var) {
4833     // We found something, but we don't know specifically what it is.
4834     S.Diag(Arg->getLocStart(), diag::err_template_arg_not_object_or_func)
4835       << Arg->getSourceRange();
4836     S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
4837     return true;
4838   }
4839
4840   // Address / reference template args must have external linkage in C++98.
4841   if (Entity->getFormalLinkage() == InternalLinkage) {
4842     S.Diag(Arg->getLocStart(), S.getLangOpts().CPlusPlus11 ?
4843              diag::warn_cxx98_compat_template_arg_object_internal :
4844              diag::ext_template_arg_object_internal)
4845       << !Func << Entity << Arg->getSourceRange();
4846     S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
4847       << !Func;
4848   } else if (!Entity->hasLinkage()) {
4849     S.Diag(Arg->getLocStart(), diag::err_template_arg_object_no_linkage)
4850       << !Func << Entity << Arg->getSourceRange();
4851     S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
4852       << !Func;
4853     return true;
4854   }
4855
4856   if (Func) {
4857     // If the template parameter has pointer type, the function decays.
4858     if (ParamType->isPointerType() && !AddressTaken)
4859       ArgType = S.Context.getPointerType(Func->getType());
4860     else if (AddressTaken && ParamType->isReferenceType()) {
4861       // If we originally had an address-of operator, but the
4862       // parameter has reference type, complain and (if things look
4863       // like they will work) drop the address-of operator.
4864       if (!S.Context.hasSameUnqualifiedType(Func->getType(),
4865                                             ParamType.getNonReferenceType())) {
4866         S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
4867           << ParamType;
4868         S.Diag(Param->getLocation(), diag::note_template_param_here);
4869         return true;
4870       }
4871
4872       S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
4873         << ParamType
4874         << FixItHint::CreateRemoval(AddrOpLoc);
4875       S.Diag(Param->getLocation(), diag::note_template_param_here);
4876
4877       ArgType = Func->getType();
4878     }
4879   } else {
4880     // A value of reference type is not an object.
4881     if (Var->getType()->isReferenceType()) {
4882       S.Diag(Arg->getLocStart(),
4883              diag::err_template_arg_reference_var)
4884         << Var->getType() << Arg->getSourceRange();
4885       S.Diag(Param->getLocation(), diag::note_template_param_here);
4886       return true;
4887     }
4888
4889     // A template argument must have static storage duration.
4890     if (Var->getTLSKind()) {
4891       S.Diag(Arg->getLocStart(), diag::err_template_arg_thread_local)
4892         << Arg->getSourceRange();
4893       S.Diag(Var->getLocation(), diag::note_template_arg_refers_here);
4894       return true;
4895     }
4896
4897     // If the template parameter has pointer type, we must have taken
4898     // the address of this object.
4899     if (ParamType->isReferenceType()) {
4900       if (AddressTaken) {
4901         // If we originally had an address-of operator, but the
4902         // parameter has reference type, complain and (if things look
4903         // like they will work) drop the address-of operator.
4904         if (!S.Context.hasSameUnqualifiedType(Var->getType(),
4905                                             ParamType.getNonReferenceType())) {
4906           S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
4907             << ParamType;
4908           S.Diag(Param->getLocation(), diag::note_template_param_here);
4909           return true;
4910         }
4911
4912         S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
4913           << ParamType
4914           << FixItHint::CreateRemoval(AddrOpLoc);
4915         S.Diag(Param->getLocation(), diag::note_template_param_here);
4916
4917         ArgType = Var->getType();
4918       }
4919     } else if (!AddressTaken && ParamType->isPointerType()) {
4920       if (Var->getType()->isArrayType()) {
4921         // Array-to-pointer decay.
4922         ArgType = S.Context.getArrayDecayedType(Var->getType());
4923       } else {
4924         // If the template parameter has pointer type but the address of
4925         // this object was not taken, complain and (possibly) recover by
4926         // taking the address of the entity.
4927         ArgType = S.Context.getPointerType(Var->getType());
4928         if (!S.Context.hasSameUnqualifiedType(ArgType, ParamType)) {
4929           S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of)
4930             << ParamType;
4931           S.Diag(Param->getLocation(), diag::note_template_param_here);
4932           return true;
4933         }
4934
4935         S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of)
4936           << ParamType
4937           << FixItHint::CreateInsertion(Arg->getLocStart(), "&");
4938
4939         S.Diag(Param->getLocation(), diag::note_template_param_here);
4940       }
4941     }
4942   }
4943
4944   if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType, ArgIn,
4945                                                      Arg, ArgType))
4946     return true;
4947
4948   // Create the template argument.
4949   Converted =
4950       TemplateArgument(cast<ValueDecl>(Entity->getCanonicalDecl()), ParamType);
4951   S.MarkAnyDeclReferenced(Arg->getLocStart(), Entity, false);
4952   return false;
4953 }
4954
4955 /// \brief Checks whether the given template argument is a pointer to
4956 /// member constant according to C++ [temp.arg.nontype]p1.
4957 static bool CheckTemplateArgumentPointerToMember(Sema &S,
4958                                                  NonTypeTemplateParmDecl *Param,
4959                                                  QualType ParamType,
4960                                                  Expr *&ResultArg,
4961                                                  TemplateArgument &Converted) {
4962   bool Invalid = false;
4963
4964   // Check for a null pointer value.
4965   Expr *Arg = ResultArg;
4966   switch (isNullPointerValueTemplateArgument(S, Param, ParamType, Arg)) {
4967   case NPV_Error:
4968     return true;
4969   case NPV_NullPointer:
4970     S.Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
4971     Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
4972                                  /*isNullPtr*/true);
4973     return false;
4974   case NPV_NotNullPointer:
4975     break;
4976   }
4977
4978   bool ObjCLifetimeConversion;
4979   if (S.IsQualificationConversion(Arg->getType(),
4980                                   ParamType.getNonReferenceType(),
4981                                   false, ObjCLifetimeConversion)) {
4982     Arg = S.ImpCastExprToType(Arg, ParamType, CK_NoOp,
4983                               Arg->getValueKind()).get();
4984     ResultArg = Arg;
4985   } else if (!S.Context.hasSameUnqualifiedType(Arg->getType(),
4986                 ParamType.getNonReferenceType())) {
4987     // We can't perform this conversion.
4988     S.Diag(Arg->getLocStart(), diag::err_template_arg_not_convertible)
4989       << Arg->getType() << ParamType << Arg->getSourceRange();
4990     S.Diag(Param->getLocation(), diag::note_template_param_here);
4991     return true;
4992   }
4993
4994   // See through any implicit casts we added to fix the type.
4995   while (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(Arg))
4996     Arg = Cast->getSubExpr();
4997
4998   // C++ [temp.arg.nontype]p1:
4999   //
5000   //   A template-argument for a non-type, non-template
5001   //   template-parameter shall be one of: [...]
5002   //
5003   //     -- a pointer to member expressed as described in 5.3.1.
5004   DeclRefExpr *DRE = nullptr;
5005
5006   // In C++98/03 mode, give an extension warning on any extra parentheses.
5007   // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
5008   bool ExtraParens = false;
5009   while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
5010     if (!Invalid && !ExtraParens) {
5011       S.Diag(Arg->getLocStart(),
5012              S.getLangOpts().CPlusPlus11 ?
5013                diag::warn_cxx98_compat_template_arg_extra_parens :
5014                diag::ext_template_arg_extra_parens)
5015         << Arg->getSourceRange();
5016       ExtraParens = true;
5017     }
5018
5019     Arg = Parens->getSubExpr();
5020   }
5021
5022   while (SubstNonTypeTemplateParmExpr *subst =
5023            dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
5024     Arg = subst->getReplacement()->IgnoreImpCasts();
5025
5026   // A pointer-to-member constant written &Class::member.
5027   if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
5028     if (UnOp->getOpcode() == UO_AddrOf) {
5029       DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr());
5030       if (DRE && !DRE->getQualifier())
5031         DRE = nullptr;
5032     }
5033   }
5034   // A constant of pointer-to-member type.
5035   else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) {
5036     if (ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl())) {
5037       if (VD->getType()->isMemberPointerType()) {
5038         if (isa<NonTypeTemplateParmDecl>(VD)) {
5039           if (Arg->isTypeDependent() || Arg->isValueDependent()) {
5040             Converted = TemplateArgument(Arg);
5041           } else {
5042             VD = cast<ValueDecl>(VD->getCanonicalDecl());
5043             Converted = TemplateArgument(VD, ParamType);
5044           }
5045           return Invalid;
5046         }
5047       }
5048     }
5049
5050     DRE = nullptr;
5051   }
5052
5053   if (!DRE)
5054     return S.Diag(Arg->getLocStart(),
5055                   diag::err_template_arg_not_pointer_to_member_form)
5056       << Arg->getSourceRange();
5057
5058   if (isa<FieldDecl>(DRE->getDecl()) ||
5059       isa<IndirectFieldDecl>(DRE->getDecl()) ||
5060       isa<CXXMethodDecl>(DRE->getDecl())) {
5061     assert((isa<FieldDecl>(DRE->getDecl()) ||
5062             isa<IndirectFieldDecl>(DRE->getDecl()) ||
5063             !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&
5064            "Only non-static member pointers can make it here");
5065
5066     // Okay: this is the address of a non-static member, and therefore
5067     // a member pointer constant.
5068     if (Arg->isTypeDependent() || Arg->isValueDependent()) {
5069       Converted = TemplateArgument(Arg);
5070     } else {
5071       ValueDecl *D = cast<ValueDecl>(DRE->getDecl()->getCanonicalDecl());
5072       Converted = TemplateArgument(D, ParamType);
5073     }
5074     return Invalid;
5075   }
5076
5077   // We found something else, but we don't know specifically what it is.
5078   S.Diag(Arg->getLocStart(),
5079          diag::err_template_arg_not_pointer_to_member_form)
5080     << Arg->getSourceRange();
5081   S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
5082   return true;
5083 }
5084
5085 /// \brief Check a template argument against its corresponding
5086 /// non-type template parameter.
5087 ///
5088 /// This routine implements the semantics of C++ [temp.arg.nontype].
5089 /// If an error occurred, it returns ExprError(); otherwise, it
5090 /// returns the converted template argument. \p ParamType is the
5091 /// type of the non-type template parameter after it has been instantiated.
5092 ExprResult Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
5093                                        QualType ParamType, Expr *Arg,
5094                                        TemplateArgument &Converted,
5095                                        CheckTemplateArgumentKind CTAK) {
5096   SourceLocation StartLoc = Arg->getLocStart();
5097
5098   // If the parameter type somehow involves auto, deduce the type now.
5099   if (getLangOpts().CPlusPlus1z && ParamType->isUndeducedType()) {
5100     // When checking a deduced template argument, deduce from its type even if
5101     // the type is dependent, in order to check the types of non-type template
5102     // arguments line up properly in partial ordering.
5103     Optional<unsigned> Depth;
5104     if (CTAK != CTAK_Specified)
5105       Depth = Param->getDepth() + 1;
5106     if (DeduceAutoType(
5107             Context.getTrivialTypeSourceInfo(ParamType, Param->getLocation()),
5108             Arg, ParamType, Depth) == DAR_Failed) {
5109       Diag(Arg->getExprLoc(),
5110            diag::err_non_type_template_parm_type_deduction_failure)
5111         << Param->getDeclName() << Param->getType() << Arg->getType()
5112         << Arg->getSourceRange();
5113       Diag(Param->getLocation(), diag::note_template_param_here);
5114       return ExprError();
5115     }
5116     // CheckNonTypeTemplateParameterType will produce a diagnostic if there's
5117     // an error. The error message normally references the parameter
5118     // declaration, but here we'll pass the argument location because that's
5119     // where the parameter type is deduced.
5120     ParamType = CheckNonTypeTemplateParameterType(ParamType, Arg->getExprLoc());
5121     if (ParamType.isNull()) {
5122       Diag(Param->getLocation(), diag::note_template_param_here);
5123       return ExprError();
5124     }
5125   }
5126
5127   // We should have already dropped all cv-qualifiers by now.
5128   assert(!ParamType.hasQualifiers() &&
5129          "non-type template parameter type cannot be qualified");
5130
5131   if (CTAK == CTAK_Deduced &&
5132       !Context.hasSameType(ParamType.getNonLValueExprType(Context),
5133                            Arg->getType())) {
5134     // C++ [temp.deduct.type]p17: (DR1770)
5135     //   If P has a form that contains <i>, and if the type of i differs from
5136     //   the type of the corresponding template parameter of the template named
5137     //   by the enclosing simple-template-id, deduction fails.
5138     //
5139     // Note that CTAK will be CTAK_DeducedFromArrayBound if the form was [i]
5140     // rather than <i>.
5141     //
5142     // FIXME: We interpret the 'i' here as referring to the expression
5143     // denoting the non-type template parameter rather than the parameter
5144     // itself, and so strip off references before comparing types. It's
5145     // not clear how this is supposed to work for references.
5146     Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)
5147       << Arg->getType()
5148       << ParamType.getUnqualifiedType();
5149     Diag(Param->getLocation(), diag::note_template_param_here);
5150     return ExprError();
5151   }
5152
5153   // If either the parameter has a dependent type or the argument is
5154   // type-dependent, there's nothing we can check now.
5155   if (ParamType->isDependentType() || Arg->isTypeDependent()) {
5156     // FIXME: Produce a cloned, canonical expression?
5157     Converted = TemplateArgument(Arg);
5158     return Arg;
5159   }
5160
5161   if (getLangOpts().CPlusPlus1z) {
5162     // C++1z [temp.arg.nontype]p1:
5163     //   A template-argument for a non-type template parameter shall be
5164     //   a converted constant expression of the type of the template-parameter.
5165     APValue Value;
5166     ExprResult ArgResult = CheckConvertedConstantExpression(
5167         Arg, ParamType, Value, CCEK_TemplateArg);
5168     if (ArgResult.isInvalid())
5169       return ExprError();
5170
5171     // For a value-dependent argument, CheckConvertedConstantExpression is
5172     // permitted (and expected) to be unable to determine a value.
5173     if (ArgResult.get()->isValueDependent()) {
5174       Converted = TemplateArgument(ArgResult.get());
5175       return ArgResult;
5176     }
5177
5178     QualType CanonParamType = Context.getCanonicalType(ParamType);
5179
5180     // Convert the APValue to a TemplateArgument.
5181     switch (Value.getKind()) {
5182     case APValue::Uninitialized:
5183       assert(ParamType->isNullPtrType());
5184       Converted = TemplateArgument(CanonParamType, /*isNullPtr*/true);
5185       break;
5186     case APValue::Int:
5187       assert(ParamType->isIntegralOrEnumerationType());
5188       Converted = TemplateArgument(Context, Value.getInt(), CanonParamType);
5189       break;
5190     case APValue::MemberPointer: {
5191       assert(ParamType->isMemberPointerType());
5192
5193       // FIXME: We need TemplateArgument representation and mangling for these.
5194       if (!Value.getMemberPointerPath().empty()) {
5195         Diag(Arg->getLocStart(),
5196              diag::err_template_arg_member_ptr_base_derived_not_supported)
5197             << Value.getMemberPointerDecl() << ParamType
5198             << Arg->getSourceRange();
5199         return ExprError();
5200       }
5201
5202       auto *VD = const_cast<ValueDecl*>(Value.getMemberPointerDecl());
5203       Converted = VD ? TemplateArgument(VD, CanonParamType)
5204                      : TemplateArgument(CanonParamType, /*isNullPtr*/true);
5205       break;
5206     }
5207     case APValue::LValue: {
5208       //   For a non-type template-parameter of pointer or reference type,
5209       //   the value of the constant expression shall not refer to
5210       assert(ParamType->isPointerType() || ParamType->isReferenceType() ||
5211              ParamType->isNullPtrType());
5212       // -- a temporary object
5213       // -- a string literal
5214       // -- the result of a typeid expression, or
5215       // -- a predefind __func__ variable
5216       if (auto *E = Value.getLValueBase().dyn_cast<const Expr*>()) {
5217         if (isa<CXXUuidofExpr>(E)) {
5218           Converted = TemplateArgument(const_cast<Expr*>(E));
5219           break;
5220         }
5221         Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
5222           << Arg->getSourceRange();
5223         return ExprError();
5224       }
5225       auto *VD = const_cast<ValueDecl *>(
5226           Value.getLValueBase().dyn_cast<const ValueDecl *>());
5227       // -- a subobject
5228       if (Value.hasLValuePath() && Value.getLValuePath().size() == 1 &&
5229           VD && VD->getType()->isArrayType() &&
5230           Value.getLValuePath()[0].ArrayIndex == 0 &&
5231           !Value.isLValueOnePastTheEnd() && ParamType->isPointerType()) {
5232         // Per defect report (no number yet):
5233         //   ... other than a pointer to the first element of a complete array
5234         //       object.
5235       } else if (!Value.hasLValuePath() || Value.getLValuePath().size() ||
5236                  Value.isLValueOnePastTheEnd()) {
5237         Diag(StartLoc, diag::err_non_type_template_arg_subobject)
5238           << Value.getAsString(Context, ParamType);
5239         return ExprError();
5240       }
5241       assert((VD || !ParamType->isReferenceType()) &&
5242              "null reference should not be a constant expression");
5243       assert((!VD || !ParamType->isNullPtrType()) &&
5244              "non-null value of type nullptr_t?");
5245       Converted = VD ? TemplateArgument(VD, CanonParamType)
5246                      : TemplateArgument(CanonParamType, /*isNullPtr*/true);
5247       break;
5248     }
5249     case APValue::AddrLabelDiff:
5250       return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
5251     case APValue::Float:
5252     case APValue::ComplexInt:
5253     case APValue::ComplexFloat:
5254     case APValue::Vector:
5255     case APValue::Array:
5256     case APValue::Struct:
5257     case APValue::Union:
5258       llvm_unreachable("invalid kind for template argument");
5259     }
5260
5261     return ArgResult.get();
5262   }
5263
5264   // C++ [temp.arg.nontype]p5:
5265   //   The following conversions are performed on each expression used
5266   //   as a non-type template-argument. If a non-type
5267   //   template-argument cannot be converted to the type of the
5268   //   corresponding template-parameter then the program is
5269   //   ill-formed.
5270   if (ParamType->isIntegralOrEnumerationType()) {
5271     // C++11:
5272     //   -- for a non-type template-parameter of integral or
5273     //      enumeration type, conversions permitted in a converted
5274     //      constant expression are applied.
5275     //
5276     // C++98:
5277     //   -- for a non-type template-parameter of integral or
5278     //      enumeration type, integral promotions (4.5) and integral
5279     //      conversions (4.7) are applied.
5280
5281     if (getLangOpts().CPlusPlus11) {
5282       // C++ [temp.arg.nontype]p1:
5283       //   A template-argument for a non-type, non-template template-parameter
5284       //   shall be one of:
5285       //
5286       //     -- for a non-type template-parameter of integral or enumeration
5287       //        type, a converted constant expression of the type of the
5288       //        template-parameter; or
5289       llvm::APSInt Value;
5290       ExprResult ArgResult =
5291         CheckConvertedConstantExpression(Arg, ParamType, Value,
5292                                          CCEK_TemplateArg);
5293       if (ArgResult.isInvalid())
5294         return ExprError();
5295
5296       // We can't check arbitrary value-dependent arguments.
5297       if (ArgResult.get()->isValueDependent()) {
5298         Converted = TemplateArgument(ArgResult.get());
5299         return ArgResult;
5300       }
5301
5302       // Widen the argument value to sizeof(parameter type). This is almost
5303       // always a no-op, except when the parameter type is bool. In
5304       // that case, this may extend the argument from 1 bit to 8 bits.
5305       QualType IntegerType = ParamType;
5306       if (const EnumType *Enum = IntegerType->getAs<EnumType>())
5307         IntegerType = Enum->getDecl()->getIntegerType();
5308       Value = Value.extOrTrunc(Context.getTypeSize(IntegerType));
5309
5310       Converted = TemplateArgument(Context, Value,
5311                                    Context.getCanonicalType(ParamType));
5312       return ArgResult;
5313     }
5314
5315     ExprResult ArgResult = DefaultLvalueConversion(Arg);
5316     if (ArgResult.isInvalid())
5317       return ExprError();
5318     Arg = ArgResult.get();
5319
5320     QualType ArgType = Arg->getType();
5321
5322     // C++ [temp.arg.nontype]p1:
5323     //   A template-argument for a non-type, non-template
5324     //   template-parameter shall be one of:
5325     //
5326     //     -- an integral constant-expression of integral or enumeration
5327     //        type; or
5328     //     -- the name of a non-type template-parameter; or
5329     SourceLocation NonConstantLoc;
5330     llvm::APSInt Value;
5331     if (!ArgType->isIntegralOrEnumerationType()) {
5332       Diag(Arg->getLocStart(),
5333            diag::err_template_arg_not_integral_or_enumeral)
5334         << ArgType << Arg->getSourceRange();
5335       Diag(Param->getLocation(), diag::note_template_param_here);
5336       return ExprError();
5337     } else if (!Arg->isValueDependent()) {
5338       class TmplArgICEDiagnoser : public VerifyICEDiagnoser {
5339         QualType T;
5340
5341       public:
5342         TmplArgICEDiagnoser(QualType T) : T(T) { }
5343
5344         void diagnoseNotICE(Sema &S, SourceLocation Loc,
5345                             SourceRange SR) override {
5346           S.Diag(Loc, diag::err_template_arg_not_ice) << T << SR;
5347         }
5348       } Diagnoser(ArgType);
5349
5350       Arg = VerifyIntegerConstantExpression(Arg, &Value, Diagnoser,
5351                                             false).get();
5352       if (!Arg)
5353         return ExprError();
5354     }
5355
5356     // From here on out, all we care about is the unqualified form
5357     // of the argument type.
5358     ArgType = ArgType.getUnqualifiedType();
5359
5360     // Try to convert the argument to the parameter's type.
5361     if (Context.hasSameType(ParamType, ArgType)) {
5362       // Okay: no conversion necessary
5363     } else if (ParamType->isBooleanType()) {
5364       // This is an integral-to-boolean conversion.
5365       Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralToBoolean).get();
5366     } else if (IsIntegralPromotion(Arg, ArgType, ParamType) ||
5367                !ParamType->isEnumeralType()) {
5368       // This is an integral promotion or conversion.
5369       Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralCast).get();
5370     } else {
5371       // We can't perform this conversion.
5372       Diag(Arg->getLocStart(),
5373            diag::err_template_arg_not_convertible)
5374         << Arg->getType() << ParamType << Arg->getSourceRange();
5375       Diag(Param->getLocation(), diag::note_template_param_here);
5376       return ExprError();
5377     }
5378
5379     // Add the value of this argument to the list of converted
5380     // arguments. We use the bitwidth and signedness of the template
5381     // parameter.
5382     if (Arg->isValueDependent()) {
5383       // The argument is value-dependent. Create a new
5384       // TemplateArgument with the converted expression.
5385       Converted = TemplateArgument(Arg);
5386       return Arg;
5387     }
5388
5389     QualType IntegerType = Context.getCanonicalType(ParamType);
5390     if (const EnumType *Enum = IntegerType->getAs<EnumType>())
5391       IntegerType = Context.getCanonicalType(Enum->getDecl()->getIntegerType());
5392
5393     if (ParamType->isBooleanType()) {
5394       // Value must be zero or one.
5395       Value = Value != 0;
5396       unsigned AllowedBits = Context.getTypeSize(IntegerType);
5397       if (Value.getBitWidth() != AllowedBits)
5398         Value = Value.extOrTrunc(AllowedBits);
5399       Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
5400     } else {
5401       llvm::APSInt OldValue = Value;
5402
5403       // Coerce the template argument's value to the value it will have
5404       // based on the template parameter's type.
5405       unsigned AllowedBits = Context.getTypeSize(IntegerType);
5406       if (Value.getBitWidth() != AllowedBits)
5407         Value = Value.extOrTrunc(AllowedBits);
5408       Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
5409
5410       // Complain if an unsigned parameter received a negative value.
5411       if (IntegerType->isUnsignedIntegerOrEnumerationType()
5412                && (OldValue.isSigned() && OldValue.isNegative())) {
5413         Diag(Arg->getLocStart(), diag::warn_template_arg_negative)
5414           << OldValue.toString(10) << Value.toString(10) << Param->getType()
5415           << Arg->getSourceRange();
5416         Diag(Param->getLocation(), diag::note_template_param_here);
5417       }
5418
5419       // Complain if we overflowed the template parameter's type.
5420       unsigned RequiredBits;
5421       if (IntegerType->isUnsignedIntegerOrEnumerationType())
5422         RequiredBits = OldValue.getActiveBits();
5423       else if (OldValue.isUnsigned())
5424         RequiredBits = OldValue.getActiveBits() + 1;
5425       else
5426         RequiredBits = OldValue.getMinSignedBits();
5427       if (RequiredBits > AllowedBits) {
5428         Diag(Arg->getLocStart(),
5429              diag::warn_template_arg_too_large)
5430           << OldValue.toString(10) << Value.toString(10) << Param->getType()
5431           << Arg->getSourceRange();
5432         Diag(Param->getLocation(), diag::note_template_param_here);
5433       }
5434     }
5435
5436     Converted = TemplateArgument(Context, Value,
5437                                  ParamType->isEnumeralType()
5438                                    ? Context.getCanonicalType(ParamType)
5439                                    : IntegerType);
5440     return Arg;
5441   }
5442
5443   QualType ArgType = Arg->getType();
5444   DeclAccessPair FoundResult; // temporary for ResolveOverloadedFunction
5445
5446   // Handle pointer-to-function, reference-to-function, and
5447   // pointer-to-member-function all in (roughly) the same way.
5448   if (// -- For a non-type template-parameter of type pointer to
5449       //    function, only the function-to-pointer conversion (4.3) is
5450       //    applied. If the template-argument represents a set of
5451       //    overloaded functions (or a pointer to such), the matching
5452       //    function is selected from the set (13.4).
5453       (ParamType->isPointerType() &&
5454        ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType()) ||
5455       // -- For a non-type template-parameter of type reference to
5456       //    function, no conversions apply. If the template-argument
5457       //    represents a set of overloaded functions, the matching
5458       //    function is selected from the set (13.4).
5459       (ParamType->isReferenceType() &&
5460        ParamType->getAs<ReferenceType>()->getPointeeType()->isFunctionType()) ||
5461       // -- For a non-type template-parameter of type pointer to
5462       //    member function, no conversions apply. If the
5463       //    template-argument represents a set of overloaded member
5464       //    functions, the matching member function is selected from
5465       //    the set (13.4).
5466       (ParamType->isMemberPointerType() &&
5467        ParamType->getAs<MemberPointerType>()->getPointeeType()
5468          ->isFunctionType())) {
5469
5470     if (Arg->getType() == Context.OverloadTy) {
5471       if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg, ParamType,
5472                                                                 true,
5473                                                                 FoundResult)) {
5474         if (DiagnoseUseOfDecl(Fn, Arg->getLocStart()))
5475           return ExprError();
5476
5477         Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
5478         ArgType = Arg->getType();
5479       } else
5480         return ExprError();
5481     }
5482
5483     if (!ParamType->isMemberPointerType()) {
5484       if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
5485                                                          ParamType,
5486                                                          Arg, Converted))
5487         return ExprError();
5488       return Arg;
5489     }
5490
5491     if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
5492                                              Converted))
5493       return ExprError();
5494     return Arg;
5495   }
5496
5497   if (ParamType->isPointerType()) {
5498     //   -- for a non-type template-parameter of type pointer to
5499     //      object, qualification conversions (4.4) and the
5500     //      array-to-pointer conversion (4.2) are applied.
5501     // C++0x also allows a value of std::nullptr_t.
5502     assert(ParamType->getPointeeType()->isIncompleteOrObjectType() &&
5503            "Only object pointers allowed here");
5504
5505     if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
5506                                                        ParamType,
5507                                                        Arg, Converted))
5508       return ExprError();
5509     return Arg;
5510   }
5511
5512   if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) {
5513     //   -- For a non-type template-parameter of type reference to
5514     //      object, no conversions apply. The type referred to by the
5515     //      reference may be more cv-qualified than the (otherwise
5516     //      identical) type of the template-argument. The
5517     //      template-parameter is bound directly to the
5518     //      template-argument, which must be an lvalue.
5519     assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&
5520            "Only object references allowed here");
5521
5522     if (Arg->getType() == Context.OverloadTy) {
5523       if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg,
5524                                                  ParamRefType->getPointeeType(),
5525                                                                 true,
5526                                                                 FoundResult)) {
5527         if (DiagnoseUseOfDecl(Fn, Arg->getLocStart()))
5528           return ExprError();
5529
5530         Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
5531         ArgType = Arg->getType();
5532       } else
5533         return ExprError();
5534     }
5535
5536     if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
5537                                                        ParamType,
5538                                                        Arg, Converted))
5539       return ExprError();
5540     return Arg;
5541   }
5542
5543   // Deal with parameters of type std::nullptr_t.
5544   if (ParamType->isNullPtrType()) {
5545     if (Arg->isTypeDependent() || Arg->isValueDependent()) {
5546       Converted = TemplateArgument(Arg);
5547       return Arg;
5548     }
5549
5550     switch (isNullPointerValueTemplateArgument(*this, Param, ParamType, Arg)) {
5551     case NPV_NotNullPointer:
5552       Diag(Arg->getExprLoc(), diag::err_template_arg_not_convertible)
5553         << Arg->getType() << ParamType;
5554       Diag(Param->getLocation(), diag::note_template_param_here);
5555       return ExprError();
5556
5557     case NPV_Error:
5558       return ExprError();
5559
5560     case NPV_NullPointer:
5561       Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
5562       Converted = TemplateArgument(Context.getCanonicalType(ParamType),
5563                                    /*isNullPtr*/true);
5564       return Arg;
5565     }
5566   }
5567
5568   //     -- For a non-type template-parameter of type pointer to data
5569   //        member, qualification conversions (4.4) are applied.
5570   assert(ParamType->isMemberPointerType() && "Only pointers to members remain");
5571
5572   if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
5573                                            Converted))
5574     return ExprError();
5575   return Arg;
5576 }
5577
5578 static void DiagnoseTemplateParameterListArityMismatch(
5579     Sema &S, TemplateParameterList *New, TemplateParameterList *Old,
5580     Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc);
5581
5582 /// \brief Check a template argument against its corresponding
5583 /// template template parameter.
5584 ///
5585 /// This routine implements the semantics of C++ [temp.arg.template].
5586 /// It returns true if an error occurred, and false otherwise.
5587 bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param,
5588                                  TemplateArgumentLoc &Arg,
5589                                  unsigned ArgumentPackIndex) {
5590   TemplateName Name = Arg.getArgument().getAsTemplateOrTemplatePattern();
5591   TemplateDecl *Template = Name.getAsTemplateDecl();
5592   if (!Template) {
5593     // Any dependent template name is fine.
5594     assert(Name.isDependent() && "Non-dependent template isn't a declaration?");
5595     return false;
5596   }
5597
5598   if (Template->isInvalidDecl())
5599     return true;
5600
5601   // C++0x [temp.arg.template]p1:
5602   //   A template-argument for a template template-parameter shall be
5603   //   the name of a class template or an alias template, expressed as an
5604   //   id-expression. When the template-argument names a class template, only
5605   //   primary class templates are considered when matching the
5606   //   template template argument with the corresponding parameter;
5607   //   partial specializations are not considered even if their
5608   //   parameter lists match that of the template template parameter.
5609   //
5610   // Note that we also allow template template parameters here, which
5611   // will happen when we are dealing with, e.g., class template
5612   // partial specializations.
5613   if (!isa<ClassTemplateDecl>(Template) &&
5614       !isa<TemplateTemplateParmDecl>(Template) &&
5615       !isa<TypeAliasTemplateDecl>(Template) &&
5616       !isa<BuiltinTemplateDecl>(Template)) {
5617     assert(isa<FunctionTemplateDecl>(Template) &&
5618            "Only function templates are possible here");
5619     Diag(Arg.getLocation(), diag::err_template_arg_not_valid_template);
5620     Diag(Template->getLocation(), diag::note_template_arg_refers_here_func)
5621       << Template;
5622   }
5623
5624   TemplateParameterList *Params = Param->getTemplateParameters();
5625   if (Param->isExpandedParameterPack())
5626     Params = Param->getExpansionTemplateParameters(ArgumentPackIndex);
5627
5628   // C++1z [temp.arg.template]p3: (DR 150)
5629   //   A template-argument matches a template template-parameter P when P
5630   //   is at least as specialized as the template-argument A.
5631   if (getLangOpts().RelaxedTemplateTemplateArgs) {
5632     // Quick check for the common case:
5633     //   If P contains a parameter pack, then A [...] matches P if each of A's
5634     //   template parameters matches the corresponding template parameter in
5635     //   the template-parameter-list of P.
5636     if (TemplateParameterListsAreEqual(
5637             Template->getTemplateParameters(), Params, false,
5638             TPL_TemplateTemplateArgumentMatch, Arg.getLocation()))
5639       return false;
5640
5641     if (isTemplateTemplateParameterAtLeastAsSpecializedAs(Params, Template,
5642                                                           Arg.getLocation()))
5643       return false;
5644     // FIXME: Produce better diagnostics for deduction failures.
5645   }
5646
5647   return !TemplateParameterListsAreEqual(Template->getTemplateParameters(),
5648                                          Params,
5649                                          true,
5650                                          TPL_TemplateTemplateArgumentMatch,
5651                                          Arg.getLocation());
5652 }
5653
5654 /// \brief Given a non-type template argument that refers to a
5655 /// declaration and the type of its corresponding non-type template
5656 /// parameter, produce an expression that properly refers to that
5657 /// declaration.
5658 ExprResult
5659 Sema::BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
5660                                               QualType ParamType,
5661                                               SourceLocation Loc) {
5662   // C++ [temp.param]p8:
5663   //
5664   //   A non-type template-parameter of type "array of T" or
5665   //   "function returning T" is adjusted to be of type "pointer to
5666   //   T" or "pointer to function returning T", respectively.
5667   if (ParamType->isArrayType())
5668     ParamType = Context.getArrayDecayedType(ParamType);
5669   else if (ParamType->isFunctionType())
5670     ParamType = Context.getPointerType(ParamType);
5671
5672   // For a NULL non-type template argument, return nullptr casted to the
5673   // parameter's type.
5674   if (Arg.getKind() == TemplateArgument::NullPtr) {
5675     return ImpCastExprToType(
5676              new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc),
5677                              ParamType,
5678                              ParamType->getAs<MemberPointerType>()
5679                                ? CK_NullToMemberPointer
5680                                : CK_NullToPointer);
5681   }
5682   assert(Arg.getKind() == TemplateArgument::Declaration &&
5683          "Only declaration template arguments permitted here");
5684
5685   ValueDecl *VD = cast<ValueDecl>(Arg.getAsDecl());
5686
5687   if (VD->getDeclContext()->isRecord() &&
5688       (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD) ||
5689        isa<IndirectFieldDecl>(VD))) {
5690     // If the value is a class member, we might have a pointer-to-member.
5691     // Determine whether the non-type template template parameter is of
5692     // pointer-to-member type. If so, we need to build an appropriate
5693     // expression for a pointer-to-member, since a "normal" DeclRefExpr
5694     // would refer to the member itself.
5695     if (ParamType->isMemberPointerType()) {
5696       QualType ClassType
5697         = Context.getTypeDeclType(cast<RecordDecl>(VD->getDeclContext()));
5698       NestedNameSpecifier *Qualifier
5699         = NestedNameSpecifier::Create(Context, nullptr, false,
5700                                       ClassType.getTypePtr());
5701       CXXScopeSpec SS;
5702       SS.MakeTrivial(Context, Qualifier, Loc);
5703
5704       // The actual value-ness of this is unimportant, but for
5705       // internal consistency's sake, references to instance methods
5706       // are r-values.
5707       ExprValueKind VK = VK_LValue;
5708       if (isa<CXXMethodDecl>(VD) && cast<CXXMethodDecl>(VD)->isInstance())
5709         VK = VK_RValue;
5710
5711       ExprResult RefExpr = BuildDeclRefExpr(VD,
5712                                             VD->getType().getNonReferenceType(),
5713                                             VK,
5714                                             Loc,
5715                                             &SS);
5716       if (RefExpr.isInvalid())
5717         return ExprError();
5718
5719       RefExpr = CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
5720
5721       // We might need to perform a trailing qualification conversion, since
5722       // the element type on the parameter could be more qualified than the
5723       // element type in the expression we constructed.
5724       bool ObjCLifetimeConversion;
5725       if (IsQualificationConversion(((Expr*) RefExpr.get())->getType(),
5726                                     ParamType.getUnqualifiedType(), false,
5727                                     ObjCLifetimeConversion))
5728         RefExpr = ImpCastExprToType(RefExpr.get(), ParamType.getUnqualifiedType(), CK_NoOp);
5729
5730       assert(!RefExpr.isInvalid() &&
5731              Context.hasSameType(((Expr*) RefExpr.get())->getType(),
5732                                  ParamType.getUnqualifiedType()));
5733       return RefExpr;
5734     }
5735   }
5736
5737   QualType T = VD->getType().getNonReferenceType();
5738
5739   if (ParamType->isPointerType()) {
5740     // When the non-type template parameter is a pointer, take the
5741     // address of the declaration.
5742     ExprResult RefExpr = BuildDeclRefExpr(VD, T, VK_LValue, Loc);
5743     if (RefExpr.isInvalid())
5744       return ExprError();
5745
5746     if (T->isFunctionType() || T->isArrayType()) {
5747       // Decay functions and arrays.
5748       RefExpr = DefaultFunctionArrayConversion(RefExpr.get());
5749       if (RefExpr.isInvalid())
5750         return ExprError();
5751
5752       return RefExpr;
5753     }
5754
5755     // Take the address of everything else
5756     return CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
5757   }
5758
5759   ExprValueKind VK = VK_RValue;
5760
5761   // If the non-type template parameter has reference type, qualify the
5762   // resulting declaration reference with the extra qualifiers on the
5763   // type that the reference refers to.
5764   if (const ReferenceType *TargetRef = ParamType->getAs<ReferenceType>()) {
5765     VK = VK_LValue;
5766     T = Context.getQualifiedType(T,
5767                               TargetRef->getPointeeType().getQualifiers());
5768   } else if (isa<FunctionDecl>(VD)) {
5769     // References to functions are always lvalues.
5770     VK = VK_LValue;
5771   }
5772
5773   return BuildDeclRefExpr(VD, T, VK, Loc);
5774 }
5775
5776 /// \brief Construct a new expression that refers to the given
5777 /// integral template argument with the given source-location
5778 /// information.
5779 ///
5780 /// This routine takes care of the mapping from an integral template
5781 /// argument (which may have any integral type) to the appropriate
5782 /// literal value.
5783 ExprResult
5784 Sema::BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
5785                                                   SourceLocation Loc) {
5786   assert(Arg.getKind() == TemplateArgument::Integral &&
5787          "Operation is only valid for integral template arguments");
5788   QualType OrigT = Arg.getIntegralType();
5789
5790   // If this is an enum type that we're instantiating, we need to use an integer
5791   // type the same size as the enumerator.  We don't want to build an
5792   // IntegerLiteral with enum type.  The integer type of an enum type can be of
5793   // any integral type with C++11 enum classes, make sure we create the right
5794   // type of literal for it.
5795   QualType T = OrigT;
5796   if (const EnumType *ET = OrigT->getAs<EnumType>())
5797     T = ET->getDecl()->getIntegerType();
5798
5799   Expr *E;
5800   if (T->isAnyCharacterType()) {
5801     // This does not need to handle u8 character literals because those are
5802     // of type char, and so can also be covered by an ASCII character literal.
5803     CharacterLiteral::CharacterKind Kind;
5804     if (T->isWideCharType())
5805       Kind = CharacterLiteral::Wide;
5806     else if (T->isChar16Type())
5807       Kind = CharacterLiteral::UTF16;
5808     else if (T->isChar32Type())
5809       Kind = CharacterLiteral::UTF32;
5810     else
5811       Kind = CharacterLiteral::Ascii;
5812
5813     E = new (Context) CharacterLiteral(Arg.getAsIntegral().getZExtValue(),
5814                                        Kind, T, Loc);
5815   } else if (T->isBooleanType()) {
5816     E = new (Context) CXXBoolLiteralExpr(Arg.getAsIntegral().getBoolValue(),
5817                                          T, Loc);
5818   } else if (T->isNullPtrType()) {
5819     E = new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc);
5820   } else {
5821     E = IntegerLiteral::Create(Context, Arg.getAsIntegral(), T, Loc);
5822   }
5823
5824   if (OrigT->isEnumeralType()) {
5825     // FIXME: This is a hack. We need a better way to handle substituted
5826     // non-type template parameters.
5827     E = CStyleCastExpr::Create(Context, OrigT, VK_RValue, CK_IntegralCast, E,
5828                                nullptr,
5829                                Context.getTrivialTypeSourceInfo(OrigT, Loc),
5830                                Loc, Loc);
5831   }
5832
5833   return E;
5834 }
5835
5836 /// \brief Match two template parameters within template parameter lists.
5837 static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, NamedDecl *Old,
5838                                        bool Complain,
5839                                      Sema::TemplateParameterListEqualKind Kind,
5840                                        SourceLocation TemplateArgLoc) {
5841   // Check the actual kind (type, non-type, template).
5842   if (Old->getKind() != New->getKind()) {
5843     if (Complain) {
5844       unsigned NextDiag = diag::err_template_param_different_kind;
5845       if (TemplateArgLoc.isValid()) {
5846         S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
5847         NextDiag = diag::note_template_param_different_kind;
5848       }
5849       S.Diag(New->getLocation(), NextDiag)
5850         << (Kind != Sema::TPL_TemplateMatch);
5851       S.Diag(Old->getLocation(), diag::note_template_prev_declaration)
5852         << (Kind != Sema::TPL_TemplateMatch);
5853     }
5854
5855     return false;
5856   }
5857
5858   // Check that both are parameter packs or neither are parameter packs.
5859   // However, if we are matching a template template argument to a
5860   // template template parameter, the template template parameter can have
5861   // a parameter pack where the template template argument does not.
5862   if (Old->isTemplateParameterPack() != New->isTemplateParameterPack() &&
5863       !(Kind == Sema::TPL_TemplateTemplateArgumentMatch &&
5864         Old->isTemplateParameterPack())) {
5865     if (Complain) {
5866       unsigned NextDiag = diag::err_template_parameter_pack_non_pack;
5867       if (TemplateArgLoc.isValid()) {
5868         S.Diag(TemplateArgLoc,
5869              diag::err_template_arg_template_params_mismatch);
5870         NextDiag = diag::note_template_parameter_pack_non_pack;
5871       }
5872
5873       unsigned ParamKind = isa<TemplateTypeParmDecl>(New)? 0
5874                       : isa<NonTypeTemplateParmDecl>(New)? 1
5875                       : 2;
5876       S.Diag(New->getLocation(), NextDiag)
5877         << ParamKind << New->isParameterPack();
5878       S.Diag(Old->getLocation(), diag::note_template_parameter_pack_here)
5879         << ParamKind << Old->isParameterPack();
5880     }
5881
5882     return false;
5883   }
5884
5885   // For non-type template parameters, check the type of the parameter.
5886   if (NonTypeTemplateParmDecl *OldNTTP
5887                                     = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
5888     NonTypeTemplateParmDecl *NewNTTP = cast<NonTypeTemplateParmDecl>(New);
5889
5890     // If we are matching a template template argument to a template
5891     // template parameter and one of the non-type template parameter types
5892     // is dependent, then we must wait until template instantiation time
5893     // to actually compare the arguments.
5894     if (Kind == Sema::TPL_TemplateTemplateArgumentMatch &&
5895         (OldNTTP->getType()->isDependentType() ||
5896          NewNTTP->getType()->isDependentType()))
5897       return true;
5898
5899     if (!S.Context.hasSameType(OldNTTP->getType(), NewNTTP->getType())) {
5900       if (Complain) {
5901         unsigned NextDiag = diag::err_template_nontype_parm_different_type;
5902         if (TemplateArgLoc.isValid()) {
5903           S.Diag(TemplateArgLoc,
5904                  diag::err_template_arg_template_params_mismatch);
5905           NextDiag = diag::note_template_nontype_parm_different_type;
5906         }
5907         S.Diag(NewNTTP->getLocation(), NextDiag)
5908           << NewNTTP->getType()
5909           << (Kind != Sema::TPL_TemplateMatch);
5910         S.Diag(OldNTTP->getLocation(),
5911                diag::note_template_nontype_parm_prev_declaration)
5912           << OldNTTP->getType();
5913       }
5914
5915       return false;
5916     }
5917
5918     return true;
5919   }
5920
5921   // For template template parameters, check the template parameter types.
5922   // The template parameter lists of template template
5923   // parameters must agree.
5924   if (TemplateTemplateParmDecl *OldTTP
5925                                     = dyn_cast<TemplateTemplateParmDecl>(Old)) {
5926     TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(New);
5927     return S.TemplateParameterListsAreEqual(NewTTP->getTemplateParameters(),
5928                                             OldTTP->getTemplateParameters(),
5929                                             Complain,
5930                                         (Kind == Sema::TPL_TemplateMatch
5931                                            ? Sema::TPL_TemplateTemplateParmMatch
5932                                            : Kind),
5933                                             TemplateArgLoc);
5934   }
5935
5936   return true;
5937 }
5938
5939 /// \brief Diagnose a known arity mismatch when comparing template argument
5940 /// lists.
5941 static
5942 void DiagnoseTemplateParameterListArityMismatch(Sema &S,
5943                                                 TemplateParameterList *New,
5944                                                 TemplateParameterList *Old,
5945                                       Sema::TemplateParameterListEqualKind Kind,
5946                                                 SourceLocation TemplateArgLoc) {
5947   unsigned NextDiag = diag::err_template_param_list_different_arity;
5948   if (TemplateArgLoc.isValid()) {
5949     S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
5950     NextDiag = diag::note_template_param_list_different_arity;
5951   }
5952   S.Diag(New->getTemplateLoc(), NextDiag)
5953     << (New->size() > Old->size())
5954     << (Kind != Sema::TPL_TemplateMatch)
5955     << SourceRange(New->getTemplateLoc(), New->getRAngleLoc());
5956   S.Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration)
5957     << (Kind != Sema::TPL_TemplateMatch)
5958     << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc());
5959 }
5960
5961 /// \brief Determine whether the given template parameter lists are
5962 /// equivalent.
5963 ///
5964 /// \param New  The new template parameter list, typically written in the
5965 /// source code as part of a new template declaration.
5966 ///
5967 /// \param Old  The old template parameter list, typically found via
5968 /// name lookup of the template declared with this template parameter
5969 /// list.
5970 ///
5971 /// \param Complain  If true, this routine will produce a diagnostic if
5972 /// the template parameter lists are not equivalent.
5973 ///
5974 /// \param Kind describes how we are to match the template parameter lists.
5975 ///
5976 /// \param TemplateArgLoc If this source location is valid, then we
5977 /// are actually checking the template parameter list of a template
5978 /// argument (New) against the template parameter list of its
5979 /// corresponding template template parameter (Old). We produce
5980 /// slightly different diagnostics in this scenario.
5981 ///
5982 /// \returns True if the template parameter lists are equal, false
5983 /// otherwise.
5984 bool
5985 Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
5986                                      TemplateParameterList *Old,
5987                                      bool Complain,
5988                                      TemplateParameterListEqualKind Kind,
5989                                      SourceLocation TemplateArgLoc) {
5990   if (Old->size() != New->size() && Kind != TPL_TemplateTemplateArgumentMatch) {
5991     if (Complain)
5992       DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
5993                                                  TemplateArgLoc);
5994
5995     return false;
5996   }
5997
5998   // C++0x [temp.arg.template]p3:
5999   //   A template-argument matches a template template-parameter (call it P)
6000   //   when each of the template parameters in the template-parameter-list of
6001   //   the template-argument's corresponding class template or alias template
6002   //   (call it A) matches the corresponding template parameter in the
6003   //   template-parameter-list of P. [...]
6004   TemplateParameterList::iterator NewParm = New->begin();
6005   TemplateParameterList::iterator NewParmEnd = New->end();
6006   for (TemplateParameterList::iterator OldParm = Old->begin(),
6007                                     OldParmEnd = Old->end();
6008        OldParm != OldParmEnd; ++OldParm) {
6009     if (Kind != TPL_TemplateTemplateArgumentMatch ||
6010         !(*OldParm)->isTemplateParameterPack()) {
6011       if (NewParm == NewParmEnd) {
6012         if (Complain)
6013           DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
6014                                                      TemplateArgLoc);
6015
6016         return false;
6017       }
6018
6019       if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
6020                                       Kind, TemplateArgLoc))
6021         return false;
6022
6023       ++NewParm;
6024       continue;
6025     }
6026
6027     // C++0x [temp.arg.template]p3:
6028     //   [...] When P's template- parameter-list contains a template parameter
6029     //   pack (14.5.3), the template parameter pack will match zero or more
6030     //   template parameters or template parameter packs in the
6031     //   template-parameter-list of A with the same type and form as the
6032     //   template parameter pack in P (ignoring whether those template
6033     //   parameters are template parameter packs).
6034     for (; NewParm != NewParmEnd; ++NewParm) {
6035       if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
6036                                       Kind, TemplateArgLoc))
6037         return false;
6038     }
6039   }
6040
6041   // Make sure we exhausted all of the arguments.
6042   if (NewParm != NewParmEnd) {
6043     if (Complain)
6044       DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
6045                                                  TemplateArgLoc);
6046
6047     return false;
6048   }
6049
6050   return true;
6051 }
6052
6053 /// \brief Check whether a template can be declared within this scope.
6054 ///
6055 /// If the template declaration is valid in this scope, returns
6056 /// false. Otherwise, issues a diagnostic and returns true.
6057 bool
6058 Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) {
6059   if (!S)
6060     return false;
6061
6062   // Find the nearest enclosing declaration scope.
6063   while ((S->getFlags() & Scope::DeclScope) == 0 ||
6064          (S->getFlags() & Scope::TemplateParamScope) != 0)
6065     S = S->getParent();
6066
6067   // C++ [temp]p4:
6068   //   A template [...] shall not have C linkage.
6069   DeclContext *Ctx = S->getEntity();
6070   if (Ctx && Ctx->isExternCContext()) {
6071     Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage)
6072         << TemplateParams->getSourceRange();
6073     if (const LinkageSpecDecl *LSD = Ctx->getExternCContext())
6074       Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
6075     return true;
6076   }
6077   Ctx = Ctx->getRedeclContext();
6078
6079   // C++ [temp]p2:
6080   //   A template-declaration can appear only as a namespace scope or
6081   //   class scope declaration.
6082   if (Ctx) {
6083     if (Ctx->isFileContext())
6084       return false;
6085     if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Ctx)) {
6086       // C++ [temp.mem]p2:
6087       //   A local class shall not have member templates.
6088       if (RD->isLocalClass())
6089         return Diag(TemplateParams->getTemplateLoc(),
6090                     diag::err_template_inside_local_class)
6091           << TemplateParams->getSourceRange();
6092       else
6093         return false;
6094     }
6095   }
6096
6097   return Diag(TemplateParams->getTemplateLoc(),
6098               diag::err_template_outside_namespace_or_class_scope)
6099     << TemplateParams->getSourceRange();
6100 }
6101
6102 /// \brief Determine what kind of template specialization the given declaration
6103 /// is.
6104 static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D) {
6105   if (!D)
6106     return TSK_Undeclared;
6107
6108   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D))
6109     return Record->getTemplateSpecializationKind();
6110   if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D))
6111     return Function->getTemplateSpecializationKind();
6112   if (VarDecl *Var = dyn_cast<VarDecl>(D))
6113     return Var->getTemplateSpecializationKind();
6114
6115   return TSK_Undeclared;
6116 }
6117
6118 /// \brief Check whether a specialization is well-formed in the current
6119 /// context.
6120 ///
6121 /// This routine determines whether a template specialization can be declared
6122 /// in the current context (C++ [temp.expl.spec]p2).
6123 ///
6124 /// \param S the semantic analysis object for which this check is being
6125 /// performed.
6126 ///
6127 /// \param Specialized the entity being specialized or instantiated, which
6128 /// may be a kind of template (class template, function template, etc.) or
6129 /// a member of a class template (member function, static data member,
6130 /// member class).
6131 ///
6132 /// \param PrevDecl the previous declaration of this entity, if any.
6133 ///
6134 /// \param Loc the location of the explicit specialization or instantiation of
6135 /// this entity.
6136 ///
6137 /// \param IsPartialSpecialization whether this is a partial specialization of
6138 /// a class template.
6139 ///
6140 /// \returns true if there was an error that we cannot recover from, false
6141 /// otherwise.
6142 static bool CheckTemplateSpecializationScope(Sema &S,
6143                                              NamedDecl *Specialized,
6144                                              NamedDecl *PrevDecl,
6145                                              SourceLocation Loc,
6146                                              bool IsPartialSpecialization) {
6147   // Keep these "kind" numbers in sync with the %select statements in the
6148   // various diagnostics emitted by this routine.
6149   int EntityKind = 0;
6150   if (isa<ClassTemplateDecl>(Specialized))
6151     EntityKind = IsPartialSpecialization? 1 : 0;
6152   else if (isa<VarTemplateDecl>(Specialized))
6153     EntityKind = IsPartialSpecialization ? 3 : 2;
6154   else if (isa<FunctionTemplateDecl>(Specialized))
6155     EntityKind = 4;
6156   else if (isa<CXXMethodDecl>(Specialized))
6157     EntityKind = 5;
6158   else if (isa<VarDecl>(Specialized))
6159     EntityKind = 6;
6160   else if (isa<RecordDecl>(Specialized))
6161     EntityKind = 7;
6162   else if (isa<EnumDecl>(Specialized) && S.getLangOpts().CPlusPlus11)
6163     EntityKind = 8;
6164   else {
6165     S.Diag(Loc, diag::err_template_spec_unknown_kind)
6166       << S.getLangOpts().CPlusPlus11;
6167     S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
6168     return true;
6169   }
6170
6171   // C++ [temp.expl.spec]p2:
6172   //   An explicit specialization shall be declared in the namespace
6173   //   of which the template is a member, or, for member templates, in
6174   //   the namespace of which the enclosing class or enclosing class
6175   //   template is a member. An explicit specialization of a member
6176   //   function, member class or static data member of a class
6177   //   template shall be declared in the namespace of which the class
6178   //   template is a member. Such a declaration may also be a
6179   //   definition. If the declaration is not a definition, the
6180   //   specialization may be defined later in the name- space in which
6181   //   the explicit specialization was declared, or in a namespace
6182   //   that encloses the one in which the explicit specialization was
6183   //   declared.
6184   if (S.CurContext->getRedeclContext()->isFunctionOrMethod()) {
6185     S.Diag(Loc, diag::err_template_spec_decl_function_scope)
6186       << Specialized;
6187     return true;
6188   }
6189
6190   if (S.CurContext->isRecord() && !IsPartialSpecialization) {
6191     if (S.getLangOpts().MicrosoftExt) {
6192       // Do not warn for class scope explicit specialization during
6193       // instantiation, warning was already emitted during pattern
6194       // semantic analysis.
6195       if (!S.ActiveTemplateInstantiations.size())
6196         S.Diag(Loc, diag::ext_function_specialization_in_class)
6197           << Specialized;
6198     } else {
6199       S.Diag(Loc, diag::err_template_spec_decl_class_scope)
6200         << Specialized;
6201       return true;
6202     }
6203   }
6204
6205   if (S.CurContext->isRecord() &&
6206       !S.CurContext->Equals(Specialized->getDeclContext())) {
6207     // Make sure that we're specializing in the right record context.
6208     // Otherwise, things can go horribly wrong.
6209     S.Diag(Loc, diag::err_template_spec_decl_class_scope)
6210       << Specialized;
6211     return true;
6212   }
6213
6214   // C++ [temp.class.spec]p6:
6215   //   A class template partial specialization may be declared or redeclared
6216   //   in any namespace scope in which its definition may be defined (14.5.1
6217   //   and 14.5.2).
6218   DeclContext *SpecializedContext
6219     = Specialized->getDeclContext()->getEnclosingNamespaceContext();
6220   DeclContext *DC = S.CurContext->getEnclosingNamespaceContext();
6221
6222   // Make sure that this redeclaration (or definition) occurs in an enclosing
6223   // namespace.
6224   // Note that HandleDeclarator() performs this check for explicit
6225   // specializations of function templates, static data members, and member
6226   // functions, so we skip the check here for those kinds of entities.
6227   // FIXME: HandleDeclarator's diagnostics aren't quite as good, though.
6228   // Should we refactor that check, so that it occurs later?
6229   if (!DC->Encloses(SpecializedContext) &&
6230       !(isa<FunctionTemplateDecl>(Specialized) ||
6231         isa<FunctionDecl>(Specialized) ||
6232         isa<VarTemplateDecl>(Specialized) ||
6233         isa<VarDecl>(Specialized))) {
6234     if (isa<TranslationUnitDecl>(SpecializedContext))
6235       S.Diag(Loc, diag::err_template_spec_redecl_global_scope)
6236         << EntityKind << Specialized;
6237     else if (isa<NamespaceDecl>(SpecializedContext)) {
6238       int Diag = diag::err_template_spec_redecl_out_of_scope;
6239       if (S.getLangOpts().MicrosoftExt)
6240         Diag = diag::ext_ms_template_spec_redecl_out_of_scope;
6241       S.Diag(Loc, Diag) << EntityKind << Specialized
6242                         << cast<NamedDecl>(SpecializedContext);
6243     } else
6244       llvm_unreachable("unexpected namespace context for specialization");
6245
6246     S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
6247   } else if ((!PrevDecl ||
6248               getTemplateSpecializationKind(PrevDecl) == TSK_Undeclared ||
6249               getTemplateSpecializationKind(PrevDecl) ==
6250                   TSK_ImplicitInstantiation)) {
6251     // C++ [temp.exp.spec]p2:
6252     //   An explicit specialization shall be declared in the namespace of which
6253     //   the template is a member, or, for member templates, in the namespace
6254     //   of which the enclosing class or enclosing class template is a member.
6255     //   An explicit specialization of a member function, member class or
6256     //   static data member of a class template shall be declared in the
6257     //   namespace of which the class template is a member.
6258     //
6259     // C++11 [temp.expl.spec]p2:
6260     //   An explicit specialization shall be declared in a namespace enclosing
6261     //   the specialized template.
6262     // C++11 [temp.explicit]p3:
6263     //   An explicit instantiation shall appear in an enclosing namespace of its
6264     //   template.
6265     if (!DC->InEnclosingNamespaceSetOf(SpecializedContext)) {
6266       bool IsCPlusPlus11Extension = DC->Encloses(SpecializedContext);
6267       if (isa<TranslationUnitDecl>(SpecializedContext)) {
6268         assert(!IsCPlusPlus11Extension &&
6269                "DC encloses TU but isn't in enclosing namespace set");
6270         S.Diag(Loc, diag::err_template_spec_decl_out_of_scope_global)
6271           << EntityKind << Specialized;
6272       } else if (isa<NamespaceDecl>(SpecializedContext)) {
6273         int Diag;
6274         if (!IsCPlusPlus11Extension)
6275           Diag = diag::err_template_spec_decl_out_of_scope;
6276         else if (!S.getLangOpts().CPlusPlus11)
6277           Diag = diag::ext_template_spec_decl_out_of_scope;
6278         else
6279           Diag = diag::warn_cxx98_compat_template_spec_decl_out_of_scope;
6280         S.Diag(Loc, Diag)
6281           << EntityKind << Specialized << cast<NamedDecl>(SpecializedContext);
6282       }
6283
6284       S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
6285     }
6286   }
6287
6288   return false;
6289 }
6290
6291 static SourceRange findTemplateParameterInType(unsigned Depth, Expr *E) {
6292   if (!E->isTypeDependent())
6293     return SourceLocation();
6294   DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
6295   Checker.TraverseStmt(E);
6296   if (Checker.MatchLoc.isInvalid())
6297     return E->getSourceRange();
6298   return Checker.MatchLoc;
6299 }
6300
6301 static SourceRange findTemplateParameter(unsigned Depth, TypeLoc TL) {
6302   if (!TL.getType()->isDependentType())
6303     return SourceLocation();
6304   DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
6305   Checker.TraverseTypeLoc(TL);
6306   if (Checker.MatchLoc.isInvalid())
6307     return TL.getSourceRange();
6308   return Checker.MatchLoc;
6309 }
6310
6311 /// \brief Subroutine of Sema::CheckTemplatePartialSpecializationArgs
6312 /// that checks non-type template partial specialization arguments.
6313 static bool CheckNonTypeTemplatePartialSpecializationArgs(
6314     Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param,
6315     const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument) {
6316   for (unsigned I = 0; I != NumArgs; ++I) {
6317     if (Args[I].getKind() == TemplateArgument::Pack) {
6318       if (CheckNonTypeTemplatePartialSpecializationArgs(
6319               S, TemplateNameLoc, Param, Args[I].pack_begin(),
6320               Args[I].pack_size(), IsDefaultArgument))
6321         return true;
6322
6323       continue;
6324     }
6325
6326     if (Args[I].getKind() != TemplateArgument::Expression)
6327       continue;
6328
6329     Expr *ArgExpr = Args[I].getAsExpr();
6330
6331     // We can have a pack expansion of any of the bullets below.
6332     if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(ArgExpr))
6333       ArgExpr = Expansion->getPattern();
6334
6335     // Strip off any implicit casts we added as part of type checking.
6336     while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
6337       ArgExpr = ICE->getSubExpr();
6338
6339     // C++ [temp.class.spec]p8:
6340     //   A non-type argument is non-specialized if it is the name of a
6341     //   non-type parameter. All other non-type arguments are
6342     //   specialized.
6343     //
6344     // Below, we check the two conditions that only apply to
6345     // specialized non-type arguments, so skip any non-specialized
6346     // arguments.
6347     if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
6348       if (isa<NonTypeTemplateParmDecl>(DRE->getDecl()))
6349         continue;
6350
6351     // C++ [temp.class.spec]p9:
6352     //   Within the argument list of a class template partial
6353     //   specialization, the following restrictions apply:
6354     //     -- A partially specialized non-type argument expression
6355     //        shall not involve a template parameter of the partial
6356     //        specialization except when the argument expression is a
6357     //        simple identifier.
6358     //     -- The type of a template parameter corresponding to a
6359     //        specialized non-type argument shall not be dependent on a
6360     //        parameter of the specialization.
6361     // DR1315 removes the first bullet, leaving an incoherent set of rules.
6362     // We implement a compromise between the original rules and DR1315:
6363     //     --  A specialized non-type template argument shall not be
6364     //         type-dependent and the corresponding template parameter
6365     //         shall have a non-dependent type.
6366     SourceRange ParamUseRange =
6367         findTemplateParameterInType(Param->getDepth(), ArgExpr);
6368     if (ParamUseRange.isValid()) {
6369       if (IsDefaultArgument) {
6370         S.Diag(TemplateNameLoc,
6371                diag::err_dependent_non_type_arg_in_partial_spec);
6372         S.Diag(ParamUseRange.getBegin(),
6373                diag::note_dependent_non_type_default_arg_in_partial_spec)
6374           << ParamUseRange;
6375       } else {
6376         S.Diag(ParamUseRange.getBegin(),
6377                diag::err_dependent_non_type_arg_in_partial_spec)
6378           << ParamUseRange;
6379       }
6380       return true;
6381     }
6382
6383     ParamUseRange = findTemplateParameter(
6384         Param->getDepth(), Param->getTypeSourceInfo()->getTypeLoc());
6385     if (ParamUseRange.isValid()) {
6386       S.Diag(IsDefaultArgument ? TemplateNameLoc : ArgExpr->getLocStart(),
6387              diag::err_dependent_typed_non_type_arg_in_partial_spec)
6388         << Param->getType();
6389       S.Diag(Param->getLocation(), diag::note_template_param_here)
6390         << (IsDefaultArgument ? ParamUseRange : SourceRange())
6391         << ParamUseRange;
6392       return true;
6393     }
6394   }
6395
6396   return false;
6397 }
6398
6399 /// \brief Check the non-type template arguments of a class template
6400 /// partial specialization according to C++ [temp.class.spec]p9.
6401 ///
6402 /// \param TemplateNameLoc the location of the template name.
6403 /// \param PrimaryTemplate the template parameters of the primary class
6404 ///        template.
6405 /// \param NumExplicit the number of explicitly-specified template arguments.
6406 /// \param TemplateArgs the template arguments of the class template
6407 ///        partial specialization.
6408 ///
6409 /// \returns \c true if there was an error, \c false otherwise.
6410 bool Sema::CheckTemplatePartialSpecializationArgs(
6411     SourceLocation TemplateNameLoc, TemplateDecl *PrimaryTemplate,
6412     unsigned NumExplicit, ArrayRef<TemplateArgument> TemplateArgs) {
6413   // We have to be conservative when checking a template in a dependent
6414   // context.
6415   if (PrimaryTemplate->getDeclContext()->isDependentContext())
6416     return false;
6417
6418   TemplateParameterList *TemplateParams =
6419       PrimaryTemplate->getTemplateParameters();
6420   for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
6421     NonTypeTemplateParmDecl *Param
6422       = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(I));
6423     if (!Param)
6424       continue;
6425
6426     if (CheckNonTypeTemplatePartialSpecializationArgs(*this, TemplateNameLoc,
6427                                                       Param, &TemplateArgs[I],
6428                                                       1, I >= NumExplicit))
6429       return true;
6430   }
6431
6432   return false;
6433 }
6434
6435 DeclResult
6436 Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
6437                                        TagUseKind TUK,
6438                                        SourceLocation KWLoc,
6439                                        SourceLocation ModulePrivateLoc,
6440                                        TemplateIdAnnotation &TemplateId,
6441                                        AttributeList *Attr,
6442                                        MultiTemplateParamsArg
6443                                            TemplateParameterLists,
6444                                        SkipBodyInfo *SkipBody) {
6445   assert(TUK != TUK_Reference && "References are not specializations");
6446
6447   CXXScopeSpec &SS = TemplateId.SS;
6448
6449   // NOTE: KWLoc is the location of the tag keyword. This will instead
6450   // store the location of the outermost template keyword in the declaration.
6451   SourceLocation TemplateKWLoc = TemplateParameterLists.size() > 0
6452     ? TemplateParameterLists[0]->getTemplateLoc() : KWLoc;
6453   SourceLocation TemplateNameLoc = TemplateId.TemplateNameLoc;
6454   SourceLocation LAngleLoc = TemplateId.LAngleLoc;
6455   SourceLocation RAngleLoc = TemplateId.RAngleLoc;
6456
6457   // Find the class template we're specializing
6458   TemplateName Name = TemplateId.Template.get();
6459   ClassTemplateDecl *ClassTemplate
6460     = dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl());
6461
6462   if (!ClassTemplate) {
6463     Diag(TemplateNameLoc, diag::err_not_class_template_specialization)
6464       << (Name.getAsTemplateDecl() &&
6465           isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()));
6466     return true;
6467   }
6468
6469   bool isExplicitSpecialization = false;
6470   bool isPartialSpecialization = false;
6471
6472   // Check the validity of the template headers that introduce this
6473   // template.
6474   // FIXME: We probably shouldn't complain about these headers for
6475   // friend declarations.
6476   bool Invalid = false;
6477   TemplateParameterList *TemplateParams =
6478       MatchTemplateParametersToScopeSpecifier(
6479           KWLoc, TemplateNameLoc, SS, &TemplateId,
6480           TemplateParameterLists, TUK == TUK_Friend, isExplicitSpecialization,
6481           Invalid);
6482   if (Invalid)
6483     return true;
6484
6485   if (TemplateParams && TemplateParams->size() > 0) {
6486     isPartialSpecialization = true;
6487
6488     if (TUK == TUK_Friend) {
6489       Diag(KWLoc, diag::err_partial_specialization_friend)
6490         << SourceRange(LAngleLoc, RAngleLoc);
6491       return true;
6492     }
6493
6494     // C++ [temp.class.spec]p10:
6495     //   The template parameter list of a specialization shall not
6496     //   contain default template argument values.
6497     for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
6498       Decl *Param = TemplateParams->getParam(I);
6499       if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
6500         if (TTP->hasDefaultArgument()) {
6501           Diag(TTP->getDefaultArgumentLoc(),
6502                diag::err_default_arg_in_partial_spec);
6503           TTP->removeDefaultArgument();
6504         }
6505       } else if (NonTypeTemplateParmDecl *NTTP
6506                    = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
6507         if (Expr *DefArg = NTTP->getDefaultArgument()) {
6508           Diag(NTTP->getDefaultArgumentLoc(),
6509                diag::err_default_arg_in_partial_spec)
6510             << DefArg->getSourceRange();
6511           NTTP->removeDefaultArgument();
6512         }
6513       } else {
6514         TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Param);
6515         if (TTP->hasDefaultArgument()) {
6516           Diag(TTP->getDefaultArgument().getLocation(),
6517                diag::err_default_arg_in_partial_spec)
6518             << TTP->getDefaultArgument().getSourceRange();
6519           TTP->removeDefaultArgument();
6520         }
6521       }
6522     }
6523   } else if (TemplateParams) {
6524     if (TUK == TUK_Friend)
6525       Diag(KWLoc, diag::err_template_spec_friend)
6526         << FixItHint::CreateRemoval(
6527                                 SourceRange(TemplateParams->getTemplateLoc(),
6528                                             TemplateParams->getRAngleLoc()))
6529         << SourceRange(LAngleLoc, RAngleLoc);
6530     else
6531       isExplicitSpecialization = true;
6532   } else {
6533     assert(TUK == TUK_Friend && "should have a 'template<>' for this decl");
6534   }
6535
6536   // Check that the specialization uses the same tag kind as the
6537   // original template.
6538   TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
6539   assert(Kind != TTK_Enum && "Invalid enum tag in class template spec!");
6540   if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
6541                                     Kind, TUK == TUK_Definition, KWLoc,
6542                                     ClassTemplate->getIdentifier())) {
6543     Diag(KWLoc, diag::err_use_with_wrong_tag)
6544       << ClassTemplate
6545       << FixItHint::CreateReplacement(KWLoc,
6546                             ClassTemplate->getTemplatedDecl()->getKindName());
6547     Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
6548          diag::note_previous_use);
6549     Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
6550   }
6551
6552   // Translate the parser's template argument list in our AST format.
6553   TemplateArgumentListInfo TemplateArgs =
6554       makeTemplateArgumentListInfo(*this, TemplateId);
6555
6556   // Check for unexpanded parameter packs in any of the template arguments.
6557   for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
6558     if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
6559                                         UPPC_PartialSpecialization))
6560       return true;
6561
6562   // Check that the template argument list is well-formed for this
6563   // template.
6564   SmallVector<TemplateArgument, 4> Converted;
6565   if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
6566                                 TemplateArgs, false, Converted))
6567     return true;
6568
6569   // Find the class template (partial) specialization declaration that
6570   // corresponds to these arguments.
6571   if (isPartialSpecialization) {
6572     if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, ClassTemplate,
6573                                                TemplateArgs.size(), Converted))
6574       return true;
6575
6576     // FIXME: Move this to CheckTemplatePartialSpecializationArgs so we
6577     // also do it during instantiation.
6578     bool InstantiationDependent;
6579     if (!Name.isDependent() &&
6580         !TemplateSpecializationType::anyDependentTemplateArguments(
6581             TemplateArgs.arguments(), InstantiationDependent)) {
6582       Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
6583         << ClassTemplate->getDeclName();
6584       isPartialSpecialization = false;
6585     }
6586   }
6587
6588   void *InsertPos = nullptr;
6589   ClassTemplateSpecializationDecl *PrevDecl = nullptr;
6590
6591   if (isPartialSpecialization)
6592     // FIXME: Template parameter list matters, too
6593     PrevDecl = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
6594   else
6595     PrevDecl = ClassTemplate->findSpecialization(Converted, InsertPos);
6596
6597   ClassTemplateSpecializationDecl *Specialization = nullptr;
6598
6599   // Check whether we can declare a class template specialization in
6600   // the current scope.
6601   if (TUK != TUK_Friend &&
6602       CheckTemplateSpecializationScope(*this, ClassTemplate, PrevDecl,
6603                                        TemplateNameLoc,
6604                                        isPartialSpecialization))
6605     return true;
6606
6607   // The canonical type
6608   QualType CanonType;
6609   if (isPartialSpecialization) {
6610     // Build the canonical type that describes the converted template
6611     // arguments of the class template partial specialization.
6612     TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
6613     CanonType = Context.getTemplateSpecializationType(CanonTemplate,
6614                                                       Converted);
6615
6616     if (Context.hasSameType(CanonType,
6617                         ClassTemplate->getInjectedClassNameSpecialization())) {
6618       // C++ [temp.class.spec]p9b3:
6619       //
6620       //   -- The argument list of the specialization shall not be identical
6621       //      to the implicit argument list of the primary template.
6622       //
6623       // This rule has since been removed, because it's redundant given DR1495,
6624       // but we keep it because it produces better diagnostics and recovery.
6625       Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
6626         << /*class template*/0 << (TUK == TUK_Definition)
6627         << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
6628       return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS,
6629                                 ClassTemplate->getIdentifier(),
6630                                 TemplateNameLoc,
6631                                 Attr,
6632                                 TemplateParams,
6633                                 AS_none, /*ModulePrivateLoc=*/SourceLocation(),
6634                                 /*FriendLoc*/SourceLocation(),
6635                                 TemplateParameterLists.size() - 1,
6636                                 TemplateParameterLists.data());
6637     }
6638
6639     // Create a new class template partial specialization declaration node.
6640     ClassTemplatePartialSpecializationDecl *PrevPartial
6641       = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
6642     ClassTemplatePartialSpecializationDecl *Partial
6643       = ClassTemplatePartialSpecializationDecl::Create(Context, Kind,
6644                                              ClassTemplate->getDeclContext(),
6645                                                        KWLoc, TemplateNameLoc,
6646                                                        TemplateParams,
6647                                                        ClassTemplate,
6648                                                        Converted,
6649                                                        TemplateArgs,
6650                                                        CanonType,
6651                                                        PrevPartial);
6652     SetNestedNameSpecifier(Partial, SS);
6653     if (TemplateParameterLists.size() > 1 && SS.isSet()) {
6654       Partial->setTemplateParameterListsInfo(
6655           Context, TemplateParameterLists.drop_back(1));
6656     }
6657
6658     if (!PrevPartial)
6659       ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
6660     Specialization = Partial;
6661
6662     // If we are providing an explicit specialization of a member class
6663     // template specialization, make a note of that.
6664     if (PrevPartial && PrevPartial->getInstantiatedFromMember())
6665       PrevPartial->setMemberSpecialization();
6666
6667     CheckTemplatePartialSpecialization(Partial);
6668   } else {
6669     // Create a new class template specialization declaration node for
6670     // this explicit specialization or friend declaration.
6671     Specialization
6672       = ClassTemplateSpecializationDecl::Create(Context, Kind,
6673                                              ClassTemplate->getDeclContext(),
6674                                                 KWLoc, TemplateNameLoc,
6675                                                 ClassTemplate,
6676                                                 Converted,
6677                                                 PrevDecl);
6678     SetNestedNameSpecifier(Specialization, SS);
6679     if (TemplateParameterLists.size() > 0) {
6680       Specialization->setTemplateParameterListsInfo(Context,
6681                                                     TemplateParameterLists);
6682     }
6683
6684     if (!PrevDecl)
6685       ClassTemplate->AddSpecialization(Specialization, InsertPos);
6686
6687     if (CurContext->isDependentContext()) {
6688       // -fms-extensions permits specialization of nested classes without
6689       // fully specializing the outer class(es).
6690       assert(getLangOpts().MicrosoftExt &&
6691              "Only possible with -fms-extensions!");
6692       TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
6693       CanonType = Context.getTemplateSpecializationType(
6694           CanonTemplate, Converted);
6695     } else {
6696       CanonType = Context.getTypeDeclType(Specialization);
6697     }
6698   }
6699
6700   // C++ [temp.expl.spec]p6:
6701   //   If a template, a member template or the member of a class template is
6702   //   explicitly specialized then that specialization shall be declared
6703   //   before the first use of that specialization that would cause an implicit
6704   //   instantiation to take place, in every translation unit in which such a
6705   //   use occurs; no diagnostic is required.
6706   if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
6707     bool Okay = false;
6708     for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
6709       // Is there any previous explicit specialization declaration?
6710       if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
6711         Okay = true;
6712         break;
6713       }
6714     }
6715
6716     if (!Okay) {
6717       SourceRange Range(TemplateNameLoc, RAngleLoc);
6718       Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
6719         << Context.getTypeDeclType(Specialization) << Range;
6720
6721       Diag(PrevDecl->getPointOfInstantiation(),
6722            diag::note_instantiation_required_here)
6723         << (PrevDecl->getTemplateSpecializationKind()
6724                                                 != TSK_ImplicitInstantiation);
6725       return true;
6726     }
6727   }
6728
6729   // If this is not a friend, note that this is an explicit specialization.
6730   if (TUK != TUK_Friend)
6731     Specialization->setSpecializationKind(TSK_ExplicitSpecialization);
6732
6733   // Check that this isn't a redefinition of this specialization.
6734   if (TUK == TUK_Definition) {
6735     RecordDecl *Def = Specialization->getDefinition();
6736     NamedDecl *Hidden = nullptr;
6737     if (Def && SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
6738       SkipBody->ShouldSkip = true;
6739       makeMergedDefinitionVisible(Hidden, KWLoc);
6740       // From here on out, treat this as just a redeclaration.
6741       TUK = TUK_Declaration;
6742     } else if (Def) {
6743       SourceRange Range(TemplateNameLoc, RAngleLoc);
6744       Diag(TemplateNameLoc, diag::err_redefinition) << Specialization << Range;
6745       Diag(Def->getLocation(), diag::note_previous_definition);
6746       Specialization->setInvalidDecl();
6747       return true;
6748     }
6749   }
6750
6751   if (Attr)
6752     ProcessDeclAttributeList(S, Specialization, Attr);
6753
6754   // Add alignment attributes if necessary; these attributes are checked when
6755   // the ASTContext lays out the structure.
6756   if (TUK == TUK_Definition) {
6757     AddAlignmentAttributesForRecord(Specialization);
6758     AddMsStructLayoutForRecord(Specialization);
6759   }
6760
6761   if (ModulePrivateLoc.isValid())
6762     Diag(Specialization->getLocation(), diag::err_module_private_specialization)
6763       << (isPartialSpecialization? 1 : 0)
6764       << FixItHint::CreateRemoval(ModulePrivateLoc);
6765
6766   // Build the fully-sugared type for this class template
6767   // specialization as the user wrote in the specialization
6768   // itself. This means that we'll pretty-print the type retrieved
6769   // from the specialization's declaration the way that the user
6770   // actually wrote the specialization, rather than formatting the
6771   // name based on the "canonical" representation used to store the
6772   // template arguments in the specialization.
6773   TypeSourceInfo *WrittenTy
6774     = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
6775                                                 TemplateArgs, CanonType);
6776   if (TUK != TUK_Friend) {
6777     Specialization->setTypeAsWritten(WrittenTy);
6778     Specialization->setTemplateKeywordLoc(TemplateKWLoc);
6779   }
6780
6781   // C++ [temp.expl.spec]p9:
6782   //   A template explicit specialization is in the scope of the
6783   //   namespace in which the template was defined.
6784   //
6785   // We actually implement this paragraph where we set the semantic
6786   // context (in the creation of the ClassTemplateSpecializationDecl),
6787   // but we also maintain the lexical context where the actual
6788   // definition occurs.
6789   Specialization->setLexicalDeclContext(CurContext);
6790
6791   // We may be starting the definition of this specialization.
6792   if (TUK == TUK_Definition)
6793     Specialization->startDefinition();
6794
6795   if (TUK == TUK_Friend) {
6796     FriendDecl *Friend = FriendDecl::Create(Context, CurContext,
6797                                             TemplateNameLoc,
6798                                             WrittenTy,
6799                                             /*FIXME:*/KWLoc);
6800     Friend->setAccess(AS_public);
6801     CurContext->addDecl(Friend);
6802   } else {
6803     // Add the specialization into its lexical context, so that it can
6804     // be seen when iterating through the list of declarations in that
6805     // context. However, specializations are not found by name lookup.
6806     CurContext->addDecl(Specialization);
6807   }
6808   return Specialization;
6809 }
6810
6811 Decl *Sema::ActOnTemplateDeclarator(Scope *S,
6812                               MultiTemplateParamsArg TemplateParameterLists,
6813                                     Declarator &D) {
6814   Decl *NewDecl = HandleDeclarator(S, D, TemplateParameterLists);
6815   ActOnDocumentableDecl(NewDecl);
6816   return NewDecl;
6817 }
6818
6819 /// \brief Strips various properties off an implicit instantiation
6820 /// that has just been explicitly specialized.
6821 static void StripImplicitInstantiation(NamedDecl *D) {
6822   D->dropAttr<DLLImportAttr>();
6823   D->dropAttr<DLLExportAttr>();
6824
6825   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
6826     FD->setInlineSpecified(false);
6827 }
6828
6829 /// \brief Compute the diagnostic location for an explicit instantiation
6830 //  declaration or definition.
6831 static SourceLocation DiagLocForExplicitInstantiation(
6832     NamedDecl* D, SourceLocation PointOfInstantiation) {
6833   // Explicit instantiations following a specialization have no effect and
6834   // hence no PointOfInstantiation. In that case, walk decl backwards
6835   // until a valid name loc is found.
6836   SourceLocation PrevDiagLoc = PointOfInstantiation;
6837   for (Decl *Prev = D; Prev && !PrevDiagLoc.isValid();
6838        Prev = Prev->getPreviousDecl()) {
6839     PrevDiagLoc = Prev->getLocation();
6840   }
6841   assert(PrevDiagLoc.isValid() &&
6842          "Explicit instantiation without point of instantiation?");
6843   return PrevDiagLoc;
6844 }
6845
6846 /// \brief Diagnose cases where we have an explicit template specialization
6847 /// before/after an explicit template instantiation, producing diagnostics
6848 /// for those cases where they are required and determining whether the
6849 /// new specialization/instantiation will have any effect.
6850 ///
6851 /// \param NewLoc the location of the new explicit specialization or
6852 /// instantiation.
6853 ///
6854 /// \param NewTSK the kind of the new explicit specialization or instantiation.
6855 ///
6856 /// \param PrevDecl the previous declaration of the entity.
6857 ///
6858 /// \param PrevTSK the kind of the old explicit specialization or instantiatin.
6859 ///
6860 /// \param PrevPointOfInstantiation if valid, indicates where the previus
6861 /// declaration was instantiated (either implicitly or explicitly).
6862 ///
6863 /// \param HasNoEffect will be set to true to indicate that the new
6864 /// specialization or instantiation has no effect and should be ignored.
6865 ///
6866 /// \returns true if there was an error that should prevent the introduction of
6867 /// the new declaration into the AST, false otherwise.
6868 bool
6869 Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
6870                                              TemplateSpecializationKind NewTSK,
6871                                              NamedDecl *PrevDecl,
6872                                              TemplateSpecializationKind PrevTSK,
6873                                         SourceLocation PrevPointOfInstantiation,
6874                                              bool &HasNoEffect) {
6875   HasNoEffect = false;
6876
6877   switch (NewTSK) {
6878   case TSK_Undeclared:
6879   case TSK_ImplicitInstantiation:
6880     assert(
6881         (PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) &&
6882         "previous declaration must be implicit!");
6883     return false;
6884
6885   case TSK_ExplicitSpecialization:
6886     switch (PrevTSK) {
6887     case TSK_Undeclared:
6888     case TSK_ExplicitSpecialization:
6889       // Okay, we're just specializing something that is either already
6890       // explicitly specialized or has merely been mentioned without any
6891       // instantiation.
6892       return false;
6893
6894     case TSK_ImplicitInstantiation:
6895       if (PrevPointOfInstantiation.isInvalid()) {
6896         // The declaration itself has not actually been instantiated, so it is
6897         // still okay to specialize it.
6898         StripImplicitInstantiation(PrevDecl);
6899         return false;
6900       }
6901       // Fall through
6902
6903     case TSK_ExplicitInstantiationDeclaration:
6904     case TSK_ExplicitInstantiationDefinition:
6905       assert((PrevTSK == TSK_ImplicitInstantiation ||
6906               PrevPointOfInstantiation.isValid()) &&
6907              "Explicit instantiation without point of instantiation?");
6908
6909       // C++ [temp.expl.spec]p6:
6910       //   If a template, a member template or the member of a class template
6911       //   is explicitly specialized then that specialization shall be declared
6912       //   before the first use of that specialization that would cause an
6913       //   implicit instantiation to take place, in every translation unit in
6914       //   which such a use occurs; no diagnostic is required.
6915       for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
6916         // Is there any previous explicit specialization declaration?
6917         if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization)
6918           return false;
6919       }
6920
6921       Diag(NewLoc, diag::err_specialization_after_instantiation)
6922         << PrevDecl;
6923       Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
6924         << (PrevTSK != TSK_ImplicitInstantiation);
6925
6926       return true;
6927     }
6928
6929   case TSK_ExplicitInstantiationDeclaration:
6930     switch (PrevTSK) {
6931     case TSK_ExplicitInstantiationDeclaration:
6932       // This explicit instantiation declaration is redundant (that's okay).
6933       HasNoEffect = true;
6934       return false;
6935
6936     case TSK_Undeclared:
6937     case TSK_ImplicitInstantiation:
6938       // We're explicitly instantiating something that may have already been
6939       // implicitly instantiated; that's fine.
6940       return false;
6941
6942     case TSK_ExplicitSpecialization:
6943       // C++0x [temp.explicit]p4:
6944       //   For a given set of template parameters, if an explicit instantiation
6945       //   of a template appears after a declaration of an explicit
6946       //   specialization for that template, the explicit instantiation has no
6947       //   effect.
6948       HasNoEffect = true;
6949       return false;
6950
6951     case TSK_ExplicitInstantiationDefinition:
6952       // C++0x [temp.explicit]p10:
6953       //   If an entity is the subject of both an explicit instantiation
6954       //   declaration and an explicit instantiation definition in the same
6955       //   translation unit, the definition shall follow the declaration.
6956       Diag(NewLoc,
6957            diag::err_explicit_instantiation_declaration_after_definition);
6958
6959       // Explicit instantiations following a specialization have no effect and
6960       // hence no PrevPointOfInstantiation. In that case, walk decl backwards
6961       // until a valid name loc is found.
6962       Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
6963            diag::note_explicit_instantiation_definition_here);
6964       HasNoEffect = true;
6965       return false;
6966     }
6967
6968   case TSK_ExplicitInstantiationDefinition:
6969     switch (PrevTSK) {
6970     case TSK_Undeclared:
6971     case TSK_ImplicitInstantiation:
6972       // We're explicitly instantiating something that may have already been
6973       // implicitly instantiated; that's fine.
6974       return false;
6975
6976     case TSK_ExplicitSpecialization:
6977       // C++ DR 259, C++0x [temp.explicit]p4:
6978       //   For a given set of template parameters, if an explicit
6979       //   instantiation of a template appears after a declaration of
6980       //   an explicit specialization for that template, the explicit
6981       //   instantiation has no effect.
6982       Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization)
6983         << PrevDecl;
6984       Diag(PrevDecl->getLocation(),
6985            diag::note_previous_template_specialization);
6986       HasNoEffect = true;
6987       return false;
6988
6989     case TSK_ExplicitInstantiationDeclaration:
6990       // We're explicity instantiating a definition for something for which we
6991       // were previously asked to suppress instantiations. That's fine.
6992
6993       // C++0x [temp.explicit]p4:
6994       //   For a given set of template parameters, if an explicit instantiation
6995       //   of a template appears after a declaration of an explicit
6996       //   specialization for that template, the explicit instantiation has no
6997       //   effect.
6998       for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
6999         // Is there any previous explicit specialization declaration?
7000         if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
7001           HasNoEffect = true;
7002           break;
7003         }
7004       }
7005
7006       return false;
7007
7008     case TSK_ExplicitInstantiationDefinition:
7009       // C++0x [temp.spec]p5:
7010       //   For a given template and a given set of template-arguments,
7011       //     - an explicit instantiation definition shall appear at most once
7012       //       in a program,
7013
7014       // MSVCCompat: MSVC silently ignores duplicate explicit instantiations.
7015       Diag(NewLoc, (getLangOpts().MSVCCompat)
7016                        ? diag::ext_explicit_instantiation_duplicate
7017                        : diag::err_explicit_instantiation_duplicate)
7018           << PrevDecl;
7019       Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
7020            diag::note_previous_explicit_instantiation);
7021       HasNoEffect = true;
7022       return false;
7023     }
7024   }
7025
7026   llvm_unreachable("Missing specialization/instantiation case?");
7027 }
7028
7029 /// \brief Perform semantic analysis for the given dependent function
7030 /// template specialization.
7031 ///
7032 /// The only possible way to get a dependent function template specialization
7033 /// is with a friend declaration, like so:
7034 ///
7035 /// \code
7036 ///   template \<class T> void foo(T);
7037 ///   template \<class T> class A {
7038 ///     friend void foo<>(T);
7039 ///   };
7040 /// \endcode
7041 ///
7042 /// There really isn't any useful analysis we can do here, so we
7043 /// just store the information.
7044 bool
7045 Sema::CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,
7046                    const TemplateArgumentListInfo &ExplicitTemplateArgs,
7047                                                    LookupResult &Previous) {
7048   // Remove anything from Previous that isn't a function template in
7049   // the correct context.
7050   DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
7051   LookupResult::Filter F = Previous.makeFilter();
7052   while (F.hasNext()) {
7053     NamedDecl *D = F.next()->getUnderlyingDecl();
7054     if (!isa<FunctionTemplateDecl>(D) ||
7055         !FDLookupContext->InEnclosingNamespaceSetOf(
7056                               D->getDeclContext()->getRedeclContext()))
7057       F.erase();
7058   }
7059   F.done();
7060
7061   // Should this be diagnosed here?
7062   if (Previous.empty()) return true;
7063
7064   FD->setDependentTemplateSpecialization(Context, Previous.asUnresolvedSet(),
7065                                          ExplicitTemplateArgs);
7066   return false;
7067 }
7068
7069 /// \brief Perform semantic analysis for the given function template
7070 /// specialization.
7071 ///
7072 /// This routine performs all of the semantic analysis required for an
7073 /// explicit function template specialization. On successful completion,
7074 /// the function declaration \p FD will become a function template
7075 /// specialization.
7076 ///
7077 /// \param FD the function declaration, which will be updated to become a
7078 /// function template specialization.
7079 ///
7080 /// \param ExplicitTemplateArgs the explicitly-provided template arguments,
7081 /// if any. Note that this may be valid info even when 0 arguments are
7082 /// explicitly provided as in, e.g., \c void sort<>(char*, char*);
7083 /// as it anyway contains info on the angle brackets locations.
7084 ///
7085 /// \param Previous the set of declarations that may be specialized by
7086 /// this function specialization.
7087 bool Sema::CheckFunctionTemplateSpecialization(
7088     FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,
7089     LookupResult &Previous) {
7090   // The set of function template specializations that could match this
7091   // explicit function template specialization.
7092   UnresolvedSet<8> Candidates;
7093   TemplateSpecCandidateSet FailedCandidates(FD->getLocation(),
7094                                             /*ForTakingAddress=*/false);
7095
7096   llvm::SmallDenseMap<FunctionDecl *, TemplateArgumentListInfo, 8>
7097       ConvertedTemplateArgs;
7098
7099   DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
7100   for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
7101          I != E; ++I) {
7102     NamedDecl *Ovl = (*I)->getUnderlyingDecl();
7103     if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Ovl)) {
7104       // Only consider templates found within the same semantic lookup scope as
7105       // FD.
7106       if (!FDLookupContext->InEnclosingNamespaceSetOf(
7107                                 Ovl->getDeclContext()->getRedeclContext()))
7108         continue;
7109
7110       // When matching a constexpr member function template specialization
7111       // against the primary template, we don't yet know whether the
7112       // specialization has an implicit 'const' (because we don't know whether
7113       // it will be a static member function until we know which template it
7114       // specializes), so adjust it now assuming it specializes this template.
7115       QualType FT = FD->getType();
7116       if (FD->isConstexpr()) {
7117         CXXMethodDecl *OldMD =
7118           dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
7119         if (OldMD && OldMD->isConst()) {
7120           const FunctionProtoType *FPT = FT->castAs<FunctionProtoType>();
7121           FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
7122           EPI.TypeQuals |= Qualifiers::Const;
7123           FT = Context.getFunctionType(FPT->getReturnType(),
7124                                        FPT->getParamTypes(), EPI);
7125         }
7126       }
7127
7128       TemplateArgumentListInfo Args;
7129       if (ExplicitTemplateArgs)
7130         Args = *ExplicitTemplateArgs;
7131
7132       // C++ [temp.expl.spec]p11:
7133       //   A trailing template-argument can be left unspecified in the
7134       //   template-id naming an explicit function template specialization
7135       //   provided it can be deduced from the function argument type.
7136       // Perform template argument deduction to determine whether we may be
7137       // specializing this template.
7138       // FIXME: It is somewhat wasteful to build
7139       TemplateDeductionInfo Info(FailedCandidates.getLocation());
7140       FunctionDecl *Specialization = nullptr;
7141       if (TemplateDeductionResult TDK = DeduceTemplateArguments(
7142               cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),
7143               ExplicitTemplateArgs ? &Args : nullptr, FT, Specialization,
7144               Info)) {
7145         // Template argument deduction failed; record why it failed, so
7146         // that we can provide nifty diagnostics.
7147         FailedCandidates.addCandidate().set(
7148             I.getPair(), FunTmpl->getTemplatedDecl(),
7149             MakeDeductionFailureInfo(Context, TDK, Info));
7150         (void)TDK;
7151         continue;
7152       }
7153
7154       // Target attributes are part of the cuda function signature, so
7155       // the deduced template's cuda target must match that of the
7156       // specialization.  Given that C++ template deduction does not
7157       // take target attributes into account, we reject candidates
7158       // here that have a different target.
7159       if (LangOpts.CUDA &&
7160           IdentifyCUDATarget(Specialization,
7161                              /* IgnoreImplicitHDAttributes = */ true) !=
7162               IdentifyCUDATarget(FD, /* IgnoreImplicitHDAttributes = */ true)) {
7163         FailedCandidates.addCandidate().set(
7164             I.getPair(), FunTmpl->getTemplatedDecl(),
7165             MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
7166         continue;
7167       }
7168
7169       // Record this candidate.
7170       if (ExplicitTemplateArgs)
7171         ConvertedTemplateArgs[Specialization] = std::move(Args);
7172       Candidates.addDecl(Specialization, I.getAccess());
7173     }
7174   }
7175
7176   // Find the most specialized function template.
7177   UnresolvedSetIterator Result = getMostSpecialized(
7178       Candidates.begin(), Candidates.end(), FailedCandidates,
7179       FD->getLocation(),
7180       PDiag(diag::err_function_template_spec_no_match) << FD->getDeclName(),
7181       PDiag(diag::err_function_template_spec_ambiguous)
7182           << FD->getDeclName() << (ExplicitTemplateArgs != nullptr),
7183       PDiag(diag::note_function_template_spec_matched));
7184
7185   if (Result == Candidates.end())
7186     return true;
7187
7188   // Ignore access information;  it doesn't figure into redeclaration checking.
7189   FunctionDecl *Specialization = cast<FunctionDecl>(*Result);
7190
7191   // C++ Concepts TS [dcl.spec.concept]p7: A program shall not declare [...]
7192   // an explicit specialization (14.8.3) [...] of a concept definition.
7193   if (Specialization->getPrimaryTemplate()->isConcept()) {
7194     Diag(FD->getLocation(), diag::err_concept_specialized)
7195         << 0 /*function*/ << 1 /*explicitly specialized*/;
7196     Diag(Specialization->getLocation(), diag::note_previous_declaration);
7197     return true;
7198   }
7199
7200   FunctionTemplateSpecializationInfo *SpecInfo
7201     = Specialization->getTemplateSpecializationInfo();
7202   assert(SpecInfo && "Function template specialization info missing?");
7203
7204   // Note: do not overwrite location info if previous template
7205   // specialization kind was explicit.
7206   TemplateSpecializationKind TSK = SpecInfo->getTemplateSpecializationKind();
7207   if (TSK == TSK_Undeclared || TSK == TSK_ImplicitInstantiation) {
7208     Specialization->setLocation(FD->getLocation());
7209     // C++11 [dcl.constexpr]p1: An explicit specialization of a constexpr
7210     // function can differ from the template declaration with respect to
7211     // the constexpr specifier.
7212     Specialization->setConstexpr(FD->isConstexpr());
7213   }
7214
7215   // FIXME: Check if the prior specialization has a point of instantiation.
7216   // If so, we have run afoul of .
7217
7218   // If this is a friend declaration, then we're not really declaring
7219   // an explicit specialization.
7220   bool isFriend = (FD->getFriendObjectKind() != Decl::FOK_None);
7221
7222   // Check the scope of this explicit specialization.
7223   if (!isFriend &&
7224       CheckTemplateSpecializationScope(*this,
7225                                        Specialization->getPrimaryTemplate(),
7226                                        Specialization, FD->getLocation(),
7227                                        false))
7228     return true;
7229
7230   // C++ [temp.expl.spec]p6:
7231   //   If a template, a member template or the member of a class template is
7232   //   explicitly specialized then that specialization shall be declared
7233   //   before the first use of that specialization that would cause an implicit
7234   //   instantiation to take place, in every translation unit in which such a
7235   //   use occurs; no diagnostic is required.
7236   bool HasNoEffect = false;
7237   if (!isFriend &&
7238       CheckSpecializationInstantiationRedecl(FD->getLocation(),
7239                                              TSK_ExplicitSpecialization,
7240                                              Specialization,
7241                                    SpecInfo->getTemplateSpecializationKind(),
7242                                          SpecInfo->getPointOfInstantiation(),
7243                                              HasNoEffect))
7244     return true;
7245
7246   // Mark the prior declaration as an explicit specialization, so that later
7247   // clients know that this is an explicit specialization.
7248   if (!isFriend) {
7249     // Since explicit specializations do not inherit '=delete' from their
7250     // primary function template - check if the 'specialization' that was
7251     // implicitly generated (during template argument deduction for partial
7252     // ordering) from the most specialized of all the function templates that
7253     // 'FD' could have been specializing, has a 'deleted' definition.  If so,
7254     // first check that it was implicitly generated during template argument
7255     // deduction by making sure it wasn't referenced, and then reset the deleted
7256     // flag to not-deleted, so that we can inherit that information from 'FD'.
7257     if (Specialization->isDeleted() && !SpecInfo->isExplicitSpecialization() &&
7258         !Specialization->getCanonicalDecl()->isReferenced()) {
7259       assert(
7260           Specialization->getCanonicalDecl() == Specialization &&
7261           "This must be the only existing declaration of this specialization");
7262       Specialization->setDeletedAsWritten(false);
7263     }
7264     SpecInfo->setTemplateSpecializationKind(TSK_ExplicitSpecialization);
7265     MarkUnusedFileScopedDecl(Specialization);
7266   }
7267
7268   // Turn the given function declaration into a function template
7269   // specialization, with the template arguments from the previous
7270   // specialization.
7271   // Take copies of (semantic and syntactic) template argument lists.
7272   const TemplateArgumentList* TemplArgs = new (Context)
7273     TemplateArgumentList(Specialization->getTemplateSpecializationArgs());
7274   FD->setFunctionTemplateSpecialization(
7275       Specialization->getPrimaryTemplate(), TemplArgs, /*InsertPos=*/nullptr,
7276       SpecInfo->getTemplateSpecializationKind(),
7277       ExplicitTemplateArgs ? &ConvertedTemplateArgs[Specialization] : nullptr);
7278
7279   // A function template specialization inherits the target attributes
7280   // of its template.  (We require the attributes explicitly in the
7281   // code to match, but a template may have implicit attributes by
7282   // virtue e.g. of being constexpr, and it passes these implicit
7283   // attributes on to its specializations.)
7284   if (LangOpts.CUDA)
7285     inheritCUDATargetAttrs(FD, *Specialization->getPrimaryTemplate());
7286
7287   // The "previous declaration" for this function template specialization is
7288   // the prior function template specialization.
7289   Previous.clear();
7290   Previous.addDecl(Specialization);
7291   return false;
7292 }
7293
7294 /// \brief Perform semantic analysis for the given non-template member
7295 /// specialization.
7296 ///
7297 /// This routine performs all of the semantic analysis required for an
7298 /// explicit member function specialization. On successful completion,
7299 /// the function declaration \p FD will become a member function
7300 /// specialization.
7301 ///
7302 /// \param Member the member declaration, which will be updated to become a
7303 /// specialization.
7304 ///
7305 /// \param Previous the set of declarations, one of which may be specialized
7306 /// by this function specialization;  the set will be modified to contain the
7307 /// redeclared member.
7308 bool
7309 Sema::CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous) {
7310   assert(!isa<TemplateDecl>(Member) && "Only for non-template members");
7311
7312   // Try to find the member we are instantiating.
7313   NamedDecl *FoundInstantiation = nullptr;
7314   NamedDecl *Instantiation = nullptr;
7315   NamedDecl *InstantiatedFrom = nullptr;
7316   MemberSpecializationInfo *MSInfo = nullptr;
7317
7318   if (Previous.empty()) {
7319     // Nowhere to look anyway.
7320   } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Member)) {
7321     for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
7322            I != E; ++I) {
7323       NamedDecl *D = (*I)->getUnderlyingDecl();
7324       if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
7325         QualType Adjusted = Function->getType();
7326         if (!hasExplicitCallingConv(Adjusted))
7327           Adjusted = adjustCCAndNoReturn(Adjusted, Method->getType());
7328         if (Context.hasSameType(Adjusted, Method->getType())) {
7329           FoundInstantiation = *I;
7330           Instantiation = Method;
7331           InstantiatedFrom = Method->getInstantiatedFromMemberFunction();
7332           MSInfo = Method->getMemberSpecializationInfo();
7333           break;
7334         }
7335       }
7336     }
7337   } else if (isa<VarDecl>(Member)) {
7338     VarDecl *PrevVar;
7339     if (Previous.isSingleResult() &&
7340         (PrevVar = dyn_cast<VarDecl>(Previous.getFoundDecl())))
7341       if (PrevVar->isStaticDataMember()) {
7342         FoundInstantiation = Previous.getRepresentativeDecl();
7343         Instantiation = PrevVar;
7344         InstantiatedFrom = PrevVar->getInstantiatedFromStaticDataMember();
7345         MSInfo = PrevVar->getMemberSpecializationInfo();
7346       }
7347   } else if (isa<RecordDecl>(Member)) {
7348     CXXRecordDecl *PrevRecord;
7349     if (Previous.isSingleResult() &&
7350         (PrevRecord = dyn_cast<CXXRecordDecl>(Previous.getFoundDecl()))) {
7351       FoundInstantiation = Previous.getRepresentativeDecl();
7352       Instantiation = PrevRecord;
7353       InstantiatedFrom = PrevRecord->getInstantiatedFromMemberClass();
7354       MSInfo = PrevRecord->getMemberSpecializationInfo();
7355     }
7356   } else if (isa<EnumDecl>(Member)) {
7357     EnumDecl *PrevEnum;
7358     if (Previous.isSingleResult() &&
7359         (PrevEnum = dyn_cast<EnumDecl>(Previous.getFoundDecl()))) {
7360       FoundInstantiation = Previous.getRepresentativeDecl();
7361       Instantiation = PrevEnum;
7362       InstantiatedFrom = PrevEnum->getInstantiatedFromMemberEnum();
7363       MSInfo = PrevEnum->getMemberSpecializationInfo();
7364     }
7365   }
7366
7367   if (!Instantiation) {
7368     // There is no previous declaration that matches. Since member
7369     // specializations are always out-of-line, the caller will complain about
7370     // this mismatch later.
7371     return false;
7372   }
7373
7374   // If this is a friend, just bail out here before we start turning
7375   // things into explicit specializations.
7376   if (Member->getFriendObjectKind() != Decl::FOK_None) {
7377     // Preserve instantiation information.
7378     if (InstantiatedFrom && isa<CXXMethodDecl>(Member)) {
7379       cast<CXXMethodDecl>(Member)->setInstantiationOfMemberFunction(
7380                                       cast<CXXMethodDecl>(InstantiatedFrom),
7381         cast<CXXMethodDecl>(Instantiation)->getTemplateSpecializationKind());
7382     } else if (InstantiatedFrom && isa<CXXRecordDecl>(Member)) {
7383       cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass(
7384                                       cast<CXXRecordDecl>(InstantiatedFrom),
7385         cast<CXXRecordDecl>(Instantiation)->getTemplateSpecializationKind());
7386     }
7387
7388     Previous.clear();
7389     Previous.addDecl(FoundInstantiation);
7390     return false;
7391   }
7392
7393   // Make sure that this is a specialization of a member.
7394   if (!InstantiatedFrom) {
7395     Diag(Member->getLocation(), diag::err_spec_member_not_instantiated)
7396       << Member;
7397     Diag(Instantiation->getLocation(), diag::note_specialized_decl);
7398     return true;
7399   }
7400
7401   // C++ [temp.expl.spec]p6:
7402   //   If a template, a member template or the member of a class template is
7403   //   explicitly specialized then that specialization shall be declared
7404   //   before the first use of that specialization that would cause an implicit
7405   //   instantiation to take place, in every translation unit in which such a
7406   //   use occurs; no diagnostic is required.
7407   assert(MSInfo && "Member specialization info missing?");
7408
7409   bool HasNoEffect = false;
7410   if (CheckSpecializationInstantiationRedecl(Member->getLocation(),
7411                                              TSK_ExplicitSpecialization,
7412                                              Instantiation,
7413                                      MSInfo->getTemplateSpecializationKind(),
7414                                            MSInfo->getPointOfInstantiation(),
7415                                              HasNoEffect))
7416     return true;
7417
7418   // Check the scope of this explicit specialization.
7419   if (CheckTemplateSpecializationScope(*this,
7420                                        InstantiatedFrom,
7421                                        Instantiation, Member->getLocation(),
7422                                        false))
7423     return true;
7424
7425   // Note that this is an explicit instantiation of a member.
7426   // the original declaration to note that it is an explicit specialization
7427   // (if it was previously an implicit instantiation). This latter step
7428   // makes bookkeeping easier.
7429   if (isa<FunctionDecl>(Member)) {
7430     FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation);
7431     if (InstantiationFunction->getTemplateSpecializationKind() ==
7432           TSK_ImplicitInstantiation) {
7433       InstantiationFunction->setTemplateSpecializationKind(
7434                                                   TSK_ExplicitSpecialization);
7435       InstantiationFunction->setLocation(Member->getLocation());
7436       // Explicit specializations of member functions of class templates do not
7437       // inherit '=delete' from the member function they are specializing.
7438       if (InstantiationFunction->isDeleted()) {
7439         assert(InstantiationFunction->getCanonicalDecl() ==
7440                InstantiationFunction);
7441         InstantiationFunction->setDeletedAsWritten(false);
7442       }
7443     }
7444
7445     cast<FunctionDecl>(Member)->setInstantiationOfMemberFunction(
7446                                         cast<CXXMethodDecl>(InstantiatedFrom),
7447                                                   TSK_ExplicitSpecialization);
7448     MarkUnusedFileScopedDecl(InstantiationFunction);
7449   } else if (isa<VarDecl>(Member)) {
7450     VarDecl *InstantiationVar = cast<VarDecl>(Instantiation);
7451     if (InstantiationVar->getTemplateSpecializationKind() ==
7452           TSK_ImplicitInstantiation) {
7453       InstantiationVar->setTemplateSpecializationKind(
7454                                                   TSK_ExplicitSpecialization);
7455       InstantiationVar->setLocation(Member->getLocation());
7456     }
7457
7458     cast<VarDecl>(Member)->setInstantiationOfStaticDataMember(
7459         cast<VarDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
7460     MarkUnusedFileScopedDecl(InstantiationVar);
7461   } else if (isa<CXXRecordDecl>(Member)) {
7462     CXXRecordDecl *InstantiationClass = cast<CXXRecordDecl>(Instantiation);
7463     if (InstantiationClass->getTemplateSpecializationKind() ==
7464           TSK_ImplicitInstantiation) {
7465       InstantiationClass->setTemplateSpecializationKind(
7466                                                    TSK_ExplicitSpecialization);
7467       InstantiationClass->setLocation(Member->getLocation());
7468     }
7469
7470     cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass(
7471                                         cast<CXXRecordDecl>(InstantiatedFrom),
7472                                                    TSK_ExplicitSpecialization);
7473   } else {
7474     assert(isa<EnumDecl>(Member) && "Only member enums remain");
7475     EnumDecl *InstantiationEnum = cast<EnumDecl>(Instantiation);
7476     if (InstantiationEnum->getTemplateSpecializationKind() ==
7477           TSK_ImplicitInstantiation) {
7478       InstantiationEnum->setTemplateSpecializationKind(
7479                                                    TSK_ExplicitSpecialization);
7480       InstantiationEnum->setLocation(Member->getLocation());
7481     }
7482
7483     cast<EnumDecl>(Member)->setInstantiationOfMemberEnum(
7484         cast<EnumDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
7485   }
7486
7487   // Save the caller the trouble of having to figure out which declaration
7488   // this specialization matches.
7489   Previous.clear();
7490   Previous.addDecl(FoundInstantiation);
7491   return false;
7492 }
7493
7494 /// \brief Check the scope of an explicit instantiation.
7495 ///
7496 /// \returns true if a serious error occurs, false otherwise.
7497 static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D,
7498                                             SourceLocation InstLoc,
7499                                             bool WasQualifiedName) {
7500   DeclContext *OrigContext= D->getDeclContext()->getEnclosingNamespaceContext();
7501   DeclContext *CurContext = S.CurContext->getRedeclContext();
7502
7503   if (CurContext->isRecord()) {
7504     S.Diag(InstLoc, diag::err_explicit_instantiation_in_class)
7505       << D;
7506     return true;
7507   }
7508
7509   // C++11 [temp.explicit]p3:
7510   //   An explicit instantiation shall appear in an enclosing namespace of its
7511   //   template. If the name declared in the explicit instantiation is an
7512   //   unqualified name, the explicit instantiation shall appear in the
7513   //   namespace where its template is declared or, if that namespace is inline
7514   //   (7.3.1), any namespace from its enclosing namespace set.
7515   //
7516   // This is DR275, which we do not retroactively apply to C++98/03.
7517   if (WasQualifiedName) {
7518     if (CurContext->Encloses(OrigContext))
7519       return false;
7520   } else {
7521     if (CurContext->InEnclosingNamespaceSetOf(OrigContext))
7522       return false;
7523   }
7524
7525   if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext)) {
7526     if (WasQualifiedName)
7527       S.Diag(InstLoc,
7528              S.getLangOpts().CPlusPlus11?
7529                diag::err_explicit_instantiation_out_of_scope :
7530                diag::warn_explicit_instantiation_out_of_scope_0x)
7531         << D << NS;
7532     else
7533       S.Diag(InstLoc,
7534              S.getLangOpts().CPlusPlus11?
7535                diag::err_explicit_instantiation_unqualified_wrong_namespace :
7536                diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)
7537         << D << NS;
7538   } else
7539     S.Diag(InstLoc,
7540            S.getLangOpts().CPlusPlus11?
7541              diag::err_explicit_instantiation_must_be_global :
7542              diag::warn_explicit_instantiation_must_be_global_0x)
7543       << D;
7544   S.Diag(D->getLocation(), diag::note_explicit_instantiation_here);
7545   return false;
7546 }
7547
7548 /// \brief Determine whether the given scope specifier has a template-id in it.
7549 static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS) {
7550   if (!SS.isSet())
7551     return false;
7552
7553   // C++11 [temp.explicit]p3:
7554   //   If the explicit instantiation is for a member function, a member class
7555   //   or a static data member of a class template specialization, the name of
7556   //   the class template specialization in the qualified-id for the member
7557   //   name shall be a simple-template-id.
7558   //
7559   // C++98 has the same restriction, just worded differently.
7560   for (NestedNameSpecifier *NNS = SS.getScopeRep(); NNS;
7561        NNS = NNS->getPrefix())
7562     if (const Type *T = NNS->getAsType())
7563       if (isa<TemplateSpecializationType>(T))
7564         return true;
7565
7566   return false;
7567 }
7568
7569 /// Make a dllexport or dllimport attr on a class template specialization take
7570 /// effect.
7571 static void dllExportImportClassTemplateSpecialization(
7572     Sema &S, ClassTemplateSpecializationDecl *Def) {
7573   auto *A = cast_or_null<InheritableAttr>(getDLLAttr(Def));
7574   assert(A && "dllExportImportClassTemplateSpecialization called "
7575               "on Def without dllexport or dllimport");
7576
7577   // We reject explicit instantiations in class scope, so there should
7578   // never be any delayed exported classes to worry about.
7579   assert(S.DelayedDllExportClasses.empty() &&
7580          "delayed exports present at explicit instantiation");
7581   S.checkClassLevelDLLAttribute(Def);
7582
7583   // Propagate attribute to base class templates.
7584   for (auto &B : Def->bases()) {
7585     if (auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
7586             B.getType()->getAsCXXRecordDecl()))
7587       S.propagateDLLAttrToBaseClassTemplate(Def, A, BT, B.getLocStart());
7588   }
7589
7590   S.referenceDLLExportedClassMethods();
7591 }
7592
7593 // Explicit instantiation of a class template specialization
7594 DeclResult
7595 Sema::ActOnExplicitInstantiation(Scope *S,
7596                                  SourceLocation ExternLoc,
7597                                  SourceLocation TemplateLoc,
7598                                  unsigned TagSpec,
7599                                  SourceLocation KWLoc,
7600                                  const CXXScopeSpec &SS,
7601                                  TemplateTy TemplateD,
7602                                  SourceLocation TemplateNameLoc,
7603                                  SourceLocation LAngleLoc,
7604                                  ASTTemplateArgsPtr TemplateArgsIn,
7605                                  SourceLocation RAngleLoc,
7606                                  AttributeList *Attr) {
7607   // Find the class template we're specializing
7608   TemplateName Name = TemplateD.get();
7609   TemplateDecl *TD = Name.getAsTemplateDecl();
7610   // Check that the specialization uses the same tag kind as the
7611   // original template.
7612   TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
7613   assert(Kind != TTK_Enum &&
7614          "Invalid enum tag in class template explicit instantiation!");
7615
7616   ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(TD);
7617
7618   if (!ClassTemplate) {
7619     NonTagKind NTK = getNonTagTypeDeclKind(TD, Kind);
7620     Diag(TemplateNameLoc, diag::err_tag_reference_non_tag) << TD << NTK << Kind;
7621     Diag(TD->getLocation(), diag::note_previous_use);
7622     return true;
7623   }
7624
7625   if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
7626                                     Kind, /*isDefinition*/false, KWLoc,
7627                                     ClassTemplate->getIdentifier())) {
7628     Diag(KWLoc, diag::err_use_with_wrong_tag)
7629       << ClassTemplate
7630       << FixItHint::CreateReplacement(KWLoc,
7631                             ClassTemplate->getTemplatedDecl()->getKindName());
7632     Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
7633          diag::note_previous_use);
7634     Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
7635   }
7636
7637   // C++0x [temp.explicit]p2:
7638   //   There are two forms of explicit instantiation: an explicit instantiation
7639   //   definition and an explicit instantiation declaration. An explicit
7640   //   instantiation declaration begins with the extern keyword. [...]
7641   TemplateSpecializationKind TSK = ExternLoc.isInvalid()
7642                                        ? TSK_ExplicitInstantiationDefinition
7643                                        : TSK_ExplicitInstantiationDeclaration;
7644
7645   if (TSK == TSK_ExplicitInstantiationDeclaration) {
7646     // Check for dllexport class template instantiation declarations.
7647     for (AttributeList *A = Attr; A; A = A->getNext()) {
7648       if (A->getKind() == AttributeList::AT_DLLExport) {
7649         Diag(ExternLoc,
7650              diag::warn_attribute_dllexport_explicit_instantiation_decl);
7651         Diag(A->getLoc(), diag::note_attribute);
7652         break;
7653       }
7654     }
7655
7656     if (auto *A = ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {
7657       Diag(ExternLoc,
7658            diag::warn_attribute_dllexport_explicit_instantiation_decl);
7659       Diag(A->getLocation(), diag::note_attribute);
7660     }
7661   }
7662
7663   // In MSVC mode, dllimported explicit instantiation definitions are treated as
7664   // instantiation declarations for most purposes.
7665   bool DLLImportExplicitInstantiationDef = false;
7666   if (TSK == TSK_ExplicitInstantiationDefinition &&
7667       Context.getTargetInfo().getCXXABI().isMicrosoft()) {
7668     // Check for dllimport class template instantiation definitions.
7669     bool DLLImport =
7670         ClassTemplate->getTemplatedDecl()->getAttr<DLLImportAttr>();
7671     for (AttributeList *A = Attr; A; A = A->getNext()) {
7672       if (A->getKind() == AttributeList::AT_DLLImport)
7673         DLLImport = true;
7674       if (A->getKind() == AttributeList::AT_DLLExport) {
7675         // dllexport trumps dllimport here.
7676         DLLImport = false;
7677         break;
7678       }
7679     }
7680     if (DLLImport) {
7681       TSK = TSK_ExplicitInstantiationDeclaration;
7682       DLLImportExplicitInstantiationDef = true;
7683     }
7684   }
7685
7686   // Translate the parser's template argument list in our AST format.
7687   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
7688   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
7689
7690   // Check that the template argument list is well-formed for this
7691   // template.
7692   SmallVector<TemplateArgument, 4> Converted;
7693   if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
7694                                 TemplateArgs, false, Converted))
7695     return true;
7696
7697   // Find the class template specialization declaration that
7698   // corresponds to these arguments.
7699   void *InsertPos = nullptr;
7700   ClassTemplateSpecializationDecl *PrevDecl
7701     = ClassTemplate->findSpecialization(Converted, InsertPos);
7702
7703   TemplateSpecializationKind PrevDecl_TSK
7704     = PrevDecl ? PrevDecl->getTemplateSpecializationKind() : TSK_Undeclared;
7705
7706   // C++0x [temp.explicit]p2:
7707   //   [...] An explicit instantiation shall appear in an enclosing
7708   //   namespace of its template. [...]
7709   //
7710   // This is C++ DR 275.
7711   if (CheckExplicitInstantiationScope(*this, ClassTemplate, TemplateNameLoc,
7712                                       SS.isSet()))
7713     return true;
7714
7715   ClassTemplateSpecializationDecl *Specialization = nullptr;
7716
7717   bool HasNoEffect = false;
7718   if (PrevDecl) {
7719     if (CheckSpecializationInstantiationRedecl(TemplateNameLoc, TSK,
7720                                                PrevDecl, PrevDecl_TSK,
7721                                             PrevDecl->getPointOfInstantiation(),
7722                                                HasNoEffect))
7723       return PrevDecl;
7724
7725     // Even though HasNoEffect == true means that this explicit instantiation
7726     // has no effect on semantics, we go on to put its syntax in the AST.
7727
7728     if (PrevDecl_TSK == TSK_ImplicitInstantiation ||
7729         PrevDecl_TSK == TSK_Undeclared) {
7730       // Since the only prior class template specialization with these
7731       // arguments was referenced but not declared, reuse that
7732       // declaration node as our own, updating the source location
7733       // for the template name to reflect our new declaration.
7734       // (Other source locations will be updated later.)
7735       Specialization = PrevDecl;
7736       Specialization->setLocation(TemplateNameLoc);
7737       PrevDecl = nullptr;
7738     }
7739
7740     if (PrevDecl_TSK == TSK_ExplicitInstantiationDeclaration &&
7741         DLLImportExplicitInstantiationDef) {
7742       // The new specialization might add a dllimport attribute.
7743       HasNoEffect = false;
7744     }
7745   }
7746
7747   if (!Specialization) {
7748     // Create a new class template specialization declaration node for
7749     // this explicit specialization.
7750     Specialization
7751       = ClassTemplateSpecializationDecl::Create(Context, Kind,
7752                                              ClassTemplate->getDeclContext(),
7753                                                 KWLoc, TemplateNameLoc,
7754                                                 ClassTemplate,
7755                                                 Converted,
7756                                                 PrevDecl);
7757     SetNestedNameSpecifier(Specialization, SS);
7758
7759     if (!HasNoEffect && !PrevDecl) {
7760       // Insert the new specialization.
7761       ClassTemplate->AddSpecialization(Specialization, InsertPos);
7762     }
7763   }
7764
7765   // Build the fully-sugared type for this explicit instantiation as
7766   // the user wrote in the explicit instantiation itself. This means
7767   // that we'll pretty-print the type retrieved from the
7768   // specialization's declaration the way that the user actually wrote
7769   // the explicit instantiation, rather than formatting the name based
7770   // on the "canonical" representation used to store the template
7771   // arguments in the specialization.
7772   TypeSourceInfo *WrittenTy
7773     = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
7774                                                 TemplateArgs,
7775                                   Context.getTypeDeclType(Specialization));
7776   Specialization->setTypeAsWritten(WrittenTy);
7777
7778   // Set source locations for keywords.
7779   Specialization->setExternLoc(ExternLoc);
7780   Specialization->setTemplateKeywordLoc(TemplateLoc);
7781   Specialization->setBraceRange(SourceRange());
7782
7783   if (Attr)
7784     ProcessDeclAttributeList(S, Specialization, Attr);
7785
7786   // Add the explicit instantiation into its lexical context. However,
7787   // since explicit instantiations are never found by name lookup, we
7788   // just put it into the declaration context directly.
7789   Specialization->setLexicalDeclContext(CurContext);
7790   CurContext->addDecl(Specialization);
7791
7792   // Syntax is now OK, so return if it has no other effect on semantics.
7793   if (HasNoEffect) {
7794     // Set the template specialization kind.
7795     Specialization->setTemplateSpecializationKind(TSK);
7796     return Specialization;
7797   }
7798
7799   // C++ [temp.explicit]p3:
7800   //   A definition of a class template or class member template
7801   //   shall be in scope at the point of the explicit instantiation of
7802   //   the class template or class member template.
7803   //
7804   // This check comes when we actually try to perform the
7805   // instantiation.
7806   ClassTemplateSpecializationDecl *Def
7807     = cast_or_null<ClassTemplateSpecializationDecl>(
7808                                               Specialization->getDefinition());
7809   if (!Def)
7810     InstantiateClassTemplateSpecialization(TemplateNameLoc, Specialization, TSK);
7811   else if (TSK == TSK_ExplicitInstantiationDefinition) {
7812     MarkVTableUsed(TemplateNameLoc, Specialization, true);
7813     Specialization->setPointOfInstantiation(Def->getPointOfInstantiation());
7814   }
7815
7816   // Instantiate the members of this class template specialization.
7817   Def = cast_or_null<ClassTemplateSpecializationDecl>(
7818                                        Specialization->getDefinition());
7819   if (Def) {
7820     TemplateSpecializationKind Old_TSK = Def->getTemplateSpecializationKind();
7821     // Fix a TSK_ExplicitInstantiationDeclaration followed by a
7822     // TSK_ExplicitInstantiationDefinition
7823     if (Old_TSK == TSK_ExplicitInstantiationDeclaration &&
7824         (TSK == TSK_ExplicitInstantiationDefinition ||
7825          DLLImportExplicitInstantiationDef)) {
7826       // FIXME: Need to notify the ASTMutationListener that we did this.
7827       Def->setTemplateSpecializationKind(TSK);
7828
7829       if (!getDLLAttr(Def) && getDLLAttr(Specialization) &&
7830           (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
7831            Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
7832         // In the MS ABI, an explicit instantiation definition can add a dll
7833         // attribute to a template with a previous instantiation declaration.
7834         // MinGW doesn't allow this.
7835         auto *A = cast<InheritableAttr>(
7836             getDLLAttr(Specialization)->clone(getASTContext()));
7837         A->setInherited(true);
7838         Def->addAttr(A);
7839         dllExportImportClassTemplateSpecialization(*this, Def);
7840       }
7841     }
7842
7843     // Fix a TSK_ImplicitInstantiation followed by a
7844     // TSK_ExplicitInstantiationDefinition
7845     if (Old_TSK == TSK_ImplicitInstantiation &&
7846         Specialization->hasAttr<DLLExportAttr>() &&
7847         (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
7848          Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
7849       // In the MS ABI, an explicit instantiation definition can add a dll
7850       // attribute to a template with a previous implicit instantiation.
7851       // MinGW doesn't allow this. We limit clang to only adding dllexport, to
7852       // avoid potentially strange codegen behavior.  For example, if we extend
7853       // this conditional to dllimport, and we have a source file calling a
7854       // method on an implicitly instantiated template class instance and then
7855       // declaring a dllimport explicit instantiation definition for the same
7856       // template class, the codegen for the method call will not respect the
7857       // dllimport, while it will with cl. The Def will already have the DLL
7858       // attribute, since the Def and Specialization will be the same in the
7859       // case of Old_TSK == TSK_ImplicitInstantiation, and we already added the
7860       // attribute to the Specialization; we just need to make it take effect.
7861       assert(Def == Specialization &&
7862              "Def and Specialization should match for implicit instantiation");
7863       dllExportImportClassTemplateSpecialization(*this, Def);
7864     }
7865
7866     // Set the template specialization kind. Make sure it is set before
7867     // instantiating the members which will trigger ASTConsumer callbacks.
7868     Specialization->setTemplateSpecializationKind(TSK);
7869     InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK);
7870   } else {
7871
7872     // Set the template specialization kind.
7873     Specialization->setTemplateSpecializationKind(TSK);
7874   }
7875
7876   return Specialization;
7877 }
7878
7879 // Explicit instantiation of a member class of a class template.
7880 DeclResult
7881 Sema::ActOnExplicitInstantiation(Scope *S,
7882                                  SourceLocation ExternLoc,
7883                                  SourceLocation TemplateLoc,
7884                                  unsigned TagSpec,
7885                                  SourceLocation KWLoc,
7886                                  CXXScopeSpec &SS,
7887                                  IdentifierInfo *Name,
7888                                  SourceLocation NameLoc,
7889                                  AttributeList *Attr) {
7890
7891   bool Owned = false;
7892   bool IsDependent = false;
7893   Decl *TagD = ActOnTag(S, TagSpec, Sema::TUK_Reference,
7894                         KWLoc, SS, Name, NameLoc, Attr, AS_none,
7895                         /*ModulePrivateLoc=*/SourceLocation(),
7896                         MultiTemplateParamsArg(), Owned, IsDependent,
7897                         SourceLocation(), false, TypeResult(),
7898                         /*IsTypeSpecifier*/false);
7899   assert(!IsDependent && "explicit instantiation of dependent name not yet handled");
7900
7901   if (!TagD)
7902     return true;
7903
7904   TagDecl *Tag = cast<TagDecl>(TagD);
7905   assert(!Tag->isEnum() && "shouldn't see enumerations here");
7906
7907   if (Tag->isInvalidDecl())
7908     return true;
7909
7910   CXXRecordDecl *Record = cast<CXXRecordDecl>(Tag);
7911   CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
7912   if (!Pattern) {
7913     Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)
7914       << Context.getTypeDeclType(Record);
7915     Diag(Record->getLocation(), diag::note_nontemplate_decl_here);
7916     return true;
7917   }
7918
7919   // C++0x [temp.explicit]p2:
7920   //   If the explicit instantiation is for a class or member class, the
7921   //   elaborated-type-specifier in the declaration shall include a
7922   //   simple-template-id.
7923   //
7924   // C++98 has the same restriction, just worded differently.
7925   if (!ScopeSpecifierHasTemplateId(SS))
7926     Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)
7927       << Record << SS.getRange();
7928
7929   // C++0x [temp.explicit]p2:
7930   //   There are two forms of explicit instantiation: an explicit instantiation
7931   //   definition and an explicit instantiation declaration. An explicit
7932   //   instantiation declaration begins with the extern keyword. [...]
7933   TemplateSpecializationKind TSK
7934     = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
7935                            : TSK_ExplicitInstantiationDeclaration;
7936
7937   // C++0x [temp.explicit]p2:
7938   //   [...] An explicit instantiation shall appear in an enclosing
7939   //   namespace of its template. [...]
7940   //
7941   // This is C++ DR 275.
7942   CheckExplicitInstantiationScope(*this, Record, NameLoc, true);
7943
7944   // Verify that it is okay to explicitly instantiate here.
7945   CXXRecordDecl *PrevDecl
7946     = cast_or_null<CXXRecordDecl>(Record->getPreviousDecl());
7947   if (!PrevDecl && Record->getDefinition())
7948     PrevDecl = Record;
7949   if (PrevDecl) {
7950     MemberSpecializationInfo *MSInfo = PrevDecl->getMemberSpecializationInfo();
7951     bool HasNoEffect = false;
7952     assert(MSInfo && "No member specialization information?");
7953     if (CheckSpecializationInstantiationRedecl(TemplateLoc, TSK,
7954                                                PrevDecl,
7955                                         MSInfo->getTemplateSpecializationKind(),
7956                                              MSInfo->getPointOfInstantiation(),
7957                                                HasNoEffect))
7958       return true;
7959     if (HasNoEffect)
7960       return TagD;
7961   }
7962
7963   CXXRecordDecl *RecordDef
7964     = cast_or_null<CXXRecordDecl>(Record->getDefinition());
7965   if (!RecordDef) {
7966     // C++ [temp.explicit]p3:
7967     //   A definition of a member class of a class template shall be in scope
7968     //   at the point of an explicit instantiation of the member class.
7969     CXXRecordDecl *Def
7970       = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
7971     if (!Def) {
7972       Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
7973         << 0 << Record->getDeclName() << Record->getDeclContext();
7974       Diag(Pattern->getLocation(), diag::note_forward_declaration)
7975         << Pattern;
7976       return true;
7977     } else {
7978       if (InstantiateClass(NameLoc, Record, Def,
7979                            getTemplateInstantiationArgs(Record),
7980                            TSK))
7981         return true;
7982
7983       RecordDef = cast_or_null<CXXRecordDecl>(Record->getDefinition());
7984       if (!RecordDef)
7985         return true;
7986     }
7987   }
7988
7989   // Instantiate all of the members of the class.
7990   InstantiateClassMembers(NameLoc, RecordDef,
7991                           getTemplateInstantiationArgs(Record), TSK);
7992
7993   if (TSK == TSK_ExplicitInstantiationDefinition)
7994     MarkVTableUsed(NameLoc, RecordDef, true);
7995
7996   // FIXME: We don't have any representation for explicit instantiations of
7997   // member classes. Such a representation is not needed for compilation, but it
7998   // should be available for clients that want to see all of the declarations in
7999   // the source code.
8000   return TagD;
8001 }
8002
8003 DeclResult Sema::ActOnExplicitInstantiation(Scope *S,
8004                                             SourceLocation ExternLoc,
8005                                             SourceLocation TemplateLoc,
8006                                             Declarator &D) {
8007   // Explicit instantiations always require a name.
8008   // TODO: check if/when DNInfo should replace Name.
8009   DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
8010   DeclarationName Name = NameInfo.getName();
8011   if (!Name) {
8012     if (!D.isInvalidType())
8013       Diag(D.getDeclSpec().getLocStart(),
8014            diag::err_explicit_instantiation_requires_name)
8015         << D.getDeclSpec().getSourceRange()
8016         << D.getSourceRange();
8017
8018     return true;
8019   }
8020
8021   // The scope passed in may not be a decl scope.  Zip up the scope tree until
8022   // we find one that is.
8023   while ((S->getFlags() & Scope::DeclScope) == 0 ||
8024          (S->getFlags() & Scope::TemplateParamScope) != 0)
8025     S = S->getParent();
8026
8027   // Determine the type of the declaration.
8028   TypeSourceInfo *T = GetTypeForDeclarator(D, S);
8029   QualType R = T->getType();
8030   if (R.isNull())
8031     return true;
8032
8033   // C++ [dcl.stc]p1:
8034   //   A storage-class-specifier shall not be specified in [...] an explicit
8035   //   instantiation (14.7.2) directive.
8036   if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
8037     Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef)
8038       << Name;
8039     return true;
8040   } else if (D.getDeclSpec().getStorageClassSpec()
8041                                                 != DeclSpec::SCS_unspecified) {
8042     // Complain about then remove the storage class specifier.
8043     Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_storage_class)
8044       << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
8045
8046     D.getMutableDeclSpec().ClearStorageClassSpecs();
8047   }
8048
8049   // C++0x [temp.explicit]p1:
8050   //   [...] An explicit instantiation of a function template shall not use the
8051   //   inline or constexpr specifiers.
8052   // Presumably, this also applies to member functions of class templates as
8053   // well.
8054   if (D.getDeclSpec().isInlineSpecified())
8055     Diag(D.getDeclSpec().getInlineSpecLoc(),
8056          getLangOpts().CPlusPlus11 ?
8057            diag::err_explicit_instantiation_inline :
8058            diag::warn_explicit_instantiation_inline_0x)
8059       << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
8060   if (D.getDeclSpec().isConstexprSpecified() && R->isFunctionType())
8061     // FIXME: Add a fix-it to remove the 'constexpr' and add a 'const' if one is
8062     // not already specified.
8063     Diag(D.getDeclSpec().getConstexprSpecLoc(),
8064          diag::err_explicit_instantiation_constexpr);
8065
8066   // C++ Concepts TS [dcl.spec.concept]p1: The concept specifier shall be
8067   // applied only to the definition of a function template or variable template,
8068   // declared in namespace scope.
8069   if (D.getDeclSpec().isConceptSpecified()) {
8070     Diag(D.getDeclSpec().getConceptSpecLoc(),
8071          diag::err_concept_specified_specialization) << 0;
8072     return true;
8073   }
8074
8075   // C++0x [temp.explicit]p2:
8076   //   There are two forms of explicit instantiation: an explicit instantiation
8077   //   definition and an explicit instantiation declaration. An explicit
8078   //   instantiation declaration begins with the extern keyword. [...]
8079   TemplateSpecializationKind TSK
8080     = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
8081                            : TSK_ExplicitInstantiationDeclaration;
8082
8083   LookupResult Previous(*this, NameInfo, LookupOrdinaryName);
8084   LookupParsedName(Previous, S, &D.getCXXScopeSpec());
8085
8086   if (!R->isFunctionType()) {
8087     // C++ [temp.explicit]p1:
8088     //   A [...] static data member of a class template can be explicitly
8089     //   instantiated from the member definition associated with its class
8090     //   template.
8091     // C++1y [temp.explicit]p1:
8092     //   A [...] variable [...] template specialization can be explicitly
8093     //   instantiated from its template.
8094     if (Previous.isAmbiguous())
8095       return true;
8096
8097     VarDecl *Prev = Previous.getAsSingle<VarDecl>();
8098     VarTemplateDecl *PrevTemplate = Previous.getAsSingle<VarTemplateDecl>();
8099
8100     if (!PrevTemplate) {
8101       if (!Prev || !Prev->isStaticDataMember()) {
8102         // We expect to see a data data member here.
8103         Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)
8104             << Name;
8105         for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
8106              P != PEnd; ++P)
8107           Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
8108         return true;
8109       }
8110
8111       if (!Prev->getInstantiatedFromStaticDataMember()) {
8112         // FIXME: Check for explicit specialization?
8113         Diag(D.getIdentifierLoc(),
8114              diag::err_explicit_instantiation_data_member_not_instantiated)
8115             << Prev;
8116         Diag(Prev->getLocation(), diag::note_explicit_instantiation_here);
8117         // FIXME: Can we provide a note showing where this was declared?
8118         return true;
8119       }
8120     } else {
8121       // Explicitly instantiate a variable template.
8122
8123       // C++1y [dcl.spec.auto]p6:
8124       //   ... A program that uses auto or decltype(auto) in a context not
8125       //   explicitly allowed in this section is ill-formed.
8126       //
8127       // This includes auto-typed variable template instantiations.
8128       if (R->isUndeducedType()) {
8129         Diag(T->getTypeLoc().getLocStart(),
8130              diag::err_auto_not_allowed_var_inst);
8131         return true;
8132       }
8133
8134       if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
8135         // C++1y [temp.explicit]p3:
8136         //   If the explicit instantiation is for a variable, the unqualified-id
8137         //   in the declaration shall be a template-id.
8138         Diag(D.getIdentifierLoc(),
8139              diag::err_explicit_instantiation_without_template_id)
8140           << PrevTemplate;
8141         Diag(PrevTemplate->getLocation(),
8142              diag::note_explicit_instantiation_here);
8143         return true;
8144       }
8145
8146       // C++ Concepts TS [dcl.spec.concept]p7: A program shall not declare an
8147       // explicit instantiation (14.8.2) [...] of a concept definition.
8148       if (PrevTemplate->isConcept()) {
8149         Diag(D.getIdentifierLoc(), diag::err_concept_specialized)
8150             << 1 /*variable*/ << 0 /*explicitly instantiated*/;
8151         Diag(PrevTemplate->getLocation(), diag::note_previous_declaration);
8152         return true;
8153       }
8154
8155       // Translate the parser's template argument list into our AST format.
8156       TemplateArgumentListInfo TemplateArgs =
8157           makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);
8158
8159       DeclResult Res = CheckVarTemplateId(PrevTemplate, TemplateLoc,
8160                                           D.getIdentifierLoc(), TemplateArgs);
8161       if (Res.isInvalid())
8162         return true;
8163
8164       // Ignore access control bits, we don't need them for redeclaration
8165       // checking.
8166       Prev = cast<VarDecl>(Res.get());
8167     }
8168
8169     // C++0x [temp.explicit]p2:
8170     //   If the explicit instantiation is for a member function, a member class
8171     //   or a static data member of a class template specialization, the name of
8172     //   the class template specialization in the qualified-id for the member
8173     //   name shall be a simple-template-id.
8174     //
8175     // C++98 has the same restriction, just worded differently.
8176     //
8177     // This does not apply to variable template specializations, where the
8178     // template-id is in the unqualified-id instead.
8179     if (!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()) && !PrevTemplate)
8180       Diag(D.getIdentifierLoc(),
8181            diag::ext_explicit_instantiation_without_qualified_id)
8182         << Prev << D.getCXXScopeSpec().getRange();
8183
8184     // Check the scope of this explicit instantiation.
8185     CheckExplicitInstantiationScope(*this, Prev, D.getIdentifierLoc(), true);
8186
8187     // Verify that it is okay to explicitly instantiate here.
8188     TemplateSpecializationKind PrevTSK = Prev->getTemplateSpecializationKind();
8189     SourceLocation POI = Prev->getPointOfInstantiation();
8190     bool HasNoEffect = false;
8191     if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
8192                                                PrevTSK, POI, HasNoEffect))
8193       return true;
8194
8195     if (!HasNoEffect) {
8196       // Instantiate static data member or variable template.
8197
8198       Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
8199       if (PrevTemplate) {
8200         // Merge attributes.
8201         if (AttributeList *Attr = D.getDeclSpec().getAttributes().getList())
8202           ProcessDeclAttributeList(S, Prev, Attr);
8203       }
8204       if (TSK == TSK_ExplicitInstantiationDefinition)
8205         InstantiateVariableDefinition(D.getIdentifierLoc(), Prev);
8206     }
8207
8208     // Check the new variable specialization against the parsed input.
8209     if (PrevTemplate && Prev && !Context.hasSameType(Prev->getType(), R)) {
8210       Diag(T->getTypeLoc().getLocStart(),
8211            diag::err_invalid_var_template_spec_type)
8212           << 0 << PrevTemplate << R << Prev->getType();
8213       Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
8214           << 2 << PrevTemplate->getDeclName();
8215       return true;
8216     }
8217
8218     // FIXME: Create an ExplicitInstantiation node?
8219     return (Decl*) nullptr;
8220   }
8221
8222   // If the declarator is a template-id, translate the parser's template
8223   // argument list into our AST format.
8224   bool HasExplicitTemplateArgs = false;
8225   TemplateArgumentListInfo TemplateArgs;
8226   if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
8227     TemplateArgs = makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);
8228     HasExplicitTemplateArgs = true;
8229   }
8230
8231   // C++ [temp.explicit]p1:
8232   //   A [...] function [...] can be explicitly instantiated from its template.
8233   //   A member function [...] of a class template can be explicitly
8234   //  instantiated from the member definition associated with its class
8235   //  template.
8236   UnresolvedSet<8> Matches;
8237   AttributeList *Attr = D.getDeclSpec().getAttributes().getList();
8238   TemplateSpecCandidateSet FailedCandidates(D.getIdentifierLoc());
8239   for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
8240        P != PEnd; ++P) {
8241     NamedDecl *Prev = *P;
8242     if (!HasExplicitTemplateArgs) {
8243       if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) {
8244         QualType Adjusted = adjustCCAndNoReturn(R, Method->getType(),
8245                                                 /*AdjustExceptionSpec*/true);
8246         if (Context.hasSameUnqualifiedType(Method->getType(), Adjusted)) {
8247           Matches.clear();
8248
8249           Matches.addDecl(Method, P.getAccess());
8250           if (Method->getTemplateSpecializationKind() == TSK_Undeclared)
8251             break;
8252         }
8253       }
8254     }
8255
8256     FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Prev);
8257     if (!FunTmpl)
8258       continue;
8259
8260     TemplateDeductionInfo Info(FailedCandidates.getLocation());
8261     FunctionDecl *Specialization = nullptr;
8262     if (TemplateDeductionResult TDK
8263           = DeduceTemplateArguments(FunTmpl,
8264                                (HasExplicitTemplateArgs ? &TemplateArgs
8265                                                         : nullptr),
8266                                     R, Specialization, Info)) {
8267       // Keep track of almost-matches.
8268       FailedCandidates.addCandidate()
8269           .set(P.getPair(), FunTmpl->getTemplatedDecl(),
8270                MakeDeductionFailureInfo(Context, TDK, Info));
8271       (void)TDK;
8272       continue;
8273     }
8274
8275     // Target attributes are part of the cuda function signature, so
8276     // the cuda target of the instantiated function must match that of its
8277     // template.  Given that C++ template deduction does not take
8278     // target attributes into account, we reject candidates here that
8279     // have a different target.
8280     if (LangOpts.CUDA &&
8281         IdentifyCUDATarget(Specialization,
8282                            /* IgnoreImplicitHDAttributes = */ true) !=
8283             IdentifyCUDATarget(Attr)) {
8284       FailedCandidates.addCandidate().set(
8285           P.getPair(), FunTmpl->getTemplatedDecl(),
8286           MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
8287       continue;
8288     }
8289
8290     Matches.addDecl(Specialization, P.getAccess());
8291   }
8292
8293   // Find the most specialized function template specialization.
8294   UnresolvedSetIterator Result = getMostSpecialized(
8295       Matches.begin(), Matches.end(), FailedCandidates,
8296       D.getIdentifierLoc(),
8297       PDiag(diag::err_explicit_instantiation_not_known) << Name,
8298       PDiag(diag::err_explicit_instantiation_ambiguous) << Name,
8299       PDiag(diag::note_explicit_instantiation_candidate));
8300
8301   if (Result == Matches.end())
8302     return true;
8303
8304   // Ignore access control bits, we don't need them for redeclaration checking.
8305   FunctionDecl *Specialization = cast<FunctionDecl>(*Result);
8306
8307   // C++11 [except.spec]p4
8308   // In an explicit instantiation an exception-specification may be specified,
8309   // but is not required.
8310   // If an exception-specification is specified in an explicit instantiation
8311   // directive, it shall be compatible with the exception-specifications of
8312   // other declarations of that function.
8313   if (auto *FPT = R->getAs<FunctionProtoType>())
8314     if (FPT->hasExceptionSpec()) {
8315       unsigned DiagID =
8316           diag::err_mismatched_exception_spec_explicit_instantiation;
8317       if (getLangOpts().MicrosoftExt)
8318         DiagID = diag::ext_mismatched_exception_spec_explicit_instantiation;
8319       bool Result = CheckEquivalentExceptionSpec(
8320           PDiag(DiagID) << Specialization->getType(),
8321           PDiag(diag::note_explicit_instantiation_here),
8322           Specialization->getType()->getAs<FunctionProtoType>(),
8323           Specialization->getLocation(), FPT, D.getLocStart());
8324       // In Microsoft mode, mismatching exception specifications just cause a
8325       // warning.
8326       if (!getLangOpts().MicrosoftExt && Result)
8327         return true;
8328     }
8329
8330   if (Specialization->getTemplateSpecializationKind() == TSK_Undeclared) {
8331     Diag(D.getIdentifierLoc(),
8332          diag::err_explicit_instantiation_member_function_not_instantiated)
8333       << Specialization
8334       << (Specialization->getTemplateSpecializationKind() ==
8335           TSK_ExplicitSpecialization);
8336     Diag(Specialization->getLocation(), diag::note_explicit_instantiation_here);
8337     return true;
8338   }
8339
8340   FunctionDecl *PrevDecl = Specialization->getPreviousDecl();
8341   if (!PrevDecl && Specialization->isThisDeclarationADefinition())
8342     PrevDecl = Specialization;
8343
8344   if (PrevDecl) {
8345     bool HasNoEffect = false;
8346     if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK,
8347                                                PrevDecl,
8348                                      PrevDecl->getTemplateSpecializationKind(),
8349                                           PrevDecl->getPointOfInstantiation(),
8350                                                HasNoEffect))
8351       return true;
8352
8353     // FIXME: We may still want to build some representation of this
8354     // explicit specialization.
8355     if (HasNoEffect)
8356       return (Decl*) nullptr;
8357   }
8358
8359   Specialization->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
8360   if (Attr)
8361     ProcessDeclAttributeList(S, Specialization, Attr);
8362
8363   if (Specialization->isDefined()) {
8364     // Let the ASTConsumer know that this function has been explicitly
8365     // instantiated now, and its linkage might have changed.
8366     Consumer.HandleTopLevelDecl(DeclGroupRef(Specialization));
8367   } else if (TSK == TSK_ExplicitInstantiationDefinition)
8368     InstantiateFunctionDefinition(D.getIdentifierLoc(), Specialization);
8369
8370   // C++0x [temp.explicit]p2:
8371   //   If the explicit instantiation is for a member function, a member class
8372   //   or a static data member of a class template specialization, the name of
8373   //   the class template specialization in the qualified-id for the member
8374   //   name shall be a simple-template-id.
8375   //
8376   // C++98 has the same restriction, just worded differently.
8377   FunctionTemplateDecl *FunTmpl = Specialization->getPrimaryTemplate();
8378   if (D.getName().getKind() != UnqualifiedId::IK_TemplateId && !FunTmpl &&
8379       D.getCXXScopeSpec().isSet() &&
8380       !ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()))
8381     Diag(D.getIdentifierLoc(),
8382          diag::ext_explicit_instantiation_without_qualified_id)
8383     << Specialization << D.getCXXScopeSpec().getRange();
8384
8385   // C++ Concepts TS [dcl.spec.concept]p7: A program shall not declare an
8386   // explicit instantiation (14.8.2) [...] of a concept definition.
8387   if (FunTmpl && FunTmpl->isConcept() &&
8388       !D.getDeclSpec().isConceptSpecified()) {
8389     Diag(D.getIdentifierLoc(), diag::err_concept_specialized)
8390         << 0 /*function*/ << 0 /*explicitly instantiated*/;
8391     Diag(FunTmpl->getLocation(), diag::note_previous_declaration);
8392     return true;
8393   }
8394
8395   CheckExplicitInstantiationScope(*this,
8396                    FunTmpl? (NamedDecl *)FunTmpl
8397                           : Specialization->getInstantiatedFromMemberFunction(),
8398                                   D.getIdentifierLoc(),
8399                                   D.getCXXScopeSpec().isSet());
8400
8401   // FIXME: Create some kind of ExplicitInstantiationDecl here.
8402   return (Decl*) nullptr;
8403 }
8404
8405 TypeResult
8406 Sema::ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
8407                         const CXXScopeSpec &SS, IdentifierInfo *Name,
8408                         SourceLocation TagLoc, SourceLocation NameLoc) {
8409   // This has to hold, because SS is expected to be defined.
8410   assert(Name && "Expected a name in a dependent tag");
8411
8412   NestedNameSpecifier *NNS = SS.getScopeRep();
8413   if (!NNS)
8414     return true;
8415
8416   TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
8417
8418   if (TUK == TUK_Declaration || TUK == TUK_Definition) {
8419     Diag(NameLoc, diag::err_dependent_tag_decl)
8420       << (TUK == TUK_Definition) << Kind << SS.getRange();
8421     return true;
8422   }
8423
8424   // Create the resulting type.
8425   ElaboratedTypeKeyword Kwd = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
8426   QualType Result = Context.getDependentNameType(Kwd, NNS, Name);
8427
8428   // Create type-source location information for this type.
8429   TypeLocBuilder TLB;
8430   DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(Result);
8431   TL.setElaboratedKeywordLoc(TagLoc);
8432   TL.setQualifierLoc(SS.getWithLocInContext(Context));
8433   TL.setNameLoc(NameLoc);
8434   return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
8435 }
8436
8437 TypeResult
8438 Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
8439                         const CXXScopeSpec &SS, const IdentifierInfo &II,
8440                         SourceLocation IdLoc) {
8441   if (SS.isInvalid())
8442     return true;
8443
8444   if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
8445     Diag(TypenameLoc,
8446          getLangOpts().CPlusPlus11 ?
8447            diag::warn_cxx98_compat_typename_outside_of_template :
8448            diag::ext_typename_outside_of_template)
8449       << FixItHint::CreateRemoval(TypenameLoc);
8450
8451   NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
8452   QualType T = CheckTypenameType(TypenameLoc.isValid()? ETK_Typename : ETK_None,
8453                                  TypenameLoc, QualifierLoc, II, IdLoc);
8454   if (T.isNull())
8455     return true;
8456
8457   TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
8458   if (isa<DependentNameType>(T)) {
8459     DependentNameTypeLoc TL = TSI->getTypeLoc().castAs<DependentNameTypeLoc>();
8460     TL.setElaboratedKeywordLoc(TypenameLoc);
8461     TL.setQualifierLoc(QualifierLoc);
8462     TL.setNameLoc(IdLoc);
8463   } else {
8464     ElaboratedTypeLoc TL = TSI->getTypeLoc().castAs<ElaboratedTypeLoc>();
8465     TL.setElaboratedKeywordLoc(TypenameLoc);
8466     TL.setQualifierLoc(QualifierLoc);
8467     TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
8468   }
8469
8470   return CreateParsedType(T, TSI);
8471 }
8472
8473 TypeResult
8474 Sema::ActOnTypenameType(Scope *S,
8475                         SourceLocation TypenameLoc,
8476                         const CXXScopeSpec &SS,
8477                         SourceLocation TemplateKWLoc,
8478                         TemplateTy TemplateIn,
8479                         SourceLocation TemplateNameLoc,
8480                         SourceLocation LAngleLoc,
8481                         ASTTemplateArgsPtr TemplateArgsIn,
8482                         SourceLocation RAngleLoc) {
8483   if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
8484     Diag(TypenameLoc,
8485          getLangOpts().CPlusPlus11 ?
8486            diag::warn_cxx98_compat_typename_outside_of_template :
8487            diag::ext_typename_outside_of_template)
8488       << FixItHint::CreateRemoval(TypenameLoc);
8489
8490   // Translate the parser's template argument list in our AST format.
8491   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
8492   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
8493
8494   TemplateName Template = TemplateIn.get();
8495   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
8496     // Construct a dependent template specialization type.
8497     assert(DTN && "dependent template has non-dependent name?");
8498     assert(DTN->getQualifier() == SS.getScopeRep());
8499     QualType T = Context.getDependentTemplateSpecializationType(ETK_Typename,
8500                                                           DTN->getQualifier(),
8501                                                           DTN->getIdentifier(),
8502                                                                 TemplateArgs);
8503
8504     // Create source-location information for this type.
8505     TypeLocBuilder Builder;
8506     DependentTemplateSpecializationTypeLoc SpecTL
8507     = Builder.push<DependentTemplateSpecializationTypeLoc>(T);
8508     SpecTL.setElaboratedKeywordLoc(TypenameLoc);
8509     SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
8510     SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
8511     SpecTL.setTemplateNameLoc(TemplateNameLoc);
8512     SpecTL.setLAngleLoc(LAngleLoc);
8513     SpecTL.setRAngleLoc(RAngleLoc);
8514     for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
8515       SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
8516     return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
8517   }
8518
8519   QualType T = CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
8520   if (T.isNull())
8521     return true;
8522
8523   // Provide source-location information for the template specialization type.
8524   TypeLocBuilder Builder;
8525   TemplateSpecializationTypeLoc SpecTL
8526     = Builder.push<TemplateSpecializationTypeLoc>(T);
8527   SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
8528   SpecTL.setTemplateNameLoc(TemplateNameLoc);
8529   SpecTL.setLAngleLoc(LAngleLoc);
8530   SpecTL.setRAngleLoc(RAngleLoc);
8531   for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
8532     SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
8533
8534   T = Context.getElaboratedType(ETK_Typename, SS.getScopeRep(), T);
8535   ElaboratedTypeLoc TL = Builder.push<ElaboratedTypeLoc>(T);
8536   TL.setElaboratedKeywordLoc(TypenameLoc);
8537   TL.setQualifierLoc(SS.getWithLocInContext(Context));
8538
8539   TypeSourceInfo *TSI = Builder.getTypeSourceInfo(Context, T);
8540   return CreateParsedType(T, TSI);
8541 }
8542
8543
8544 /// Determine whether this failed name lookup should be treated as being
8545 /// disabled by a usage of std::enable_if.
8546 static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II,
8547                        SourceRange &CondRange) {
8548   // We must be looking for a ::type...
8549   if (!II.isStr("type"))
8550     return false;
8551
8552   // ... within an explicitly-written template specialization...
8553   if (!NNS || !NNS.getNestedNameSpecifier()->getAsType())
8554     return false;
8555   TypeLoc EnableIfTy = NNS.getTypeLoc();
8556   TemplateSpecializationTypeLoc EnableIfTSTLoc =
8557       EnableIfTy.getAs<TemplateSpecializationTypeLoc>();
8558   if (!EnableIfTSTLoc || EnableIfTSTLoc.getNumArgs() == 0)
8559     return false;
8560   const TemplateSpecializationType *EnableIfTST =
8561     cast<TemplateSpecializationType>(EnableIfTSTLoc.getTypePtr());
8562
8563   // ... which names a complete class template declaration...
8564   const TemplateDecl *EnableIfDecl =
8565     EnableIfTST->getTemplateName().getAsTemplateDecl();
8566   if (!EnableIfDecl || EnableIfTST->isIncompleteType())
8567     return false;
8568
8569   // ... called "enable_if".
8570   const IdentifierInfo *EnableIfII =
8571     EnableIfDecl->getDeclName().getAsIdentifierInfo();
8572   if (!EnableIfII || !EnableIfII->isStr("enable_if"))
8573     return false;
8574
8575   // Assume the first template argument is the condition.
8576   CondRange = EnableIfTSTLoc.getArgLoc(0).getSourceRange();
8577   return true;
8578 }
8579
8580 /// \brief Build the type that describes a C++ typename specifier,
8581 /// e.g., "typename T::type".
8582 QualType
8583 Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword,
8584                         SourceLocation KeywordLoc,
8585                         NestedNameSpecifierLoc QualifierLoc,
8586                         const IdentifierInfo &II,
8587                         SourceLocation IILoc) {
8588   CXXScopeSpec SS;
8589   SS.Adopt(QualifierLoc);
8590
8591   DeclContext *Ctx = computeDeclContext(SS);
8592   if (!Ctx) {
8593     // If the nested-name-specifier is dependent and couldn't be
8594     // resolved to a type, build a typename type.
8595     assert(QualifierLoc.getNestedNameSpecifier()->isDependent());
8596     return Context.getDependentNameType(Keyword,
8597                                         QualifierLoc.getNestedNameSpecifier(),
8598                                         &II);
8599   }
8600
8601   // If the nested-name-specifier refers to the current instantiation,
8602   // the "typename" keyword itself is superfluous. In C++03, the
8603   // program is actually ill-formed. However, DR 382 (in C++0x CD1)
8604   // allows such extraneous "typename" keywords, and we retroactively
8605   // apply this DR to C++03 code with only a warning. In any case we continue.
8606
8607   if (RequireCompleteDeclContext(SS, Ctx))
8608     return QualType();
8609
8610   DeclarationName Name(&II);
8611   LookupResult Result(*this, Name, IILoc, LookupOrdinaryName);
8612   LookupQualifiedName(Result, Ctx, SS);
8613   unsigned DiagID = 0;
8614   Decl *Referenced = nullptr;
8615   switch (Result.getResultKind()) {
8616   case LookupResult::NotFound: {
8617     // If we're looking up 'type' within a template named 'enable_if', produce
8618     // a more specific diagnostic.
8619     SourceRange CondRange;
8620     if (isEnableIf(QualifierLoc, II, CondRange)) {
8621       Diag(CondRange.getBegin(), diag::err_typename_nested_not_found_enable_if)
8622         << Ctx << CondRange;
8623       return QualType();
8624     }
8625
8626     DiagID = diag::err_typename_nested_not_found;
8627     break;
8628   }
8629
8630   case LookupResult::FoundUnresolvedValue: {
8631     // We found a using declaration that is a value. Most likely, the using
8632     // declaration itself is meant to have the 'typename' keyword.
8633     SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
8634                           IILoc);
8635     Diag(IILoc, diag::err_typename_refers_to_using_value_decl)
8636       << Name << Ctx << FullRange;
8637     if (UnresolvedUsingValueDecl *Using
8638           = dyn_cast<UnresolvedUsingValueDecl>(Result.getRepresentativeDecl())){
8639       SourceLocation Loc = Using->getQualifierLoc().getBeginLoc();
8640       Diag(Loc, diag::note_using_value_decl_missing_typename)
8641         << FixItHint::CreateInsertion(Loc, "typename ");
8642     }
8643   }
8644   // Fall through to create a dependent typename type, from which we can recover
8645   // better.
8646
8647   case LookupResult::NotFoundInCurrentInstantiation:
8648     // Okay, it's a member of an unknown instantiation.
8649     return Context.getDependentNameType(Keyword,
8650                                         QualifierLoc.getNestedNameSpecifier(),
8651                                         &II);
8652
8653   case LookupResult::Found:
8654     if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) {
8655       // We found a type. Build an ElaboratedType, since the
8656       // typename-specifier was just sugar.
8657       MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
8658       return Context.getElaboratedType(ETK_Typename,
8659                                        QualifierLoc.getNestedNameSpecifier(),
8660                                        Context.getTypeDeclType(Type));
8661     }
8662
8663     DiagID = diag::err_typename_nested_not_type;
8664     Referenced = Result.getFoundDecl();
8665     break;
8666
8667   case LookupResult::FoundOverloaded:
8668     DiagID = diag::err_typename_nested_not_type;
8669     Referenced = *Result.begin();
8670     break;
8671
8672   case LookupResult::Ambiguous:
8673     return QualType();
8674   }
8675
8676   // If we get here, it's because name lookup did not find a
8677   // type. Emit an appropriate diagnostic and return an error.
8678   SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
8679                         IILoc);
8680   Diag(IILoc, DiagID) << FullRange << Name << Ctx;
8681   if (Referenced)
8682     Diag(Referenced->getLocation(), diag::note_typename_refers_here)
8683       << Name;
8684   return QualType();
8685 }
8686
8687 namespace {
8688   // See Sema::RebuildTypeInCurrentInstantiation
8689   class CurrentInstantiationRebuilder
8690     : public TreeTransform<CurrentInstantiationRebuilder> {
8691     SourceLocation Loc;
8692     DeclarationName Entity;
8693
8694   public:
8695     typedef TreeTransform<CurrentInstantiationRebuilder> inherited;
8696
8697     CurrentInstantiationRebuilder(Sema &SemaRef,
8698                                   SourceLocation Loc,
8699                                   DeclarationName Entity)
8700     : TreeTransform<CurrentInstantiationRebuilder>(SemaRef),
8701       Loc(Loc), Entity(Entity) { }
8702
8703     /// \brief Determine whether the given type \p T has already been
8704     /// transformed.
8705     ///
8706     /// For the purposes of type reconstruction, a type has already been
8707     /// transformed if it is NULL or if it is not dependent.
8708     bool AlreadyTransformed(QualType T) {
8709       return T.isNull() || !T->isDependentType();
8710     }
8711
8712     /// \brief Returns the location of the entity whose type is being
8713     /// rebuilt.
8714     SourceLocation getBaseLocation() { return Loc; }
8715
8716     /// \brief Returns the name of the entity whose type is being rebuilt.
8717     DeclarationName getBaseEntity() { return Entity; }
8718
8719     /// \brief Sets the "base" location and entity when that
8720     /// information is known based on another transformation.
8721     void setBase(SourceLocation Loc, DeclarationName Entity) {
8722       this->Loc = Loc;
8723       this->Entity = Entity;
8724     }
8725
8726     ExprResult TransformLambdaExpr(LambdaExpr *E) {
8727       // Lambdas never need to be transformed.
8728       return E;
8729     }
8730   };
8731 } // end anonymous namespace
8732
8733 /// \brief Rebuilds a type within the context of the current instantiation.
8734 ///
8735 /// The type \p T is part of the type of an out-of-line member definition of
8736 /// a class template (or class template partial specialization) that was parsed
8737 /// and constructed before we entered the scope of the class template (or
8738 /// partial specialization thereof). This routine will rebuild that type now
8739 /// that we have entered the declarator's scope, which may produce different
8740 /// canonical types, e.g.,
8741 ///
8742 /// \code
8743 /// template<typename T>
8744 /// struct X {
8745 ///   typedef T* pointer;
8746 ///   pointer data();
8747 /// };
8748 ///
8749 /// template<typename T>
8750 /// typename X<T>::pointer X<T>::data() { ... }
8751 /// \endcode
8752 ///
8753 /// Here, the type "typename X<T>::pointer" will be created as a DependentNameType,
8754 /// since we do not know that we can look into X<T> when we parsed the type.
8755 /// This function will rebuild the type, performing the lookup of "pointer"
8756 /// in X<T> and returning an ElaboratedType whose canonical type is the same
8757 /// as the canonical type of T*, allowing the return types of the out-of-line
8758 /// definition and the declaration to match.
8759 TypeSourceInfo *Sema::RebuildTypeInCurrentInstantiation(TypeSourceInfo *T,
8760                                                         SourceLocation Loc,
8761                                                         DeclarationName Name) {
8762   if (!T || !T->getType()->isDependentType())
8763     return T;
8764
8765   CurrentInstantiationRebuilder Rebuilder(*this, Loc, Name);
8766   return Rebuilder.TransformType(T);
8767 }
8768
8769 ExprResult Sema::RebuildExprInCurrentInstantiation(Expr *E) {
8770   CurrentInstantiationRebuilder Rebuilder(*this, E->getExprLoc(),
8771                                           DeclarationName());
8772   return Rebuilder.TransformExpr(E);
8773 }
8774
8775 bool Sema::RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS) {
8776   if (SS.isInvalid())
8777     return true;
8778
8779   NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
8780   CurrentInstantiationRebuilder Rebuilder(*this, SS.getRange().getBegin(),
8781                                           DeclarationName());
8782   NestedNameSpecifierLoc Rebuilt
8783     = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);
8784   if (!Rebuilt)
8785     return true;
8786
8787   SS.Adopt(Rebuilt);
8788   return false;
8789 }
8790
8791 /// \brief Rebuild the template parameters now that we know we're in a current
8792 /// instantiation.
8793 bool Sema::RebuildTemplateParamsInCurrentInstantiation(
8794                                                TemplateParameterList *Params) {
8795   for (unsigned I = 0, N = Params->size(); I != N; ++I) {
8796     Decl *Param = Params->getParam(I);
8797
8798     // There is nothing to rebuild in a type parameter.
8799     if (isa<TemplateTypeParmDecl>(Param))
8800       continue;
8801
8802     // Rebuild the template parameter list of a template template parameter.
8803     if (TemplateTemplateParmDecl *TTP
8804         = dyn_cast<TemplateTemplateParmDecl>(Param)) {
8805       if (RebuildTemplateParamsInCurrentInstantiation(
8806             TTP->getTemplateParameters()))
8807         return true;
8808
8809       continue;
8810     }
8811
8812     // Rebuild the type of a non-type template parameter.
8813     NonTypeTemplateParmDecl *NTTP = cast<NonTypeTemplateParmDecl>(Param);
8814     TypeSourceInfo *NewTSI
8815       = RebuildTypeInCurrentInstantiation(NTTP->getTypeSourceInfo(),
8816                                           NTTP->getLocation(),
8817                                           NTTP->getDeclName());
8818     if (!NewTSI)
8819       return true;
8820
8821     if (NewTSI != NTTP->getTypeSourceInfo()) {
8822       NTTP->setTypeSourceInfo(NewTSI);
8823       NTTP->setType(NewTSI->getType());
8824     }
8825   }
8826
8827   return false;
8828 }
8829
8830 /// \brief Produces a formatted string that describes the binding of
8831 /// template parameters to template arguments.
8832 std::string
8833 Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params,
8834                                       const TemplateArgumentList &Args) {
8835   return getTemplateArgumentBindingsText(Params, Args.data(), Args.size());
8836 }
8837
8838 std::string
8839 Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params,
8840                                       const TemplateArgument *Args,
8841                                       unsigned NumArgs) {
8842   SmallString<128> Str;
8843   llvm::raw_svector_ostream Out(Str);
8844
8845   if (!Params || Params->size() == 0 || NumArgs == 0)
8846     return std::string();
8847
8848   for (unsigned I = 0, N = Params->size(); I != N; ++I) {
8849     if (I >= NumArgs)
8850       break;
8851
8852     if (I == 0)
8853       Out << "[with ";
8854     else
8855       Out << ", ";
8856
8857     if (const IdentifierInfo *Id = Params->getParam(I)->getIdentifier()) {
8858       Out << Id->getName();
8859     } else {
8860       Out << '$' << I;
8861     }
8862
8863     Out << " = ";
8864     Args[I].print(getPrintingPolicy(), Out);
8865   }
8866
8867   Out << ']';
8868   return Out.str();
8869 }
8870
8871 void Sema::MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD,
8872                                     CachedTokens &Toks) {
8873   if (!FD)
8874     return;
8875
8876   auto LPT = llvm::make_unique<LateParsedTemplate>();
8877
8878   // Take tokens to avoid allocations
8879   LPT->Toks.swap(Toks);
8880   LPT->D = FnD;
8881   LateParsedTemplateMap.insert(std::make_pair(FD, std::move(LPT)));
8882
8883   FD->setLateTemplateParsed(true);
8884 }
8885
8886 void Sema::UnmarkAsLateParsedTemplate(FunctionDecl *FD) {
8887   if (!FD)
8888     return;
8889   FD->setLateTemplateParsed(false);
8890 }
8891
8892 bool Sema::IsInsideALocalClassWithinATemplateFunction() {
8893   DeclContext *DC = CurContext;
8894
8895   while (DC) {
8896     if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(CurContext)) {
8897       const FunctionDecl *FD = RD->isLocalClass();
8898       return (FD && FD->getTemplatedKind() != FunctionDecl::TK_NonTemplate);
8899     } else if (DC->isTranslationUnit() || DC->isNamespace())
8900       return false;
8901
8902     DC = DC->getParent();
8903   }
8904   return false;
8905 }
8906
8907 namespace {
8908 /// \brief Walk the path from which a declaration was instantiated, and check
8909 /// that every explicit specialization along that path is visible. This enforces
8910 /// C++ [temp.expl.spec]/6:
8911 ///
8912 ///   If a template, a member template or a member of a class template is
8913 ///   explicitly specialized then that specialization shall be declared before
8914 ///   the first use of that specialization that would cause an implicit
8915 ///   instantiation to take place, in every translation unit in which such a
8916 ///   use occurs; no diagnostic is required.
8917 ///
8918 /// and also C++ [temp.class.spec]/1:
8919 ///
8920 ///   A partial specialization shall be declared before the first use of a
8921 ///   class template specialization that would make use of the partial
8922 ///   specialization as the result of an implicit or explicit instantiation
8923 ///   in every translation unit in which such a use occurs; no diagnostic is
8924 ///   required.
8925 class ExplicitSpecializationVisibilityChecker {
8926   Sema &S;
8927   SourceLocation Loc;
8928   llvm::SmallVector<Module *, 8> Modules;
8929
8930 public:
8931   ExplicitSpecializationVisibilityChecker(Sema &S, SourceLocation Loc)
8932       : S(S), Loc(Loc) {}
8933
8934   void check(NamedDecl *ND) {
8935     if (auto *FD = dyn_cast<FunctionDecl>(ND))
8936       return checkImpl(FD);
8937     if (auto *RD = dyn_cast<CXXRecordDecl>(ND))
8938       return checkImpl(RD);
8939     if (auto *VD = dyn_cast<VarDecl>(ND))
8940       return checkImpl(VD);
8941     if (auto *ED = dyn_cast<EnumDecl>(ND))
8942       return checkImpl(ED);
8943   }
8944
8945 private:
8946   void diagnose(NamedDecl *D, bool IsPartialSpec) {
8947     auto Kind = IsPartialSpec ? Sema::MissingImportKind::PartialSpecialization
8948                               : Sema::MissingImportKind::ExplicitSpecialization;
8949     const bool Recover = true;
8950
8951     // If we got a custom set of modules (because only a subset of the
8952     // declarations are interesting), use them, otherwise let
8953     // diagnoseMissingImport intelligently pick some.
8954     if (Modules.empty())
8955       S.diagnoseMissingImport(Loc, D, Kind, Recover);
8956     else
8957       S.diagnoseMissingImport(Loc, D, D->getLocation(), Modules, Kind, Recover);
8958   }
8959
8960   // Check a specific declaration. There are three problematic cases:
8961   //
8962   //  1) The declaration is an explicit specialization of a template
8963   //     specialization.
8964   //  2) The declaration is an explicit specialization of a member of an
8965   //     templated class.
8966   //  3) The declaration is an instantiation of a template, and that template
8967   //     is an explicit specialization of a member of a templated class.
8968   //
8969   // We don't need to go any deeper than that, as the instantiation of the
8970   // surrounding class / etc is not triggered by whatever triggered this
8971   // instantiation, and thus should be checked elsewhere.
8972   template<typename SpecDecl>
8973   void checkImpl(SpecDecl *Spec) {
8974     bool IsHiddenExplicitSpecialization = false;
8975     if (Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {
8976       IsHiddenExplicitSpecialization =
8977           Spec->getMemberSpecializationInfo()
8978               ? !S.hasVisibleMemberSpecialization(Spec, &Modules)
8979               : !S.hasVisibleDeclaration(Spec);
8980     } else {
8981       checkInstantiated(Spec);
8982     }
8983
8984     if (IsHiddenExplicitSpecialization)
8985       diagnose(Spec->getMostRecentDecl(), false);
8986   }
8987
8988   void checkInstantiated(FunctionDecl *FD) {
8989     if (auto *TD = FD->getPrimaryTemplate())
8990       checkTemplate(TD);
8991   }
8992
8993   void checkInstantiated(CXXRecordDecl *RD) {
8994     auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
8995     if (!SD)
8996       return;
8997
8998     auto From = SD->getSpecializedTemplateOrPartial();
8999     if (auto *TD = From.dyn_cast<ClassTemplateDecl *>())
9000       checkTemplate(TD);
9001     else if (auto *TD =
9002                  From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
9003       if (!S.hasVisibleDeclaration(TD))
9004         diagnose(TD, true);
9005       checkTemplate(TD);
9006     }
9007   }
9008
9009   void checkInstantiated(VarDecl *RD) {
9010     auto *SD = dyn_cast<VarTemplateSpecializationDecl>(RD);
9011     if (!SD)
9012       return;
9013
9014     auto From = SD->getSpecializedTemplateOrPartial();
9015     if (auto *TD = From.dyn_cast<VarTemplateDecl *>())
9016       checkTemplate(TD);
9017     else if (auto *TD =
9018                  From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
9019       if (!S.hasVisibleDeclaration(TD))
9020         diagnose(TD, true);
9021       checkTemplate(TD);
9022     }
9023   }
9024
9025   void checkInstantiated(EnumDecl *FD) {}
9026
9027   template<typename TemplDecl>
9028   void checkTemplate(TemplDecl *TD) {
9029     if (TD->isMemberSpecialization()) {
9030       if (!S.hasVisibleMemberSpecialization(TD, &Modules))
9031         diagnose(TD->getMostRecentDecl(), false);
9032     }
9033   }
9034 };
9035 } // end anonymous namespace
9036
9037 void Sema::checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec) {
9038   if (!getLangOpts().Modules)
9039     return;
9040
9041   ExplicitSpecializationVisibilityChecker(*this, Loc).check(Spec);
9042 }
9043
9044 /// \brief Check whether a template partial specialization that we've discovered
9045 /// is hidden, and produce suitable diagnostics if so.
9046 void Sema::checkPartialSpecializationVisibility(SourceLocation Loc,
9047                                                 NamedDecl *Spec) {
9048   llvm::SmallVector<Module *, 8> Modules;
9049   if (!hasVisibleDeclaration(Spec, &Modules))
9050     diagnoseMissingImport(Loc, Spec, Spec->getLocation(), Modules,
9051                           MissingImportKind::PartialSpecialization,
9052                           /*Recover*/true);
9053 }