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 "clang/Sema/SemaInternal.h"
  13 #include "clang/Sema/Lookup.h"
  14 #include "clang/Sema/Scope.h"
  15 #include "clang/Sema/Template.h"
  16 #include "clang/Sema/TemplateDeduction.h"
  17 #include "TreeTransform.h"
  18 #include "clang/AST/ASTContext.h"
  19 #include "clang/AST/Expr.h"
  20 #include "clang/AST/ExprCXX.h"
  21 #include "clang/AST/DeclFriend.h"
  22 #include "clang/AST/DeclTemplate.h"
  23 #include "clang/AST/RecursiveASTVisitor.h"
  24 #include "clang/AST/TypeVisitor.h"
  25 #include "clang/Sema/DeclSpec.h"
  26 #include "clang/Sema/ParsedTemplate.h"
  27 #include "clang/Basic/LangOptions.h"
  28 #include "clang/Basic/PartialDiagnostic.h"
  29 #include "llvm/ADT/StringExtras.h"
  30 using namespace clang;
  31 using namespace sema;
  32
  33 // Exported for use by Parser.
  34 SourceRange
  35 clang::getTemplateParamsRange(TemplateParameterList const * const *Ps,
  36                               unsigned N) {
  37   if (!N) return SourceRange();
  38   return SourceRange(Ps[0]->getTemplateLoc(), Ps[N-1]->getRAngleLoc());
  39 }
  40
  41 /// \brief Determine whether the declaration found is acceptable as the name
  42 /// of a template and, if so, return that template declaration. Otherwise,
  43 /// returns NULL.
  44 static NamedDecl *isAcceptableTemplateName(ASTContext &Context,
  45                                            NamedDecl *Orig) {
  46   NamedDecl *D = Orig->getUnderlyingDecl();
  47
  48   if (isa<TemplateDecl>(D))
  49     return Orig;
  50
  51   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
  52     // C++ [temp.local]p1:
  53     //   Like normal (non-template) classes, class templates have an
  54     //   injected-class-name (Clause 9). The injected-class-name
  55     //   can be used with or without a template-argument-list. When
  56     //   it is used without a template-argument-list, it is
  57     //   equivalent to the injected-class-name followed by the
  58     //   template-parameters of the class template enclosed in
  59     //   <>. When it is used with a template-argument-list, it
  60     //   refers to the specified class template specialization,
  61     //   which could be the current specialization or another
  62     //   specialization.
  63     if (Record->isInjectedClassName()) {
  64       Record = cast<CXXRecordDecl>(Record->getDeclContext());
  65       if (Record->getDescribedClassTemplate())
  66         return Record->getDescribedClassTemplate();
  67
  68       if (ClassTemplateSpecializationDecl *Spec
  69             = dyn_cast<ClassTemplateSpecializationDecl>(Record))
  70         return Spec->getSpecializedTemplate();
  71     }
  72
  73     return 0;
  74   }
  75
  76   return 0;
  77 }
  78
  79 void Sema::FilterAcceptableTemplateNames(LookupResult &R) {
  80   // The set of class templates we've already seen.
  81   llvm::SmallPtrSet<ClassTemplateDecl *, 8> ClassTemplates;
  82   LookupResult::Filter filter = R.makeFilter();
  83   while (filter.hasNext()) {
  84     NamedDecl *Orig = filter.next();
  85     NamedDecl *Repl = isAcceptableTemplateName(Context, Orig);
  86     if (!Repl)
  87       filter.erase();
  88     else if (Repl != Orig) {
  89
  90       // C++ [temp.local]p3:
  91       //   A lookup that finds an injected-class-name (10.2) can result in an
  92       //   ambiguity in certain cases (for example, if it is found in more than
  93       //   one base class). If all of the injected-class-names that are found
  94       //   refer to specializations of the same class template, and if the name
  95       //   is used as a template-name, the reference refers to the class
  96       //   template itself and not a specialization thereof, and is not
  97       //   ambiguous.
  98       if (ClassTemplateDecl *ClassTmpl = dyn_cast<ClassTemplateDecl>(Repl))
  99         if (!ClassTemplates.insert(ClassTmpl)) {
 100           filter.erase();
 101           continue;
 102         }
 103
 104       // FIXME: we promote access to public here as a workaround to
 105       // the fact that LookupResult doesn't let us remember that we
 106       // found this template through a particular injected class name,
 107       // which means we end up doing nasty things to the invariants.
 108       // Pretending that access is public is *much* safer.
 109       filter.replace(Repl, AS_public);
 110     }
 111   }
 112   filter.done();
 113 }
 114
 115 bool Sema::hasAnyAcceptableTemplateNames(LookupResult &R) {
 116   for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I)
 117     if (isAcceptableTemplateName(Context, *I))
 118       return true;
 119
 120   return false;
 121 }
 122
 123 TemplateNameKind Sema::isTemplateName(Scope *S,
 124                                       CXXScopeSpec &SS,
 125                                       bool hasTemplateKeyword,
 126                                       UnqualifiedId &Name,
 127                                       ParsedType ObjectTypePtr,
 128                                       bool EnteringContext,
 129                                       TemplateTy &TemplateResult,
 130                                       bool &MemberOfUnknownSpecialization) {
 131   assert(getLangOptions().CPlusPlus && "No template names in C!");
 132
 133   DeclarationName TName;
 134   MemberOfUnknownSpecialization = false;
 135
 136   switch (Name.getKind()) {
 137   case UnqualifiedId::IK_Identifier:
 138     TName = DeclarationName(Name.Identifier);
 139     break;
 140
 141   case UnqualifiedId::IK_OperatorFunctionId:
 142     TName = Context.DeclarationNames.getCXXOperatorName(
 143                                               Name.OperatorFunctionId.Operator);
 144     break;
 145
 146   case UnqualifiedId::IK_LiteralOperatorId:
 147     TName = Context.DeclarationNames.getCXXLiteralOperatorName(Name.Identifier);
 148     break;
 149
 150   default:
 151     return TNK_Non_template;
 152   }
 153
 154   QualType ObjectType = ObjectTypePtr.get();
 155
 156   LookupResult R(*this, TName, Name.getSourceRange().getBegin(),
 157                  LookupOrdinaryName);
 158   LookupTemplateName(R, S, SS, ObjectType, EnteringContext,
 159                      MemberOfUnknownSpecialization);
 160   if (R.empty()) return TNK_Non_template;
 161   if (R.isAmbiguous()) {
 162     // Suppress diagnostics;  we'll redo this lookup later.
 163     R.suppressDiagnostics();
 164
 165     // FIXME: we might have ambiguous templates, in which case we
 166     // should at least parse them properly!
 167     return TNK_Non_template;
 168   }
 169
 170   TemplateName Template;
 171   TemplateNameKind TemplateKind;
 172
 173   unsigned ResultCount = R.end() - R.begin();
 174   if (ResultCount > 1) {
 175     // We assume that we'll preserve the qualifier from a function
 176     // template name in other ways.
 177     Template = Context.getOverloadedTemplateName(R.begin(), R.end());
 178     TemplateKind = TNK_Function_template;
 179
 180     // We'll do this lookup again later.
 181     R.suppressDiagnostics();
 182   } else {
 183     TemplateDecl *TD = cast<TemplateDecl>((*R.begin())->getUnderlyingDecl());
 184
 185     if (SS.isSet() && !SS.isInvalid()) {
 186       NestedNameSpecifier *Qualifier
 187         = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
 188       Template = Context.getQualifiedTemplateName(Qualifier,
 189                                                   hasTemplateKeyword, TD);
 190     } else {
 191       Template = TemplateName(TD);
 192     }
 193
 194     if (isa<FunctionTemplateDecl>(TD)) {
 195       TemplateKind = TNK_Function_template;
 196
 197       // We'll do this lookup again later.
 198       R.suppressDiagnostics();
 199     } else {
 200       assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||
 201              isa<TypeAliasTemplateDecl>(TD));
 202       TemplateKind = TNK_Type_template;
 203     }
 204   }
 205
 206   TemplateResult = TemplateTy::make(Template);
 207   return TemplateKind;
 208 }
 209
 210 bool Sema::DiagnoseUnknownTemplateName(const IdentifierInfo &II,
 211                                        SourceLocation IILoc,
 212                                        Scope *S,
 213                                        const CXXScopeSpec *SS,
 214                                        TemplateTy &SuggestedTemplate,
 215                                        TemplateNameKind &SuggestedKind) {
 216   // We can't recover unless there's a dependent scope specifier preceding the
 217   // template name.
 218   // FIXME: Typo correction?
 219   if (!SS || !SS->isSet() || !isDependentScopeSpecifier(*SS) ||
 220       computeDeclContext(*SS))
 221     return false;
 222
 223   // The code is missing a 'template' keyword prior to the dependent template
 224   // name.
 225   NestedNameSpecifier *Qualifier = (NestedNameSpecifier*)SS->getScopeRep();
 226   Diag(IILoc, diag::err_template_kw_missing)
 227     << Qualifier << II.getName()
 228     << FixItHint::CreateInsertion(IILoc, "template ");
 229   SuggestedTemplate
 230     = TemplateTy::make(Context.getDependentTemplateName(Qualifier, &II));
 231   SuggestedKind = TNK_Dependent_template_name;
 232   return true;
 233 }
 234
 235 void Sema::LookupTemplateName(LookupResult &Found,
 236                               Scope *S, CXXScopeSpec &SS,
 237                               QualType ObjectType,
 238                               bool EnteringContext,
 239                               bool &MemberOfUnknownSpecialization) {
 240   // Determine where to perform name lookup
 241   MemberOfUnknownSpecialization = false;
 242   DeclContext *LookupCtx = 0;
 243   bool isDependent = false;
 244   if (!ObjectType.isNull()) {
 245     // This nested-name-specifier occurs in a member access expression, e.g.,
 246     // x->B::f, and we are looking into the type of the object.
 247     assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
 248     LookupCtx = computeDeclContext(ObjectType);
 249     isDependent = ObjectType->isDependentType();
 250     assert((isDependent || !ObjectType->isIncompleteType()) &&
 251            "Caller should have completed object type");
 252   } else if (SS.isSet()) {
 253     // This nested-name-specifier occurs after another nested-name-specifier,
 254     // so long into the context associated with the prior nested-name-specifier.
 255     LookupCtx = computeDeclContext(SS, EnteringContext);
 256     isDependent = isDependentScopeSpecifier(SS);
 257
 258     // The declaration context must be complete.
 259     if (LookupCtx && RequireCompleteDeclContext(SS, LookupCtx))
 260       return;
 261   }
 262
 263   bool ObjectTypeSearchedInScope = false;
 264   if (LookupCtx) {
 265     // Perform "qualified" name lookup into the declaration context we
 266     // computed, which is either the type of the base of a member access
 267     // expression or the declaration context associated with a prior
 268     // nested-name-specifier.
 269     LookupQualifiedName(Found, LookupCtx);
 270
 271     if (!ObjectType.isNull() && Found.empty()) {
 272       // C++ [basic.lookup.classref]p1:
 273       //   In a class member access expression (5.2.5), if the . or -> token is
 274       //   immediately followed by an identifier followed by a <, the
 275       //   identifier must be looked up to determine whether the < is the
 276       //   beginning of a template argument list (14.2) or a less-than operator.
 277       //   The identifier is first looked up in the class of the object
 278       //   expression. If the identifier is not found, it is then looked up in
 279       //   the context of the entire postfix-expression and shall name a class
 280       //   or function template.
 281       if (S) LookupName(Found, S);
 282       ObjectTypeSearchedInScope = true;
 283     }
 284   } else if (isDependent && (!S || ObjectType.isNull())) {
 285     // We cannot look into a dependent object type or nested nme
 286     // specifier.
 287     MemberOfUnknownSpecialization = true;
 288     return;
 289   } else {
 290     // Perform unqualified name lookup in the current scope.
 291     LookupName(Found, S);
 292   }
 293
 294   if (Found.empty() && !isDependent) {
 295     // If we did not find any names, attempt to correct any typos.
 296     DeclarationName Name = Found.getLookupName();
 297     Found.clear();
 298     if (TypoCorrection Corrected = CorrectTypo(Found.getLookupNameInfo(),
 299                                                Found.getLookupKind(), S, &SS,
 300                                                LookupCtx, false,
 301                                                CTC_CXXCasts)) {
 302       Found.setLookupName(Corrected.getCorrection());
 303       if (Corrected.getCorrectionDecl())
 304         Found.addDecl(Corrected.getCorrectionDecl());
 305       FilterAcceptableTemplateNames(Found);
 306       if (!Found.empty()) {
 307         std::string CorrectedStr(Corrected.getAsString(getLangOptions()));
 308         std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOptions()));
 309         if (LookupCtx)
 310           Diag(Found.getNameLoc(), diag::err_no_member_template_suggest)
 311             << Name << LookupCtx << CorrectedQuotedStr << SS.getRange()
 312             << FixItHint::CreateReplacement(Found.getNameLoc(), CorrectedStr);
 313         else
 314           Diag(Found.getNameLoc(), diag::err_no_template_suggest)
 315             << Name << CorrectedQuotedStr
 316             << FixItHint::CreateReplacement(Found.getNameLoc(), CorrectedStr);
 317         if (TemplateDecl *Template = Found.getAsSingle<TemplateDecl>())
 318           Diag(Template->getLocation(), diag::note_previous_decl)
 319             << CorrectedQuotedStr;
 320       }
 321     } else {
 322       Found.setLookupName(Name);
 323     }
 324   }
 325
 326   FilterAcceptableTemplateNames(Found);
 327   if (Found.empty()) {
 328     if (isDependent)
 329       MemberOfUnknownSpecialization = true;
 330     return;
 331   }
 332
 333   if (S && !ObjectType.isNull() && !ObjectTypeSearchedInScope) {
 334     // C++ [basic.lookup.classref]p1:
 335     //   [...] If the lookup in the class of the object expression finds a
 336     //   template, the name is also looked up in the context of the entire
 337     //   postfix-expression and [...]
 338     //
 339     LookupResult FoundOuter(*this, Found.getLookupName(), Found.getNameLoc(),
 340                             LookupOrdinaryName);
 341     LookupName(FoundOuter, S);
 342     FilterAcceptableTemplateNames(FoundOuter);
 343
 344     if (FoundOuter.empty()) {
 345       //   - if the name is not found, the name found in the class of the
 346       //     object expression is used, otherwise
 347     } else if (!FoundOuter.getAsSingle<ClassTemplateDecl>()) {
 348       //   - if the name is found in the context of the entire
 349       //     postfix-expression and does not name a class template, the name
 350       //     found in the class of the object expression is used, otherwise
 351     } else if (!Found.isSuppressingDiagnostics()) {
 352       //   - if the name found is a class template, it must refer to the same
 353       //     entity as the one found in the class of the object expression,
 354       //     otherwise the program is ill-formed.
 355       if (!Found.isSingleResult() ||
 356           Found.getFoundDecl()->getCanonicalDecl()
 357             != FoundOuter.getFoundDecl()->getCanonicalDecl()) {
 358         Diag(Found.getNameLoc(),
 359              diag::ext_nested_name_member_ref_lookup_ambiguous)
 360           << Found.getLookupName()
 361           << ObjectType;
 362         Diag(Found.getRepresentativeDecl()->getLocation(),
 363              diag::note_ambig_member_ref_object_type)
 364           << ObjectType;
 365         Diag(FoundOuter.getFoundDecl()->getLocation(),
 366              diag::note_ambig_member_ref_scope);
 367
 368         // Recover by taking the template that we found in the object
 369         // expression's type.
 370       }
 371     }
 372   }
 373 }
 374
 375 /// ActOnDependentIdExpression - Handle a dependent id-expression that
 376 /// was just parsed.  This is only possible with an explicit scope
 377 /// specifier naming a dependent type.
 378 ExprResult
 379 Sema::ActOnDependentIdExpression(const CXXScopeSpec &SS,
 380                                  const DeclarationNameInfo &NameInfo,
 381                                  bool isAddressOfOperand,
 382                            const TemplateArgumentListInfo *TemplateArgs) {
 383   DeclContext *DC = getFunctionLevelDeclContext();
 384
 385   if (!isAddressOfOperand &&
 386       isa<CXXMethodDecl>(DC) &&
 387       cast<CXXMethodDecl>(DC)->isInstance()) {
 388     QualType ThisType = cast<CXXMethodDecl>(DC)->getThisType(Context);
 389
 390     // Since the 'this' expression is synthesized, we don't need to
 391     // perform the double-lookup check.
 392     NamedDecl *FirstQualifierInScope = 0;
 393
 394     return Owned(CXXDependentScopeMemberExpr::Create(Context,
 395                                                      /*This*/ 0, ThisType,
 396                                                      /*IsArrow*/ true,
 397                                                      /*Op*/ SourceLocation(),
 398                                                SS.getWithLocInContext(Context),
 399                                                      FirstQualifierInScope,
 400                                                      NameInfo,
 401                                                      TemplateArgs));
 402   }
 403
 404   return BuildDependentDeclRefExpr(SS, NameInfo, TemplateArgs);
 405 }
 406
 407 ExprResult
 408 Sema::BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
 409                                 const DeclarationNameInfo &NameInfo,
 410                                 const TemplateArgumentListInfo *TemplateArgs) {
 411   return Owned(DependentScopeDeclRefExpr::Create(Context,
 412                                                SS.getWithLocInContext(Context),
 413                                                  NameInfo,
 414                                                  TemplateArgs));
 415 }
 416
 417 /// DiagnoseTemplateParameterShadow - Produce a diagnostic complaining
 418 /// that the template parameter 'PrevDecl' is being shadowed by a new
 419 /// declaration at location Loc. Returns true to indicate that this is
 420 /// an error, and false otherwise.
 421 bool Sema::DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl) {
 422   assert(PrevDecl->isTemplateParameter() && "Not a template parameter");
 423
 424   // Microsoft Visual C++ permits template parameters to be shadowed.
 425   if (getLangOptions().Microsoft)
 426     return false;
 427
 428   // C++ [temp.local]p4:
 429   //   A template-parameter shall not be redeclared within its
 430   //   scope (including nested scopes).
 431   Diag(Loc, diag::err_template_param_shadow)
 432     << cast<NamedDecl>(PrevDecl)->getDeclName();
 433   Diag(PrevDecl->getLocation(), diag::note_template_param_here);
 434   return true;
 435 }
 436
 437 /// AdjustDeclIfTemplate - If the given decl happens to be a template, reset
 438 /// the parameter D to reference the templated declaration and return a pointer
 439 /// to the template declaration. Otherwise, do nothing to D and return null.
 440 TemplateDecl *Sema::AdjustDeclIfTemplate(Decl *&D) {
 441   if (TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D)) {
 442     D = Temp->getTemplatedDecl();
 443     return Temp;
 444   }
 445   return 0;
 446 }
 447
 448 ParsedTemplateArgument ParsedTemplateArgument::getTemplatePackExpansion(
 449                                              SourceLocation EllipsisLoc) const {
 450   assert(Kind == Template &&
 451          "Only template template arguments can be pack expansions here");
 452   assert(getAsTemplate().get().containsUnexpandedParameterPack() &&
 453          "Template template argument pack expansion without packs");
 454   ParsedTemplateArgument Result(*this);
 455   Result.EllipsisLoc = EllipsisLoc;
 456   return Result;
 457 }
 458
 459 static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef,
 460                                             const ParsedTemplateArgument &Arg) {
 461
 462   switch (Arg.getKind()) {
 463   case ParsedTemplateArgument::Type: {
 464     TypeSourceInfo *DI;
 465     QualType T = SemaRef.GetTypeFromParser(Arg.getAsType(), &DI);
 466     if (!DI)
 467       DI = SemaRef.Context.getTrivialTypeSourceInfo(T, Arg.getLocation());
 468     return TemplateArgumentLoc(TemplateArgument(T), DI);
 469   }
 470
 471   case ParsedTemplateArgument::NonType: {
 472     Expr *E = static_cast<Expr *>(Arg.getAsExpr());
 473     return TemplateArgumentLoc(TemplateArgument(E), E);
 474   }
 475
 476   case ParsedTemplateArgument::Template: {
 477     TemplateName Template = Arg.getAsTemplate().get();
 478     TemplateArgument TArg;
 479     if (Arg.getEllipsisLoc().isValid())
 480       TArg = TemplateArgument(Template, llvm::Optional<unsigned int>());
 481     else
 482       TArg = Template;
 483     return TemplateArgumentLoc(TArg,
 484                                Arg.getScopeSpec().getWithLocInContext(
 485                                                               SemaRef.Context),
 486                                Arg.getLocation(),
 487                                Arg.getEllipsisLoc());
 488   }
 489   }
 490
 491   llvm_unreachable("Unhandled parsed template argument");
 492   return TemplateArgumentLoc();
 493 }
 494
 495 /// \brief Translates template arguments as provided by the parser
 496 /// into template arguments used by semantic analysis.
 497 void Sema::translateTemplateArguments(const ASTTemplateArgsPtr &TemplateArgsIn,
 498                                       TemplateArgumentListInfo &TemplateArgs) {
 499  for (unsigned I = 0, Last = TemplateArgsIn.size(); I != Last; ++I)
 500    TemplateArgs.addArgument(translateTemplateArgument(*this,
 501                                                       TemplateArgsIn[I]));
 502 }
 503
 504 /// ActOnTypeParameter - Called when a C++ template type parameter
 505 /// (e.g., "typename T") has been parsed. Typename specifies whether
 506 /// the keyword "typename" was used to declare the type parameter
 507 /// (otherwise, "class" was used), and KeyLoc is the location of the
 508 /// "class" or "typename" keyword. ParamName is the name of the
 509 /// parameter (NULL indicates an unnamed template parameter) and
 510 /// ParamNameLoc is the location of the parameter name (if any).
 511 /// If the type parameter has a default argument, it will be added
 512 /// later via ActOnTypeParameterDefault.
 513 Decl *Sema::ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis,
 514                                SourceLocation EllipsisLoc,
 515                                SourceLocation KeyLoc,
 516                                IdentifierInfo *ParamName,
 517                                SourceLocation ParamNameLoc,
 518                                unsigned Depth, unsigned Position,
 519                                SourceLocation EqualLoc,
 520                                ParsedType DefaultArg) {
 521   assert(S->isTemplateParamScope() &&
 522          "Template type parameter not in template parameter scope!");
 523   bool Invalid = false;
 524
 525   if (ParamName) {
 526     NamedDecl *PrevDecl = LookupSingleName(S, ParamName, ParamNameLoc,
 527                                            LookupOrdinaryName,
 528                                            ForRedeclaration);
 529     if (PrevDecl && PrevDecl->isTemplateParameter())
 530       Invalid = Invalid || DiagnoseTemplateParameterShadow(ParamNameLoc,
 531                                                            PrevDecl);
 532   }
 533
 534   SourceLocation Loc = ParamNameLoc;
 535   if (!ParamName)
 536     Loc = KeyLoc;
 537
 538   TemplateTypeParmDecl *Param
 539     = TemplateTypeParmDecl::Create(Context, Context.getTranslationUnitDecl(),
 540                                    KeyLoc, Loc, Depth, Position, ParamName,
 541                                    Typename, Ellipsis);
 542   Param->setAccess(AS_public);
 543   if (Invalid)
 544     Param->setInvalidDecl();
 545
 546   if (ParamName) {
 547     // Add the template parameter into the current scope.
 548     S->AddDecl(Param);
 549     IdResolver.AddDecl(Param);
 550   }
 551
 552   // C++0x [temp.param]p9:
 553   //   A default template-argument may be specified for any kind of
 554   //   template-parameter that is not a template parameter pack.
 555   if (DefaultArg && Ellipsis) {
 556     Diag(EqualLoc, diag::err_template_param_pack_default_arg);
 557     DefaultArg = ParsedType();
 558   }
 559
 560   // Handle the default argument, if provided.
 561   if (DefaultArg) {
 562     TypeSourceInfo *DefaultTInfo;
 563     GetTypeFromParser(DefaultArg, &DefaultTInfo);
 564
 565     assert(DefaultTInfo && "expected source information for type");
 566
 567     // Check for unexpanded parameter packs.
 568     if (DiagnoseUnexpandedParameterPack(Loc, DefaultTInfo,
 569                                         UPPC_DefaultArgument))
 570       return Param;
 571
 572     // Check the template argument itself.
 573     if (CheckTemplateArgument(Param, DefaultTInfo)) {
 574       Param->setInvalidDecl();
 575       return Param;
 576     }
 577
 578     Param->setDefaultArgument(DefaultTInfo, false);
 579   }
 580
 581   return Param;
 582 }
 583
 584 /// \brief Check that the type of a non-type template parameter is
 585 /// well-formed.
 586 ///
 587 /// \returns the (possibly-promoted) parameter type if valid;
 588 /// otherwise, produces a diagnostic and returns a NULL type.
 589 QualType
 590 Sema::CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc) {
 591   // We don't allow variably-modified types as the type of non-type template
 592   // parameters.
 593   if (T->isVariablyModifiedType()) {
 594     Diag(Loc, diag::err_variably_modified_nontype_template_param)
 595       << T;
 596     return QualType();
 597   }
 598
 599   // C++ [temp.param]p4:
 600   //
 601   // A non-type template-parameter shall have one of the following
 602   // (optionally cv-qualified) types:
 603   //
 604   //       -- integral or enumeration type,
 605   if (T->isIntegralOrEnumerationType() ||
 606       //   -- pointer to object or pointer to function,
 607       T->isPointerType() ||
 608       //   -- reference to object or reference to function,
 609       T->isReferenceType() ||
 610       //   -- pointer to member,
 611       T->isMemberPointerType() ||
 612       //   -- std::nullptr_t.
 613       T->isNullPtrType() ||
 614       // If T is a dependent type, we can't do the check now, so we
 615       // assume that it is well-formed.
 616       T->isDependentType())
 617     return T;
 618   // C++ [temp.param]p8:
 619   //
 620   //   A non-type template-parameter of type "array of T" or
 621   //   "function returning T" is adjusted to be of type "pointer to
 622   //   T" or "pointer to function returning T", respectively.
 623   else if (T->isArrayType())
 624     // FIXME: Keep the type prior to promotion?
 625     return Context.getArrayDecayedType(T);
 626   else if (T->isFunctionType())
 627     // FIXME: Keep the type prior to promotion?
 628     return Context.getPointerType(T);
 629
 630   Diag(Loc, diag::err_template_nontype_parm_bad_type)
 631     << T;
 632
 633   return QualType();
 634 }
 635
 636 Decl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
 637                                           unsigned Depth,
 638                                           unsigned Position,
 639                                           SourceLocation EqualLoc,
 640                                           Expr *Default) {
 641   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
 642   QualType T = TInfo->getType();
 643
 644   assert(S->isTemplateParamScope() &&
 645          "Non-type template parameter not in template parameter scope!");
 646   bool Invalid = false;
 647
 648   IdentifierInfo *ParamName = D.getIdentifier();
 649   if (ParamName) {
 650     NamedDecl *PrevDecl = LookupSingleName(S, ParamName, D.getIdentifierLoc(),
 651                                            LookupOrdinaryName,
 652                                            ForRedeclaration);
 653     if (PrevDecl && PrevDecl->isTemplateParameter())
 654       Invalid = Invalid || DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
 655                                                            PrevDecl);
 656   }
 657
 658   T = CheckNonTypeTemplateParameterType(T, D.getIdentifierLoc());
 659   if (T.isNull()) {
 660     T = Context.IntTy; // Recover with an 'int' type.
 661     Invalid = true;
 662   }
 663
 664   bool IsParameterPack = D.hasEllipsis();
 665   NonTypeTemplateParmDecl *Param
 666     = NonTypeTemplateParmDecl::Create(Context, Context.getTranslationUnitDecl(),
 667                                       D.getSourceRange().getBegin(),
 668                                       D.getIdentifierLoc(),
 669                                       Depth, Position, ParamName, T,
 670                                       IsParameterPack, TInfo);
 671   Param->setAccess(AS_public);
 672
 673   if (Invalid)
 674     Param->setInvalidDecl();
 675
 676   if (D.getIdentifier()) {
 677     // Add the template parameter into the current scope.
 678     S->AddDecl(Param);
 679     IdResolver.AddDecl(Param);
 680   }
 681
 682   // C++0x [temp.param]p9:
 683   //   A default template-argument may be specified for any kind of
 684   //   template-parameter that is not a template parameter pack.
 685   if (Default && IsParameterPack) {
 686     Diag(EqualLoc, diag::err_template_param_pack_default_arg);
 687     Default = 0;
 688   }
 689
 690   // Check the well-formedness of the default template argument, if provided.
 691   if (Default) {
 692     // Check for unexpanded parameter packs.
 693     if (DiagnoseUnexpandedParameterPack(Default, UPPC_DefaultArgument))
 694       return Param;
 695
 696     TemplateArgument Converted;
 697     ExprResult DefaultRes = CheckTemplateArgument(Param, Param->getType(), Default, Converted);
 698     if (DefaultRes.isInvalid()) {
 699       Param->setInvalidDecl();
 700       return Param;
 701     }
 702     Default = DefaultRes.take();
 703
 704     Param->setDefaultArgument(Default, false);
 705   }
 706
 707   return Param;
 708 }
 709
 710 /// ActOnTemplateTemplateParameter - Called when a C++ template template
 711 /// parameter (e.g. T in template <template <typename> class T> class array)
 712 /// has been parsed. S is the current scope.
 713 Decl *Sema::ActOnTemplateTemplateParameter(Scope* S,
 714                                            SourceLocation TmpLoc,
 715                                            TemplateParamsTy *Params,
 716                                            SourceLocation EllipsisLoc,
 717                                            IdentifierInfo *Name,
 718                                            SourceLocation NameLoc,
 719                                            unsigned Depth,
 720                                            unsigned Position,
 721                                            SourceLocation EqualLoc,
 722                                            ParsedTemplateArgument Default) {
 723   assert(S->isTemplateParamScope() &&
 724          "Template template parameter not in template parameter scope!");
 725
 726   // Construct the parameter object.
 727   bool IsParameterPack = EllipsisLoc.isValid();
 728   TemplateTemplateParmDecl *Param =
 729     TemplateTemplateParmDecl::Create(Context, Context.getTranslationUnitDecl(),
 730                                      NameLoc.isInvalid()? TmpLoc : NameLoc,
 731                                      Depth, Position, IsParameterPack,
 732                                      Name, Params);
 733   Param->setAccess(AS_public);
 734
 735   // If the template template parameter has a name, then link the identifier
 736   // into the scope and lookup mechanisms.
 737   if (Name) {
 738     S->AddDecl(Param);
 739     IdResolver.AddDecl(Param);
 740   }
 741
 742   if (Params->size() == 0) {
 743     Diag(Param->getLocation(), diag::err_template_template_parm_no_parms)
 744     << SourceRange(Params->getLAngleLoc(), Params->getRAngleLoc());
 745     Param->setInvalidDecl();
 746   }
 747
 748   // C++0x [temp.param]p9:
 749   //   A default template-argument may be specified for any kind of
 750   //   template-parameter that is not a template parameter pack.
 751   if (IsParameterPack && !Default.isInvalid()) {
 752     Diag(EqualLoc, diag::err_template_param_pack_default_arg);
 753     Default = ParsedTemplateArgument();
 754   }
 755
 756   if (!Default.isInvalid()) {
 757     // Check only that we have a template template argument. We don't want to
 758     // try to check well-formedness now, because our template template parameter
 759     // might have dependent types in its template parameters, which we wouldn't
 760     // be able to match now.
 761     //
 762     // If none of the template template parameter's template arguments mention
 763     // other template parameters, we could actually perform more checking here.
 764     // However, it isn't worth doing.
 765     TemplateArgumentLoc DefaultArg = translateTemplateArgument(*this, Default);
 766     if (DefaultArg.getArgument().getAsTemplate().isNull()) {
 767       Diag(DefaultArg.getLocation(), diag::err_template_arg_not_class_template)
 768         << DefaultArg.getSourceRange();
 769       return Param;
 770     }
 771
 772     // Check for unexpanded parameter packs.
 773     if (DiagnoseUnexpandedParameterPack(DefaultArg.getLocation(),
 774                                         DefaultArg.getArgument().getAsTemplate(),
 775                                         UPPC_DefaultArgument))
 776       return Param;
 777
 778     Param->setDefaultArgument(DefaultArg, false);
 779   }
 780
 781   return Param;
 782 }
 783
 784 /// ActOnTemplateParameterList - Builds a TemplateParameterList that
 785 /// contains the template parameters in Params/NumParams.
 786 Sema::TemplateParamsTy *
 787 Sema::ActOnTemplateParameterList(unsigned Depth,
 788                                  SourceLocation ExportLoc,
 789                                  SourceLocation TemplateLoc,
 790                                  SourceLocation LAngleLoc,
 791                                  Decl **Params, unsigned NumParams,
 792                                  SourceLocation RAngleLoc) {
 793   if (ExportLoc.isValid())
 794     Diag(ExportLoc, diag::warn_template_export_unsupported);
 795
 796   return TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc,
 797                                        (NamedDecl**)Params, NumParams,
 798                                        RAngleLoc);
 799 }
 800
 801 static void SetNestedNameSpecifier(TagDecl *T, const CXXScopeSpec &SS) {
 802   if (SS.isSet())
 803     T->setQualifierInfo(SS.getWithLocInContext(T->getASTContext()));
 804 }
 805
 806 DeclResult
 807 Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
 808                          SourceLocation KWLoc, CXXScopeSpec &SS,
 809                          IdentifierInfo *Name, SourceLocation NameLoc,
 810                          AttributeList *Attr,
 811                          TemplateParameterList *TemplateParams,
 812                          AccessSpecifier AS,
 813                          unsigned NumOuterTemplateParamLists,
 814                          TemplateParameterList** OuterTemplateParamLists) {
 815   assert(TemplateParams && TemplateParams->size() > 0 &&
 816          "No template parameters");
 817   assert(TUK != TUK_Reference && "Can only declare or define class templates");
 818   bool Invalid = false;
 819
 820   // Check that we can declare a template here.
 821   if (CheckTemplateDeclScope(S, TemplateParams))
 822     return true;
 823
 824   TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
 825   assert(Kind != TTK_Enum && "can't build template of enumerated type");
 826
 827   // There is no such thing as an unnamed class template.
 828   if (!Name) {
 829     Diag(KWLoc, diag::err_template_unnamed_class);
 830     return true;
 831   }
 832
 833   // Find any previous declaration with this name.
 834   DeclContext *SemanticContext;
 835   LookupResult Previous(*this, Name, NameLoc, LookupOrdinaryName,
 836                         ForRedeclaration);
 837   if (SS.isNotEmpty() && !SS.isInvalid()) {
 838     SemanticContext = computeDeclContext(SS, true);
 839     if (!SemanticContext) {
 840       // FIXME: Produce a reasonable diagnostic here
 841       return true;
 842     }
 843
 844     if (RequireCompleteDeclContext(SS, SemanticContext))
 845       return true;
 846
 847     LookupQualifiedName(Previous, SemanticContext);
 848   } else {
 849     SemanticContext = CurContext;
 850     LookupName(Previous, S);
 851   }
 852
 853   if (Previous.isAmbiguous())
 854     return true;
 855
 856   NamedDecl *PrevDecl = 0;
 857   if (Previous.begin() != Previous.end())
 858     PrevDecl = (*Previous.begin())->getUnderlyingDecl();
 859
 860   // If there is a previous declaration with the same name, check
 861   // whether this is a valid redeclaration.
 862   ClassTemplateDecl *PrevClassTemplate
 863     = dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);
 864
 865   // We may have found the injected-class-name of a class template,
 866   // class template partial specialization, or class template specialization.
 867   // In these cases, grab the template that is being defined or specialized.
 868   if (!PrevClassTemplate && PrevDecl && isa<CXXRecordDecl>(PrevDecl) &&
 869       cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {
 870     PrevDecl = cast<CXXRecordDecl>(PrevDecl->getDeclContext());
 871     PrevClassTemplate
 872       = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();
 873     if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {
 874       PrevClassTemplate
 875         = cast<ClassTemplateSpecializationDecl>(PrevDecl)
 876             ->getSpecializedTemplate();
 877     }
 878   }
 879
 880   if (TUK == TUK_Friend) {
 881     // C++ [namespace.memdef]p3:
 882     //   [...] When looking for a prior declaration of a class or a function
 883     //   declared as a friend, and when the name of the friend class or
 884     //   function is neither a qualified name nor a template-id, scopes outside
 885     //   the innermost enclosing namespace scope are not considered.
 886     if (!SS.isSet()) {
 887       DeclContext *OutermostContext = CurContext;
 888       while (!OutermostContext->isFileContext())
 889         OutermostContext = OutermostContext->getLookupParent();
 890
 891       if (PrevDecl &&
 892           (OutermostContext->Equals(PrevDecl->getDeclContext()) ||
 893            OutermostContext->Encloses(PrevDecl->getDeclContext()))) {
 894         SemanticContext = PrevDecl->getDeclContext();
 895       } else {
 896         // Declarations in outer scopes don't matter. However, the outermost
 897         // context we computed is the semantic context for our new
 898         // declaration.
 899         PrevDecl = PrevClassTemplate = 0;
 900         SemanticContext = OutermostContext;
 901       }
 902     }
 903
 904     if (CurContext->isDependentContext()) {
 905       // If this is a dependent context, we don't want to link the friend
 906       // class template to the template in scope, because that would perform
 907       // checking of the template parameter lists that can't be performed
 908       // until the outer context is instantiated.
 909       PrevDecl = PrevClassTemplate = 0;
 910     }
 911   } else if (PrevDecl && !isDeclInScope(PrevDecl, SemanticContext, S))
 912     PrevDecl = PrevClassTemplate = 0;
 913
 914   if (PrevClassTemplate) {
 915     // Ensure that the template parameter lists are compatible.
 916     if (!TemplateParameterListsAreEqual(TemplateParams,
 917                                    PrevClassTemplate->getTemplateParameters(),
 918                                         /*Complain=*/true,
 919                                         TPL_TemplateMatch))
 920       return true;
 921
 922     // C++ [temp.class]p4:
 923     //   In a redeclaration, partial specialization, explicit
 924     //   specialization or explicit instantiation of a class template,
 925     //   the class-key shall agree in kind with the original class
 926     //   template declaration (7.1.5.3).
 927     RecordDecl *PrevRecordDecl = PrevClassTemplate->getTemplatedDecl();
 928     if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind,
 929                                       TUK == TUK_Definition,  KWLoc, *Name)) {
 930       Diag(KWLoc, diag::err_use_with_wrong_tag)
 931         << Name
 932         << FixItHint::CreateReplacement(KWLoc, PrevRecordDecl->getKindName());
 933       Diag(PrevRecordDecl->getLocation(), diag::note_previous_use);
 934       Kind = PrevRecordDecl->getTagKind();
 935     }
 936
 937     // Check for redefinition of this class template.
 938     if (TUK == TUK_Definition) {
 939       if (TagDecl *Def = PrevRecordDecl->getDefinition()) {
 940         Diag(NameLoc, diag::err_redefinition) << Name;
 941         Diag(Def->getLocation(), diag::note_previous_definition);
 942         // FIXME: Would it make sense to try to "forget" the previous
 943         // definition, as part of error recovery?
 944         return true;
 945       }
 946     }
 947   } else if (PrevDecl && PrevDecl->isTemplateParameter()) {
 948     // Maybe we will complain about the shadowed template parameter.
 949     DiagnoseTemplateParameterShadow(NameLoc, PrevDecl);
 950     // Just pretend that we didn't see the previous declaration.
 951     PrevDecl = 0;
 952   } else if (PrevDecl) {
 953     // C++ [temp]p5:
 954     //   A class template shall not have the same name as any other
 955     //   template, class, function, object, enumeration, enumerator,
 956     //   namespace, or type in the same scope (3.3), except as specified
 957     //   in (14.5.4).
 958     Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
 959     Diag(PrevDecl->getLocation(), diag::note_previous_definition);
 960     return true;
 961   }
 962
 963   // Check the template parameter list of this declaration, possibly
 964   // merging in the template parameter list from the previous class
 965   // template declaration.
 966   if (CheckTemplateParameterList(TemplateParams,
 967             PrevClassTemplate? PrevClassTemplate->getTemplateParameters() : 0,
 968                                  (SS.isSet() && SemanticContext &&
 969                                   SemanticContext->isRecord() &&
 970                                   SemanticContext->isDependentContext())
 971                                    ? TPC_ClassTemplateMember
 972                                    : TPC_ClassTemplate))
 973     Invalid = true;
 974
 975   if (SS.isSet()) {
 976     // If the name of the template was qualified, we must be defining the
 977     // template out-of-line.
 978     if (!SS.isInvalid() && !Invalid && !PrevClassTemplate &&
 979         !(TUK == TUK_Friend && CurContext->isDependentContext()))
 980       Diag(NameLoc, diag::err_member_def_does_not_match)
 981         << Name << SemanticContext << SS.getRange();
 982   }
 983
 984   CXXRecordDecl *NewClass =
 985     CXXRecordDecl::Create(Context, Kind, SemanticContext, KWLoc, NameLoc, Name,
 986                           PrevClassTemplate?
 987                             PrevClassTemplate->getTemplatedDecl() : 0,
 988                           /*DelayTypeCreation=*/true);
 989   SetNestedNameSpecifier(NewClass, SS);
 990   if (NumOuterTemplateParamLists > 0)
 991     NewClass->setTemplateParameterListsInfo(Context,
 992                                             NumOuterTemplateParamLists,
 993                                             OuterTemplateParamLists);
 994
 995   ClassTemplateDecl *NewTemplate
 996     = ClassTemplateDecl::Create(Context, SemanticContext, NameLoc,
 997                                 DeclarationName(Name), TemplateParams,
 998                                 NewClass, PrevClassTemplate);
 999   NewClass->setDescribedClassTemplate(NewTemplate);
1000
1001   // Build the type for the class template declaration now.
1002   QualType T = NewTemplate->getInjectedClassNameSpecialization();
1003   T = Context.getInjectedClassNameType(NewClass, T);
1004   assert(T->isDependentType() && "Class template type is not dependent?");
1005   (void)T;
1006
1007   // If we are providing an explicit specialization of a member that is a
1008   // class template, make a note of that.
1009   if (PrevClassTemplate &&
1010       PrevClassTemplate->getInstantiatedFromMemberTemplate())
1011     PrevClassTemplate->setMemberSpecialization();
1012
1013   // Set the access specifier.
1014   if (!Invalid && TUK != TUK_Friend)
1015     SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS);
1016
1017   // Set the lexical context of these templates
1018   NewClass->setLexicalDeclContext(CurContext);
1019   NewTemplate->setLexicalDeclContext(CurContext);
1020
1021   if (TUK == TUK_Definition)
1022     NewClass->startDefinition();
1023
1024   if (Attr)
1025     ProcessDeclAttributeList(S, NewClass, Attr);
1026
1027   if (TUK != TUK_Friend)
1028     PushOnScopeChains(NewTemplate, S);
1029   else {
1030     if (PrevClassTemplate && PrevClassTemplate->getAccess() != AS_none) {
1031       NewTemplate->setAccess(PrevClassTemplate->getAccess());
1032       NewClass->setAccess(PrevClassTemplate->getAccess());
1033     }
1034
1035     NewTemplate->setObjectOfFriendDecl(/* PreviouslyDeclared = */
1036                                        PrevClassTemplate != NULL);
1037
1038     // Friend templates are visible in fairly strange ways.
1039     if (!CurContext->isDependentContext()) {
1040       DeclContext *DC = SemanticContext->getRedeclContext();
1041       DC->makeDeclVisibleInContext(NewTemplate, /* Recoverable = */ false);
1042       if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
1043         PushOnScopeChains(NewTemplate, EnclosingScope,
1044                           /* AddToContext = */ false);
1045     }
1046
1047     FriendDecl *Friend = FriendDecl::Create(Context, CurContext,
1048                                             NewClass->getLocation(),
1049                                             NewTemplate,
1050                                     /*FIXME:*/NewClass->getLocation());
1051     Friend->setAccess(AS_public);
1052     CurContext->addDecl(Friend);
1053   }
1054
1055   if (Invalid) {
1056     NewTemplate->setInvalidDecl();
1057     NewClass->setInvalidDecl();
1058   }
1059   return NewTemplate;
1060 }
1061
1062 /// \brief Diagnose the presence of a default template argument on a
1063 /// template parameter, which is ill-formed in certain contexts.
1064 ///
1065 /// \returns true if the default template argument should be dropped.
1066 static bool DiagnoseDefaultTemplateArgument(Sema &S,
1067                                             Sema::TemplateParamListContext TPC,
1068                                             SourceLocation ParamLoc,
1069                                             SourceRange DefArgRange) {
1070   switch (TPC) {
1071   case Sema::TPC_ClassTemplate:
1072   case Sema::TPC_TypeAliasTemplate:
1073     return false;
1074
1075   case Sema::TPC_FunctionTemplate:
1076   case Sema::TPC_FriendFunctionTemplateDefinition:
1077     // C++ [temp.param]p9:
1078     //   A default template-argument shall not be specified in a
1079     //   function template declaration or a function template
1080     //   definition [...]
1081     //   If a friend function template declaration specifies a default
1082     //   template-argument, that declaration shall be a definition and shall be
1083     //   the only declaration of the function template in the translation unit.
1084     // (C++98/03 doesn't have this wording; see DR226).
1085     if (!S.getLangOptions().CPlusPlus0x)
1086       S.Diag(ParamLoc,
1087              diag::ext_template_parameter_default_in_function_template)
1088         << DefArgRange;
1089     return false;
1090
1091   case Sema::TPC_ClassTemplateMember:
1092     // C++0x [temp.param]p9:
1093     //   A default template-argument shall not be specified in the
1094     //   template-parameter-lists of the definition of a member of a
1095     //   class template that appears outside of the member's class.
1096     S.Diag(ParamLoc, diag::err_template_parameter_default_template_member)
1097       << DefArgRange;
1098     return true;
1099
1100   case Sema::TPC_FriendFunctionTemplate:
1101     // C++ [temp.param]p9:
1102     //   A default template-argument shall not be specified in a
1103     //   friend template declaration.
1104     S.Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
1105       << DefArgRange;
1106     return true;
1107
1108     // FIXME: C++0x [temp.param]p9 allows default template-arguments
1109     // for friend function templates if there is only a single
1110     // declaration (and it is a definition). Strange!
1111   }
1112
1113   return false;
1114 }
1115
1116 /// \brief Check for unexpanded parameter packs within the template parameters
1117 /// of a template template parameter, recursively.
1118 static bool DiagnoseUnexpandedParameterPacks(Sema &S,
1119                                              TemplateTemplateParmDecl *TTP) {
1120   TemplateParameterList *Params = TTP->getTemplateParameters();
1121   for (unsigned I = 0, N = Params->size(); I != N; ++I) {
1122     NamedDecl *P = Params->getParam(I);
1123     if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
1124       if (S.DiagnoseUnexpandedParameterPack(NTTP->getLocation(),
1125                                             NTTP->getTypeSourceInfo(),
1126                                       Sema::UPPC_NonTypeTemplateParameterType))
1127         return true;
1128
1129       continue;
1130     }
1131
1132     if (TemplateTemplateParmDecl *InnerTTP
1133                                         = dyn_cast<TemplateTemplateParmDecl>(P))
1134       if (DiagnoseUnexpandedParameterPacks(S, InnerTTP))
1135         return true;
1136   }
1137
1138   return false;
1139 }
1140
1141 /// \brief Checks the validity of a template parameter list, possibly
1142 /// considering the template parameter list from a previous
1143 /// declaration.
1144 ///
1145 /// If an "old" template parameter list is provided, it must be
1146 /// equivalent (per TemplateParameterListsAreEqual) to the "new"
1147 /// template parameter list.
1148 ///
1149 /// \param NewParams Template parameter list for a new template
1150 /// declaration. This template parameter list will be updated with any
1151 /// default arguments that are carried through from the previous
1152 /// template parameter list.
1153 ///
1154 /// \param OldParams If provided, template parameter list from a
1155 /// previous declaration of the same template. Default template
1156 /// arguments will be merged from the old template parameter list to
1157 /// the new template parameter list.
1158 ///
1159 /// \param TPC Describes the context in which we are checking the given
1160 /// template parameter list.
1161 ///
1162 /// \returns true if an error occurred, false otherwise.
1163 bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
1164                                       TemplateParameterList *OldParams,
1165                                       TemplateParamListContext TPC) {
1166   bool Invalid = false;
1167
1168   // C++ [temp.param]p10:
1169   //   The set of default template-arguments available for use with a
1170   //   template declaration or definition is obtained by merging the
1171   //   default arguments from the definition (if in scope) and all
1172   //   declarations in scope in the same way default function
1173   //   arguments are (8.3.6).
1174   bool SawDefaultArgument = false;
1175   SourceLocation PreviousDefaultArgLoc;
1176
1177   bool SawParameterPack = false;
1178   SourceLocation ParameterPackLoc;
1179
1180   // Dummy initialization to avoid warnings.
1181   TemplateParameterList::iterator OldParam = NewParams->end();
1182   if (OldParams)
1183     OldParam = OldParams->begin();
1184
1185   bool RemoveDefaultArguments = false;
1186   for (TemplateParameterList::iterator NewParam = NewParams->begin(),
1187                                     NewParamEnd = NewParams->end();
1188        NewParam != NewParamEnd; ++NewParam) {
1189     // Variables used to diagnose redundant default arguments
1190     bool RedundantDefaultArg = false;
1191     SourceLocation OldDefaultLoc;
1192     SourceLocation NewDefaultLoc;
1193
1194     // Variables used to diagnose missing default arguments
1195     bool MissingDefaultArg = false;
1196
1197     // C++0x [temp.param]p11:
1198     //   If a template parameter of a primary class template or alias template
1199     //   is a template parameter pack, it shall be the last template parameter.
1200     if (SawParameterPack &&
1201         (TPC == TPC_ClassTemplate || TPC == TPC_TypeAliasTemplate)) {
1202       Diag(ParameterPackLoc,
1203            diag::err_template_param_pack_must_be_last_template_parameter);
1204       Invalid = true;
1205     }
1206
1207     if (TemplateTypeParmDecl *NewTypeParm
1208           = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
1209       // Check the presence of a default argument here.
1210       if (NewTypeParm->hasDefaultArgument() &&
1211           DiagnoseDefaultTemplateArgument(*this, TPC,
1212                                           NewTypeParm->getLocation(),
1213                NewTypeParm->getDefaultArgumentInfo()->getTypeLoc()
1214                                                        .getSourceRange()))
1215         NewTypeParm->removeDefaultArgument();
1216
1217       // Merge default arguments for template type parameters.
1218       TemplateTypeParmDecl *OldTypeParm
1219           = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : 0;
1220
1221       if (NewTypeParm->isParameterPack()) {
1222         assert(!NewTypeParm->hasDefaultArgument() &&
1223                "Parameter packs can't have a default argument!");
1224         SawParameterPack = true;
1225         ParameterPackLoc = NewTypeParm->getLocation();
1226       } else if (OldTypeParm && OldTypeParm->hasDefaultArgument() &&
1227                  NewTypeParm->hasDefaultArgument()) {
1228         OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc();
1229         NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
1230         SawDefaultArgument = true;
1231         RedundantDefaultArg = true;
1232         PreviousDefaultArgLoc = NewDefaultLoc;
1233       } else if (OldTypeParm && OldTypeParm->hasDefaultArgument()) {
1234         // Merge the default argument from the old declaration to the
1235         // new declaration.
1236         SawDefaultArgument = true;
1237         NewTypeParm->setDefaultArgument(OldTypeParm->getDefaultArgumentInfo(),
1238                                         true);
1239         PreviousDefaultArgLoc = OldTypeParm->getDefaultArgumentLoc();
1240       } else if (NewTypeParm->hasDefaultArgument()) {
1241         SawDefaultArgument = true;
1242         PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
1243       } else if (SawDefaultArgument)
1244         MissingDefaultArg = true;
1245     } else if (NonTypeTemplateParmDecl *NewNonTypeParm
1246                = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
1247       // Check for unexpanded parameter packs.
1248       if (DiagnoseUnexpandedParameterPack(NewNonTypeParm->getLocation(),
1249                                           NewNonTypeParm->getTypeSourceInfo(),
1250                                           UPPC_NonTypeTemplateParameterType)) {
1251         Invalid = true;
1252         continue;
1253       }
1254
1255       // Check the presence of a default argument here.
1256       if (NewNonTypeParm->hasDefaultArgument() &&
1257           DiagnoseDefaultTemplateArgument(*this, TPC,
1258                                           NewNonTypeParm->getLocation(),
1259                     NewNonTypeParm->getDefaultArgument()->getSourceRange())) {
1260         NewNonTypeParm->removeDefaultArgument();
1261       }
1262
1263       // Merge default arguments for non-type template parameters
1264       NonTypeTemplateParmDecl *OldNonTypeParm
1265         = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : 0;
1266       if (NewNonTypeParm->isParameterPack()) {
1267         assert(!NewNonTypeParm->hasDefaultArgument() &&
1268                "Parameter packs can't have a default argument!");
1269         SawParameterPack = true;
1270         ParameterPackLoc = NewNonTypeParm->getLocation();
1271       } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument() &&
1272           NewNonTypeParm->hasDefaultArgument()) {
1273         OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc();
1274         NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
1275         SawDefaultArgument = true;
1276         RedundantDefaultArg = true;
1277         PreviousDefaultArgLoc = NewDefaultLoc;
1278       } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument()) {
1279         // Merge the default argument from the old declaration to the
1280         // new declaration.
1281         SawDefaultArgument = true;
1282         // FIXME: We need to create a new kind of "default argument"
1283         // expression that points to a previous non-type template
1284         // parameter.
1285         NewNonTypeParm->setDefaultArgument(
1286                                          OldNonTypeParm->getDefaultArgument(),
1287                                          /*Inherited=*/ true);
1288         PreviousDefaultArgLoc = OldNonTypeParm->getDefaultArgumentLoc();
1289       } else if (NewNonTypeParm->hasDefaultArgument()) {
1290         SawDefaultArgument = true;
1291         PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
1292       } else if (SawDefaultArgument)
1293         MissingDefaultArg = true;
1294     } else {
1295       // Check the presence of a default argument here.
1296       TemplateTemplateParmDecl *NewTemplateParm
1297         = cast<TemplateTemplateParmDecl>(*NewParam);
1298
1299       // Check for unexpanded parameter packs, recursively.
1300       if (DiagnoseUnexpandedParameterPacks(*this, NewTemplateParm)) {
1301         Invalid = true;
1302         continue;
1303       }
1304
1305       if (NewTemplateParm->hasDefaultArgument() &&
1306           DiagnoseDefaultTemplateArgument(*this, TPC,
1307                                           NewTemplateParm->getLocation(),
1308                      NewTemplateParm->getDefaultArgument().getSourceRange()))
1309         NewTemplateParm->removeDefaultArgument();
1310
1311       // Merge default arguments for template template parameters
1312       TemplateTemplateParmDecl *OldTemplateParm
1313         = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : 0;
1314       if (NewTemplateParm->isParameterPack()) {
1315         assert(!NewTemplateParm->hasDefaultArgument() &&
1316                "Parameter packs can't have a default argument!");
1317         SawParameterPack = true;
1318         ParameterPackLoc = NewTemplateParm->getLocation();
1319       } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument() &&
1320           NewTemplateParm->hasDefaultArgument()) {
1321         OldDefaultLoc = OldTemplateParm->getDefaultArgument().getLocation();
1322         NewDefaultLoc = NewTemplateParm->getDefaultArgument().getLocation();
1323         SawDefaultArgument = true;
1324         RedundantDefaultArg = true;
1325         PreviousDefaultArgLoc = NewDefaultLoc;
1326       } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) {
1327         // Merge the default argument from the old declaration to the
1328         // new declaration.
1329         SawDefaultArgument = true;
1330         // FIXME: We need to create a new kind of "default argument" expression
1331         // that points to a previous template template parameter.
1332         NewTemplateParm->setDefaultArgument(
1333                                           OldTemplateParm->getDefaultArgument(),
1334                                           /*Inherited=*/ true);
1335         PreviousDefaultArgLoc
1336           = OldTemplateParm->getDefaultArgument().getLocation();
1337       } else if (NewTemplateParm->hasDefaultArgument()) {
1338         SawDefaultArgument = true;
1339         PreviousDefaultArgLoc
1340           = NewTemplateParm->getDefaultArgument().getLocation();
1341       } else if (SawDefaultArgument)
1342         MissingDefaultArg = true;
1343     }
1344
1345     if (RedundantDefaultArg) {
1346       // C++ [temp.param]p12:
1347       //   A template-parameter shall not be given default arguments
1348       //   by two different declarations in the same scope.
1349       Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
1350       Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
1351       Invalid = true;
1352     } else if (MissingDefaultArg && TPC != TPC_FunctionTemplate) {
1353       // C++ [temp.param]p11:
1354       //   If a template-parameter of a class template has a default
1355       //   template-argument, each subsequent template-parameter shall either
1356       //   have a default template-argument supplied or be a template parameter
1357       //   pack.
1358       Diag((*NewParam)->getLocation(),
1359            diag::err_template_param_default_arg_missing);
1360       Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
1361       Invalid = true;
1362       RemoveDefaultArguments = true;
1363     }
1364
1365     // If we have an old template parameter list that we're merging
1366     // in, move on to the next parameter.
1367     if (OldParams)
1368       ++OldParam;
1369   }
1370
1371   // We were missing some default arguments at the end of the list, so remove
1372   // all of the default arguments.
1373   if (RemoveDefaultArguments) {
1374     for (TemplateParameterList::iterator NewParam = NewParams->begin(),
1375                                       NewParamEnd = NewParams->end();
1376          NewParam != NewParamEnd; ++NewParam) {
1377       if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*NewParam))
1378         TTP->removeDefaultArgument();
1379       else if (NonTypeTemplateParmDecl *NTTP
1380                                 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
1381         NTTP->removeDefaultArgument();
1382       else
1383         cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();
1384     }
1385   }
1386
1387   return Invalid;
1388 }
1389
1390 namespace {
1391
1392 /// A class which looks for a use of a certain level of template
1393 /// parameter.
1394 struct DependencyChecker : RecursiveASTVisitor<DependencyChecker> {
1395   typedef RecursiveASTVisitor<DependencyChecker> super;
1396
1397   unsigned Depth;
1398   bool Match;
1399
1400   DependencyChecker(TemplateParameterList *Params) : Match(false) {
1401     NamedDecl *ND = Params->getParam(0);
1402     if (TemplateTypeParmDecl *PD = dyn_cast<TemplateTypeParmDecl>(ND)) {
1403       Depth = PD->getDepth();
1404     } else if (NonTypeTemplateParmDecl *PD =
1405                  dyn_cast<NonTypeTemplateParmDecl>(ND)) {
1406       Depth = PD->getDepth();
1407     } else {
1408       Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();
1409     }
1410   }
1411
1412   bool Matches(unsigned ParmDepth) {
1413     if (ParmDepth >= Depth) {
1414       Match = true;
1415       return true;
1416     }
1417     return false;
1418   }
1419
1420   bool VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
1421     return !Matches(T->getDepth());
1422   }
1423
1424   bool TraverseTemplateName(TemplateName N) {
1425     if (TemplateTemplateParmDecl *PD =
1426           dyn_cast_or_null<TemplateTemplateParmDecl>(N.getAsTemplateDecl()))
1427       if (Matches(PD->getDepth())) return false;
1428     return super::TraverseTemplateName(N);
1429   }
1430
1431   bool VisitDeclRefExpr(DeclRefExpr *E) {
1432     if (NonTypeTemplateParmDecl *PD =
1433           dyn_cast<NonTypeTemplateParmDecl>(E->getDecl())) {
1434       if (PD->getDepth() == Depth) {
1435         Match = true;
1436         return false;
1437       }
1438     }
1439     return super::VisitDeclRefExpr(E);
1440   }
1441
1442   bool TraverseInjectedClassNameType(const InjectedClassNameType *T) {
1443     return TraverseType(T->getInjectedSpecializationType());
1444   }
1445 };
1446 }
1447
1448 /// Determines whether a given type depends on the given parameter
1449 /// list.
1450 static bool
1451 DependsOnTemplateParameters(QualType T, TemplateParameterList *Params) {
1452   DependencyChecker Checker(Params);
1453   Checker.TraverseType(T);
1454   return Checker.Match;
1455 }
1456
1457 // Find the source range corresponding to the named type in the given
1458 // nested-name-specifier, if any.
1459 static SourceRange getRangeOfTypeInNestedNameSpecifier(ASTContext &Context,
1460                                                        QualType T,
1461                                                        const CXXScopeSpec &SS) {
1462   NestedNameSpecifierLoc NNSLoc(SS.getScopeRep(), SS.location_data());
1463   while (NestedNameSpecifier *NNS = NNSLoc.getNestedNameSpecifier()) {
1464     if (const Type *CurType = NNS->getAsType()) {
1465       if (Context.hasSameUnqualifiedType(T, QualType(CurType, 0)))
1466         return NNSLoc.getTypeLoc().getSourceRange();
1467     } else
1468       break;
1469
1470     NNSLoc = NNSLoc.getPrefix();
1471   }
1472
1473   return SourceRange();
1474 }
1475
1476 /// \brief Match the given template parameter lists to the given scope
1477 /// specifier, returning the template parameter list that applies to the
1478 /// name.
1479 ///
1480 /// \param DeclStartLoc the start of the declaration that has a scope
1481 /// specifier or a template parameter list.
1482 ///
1483 /// \param DeclLoc The location of the declaration itself.
1484 ///
1485 /// \param SS the scope specifier that will be matched to the given template
1486 /// parameter lists. This scope specifier precedes a qualified name that is
1487 /// being declared.
1488 ///
1489 /// \param ParamLists the template parameter lists, from the outermost to the
1490 /// innermost template parameter lists.
1491 ///
1492 /// \param NumParamLists the number of template parameter lists in ParamLists.
1493 ///
1494 /// \param IsFriend Whether to apply the slightly different rules for
1495 /// matching template parameters to scope specifiers in friend
1496 /// declarations.
1497 ///
1498 /// \param IsExplicitSpecialization will be set true if the entity being
1499 /// declared is an explicit specialization, false otherwise.
1500 ///
1501 /// \returns the template parameter list, if any, that corresponds to the
1502 /// name that is preceded by the scope specifier @p SS. This template
1503 /// parameter list may have template parameters (if we're declaring a
1504 /// template) or may have no template parameters (if we're declaring a
1505 /// template specialization), or may be NULL (if what we're declaring isn't
1506 /// itself a template).
1507 TemplateParameterList *
1508 Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc,
1509                                               SourceLocation DeclLoc,
1510                                               const CXXScopeSpec &SS,
1511                                           TemplateParameterList **ParamLists,
1512                                               unsigned NumParamLists,
1513                                               bool IsFriend,
1514                                               bool &IsExplicitSpecialization,
1515                                               bool &Invalid) {
1516   IsExplicitSpecialization = false;
1517   Invalid = false;
1518
1519   // The sequence of nested types to which we will match up the template
1520   // parameter lists. We first build this list by starting with the type named
1521   // by the nested-name-specifier and walking out until we run out of types.
1522   llvm::SmallVector<QualType, 4> NestedTypes;
1523   QualType T;
1524   if (SS.getScopeRep()) {
1525     if (CXXRecordDecl *Record
1526               = dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, true)))
1527       T = Context.getTypeDeclType(Record);
1528     else
1529       T = QualType(SS.getScopeRep()->getAsType(), 0);
1530   }
1531
1532   // If we found an explicit specialization that prevents us from needing
1533   // 'template<>' headers, this will be set to the location of that
1534   // explicit specialization.
1535   SourceLocation ExplicitSpecLoc;
1536
1537   while (!T.isNull()) {
1538     NestedTypes.push_back(T);
1539
1540     // Retrieve the parent of a record type.
1541     if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
1542       // If this type is an explicit specialization, we're done.
1543       if (ClassTemplateSpecializationDecl *Spec
1544           = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
1545         if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
1546             Spec->getSpecializationKind() == TSK_ExplicitSpecialization) {
1547           ExplicitSpecLoc = Spec->getLocation();
1548           break;
1549         }
1550       } else if (Record->getTemplateSpecializationKind()
1551                                                 == TSK_ExplicitSpecialization) {
1552         ExplicitSpecLoc = Record->getLocation();
1553         break;
1554       }
1555
1556       if (TypeDecl *Parent = dyn_cast<TypeDecl>(Record->getParent()))
1557         T = Context.getTypeDeclType(Parent);
1558       else
1559         T = QualType();
1560       continue;
1561     }
1562
1563     if (const TemplateSpecializationType *TST
1564                                      = T->getAs<TemplateSpecializationType>()) {
1565       if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
1566         if (TypeDecl *Parent = dyn_cast<TypeDecl>(Template->getDeclContext()))
1567           T = Context.getTypeDeclType(Parent);
1568         else
1569           T = QualType();
1570         continue;
1571       }
1572     }
1573
1574     // Look one step prior in a dependent template specialization type.
1575     if (const DependentTemplateSpecializationType *DependentTST
1576                           = T->getAs<DependentTemplateSpecializationType>()) {
1577       if (NestedNameSpecifier *NNS = DependentTST->getQualifier())
1578         T = QualType(NNS->getAsType(), 0);
1579       else
1580         T = QualType();
1581       continue;
1582     }
1583
1584     // Look one step prior in a dependent name type.
1585     if (const DependentNameType *DependentName = T->getAs<DependentNameType>()){
1586       if (NestedNameSpecifier *NNS = DependentName->getQualifier())
1587         T = QualType(NNS->getAsType(), 0);
1588       else
1589         T = QualType();
1590       continue;
1591     }
1592
1593     // Retrieve the parent of an enumeration type.
1594     if (const EnumType *EnumT = T->getAs<EnumType>()) {
1595       // FIXME: Forward-declared enums require a TSK_ExplicitSpecialization
1596       // check here.
1597       EnumDecl *Enum = EnumT->getDecl();
1598
1599       // Get to the parent type.
1600       if (TypeDecl *Parent = dyn_cast<TypeDecl>(Enum->getParent()))
1601         T = Context.getTypeDeclType(Parent);
1602       else
1603         T = QualType();
1604       continue;
1605     }
1606
1607     T = QualType();
1608   }
1609   // Reverse the nested types list, since we want to traverse from the outermost
1610   // to the innermost while checking template-parameter-lists.
1611   std::reverse(NestedTypes.begin(), NestedTypes.end());
1612
1613   // C++0x [temp.expl.spec]p17:
1614   //   A member or a member template may be nested within many
1615   //   enclosing class templates. In an explicit specialization for
1616   //   such a member, the member declaration shall be preceded by a
1617   //   template<> for each enclosing class template that is
1618   //   explicitly specialized.
1619   bool SawNonEmptyTemplateParameterList = false;
1620   unsigned ParamIdx = 0;
1621   for (unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
1622        ++TypeIdx) {
1623     T = NestedTypes[TypeIdx];
1624
1625     // Whether we expect a 'template<>' header.
1626     bool NeedEmptyTemplateHeader = false;
1627
1628     // Whether we expect a template header with parameters.
1629     bool NeedNonemptyTemplateHeader = false;
1630
1631     // For a dependent type, the set of template parameters that we
1632     // expect to see.
1633     TemplateParameterList *ExpectedTemplateParams = 0;
1634
1635     // C++0x [temp.expl.spec]p15:
1636     //   A member or a member template may be nested within many enclosing
1637     //   class templates. In an explicit specialization for such a member, the
1638     //   member declaration shall be preceded by a template<> for each
1639     //   enclosing class template that is explicitly specialized.
1640     if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
1641       if (ClassTemplatePartialSpecializationDecl *Partial
1642             = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) {
1643         ExpectedTemplateParams = Partial->getTemplateParameters();
1644         NeedNonemptyTemplateHeader = true;
1645       } else if (Record->isDependentType()) {
1646         if (Record->getDescribedClassTemplate()) {
1647           ExpectedTemplateParams = Record->getDescribedClassTemplate()
1648                                                       ->getTemplateParameters();
1649           NeedNonemptyTemplateHeader = true;
1650         }
1651       } else if (ClassTemplateSpecializationDecl *Spec
1652                      = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
1653         // C++0x [temp.expl.spec]p4:
1654         //   Members of an explicitly specialized class template are defined
1655         //   in the same manner as members of normal classes, and not using
1656         //   the template<> syntax.
1657         if (Spec->getSpecializationKind() != TSK_ExplicitSpecialization)
1658           NeedEmptyTemplateHeader = true;
1659         else
1660           continue;
1661       } else if (Record->getTemplateSpecializationKind()) {
1662         if (Record->getTemplateSpecializationKind()
1663                                                 != TSK_ExplicitSpecialization &&
1664             TypeIdx == NumTypes - 1)
1665           IsExplicitSpecialization = true;
1666
1667         continue;
1668       }
1669     } else if (const TemplateSpecializationType *TST
1670                                      = T->getAs<TemplateSpecializationType>()) {
1671       if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
1672         ExpectedTemplateParams = Template->getTemplateParameters();
1673         NeedNonemptyTemplateHeader = true;
1674       }
1675     } else if (T->getAs<DependentTemplateSpecializationType>()) {
1676       // FIXME:  We actually could/should check the template arguments here
1677       // against the corresponding template parameter list.
1678       NeedNonemptyTemplateHeader = false;
1679     }
1680
1681     // C++ [temp.expl.spec]p16:
1682     //   In an explicit specialization declaration for a member of a class
1683     //   template or a member template that ap- pears in namespace scope, the
1684     //   member template and some of its enclosing class templates may remain
1685     //   unspecialized, except that the declaration shall not explicitly
1686     //   specialize a class member template if its en- closing class templates
1687     //   are not explicitly specialized as well.
1688     if (ParamIdx < NumParamLists) {
1689       if (ParamLists[ParamIdx]->size() == 0) {
1690         if (SawNonEmptyTemplateParameterList) {
1691           Diag(DeclLoc, diag::err_specialize_member_of_template)
1692             << ParamLists[ParamIdx]->getSourceRange();
1693           Invalid = true;
1694           IsExplicitSpecialization = false;
1695           return 0;
1696         }
1697       } else
1698         SawNonEmptyTemplateParameterList = true;
1699     }
1700
1701     if (NeedEmptyTemplateHeader) {
1702       // If we're on the last of the types, and we need a 'template<>' header
1703       // here, then it's an explicit specialization.
1704       if (TypeIdx == NumTypes - 1)
1705         IsExplicitSpecialization = true;
1706
1707       if (ParamIdx < NumParamLists) {
1708         if (ParamLists[ParamIdx]->size() > 0) {
1709           // The header has template parameters when it shouldn't. Complain.
1710           Diag(ParamLists[ParamIdx]->getTemplateLoc(),
1711                diag::err_template_param_list_matches_nontemplate)
1712             << T
1713             << SourceRange(ParamLists[ParamIdx]->getLAngleLoc(),
1714                            ParamLists[ParamIdx]->getRAngleLoc())
1715             << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
1716           Invalid = true;
1717           return 0;
1718         }
1719
1720         // Consume this template header.
1721         ++ParamIdx;
1722         continue;
1723       }
1724
1725       if (!IsFriend) {
1726         // We don't have a template header, but we should.
1727         SourceLocation ExpectedTemplateLoc;
1728         if (NumParamLists > 0)
1729           ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
1730         else
1731           ExpectedTemplateLoc = DeclStartLoc;
1732
1733         Diag(DeclLoc, diag::err_template_spec_needs_header)
1734           << getRangeOfTypeInNestedNameSpecifier(Context, T, SS)
1735           << FixItHint::CreateInsertion(ExpectedTemplateLoc, "template<> ");
1736       }
1737
1738       continue;
1739     }
1740
1741     if (NeedNonemptyTemplateHeader) {
1742       // In friend declarations we can have template-ids which don't
1743       // depend on the corresponding template parameter lists.  But
1744       // assume that empty parameter lists are supposed to match this
1745       // template-id.
1746       if (IsFriend && T->isDependentType()) {
1747         if (ParamIdx < NumParamLists &&
1748             DependsOnTemplateParameters(T, ParamLists[ParamIdx]))
1749           ExpectedTemplateParams = 0;
1750         else
1751           continue;
1752       }
1753
1754       if (ParamIdx < NumParamLists) {
1755         // Check the template parameter list, if we can.
1756         if (ExpectedTemplateParams &&
1757             !TemplateParameterListsAreEqual(ParamLists[ParamIdx],
1758                                             ExpectedTemplateParams,
1759                                             true, TPL_TemplateMatch))
1760           Invalid = true;
1761
1762         if (!Invalid &&
1763             CheckTemplateParameterList(ParamLists[ParamIdx], 0,
1764                                        TPC_ClassTemplateMember))
1765           Invalid = true;
1766
1767         ++ParamIdx;
1768         continue;
1769       }
1770
1771       Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
1772         << T
1773         << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
1774       Invalid = true;
1775       continue;
1776     }
1777   }
1778
1779   // If there were at least as many template-ids as there were template
1780   // parameter lists, then there are no template parameter lists remaining for
1781   // the declaration itself.
1782   if (ParamIdx >= NumParamLists)
1783     return 0;
1784
1785   // If there were too many template parameter lists, complain about that now.
1786   if (ParamIdx < NumParamLists - 1) {
1787     bool HasAnyExplicitSpecHeader = false;
1788     bool AllExplicitSpecHeaders = true;
1789     for (unsigned I = ParamIdx; I != NumParamLists - 1; ++I) {
1790       if (ParamLists[I]->size() == 0)
1791         HasAnyExplicitSpecHeader = true;
1792       else
1793         AllExplicitSpecHeaders = false;
1794     }
1795
1796     Diag(ParamLists[ParamIdx]->getTemplateLoc(),
1797          AllExplicitSpecHeaders? diag::warn_template_spec_extra_headers
1798                                : diag::err_template_spec_extra_headers)
1799       << SourceRange(ParamLists[ParamIdx]->getTemplateLoc(),
1800                      ParamLists[NumParamLists - 2]->getRAngleLoc());
1801
1802     // If there was a specialization somewhere, such that 'template<>' is
1803     // not required, and there were any 'template<>' headers, note where the
1804     // specialization occurred.
1805     if (ExplicitSpecLoc.isValid() && HasAnyExplicitSpecHeader)
1806       Diag(ExplicitSpecLoc,
1807            diag::note_explicit_template_spec_does_not_need_header)
1808         << NestedTypes.back();
1809
1810     // We have a template parameter list with no corresponding scope, which
1811     // means that the resulting template declaration can't be instantiated
1812     // properly (we'll end up with dependent nodes when we shouldn't).
1813     if (!AllExplicitSpecHeaders)
1814       Invalid = true;
1815   }
1816
1817   // C++ [temp.expl.spec]p16:
1818   //   In an explicit specialization declaration for a member of a class
1819   //   template or a member template that ap- pears in namespace scope, the
1820   //   member template and some of its enclosing class templates may remain
1821   //   unspecialized, except that the declaration shall not explicitly
1822   //   specialize a class member template if its en- closing class templates
1823   //   are not explicitly specialized as well.
1824   if (ParamLists[NumParamLists - 1]->size() == 0 &&
1825       SawNonEmptyTemplateParameterList) {
1826     Diag(DeclLoc, diag::err_specialize_member_of_template)
1827       << ParamLists[ParamIdx]->getSourceRange();
1828     Invalid = true;
1829     IsExplicitSpecialization = false;
1830     return 0;
1831   }
1832
1833   // Return the last template parameter list, which corresponds to the
1834   // entity being declared.
1835   return ParamLists[NumParamLists - 1];
1836 }
1837
1838 void Sema::NoteAllFoundTemplates(TemplateName Name) {
1839   if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
1840     Diag(Template->getLocation(), diag::note_template_declared_here)
1841       << (isa<FunctionTemplateDecl>(Template)? 0
1842           : isa<ClassTemplateDecl>(Template)? 1
1843           : isa<TypeAliasTemplateDecl>(Template)? 2
1844           : 3)
1845       << Template->getDeclName();
1846     return;
1847   }
1848
1849   if (OverloadedTemplateStorage *OST = Name.getAsOverloadedTemplate()) {
1850     for (OverloadedTemplateStorage::iterator I = OST->begin(),
1851                                           IEnd = OST->end();
1852          I != IEnd; ++I)
1853       Diag((*I)->getLocation(), diag::note_template_declared_here)
1854         << 0 << (*I)->getDeclName();
1855
1856     return;
1857   }
1858 }
1859
1860
1861 QualType Sema::CheckTemplateIdType(TemplateName Name,
1862                                    SourceLocation TemplateLoc,
1863                                    TemplateArgumentListInfo &TemplateArgs) {
1864   DependentTemplateName *DTN
1865     = Name.getUnderlying().getAsDependentTemplateName();
1866   if (DTN && DTN->isIdentifier())
1867     // When building a template-id where the template-name is dependent,
1868     // assume the template is a type template. Either our assumption is
1869     // correct, or the code is ill-formed and will be diagnosed when the
1870     // dependent name is substituted.
1871     return Context.getDependentTemplateSpecializationType(ETK_None,
1872                                                           DTN->getQualifier(),
1873                                                           DTN->getIdentifier(),
1874                                                           TemplateArgs);
1875
1876   TemplateDecl *Template = Name.getAsTemplateDecl();
1877   if (!Template || isa<FunctionTemplateDecl>(Template)) {
1878     // We might have a substituted template template parameter pack. If so,
1879     // build a template specialization type for it.
1880     if (Name.getAsSubstTemplateTemplateParmPack())
1881       return Context.getTemplateSpecializationType(Name, TemplateArgs);
1882
1883     Diag(TemplateLoc, diag::err_template_id_not_a_type)
1884       << Name;
1885     NoteAllFoundTemplates(Name);
1886     return QualType();
1887   }
1888
1889   // Check that the template argument list is well-formed for this
1890   // template.
1891   llvm::SmallVector<TemplateArgument, 4> Converted;
1892   if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs,
1893                                 false, Converted))
1894     return QualType();
1895
1896   assert((Converted.size() == Template->getTemplateParameters()->size()) &&
1897          "Converted template argument list is too short!");
1898
1899   QualType CanonType;
1900
1901   bool InstantiationDependent = false;
1902   if (TypeAliasTemplateDecl *AliasTemplate
1903         = dyn_cast<TypeAliasTemplateDecl>(Template)) {
1904     // Find the canonical type for this type alias template specialization.
1905     TypeAliasDecl *Pattern = AliasTemplate->getTemplatedDecl();
1906     if (Pattern->isInvalidDecl())
1907       return QualType();
1908
1909     TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
1910                                       Converted.data(), Converted.size());
1911
1912     // Only substitute for the innermost template argument list.
1913     MultiLevelTemplateArgumentList TemplateArgLists;
1914     TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
1915     unsigned Depth = AliasTemplate->getTemplateParameters()->getDepth();
1916     for (unsigned I = 0; I < Depth; ++I)
1917       TemplateArgLists.addOuterTemplateArguments(0, 0);
1918
1919     InstantiatingTemplate Inst(*this, TemplateLoc, Template);
1920     CanonType = SubstType(Pattern->getUnderlyingType(),
1921                           TemplateArgLists, AliasTemplate->getLocation(),
1922                           AliasTemplate->getDeclName());
1923     if (CanonType.isNull())
1924       return QualType();
1925   } else if (Name.isDependent() ||
1926              TemplateSpecializationType::anyDependentTemplateArguments(
1927                TemplateArgs, InstantiationDependent)) {
1928     // This class template specialization is a dependent
1929     // type. Therefore, its canonical type is another class template
1930     // specialization type that contains all of the converted
1931     // arguments in canonical form. This ensures that, e.g., A<T> and
1932     // A<T, T> have identical types when A is declared as:
1933     //
1934     //   template<typename T, typename U = T> struct A;
1935     TemplateName CanonName = Context.getCanonicalTemplateName(Name);
1936     CanonType = Context.getTemplateSpecializationType(CanonName,
1937                                                       Converted.data(),
1938                                                       Converted.size());
1939
1940     // FIXME: CanonType is not actually the canonical type, and unfortunately
1941     // it is a TemplateSpecializationType that we will never use again.
1942     // In the future, we need to teach getTemplateSpecializationType to only
1943     // build the canonical type and return that to us.
1944     CanonType = Context.getCanonicalType(CanonType);
1945
1946     // This might work out to be a current instantiation, in which
1947     // case the canonical type needs to be the InjectedClassNameType.
1948     //
1949     // TODO: in theory this could be a simple hashtable lookup; most
1950     // changes to CurContext don't change the set of current
1951     // instantiations.
1952     if (isa<ClassTemplateDecl>(Template)) {
1953       for (DeclContext *Ctx = CurContext; Ctx; Ctx = Ctx->getLookupParent()) {
1954         // If we get out to a namespace, we're done.
1955         if (Ctx->isFileContext()) break;
1956
1957         // If this isn't a record, keep looking.
1958         CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx);
1959         if (!Record) continue;
1960
1961         // Look for one of the two cases with InjectedClassNameTypes
1962         // and check whether it's the same template.
1963         if (!isa<ClassTemplatePartialSpecializationDecl>(Record) &&
1964             !Record->getDescribedClassTemplate())
1965           continue;
1966
1967         // Fetch the injected class name type and check whether its
1968         // injected type is equal to the type we just built.
1969         QualType ICNT = Context.getTypeDeclType(Record);
1970         QualType Injected = cast<InjectedClassNameType>(ICNT)
1971           ->getInjectedSpecializationType();
1972
1973         if (CanonType != Injected->getCanonicalTypeInternal())
1974           continue;
1975
1976         // If so, the canonical type of this TST is the injected
1977         // class name type of the record we just found.
1978         assert(ICNT.isCanonical());
1979         CanonType = ICNT;
1980         break;
1981       }
1982     }
1983   } else if (ClassTemplateDecl *ClassTemplate
1984                = dyn_cast<ClassTemplateDecl>(Template)) {
1985     // Find the class template specialization declaration that
1986     // corresponds to these arguments.
1987     void *InsertPos = 0;
1988     ClassTemplateSpecializationDecl *Decl
1989       = ClassTemplate->findSpecialization(Converted.data(), Converted.size(),
1990                                           InsertPos);
1991     if (!Decl) {
1992       // This is the first time we have referenced this class template
1993       // specialization. Create the canonical declaration and add it to
1994       // the set of specializations.
1995       Decl = ClassTemplateSpecializationDecl::Create(Context,
1996                             ClassTemplate->getTemplatedDecl()->getTagKind(),
1997                                                 ClassTemplate->getDeclContext(),
1998                                                 ClassTemplate->getLocation(),
1999                                                 ClassTemplate->getLocation(),
2000                                                      ClassTemplate,
2001                                                      Converted.data(),
2002                                                      Converted.size(), 0);
2003       ClassTemplate->AddSpecialization(Decl, InsertPos);
2004       Decl->setLexicalDeclContext(CurContext);
2005     }
2006
2007     CanonType = Context.getTypeDeclType(Decl);
2008     assert(isa<RecordType>(CanonType) &&
2009            "type of non-dependent specialization is not a RecordType");
2010   }
2011
2012   // Build the fully-sugared type for this class template
2013   // specialization, which refers back to the class template
2014   // specialization we created or found.
2015   return Context.getTemplateSpecializationType(Name, TemplateArgs, CanonType);
2016 }
2017
2018 TypeResult
2019 Sema::ActOnTemplateIdType(CXXScopeSpec &SS,
2020                           TemplateTy TemplateD, SourceLocation TemplateLoc,
2021                           SourceLocation LAngleLoc,
2022                           ASTTemplateArgsPtr TemplateArgsIn,
2023                           SourceLocation RAngleLoc) {
2024   if (SS.isInvalid())
2025     return true;
2026
2027   TemplateName Template = TemplateD.getAsVal<TemplateName>();
2028
2029   // Translate the parser's template argument list in our AST format.
2030   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
2031   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
2032
2033   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
2034     QualType T = Context.getDependentTemplateSpecializationType(ETK_None,
2035                                                            DTN->getQualifier(),
2036                                                            DTN->getIdentifier(),
2037                                                                 TemplateArgs);
2038
2039     // Build type-source information.
2040     TypeLocBuilder TLB;
2041     DependentTemplateSpecializationTypeLoc SpecTL
2042       = TLB.push<DependentTemplateSpecializationTypeLoc>(T);
2043     SpecTL.setKeywordLoc(SourceLocation());
2044     SpecTL.setNameLoc(TemplateLoc);
2045     SpecTL.setLAngleLoc(LAngleLoc);
2046     SpecTL.setRAngleLoc(RAngleLoc);
2047     SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
2048     for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
2049       SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
2050     return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
2051   }
2052
2053   QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
2054   TemplateArgsIn.release();
2055
2056   if (Result.isNull())
2057     return true;
2058
2059   // Build type-source information.
2060   TypeLocBuilder TLB;
2061   TemplateSpecializationTypeLoc SpecTL
2062     = TLB.push<TemplateSpecializationTypeLoc>(Result);
2063   SpecTL.setTemplateNameLoc(TemplateLoc);
2064   SpecTL.setLAngleLoc(LAngleLoc);
2065   SpecTL.setRAngleLoc(RAngleLoc);
2066   for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
2067     SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
2068
2069   if (SS.isNotEmpty()) {
2070     // Create an elaborated-type-specifier containing the nested-name-specifier.
2071     Result = Context.getElaboratedType(ETK_None, SS.getScopeRep(), Result);
2072     ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
2073     ElabTL.setKeywordLoc(SourceLocation());
2074     ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
2075   }
2076
2077   return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
2078 }
2079
2080 TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK,
2081                                         TypeSpecifierType TagSpec,
2082                                         SourceLocation TagLoc,
2083                                         CXXScopeSpec &SS,
2084                                         TemplateTy TemplateD,
2085                                         SourceLocation TemplateLoc,
2086                                         SourceLocation LAngleLoc,
2087                                         ASTTemplateArgsPtr TemplateArgsIn,
2088                                         SourceLocation RAngleLoc) {
2089   TemplateName Template = TemplateD.getAsVal<TemplateName>();
2090
2091   // Translate the parser's template argument list in our AST format.
2092   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
2093   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
2094
2095   // Determine the tag kind
2096   TagTypeKind TagKind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
2097   ElaboratedTypeKeyword Keyword
2098     = TypeWithKeyword::getKeywordForTagTypeKind(TagKind);
2099
2100   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
2101     QualType T = Context.getDependentTemplateSpecializationType(Keyword,
2102                                                           DTN->getQualifier(),
2103                                                           DTN->getIdentifier(),
2104                                                                 TemplateArgs);
2105
2106     // Build type-source information.
2107     TypeLocBuilder TLB;
2108     DependentTemplateSpecializationTypeLoc SpecTL
2109     = TLB.push<DependentTemplateSpecializationTypeLoc>(T);
2110     SpecTL.setKeywordLoc(TagLoc);
2111     SpecTL.setNameLoc(TemplateLoc);
2112     SpecTL.setLAngleLoc(LAngleLoc);
2113     SpecTL.setRAngleLoc(RAngleLoc);
2114     SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
2115     for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
2116       SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
2117     return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
2118   }
2119
2120   if (TypeAliasTemplateDecl *TAT =
2121         dyn_cast_or_null<TypeAliasTemplateDecl>(Template.getAsTemplateDecl())) {
2122     // C++0x [dcl.type.elab]p2:
2123     //   If the identifier resolves to a typedef-name or the simple-template-id
2124     //   resolves to an alias template specialization, the
2125     //   elaborated-type-specifier is ill-formed.
2126     Diag(TemplateLoc, diag::err_tag_reference_non_tag) << 4;
2127     Diag(TAT->getLocation(), diag::note_declared_at);
2128   }
2129
2130   QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
2131   if (Result.isNull())
2132     return TypeResult();
2133
2134   // Check the tag kind
2135   if (const RecordType *RT = Result->getAs<RecordType>()) {
2136     RecordDecl *D = RT->getDecl();
2137
2138     IdentifierInfo *Id = D->getIdentifier();
2139     assert(Id && "templated class must have an identifier");
2140
2141     if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition,
2142                                       TagLoc, *Id)) {
2143       Diag(TagLoc, diag::err_use_with_wrong_tag)
2144         << Result
2145         << FixItHint::CreateReplacement(SourceRange(TagLoc), D->getKindName());
2146       Diag(D->getLocation(), diag::note_previous_use);
2147     }
2148   }
2149
2150   // Provide source-location information for the template specialization.
2151   TypeLocBuilder TLB;
2152   TemplateSpecializationTypeLoc SpecTL
2153     = TLB.push<TemplateSpecializationTypeLoc>(Result);
2154   SpecTL.setTemplateNameLoc(TemplateLoc);
2155   SpecTL.setLAngleLoc(LAngleLoc);
2156   SpecTL.setRAngleLoc(RAngleLoc);
2157   for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
2158     SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
2159
2160   // Construct an elaborated type containing the nested-name-specifier (if any)
2161   // and keyword.
2162   Result = Context.getElaboratedType(Keyword, SS.getScopeRep(), Result);
2163   ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
2164   ElabTL.setKeywordLoc(TagLoc);
2165   ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
2166   return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
2167 }
2168
2169 ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,
2170                                      LookupResult &R,
2171                                      bool RequiresADL,
2172                                  const TemplateArgumentListInfo &TemplateArgs) {
2173   // FIXME: Can we do any checking at this point? I guess we could check the
2174   // template arguments that we have against the template name, if the template
2175   // name refers to a single template. That's not a terribly common case,
2176   // though.
2177   // foo<int> could identify a single function unambiguously
2178   // This approach does NOT work, since f<int>(1);
2179   // gets resolved prior to resorting to overload resolution
2180   // i.e., template<class T> void f(double);
2181   //       vs template<class T, class U> void f(U);
2182
2183   // These should be filtered out by our callers.
2184   assert(!R.empty() && "empty lookup results when building templateid");
2185   assert(!R.isAmbiguous() && "ambiguous lookup when building templateid");
2186
2187   // We don't want lookup warnings at this point.
2188   R.suppressDiagnostics();
2189
2190   UnresolvedLookupExpr *ULE
2191     = UnresolvedLookupExpr::Create(Context, R.getNamingClass(),
2192                                    SS.getWithLocInContext(Context),
2193                                    R.getLookupNameInfo(),
2194                                    RequiresADL, TemplateArgs,
2195                                    R.begin(), R.end());
2196
2197   return Owned(ULE);
2198 }
2199
2200 // We actually only call this from template instantiation.
2201 ExprResult
2202 Sema::BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS,
2203                                    const DeclarationNameInfo &NameInfo,
2204                              const TemplateArgumentListInfo &TemplateArgs) {
2205   DeclContext *DC;
2206   if (!(DC = computeDeclContext(SS, false)) ||
2207       DC->isDependentContext() ||
2208       RequireCompleteDeclContext(SS, DC))
2209     return BuildDependentDeclRefExpr(SS, NameInfo, &TemplateArgs);
2210
2211   bool MemberOfUnknownSpecialization;
2212   LookupResult R(*this, NameInfo, LookupOrdinaryName);
2213   LookupTemplateName(R, (Scope*) 0, SS, QualType(), /*Entering*/ false,
2214                      MemberOfUnknownSpecialization);
2215
2216   if (R.isAmbiguous())
2217     return ExprError();
2218
2219   if (R.empty()) {
2220     Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_non_template)
2221       << NameInfo.getName() << SS.getRange();
2222     return ExprError();
2223   }
2224
2225   if (ClassTemplateDecl *Temp = R.getAsSingle<ClassTemplateDecl>()) {
2226     Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_class_template)
2227       << (NestedNameSpecifier*) SS.getScopeRep()
2228       << NameInfo.getName() << SS.getRange();
2229     Diag(Temp->getLocation(), diag::note_referenced_class_template);
2230     return ExprError();
2231   }
2232
2233   return BuildTemplateIdExpr(SS, R, /* ADL */ false, TemplateArgs);
2234 }
2235
2236 /// \brief Form a dependent template name.
2237 ///
2238 /// This action forms a dependent template name given the template
2239 /// name and its (presumably dependent) scope specifier. For
2240 /// example, given "MetaFun::template apply", the scope specifier \p
2241 /// SS will be "MetaFun::", \p TemplateKWLoc contains the location
2242 /// of the "template" keyword, and "apply" is the \p Name.
2243 TemplateNameKind Sema::ActOnDependentTemplateName(Scope *S,
2244                                                   SourceLocation TemplateKWLoc,
2245                                                   CXXScopeSpec &SS,
2246                                                   UnqualifiedId &Name,
2247                                                   ParsedType ObjectType,
2248                                                   bool EnteringContext,
2249                                                   TemplateTy &Result) {
2250   if (TemplateKWLoc.isValid() && S && !S->getTemplateParamParent() &&
2251       !getLangOptions().CPlusPlus0x)
2252     Diag(TemplateKWLoc, diag::ext_template_outside_of_template)
2253       << FixItHint::CreateRemoval(TemplateKWLoc);
2254
2255   DeclContext *LookupCtx = 0;
2256   if (SS.isSet())
2257     LookupCtx = computeDeclContext(SS, EnteringContext);
2258   if (!LookupCtx && ObjectType)
2259     LookupCtx = computeDeclContext(ObjectType.get());
2260   if (LookupCtx) {
2261     // C++0x [temp.names]p5:
2262     //   If a name prefixed by the keyword template is not the name of
2263     //   a template, the program is ill-formed. [Note: the keyword
2264     //   template may not be applied to non-template members of class
2265     //   templates. -end note ] [ Note: as is the case with the
2266     //   typename prefix, the template prefix is allowed in cases
2267     //   where it is not strictly necessary; i.e., when the
2268     //   nested-name-specifier or the expression on the left of the ->
2269     //   or . is not dependent on a template-parameter, or the use
2270     //   does not appear in the scope of a template. -end note]
2271     //
2272     // Note: C++03 was more strict here, because it banned the use of
2273     // the "template" keyword prior to a template-name that was not a
2274     // dependent name. C++ DR468 relaxed this requirement (the
2275     // "template" keyword is now permitted). We follow the C++0x
2276     // rules, even in C++03 mode with a warning, retroactively applying the DR.
2277     bool MemberOfUnknownSpecialization;
2278     TemplateNameKind TNK = isTemplateName(0, SS, TemplateKWLoc.isValid(), Name,
2279                                           ObjectType, EnteringContext, Result,
2280                                           MemberOfUnknownSpecialization);
2281     if (TNK == TNK_Non_template && LookupCtx->isDependentContext() &&
2282         isa<CXXRecordDecl>(LookupCtx) &&
2283         (!cast<CXXRecordDecl>(LookupCtx)->hasDefinition() ||
2284          cast<CXXRecordDecl>(LookupCtx)->hasAnyDependentBases())) {
2285       // This is a dependent template. Handle it below.
2286     } else if (TNK == TNK_Non_template) {
2287       Diag(Name.getSourceRange().getBegin(),
2288            diag::err_template_kw_refers_to_non_template)
2289         << GetNameFromUnqualifiedId(Name).getName()
2290         << Name.getSourceRange()
2291         << TemplateKWLoc;
2292       return TNK_Non_template;
2293     } else {
2294       // We found something; return it.
2295       return TNK;
2296     }
2297   }
2298
2299   NestedNameSpecifier *Qualifier
2300     = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
2301
2302   switch (Name.getKind()) {
2303   case UnqualifiedId::IK_Identifier:
2304     Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
2305                                                               Name.Identifier));
2306     return TNK_Dependent_template_name;
2307
2308   case UnqualifiedId::IK_OperatorFunctionId:
2309     Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
2310                                              Name.OperatorFunctionId.Operator));
2311     return TNK_Dependent_template_name;
2312
2313   case UnqualifiedId::IK_LiteralOperatorId:
2314     assert(false && "We don't support these; Parse shouldn't have allowed propagation");
2315
2316   default:
2317     break;
2318   }
2319
2320   Diag(Name.getSourceRange().getBegin(),
2321        diag::err_template_kw_refers_to_non_template)
2322     << GetNameFromUnqualifiedId(Name).getName()
2323     << Name.getSourceRange()
2324     << TemplateKWLoc;
2325   return TNK_Non_template;
2326 }
2327
2328 bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
2329                                      const TemplateArgumentLoc &AL,
2330                           llvm::SmallVectorImpl<TemplateArgument> &Converted) {
2331   const TemplateArgument &Arg = AL.getArgument();
2332
2333   // Check template type parameter.
2334   switch(Arg.getKind()) {
2335   case TemplateArgument::Type:
2336     // C++ [temp.arg.type]p1:
2337     //   A template-argument for a template-parameter which is a
2338     //   type shall be a type-id.
2339     break;
2340   case TemplateArgument::Template: {
2341     // We have a template type parameter but the template argument
2342     // is a template without any arguments.
2343     SourceRange SR = AL.getSourceRange();
2344     TemplateName Name = Arg.getAsTemplate();
2345     Diag(SR.getBegin(), diag::err_template_missing_args)
2346       << Name << SR;
2347     if (TemplateDecl *Decl = Name.getAsTemplateDecl())
2348       Diag(Decl->getLocation(), diag::note_template_decl_here);
2349
2350     return true;
2351   }
2352   default: {
2353     // We have a template type parameter but the template argument
2354     // is not a type.
2355     SourceRange SR = AL.getSourceRange();
2356     Diag(SR.getBegin(), diag::err_template_arg_must_be_type) << SR;
2357     Diag(Param->getLocation(), diag::note_template_param_here);
2358
2359     return true;
2360   }
2361   }
2362
2363   if (CheckTemplateArgument(Param, AL.getTypeSourceInfo()))
2364     return true;
2365
2366   // Add the converted template type argument.
2367   QualType ArgType = Context.getCanonicalType(Arg.getAsType());
2368
2369   // Objective-C ARC:
2370   //   If an explicitly-specified template argument type is a lifetime type
2371   //   with no lifetime qualifier, the __strong lifetime qualifier is inferred.
2372   if (getLangOptions().ObjCAutoRefCount &&
2373       ArgType->isObjCLifetimeType() &&
2374       !ArgType.getObjCLifetime()) {
2375     Qualifiers Qs;
2376     Qs.setObjCLifetime(Qualifiers::OCL_Strong);
2377     ArgType = Context.getQualifiedType(ArgType, Qs);
2378   }
2379
2380   Converted.push_back(TemplateArgument(ArgType));
2381   return false;
2382 }
2383
2384 /// \brief Substitute template arguments into the default template argument for
2385 /// the given template type parameter.
2386 ///
2387 /// \param SemaRef the semantic analysis object for which we are performing
2388 /// the substitution.
2389 ///
2390 /// \param Template the template that we are synthesizing template arguments
2391 /// for.
2392 ///
2393 /// \param TemplateLoc the location of the template name that started the
2394 /// template-id we are checking.
2395 ///
2396 /// \param RAngleLoc the location of the right angle bracket ('>') that
2397 /// terminates the template-id.
2398 ///
2399 /// \param Param the template template parameter whose default we are
2400 /// substituting into.
2401 ///
2402 /// \param Converted the list of template arguments provided for template
2403 /// parameters that precede \p Param in the template parameter list.
2404 /// \returns the substituted template argument, or NULL if an error occurred.
2405 static TypeSourceInfo *
2406 SubstDefaultTemplateArgument(Sema &SemaRef,
2407                              TemplateDecl *Template,
2408                              SourceLocation TemplateLoc,
2409                              SourceLocation RAngleLoc,
2410                              TemplateTypeParmDecl *Param,
2411                          llvm::SmallVectorImpl<TemplateArgument> &Converted) {
2412   TypeSourceInfo *ArgType = Param->getDefaultArgumentInfo();
2413
2414   // If the argument type is dependent, instantiate it now based
2415   // on the previously-computed template arguments.
2416   if (ArgType->getType()->isDependentType()) {
2417     TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
2418                                       Converted.data(), Converted.size());
2419
2420     MultiLevelTemplateArgumentList AllTemplateArgs
2421       = SemaRef.getTemplateInstantiationArgs(Template, &TemplateArgs);
2422
2423     Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
2424                                      Template, Converted.data(),
2425                                      Converted.size(),
2426                                      SourceRange(TemplateLoc, RAngleLoc));
2427
2428     ArgType = SemaRef.SubstType(ArgType, AllTemplateArgs,
2429                                 Param->getDefaultArgumentLoc(),
2430                                 Param->getDeclName());
2431   }
2432
2433   return ArgType;
2434 }
2435
2436 /// \brief Substitute template arguments into the default template argument for
2437 /// the given non-type template parameter.
2438 ///
2439 /// \param SemaRef the semantic analysis object for which we are performing
2440 /// the substitution.
2441 ///
2442 /// \param Template the template that we are synthesizing template arguments
2443 /// for.
2444 ///
2445 /// \param TemplateLoc the location of the template name that started the
2446 /// template-id we are checking.
2447 ///
2448 /// \param RAngleLoc the location of the right angle bracket ('>') that
2449 /// terminates the template-id.
2450 ///
2451 /// \param Param the non-type template parameter whose default we are
2452 /// substituting into.
2453 ///
2454 /// \param Converted the list of template arguments provided for template
2455 /// parameters that precede \p Param in the template parameter list.
2456 ///
2457 /// \returns the substituted template argument, or NULL if an error occurred.
2458 static ExprResult
2459 SubstDefaultTemplateArgument(Sema &SemaRef,
2460                              TemplateDecl *Template,
2461                              SourceLocation TemplateLoc,
2462                              SourceLocation RAngleLoc,
2463                              NonTypeTemplateParmDecl *Param,
2464                         llvm::SmallVectorImpl<TemplateArgument> &Converted) {
2465   TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
2466                                     Converted.data(), Converted.size());
2467
2468   MultiLevelTemplateArgumentList AllTemplateArgs
2469     = SemaRef.getTemplateInstantiationArgs(Template, &TemplateArgs);
2470
2471   Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
2472                                    Template, Converted.data(),
2473                                    Converted.size(),
2474                                    SourceRange(TemplateLoc, RAngleLoc));
2475
2476   return SemaRef.SubstExpr(Param->getDefaultArgument(), AllTemplateArgs);
2477 }
2478
2479 /// \brief Substitute template arguments into the default template argument for
2480 /// the given template template parameter.
2481 ///
2482 /// \param SemaRef the semantic analysis object for which we are performing
2483 /// the substitution.
2484 ///
2485 /// \param Template the template that we are synthesizing template arguments
2486 /// for.
2487 ///
2488 /// \param TemplateLoc the location of the template name that started the
2489 /// template-id we are checking.
2490 ///
2491 /// \param RAngleLoc the location of the right angle bracket ('>') that
2492 /// terminates the template-id.
2493 ///
2494 /// \param Param the template template parameter whose default we are
2495 /// substituting into.
2496 ///
2497 /// \param Converted the list of template arguments provided for template
2498 /// parameters that precede \p Param in the template parameter list.
2499 ///
2500 /// \param QualifierLoc Will be set to the nested-name-specifier (with
2501 /// source-location information) that precedes the template name.
2502 ///
2503 /// \returns the substituted template argument, or NULL if an error occurred.
2504 static TemplateName
2505 SubstDefaultTemplateArgument(Sema &SemaRef,
2506                              TemplateDecl *Template,
2507                              SourceLocation TemplateLoc,
2508                              SourceLocation RAngleLoc,
2509                              TemplateTemplateParmDecl *Param,
2510                        llvm::SmallVectorImpl<TemplateArgument> &Converted,
2511                              NestedNameSpecifierLoc &QualifierLoc) {
2512   TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
2513                                     Converted.data(), Converted.size());
2514
2515   MultiLevelTemplateArgumentList AllTemplateArgs
2516     = SemaRef.getTemplateInstantiationArgs(Template, &TemplateArgs);
2517
2518   Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
2519                                    Template, Converted.data(),
2520                                    Converted.size(),
2521                                    SourceRange(TemplateLoc, RAngleLoc));
2522
2523   // Substitute into the nested-name-specifier first,
2524   QualifierLoc = Param->getDefaultArgument().getTemplateQualifierLoc();
2525   if (QualifierLoc) {
2526     QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
2527                                                        AllTemplateArgs);
2528     if (!QualifierLoc)
2529       return TemplateName();
2530   }
2531
2532   return SemaRef.SubstTemplateName(QualifierLoc,
2533                       Param->getDefaultArgument().getArgument().getAsTemplate(),
2534                               Param->getDefaultArgument().getTemplateNameLoc(),
2535                                    AllTemplateArgs);
2536 }
2537
2538 /// \brief If the given template parameter has a default template
2539 /// argument, substitute into that default template argument and
2540 /// return the corresponding template argument.
2541 TemplateArgumentLoc
2542 Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
2543                                               SourceLocation TemplateLoc,
2544                                               SourceLocation RAngleLoc,
2545                                               Decl *Param,
2546                       llvm::SmallVectorImpl<TemplateArgument> &Converted) {
2547    if (TemplateTypeParmDecl *TypeParm = dyn_cast<TemplateTypeParmDecl>(Param)) {
2548     if (!TypeParm->hasDefaultArgument())
2549       return TemplateArgumentLoc();
2550
2551     TypeSourceInfo *DI = SubstDefaultTemplateArgument(*this, Template,
2552                                                       TemplateLoc,
2553                                                       RAngleLoc,
2554                                                       TypeParm,
2555                                                       Converted);
2556     if (DI)
2557       return TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
2558
2559     return TemplateArgumentLoc();
2560   }
2561
2562   if (NonTypeTemplateParmDecl *NonTypeParm
2563         = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
2564     if (!NonTypeParm->hasDefaultArgument())
2565       return TemplateArgumentLoc();
2566
2567     ExprResult Arg = SubstDefaultTemplateArgument(*this, Template,
2568                                                   TemplateLoc,
2569                                                   RAngleLoc,
2570                                                   NonTypeParm,
2571                                                   Converted);
2572     if (Arg.isInvalid())
2573       return TemplateArgumentLoc();
2574
2575     Expr *ArgE = Arg.takeAs<Expr>();
2576     return TemplateArgumentLoc(TemplateArgument(ArgE), ArgE);
2577   }
2578
2579   TemplateTemplateParmDecl *TempTempParm
2580     = cast<TemplateTemplateParmDecl>(Param);
2581   if (!TempTempParm->hasDefaultArgument())
2582     return TemplateArgumentLoc();
2583
2584
2585   NestedNameSpecifierLoc QualifierLoc;
2586   TemplateName TName = SubstDefaultTemplateArgument(*this, Template,
2587                                                     TemplateLoc,
2588                                                     RAngleLoc,
2589                                                     TempTempParm,
2590                                                     Converted,
2591                                                     QualifierLoc);
2592   if (TName.isNull())
2593     return TemplateArgumentLoc();
2594
2595   return TemplateArgumentLoc(TemplateArgument(TName),
2596                 TempTempParm->getDefaultArgument().getTemplateQualifierLoc(),
2597                 TempTempParm->getDefaultArgument().getTemplateNameLoc());
2598 }
2599
2600 /// \brief Check that the given template argument corresponds to the given
2601 /// template parameter.
2602 ///
2603 /// \param Param The template parameter against which the argument will be
2604 /// checked.
2605 ///
2606 /// \param Arg The template argument.
2607 ///
2608 /// \param Template The template in which the template argument resides.
2609 ///
2610 /// \param TemplateLoc The location of the template name for the template
2611 /// whose argument list we're matching.
2612 ///
2613 /// \param RAngleLoc The location of the right angle bracket ('>') that closes
2614 /// the template argument list.
2615 ///
2616 /// \param ArgumentPackIndex The index into the argument pack where this
2617 /// argument will be placed. Only valid if the parameter is a parameter pack.
2618 ///
2619 /// \param Converted The checked, converted argument will be added to the
2620 /// end of this small vector.
2621 ///
2622 /// \param CTAK Describes how we arrived at this particular template argument:
2623 /// explicitly written, deduced, etc.
2624 ///
2625 /// \returns true on error, false otherwise.
2626 bool Sema::CheckTemplateArgument(NamedDecl *Param,
2627                                  const TemplateArgumentLoc &Arg,
2628                                  NamedDecl *Template,
2629                                  SourceLocation TemplateLoc,
2630                                  SourceLocation RAngleLoc,
2631                                  unsigned ArgumentPackIndex,
2632                             llvm::SmallVectorImpl<TemplateArgument> &Converted,
2633                                  CheckTemplateArgumentKind CTAK) {
2634   // Check template type parameters.
2635   if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2636     return CheckTemplateTypeArgument(TTP, Arg, Converted);
2637
2638   // Check non-type template parameters.
2639   if (NonTypeTemplateParmDecl *NTTP =dyn_cast<NonTypeTemplateParmDecl>(Param)) {
2640     // Do substitution on the type of the non-type template parameter
2641     // with the template arguments we've seen thus far.  But if the
2642     // template has a dependent context then we cannot substitute yet.
2643     QualType NTTPType = NTTP->getType();
2644     if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
2645       NTTPType = NTTP->getExpansionType(ArgumentPackIndex);
2646
2647     if (NTTPType->isDependentType() &&
2648         !isa<TemplateTemplateParmDecl>(Template) &&
2649         !Template->getDeclContext()->isDependentContext()) {
2650       // Do substitution on the type of the non-type template parameter.
2651       InstantiatingTemplate Inst(*this, TemplateLoc, Template,
2652                                  NTTP, Converted.data(), Converted.size(),
2653                                  SourceRange(TemplateLoc, RAngleLoc));
2654
2655       TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
2656                                         Converted.data(), Converted.size());
2657       NTTPType = SubstType(NTTPType,
2658                            MultiLevelTemplateArgumentList(TemplateArgs),
2659                            NTTP->getLocation(),
2660                            NTTP->getDeclName());
2661       // If that worked, check the non-type template parameter type
2662       // for validity.
2663       if (!NTTPType.isNull())
2664         NTTPType = CheckNonTypeTemplateParameterType(NTTPType,
2665                                                      NTTP->getLocation());
2666       if (NTTPType.isNull())
2667         return true;
2668     }
2669
2670     switch (Arg.getArgument().getKind()) {
2671     case TemplateArgument::Null:
2672       assert(false && "Should never see a NULL template argument here");
2673       return true;
2674
2675     case TemplateArgument::Expression: {
2676       TemplateArgument Result;
2677       ExprResult Res =
2678         CheckTemplateArgument(NTTP, NTTPType, Arg.getArgument().getAsExpr(),
2679                               Result, CTAK);
2680       if (Res.isInvalid())
2681         return true;
2682
2683       Converted.push_back(Result);
2684       break;
2685     }
2686
2687     case TemplateArgument::Declaration:
2688     case TemplateArgument::Integral:
2689       // We've already checked this template argument, so just copy
2690       // it to the list of converted arguments.
2691       Converted.push_back(Arg.getArgument());
2692       break;
2693
2694     case TemplateArgument::Template:
2695     case TemplateArgument::TemplateExpansion:
2696       // We were given a template template argument. It may not be ill-formed;
2697       // see below.
2698       if (DependentTemplateName *DTN
2699             = Arg.getArgument().getAsTemplateOrTemplatePattern()
2700                                               .getAsDependentTemplateName()) {
2701         // We have a template argument such as \c T::template X, which we
2702         // parsed as a template template argument. However, since we now
2703         // know that we need a non-type template argument, convert this
2704         // template name into an expression.
2705
2706         DeclarationNameInfo NameInfo(DTN->getIdentifier(),
2707                                      Arg.getTemplateNameLoc());
2708
2709         CXXScopeSpec SS;
2710         SS.Adopt(Arg.getTemplateQualifierLoc());
2711         ExprResult E = Owned(DependentScopeDeclRefExpr::Create(Context,
2712                                                 SS.getWithLocInContext(Context),
2713                                                     NameInfo));
2714
2715         // If we parsed the template argument as a pack expansion, create a
2716         // pack expansion expression.
2717         if (Arg.getArgument().getKind() == TemplateArgument::TemplateExpansion){
2718           E = ActOnPackExpansion(E.take(), Arg.getTemplateEllipsisLoc());
2719           if (E.isInvalid())
2720             return true;
2721         }
2722
2723         TemplateArgument Result;
2724         E = CheckTemplateArgument(NTTP, NTTPType, E.take(), Result);
2725         if (E.isInvalid())
2726           return true;
2727
2728         Converted.push_back(Result);
2729         break;
2730       }
2731
2732       // We have a template argument that actually does refer to a class
2733       // template, alias template, or template template parameter, and
2734       // therefore cannot be a non-type template argument.
2735       Diag(Arg.getLocation(), diag::err_template_arg_must_be_expr)
2736         << Arg.getSourceRange();
2737
2738       Diag(Param->getLocation(), diag::note_template_param_here);
2739       return true;
2740
2741     case TemplateArgument::Type: {
2742       // We have a non-type template parameter but the template
2743       // argument is a type.
2744
2745       // C++ [temp.arg]p2:
2746       //   In a template-argument, an ambiguity between a type-id and
2747       //   an expression is resolved to a type-id, regardless of the
2748       //   form of the corresponding template-parameter.
2749       //
2750       // We warn specifically about this case, since it can be rather
2751       // confusing for users.
2752       QualType T = Arg.getArgument().getAsType();
2753       SourceRange SR = Arg.getSourceRange();
2754       if (T->isFunctionType())
2755         Diag(SR.getBegin(), diag::err_template_arg_nontype_ambig) << SR << T;
2756       else
2757         Diag(SR.getBegin(), diag::err_template_arg_must_be_expr) << SR;
2758       Diag(Param->getLocation(), diag::note_template_param_here);
2759       return true;
2760     }
2761
2762     case TemplateArgument::Pack:
2763       llvm_unreachable("Caller must expand template argument packs");
2764       break;
2765     }
2766
2767     return false;
2768   }
2769
2770
2771   // Check template template parameters.
2772   TemplateTemplateParmDecl *TempParm = cast<TemplateTemplateParmDecl>(Param);
2773
2774   // Substitute into the template parameter list of the template
2775   // template parameter, since previously-supplied template arguments
2776   // may appear within the template template parameter.
2777   {
2778     // Set up a template instantiation context.
2779     LocalInstantiationScope Scope(*this);
2780     InstantiatingTemplate Inst(*this, TemplateLoc, Template,
2781                                TempParm, Converted.data(), Converted.size(),
2782                                SourceRange(TemplateLoc, RAngleLoc));
2783
2784     TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
2785                                       Converted.data(), Converted.size());
2786     TempParm = cast_or_null<TemplateTemplateParmDecl>(
2787                       SubstDecl(TempParm, CurContext,
2788                                 MultiLevelTemplateArgumentList(TemplateArgs)));
2789     if (!TempParm)
2790       return true;
2791   }
2792
2793   switch (Arg.getArgument().getKind()) {
2794   case TemplateArgument::Null:
2795     assert(false && "Should never see a NULL template argument here");
2796     return true;
2797
2798   case TemplateArgument::Template:
2799   case TemplateArgument::TemplateExpansion:
2800     if (CheckTemplateArgument(TempParm, Arg))
2801       return true;
2802
2803     Converted.push_back(Arg.getArgument());
2804     break;
2805
2806   case TemplateArgument::Expression:
2807   case TemplateArgument::Type:
2808     // We have a template template parameter but the template
2809     // argument does not refer to a template.
2810     Diag(Arg.getLocation(), diag::err_template_arg_must_be_template)
2811       << getLangOptions().CPlusPlus0x;
2812     return true;
2813
2814   case TemplateArgument::Declaration:
2815     llvm_unreachable(
2816                        "Declaration argument with template template parameter");
2817     break;
2818   case TemplateArgument::Integral:
2819     llvm_unreachable(
2820                           "Integral argument with template template parameter");
2821     break;
2822
2823   case TemplateArgument::Pack:
2824     llvm_unreachable("Caller must expand template argument packs");
2825     break;
2826   }
2827
2828   return false;
2829 }
2830
2831 /// \brief Check that the given template argument list is well-formed
2832 /// for specializing the given template.
2833 bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
2834                                      SourceLocation TemplateLoc,
2835                                      TemplateArgumentListInfo &TemplateArgs,
2836                                      bool PartialTemplateArgs,
2837                           llvm::SmallVectorImpl<TemplateArgument> &Converted) {
2838   TemplateParameterList *Params = Template->getTemplateParameters();
2839   unsigned NumParams = Params->size();
2840   unsigned NumArgs = TemplateArgs.size();
2841   bool Invalid = false;
2842
2843   SourceLocation RAngleLoc = TemplateArgs.getRAngleLoc();
2844
2845   bool HasParameterPack =
2846     NumParams > 0 && Params->getParam(NumParams - 1)->isTemplateParameterPack();
2847
2848   if ((NumArgs > NumParams && !HasParameterPack) ||
2849       (NumArgs < Params->getMinRequiredArguments() &&
2850        !PartialTemplateArgs)) {
2851     // FIXME: point at either the first arg beyond what we can handle,
2852     // or the '>', depending on whether we have too many or too few
2853     // arguments.
2854     SourceRange Range;
2855     if (NumArgs > NumParams)
2856       Range = SourceRange(TemplateArgs[NumParams].getLocation(), RAngleLoc);
2857     Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
2858       << (NumArgs > NumParams)
2859       << (isa<ClassTemplateDecl>(Template)? 0 :
2860           isa<FunctionTemplateDecl>(Template)? 1 :
2861           isa<TemplateTemplateParmDecl>(Template)? 2 : 3)
2862       << Template << Range;
2863     Diag(Template->getLocation(), diag::note_template_decl_here)
2864       << Params->getSourceRange();
2865     Invalid = true;
2866   }
2867
2868   // C++ [temp.arg]p1:
2869   //   [...] The type and form of each template-argument specified in
2870   //   a template-id shall match the type and form specified for the
2871   //   corresponding parameter declared by the template in its
2872   //   template-parameter-list.
2873   bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);
2874   llvm::SmallVector<TemplateArgument, 2> ArgumentPack;
2875   TemplateParameterList::iterator Param = Params->begin(),
2876                                ParamEnd = Params->end();
2877   unsigned ArgIdx = 0;
2878   LocalInstantiationScope InstScope(*this, true);
2879   while (Param != ParamEnd) {
2880     if (ArgIdx < NumArgs) {
2881       // If we have an expanded parameter pack, make sure we don't have too
2882       // many arguments.
2883       if (NonTypeTemplateParmDecl *NTTP
2884                                 = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
2885         if (NTTP->isExpandedParameterPack() &&
2886             ArgumentPack.size() >= NTTP->getNumExpansionTypes()) {
2887           Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
2888             << true
2889             << (isa<ClassTemplateDecl>(Template)? 0 :
2890                 isa<FunctionTemplateDecl>(Template)? 1 :
2891                 isa<TemplateTemplateParmDecl>(Template)? 2 : 3)
2892             << Template;
2893           Diag(Template->getLocation(), diag::note_template_decl_here)
2894             << Params->getSourceRange();
2895           return true;
2896         }
2897       }
2898
2899       // Check the template argument we were given.
2900       if (CheckTemplateArgument(*Param, TemplateArgs[ArgIdx], Template,
2901                                 TemplateLoc, RAngleLoc,
2902                                 ArgumentPack.size(), Converted))
2903         return true;
2904
2905       if ((*Param)->isTemplateParameterPack()) {
2906         // The template parameter was a template parameter pack, so take the
2907         // deduced argument and place it on the argument pack. Note that we
2908         // stay on the same template parameter so that we can deduce more
2909         // arguments.
2910         ArgumentPack.push_back(Converted.back());
2911         Converted.pop_back();
2912       } else {
2913         // Move to the next template parameter.
2914         ++Param;
2915       }
2916       ++ArgIdx;
2917       continue;
2918     }
2919
2920     // If we're checking a partial template argument list, we're done.
2921     if (PartialTemplateArgs) {
2922       if ((*Param)->isTemplateParameterPack() && !ArgumentPack.empty())
2923         Converted.push_back(TemplateArgument::CreatePackCopy(Context,
2924                                                          ArgumentPack.data(),
2925                                                          ArgumentPack.size()));
2926
2927       return Invalid;
2928     }
2929
2930     // If we have a template parameter pack with no more corresponding
2931     // arguments, just break out now and we'll fill in the argument pack below.
2932     if ((*Param)->isTemplateParameterPack())
2933       break;
2934
2935     // We have a default template argument that we will use.
2936     TemplateArgumentLoc Arg;
2937
2938     // Retrieve the default template argument from the template
2939     // parameter. For each kind of template parameter, we substitute the
2940     // template arguments provided thus far and any "outer" template arguments
2941     // (when the template parameter was part of a nested template) into
2942     // the default argument.
2943     if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
2944       if (!TTP->hasDefaultArgument()) {
2945         assert(Invalid && "Missing default argument");
2946         break;
2947       }
2948
2949       TypeSourceInfo *ArgType = SubstDefaultTemplateArgument(*this,
2950                                                              Template,
2951                                                              TemplateLoc,
2952                                                              RAngleLoc,
2953                                                              TTP,
2954                                                              Converted);
2955       if (!ArgType)
2956         return true;
2957
2958       Arg = TemplateArgumentLoc(TemplateArgument(ArgType->getType()),
2959                                 ArgType);
2960     } else if (NonTypeTemplateParmDecl *NTTP
2961                  = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
2962       if (!NTTP->hasDefaultArgument()) {
2963         assert(Invalid && "Missing default argument");
2964         break;
2965       }
2966
2967       ExprResult E = SubstDefaultTemplateArgument(*this, Template,
2968                                                               TemplateLoc,
2969                                                               RAngleLoc,
2970                                                               NTTP,
2971                                                               Converted);
2972       if (E.isInvalid())
2973         return true;
2974
2975       Expr *Ex = E.takeAs<Expr>();
2976       Arg = TemplateArgumentLoc(TemplateArgument(Ex), Ex);
2977     } else {
2978       TemplateTemplateParmDecl *TempParm
2979         = cast<TemplateTemplateParmDecl>(*Param);
2980
2981       if (!TempParm->hasDefaultArgument()) {
2982         assert(Invalid && "Missing default argument");
2983         break;
2984       }
2985
2986       NestedNameSpecifierLoc QualifierLoc;
2987       TemplateName Name = SubstDefaultTemplateArgument(*this, Template,
2988                                                        TemplateLoc,
2989                                                        RAngleLoc,
2990                                                        TempParm,
2991                                                        Converted,
2992                                                        QualifierLoc);
2993       if (Name.isNull())
2994         return true;
2995
2996       Arg = TemplateArgumentLoc(TemplateArgument(Name), QualifierLoc,
2997                            TempParm->getDefaultArgument().getTemplateNameLoc());
2998     }
2999
3000     // Introduce an instantiation record that describes where we are using
3001     // the default template argument.
3002     InstantiatingTemplate Instantiating(*this, RAngleLoc, Template, *Param,
3003                                         Converted.data(), Converted.size(),
3004                                         SourceRange(TemplateLoc, RAngleLoc));
3005
3006     // Check the default template argument.
3007     if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc,
3008                               RAngleLoc, 0, Converted))
3009       return true;
3010
3011     // Core issue 150 (assumed resolution): if this is a template template
3012     // parameter, keep track of the default template arguments from the
3013     // template definition.
3014     if (isTemplateTemplateParameter)
3015       TemplateArgs.addArgument(Arg);
3016
3017     // Move to the next template parameter and argument.
3018     ++Param;
3019     ++ArgIdx;
3020   }
3021
3022   // Form argument packs for each of the parameter packs remaining.
3023   while (Param != ParamEnd) {
3024     // If we're checking a partial list of template arguments, don't fill
3025     // in arguments for non-template parameter packs.
3026
3027     if ((*Param)->isTemplateParameterPack()) {
3028       if (ArgumentPack.empty())
3029         Converted.push_back(TemplateArgument(0, 0));
3030       else {
3031         Converted.push_back(TemplateArgument::CreatePackCopy(Context,
3032                                                           ArgumentPack.data(),
3033                                                          ArgumentPack.size()));
3034         ArgumentPack.clear();
3035       }
3036     }
3037
3038     ++Param;
3039   }
3040
3041   return Invalid;
3042 }
3043
3044 namespace {
3045   class UnnamedLocalNoLinkageFinder
3046     : public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
3047   {
3048     Sema &S;
3049     SourceRange SR;
3050
3051     typedef TypeVisitor<UnnamedLocalNoLinkageFinder, bool> inherited;
3052
3053   public:
3054     UnnamedLocalNoLinkageFinder(Sema &S, SourceRange SR) : S(S), SR(SR) { }
3055
3056     bool Visit(QualType T) {
3057       return inherited::Visit(T.getTypePtr());
3058     }
3059
3060 #define TYPE(Class, Parent) \
3061     bool Visit##Class##Type(const Class##Type *);
3062 #define ABSTRACT_TYPE(Class, Parent) \
3063     bool Visit##Class##Type(const Class##Type *) { return false; }
3064 #define NON_CANONICAL_TYPE(Class, Parent) \
3065     bool Visit##Class##Type(const Class##Type *) { return false; }
3066 #include "clang/AST/TypeNodes.def"
3067
3068     bool VisitTagDecl(const TagDecl *Tag);
3069     bool VisitNestedNameSpecifier(NestedNameSpecifier *NNS);
3070   };
3071 }
3072
3073 bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(const BuiltinType*) {
3074   return false;
3075 }
3076
3077 bool UnnamedLocalNoLinkageFinder::VisitComplexType(const ComplexType* T) {
3078   return Visit(T->getElementType());
3079 }
3080
3081 bool UnnamedLocalNoLinkageFinder::VisitPointerType(const PointerType* T) {
3082   return Visit(T->getPointeeType());
3083 }
3084
3085 bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
3086                                                     const BlockPointerType* T) {
3087   return Visit(T->getPointeeType());
3088 }
3089
3090 bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
3091                                                 const LValueReferenceType* T) {
3092   return Visit(T->getPointeeType());
3093 }
3094
3095 bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
3096                                                 const RValueReferenceType* T) {
3097   return Visit(T->getPointeeType());
3098 }
3099
3100 bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
3101                                                   const MemberPointerType* T) {
3102   return Visit(T->getPointeeType()) || Visit(QualType(T->getClass(), 0));
3103 }
3104
3105 bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
3106                                                   const ConstantArrayType* T) {
3107   return Visit(T->getElementType());
3108 }
3109
3110 bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
3111                                                  const IncompleteArrayType* T) {
3112   return Visit(T->getElementType());
3113 }
3114
3115 bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
3116                                                    const VariableArrayType* T) {
3117   return Visit(T->getElementType());
3118 }
3119
3120 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
3121                                             const DependentSizedArrayType* T) {
3122   return Visit(T->getElementType());
3123 }
3124
3125 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
3126                                          const DependentSizedExtVectorType* T) {
3127   return Visit(T->getElementType());
3128 }
3129
3130 bool UnnamedLocalNoLinkageFinder::VisitVectorType(const VectorType* T) {
3131   return Visit(T->getElementType());
3132 }
3133
3134 bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(const ExtVectorType* T) {
3135   return Visit(T->getElementType());
3136 }
3137
3138 bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
3139                                                   const FunctionProtoType* T) {
3140   for (FunctionProtoType::arg_type_iterator A = T->arg_type_begin(),
3141                                          AEnd = T->arg_type_end();
3142        A != AEnd; ++A) {
3143     if (Visit(*A))
3144       return true;
3145   }
3146
3147   return Visit(T->getResultType());
3148 }
3149
3150 bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
3151                                                const FunctionNoProtoType* T) {
3152   return Visit(T->getResultType());
3153 }
3154
3155 bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
3156                                                   const UnresolvedUsingType*) {
3157   return false;
3158 }
3159
3160 bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(const TypeOfExprType*) {
3161   return false;
3162 }
3163
3164 bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(const TypeOfType* T) {
3165   return Visit(T->getUnderlyingType());
3166 }
3167
3168 bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(const DecltypeType*) {
3169   return false;
3170 }
3171
3172 bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
3173                                                     const UnaryTransformType*) {
3174   return false;
3175 }
3176
3177 bool UnnamedLocalNoLinkageFinder::VisitAutoType(const AutoType *T) {
3178   return Visit(T->getDeducedType());
3179 }
3180
3181 bool UnnamedLocalNoLinkageFinder::VisitRecordType(const RecordType* T) {
3182   return VisitTagDecl(T->getDecl());
3183 }
3184
3185 bool UnnamedLocalNoLinkageFinder::VisitEnumType(const EnumType* T) {
3186   return VisitTagDecl(T->getDecl());
3187 }
3188
3189 bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
3190                                                  const TemplateTypeParmType*) {
3191   return false;
3192 }
3193
3194 bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
3195                                         const SubstTemplateTypeParmPackType *) {
3196   return false;
3197 }
3198
3199 bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
3200                                             const TemplateSpecializationType*) {
3201   return false;
3202 }
3203
3204 bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
3205                                               const InjectedClassNameType* T) {
3206   return VisitTagDecl(T->getDecl());
3207 }
3208
3209 bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
3210                                                    const DependentNameType* T) {
3211   return VisitNestedNameSpecifier(T->getQualifier());
3212 }
3213
3214 bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
3215                                  const DependentTemplateSpecializationType* T) {
3216   return VisitNestedNameSpecifier(T->getQualifier());
3217 }
3218
3219 bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
3220                                                    const PackExpansionType* T) {
3221   return Visit(T->getPattern());
3222 }
3223
3224 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(const ObjCObjectType *) {
3225   return false;
3226 }
3227
3228 bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
3229                                                    const ObjCInterfaceType *) {
3230   return false;
3231 }
3232
3233 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
3234                                                 const ObjCObjectPointerType *) {
3235   return false;
3236 }
3237
3238 bool UnnamedLocalNoLinkageFinder::VisitTagDecl(const TagDecl *Tag) {
3239   if (Tag->getDeclContext()->isFunctionOrMethod()) {
3240     S.Diag(SR.getBegin(), diag::ext_template_arg_local_type)
3241       << S.Context.getTypeDeclType(Tag) << SR;
3242     return true;
3243   }
3244
3245   if (!Tag->getDeclName() && !Tag->getTypedefNameForAnonDecl()) {
3246     S.Diag(SR.getBegin(), diag::ext_template_arg_unnamed_type) << SR;
3247     S.Diag(Tag->getLocation(), diag::note_template_unnamed_type_here);
3248     return true;
3249   }
3250
3251   return false;
3252 }
3253
3254 bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
3255                                                     NestedNameSpecifier *NNS) {
3256   if (NNS->getPrefix() && VisitNestedNameSpecifier(NNS->getPrefix()))
3257     return true;
3258
3259   switch (NNS->getKind()) {
3260   case NestedNameSpecifier::Identifier:
3261   case NestedNameSpecifier::Namespace:
3262   case NestedNameSpecifier::NamespaceAlias:
3263   case NestedNameSpecifier::Global:
3264     return false;
3265
3266   case NestedNameSpecifier::TypeSpec:
3267   case NestedNameSpecifier::TypeSpecWithTemplate:
3268     return Visit(QualType(NNS->getAsType(), 0));
3269   }
3270   return false;
3271 }
3272
3273
3274 /// \brief Check a template argument against its corresponding
3275 /// template type parameter.
3276 ///
3277 /// This routine implements the semantics of C++ [temp.arg.type]. It
3278 /// returns true if an error occurred, and false otherwise.
3279 bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param,
3280                                  TypeSourceInfo *ArgInfo) {
3281   assert(ArgInfo && "invalid TypeSourceInfo");
3282   QualType Arg = ArgInfo->getType();
3283   SourceRange SR = ArgInfo->getTypeLoc().getSourceRange();
3284
3285   if (Arg->isVariablyModifiedType()) {
3286     return Diag(SR.getBegin(), diag::err_variably_modified_template_arg) << Arg;
3287   } else if (Context.hasSameUnqualifiedType(Arg, Context.OverloadTy)) {
3288     return Diag(SR.getBegin(), diag::err_template_arg_overload_type) << SR;
3289   }
3290
3291   // C++03 [temp.arg.type]p2:
3292   //   A local type, a type with no linkage, an unnamed type or a type
3293   //   compounded from any of these types shall not be used as a
3294   //   template-argument for a template type-parameter.
3295   //
3296   // C++0x allows these, and even in C++03 we allow them as an extension with
3297   // a warning.
3298   if (!LangOpts.CPlusPlus0x && Arg->hasUnnamedOrLocalType()) {
3299     UnnamedLocalNoLinkageFinder Finder(*this, SR);
3300     (void)Finder.Visit(Context.getCanonicalType(Arg));
3301   }
3302
3303   return false;
3304 }
3305
3306 /// \brief Checks whether the given template argument is the address
3307 /// of an object or function according to C++ [temp.arg.nontype]p1.
3308 static bool
3309 CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S,
3310                                                NonTypeTemplateParmDecl *Param,
3311                                                QualType ParamType,
3312                                                Expr *ArgIn,
3313                                                TemplateArgument &Converted) {
3314   bool Invalid = false;
3315   Expr *Arg = ArgIn;
3316   QualType ArgType = Arg->getType();
3317
3318   // See through any implicit casts we added to fix the type.
3319   Arg = Arg->IgnoreImpCasts();
3320
3321   // C++ [temp.arg.nontype]p1:
3322   //
3323   //   A template-argument for a non-type, non-template
3324   //   template-parameter shall be one of: [...]
3325   //
3326   //     -- the address of an object or function with external
3327   //        linkage, including function templates and function
3328   //        template-ids but excluding non-static class members,
3329   //        expressed as & id-expression where the & is optional if
3330   //        the name refers to a function or array, or if the
3331   //        corresponding template-parameter is a reference; or
3332
3333   // In C++98/03 mode, give an extension warning on any extra parentheses.
3334   // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
3335   bool ExtraParens = false;
3336   while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
3337     if (!Invalid && !ExtraParens && !S.getLangOptions().CPlusPlus0x) {
3338       S.Diag(Arg->getSourceRange().getBegin(),
3339              diag::ext_template_arg_extra_parens)
3340         << Arg->getSourceRange();
3341       ExtraParens = true;
3342     }
3343
3344     Arg = Parens->getSubExpr();
3345   }
3346
3347   while (SubstNonTypeTemplateParmExpr *subst =
3348            dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
3349     Arg = subst->getReplacement()->IgnoreImpCasts();
3350
3351   bool AddressTaken = false;
3352   SourceLocation AddrOpLoc;
3353   if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
3354     if (UnOp->getOpcode() == UO_AddrOf) {
3355       Arg = UnOp->getSubExpr();
3356       AddressTaken = true;
3357       AddrOpLoc = UnOp->getOperatorLoc();
3358     }
3359   }
3360
3361   if (S.getLangOptions().Microsoft && isa<CXXUuidofExpr>(Arg)) {
3362     Converted = TemplateArgument(ArgIn);
3363     return false;
3364   }
3365
3366   while (SubstNonTypeTemplateParmExpr *subst =
3367            dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
3368     Arg = subst->getReplacement()->IgnoreImpCasts();
3369
3370   DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg);
3371   if (!DRE) {
3372     S.Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
3373       << Arg->getSourceRange();
3374     S.Diag(Param->getLocation(), diag::note_template_param_here);
3375     return true;
3376   }
3377
3378   // Stop checking the precise nature of the argument if it is value dependent,
3379   // it should be checked when instantiated.
3380   if (Arg->isValueDependent()) {
3381     Converted = TemplateArgument(ArgIn);
3382     return false;
3383   }
3384
3385   if (!isa<ValueDecl>(DRE->getDecl())) {
3386     S.Diag(Arg->getSourceRange().getBegin(),
3387            diag::err_template_arg_not_object_or_func_form)
3388       << Arg->getSourceRange();
3389     S.Diag(Param->getLocation(), diag::note_template_param_here);
3390     return true;
3391   }
3392
3393   NamedDecl *Entity = 0;
3394
3395   // Cannot refer to non-static data members
3396   if (FieldDecl *Field = dyn_cast<FieldDecl>(DRE->getDecl())) {
3397     S.Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_field)
3398       << Field << Arg->getSourceRange();
3399     S.Diag(Param->getLocation(), diag::note_template_param_here);
3400     return true;
3401   }
3402
3403   // Cannot refer to non-static member functions
3404   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(DRE->getDecl()))
3405     if (!Method->isStatic()) {
3406       S.Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_method)
3407         << Method << Arg->getSourceRange();
3408       S.Diag(Param->getLocation(), diag::note_template_param_here);
3409       return true;
3410     }
3411
3412   // Functions must have external linkage.
3413   if (FunctionDecl *Func = dyn_cast<FunctionDecl>(DRE->getDecl())) {
3414     if (!isExternalLinkage(Func->getLinkage())) {
3415       S.Diag(Arg->getSourceRange().getBegin(),
3416              diag::err_template_arg_function_not_extern)
3417         << Func << Arg->getSourceRange();
3418       S.Diag(Func->getLocation(), diag::note_template_arg_internal_object)
3419         << true;
3420       return true;
3421     }
3422
3423     // Okay: we've named a function with external linkage.
3424     Entity = Func;
3425
3426     // If the template parameter has pointer type, the function decays.
3427     if (ParamType->isPointerType() && !AddressTaken)
3428       ArgType = S.Context.getPointerType(Func->getType());
3429     else if (AddressTaken && ParamType->isReferenceType()) {
3430       // If we originally had an address-of operator, but the
3431       // parameter has reference type, complain and (if things look
3432       // like they will work) drop the address-of operator.
3433       if (!S.Context.hasSameUnqualifiedType(Func->getType(),
3434                                             ParamType.getNonReferenceType())) {
3435         S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
3436           << ParamType;
3437         S.Diag(Param->getLocation(), diag::note_template_param_here);
3438         return true;
3439       }
3440
3441       S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
3442         << ParamType
3443         << FixItHint::CreateRemoval(AddrOpLoc);
3444       S.Diag(Param->getLocation(), diag::note_template_param_here);
3445
3446       ArgType = Func->getType();
3447     }
3448   } else if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
3449     if (!isExternalLinkage(Var->getLinkage())) {
3450       S.Diag(Arg->getSourceRange().getBegin(),
3451              diag::err_template_arg_object_not_extern)
3452         << Var << Arg->getSourceRange();
3453       S.Diag(Var->getLocation(), diag::note_template_arg_internal_object)
3454         << true;
3455       return true;
3456     }
3457
3458     // A value of reference type is not an object.
3459     if (Var->getType()->isReferenceType()) {
3460       S.Diag(Arg->getSourceRange().getBegin(),
3461              diag::err_template_arg_reference_var)
3462         << Var->getType() << Arg->getSourceRange();
3463       S.Diag(Param->getLocation(), diag::note_template_param_here);
3464       return true;
3465     }
3466
3467     // Okay: we've named an object with external linkage
3468     Entity = Var;
3469
3470     // If the template parameter has pointer type, we must have taken
3471     // the address of this object.
3472     if (ParamType->isReferenceType()) {
3473       if (AddressTaken) {
3474         // If we originally had an address-of operator, but the
3475         // parameter has reference type, complain and (if things look
3476         // like they will work) drop the address-of operator.
3477         if (!S.Context.hasSameUnqualifiedType(Var->getType(),
3478                                             ParamType.getNonReferenceType())) {
3479           S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
3480             << ParamType;
3481           S.Diag(Param->getLocation(), diag::note_template_param_here);
3482           return true;
3483         }
3484
3485         S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
3486           << ParamType
3487           << FixItHint::CreateRemoval(AddrOpLoc);
3488         S.Diag(Param->getLocation(), diag::note_template_param_here);
3489
3490         ArgType = Var->getType();
3491       }
3492     } else if (!AddressTaken && ParamType->isPointerType()) {
3493       if (Var->getType()->isArrayType()) {
3494         // Array-to-pointer decay.
3495         ArgType = S.Context.getArrayDecayedType(Var->getType());
3496       } else {
3497         // If the template parameter has pointer type but the address of
3498         // this object was not taken, complain and (possibly) recover by
3499         // taking the address of the entity.
3500         ArgType = S.Context.getPointerType(Var->getType());
3501         if (!S.Context.hasSameUnqualifiedType(ArgType, ParamType)) {
3502           S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of)
3503             << ParamType;
3504           S.Diag(Param->getLocation(), diag::note_template_param_here);
3505           return true;
3506         }
3507
3508         S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of)
3509           << ParamType
3510           << FixItHint::CreateInsertion(Arg->getLocStart(), "&");
3511
3512         S.Diag(Param->getLocation(), diag::note_template_param_here);
3513       }
3514     }
3515   } else {
3516     // We found something else, but we don't know specifically what it is.
3517     S.Diag(Arg->getSourceRange().getBegin(),
3518            diag::err_template_arg_not_object_or_func)
3519       << Arg->getSourceRange();
3520     S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
3521     return true;
3522   }
3523
3524   bool ObjCLifetimeConversion;
3525   if (ParamType->isPointerType() &&
3526       !ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType() &&
3527       S.IsQualificationConversion(ArgType, ParamType, false,
3528                                   ObjCLifetimeConversion)) {
3529     // For pointer-to-object types, qualification conversions are
3530     // permitted.
3531   } else {
3532     if (const ReferenceType *ParamRef = ParamType->getAs<ReferenceType>()) {
3533       if (!ParamRef->getPointeeType()->isFunctionType()) {
3534         // C++ [temp.arg.nontype]p5b3:
3535         //   For a non-type template-parameter of type reference to
3536         //   object, no conversions apply. The type referred to by the
3537         //   reference may be more cv-qualified than the (otherwise
3538         //   identical) type of the template- argument. The
3539         //   template-parameter is bound directly to the
3540         //   template-argument, which shall be an lvalue.
3541
3542         // FIXME: Other qualifiers?
3543         unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();
3544         unsigned ArgQuals = ArgType.getCVRQualifiers();
3545
3546         if ((ParamQuals | ArgQuals) != ParamQuals) {
3547           S.Diag(Arg->getSourceRange().getBegin(),
3548                  diag::err_template_arg_ref_bind_ignores_quals)
3549             << ParamType << Arg->getType()
3550             << Arg->getSourceRange();
3551           S.Diag(Param->getLocation(), diag::note_template_param_here);
3552           return true;
3553         }
3554       }
3555     }
3556
3557     // At this point, the template argument refers to an object or
3558     // function with external linkage. We now need to check whether the
3559     // argument and parameter types are compatible.
3560     if (!S.Context.hasSameUnqualifiedType(ArgType,
3561                                           ParamType.getNonReferenceType())) {
3562       // We can't perform this conversion or binding.
3563       if (ParamType->isReferenceType())
3564         S.Diag(Arg->getLocStart(), diag::err_template_arg_no_ref_bind)
3565           << ParamType << ArgIn->getType() << Arg->getSourceRange();
3566       else
3567         S.Diag(Arg->getLocStart(),  diag::err_template_arg_not_convertible)
3568           << ArgIn->getType() << ParamType << Arg->getSourceRange();
3569       S.Diag(Param->getLocation(), diag::note_template_param_here);
3570       return true;
3571     }
3572   }
3573
3574   // Create the template argument.
3575   Converted = TemplateArgument(Entity->getCanonicalDecl());
3576   S.MarkDeclarationReferenced(Arg->getLocStart(), Entity);
3577   return false;
3578 }
3579
3580 /// \brief Checks whether the given template argument is a pointer to
3581 /// member constant according to C++ [temp.arg.nontype]p1.
3582 bool Sema::CheckTemplateArgumentPointerToMember(Expr *Arg,
3583                                                 TemplateArgument &Converted) {
3584   bool Invalid = false;
3585
3586   // See through any implicit casts we added to fix the type.
3587   while (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(Arg))
3588     Arg = Cast->getSubExpr();
3589
3590   // C++ [temp.arg.nontype]p1:
3591   //
3592   //   A template-argument for a non-type, non-template
3593   //   template-parameter shall be one of: [...]
3594   //
3595   //     -- a pointer to member expressed as described in 5.3.1.
3596   DeclRefExpr *DRE = 0;
3597
3598   // In C++98/03 mode, give an extension warning on any extra parentheses.
3599   // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
3600   bool ExtraParens = false;
3601   while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
3602     if (!Invalid && !ExtraParens && !getLangOptions().CPlusPlus0x) {
3603       Diag(Arg->getSourceRange().getBegin(),
3604            diag::ext_template_arg_extra_parens)
3605         << Arg->getSourceRange();
3606       ExtraParens = true;
3607     }
3608
3609     Arg = Parens->getSubExpr();
3610   }
3611
3612   while (SubstNonTypeTemplateParmExpr *subst =
3613            dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
3614     Arg = subst->getReplacement()->IgnoreImpCasts();
3615
3616   // A pointer-to-member constant written &Class::member.
3617   if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
3618     if (UnOp->getOpcode() == UO_AddrOf) {
3619       DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr());
3620       if (DRE && !DRE->getQualifier())
3621         DRE = 0;
3622     }
3623   }
3624   // A constant of pointer-to-member type.
3625   else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) {
3626     if (ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl())) {
3627       if (VD->getType()->isMemberPointerType()) {
3628         if (isa<NonTypeTemplateParmDecl>(VD) ||
3629             (isa<VarDecl>(VD) &&
3630              Context.getCanonicalType(VD->getType()).isConstQualified())) {
3631           if (Arg->isTypeDependent() || Arg->isValueDependent())
3632             Converted = TemplateArgument(Arg);
3633           else
3634             Converted = TemplateArgument(VD->getCanonicalDecl());
3635           return Invalid;
3636         }
3637       }
3638     }
3639
3640     DRE = 0;
3641   }
3642
3643   if (!DRE)
3644     return Diag(Arg->getSourceRange().getBegin(),
3645                 diag::err_template_arg_not_pointer_to_member_form)
3646       << Arg->getSourceRange();
3647
3648   if (isa<FieldDecl>(DRE->getDecl()) || isa<CXXMethodDecl>(DRE->getDecl())) {
3649     assert((isa<FieldDecl>(DRE->getDecl()) ||
3650             !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&
3651            "Only non-static member pointers can make it here");
3652
3653     // Okay: this is the address of a non-static member, and therefore
3654     // a member pointer constant.
3655     if (Arg->isTypeDependent() || Arg->isValueDependent())
3656       Converted = TemplateArgument(Arg);
3657     else
3658       Converted = TemplateArgument(DRE->getDecl()->getCanonicalDecl());
3659     return Invalid;
3660   }
3661
3662   // We found something else, but we don't know specifically what it is.
3663   Diag(Arg->getSourceRange().getBegin(),
3664        diag::err_template_arg_not_pointer_to_member_form)
3665       << Arg->getSourceRange();
3666   Diag(DRE->getDecl()->getLocation(),
3667        diag::note_template_arg_refers_here);
3668   return true;
3669 }
3670
3671 /// \brief Check a template argument against its corresponding
3672 /// non-type template parameter.
3673 ///
3674 /// This routine implements the semantics of C++ [temp.arg.nontype].
3675 /// If an error occurred, it returns ExprError(); otherwise, it
3676 /// returns the converted template argument. \p
3677 /// InstantiatedParamType is the type of the non-type template
3678 /// parameter after it has been instantiated.
3679 ExprResult Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
3680                                        QualType InstantiatedParamType, Expr *Arg,
3681                                        TemplateArgument &Converted,
3682                                        CheckTemplateArgumentKind CTAK) {
3683   SourceLocation StartLoc = Arg->getSourceRange().getBegin();
3684
3685   // If either the parameter has a dependent type or the argument is
3686   // type-dependent, there's nothing we can check now.
3687   if (InstantiatedParamType->isDependentType() || Arg->isTypeDependent()) {
3688     // FIXME: Produce a cloned, canonical expression?
3689     Converted = TemplateArgument(Arg);
3690     return Owned(Arg);
3691   }
3692
3693   // C++ [temp.arg.nontype]p5:
3694   //   The following conversions are performed on each expression used
3695   //   as a non-type template-argument. If a non-type
3696   //   template-argument cannot be converted to the type of the
3697   //   corresponding template-parameter then the program is
3698   //   ill-formed.
3699   //
3700   //     -- for a non-type template-parameter of integral or
3701   //        enumeration type, integral promotions (4.5) and integral
3702   //        conversions (4.7) are applied.
3703   QualType ParamType = InstantiatedParamType;
3704   QualType ArgType = Arg->getType();
3705   if (ParamType->isIntegralOrEnumerationType()) {
3706     // C++ [temp.arg.nontype]p1:
3707     //   A template-argument for a non-type, non-template
3708     //   template-parameter shall be one of:
3709     //
3710     //     -- an integral constant-expression of integral or enumeration
3711     //        type; or
3712     //     -- the name of a non-type template-parameter; or
3713     SourceLocation NonConstantLoc;
3714     llvm::APSInt Value;
3715     if (!ArgType->isIntegralOrEnumerationType()) {
3716       Diag(Arg->getSourceRange().getBegin(),
3717            diag::err_template_arg_not_integral_or_enumeral)
3718         << ArgType << Arg->getSourceRange();
3719       Diag(Param->getLocation(), diag::note_template_param_here);
3720       return ExprError();
3721     } else if (!Arg->isValueDependent() &&
3722                !Arg->isIntegerConstantExpr(Value, Context, &NonConstantLoc)) {
3723       Diag(NonConstantLoc, diag::err_template_arg_not_ice)
3724         << ArgType << Arg->getSourceRange();
3725       return ExprError();
3726     }
3727
3728     // From here on out, all we care about are the unqualified forms
3729     // of the parameter and argument types.
3730     ParamType = ParamType.getUnqualifiedType();
3731     ArgType = ArgType.getUnqualifiedType();
3732
3733     // Try to convert the argument to the parameter's type.
3734     if (Context.hasSameType(ParamType, ArgType)) {
3735       // Okay: no conversion necessary
3736     } else if (CTAK == CTAK_Deduced) {
3737       // C++ [temp.deduct.type]p17:
3738       //   If, in the declaration of a function template with a non-type
3739       //   template-parameter, the non-type template- parameter is used
3740       //   in an expression in the function parameter-list and, if the
3741       //   corresponding template-argument is deduced, the
3742       //   template-argument type shall match the type of the
3743       //   template-parameter exactly, except that a template-argument
3744       //   deduced from an array bound may be of any integral type.
3745       Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)
3746         << ArgType << ParamType;
3747       Diag(Param->getLocation(), diag::note_template_param_here);
3748       return ExprError();
3749     } else if (ParamType->isBooleanType()) {
3750       // This is an integral-to-boolean conversion.
3751       Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralToBoolean).take();
3752     } else if (IsIntegralPromotion(Arg, ArgType, ParamType) ||
3753                !ParamType->isEnumeralType()) {
3754       // This is an integral promotion or conversion.
3755       Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralCast).take();
3756     } else {
3757       // We can't perform this conversion.
3758       Diag(Arg->getSourceRange().getBegin(),
3759            diag::err_template_arg_not_convertible)
3760         << Arg->getType() << InstantiatedParamType << Arg->getSourceRange();
3761       Diag(Param->getLocation(), diag::note_template_param_here);
3762       return ExprError();
3763     }
3764
3765     // Add the value of this argument to the list of converted
3766     // arguments. We use the bitwidth and signedness of the template
3767     // parameter.
3768     if (Arg->isValueDependent()) {
3769       // The argument is value-dependent. Create a new
3770       // TemplateArgument with the converted expression.
3771       Converted = TemplateArgument(Arg);
3772       return Owned(Arg);
3773     }
3774
3775     QualType IntegerType = Context.getCanonicalType(ParamType);
3776     if (const EnumType *Enum = IntegerType->getAs<EnumType>())
3777       IntegerType = Context.getCanonicalType(Enum->getDecl()->getIntegerType());
3778
3779     if (ParamType->isBooleanType()) {
3780       // Value must be zero or one.
3781       Value = Value != 0;
3782       unsigned AllowedBits = Context.getTypeSize(IntegerType);
3783       if (Value.getBitWidth() != AllowedBits)
3784         Value = Value.extOrTrunc(AllowedBits);
3785       Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
3786     } else {
3787       llvm::APSInt OldValue = Value;
3788
3789       // Coerce the template argument's value to the value it will have
3790       // based on the template parameter's type.
3791       unsigned AllowedBits = Context.getTypeSize(IntegerType);
3792       if (Value.getBitWidth() != AllowedBits)
3793         Value = Value.extOrTrunc(AllowedBits);
3794       Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
3795
3796       // Complain if an unsigned parameter received a negative value.
3797       if (IntegerType->isUnsignedIntegerOrEnumerationType()
3798                && (OldValue.isSigned() && OldValue.isNegative())) {
3799         Diag(Arg->getSourceRange().getBegin(), diag::warn_template_arg_negative)
3800           << OldValue.toString(10) << Value.toString(10) << Param->getType()
3801           << Arg->getSourceRange();
3802         Diag(Param->getLocation(), diag::note_template_param_here);
3803       }
3804
3805       // Complain if we overflowed the template parameter's type.
3806       unsigned RequiredBits;
3807       if (IntegerType->isUnsignedIntegerOrEnumerationType())
3808         RequiredBits = OldValue.getActiveBits();
3809       else if (OldValue.isUnsigned())
3810         RequiredBits = OldValue.getActiveBits() + 1;
3811       else
3812         RequiredBits = OldValue.getMinSignedBits();
3813       if (RequiredBits > AllowedBits) {
3814         Diag(Arg->getSourceRange().getBegin(),
3815              diag::warn_template_arg_too_large)
3816           << OldValue.toString(10) << Value.toString(10) << Param->getType()
3817           << Arg->getSourceRange();
3818         Diag(Param->getLocation(), diag::note_template_param_here);
3819       }
3820     }
3821
3822     Converted = TemplateArgument(Value,
3823                                  ParamType->isEnumeralType() ? ParamType
3824                                                              : IntegerType);
3825     return Owned(Arg);
3826   }
3827
3828   DeclAccessPair FoundResult; // temporary for ResolveOverloadedFunction
3829
3830   // C++0x [temp.arg.nontype]p5 bullets 2, 4 and 6 permit conversion
3831   // from a template argument of type std::nullptr_t to a non-type
3832   // template parameter of type pointer to object, pointer to
3833   // function, or pointer-to-member, respectively.
3834   if (ArgType->isNullPtrType()) {
3835     if (ParamType->isPointerType() || ParamType->isMemberPointerType()) {
3836       Converted = TemplateArgument((NamedDecl *)0);
3837       return Owned(Arg);
3838     }
3839
3840     if (ParamType->isNullPtrType()) {
3841       llvm::APSInt Zero(Context.getTypeSize(Context.NullPtrTy), true);
3842       Converted = TemplateArgument(Zero, Context.NullPtrTy);
3843       return Owned(Arg);
3844     }
3845   }
3846
3847   // Handle pointer-to-function, reference-to-function, and
3848   // pointer-to-member-function all in (roughly) the same way.
3849   if (// -- For a non-type template-parameter of type pointer to
3850       //    function, only the function-to-pointer conversion (4.3) is
3851       //    applied. If the template-argument represents a set of
3852       //    overloaded functions (or a pointer to such), the matching
3853       //    function is selected from the set (13.4).
3854       (ParamType->isPointerType() &&
3855        ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType()) ||
3856       // -- For a non-type template-parameter of type reference to
3857       //    function, no conversions apply. If the template-argument
3858       //    represents a set of overloaded functions, the matching
3859       //    function is selected from the set (13.4).
3860       (ParamType->isReferenceType() &&
3861        ParamType->getAs<ReferenceType>()->getPointeeType()->isFunctionType()) ||
3862       // -- For a non-type template-parameter of type pointer to
3863       //    member function, no conversions apply. If the
3864       //    template-argument represents a set of overloaded member
3865       //    functions, the matching member function is selected from
3866       //    the set (13.4).
3867       (ParamType->isMemberPointerType() &&
3868        ParamType->getAs<MemberPointerType>()->getPointeeType()
3869          ->isFunctionType())) {
3870
3871     if (Arg->getType() == Context.OverloadTy) {
3872       if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg, ParamType,
3873                                                                 true,
3874                                                                 FoundResult)) {
3875         if (DiagnoseUseOfDecl(Fn, Arg->getSourceRange().getBegin()))
3876           return ExprError();
3877
3878         Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
3879         ArgType = Arg->getType();
3880       } else
3881         return ExprError();
3882     }
3883
3884     if (!ParamType->isMemberPointerType()) {
3885       if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
3886                                                          ParamType,
3887                                                          Arg, Converted))
3888         return ExprError();
3889       return Owned(Arg);
3890     }
3891
3892     bool ObjCLifetimeConversion;
3893     if (IsQualificationConversion(ArgType, ParamType.getNonReferenceType(),
3894                                   false, ObjCLifetimeConversion)) {
3895       Arg = ImpCastExprToType(Arg, ParamType, CK_NoOp, CastCategory(Arg)).take();
3896     } else if (!Context.hasSameUnqualifiedType(ArgType,
3897                                            ParamType.getNonReferenceType())) {
3898       // We can't perform this conversion.
3899       Diag(Arg->getSourceRange().getBegin(),
3900            diag::err_template_arg_not_convertible)
3901         << Arg->getType() << InstantiatedParamType << Arg->getSourceRange();
3902       Diag(Param->getLocation(), diag::note_template_param_here);
3903       return ExprError();
3904     }
3905
3906     if (CheckTemplateArgumentPointerToMember(Arg, Converted))
3907       return ExprError();
3908     return Owned(Arg);
3909   }
3910
3911   if (ParamType->isPointerType()) {
3912     //   -- for a non-type template-parameter of type pointer to
3913     //      object, qualification conversions (4.4) and the
3914     //      array-to-pointer conversion (4.2) are applied.
3915     // C++0x also allows a value of std::nullptr_t.
3916     assert(ParamType->getPointeeType()->isIncompleteOrObjectType() &&
3917            "Only object pointers allowed here");
3918
3919     if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
3920                                                        ParamType,
3921                                                        Arg, Converted))
3922       return ExprError();
3923     return Owned(Arg);
3924   }
3925
3926   if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) {
3927     //   -- For a non-type template-parameter of type reference to
3928     //      object, no conversions apply. The type referred to by the
3929     //      reference may be more cv-qualified than the (otherwise
3930     //      identical) type of the template-argument. The
3931     //      template-parameter is bound directly to the
3932     //      template-argument, which must be an lvalue.
3933     assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&
3934            "Only object references allowed here");
3935
3936     if (Arg->getType() == Context.OverloadTy) {
3937       if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg,
3938                                                  ParamRefType->getPointeeType(),
3939                                                                 true,
3940                                                                 FoundResult)) {
3941         if (DiagnoseUseOfDecl(Fn, Arg->getSourceRange().getBegin()))
3942           return ExprError();
3943
3944         Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
3945         ArgType = Arg->getType();
3946       } else
3947         return ExprError();
3948     }
3949
3950     if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
3951                                                        ParamType,
3952                                                        Arg, Converted))
3953       return ExprError();
3954     return Owned(Arg);
3955   }
3956
3957   //     -- For a non-type template-parameter of type pointer to data
3958   //        member, qualification conversions (4.4) are applied.
3959   assert(ParamType->isMemberPointerType() && "Only pointers to members remain");
3960
3961   bool ObjCLifetimeConversion;
3962   if (Context.hasSameUnqualifiedType(ParamType, ArgType)) {
3963     // Types match exactly: nothing more to do here.
3964   } else if (IsQualificationConversion(ArgType, ParamType, false,
3965                                        ObjCLifetimeConversion)) {
3966     Arg = ImpCastExprToType(Arg, ParamType, CK_NoOp, CastCategory(Arg)).take();
3967   } else {
3968     // We can't perform this conversion.
3969     Diag(Arg->getSourceRange().getBegin(),
3970          diag::err_template_arg_not_convertible)
3971       << Arg->getType() << InstantiatedParamType << Arg->getSourceRange();
3972     Diag(Param->getLocation(), diag::note_template_param_here);
3973     return ExprError();
3974   }
3975
3976   if (CheckTemplateArgumentPointerToMember(Arg, Converted))
3977     return ExprError();
3978   return Owned(Arg);
3979 }
3980
3981 /// \brief Check a template argument against its corresponding
3982 /// template template parameter.
3983 ///
3984 /// This routine implements the semantics of C++ [temp.arg.template].
3985 /// It returns true if an error occurred, and false otherwise.
3986 bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param,
3987                                  const TemplateArgumentLoc &Arg) {
3988   TemplateName Name = Arg.getArgument().getAsTemplate();
3989   TemplateDecl *Template = Name.getAsTemplateDecl();
3990   if (!Template) {
3991     // Any dependent template name is fine.
3992     assert(Name.isDependent() && "Non-dependent template isn't a declaration?");
3993     return false;
3994   }
3995
3996   // C++0x [temp.arg.template]p1:
3997   //   A template-argument for a template template-parameter shall be
3998   //   the name of a class template or an alias template, expressed as an
3999   //   id-expression. When the template-argument names a class template, only
4000   //   primary class templates are considered when matching the
4001   //   template template argument with the corresponding parameter;
4002   //   partial specializations are not considered even if their
4003   //   parameter lists match that of the template template parameter.
4004   //
4005   // Note that we also allow template template parameters here, which
4006   // will happen when we are dealing with, e.g., class template
4007   // partial specializations.
4008   if (!isa<ClassTemplateDecl>(Template) &&
4009       !isa<TemplateTemplateParmDecl>(Template) &&
4010       !isa<TypeAliasTemplateDecl>(Template)) {
4011     assert(isa<FunctionTemplateDecl>(Template) &&
4012            "Only function templates are possible here");
4013     Diag(Arg.getLocation(), diag::err_template_arg_not_class_template);
4014     Diag(Template->getLocation(), diag::note_template_arg_refers_here_func)
4015       << Template;
4016   }
4017
4018   return !TemplateParameterListsAreEqual(Template->getTemplateParameters(),
4019                                          Param->getTemplateParameters(),
4020                                          true,
4021                                          TPL_TemplateTemplateArgumentMatch,
4022                                          Arg.getLocation());
4023 }
4024
4025 /// \brief Given a non-type template argument that refers to a
4026 /// declaration and the type of its corresponding non-type template
4027 /// parameter, produce an expression that properly refers to that
4028 /// declaration.
4029 ExprResult
4030 Sema::BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
4031                                               QualType ParamType,
4032                                               SourceLocation Loc) {
4033   assert(Arg.getKind() == TemplateArgument::Declaration &&
4034          "Only declaration template arguments permitted here");
4035   ValueDecl *VD = cast<ValueDecl>(Arg.getAsDecl());
4036
4037   if (VD->getDeclContext()->isRecord() &&
4038       (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD))) {
4039     // If the value is a class member, we might have a pointer-to-member.
4040     // Determine whether the non-type template template parameter is of
4041     // pointer-to-member type. If so, we need to build an appropriate
4042     // expression for a pointer-to-member, since a "normal" DeclRefExpr
4043     // would refer to the member itself.
4044     if (ParamType->isMemberPointerType()) {
4045       QualType ClassType
4046         = Context.getTypeDeclType(cast<RecordDecl>(VD->getDeclContext()));
4047       NestedNameSpecifier *Qualifier
4048         = NestedNameSpecifier::Create(Context, 0, false,
4049                                       ClassType.getTypePtr());
4050       CXXScopeSpec SS;
4051       SS.MakeTrivial(Context, Qualifier, Loc);
4052
4053       // The actual value-ness of this is unimportant, but for
4054       // internal consistency's sake, references to instance methods
4055       // are r-values.
4056       ExprValueKind VK = VK_LValue;
4057       if (isa<CXXMethodDecl>(VD) && cast<CXXMethodDecl>(VD)->isInstance())
4058         VK = VK_RValue;
4059
4060       ExprResult RefExpr = BuildDeclRefExpr(VD,
4061                                             VD->getType().getNonReferenceType(),
4062                                             VK,
4063                                             Loc,
4064                                             &SS);
4065       if (RefExpr.isInvalid())
4066         return ExprError();
4067
4068       RefExpr = CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
4069
4070       // We might need to perform a trailing qualification conversion, since
4071       // the element type on the parameter could be more qualified than the
4072       // element type in the expression we constructed.
4073       bool ObjCLifetimeConversion;
4074       if (IsQualificationConversion(((Expr*) RefExpr.get())->getType(),
4075                                     ParamType.getUnqualifiedType(), false,
4076                                     ObjCLifetimeConversion))
4077         RefExpr = ImpCastExprToType(RefExpr.take(), ParamType.getUnqualifiedType(), CK_NoOp);
4078
4079       assert(!RefExpr.isInvalid() &&
4080              Context.hasSameType(((Expr*) RefExpr.get())->getType(),
4081                                  ParamType.getUnqualifiedType()));
4082       return move(RefExpr);
4083     }
4084   }
4085
4086   QualType T = VD->getType().getNonReferenceType();
4087   if (ParamType->isPointerType()) {
4088     // When the non-type template parameter is a pointer, take the
4089     // address of the declaration.
4090     ExprResult RefExpr = BuildDeclRefExpr(VD, T, VK_LValue, Loc);
4091     if (RefExpr.isInvalid())
4092       return ExprError();
4093
4094     if (T->isFunctionType() || T->isArrayType()) {
4095       // Decay functions and arrays.
4096       RefExpr = DefaultFunctionArrayConversion(RefExpr.take());
4097       if (RefExpr.isInvalid())
4098         return ExprError();
4099
4100       return move(RefExpr);
4101     }
4102
4103     // Take the address of everything else
4104     return CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
4105   }
4106
4107   ExprValueKind VK = VK_RValue;
4108
4109   // If the non-type template parameter has reference type, qualify the
4110   // resulting declaration reference with the extra qualifiers on the
4111   // type that the reference refers to.
4112   if (const ReferenceType *TargetRef = ParamType->getAs<ReferenceType>()) {
4113     VK = VK_LValue;
4114     T = Context.getQualifiedType(T,
4115                               TargetRef->getPointeeType().getQualifiers());
4116   }
4117
4118   return BuildDeclRefExpr(VD, T, VK, Loc);
4119 }
4120
4121 /// \brief Construct a new expression that refers to the given
4122 /// integral template argument with the given source-location
4123 /// information.
4124 ///
4125 /// This routine takes care of the mapping from an integral template
4126 /// argument (which may have any integral type) to the appropriate
4127 /// literal value.
4128 ExprResult
4129 Sema::BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
4130                                                   SourceLocation Loc) {
4131   assert(Arg.getKind() == TemplateArgument::Integral &&
4132          "Operation is only valid for integral template arguments");
4133   QualType T = Arg.getIntegralType();
4134   if (T->isCharType() || T->isWideCharType())
4135     return Owned(new (Context) CharacterLiteral(
4136                                              Arg.getAsIntegral()->getZExtValue(),
4137                                              T->isWideCharType(), T, Loc));
4138   if (T->isBooleanType())
4139     return Owned(new (Context) CXXBoolLiteralExpr(
4140                                             Arg.getAsIntegral()->getBoolValue(),
4141                                             T, Loc));
4142
4143   if (T->isNullPtrType())
4144     return Owned(new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc));
4145
4146   // If this is an enum type that we're instantiating, we need to use an integer
4147   // type the same size as the enumerator.  We don't want to build an
4148   // IntegerLiteral with enum type.
4149   QualType BT;
4150   if (const EnumType *ET = T->getAs<EnumType>())
4151     BT = ET->getDecl()->getIntegerType();
4152   else
4153     BT = T;
4154
4155   Expr *E = IntegerLiteral::Create(Context, *Arg.getAsIntegral(), BT, Loc);
4156   if (T->isEnumeralType()) {
4157     // FIXME: This is a hack. We need a better way to handle substituted
4158     // non-type template parameters.
4159     E = CStyleCastExpr::Create(Context, T, VK_RValue, CK_IntegralCast, E, 0,
4160                                Context.getTrivialTypeSourceInfo(T, Loc),
4161                                Loc, Loc);
4162   }
4163
4164   return Owned(E);
4165 }
4166
4167 /// \brief Match two template parameters within template parameter lists.
4168 static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, NamedDecl *Old,
4169                                        bool Complain,
4170                                      Sema::TemplateParameterListEqualKind Kind,
4171                                        SourceLocation TemplateArgLoc) {
4172   // Check the actual kind (type, non-type, template).
4173   if (Old->getKind() != New->getKind()) {
4174     if (Complain) {
4175       unsigned NextDiag = diag::err_template_param_different_kind;
4176       if (TemplateArgLoc.isValid()) {
4177         S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
4178         NextDiag = diag::note_template_param_different_kind;
4179       }
4180       S.Diag(New->getLocation(), NextDiag)
4181         << (Kind != Sema::TPL_TemplateMatch);
4182       S.Diag(Old->getLocation(), diag::note_template_prev_declaration)
4183         << (Kind != Sema::TPL_TemplateMatch);
4184     }
4185
4186     return false;
4187   }
4188
4189   // Check that both are parameter packs are neither are parameter packs.
4190   // However, if we are matching a template template argument to a
4191   // template template parameter, the template template parameter can have
4192   // a parameter pack where the template template argument does not.
4193   if (Old->isTemplateParameterPack() != New->isTemplateParameterPack() &&
4194       !(Kind == Sema::TPL_TemplateTemplateArgumentMatch &&
4195         Old->isTemplateParameterPack())) {
4196     if (Complain) {
4197       unsigned NextDiag = diag::err_template_parameter_pack_non_pack;
4198       if (TemplateArgLoc.isValid()) {
4199         S.Diag(TemplateArgLoc,
4200              diag::err_template_arg_template_params_mismatch);
4201         NextDiag = diag::note_template_parameter_pack_non_pack;
4202       }
4203
4204       unsigned ParamKind = isa<TemplateTypeParmDecl>(New)? 0
4205                       : isa<NonTypeTemplateParmDecl>(New)? 1
4206                       : 2;
4207       S.Diag(New->getLocation(), NextDiag)
4208         << ParamKind << New->isParameterPack();
4209       S.Diag(Old->getLocation(), diag::note_template_parameter_pack_here)
4210         << ParamKind << Old->isParameterPack();
4211     }
4212
4213     return false;
4214   }
4215
4216   // For non-type template parameters, check the type of the parameter.
4217   if (NonTypeTemplateParmDecl *OldNTTP
4218                                     = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
4219     NonTypeTemplateParmDecl *NewNTTP = cast<NonTypeTemplateParmDecl>(New);
4220
4221     // If we are matching a template template argument to a template
4222     // template parameter and one of the non-type template parameter types
4223     // is dependent, then we must wait until template instantiation time
4224     // to actually compare the arguments.
4225     if (Kind == Sema::TPL_TemplateTemplateArgumentMatch &&
4226         (OldNTTP->getType()->isDependentType() ||
4227          NewNTTP->getType()->isDependentType()))
4228       return true;
4229
4230     if (!S.Context.hasSameType(OldNTTP->getType(), NewNTTP->getType())) {
4231       if (Complain) {
4232         unsigned NextDiag = diag::err_template_nontype_parm_different_type;
4233         if (TemplateArgLoc.isValid()) {
4234           S.Diag(TemplateArgLoc,
4235                  diag::err_template_arg_template_params_mismatch);
4236           NextDiag = diag::note_template_nontype_parm_different_type;
4237         }
4238         S.Diag(NewNTTP->getLocation(), NextDiag)
4239           << NewNTTP->getType()
4240           << (Kind != Sema::TPL_TemplateMatch);
4241         S.Diag(OldNTTP->getLocation(),
4242                diag::note_template_nontype_parm_prev_declaration)
4243           << OldNTTP->getType();
4244       }
4245
4246       return false;
4247     }
4248
4249     return true;
4250   }
4251
4252   // For template template parameters, check the template parameter types.
4253   // The template parameter lists of template template
4254   // parameters must agree.
4255   if (TemplateTemplateParmDecl *OldTTP
4256                                     = dyn_cast<TemplateTemplateParmDecl>(Old)) {
4257     TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(New);
4258     return S.TemplateParameterListsAreEqual(NewTTP->getTemplateParameters(),
4259                                             OldTTP->getTemplateParameters(),
4260                                             Complain,
4261                                         (Kind == Sema::TPL_TemplateMatch
4262                                            ? Sema::TPL_TemplateTemplateParmMatch
4263                                            : Kind),
4264                                             TemplateArgLoc);
4265   }
4266
4267   return true;
4268 }
4269
4270 /// \brief Diagnose a known arity mismatch when comparing template argument
4271 /// lists.
4272 static
4273 void DiagnoseTemplateParameterListArityMismatch(Sema &S,
4274                                                 TemplateParameterList *New,
4275                                                 TemplateParameterList *Old,
4276                                       Sema::TemplateParameterListEqualKind Kind,
4277                                                 SourceLocation TemplateArgLoc) {
4278   unsigned NextDiag = diag::err_template_param_list_different_arity;
4279   if (TemplateArgLoc.isValid()) {
4280     S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
4281     NextDiag = diag::note_template_param_list_different_arity;
4282   }
4283   S.Diag(New->getTemplateLoc(), NextDiag)
4284     << (New->size() > Old->size())
4285     << (Kind != Sema::TPL_TemplateMatch)
4286     << SourceRange(New->getTemplateLoc(), New->getRAngleLoc());
4287   S.Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration)
4288     << (Kind != Sema::TPL_TemplateMatch)
4289     << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc());
4290 }
4291
4292 /// \brief Determine whether the given template parameter lists are
4293 /// equivalent.
4294 ///
4295 /// \param New  The new template parameter list, typically written in the
4296 /// source code as part of a new template declaration.
4297 ///
4298 /// \param Old  The old template parameter list, typically found via
4299 /// name lookup of the template declared with this template parameter
4300 /// list.
4301 ///
4302 /// \param Complain  If true, this routine will produce a diagnostic if
4303 /// the template parameter lists are not equivalent.
4304 ///
4305 /// \param Kind describes how we are to match the template parameter lists.
4306 ///
4307 /// \param TemplateArgLoc If this source location is valid, then we
4308 /// are actually checking the template parameter list of a template
4309 /// argument (New) against the template parameter list of its
4310 /// corresponding template template parameter (Old). We produce
4311 /// slightly different diagnostics in this scenario.
4312 ///
4313 /// \returns True if the template parameter lists are equal, false
4314 /// otherwise.
4315 bool
4316 Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
4317                                      TemplateParameterList *Old,
4318                                      bool Complain,
4319                                      TemplateParameterListEqualKind Kind,
4320                                      SourceLocation TemplateArgLoc) {
4321   if (Old->size() != New->size() && Kind != TPL_TemplateTemplateArgumentMatch) {
4322     if (Complain)
4323       DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
4324                                                  TemplateArgLoc);
4325
4326     return false;
4327   }
4328
4329   // C++0x [temp.arg.template]p3:
4330   //   A template-argument matches a template template-parameter (call it P)
4331   //   when each of the template parameters in the template-parameter-list of
4332   //   the template-argument's corresponding class template or alias template
4333   //   (call it A) matches the corresponding template parameter in the
4334   //   template-parameter-list of P. [...]
4335   TemplateParameterList::iterator NewParm = New->begin();
4336   TemplateParameterList::iterator NewParmEnd = New->end();
4337   for (TemplateParameterList::iterator OldParm = Old->begin(),
4338                                     OldParmEnd = Old->end();
4339        OldParm != OldParmEnd; ++OldParm) {
4340     if (Kind != TPL_TemplateTemplateArgumentMatch ||
4341         !(*OldParm)->isTemplateParameterPack()) {
4342       if (NewParm == NewParmEnd) {
4343         if (Complain)
4344           DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
4345                                                      TemplateArgLoc);
4346
4347         return false;
4348       }
4349
4350       if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
4351                                       Kind, TemplateArgLoc))
4352         return false;
4353
4354       ++NewParm;
4355       continue;
4356     }
4357
4358     // C++0x [temp.arg.template]p3:
4359     //   [...] When P's template- parameter-list contains a template parameter
4360     //   pack (14.5.3), the template parameter pack will match zero or more
4361     //   template parameters or template parameter packs in the
4362     //   template-parameter-list of A with the same type and form as the
4363     //   template parameter pack in P (ignoring whether those template
4364     //   parameters are template parameter packs).
4365     for (; NewParm != NewParmEnd; ++NewParm) {
4366       if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
4367                                       Kind, TemplateArgLoc))
4368         return false;
4369     }
4370   }
4371
4372   // Make sure we exhausted all of the arguments.
4373   if (NewParm != NewParmEnd) {
4374     if (Complain)
4375       DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
4376                                                  TemplateArgLoc);
4377
4378     return false;
4379   }
4380
4381   return true;
4382 }
4383
4384 /// \brief Check whether a template can be declared within this scope.
4385 ///
4386 /// If the template declaration is valid in this scope, returns
4387 /// false. Otherwise, issues a diagnostic and returns true.
4388 bool
4389 Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) {
4390   // Find the nearest enclosing declaration scope.
4391   while ((S->getFlags() & Scope::DeclScope) == 0 ||
4392          (S->getFlags() & Scope::TemplateParamScope) != 0)
4393     S = S->getParent();
4394
4395   // C++ [temp]p2:
4396   //   A template-declaration can appear only as a namespace scope or
4397   //   class scope declaration.
4398   DeclContext *Ctx = static_cast<DeclContext *>(S->getEntity());
4399   if (Ctx && isa<LinkageSpecDecl>(Ctx) &&
4400       cast<LinkageSpecDecl>(Ctx)->getLanguage() != LinkageSpecDecl::lang_cxx)
4401     return Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage)
4402              << TemplateParams->getSourceRange();
4403
4404   while (Ctx && isa<LinkageSpecDecl>(Ctx))
4405     Ctx = Ctx->getParent();
4406
4407   if (Ctx && (Ctx->isFileContext() || Ctx->isRecord()))
4408     return false;
4409
4410   return Diag(TemplateParams->getTemplateLoc(),
4411               diag::err_template_outside_namespace_or_class_scope)
4412     << TemplateParams->getSourceRange();
4413 }
4414
4415 /// \brief Determine what kind of template specialization the given declaration
4416 /// is.
4417 static TemplateSpecializationKind getTemplateSpecializationKind(NamedDecl *D) {
4418   if (!D)
4419     return TSK_Undeclared;
4420
4421   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D))
4422     return Record->getTemplateSpecializationKind();
4423   if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D))
4424     return Function->getTemplateSpecializationKind();
4425   if (VarDecl *Var = dyn_cast<VarDecl>(D))
4426     return Var->getTemplateSpecializationKind();
4427
4428   return TSK_Undeclared;
4429 }
4430
4431 /// \brief Check whether a specialization is well-formed in the current
4432 /// context.
4433 ///
4434 /// This routine determines whether a template specialization can be declared
4435 /// in the current context (C++ [temp.expl.spec]p2).
4436 ///
4437 /// \param S the semantic analysis object for which this check is being
4438 /// performed.
4439 ///
4440 /// \param Specialized the entity being specialized or instantiated, which
4441 /// may be a kind of template (class template, function template, etc.) or
4442 /// a member of a class template (member function, static data member,
4443 /// member class).
4444 ///
4445 /// \param PrevDecl the previous declaration of this entity, if any.
4446 ///
4447 /// \param Loc the location of the explicit specialization or instantiation of
4448 /// this entity.
4449 ///
4450 /// \param IsPartialSpecialization whether this is a partial specialization of
4451 /// a class template.
4452 ///
4453 /// \returns true if there was an error that we cannot recover from, false
4454 /// otherwise.
4455 static bool CheckTemplateSpecializationScope(Sema &S,
4456                                              NamedDecl *Specialized,
4457                                              NamedDecl *PrevDecl,
4458                                              SourceLocation Loc,
4459                                              bool IsPartialSpecialization) {
4460   // Keep these "kind" numbers in sync with the %select statements in the
4461   // various diagnostics emitted by this routine.
4462   int EntityKind = 0;
4463   if (isa<ClassTemplateDecl>(Specialized))
4464     EntityKind = IsPartialSpecialization? 1 : 0;
4465   else if (isa<FunctionTemplateDecl>(Specialized))
4466     EntityKind = 2;
4467   else if (isa<CXXMethodDecl>(Specialized))
4468     EntityKind = 3;
4469   else if (isa<VarDecl>(Specialized))
4470     EntityKind = 4;
4471   else if (isa<RecordDecl>(Specialized))
4472     EntityKind = 5;
4473   else {
4474     S.Diag(Loc, diag::err_template_spec_unknown_kind);
4475     S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
4476     return true;
4477   }
4478
4479   // C++ [temp.expl.spec]p2:
4480   //   An explicit specialization shall be declared in the namespace
4481   //   of which the template is a member, or, for member templates, in
4482   //   the namespace of which the enclosing class or enclosing class
4483   //   template is a member. An explicit specialization of a member
4484   //   function, member class or static data member of a class
4485   //   template shall be declared in the namespace of which the class
4486   //   template is a member. Such a declaration may also be a
4487   //   definition. If the declaration is not a definition, the
4488   //   specialization may be defined later in the name- space in which
4489   //   the explicit specialization was declared, or in a namespace
4490   //   that encloses the one in which the explicit specialization was
4491   //   declared.
4492   if (S.CurContext->getRedeclContext()->isFunctionOrMethod()) {
4493     S.Diag(Loc, diag::err_template_spec_decl_function_scope)
4494       << Specialized;
4495     return true;
4496   }
4497
4498   if (S.CurContext->isRecord() && !IsPartialSpecialization) {
4499     S.Diag(Loc, diag::err_template_spec_decl_class_scope)
4500       << Specialized;
4501     return true;
4502   }
4503
4504   // C++ [temp.class.spec]p6:
4505   //   A class template partial specialization may be declared or redeclared
4506   //   in any namespace scope in which its definition may be defined (14.5.1
4507   //   and 14.5.2).
4508   bool ComplainedAboutScope = false;
4509   DeclContext *SpecializedContext
4510     = Specialized->getDeclContext()->getEnclosingNamespaceContext();
4511   DeclContext *DC = S.CurContext->getEnclosingNamespaceContext();
4512   if ((!PrevDecl ||
4513        getTemplateSpecializationKind(PrevDecl) == TSK_Undeclared ||
4514        getTemplateSpecializationKind(PrevDecl) == TSK_ImplicitInstantiation)){
4515     // C++ [temp.exp.spec]p2:
4516     //   An explicit specialization shall be declared in the namespace of which
4517     //   the template is a member, or, for member templates, in the namespace
4518     //   of which the enclosing class or enclosing class template is a member.
4519     //   An explicit specialization of a member function, member class or
4520     //   static data member of a class template shall be declared in the
4521     //   namespace of which the class template is a member.
4522     //
4523     // C++0x [temp.expl.spec]p2:
4524     //   An explicit specialization shall be declared in a namespace enclosing
4525     //   the specialized template.
4526     if (!DC->InEnclosingNamespaceSetOf(SpecializedContext) &&
4527         !(S.getLangOptions().CPlusPlus0x && DC->Encloses(SpecializedContext))) {
4528       bool IsCPlusPlus0xExtension
4529         = !S.getLangOptions().CPlusPlus0x && DC->Encloses(SpecializedContext);
4530       if (isa<TranslationUnitDecl>(SpecializedContext))
4531         S.Diag(Loc, IsCPlusPlus0xExtension
4532                       ? diag::ext_template_spec_decl_out_of_scope_global
4533                       : diag::err_template_spec_decl_out_of_scope_global)
4534           << EntityKind << Specialized;
4535       else if (isa<NamespaceDecl>(SpecializedContext))
4536         S.Diag(Loc, IsCPlusPlus0xExtension
4537                       ? diag::ext_template_spec_decl_out_of_scope
4538                       : diag::err_template_spec_decl_out_of_scope)
4539           << EntityKind << Specialized
4540           << cast<NamedDecl>(SpecializedContext);
4541
4542       S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
4543       ComplainedAboutScope = true;
4544     }
4545   }
4546
4547   // Make sure that this redeclaration (or definition) occurs in an enclosing
4548   // namespace.
4549   // Note that HandleDeclarator() performs this check for explicit
4550   // specializations of function templates, static data members, and member
4551   // functions, so we skip the check here for those kinds of entities.
4552   // FIXME: HandleDeclarator's diagnostics aren't quite as good, though.
4553   // Should we refactor that check, so that it occurs later?
4554   if (!ComplainedAboutScope && !DC->Encloses(SpecializedContext) &&
4555       !(isa<FunctionTemplateDecl>(Specialized) || isa<VarDecl>(Specialized) ||
4556         isa<FunctionDecl>(Specialized))) {
4557     if (isa<TranslationUnitDecl>(SpecializedContext))
4558       S.Diag(Loc, diag::err_template_spec_redecl_global_scope)
4559         << EntityKind << Specialized;
4560     else if (isa<NamespaceDecl>(SpecializedContext))
4561       S.Diag(Loc, diag::err_template_spec_redecl_out_of_scope)
4562         << EntityKind << Specialized
4563         << cast<NamedDecl>(SpecializedContext);
4564
4565     S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
4566   }
4567
4568   // FIXME: check for specialization-after-instantiation errors and such.
4569
4570   return false;
4571 }
4572
4573 /// \brief Subroutine of Sema::CheckClassTemplatePartialSpecializationArgs
4574 /// that checks non-type template partial specialization arguments.
4575 static bool CheckNonTypeClassTemplatePartialSpecializationArgs(Sema &S,
4576                                                 NonTypeTemplateParmDecl *Param,
4577                                                   const TemplateArgument *Args,
4578                                                         unsigned NumArgs) {
4579   for (unsigned I = 0; I != NumArgs; ++I) {
4580     if (Args[I].getKind() == TemplateArgument::Pack) {
4581       if (CheckNonTypeClassTemplatePartialSpecializationArgs(S, Param,
4582                                                            Args[I].pack_begin(),
4583                                                            Args[I].pack_size()))
4584         return true;
4585
4586       continue;
4587     }
4588
4589     Expr *ArgExpr = Args[I].getAsExpr();
4590     if (!ArgExpr) {
4591       continue;
4592     }
4593
4594     // We can have a pack expansion of any of the bullets below.
4595     if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(ArgExpr))
4596       ArgExpr = Expansion->getPattern();
4597
4598     // Strip off any implicit casts we added as part of type checking.
4599     while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
4600       ArgExpr = ICE->getSubExpr();
4601
4602     // C++ [temp.class.spec]p8:
4603     //   A non-type argument is non-specialized if it is the name of a
4604     //   non-type parameter. All other non-type arguments are
4605     //   specialized.
4606     //
4607     // Below, we check the two conditions that only apply to
4608     // specialized non-type arguments, so skip any non-specialized
4609     // arguments.
4610     if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
4611       if (isa<NonTypeTemplateParmDecl>(DRE->getDecl()))
4612         continue;
4613
4614     // C++ [temp.class.spec]p9:
4615     //   Within the argument list of a class template partial
4616     //   specialization, the following restrictions apply:
4617     //     -- A partially specialized non-type argument expression
4618     //        shall not involve a template parameter of the partial
4619     //        specialization except when the argument expression is a
4620     //        simple identifier.
4621     if (ArgExpr->isTypeDependent() || ArgExpr->isValueDependent()) {
4622       S.Diag(ArgExpr->getLocStart(),
4623            diag::err_dependent_non_type_arg_in_partial_spec)
4624         << ArgExpr->getSourceRange();
4625       return true;
4626     }
4627
4628     //     -- The type of a template parameter corresponding to a
4629     //        specialized non-type argument shall not be dependent on a
4630     //        parameter of the specialization.
4631     if (Param->getType()->isDependentType()) {
4632       S.Diag(ArgExpr->getLocStart(),
4633            diag::err_dependent_typed_non_type_arg_in_partial_spec)
4634         << Param->getType()
4635         << ArgExpr->getSourceRange();
4636       S.Diag(Param->getLocation(), diag::note_template_param_here);
4637       return true;
4638     }
4639   }
4640
4641   return false;
4642 }
4643
4644 /// \brief Check the non-type template arguments of a class template
4645 /// partial specialization according to C++ [temp.class.spec]p9.
4646 ///
4647 /// \param TemplateParams the template parameters of the primary class
4648 /// template.
4649 ///
4650 /// \param TemplateArg the template arguments of the class template
4651 /// partial specialization.
4652 ///
4653 /// \returns true if there was an error, false otherwise.
4654 static bool CheckClassTemplatePartialSpecializationArgs(Sema &S,
4655                                         TemplateParameterList *TemplateParams,
4656                        llvm::SmallVectorImpl<TemplateArgument> &TemplateArgs) {
4657   const TemplateArgument *ArgList = TemplateArgs.data();
4658
4659   for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
4660     NonTypeTemplateParmDecl *Param
4661       = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(I));
4662     if (!Param)
4663       continue;
4664
4665     if (CheckNonTypeClassTemplatePartialSpecializationArgs(S, Param,
4666                                                            &ArgList[I], 1))
4667       return true;
4668   }
4669
4670   return false;
4671 }
4672
4673 /// \brief Retrieve the previous declaration of the given declaration.
4674 static NamedDecl *getPreviousDecl(NamedDecl *ND) {
4675   if (VarDecl *VD = dyn_cast<VarDecl>(ND))
4676     return VD->getPreviousDeclaration();
4677   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
4678     return FD->getPreviousDeclaration();
4679   if (TagDecl *TD = dyn_cast<TagDecl>(ND))
4680     return TD->getPreviousDeclaration();
4681   if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(ND))
4682     return TD->getPreviousDeclaration();
4683   if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
4684     return FTD->getPreviousDeclaration();
4685   if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(ND))
4686     return CTD->getPreviousDeclaration();
4687   return 0;
4688 }
4689
4690 DeclResult
4691 Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
4692                                        TagUseKind TUK,
4693                                        SourceLocation KWLoc,
4694                                        CXXScopeSpec &SS,
4695                                        TemplateTy TemplateD,
4696                                        SourceLocation TemplateNameLoc,
4697                                        SourceLocation LAngleLoc,
4698                                        ASTTemplateArgsPtr TemplateArgsIn,
4699                                        SourceLocation RAngleLoc,
4700                                        AttributeList *Attr,
4701                                MultiTemplateParamsArg TemplateParameterLists) {
4702   assert(TUK != TUK_Reference && "References are not specializations");
4703
4704   // NOTE: KWLoc is the location of the tag keyword. This will instead
4705   // store the location of the outermost template keyword in the declaration.
4706   SourceLocation TemplateKWLoc = TemplateParameterLists.size() > 0
4707     ? TemplateParameterLists.get()[0]->getTemplateLoc() : SourceLocation();
4708
4709   // Find the class template we're specializing
4710   TemplateName Name = TemplateD.getAsVal<TemplateName>();
4711   ClassTemplateDecl *ClassTemplate
4712     = dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl());
4713
4714   if (!ClassTemplate) {
4715     Diag(TemplateNameLoc, diag::err_not_class_template_specialization)
4716       << (Name.getAsTemplateDecl() &&
4717           isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()));
4718     return true;
4719   }
4720
4721   bool isExplicitSpecialization = false;
4722   bool isPartialSpecialization = false;
4723
4724   // Check the validity of the template headers that introduce this
4725   // template.
4726   // FIXME: We probably shouldn't complain about these headers for
4727   // friend declarations.
4728   bool Invalid = false;
4729   TemplateParameterList *TemplateParams
4730     = MatchTemplateParametersToScopeSpecifier(TemplateNameLoc,
4731                                               TemplateNameLoc,
4732                                               SS,
4733                         (TemplateParameterList**)TemplateParameterLists.get(),
4734                                               TemplateParameterLists.size(),
4735                                               TUK == TUK_Friend,
4736                                               isExplicitSpecialization,
4737                                               Invalid);
4738   if (Invalid)
4739     return true;
4740
4741   if (TemplateParams && TemplateParams->size() > 0) {
4742     isPartialSpecialization = true;
4743
4744     if (TUK == TUK_Friend) {
4745       Diag(KWLoc, diag::err_partial_specialization_friend)
4746         << SourceRange(LAngleLoc, RAngleLoc);
4747       return true;
4748     }
4749
4750     // C++ [temp.class.spec]p10:
4751     //   The template parameter list of a specialization shall not
4752     //   contain default template argument values.
4753     for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
4754       Decl *Param = TemplateParams->getParam(I);
4755       if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
4756         if (TTP->hasDefaultArgument()) {
4757           Diag(TTP->getDefaultArgumentLoc(),
4758                diag::err_default_arg_in_partial_spec);
4759           TTP->removeDefaultArgument();
4760         }
4761       } else if (NonTypeTemplateParmDecl *NTTP
4762                    = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4763         if (Expr *DefArg = NTTP->getDefaultArgument()) {
4764           Diag(NTTP->getDefaultArgumentLoc(),
4765                diag::err_default_arg_in_partial_spec)
4766             << DefArg->getSourceRange();
4767           NTTP->removeDefaultArgument();
4768         }
4769       } else {
4770         TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Param);
4771         if (TTP->hasDefaultArgument()) {
4772           Diag(TTP->getDefaultArgument().getLocation(),
4773                diag::err_default_arg_in_partial_spec)
4774             << TTP->getDefaultArgument().getSourceRange();
4775           TTP->removeDefaultArgument();
4776         }
4777       }
4778     }
4779   } else if (TemplateParams) {
4780     if (TUK == TUK_Friend)
4781       Diag(KWLoc, diag::err_template_spec_friend)
4782         << FixItHint::CreateRemoval(
4783                                 SourceRange(TemplateParams->getTemplateLoc(),
4784                                             TemplateParams->getRAngleLoc()))
4785         << SourceRange(LAngleLoc, RAngleLoc);
4786     else
4787       isExplicitSpecialization = true;
4788   } else if (TUK != TUK_Friend) {
4789     Diag(KWLoc, diag::err_template_spec_needs_header)
4790       << FixItHint::CreateInsertion(KWLoc, "template<> ");
4791     isExplicitSpecialization = true;
4792   }
4793
4794   // Check that the specialization uses the same tag kind as the
4795   // original template.
4796   TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
4797   assert(Kind != TTK_Enum && "Invalid enum tag in class template spec!");
4798   if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
4799                                     Kind, TUK == TUK_Definition, KWLoc,
4800                                     *ClassTemplate->getIdentifier())) {
4801     Diag(KWLoc, diag::err_use_with_wrong_tag)
4802       << ClassTemplate
4803       << FixItHint::CreateReplacement(KWLoc,
4804                             ClassTemplate->getTemplatedDecl()->getKindName());
4805     Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
4806          diag::note_previous_use);
4807     Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
4808   }
4809
4810   // Translate the parser's template argument list in our AST format.
4811   TemplateArgumentListInfo TemplateArgs;
4812   TemplateArgs.setLAngleLoc(LAngleLoc);
4813   TemplateArgs.setRAngleLoc(RAngleLoc);
4814   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
4815
4816   // Check for unexpanded parameter packs in any of the template arguments.
4817   for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
4818     if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
4819                                         UPPC_PartialSpecialization))
4820       return true;
4821
4822   // Check that the template argument list is well-formed for this
4823   // template.
4824   llvm::SmallVector<TemplateArgument, 4> Converted;
4825   if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
4826                                 TemplateArgs, false, Converted))
4827     return true;
4828
4829   assert((Converted.size() == ClassTemplate->getTemplateParameters()->size()) &&
4830          "Converted template argument list is too short!");
4831
4832   // Find the class template (partial) specialization declaration that
4833   // corresponds to these arguments.
4834   if (isPartialSpecialization) {
4835     if (CheckClassTemplatePartialSpecializationArgs(*this,
4836                                          ClassTemplate->getTemplateParameters(),
4837                                          Converted))
4838       return true;
4839
4840     bool InstantiationDependent;
4841     if (!Name.isDependent() &&
4842         !TemplateSpecializationType::anyDependentTemplateArguments(
4843                                              TemplateArgs.getArgumentArray(),
4844                                                          TemplateArgs.size(),
4845                                                      InstantiationDependent)) {
4846       Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
4847         << ClassTemplate->getDeclName();
4848       isPartialSpecialization = false;
4849     }
4850   }
4851
4852   void *InsertPos = 0;
4853   ClassTemplateSpecializationDecl *PrevDecl = 0;
4854
4855   if (isPartialSpecialization)
4856     // FIXME: Template parameter list matters, too
4857     PrevDecl
4858       = ClassTemplate->findPartialSpecialization(Converted.data(),
4859                                                  Converted.size(),
4860                                                  InsertPos);
4861   else
4862     PrevDecl
4863       = ClassTemplate->findSpecialization(Converted.data(),
4864                                           Converted.size(), InsertPos);
4865
4866   ClassTemplateSpecializationDecl *Specialization = 0;
4867
4868   // Check whether we can declare a class template specialization in
4869   // the current scope.
4870   if (TUK != TUK_Friend &&
4871       CheckTemplateSpecializationScope(*this, ClassTemplate, PrevDecl,
4872                                        TemplateNameLoc,
4873                                        isPartialSpecialization))
4874     return true;
4875
4876   // The canonical type
4877   QualType CanonType;
4878   if (PrevDecl &&
4879       (PrevDecl->getSpecializationKind() == TSK_Undeclared ||
4880                TUK == TUK_Friend)) {
4881     // Since the only prior class template specialization with these
4882     // arguments was referenced but not declared, or we're only
4883     // referencing this specialization as a friend, reuse that
4884     // declaration node as our own, updating its source location and
4885     // the list of outer template parameters to reflect our new declaration.
4886     Specialization = PrevDecl;
4887     Specialization->setLocation(TemplateNameLoc);
4888     if (TemplateParameterLists.size() > 0) {
4889       Specialization->setTemplateParameterListsInfo(Context,
4890                                               TemplateParameterLists.size(),
4891                     (TemplateParameterList**) TemplateParameterLists.release());
4892     }
4893     PrevDecl = 0;
4894     CanonType = Context.getTypeDeclType(Specialization);
4895   } else if (isPartialSpecialization) {
4896     // Build the canonical type that describes the converted template
4897     // arguments of the class template partial specialization.
4898     TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
4899     CanonType = Context.getTemplateSpecializationType(CanonTemplate,
4900                                                       Converted.data(),
4901                                                       Converted.size());
4902
4903     if (Context.hasSameType(CanonType,
4904                         ClassTemplate->getInjectedClassNameSpecialization())) {
4905       // C++ [temp.class.spec]p9b3:
4906       //
4907       //   -- The argument list of the specialization shall not be identical
4908       //      to the implicit argument list of the primary template.
4909       Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
4910       << (TUK == TUK_Definition)
4911       << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
4912       return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS,
4913                                 ClassTemplate->getIdentifier(),
4914                                 TemplateNameLoc,
4915                                 Attr,
4916                                 TemplateParams,
4917                                 AS_none,
4918                                 TemplateParameterLists.size() - 1,
4919                   (TemplateParameterList**) TemplateParameterLists.release());
4920     }
4921
4922     // Create a new class template partial specialization declaration node.
4923     ClassTemplatePartialSpecializationDecl *PrevPartial
4924       = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
4925     unsigned SequenceNumber = PrevPartial? PrevPartial->getSequenceNumber()
4926                             : ClassTemplate->getNextPartialSpecSequenceNumber();
4927     ClassTemplatePartialSpecializationDecl *Partial
4928       = ClassTemplatePartialSpecializationDecl::Create(Context, Kind,
4929                                              ClassTemplate->getDeclContext(),
4930                                                        KWLoc, TemplateNameLoc,
4931                                                        TemplateParams,
4932                                                        ClassTemplate,
4933                                                        Converted.data(),
4934                                                        Converted.size(),
4935                                                        TemplateArgs,
4936                                                        CanonType,
4937                                                        PrevPartial,
4938                                                        SequenceNumber);
4939     SetNestedNameSpecifier(Partial, SS);
4940     if (TemplateParameterLists.size() > 1 && SS.isSet()) {
4941       Partial->setTemplateParameterListsInfo(Context,
4942                                              TemplateParameterLists.size() - 1,
4943                     (TemplateParameterList**) TemplateParameterLists.release());
4944     }
4945
4946     if (!PrevPartial)
4947       ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
4948     Specialization = Partial;
4949
4950     // If we are providing an explicit specialization of a member class
4951     // template specialization, make a note of that.
4952     if (PrevPartial && PrevPartial->getInstantiatedFromMember())
4953       PrevPartial->setMemberSpecialization();
4954
4955     // Check that all of the template parameters of the class template
4956     // partial specialization are deducible from the template
4957     // arguments. If not, this class template partial specialization
4958     // will never be used.
4959     llvm::SmallVector<bool, 8> DeducibleParams;
4960     DeducibleParams.resize(TemplateParams->size());
4961     MarkUsedTemplateParameters(Partial->getTemplateArgs(), true,
4962                                TemplateParams->getDepth(),
4963                                DeducibleParams);
4964     unsigned NumNonDeducible = 0;
4965     for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I)
4966       if (!DeducibleParams[I])
4967         ++NumNonDeducible;
4968
4969     if (NumNonDeducible) {
4970       Diag(TemplateNameLoc, diag::warn_partial_specs_not_deducible)
4971         << (NumNonDeducible > 1)
4972         << SourceRange(TemplateNameLoc, RAngleLoc);
4973       for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
4974         if (!DeducibleParams[I]) {
4975           NamedDecl *Param = cast<NamedDecl>(TemplateParams->getParam(I));
4976           if (Param->getDeclName())
4977             Diag(Param->getLocation(),
4978                  diag::note_partial_spec_unused_parameter)
4979               << Param->getDeclName();
4980           else
4981             Diag(Param->getLocation(),
4982                  diag::note_partial_spec_unused_parameter)
4983               << "<anonymous>";
4984         }
4985       }
4986     }
4987   } else {
4988     // Create a new class template specialization declaration node for
4989     // this explicit specialization or friend declaration.
4990     Specialization
4991       = ClassTemplateSpecializationDecl::Create(Context, Kind,
4992                                              ClassTemplate->getDeclContext(),
4993                                                 KWLoc, TemplateNameLoc,
4994                                                 ClassTemplate,
4995                                                 Converted.data(),
4996                                                 Converted.size(),
4997                                                 PrevDecl);
4998     SetNestedNameSpecifier(Specialization, SS);
4999     if (TemplateParameterLists.size() > 0) {
5000       Specialization->setTemplateParameterListsInfo(Context,
5001                                               TemplateParameterLists.size(),
5002                     (TemplateParameterList**) TemplateParameterLists.release());
5003     }
5004
5005     if (!PrevDecl)
5006       ClassTemplate->AddSpecialization(Specialization, InsertPos);
5007
5008     CanonType = Context.getTypeDeclType(Specialization);
5009   }
5010
5011   // C++ [temp.expl.spec]p6:
5012   //   If a template, a member template or the member of a class template is
5013   //   explicitly specialized then that specialization shall be declared
5014   //   before the first use of that specialization that would cause an implicit
5015   //   instantiation to take place, in every translation unit in which such a
5016   //   use occurs; no diagnostic is required.
5017   if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
5018     bool Okay = false;
5019     for (NamedDecl *Prev = PrevDecl; Prev; Prev = getPreviousDecl(Prev)) {
5020       // Is there any previous explicit specialization declaration?
5021       if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
5022         Okay = true;
5023         break;
5024       }
5025     }
5026
5027     if (!Okay) {
5028       SourceRange Range(TemplateNameLoc, RAngleLoc);
5029       Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
5030         << Context.getTypeDeclType(Specialization) << Range;
5031
5032       Diag(PrevDecl->getPointOfInstantiation(),
5033            diag::note_instantiation_required_here)
5034         << (PrevDecl->getTemplateSpecializationKind()
5035                                                 != TSK_ImplicitInstantiation);
5036       return true;
5037     }
5038   }
5039
5040   // If this is not a friend, note that this is an explicit specialization.
5041   if (TUK != TUK_Friend)
5042     Specialization->setSpecializationKind(TSK_ExplicitSpecialization);
5043
5044   // Check that this isn't a redefinition of this specialization.
5045   if (TUK == TUK_Definition) {
5046     if (RecordDecl *Def = Specialization->getDefinition()) {
5047       SourceRange Range(TemplateNameLoc, RAngleLoc);
5048       Diag(TemplateNameLoc, diag::err_redefinition)
5049         << Context.getTypeDeclType(Specialization) << Range;
5050       Diag(Def->getLocation(), diag::note_previous_definition);
5051       Specialization->setInvalidDecl();
5052       return true;
5053     }
5054   }
5055
5056   if (Attr)
5057     ProcessDeclAttributeList(S, Specialization, Attr);
5058
5059   // Build the fully-sugared type for this class template
5060   // specialization as the user wrote in the specialization
5061   // itself. This means that we'll pretty-print the type retrieved
5062   // from the specialization's declaration the way that the user
5063   // actually wrote the specialization, rather than formatting the
5064   // name based on the "canonical" representation used to store the
5065   // template arguments in the specialization.
5066   TypeSourceInfo *WrittenTy
5067     = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
5068                                                 TemplateArgs, CanonType);
5069   if (TUK != TUK_Friend) {
5070     Specialization->setTypeAsWritten(WrittenTy);
5071     Specialization->setTemplateKeywordLoc(TemplateKWLoc);
5072   }
5073   TemplateArgsIn.release();
5074
5075   // C++ [temp.expl.spec]p9:
5076   //   A template explicit specialization is in the scope of the
5077   //   namespace in which the template was defined.
5078   //
5079   // We actually implement this paragraph where we set the semantic
5080   // context (in the creation of the ClassTemplateSpecializationDecl),
5081   // but we also maintain the lexical context where the actual
5082   // definition occurs.
5083   Specialization->setLexicalDeclContext(CurContext);
5084
5085   // We may be starting the definition of this specialization.
5086   if (TUK == TUK_Definition)
5087     Specialization->startDefinition();
5088
5089   if (TUK == TUK_Friend) {
5090     FriendDecl *Friend = FriendDecl::Create(Context, CurContext,
5091                                             TemplateNameLoc,
5092                                             WrittenTy,
5093                                             /*FIXME:*/KWLoc);
5094     Friend->setAccess(AS_public);
5095     CurContext->addDecl(Friend);
5096   } else {
5097     // Add the specialization into its lexical context, so that it can
5098     // be seen when iterating through the list of declarations in that
5099     // context. However, specializations are not found by name lookup.
5100     CurContext->addDecl(Specialization);
5101   }
5102   return Specialization;
5103 }
5104
5105 Decl *Sema::ActOnTemplateDeclarator(Scope *S,
5106                               MultiTemplateParamsArg TemplateParameterLists,
5107                                     Declarator &D) {
5108   return HandleDeclarator(S, D, move(TemplateParameterLists), false);
5109 }
5110
5111 Decl *Sema::ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope,
5112                                MultiTemplateParamsArg TemplateParameterLists,
5113                                             Declarator &D) {
5114   assert(getCurFunctionDecl() == 0 && "Function parsing confused");
5115   DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
5116
5117   if (FTI.hasPrototype) {
5118     // FIXME: Diagnose arguments without names in C.
5119   }
5120
5121   Scope *ParentScope = FnBodyScope->getParent();
5122
5123   Decl *DP = HandleDeclarator(ParentScope, D,
5124                               move(TemplateParameterLists),
5125                               /*IsFunctionDefinition=*/true);
5126   if (FunctionTemplateDecl *FunctionTemplate
5127         = dyn_cast_or_null<FunctionTemplateDecl>(DP))
5128     return ActOnStartOfFunctionDef(FnBodyScope,
5129                                    FunctionTemplate->getTemplatedDecl());
5130   if (FunctionDecl *Function = dyn_cast_or_null<FunctionDecl>(DP))
5131     return ActOnStartOfFunctionDef(FnBodyScope, Function);
5132   return 0;
5133 }
5134
5135 /// \brief Strips various properties off an implicit instantiation
5136 /// that has just been explicitly specialized.
5137 static void StripImplicitInstantiation(NamedDecl *D) {
5138   D->dropAttrs();
5139
5140   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
5141     FD->setInlineSpecified(false);
5142   }
5143 }
5144
5145 /// \brief Diagnose cases where we have an explicit template specialization
5146 /// before/after an explicit template instantiation, producing diagnostics
5147 /// for those cases where they are required and determining whether the
5148 /// new specialization/instantiation will have any effect.
5149 ///
5150 /// \param NewLoc the location of the new explicit specialization or
5151 /// instantiation.
5152 ///
5153 /// \param NewTSK the kind of the new explicit specialization or instantiation.
5154 ///
5155 /// \param PrevDecl the previous declaration of the entity.
5156 ///
5157 /// \param PrevTSK the kind of the old explicit specialization or instantiatin.
5158 ///
5159 /// \param PrevPointOfInstantiation if valid, indicates where the previus
5160 /// declaration was instantiated (either implicitly or explicitly).
5161 ///
5162 /// \param HasNoEffect will be set to true to indicate that the new
5163 /// specialization or instantiation has no effect and should be ignored.
5164 ///
5165 /// \returns true if there was an error that should prevent the introduction of
5166 /// the new declaration into the AST, false otherwise.
5167 bool
5168 Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
5169                                              TemplateSpecializationKind NewTSK,
5170                                              NamedDecl *PrevDecl,
5171                                              TemplateSpecializationKind PrevTSK,
5172                                         SourceLocation PrevPointOfInstantiation,
5173                                              bool &HasNoEffect) {
5174   HasNoEffect = false;
5175
5176   switch (NewTSK) {
5177   case TSK_Undeclared:
5178   case TSK_ImplicitInstantiation:
5179     assert(false && "Don't check implicit instantiations here");
5180     return false;
5181
5182   case TSK_ExplicitSpecialization:
5183     switch (PrevTSK) {
5184     case TSK_Undeclared:
5185     case TSK_ExplicitSpecialization:
5186       // Okay, we're just specializing something that is either already
5187       // explicitly specialized or has merely been mentioned without any
5188       // instantiation.
5189       return false;
5190
5191     case TSK_ImplicitInstantiation:
5192       if (PrevPointOfInstantiation.isInvalid()) {
5193         // The declaration itself has not actually been instantiated, so it is
5194         // still okay to specialize it.
5195         StripImplicitInstantiation(PrevDecl);
5196         return false;
5197       }
5198       // Fall through
5199
5200     case TSK_ExplicitInstantiationDeclaration:
5201     case TSK_ExplicitInstantiationDefinition:
5202       assert((PrevTSK == TSK_ImplicitInstantiation ||
5203               PrevPointOfInstantiation.isValid()) &&
5204              "Explicit instantiation without point of instantiation?");
5205
5206       // C++ [temp.expl.spec]p6:
5207       //   If a template, a member template or the member of a class template
5208       //   is explicitly specialized then that specialization shall be declared
5209       //   before the first use of that specialization that would cause an
5210       //   implicit instantiation to take place, in every translation unit in
5211       //   which such a use occurs; no diagnostic is required.
5212       for (NamedDecl *Prev = PrevDecl; Prev; Prev = getPreviousDecl(Prev)) {
5213         // Is there any previous explicit specialization declaration?
5214         if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization)
5215           return false;
5216       }
5217
5218       Diag(NewLoc, diag::err_specialization_after_instantiation)
5219         << PrevDecl;
5220       Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
5221         << (PrevTSK != TSK_ImplicitInstantiation);
5222
5223       return true;
5224     }
5225     break;
5226
5227   case TSK_ExplicitInstantiationDeclaration:
5228     switch (PrevTSK) {
5229     case TSK_ExplicitInstantiationDeclaration:
5230       // This explicit instantiation declaration is redundant (that's okay).
5231       HasNoEffect = true;
5232       return false;
5233
5234     case TSK_Undeclared:
5235     case TSK_ImplicitInstantiation:
5236       // We're explicitly instantiating something that may have already been
5237       // implicitly instantiated; that's fine.
5238       return false;
5239
5240     case TSK_ExplicitSpecialization:
5241       // C++0x [temp.explicit]p4:
5242       //   For a given set of template parameters, if an explicit instantiation
5243       //   of a template appears after a declaration of an explicit
5244       //   specialization for that template, the explicit instantiation has no
5245       //   effect.
5246       HasNoEffect = true;
5247       return false;
5248
5249     case TSK_ExplicitInstantiationDefinition:
5250       // C++0x [temp.explicit]p10:
5251       //   If an entity is the subject of both an explicit instantiation
5252       //   declaration and an explicit instantiation definition in the same
5253       //   translation unit, the definition shall follow the declaration.
5254       Diag(NewLoc,
5255            diag::err_explicit_instantiation_declaration_after_definition);
5256       Diag(PrevPointOfInstantiation,
5257            diag::note_explicit_instantiation_definition_here);
5258       assert(PrevPointOfInstantiation.isValid() &&
5259              "Explicit instantiation without point of instantiation?");
5260       HasNoEffect = true;
5261       return false;
5262     }
5263     break;
5264
5265   case TSK_ExplicitInstantiationDefinition:
5266     switch (PrevTSK) {
5267     case TSK_Undeclared:
5268     case TSK_ImplicitInstantiation:
5269       // We're explicitly instantiating something that may have already been
5270       // implicitly instantiated; that's fine.
5271       return false;
5272
5273     case TSK_ExplicitSpecialization:
5274       // C++ DR 259, C++0x [temp.explicit]p4:
5275       //   For a given set of template parameters, if an explicit
5276       //   instantiation of a template appears after a declaration of
5277       //   an explicit specialization for that template, the explicit
5278       //   instantiation has no effect.
5279       //
5280       // In C++98/03 mode, we only give an extension warning here, because it
5281       // is not harmful to try to explicitly instantiate something that
5282       // has been explicitly specialized.
5283       if (!getLangOptions().CPlusPlus0x) {
5284         Diag(NewLoc, diag::ext_explicit_instantiation_after_specialization)
5285           << PrevDecl;
5286         Diag(PrevDecl->getLocation(),
5287              diag::note_previous_template_specialization);
5288       }
5289       HasNoEffect = true;
5290       return false;
5291
5292     case TSK_ExplicitInstantiationDeclaration:
5293       // We're explicity instantiating a definition for something for which we
5294       // were previously asked to suppress instantiations. That's fine.
5295       return false;
5296
5297     case TSK_ExplicitInstantiationDefinition:
5298       // C++0x [temp.spec]p5:
5299       //   For a given template and a given set of template-arguments,
5300       //     - an explicit instantiation definition shall appear at most once
5301       //       in a program,
5302       Diag(NewLoc, diag::err_explicit_instantiation_duplicate)
5303         << PrevDecl;
5304       Diag(PrevPointOfInstantiation,
5305            diag::note_previous_explicit_instantiation);
5306       HasNoEffect = true;
5307       return false;
5308     }
5309     break;
5310   }
5311
5312   assert(false && "Missing specialization/instantiation case?");
5313
5314   return false;
5315 }
5316
5317 /// \brief Perform semantic analysis for the given dependent function
5318 /// template specialization.  The only possible way to get a dependent
5319 /// function template specialization is with a friend declaration,
5320 /// like so:
5321 ///
5322 ///   template <class T> void foo(T);
5323 ///   template <class T> class A {
5324 ///     friend void foo<>(T);
5325 ///   };
5326 ///
5327 /// There really isn't any useful analysis we can do here, so we
5328 /// just store the information.
5329 bool
5330 Sema::CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,
5331                    const TemplateArgumentListInfo &ExplicitTemplateArgs,
5332                                                    LookupResult &Previous) {
5333   // Remove anything from Previous that isn't a function template in
5334   // the correct context.
5335   DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
5336   LookupResult::Filter F = Previous.makeFilter();
5337   while (F.hasNext()) {
5338     NamedDecl *D = F.next()->getUnderlyingDecl();
5339     if (!isa<FunctionTemplateDecl>(D) ||
5340         !FDLookupContext->InEnclosingNamespaceSetOf(
5341                               D->getDeclContext()->getRedeclContext()))
5342       F.erase();
5343   }
5344   F.done();
5345
5346   // Should this be diagnosed here?
5347   if (Previous.empty()) return true;
5348
5349   FD->setDependentTemplateSpecialization(Context, Previous.asUnresolvedSet(),
5350                                          ExplicitTemplateArgs);
5351   return false;
5352 }
5353
5354 /// \brief Perform semantic analysis for the given function template
5355 /// specialization.
5356 ///
5357 /// This routine performs all of the semantic analysis required for an
5358 /// explicit function template specialization. On successful completion,
5359 /// the function declaration \p FD will become a function template
5360 /// specialization.
5361 ///
5362 /// \param FD the function declaration, which will be updated to become a
5363 /// function template specialization.
5364 ///
5365 /// \param ExplicitTemplateArgs the explicitly-provided template arguments,
5366 /// if any. Note that this may be valid info even when 0 arguments are
5367 /// explicitly provided as in, e.g., \c void sort<>(char*, char*);
5368 /// as it anyway contains info on the angle brackets locations.
5369 ///
5370 /// \param Previous the set of declarations that may be specialized by
5371 /// this function specialization.
5372 bool
5373 Sema::CheckFunctionTemplateSpecialization(FunctionDecl *FD,
5374                                  TemplateArgumentListInfo *ExplicitTemplateArgs,
5375                                           LookupResult &Previous) {
5376   // The set of function template specializations that could match this
5377   // explicit function template specialization.
5378   UnresolvedSet<8> Candidates;
5379
5380   DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
5381   for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
5382          I != E; ++I) {
5383     NamedDecl *Ovl = (*I)->getUnderlyingDecl();
5384     if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Ovl)) {
5385       // Only consider templates found within the same semantic lookup scope as
5386       // FD.
5387       if (!FDLookupContext->InEnclosingNamespaceSetOf(
5388                                 Ovl->getDeclContext()->getRedeclContext()))
5389         continue;
5390
5391       // C++ [temp.expl.spec]p11:
5392       //   A trailing template-argument can be left unspecified in the
5393       //   template-id naming an explicit function template specialization
5394       //   provided it can be deduced from the function argument type.
5395       // Perform template argument deduction to determine whether we may be
5396       // specializing this template.
5397       // FIXME: It is somewhat wasteful to build
5398       TemplateDeductionInfo Info(Context, FD->getLocation());
5399       FunctionDecl *Specialization = 0;
5400       if (TemplateDeductionResult TDK
5401             = DeduceTemplateArguments(FunTmpl, ExplicitTemplateArgs,
5402                                       FD->getType(),
5403                                       Specialization,
5404                                       Info)) {
5405         // FIXME: Template argument deduction failed; record why it failed, so
5406         // that we can provide nifty diagnostics.
5407         (void)TDK;
5408         continue;
5409       }
5410
5411       // Record this candidate.
5412       Candidates.addDecl(Specialization, I.getAccess());
5413     }
5414   }
5415
5416   // Find the most specialized function template.
5417   UnresolvedSetIterator Result
5418     = getMostSpecialized(Candidates.begin(), Candidates.end(),
5419                          TPOC_Other, 0, FD->getLocation(),
5420                   PDiag(diag::err_function_template_spec_no_match)
5421                     << FD->getDeclName(),
5422                   PDiag(diag::err_function_template_spec_ambiguous)
5423                     << FD->getDeclName() << (ExplicitTemplateArgs != 0),
5424                   PDiag(diag::note_function_template_spec_matched));
5425   if (Result == Candidates.end())
5426     return true;
5427
5428   // Ignore access information;  it doesn't figure into redeclaration checking.
5429   FunctionDecl *Specialization = cast<FunctionDecl>(*Result);
5430
5431   FunctionTemplateSpecializationInfo *SpecInfo
5432     = Specialization->getTemplateSpecializationInfo();
5433   assert(SpecInfo && "Function template specialization info missing?");
5434
5435   // Note: do not overwrite location info if previous template
5436   // specialization kind was explicit.
5437   TemplateSpecializationKind TSK = SpecInfo->getTemplateSpecializationKind();
5438   if (TSK == TSK_Undeclared || TSK == TSK_ImplicitInstantiation)
5439     Specialization->setLocation(FD->getLocation());
5440
5441   // FIXME: Check if the prior specialization has a point of instantiation.
5442   // If so, we have run afoul of .
5443
5444   // If this is a friend declaration, then we're not really declaring
5445   // an explicit specialization.
5446   bool isFriend = (FD->getFriendObjectKind() != Decl::FOK_None);
5447
5448   // Check the scope of this explicit specialization.
5449   if (!isFriend &&
5450       CheckTemplateSpecializationScope(*this,
5451                                        Specialization->getPrimaryTemplate(),
5452                                        Specialization, FD->getLocation(),
5453                                        false))
5454     return true;
5455
5456   // C++ [temp.expl.spec]p6:
5457   //   If a template, a member template or the member of a class template is
5458   //   explicitly specialized then that specialization shall be declared
5459   //   before the first use of that specialization that would cause an implicit
5460   //   instantiation to take place, in every translation unit in which such a
5461   //   use occurs; no diagnostic is required.
5462   bool HasNoEffect = false;
5463   if (!isFriend &&
5464       CheckSpecializationInstantiationRedecl(FD->getLocation(),
5465                                              TSK_ExplicitSpecialization,
5466                                              Specialization,
5467                                    SpecInfo->getTemplateSpecializationKind(),
5468                                          SpecInfo->getPointOfInstantiation(),
5469                                              HasNoEffect))
5470     return true;
5471
5472   // Mark the prior declaration as an explicit specialization, so that later
5473   // clients know that this is an explicit specialization.
5474   if (!isFriend) {
5475     SpecInfo->setTemplateSpecializationKind(TSK_ExplicitSpecialization);
5476     MarkUnusedFileScopedDecl(Specialization);
5477   }
5478
5479   // Turn the given function declaration into a function template
5480   // specialization, with the template arguments from the previous
5481   // specialization.
5482   // Take copies of (semantic and syntactic) template argument lists.
5483   const TemplateArgumentList* TemplArgs = new (Context)
5484     TemplateArgumentList(Specialization->getTemplateSpecializationArgs());
5485   const TemplateArgumentListInfo* TemplArgsAsWritten = ExplicitTemplateArgs
5486     ? new (Context) TemplateArgumentListInfo(*ExplicitTemplateArgs) : 0;
5487   FD->setFunctionTemplateSpecialization(Specialization->getPrimaryTemplate(),
5488                                         TemplArgs, /*InsertPos=*/0,
5489                                     SpecInfo->getTemplateSpecializationKind(),
5490                                         TemplArgsAsWritten);
5491   FD->setStorageClass(Specialization->getStorageClass());
5492
5493   // The "previous declaration" for this function template specialization is
5494   // the prior function template specialization.
5495   Previous.clear();
5496   Previous.addDecl(Specialization);
5497   return false;
5498 }
5499
5500 /// \brief Perform semantic analysis for the given non-template member
5501 /// specialization.
5502 ///
5503 /// This routine performs all of the semantic analysis required for an
5504 /// explicit member function specialization. On successful completion,
5505 /// the function declaration \p FD will become a member function
5506 /// specialization.
5507 ///
5508 /// \param Member the member declaration, which will be updated to become a
5509 /// specialization.
5510 ///
5511 /// \param Previous the set of declarations, one of which may be specialized
5512 /// by this function specialization;  the set will be modified to contain the
5513 /// redeclared member.
5514 bool
5515 Sema::CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous) {
5516   assert(!isa<TemplateDecl>(Member) && "Only for non-template members");
5517
5518   // Try to find the member we are instantiating.
5519   NamedDecl *Instantiation = 0;
5520   NamedDecl *InstantiatedFrom = 0;
5521   MemberSpecializationInfo *MSInfo = 0;
5522
5523   if (Previous.empty()) {
5524     // Nowhere to look anyway.
5525   } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Member)) {
5526     for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
5527            I != E; ++I) {
5528       NamedDecl *D = (*I)->getUnderlyingDecl();
5529       if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
5530         if (Context.hasSameType(Function->getType(), Method->getType())) {
5531           Instantiation = Method;
5532           InstantiatedFrom = Method->getInstantiatedFromMemberFunction();
5533           MSInfo = Method->getMemberSpecializationInfo();
5534           break;
5535         }
5536       }
5537     }
5538   } else if (isa<VarDecl>(Member)) {
5539     VarDecl *PrevVar;
5540     if (Previous.isSingleResult() &&
5541         (PrevVar = dyn_cast<VarDecl>(Previous.getFoundDecl())))
5542       if (PrevVar->isStaticDataMember()) {
5543         Instantiation = PrevVar;
5544         InstantiatedFrom = PrevVar->getInstantiatedFromStaticDataMember();
5545         MSInfo = PrevVar->getMemberSpecializationInfo();
5546       }
5547   } else if (isa<RecordDecl>(Member)) {
5548     CXXRecordDecl *PrevRecord;
5549     if (Previous.isSingleResult() &&
5550         (PrevRecord = dyn_cast<CXXRecordDecl>(Previous.getFoundDecl()))) {
5551       Instantiation = PrevRecord;
5552       InstantiatedFrom = PrevRecord->getInstantiatedFromMemberClass();
5553       MSInfo = PrevRecord->getMemberSpecializationInfo();
5554     }
5555   }
5556
5557   if (!Instantiation) {
5558     // There is no previous declaration that matches. Since member
5559     // specializations are always out-of-line, the caller will complain about
5560     // this mismatch later.
5561     return false;
5562   }
5563
5564   // If this is a friend, just bail out here before we start turning
5565   // things into explicit specializations.
5566   if (Member->getFriendObjectKind() != Decl::FOK_None) {
5567     // Preserve instantiation information.
5568     if (InstantiatedFrom && isa<CXXMethodDecl>(Member)) {
5569       cast<CXXMethodDecl>(Member)->setInstantiationOfMemberFunction(
5570                                       cast<CXXMethodDecl>(InstantiatedFrom),
5571         cast<CXXMethodDecl>(Instantiation)->getTemplateSpecializationKind());
5572     } else if (InstantiatedFrom && isa<CXXRecordDecl>(Member)) {
5573       cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass(
5574                                       cast<CXXRecordDecl>(InstantiatedFrom),
5575         cast<CXXRecordDecl>(Instantiation)->getTemplateSpecializationKind());
5576     }
5577
5578     Previous.clear();
5579     Previous.addDecl(Instantiation);
5580     return false;
5581   }
5582
5583   // Make sure that this is a specialization of a member.
5584   if (!InstantiatedFrom) {
5585     Diag(Member->getLocation(), diag::err_spec_member_not_instantiated)
5586       << Member;
5587     Diag(Instantiation->getLocation(), diag::note_specialized_decl);
5588     return true;
5589   }
5590
5591   // C++ [temp.expl.spec]p6:
5592   //   If a template, a member template or the member of a class template is
5593   //   explicitly specialized then that spe- cialization shall be declared
5594   //   before the first use of that specialization that would cause an implicit
5595   //   instantiation to take place, in every translation unit in which such a
5596   //   use occurs; no diagnostic is required.
5597   assert(MSInfo && "Member specialization info missing?");
5598
5599   bool HasNoEffect = false;
5600   if (CheckSpecializationInstantiationRedecl(Member->getLocation(),
5601                                              TSK_ExplicitSpecialization,
5602                                              Instantiation,
5603                                      MSInfo->getTemplateSpecializationKind(),
5604                                            MSInfo->getPointOfInstantiation(),
5605                                              HasNoEffect))
5606     return true;
5607
5608   // Check the scope of this explicit specialization.
5609   if (CheckTemplateSpecializationScope(*this,
5610                                        InstantiatedFrom,
5611                                        Instantiation, Member->getLocation(),
5612                                        false))
5613     return true;
5614
5615   // Note that this is an explicit instantiation of a member.
5616   // the original declaration to note that it is an explicit specialization
5617   // (if it was previously an implicit instantiation). This latter step
5618   // makes bookkeeping easier.
5619   if (isa<FunctionDecl>(Member)) {
5620     FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation);
5621     if (InstantiationFunction->getTemplateSpecializationKind() ==
5622           TSK_ImplicitInstantiation) {
5623       InstantiationFunction->setTemplateSpecializationKind(
5624                                                   TSK_ExplicitSpecialization);
5625       InstantiationFunction->setLocation(Member->getLocation());
5626     }
5627
5628     cast<FunctionDecl>(Member)->setInstantiationOfMemberFunction(
5629                                         cast<CXXMethodDecl>(InstantiatedFrom),
5630                                                   TSK_ExplicitSpecialization);
5631     MarkUnusedFileScopedDecl(InstantiationFunction);
5632   } else if (isa<VarDecl>(Member)) {
5633     VarDecl *InstantiationVar = cast<VarDecl>(Instantiation);
5634     if (InstantiationVar->getTemplateSpecializationKind() ==
5635           TSK_ImplicitInstantiation) {
5636       InstantiationVar->setTemplateSpecializationKind(
5637                                                   TSK_ExplicitSpecialization);
5638       InstantiationVar->setLocation(Member->getLocation());
5639     }
5640
5641     Context.setInstantiatedFromStaticDataMember(cast<VarDecl>(Member),
5642                                                 cast<VarDecl>(InstantiatedFrom),
5643                                                 TSK_ExplicitSpecialization);
5644     MarkUnusedFileScopedDecl(InstantiationVar);
5645   } else {
5646     assert(isa<CXXRecordDecl>(Member) && "Only member classes remain");
5647     CXXRecordDecl *InstantiationClass = cast<CXXRecordDecl>(Instantiation);
5648     if (InstantiationClass->getTemplateSpecializationKind() ==
5649           TSK_ImplicitInstantiation) {
5650       InstantiationClass->setTemplateSpecializationKind(
5651                                                    TSK_ExplicitSpecialization);
5652       InstantiationClass->setLocation(Member->getLocation());
5653     }
5654
5655     cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass(
5656                                         cast<CXXRecordDecl>(InstantiatedFrom),
5657                                                    TSK_ExplicitSpecialization);
5658   }
5659
5660   // Save the caller the trouble of having to figure out which declaration
5661   // this specialization matches.
5662   Previous.clear();
5663   Previous.addDecl(Instantiation);
5664   return false;
5665 }
5666
5667 /// \brief Check the scope of an explicit instantiation.
5668 ///
5669 /// \returns true if a serious error occurs, false otherwise.
5670 static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D,
5671                                             SourceLocation InstLoc,
5672                                             bool WasQualifiedName) {
5673   DeclContext *OrigContext= D->getDeclContext()->getEnclosingNamespaceContext();
5674   DeclContext *CurContext = S.CurContext->getRedeclContext();
5675
5676   if (CurContext->isRecord()) {
5677     S.Diag(InstLoc, diag::err_explicit_instantiation_in_class)
5678       << D;
5679     return true;
5680   }
5681
5682   // C++0x [temp.explicit]p2:
5683   //   An explicit instantiation shall appear in an enclosing namespace of its
5684   //   template.
5685   //
5686   // This is DR275, which we do not retroactively apply to C++98/03.
5687   if (S.getLangOptions().CPlusPlus0x &&
5688       !CurContext->Encloses(OrigContext)) {
5689     if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext))
5690       S.Diag(InstLoc,
5691              S.getLangOptions().CPlusPlus0x?
5692                  diag::err_explicit_instantiation_out_of_scope
5693                : diag::warn_explicit_instantiation_out_of_scope_0x)
5694         << D << NS;
5695     else
5696       S.Diag(InstLoc,
5697              S.getLangOptions().CPlusPlus0x?
5698                  diag::err_explicit_instantiation_must_be_global
5699                : diag::warn_explicit_instantiation_out_of_scope_0x)
5700         << D;
5701     S.Diag(D->getLocation(), diag::note_explicit_instantiation_here);
5702     return false;
5703   }
5704
5705   // C++0x [temp.explicit]p2:
5706   //   If the name declared in the explicit instantiation is an unqualified
5707   //   name, the explicit instantiation shall appear in the namespace where
5708   //   its template is declared or, if that namespace is inline (7.3.1), any
5709   //   namespace from its enclosing namespace set.
5710   if (WasQualifiedName)
5711     return false;
5712
5713   if (CurContext->InEnclosingNamespaceSetOf(OrigContext))
5714     return false;
5715
5716   S.Diag(InstLoc,
5717          S.getLangOptions().CPlusPlus0x?
5718              diag::err_explicit_instantiation_unqualified_wrong_namespace
5719            : diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)
5720     << D << OrigContext;
5721   S.Diag(D->getLocation(), diag::note_explicit_instantiation_here);
5722   return false;
5723 }
5724
5725 /// \brief Determine whether the given scope specifier has a template-id in it.
5726 static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS) {
5727   if (!SS.isSet())
5728     return false;
5729
5730   // C++0x [temp.explicit]p2:
5731   //   If the explicit instantiation is for a member function, a member class
5732   //   or a static data member of a class template specialization, the name of
5733   //   the class template specialization in the qualified-id for the member
5734   //   name shall be a simple-template-id.
5735   //
5736   // C++98 has the same restriction, just worded differently.
5737   for (NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep();
5738        NNS; NNS = NNS->getPrefix())
5739     if (const Type *T = NNS->getAsType())
5740       if (isa<TemplateSpecializationType>(T))
5741         return true;
5742
5743   return false;
5744 }
5745
5746 // Explicit instantiation of a class template specialization
5747 DeclResult
5748 Sema::ActOnExplicitInstantiation(Scope *S,
5749                                  SourceLocation ExternLoc,
5750                                  SourceLocation TemplateLoc,
5751                                  unsigned TagSpec,
5752                                  SourceLocation KWLoc,
5753                                  const CXXScopeSpec &SS,
5754                                  TemplateTy TemplateD,
5755                                  SourceLocation TemplateNameLoc,
5756                                  SourceLocation LAngleLoc,
5757                                  ASTTemplateArgsPtr TemplateArgsIn,
5758                                  SourceLocation RAngleLoc,
5759                                  AttributeList *Attr) {
5760   // Find the class template we're specializing
5761   TemplateName Name = TemplateD.getAsVal<TemplateName>();
5762   ClassTemplateDecl *ClassTemplate
5763     = cast<ClassTemplateDecl>(Name.getAsTemplateDecl());
5764
5765   // Check that the specialization uses the same tag kind as the
5766   // original template.
5767   TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
5768   assert(Kind != TTK_Enum &&
5769          "Invalid enum tag in class template explicit instantiation!");
5770   if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
5771                                     Kind, /*isDefinition*/false, KWLoc,
5772                                     *ClassTemplate->getIdentifier())) {
5773     Diag(KWLoc, diag::err_use_with_wrong_tag)
5774       << ClassTemplate
5775       << FixItHint::CreateReplacement(KWLoc,
5776                             ClassTemplate->getTemplatedDecl()->getKindName());
5777     Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
5778          diag::note_previous_use);
5779     Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
5780   }
5781
5782   // C++0x [temp.explicit]p2:
5783   //   There are two forms of explicit instantiation: an explicit instantiation
5784   //   definition and an explicit instantiation declaration. An explicit
5785   //   instantiation declaration begins with the extern keyword. [...]
5786   TemplateSpecializationKind TSK
5787     = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
5788                            : TSK_ExplicitInstantiationDeclaration;
5789
5790   // Translate the parser's template argument list in our AST format.
5791   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
5792   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
5793
5794   // Check that the template argument list is well-formed for this
5795   // template.
5796   llvm::SmallVector<TemplateArgument, 4> Converted;
5797   if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
5798                                 TemplateArgs, false, Converted))
5799     return true;
5800
5801   assert((Converted.size() == ClassTemplate->getTemplateParameters()->size()) &&
5802          "Converted template argument list is too short!");
5803
5804   // Find the class template specialization declaration that
5805   // corresponds to these arguments.
5806   void *InsertPos = 0;
5807   ClassTemplateSpecializationDecl *PrevDecl
5808     = ClassTemplate->findSpecialization(Converted.data(),
5809                                         Converted.size(), InsertPos);
5810
5811   TemplateSpecializationKind PrevDecl_TSK
5812     = PrevDecl ? PrevDecl->getTemplateSpecializationKind() : TSK_Undeclared;
5813
5814   // C++0x [temp.explicit]p2:
5815   //   [...] An explicit instantiation shall appear in an enclosing
5816   //   namespace of its template. [...]
5817   //
5818   // This is C++ DR 275.
5819   if (CheckExplicitInstantiationScope(*this, ClassTemplate, TemplateNameLoc,
5820                                       SS.isSet()))
5821     return true;
5822
5823   ClassTemplateSpecializationDecl *Specialization = 0;
5824
5825   bool HasNoEffect = false;
5826   if (PrevDecl) {
5827     if (CheckSpecializationInstantiationRedecl(TemplateNameLoc, TSK,
5828                                                PrevDecl, PrevDecl_TSK,
5829                                             PrevDecl->getPointOfInstantiation(),
5830                                                HasNoEffect))
5831       return PrevDecl;
5832
5833     // Even though HasNoEffect == true means that this explicit instantiation
5834     // has no effect on semantics, we go on to put its syntax in the AST.
5835
5836     if (PrevDecl_TSK == TSK_ImplicitInstantiation ||
5837         PrevDecl_TSK == TSK_Undeclared) {
5838       // Since the only prior class template specialization with these
5839       // arguments was referenced but not declared, reuse that
5840       // declaration node as our own, updating the source location
5841       // for the template name to reflect our new declaration.
5842       // (Other source locations will be updated later.)
5843       Specialization = PrevDecl;
5844       Specialization->setLocation(TemplateNameLoc);
5845       PrevDecl = 0;
5846     }
5847   }
5848
5849   if (!Specialization) {
5850     // Create a new class template specialization declaration node for
5851     // this explicit specialization.
5852     Specialization
5853       = ClassTemplateSpecializationDecl::Create(Context, Kind,
5854                                              ClassTemplate->getDeclContext(),
5855                                                 KWLoc, TemplateNameLoc,
5856                                                 ClassTemplate,
5857                                                 Converted.data(),
5858                                                 Converted.size(),
5859                                                 PrevDecl);
5860     SetNestedNameSpecifier(Specialization, SS);
5861
5862     if (!HasNoEffect && !PrevDecl) {
5863       // Insert the new specialization.
5864       ClassTemplate->AddSpecialization(Specialization, InsertPos);
5865     }
5866   }
5867
5868   // Build the fully-sugared type for this explicit instantiation as
5869   // the user wrote in the explicit instantiation itself. This means
5870   // that we'll pretty-print the type retrieved from the
5871   // specialization's declaration the way that the user actually wrote
5872   // the explicit instantiation, rather than formatting the name based
5873   // on the "canonical" representation used to store the template
5874   // arguments in the specialization.
5875   TypeSourceInfo *WrittenTy
5876     = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
5877                                                 TemplateArgs,
5878                                   Context.getTypeDeclType(Specialization));
5879   Specialization->setTypeAsWritten(WrittenTy);
5880   TemplateArgsIn.release();
5881
5882   // Set source locations for keywords.
5883   Specialization->setExternLoc(ExternLoc);
5884   Specialization->setTemplateKeywordLoc(TemplateLoc);
5885
5886   // Add the explicit instantiation into its lexical context. However,
5887   // since explicit instantiations are never found by name lookup, we
5888   // just put it into the declaration context directly.
5889   Specialization->setLexicalDeclContext(CurContext);
5890   CurContext->addDecl(Specialization);
5891
5892   // Syntax is now OK, so return if it has no other effect on semantics.
5893   if (HasNoEffect) {
5894     // Set the template specialization kind.
5895     Specialization->setTemplateSpecializationKind(TSK);
5896     return Specialization;
5897   }
5898
5899   // C++ [temp.explicit]p3:
5900   //   A definition of a class template or class member template
5901   //   shall be in scope at the point of the explicit instantiation of
5902   //   the class template or class member template.
5903   //
5904   // This check comes when we actually try to perform the
5905   // instantiation.
5906   ClassTemplateSpecializationDecl *Def
5907     = cast_or_null<ClassTemplateSpecializationDecl>(
5908                                               Specialization->getDefinition());
5909   if (!Def)
5910     InstantiateClassTemplateSpecialization(TemplateNameLoc, Specialization, TSK);
5911   else if (TSK == TSK_ExplicitInstantiationDefinition) {
5912     MarkVTableUsed(TemplateNameLoc, Specialization, true);
5913     Specialization->setPointOfInstantiation(Def->getPointOfInstantiation());
5914   }
5915
5916   // Instantiate the members of this class template specialization.
5917   Def = cast_or_null<ClassTemplateSpecializationDecl>(
5918                                        Specialization->getDefinition());
5919   if (Def) {
5920     TemplateSpecializationKind Old_TSK = Def->getTemplateSpecializationKind();
5921
5922     // Fix a TSK_ExplicitInstantiationDeclaration followed by a
5923     // TSK_ExplicitInstantiationDefinition
5924     if (Old_TSK == TSK_ExplicitInstantiationDeclaration &&
5925         TSK == TSK_ExplicitInstantiationDefinition)
5926       Def->setTemplateSpecializationKind(TSK);
5927
5928     InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK);
5929   }
5930
5931   // Set the template specialization kind.
5932   Specialization->setTemplateSpecializationKind(TSK);
5933   return Specialization;
5934 }
5935
5936 // Explicit instantiation of a member class of a class template.
5937 DeclResult
5938 Sema::ActOnExplicitInstantiation(Scope *S,
5939                                  SourceLocation ExternLoc,
5940                                  SourceLocation TemplateLoc,
5941                                  unsigned TagSpec,
5942                                  SourceLocation KWLoc,
5943                                  CXXScopeSpec &SS,
5944                                  IdentifierInfo *Name,
5945                                  SourceLocation NameLoc,
5946                                  AttributeList *Attr) {
5947
5948   bool Owned = false;
5949   bool IsDependent = false;
5950   Decl *TagD = ActOnTag(S, TagSpec, Sema::TUK_Reference,
5951                         KWLoc, SS, Name, NameLoc, Attr, AS_none,
5952                         MultiTemplateParamsArg(*this, 0, 0),
5953                         Owned, IsDependent, false, false,
5954                         TypeResult());
5955   assert(!IsDependent && "explicit instantiation of dependent name not yet handled");
5956
5957   if (!TagD)
5958     return true;
5959
5960   TagDecl *Tag = cast<TagDecl>(TagD);
5961   if (Tag->isEnum()) {
5962     Diag(TemplateLoc, diag::err_explicit_instantiation_enum)
5963       << Context.getTypeDeclType(Tag);
5964     return true;
5965   }
5966
5967   if (Tag->isInvalidDecl())
5968     return true;
5969
5970   CXXRecordDecl *Record = cast<CXXRecordDecl>(Tag);
5971   CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
5972   if (!Pattern) {
5973     Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)
5974       << Context.getTypeDeclType(Record);
5975     Diag(Record->getLocation(), diag::note_nontemplate_decl_here);
5976     return true;
5977   }
5978
5979   // C++0x [temp.explicit]p2:
5980   //   If the explicit instantiation is for a class or member class, the
5981   //   elaborated-type-specifier in the declaration shall include a
5982   //   simple-template-id.
5983   //
5984   // C++98 has the same restriction, just worded differently.
5985   if (!ScopeSpecifierHasTemplateId(SS))
5986     Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)
5987       << Record << SS.getRange();
5988
5989   // C++0x [temp.explicit]p2:
5990   //   There are two forms of explicit instantiation: an explicit instantiation
5991   //   definition and an explicit instantiation declaration. An explicit
5992   //   instantiation declaration begins with the extern keyword. [...]
5993   TemplateSpecializationKind TSK
5994     = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
5995                            : TSK_ExplicitInstantiationDeclaration;
5996
5997   // C++0x [temp.explicit]p2:
5998   //   [...] An explicit instantiation shall appear in an enclosing
5999   //   namespace of its template. [...]
6000   //
6001   // This is C++ DR 275.
6002   CheckExplicitInstantiationScope(*this, Record, NameLoc, true);
6003
6004   // Verify that it is okay to explicitly instantiate here.
6005   CXXRecordDecl *PrevDecl
6006     = cast_or_null<CXXRecordDecl>(Record->getPreviousDeclaration());
6007   if (!PrevDecl && Record->getDefinition())
6008     PrevDecl = Record;
6009   if (PrevDecl) {
6010     MemberSpecializationInfo *MSInfo = PrevDecl->getMemberSpecializationInfo();
6011     bool HasNoEffect = false;
6012     assert(MSInfo && "No member specialization information?");
6013     if (CheckSpecializationInstantiationRedecl(TemplateLoc, TSK,
6014                                                PrevDecl,
6015                                         MSInfo->getTemplateSpecializationKind(),
6016                                              MSInfo->getPointOfInstantiation(),
6017                                                HasNoEffect))
6018       return true;
6019     if (HasNoEffect)
6020       return TagD;
6021   }
6022
6023   CXXRecordDecl *RecordDef
6024     = cast_or_null<CXXRecordDecl>(Record->getDefinition());
6025   if (!RecordDef) {
6026     // C++ [temp.explicit]p3:
6027     //   A definition of a member class of a class template shall be in scope
6028     //   at the point of an explicit instantiation of the member class.
6029     CXXRecordDecl *Def
6030       = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
6031     if (!Def) {
6032       Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
6033         << 0 << Record->getDeclName() << Record->getDeclContext();
6034       Diag(Pattern->getLocation(), diag::note_forward_declaration)
6035         << Pattern;
6036       return true;
6037     } else {
6038       if (InstantiateClass(NameLoc, Record, Def,
6039                            getTemplateInstantiationArgs(Record),
6040                            TSK))
6041         return true;
6042
6043       RecordDef = cast_or_null<CXXRecordDecl>(Record->getDefinition());
6044       if (!RecordDef)
6045         return true;
6046     }
6047   }
6048
6049   // Instantiate all of the members of the class.
6050   InstantiateClassMembers(NameLoc, RecordDef,
6051                           getTemplateInstantiationArgs(Record), TSK);
6052
6053   if (TSK == TSK_ExplicitInstantiationDefinition)
6054     MarkVTableUsed(NameLoc, RecordDef, true);
6055
6056   // FIXME: We don't have any representation for explicit instantiations of
6057   // member classes. Such a representation is not needed for compilation, but it
6058   // should be available for clients that want to see all of the declarations in
6059   // the source code.
6060   return TagD;
6061 }
6062
6063 DeclResult Sema::ActOnExplicitInstantiation(Scope *S,
6064                                             SourceLocation ExternLoc,
6065                                             SourceLocation TemplateLoc,
6066                                             Declarator &D) {
6067   // Explicit instantiations always require a name.
6068   // TODO: check if/when DNInfo should replace Name.
6069   DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
6070   DeclarationName Name = NameInfo.getName();
6071   if (!Name) {
6072     if (!D.isInvalidType())
6073       Diag(D.getDeclSpec().getSourceRange().getBegin(),
6074            diag::err_explicit_instantiation_requires_name)
6075         << D.getDeclSpec().getSourceRange()
6076         << D.getSourceRange();
6077
6078     return true;
6079   }
6080
6081   // The scope passed in may not be a decl scope.  Zip up the scope tree until
6082   // we find one that is.
6083   while ((S->getFlags() & Scope::DeclScope) == 0 ||
6084          (S->getFlags() & Scope::TemplateParamScope) != 0)
6085     S = S->getParent();
6086
6087   // Determine the type of the declaration.
6088   TypeSourceInfo *T = GetTypeForDeclarator(D, S);
6089   QualType R = T->getType();
6090   if (R.isNull())
6091     return true;
6092
6093   // C++ [dcl.stc]p1:
6094   //   A storage-class-specifier shall not be specified in [...] an explicit
6095   //   instantiation (14.7.2) directive.
6096   if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
6097     Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef)
6098       << Name;
6099     return true;
6100   } else if (D.getDeclSpec().getStorageClassSpec()
6101                                                 != DeclSpec::SCS_unspecified) {
6102     // Complain about then remove the storage class specifier.
6103     Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_storage_class)
6104       << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
6105
6106     D.getMutableDeclSpec().ClearStorageClassSpecs();
6107   }
6108
6109   // C++0x [temp.explicit]p1:
6110   //   [...] An explicit instantiation of a function template shall not use the
6111   //   inline or constexpr specifiers.
6112   // Presumably, this also applies to member functions of class templates as
6113   // well.
6114   if (D.getDeclSpec().isInlineSpecified() && getLangOptions().CPlusPlus0x)
6115     Diag(D.getDeclSpec().getInlineSpecLoc(),
6116          diag::err_explicit_instantiation_inline)
6117       <<FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
6118
6119   // FIXME: check for constexpr specifier.
6120
6121   // C++0x [temp.explicit]p2:
6122   //   There are two forms of explicit instantiation: an explicit instantiation
6123   //   definition and an explicit instantiation declaration. An explicit
6124   //   instantiation declaration begins with the extern keyword. [...]
6125   TemplateSpecializationKind TSK
6126     = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
6127                            : TSK_ExplicitInstantiationDeclaration;
6128
6129   LookupResult Previous(*this, NameInfo, LookupOrdinaryName);
6130   LookupParsedName(Previous, S, &D.getCXXScopeSpec());
6131
6132   if (!R->isFunctionType()) {
6133     // C++ [temp.explicit]p1:
6134     //   A [...] static data member of a class template can be explicitly
6135     //   instantiated from the member definition associated with its class
6136     //   template.
6137     if (Previous.isAmbiguous())
6138       return true;
6139
6140     VarDecl *Prev = Previous.getAsSingle<VarDecl>();
6141     if (!Prev || !Prev->isStaticDataMember()) {
6142       // We expect to see a data data member here.
6143       Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)
6144         << Name;
6145       for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
6146            P != PEnd; ++P)
6147         Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
6148       return true;
6149     }
6150
6151     if (!Prev->getInstantiatedFromStaticDataMember()) {
6152       // FIXME: Check for explicit specialization?
6153       Diag(D.getIdentifierLoc(),
6154            diag::err_explicit_instantiation_data_member_not_instantiated)
6155         << Prev;
6156       Diag(Prev->getLocation(), diag::note_explicit_instantiation_here);
6157       // FIXME: Can we provide a note showing where this was declared?
6158       return true;
6159     }
6160
6161     // C++0x [temp.explicit]p2:
6162     //   If the explicit instantiation is for a member function, a member class
6163     //   or a static data member of a class template specialization, the name of
6164     //   the class template specialization in the qualified-id for the member
6165     //   name shall be a simple-template-id.
6166     //
6167     // C++98 has the same restriction, just worded differently.
6168     if (!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()))
6169       Diag(D.getIdentifierLoc(),
6170            diag::ext_explicit_instantiation_without_qualified_id)
6171         << Prev << D.getCXXScopeSpec().getRange();
6172
6173     // Check the scope of this explicit instantiation.
6174     CheckExplicitInstantiationScope(*this, Prev, D.getIdentifierLoc(), true);
6175
6176     // Verify that it is okay to explicitly instantiate here.
6177     MemberSpecializationInfo *MSInfo = Prev->getMemberSpecializationInfo();
6178     assert(MSInfo && "Missing static data member specialization info?");
6179     bool HasNoEffect = false;
6180     if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
6181                                         MSInfo->getTemplateSpecializationKind(),
6182                                               MSInfo->getPointOfInstantiation(),
6183                                                HasNoEffect))
6184       return true;
6185     if (HasNoEffect)
6186       return (Decl*) 0;
6187
6188     // Instantiate static data member.
6189     Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
6190     if (TSK == TSK_ExplicitInstantiationDefinition)
6191       InstantiateStaticDataMemberDefinition(D.getIdentifierLoc(), Prev);
6192
6193     // FIXME: Create an ExplicitInstantiation node?
6194     return (Decl*) 0;
6195   }
6196
6197   // If the declarator is a template-id, translate the parser's template
6198   // argument list into our AST format.
6199   bool HasExplicitTemplateArgs = false;
6200   TemplateArgumentListInfo TemplateArgs;
6201   if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
6202     TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
6203     TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
6204     TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
6205     ASTTemplateArgsPtr TemplateArgsPtr(*this,
6206                                        TemplateId->getTemplateArgs(),
6207                                        TemplateId->NumArgs);
6208     translateTemplateArguments(TemplateArgsPtr, TemplateArgs);
6209     HasExplicitTemplateArgs = true;
6210     TemplateArgsPtr.release();
6211   }
6212
6213   // C++ [temp.explicit]p1:
6214   //   A [...] function [...] can be explicitly instantiated from its template.
6215   //   A member function [...] of a class template can be explicitly
6216   //  instantiated from the member definition associated with its class
6217   //  template.
6218   UnresolvedSet<8> Matches;
6219   for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
6220        P != PEnd; ++P) {
6221     NamedDecl *Prev = *P;
6222     if (!HasExplicitTemplateArgs) {
6223       if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) {
6224         if (Context.hasSameUnqualifiedType(Method->getType(), R)) {
6225           Matches.clear();
6226
6227           Matches.addDecl(Method, P.getAccess());
6228           if (Method->getTemplateSpecializationKind() == TSK_Undeclared)
6229             break;
6230         }
6231       }
6232     }
6233
6234     FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Prev);
6235     if (!FunTmpl)
6236       continue;
6237
6238     TemplateDeductionInfo Info(Context, D.getIdentifierLoc());
6239     FunctionDecl *Specialization = 0;
6240     if (TemplateDeductionResult TDK
6241           = DeduceTemplateArguments(FunTmpl,
6242                                (HasExplicitTemplateArgs ? &TemplateArgs : 0),
6243                                     R, Specialization, Info)) {
6244       // FIXME: Keep track of almost-matches?
6245       (void)TDK;
6246       continue;
6247     }
6248
6249     Matches.addDecl(Specialization, P.getAccess());
6250   }
6251
6252   // Find the most specialized function template specialization.
6253   UnresolvedSetIterator Result
6254     = getMostSpecialized(Matches.begin(), Matches.end(), TPOC_Other, 0,
6255                          D.getIdentifierLoc(),
6256                      PDiag(diag::err_explicit_instantiation_not_known) << Name,
6257                      PDiag(diag::err_explicit_instantiation_ambiguous) << Name,
6258                          PDiag(diag::note_explicit_instantiation_candidate));
6259
6260   if (Result == Matches.end())
6261     return true;
6262
6263   // Ignore access control bits, we don't need them for redeclaration checking.
6264   FunctionDecl *Specialization = cast<FunctionDecl>(*Result);
6265
6266   if (Specialization->getTemplateSpecializationKind() == TSK_Undeclared) {
6267     Diag(D.getIdentifierLoc(),
6268          diag::err_explicit_instantiation_member_function_not_instantiated)
6269       << Specialization
6270       << (Specialization->getTemplateSpecializationKind() ==
6271           TSK_ExplicitSpecialization);
6272     Diag(Specialization->getLocation(), diag::note_explicit_instantiation_here);
6273     return true;
6274   }
6275
6276   FunctionDecl *PrevDecl = Specialization->getPreviousDeclaration();
6277   if (!PrevDecl && Specialization->isThisDeclarationADefinition())
6278     PrevDecl = Specialization;
6279
6280   if (PrevDecl) {
6281     bool HasNoEffect = false;
6282     if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK,
6283                                                PrevDecl,
6284                                      PrevDecl->getTemplateSpecializationKind(),
6285                                           PrevDecl->getPointOfInstantiation(),
6286                                                HasNoEffect))
6287       return true;
6288
6289     // FIXME: We may still want to build some representation of this
6290     // explicit specialization.
6291     if (HasNoEffect)
6292       return (Decl*) 0;
6293   }
6294
6295   Specialization->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
6296
6297   if (TSK == TSK_ExplicitInstantiationDefinition)
6298     InstantiateFunctionDefinition(D.getIdentifierLoc(), Specialization);
6299
6300   // C++0x [temp.explicit]p2:
6301   //   If the explicit instantiation is for a member function, a member class
6302   //   or a static data member of a class template specialization, the name of
6303   //   the class template specialization in the qualified-id for the member
6304   //   name shall be a simple-template-id.
6305   //
6306   // C++98 has the same restriction, just worded differently.
6307   FunctionTemplateDecl *FunTmpl = Specialization->getPrimaryTemplate();
6308   if (D.getName().getKind() != UnqualifiedId::IK_TemplateId && !FunTmpl &&
6309       D.getCXXScopeSpec().isSet() &&
6310       !ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()))
6311     Diag(D.getIdentifierLoc(),
6312          diag::ext_explicit_instantiation_without_qualified_id)
6313     << Specialization << D.getCXXScopeSpec().getRange();
6314
6315   CheckExplicitInstantiationScope(*this,
6316                    FunTmpl? (NamedDecl *)FunTmpl
6317                           : Specialization->getInstantiatedFromMemberFunction(),
6318                                   D.getIdentifierLoc(),
6319                                   D.getCXXScopeSpec().isSet());
6320
6321   // FIXME: Create some kind of ExplicitInstantiationDecl here.
6322   return (Decl*) 0;
6323 }
6324
6325 TypeResult
6326 Sema::ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
6327                         const CXXScopeSpec &SS, IdentifierInfo *Name,
6328                         SourceLocation TagLoc, SourceLocation NameLoc) {
6329   // This has to hold, because SS is expected to be defined.
6330   assert(Name && "Expected a name in a dependent tag");
6331
6332   NestedNameSpecifier *NNS
6333     = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
6334   if (!NNS)
6335     return true;
6336
6337   TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
6338
6339   if (TUK == TUK_Declaration || TUK == TUK_Definition) {
6340     Diag(NameLoc, diag::err_dependent_tag_decl)
6341       << (TUK == TUK_Definition) << Kind << SS.getRange();
6342     return true;
6343   }
6344
6345   // Create the resulting type.
6346   ElaboratedTypeKeyword Kwd = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
6347   QualType Result = Context.getDependentNameType(Kwd, NNS, Name);
6348
6349   // Create type-source location information for this type.
6350   TypeLocBuilder TLB;
6351   DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(Result);
6352   TL.setKeywordLoc(TagLoc);
6353   TL.setQualifierLoc(SS.getWithLocInContext(Context));
6354   TL.setNameLoc(NameLoc);
6355   return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
6356 }
6357
6358 TypeResult
6359 Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
6360                         const CXXScopeSpec &SS, const IdentifierInfo &II,
6361                         SourceLocation IdLoc) {
6362   if (SS.isInvalid())
6363     return true;
6364
6365   if (TypenameLoc.isValid() && S && !S->getTemplateParamParent() &&
6366       !getLangOptions().CPlusPlus0x)
6367     Diag(TypenameLoc, diag::ext_typename_outside_of_template)
6368       << FixItHint::CreateRemoval(TypenameLoc);
6369
6370   NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
6371   QualType T = CheckTypenameType(TypenameLoc.isValid()? ETK_Typename : ETK_None,
6372                                  TypenameLoc, QualifierLoc, II, IdLoc);
6373   if (T.isNull())
6374     return true;
6375
6376   TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
6377   if (isa<DependentNameType>(T)) {
6378     DependentNameTypeLoc TL = cast<DependentNameTypeLoc>(TSI->getTypeLoc());
6379     TL.setKeywordLoc(TypenameLoc);
6380     TL.setQualifierLoc(QualifierLoc);
6381     TL.setNameLoc(IdLoc);
6382   } else {
6383     ElaboratedTypeLoc TL = cast<ElaboratedTypeLoc>(TSI->getTypeLoc());
6384     TL.setKeywordLoc(TypenameLoc);
6385     TL.setQualifierLoc(QualifierLoc);
6386     cast<TypeSpecTypeLoc>(TL.getNamedTypeLoc()).setNameLoc(IdLoc);
6387   }
6388
6389   return CreateParsedType(T, TSI);
6390 }
6391
6392 TypeResult
6393 Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
6394                         const CXXScopeSpec &SS,
6395                         SourceLocation TemplateLoc,
6396                         TemplateTy TemplateIn,
6397                         SourceLocation TemplateNameLoc,
6398                         SourceLocation LAngleLoc,
6399                         ASTTemplateArgsPtr TemplateArgsIn,
6400                         SourceLocation RAngleLoc) {
6401   if (TypenameLoc.isValid() && S && !S->getTemplateParamParent() &&
6402       !getLangOptions().CPlusPlus0x)
6403     Diag(TypenameLoc, diag::ext_typename_outside_of_template)
6404     << FixItHint::CreateRemoval(TypenameLoc);
6405
6406   // Translate the parser's template argument list in our AST format.
6407   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
6408   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
6409
6410   TemplateName Template = TemplateIn.get();
6411   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
6412     // Construct a dependent template specialization type.
6413     assert(DTN && "dependent template has non-dependent name?");
6414     assert(DTN->getQualifier()
6415            == static_cast<NestedNameSpecifier*>(SS.getScopeRep()));
6416     QualType T = Context.getDependentTemplateSpecializationType(ETK_Typename,
6417                                                           DTN->getQualifier(),
6418                                                           DTN->getIdentifier(),
6419                                                                 TemplateArgs);
6420
6421     // Create source-location information for this type.
6422     TypeLocBuilder Builder;
6423     DependentTemplateSpecializationTypeLoc SpecTL
6424     = Builder.push<DependentTemplateSpecializationTypeLoc>(T);
6425     SpecTL.setLAngleLoc(LAngleLoc);
6426     SpecTL.setRAngleLoc(RAngleLoc);
6427     SpecTL.setKeywordLoc(TypenameLoc);
6428     SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
6429     SpecTL.setNameLoc(TemplateNameLoc);
6430     for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
6431       SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
6432     return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
6433   }
6434
6435   QualType T = CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
6436   if (T.isNull())
6437     return true;
6438
6439   // Provide source-location information for the template specialization
6440   // type.
6441   TypeLocBuilder Builder;
6442   TemplateSpecializationTypeLoc SpecTL
6443     = Builder.push<TemplateSpecializationTypeLoc>(T);
6444
6445   // FIXME: No place to set the location of the 'template' keyword!
6446   SpecTL.setLAngleLoc(LAngleLoc);
6447   SpecTL.setRAngleLoc(RAngleLoc);
6448   SpecTL.setTemplateNameLoc(TemplateNameLoc);
6449   for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
6450     SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
6451
6452   T = Context.getElaboratedType(ETK_Typename, SS.getScopeRep(), T);
6453   ElaboratedTypeLoc TL = Builder.push<ElaboratedTypeLoc>(T);
6454   TL.setKeywordLoc(TypenameLoc);
6455   TL.setQualifierLoc(SS.getWithLocInContext(Context));
6456
6457   TypeSourceInfo *TSI = Builder.getTypeSourceInfo(Context, T);
6458   return CreateParsedType(T, TSI);
6459 }
6460
6461
6462 /// \brief Build the type that describes a C++ typename specifier,
6463 /// e.g., "typename T::type".
6464 QualType
6465 Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword,
6466                         SourceLocation KeywordLoc,
6467                         NestedNameSpecifierLoc QualifierLoc,
6468                         const IdentifierInfo &II,
6469                         SourceLocation IILoc) {
6470   CXXScopeSpec SS;
6471   SS.Adopt(QualifierLoc);
6472
6473   DeclContext *Ctx = computeDeclContext(SS);
6474   if (!Ctx) {
6475     // If the nested-name-specifier is dependent and couldn't be
6476     // resolved to a type, build a typename type.
6477     assert(QualifierLoc.getNestedNameSpecifier()->isDependent());
6478     return Context.getDependentNameType(Keyword,
6479                                         QualifierLoc.getNestedNameSpecifier(),
6480                                         &II);
6481   }
6482
6483   // If the nested-name-specifier refers to the current instantiation,
6484   // the "typename" keyword itself is superfluous. In C++03, the
6485   // program is actually ill-formed. However, DR 382 (in C++0x CD1)
6486   // allows such extraneous "typename" keywords, and we retroactively
6487   // apply this DR to C++03 code with only a warning. In any case we continue.
6488
6489   if (RequireCompleteDeclContext(SS, Ctx))
6490     return QualType();
6491
6492   DeclarationName Name(&II);
6493   LookupResult Result(*this, Name, IILoc, LookupOrdinaryName);
6494   LookupQualifiedName(Result, Ctx);
6495   unsigned DiagID = 0;
6496   Decl *Referenced = 0;
6497   switch (Result.getResultKind()) {
6498   case LookupResult::NotFound:
6499     DiagID = diag::err_typename_nested_not_found;
6500     break;
6501
6502   case LookupResult::FoundUnresolvedValue: {
6503     // We found a using declaration that is a value. Most likely, the using
6504     // declaration itself is meant to have the 'typename' keyword.
6505     SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
6506                           IILoc);
6507     Diag(IILoc, diag::err_typename_refers_to_using_value_decl)
6508       << Name << Ctx << FullRange;
6509     if (UnresolvedUsingValueDecl *Using
6510           = dyn_cast<UnresolvedUsingValueDecl>(Result.getRepresentativeDecl())){
6511       SourceLocation Loc = Using->getQualifierLoc().getBeginLoc();
6512       Diag(Loc, diag::note_using_value_decl_missing_typename)
6513         << FixItHint::CreateInsertion(Loc, "typename ");
6514     }
6515   }
6516   // Fall through to create a dependent typename type, from which we can recover
6517   // better.
6518
6519   case LookupResult::NotFoundInCurrentInstantiation:
6520     // Okay, it's a member of an unknown instantiation.
6521     return Context.getDependentNameType(Keyword,
6522                                         QualifierLoc.getNestedNameSpecifier(),
6523                                         &II);
6524
6525   case LookupResult::Found:
6526     if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) {
6527       // We found a type. Build an ElaboratedType, since the
6528       // typename-specifier was just sugar.
6529       return Context.getElaboratedType(ETK_Typename,
6530                                        QualifierLoc.getNestedNameSpecifier(),
6531                                        Context.getTypeDeclType(Type));
6532     }
6533
6534     DiagID = diag::err_typename_nested_not_type;
6535     Referenced = Result.getFoundDecl();
6536     break;
6537
6538
6539     llvm_unreachable("unresolved using decl in non-dependent context");
6540     return QualType();
6541
6542   case LookupResult::FoundOverloaded:
6543     DiagID = diag::err_typename_nested_not_type;
6544     Referenced = *Result.begin();
6545     break;
6546
6547   case LookupResult::Ambiguous:
6548     return QualType();
6549   }
6550
6551   // If we get here, it's because name lookup did not find a
6552   // type. Emit an appropriate diagnostic and return an error.
6553   SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
6554                         IILoc);
6555   Diag(IILoc, DiagID) << FullRange << Name << Ctx;
6556   if (Referenced)
6557     Diag(Referenced->getLocation(), diag::note_typename_refers_here)
6558       << Name;
6559   return QualType();
6560 }
6561
6562 namespace {
6563   // See Sema::RebuildTypeInCurrentInstantiation
6564   class CurrentInstantiationRebuilder
6565     : public TreeTransform<CurrentInstantiationRebuilder> {
6566     SourceLocation Loc;
6567     DeclarationName Entity;
6568
6569   public:
6570     typedef TreeTransform<CurrentInstantiationRebuilder> inherited;
6571
6572     CurrentInstantiationRebuilder(Sema &SemaRef,
6573                                   SourceLocation Loc,
6574                                   DeclarationName Entity)
6575     : TreeTransform<CurrentInstantiationRebuilder>(SemaRef),
6576       Loc(Loc), Entity(Entity) { }
6577
6578     /// \brief Determine whether the given type \p T has already been
6579     /// transformed.
6580     ///
6581     /// For the purposes of type reconstruction, a type has already been
6582     /// transformed if it is NULL or if it is not dependent.
6583     bool AlreadyTransformed(QualType T) {
6584       return T.isNull() || !T->isDependentType();
6585     }
6586
6587     /// \brief Returns the location of the entity whose type is being
6588     /// rebuilt.
6589     SourceLocation getBaseLocation() { return Loc; }
6590
6591     /// \brief Returns the name of the entity whose type is being rebuilt.
6592     DeclarationName getBaseEntity() { return Entity; }
6593
6594     /// \brief Sets the "base" location and entity when that
6595     /// information is known based on another transformation.
6596     void setBase(SourceLocation Loc, DeclarationName Entity) {
6597       this->Loc = Loc;
6598       this->Entity = Entity;
6599     }
6600   };
6601 }
6602
6603 /// \brief Rebuilds a type within the context of the current instantiation.
6604 ///
6605 /// The type \p T is part of the type of an out-of-line member definition of
6606 /// a class template (or class template partial specialization) that was parsed
6607 /// and constructed before we entered the scope of the class template (or
6608 /// partial specialization thereof). This routine will rebuild that type now
6609 /// that we have entered the declarator's scope, which may produce different
6610 /// canonical types, e.g.,
6611 ///
6612 /// \code
6613 /// template<typename T>
6614 /// struct X {
6615 ///   typedef T* pointer;
6616 ///   pointer data();
6617 /// };
6618 ///
6619 /// template<typename T>
6620 /// typename X<T>::pointer X<T>::data() { ... }
6621 /// \endcode
6622 ///
6623 /// Here, the type "typename X<T>::pointer" will be created as a DependentNameType,
6624 /// since we do not know that we can look into X<T> when we parsed the type.
6625 /// This function will rebuild the type, performing the lookup of "pointer"
6626 /// in X<T> and returning an ElaboratedType whose canonical type is the same
6627 /// as the canonical type of T*, allowing the return types of the out-of-line
6628 /// definition and the declaration to match.
6629 TypeSourceInfo *Sema::RebuildTypeInCurrentInstantiation(TypeSourceInfo *T,
6630                                                         SourceLocation Loc,
6631                                                         DeclarationName Name) {
6632   if (!T || !T->getType()->isDependentType())
6633     return T;
6634
6635   CurrentInstantiationRebuilder Rebuilder(*this, Loc, Name);
6636   return Rebuilder.TransformType(T);
6637 }
6638
6639 ExprResult Sema::RebuildExprInCurrentInstantiation(Expr *E) {
6640   CurrentInstantiationRebuilder Rebuilder(*this, E->getExprLoc(),
6641                                           DeclarationName());
6642   return Rebuilder.TransformExpr(E);
6643 }
6644
6645 bool Sema::RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS) {
6646   if (SS.isInvalid())
6647     return true;
6648
6649   NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
6650   CurrentInstantiationRebuilder Rebuilder(*this, SS.getRange().getBegin(),
6651                                           DeclarationName());
6652   NestedNameSpecifierLoc Rebuilt
6653     = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);
6654   if (!Rebuilt)
6655     return true;
6656
6657   SS.Adopt(Rebuilt);
6658   return false;
6659 }
6660
6661 /// \brief Produces a formatted string that describes the binding of
6662 /// template parameters to template arguments.
6663 std::string
6664 Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params,
6665                                       const TemplateArgumentList &Args) {
6666   return getTemplateArgumentBindingsText(Params, Args.data(), Args.size());
6667 }
6668
6669 std::string
6670 Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params,
6671                                       const TemplateArgument *Args,
6672                                       unsigned NumArgs) {
6673   llvm::SmallString<128> Str;
6674   llvm::raw_svector_ostream Out(Str);
6675
6676   if (!Params || Params->size() == 0 || NumArgs == 0)
6677     return std::string();
6678
6679   for (unsigned I = 0, N = Params->size(); I != N; ++I) {
6680     if (I >= NumArgs)
6681       break;
6682
6683     if (I == 0)
6684       Out << "[with ";
6685     else
6686       Out << ", ";
6687
6688     if (const IdentifierInfo *Id = Params->getParam(I)->getIdentifier()) {
6689       Out << Id->getName();
6690     } else {
6691       Out << '$' << I;
6692     }
6693
6694     Out << " = ";
6695     Args[I].print(Context.PrintingPolicy, Out);
6696   }
6697
6698   Out << ']';
6699   return Out.str();
6700 }
6701
6702 void Sema::MarkAsLateParsedTemplate(FunctionDecl *FD, bool Flag) {
6703   if (!FD)
6704     return;
6705   FD->setLateTemplateParsed(Flag);
6706 }
6707
6708 bool Sema::IsInsideALocalClassWithinATemplateFunction() {
6709   DeclContext *DC = CurContext;
6710
6711   while (DC) {
6712     if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(CurContext)) {
6713       const FunctionDecl *FD = RD->isLocalClass();
6714       return (FD && FD->getTemplatedKind() != FunctionDecl::TK_NonTemplate);
6715     } else if (DC->isTranslationUnit() || DC->isNamespace())
6716       return false;
6717
6718     DC = DC->getParent();
6719   }
6720   return false;
6721 }