contrib/llvm/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

   1 //===--- SemaTemplateInstantiateDecl.cpp - C++ Template Decl Instantiation ===/
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //===----------------------------------------------------------------------===/
   8 //
   9 //  This file implements C++ template instantiation for declarations.
  10 //
  11 //===----------------------------------------------------------------------===/
  12 #include "clang/Sema/SemaInternal.h"
  13 #include "clang/Sema/Lookup.h"
  14 #include "clang/Sema/PrettyDeclStackTrace.h"
  15 #include "clang/Sema/Template.h"
  16 #include "clang/AST/ASTConsumer.h"
  17 #include "clang/AST/ASTContext.h"
  18 #include "clang/AST/DeclTemplate.h"
  19 #include "clang/AST/DeclVisitor.h"
  20 #include "clang/AST/DependentDiagnostic.h"
  21 #include "clang/AST/Expr.h"
  22 #include "clang/AST/ExprCXX.h"
  23 #include "clang/AST/TypeLoc.h"
  24 #include "clang/Lex/Preprocessor.h"
  25
  26 using namespace clang;
  27
  28 bool TemplateDeclInstantiator::SubstQualifier(const DeclaratorDecl *OldDecl,
  29                                               DeclaratorDecl *NewDecl) {
  30   if (!OldDecl->getQualifierLoc())
  31     return false;
  32
  33   NestedNameSpecifierLoc NewQualifierLoc
  34     = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
  35                                           TemplateArgs);
  36
  37   if (!NewQualifierLoc)
  38     return true;
  39
  40   NewDecl->setQualifierInfo(NewQualifierLoc);
  41   return false;
  42 }
  43
  44 bool TemplateDeclInstantiator::SubstQualifier(const TagDecl *OldDecl,
  45                                               TagDecl *NewDecl) {
  46   if (!OldDecl->getQualifierLoc())
  47     return false;
  48
  49   NestedNameSpecifierLoc NewQualifierLoc
  50   = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
  51                                         TemplateArgs);
  52
  53   if (!NewQualifierLoc)
  54     return true;
  55
  56   NewDecl->setQualifierInfo(NewQualifierLoc);
  57   return false;
  58 }
  59
  60 // FIXME: Is this still too simple?
  61 void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
  62                             Decl *Tmpl, Decl *New) {
  63   for (AttrVec::const_iterator i = Tmpl->attr_begin(), e = Tmpl->attr_end();
  64        i != e; ++i) {
  65     const Attr *TmplAttr = *i;
  66     // FIXME: This should be generalized to more than just the AlignedAttr.
  67     if (const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr)) {
  68       if (Aligned->isAlignmentDependent()) {
  69         // The alignment expression is not potentially evaluated.
  70         EnterExpressionEvaluationContext Unevaluated(*this,
  71                                                      Sema::Unevaluated);
  72
  73         if (Aligned->isAlignmentExpr()) {
  74           ExprResult Result = SubstExpr(Aligned->getAlignmentExpr(),
  75                                         TemplateArgs);
  76           if (!Result.isInvalid())
  77             AddAlignedAttr(Aligned->getLocation(), New, Result.takeAs<Expr>());
  78         }
  79         else {
  80           TypeSourceInfo *Result = SubstType(Aligned->getAlignmentType(),
  81                                              TemplateArgs,
  82                                              Aligned->getLocation(),
  83                                              DeclarationName());
  84           if (Result)
  85             AddAlignedAttr(Aligned->getLocation(), New, Result);
  86         }
  87         continue;
  88       }
  89     }
  90
  91     // FIXME: Is cloning correct for all attributes?
  92     Attr *NewAttr = TmplAttr->clone(Context);
  93     New->addAttr(NewAttr);
  94   }
  95 }
  96
  97 Decl *
  98 TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
  99   assert(false && "Translation units cannot be instantiated");
 100   return D;
 101 }
 102
 103 Decl *
 104 TemplateDeclInstantiator::VisitLabelDecl(LabelDecl *D) {
 105   LabelDecl *Inst = LabelDecl::Create(SemaRef.Context, Owner, D->getLocation(),
 106                                       D->getIdentifier());
 107   Owner->addDecl(Inst);
 108   return Inst;
 109 }
 110
 111 Decl *
 112 TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) {
 113   assert(false && "Namespaces cannot be instantiated");
 114   return D;
 115 }
 116
 117 Decl *
 118 TemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
 119   NamespaceAliasDecl *Inst
 120     = NamespaceAliasDecl::Create(SemaRef.Context, Owner,
 121                                  D->getNamespaceLoc(),
 122                                  D->getAliasLoc(),
 123                                  D->getIdentifier(),
 124                                  D->getQualifierLoc(),
 125                                  D->getTargetNameLoc(),
 126                                  D->getNamespace());
 127   Owner->addDecl(Inst);
 128   return Inst;
 129 }
 130
 131 Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D,
 132                                                            bool IsTypeAlias) {
 133   bool Invalid = false;
 134   TypeSourceInfo *DI = D->getTypeSourceInfo();
 135   if (DI->getType()->isDependentType() ||
 136       DI->getType()->isVariablyModifiedType()) {
 137     DI = SemaRef.SubstType(DI, TemplateArgs,
 138                            D->getLocation(), D->getDeclName());
 139     if (!DI) {
 140       Invalid = true;
 141       DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
 142     }
 143   } else {
 144     SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
 145   }
 146
 147   // Create the new typedef
 148   TypedefNameDecl *Typedef;
 149   if (IsTypeAlias)
 150     Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
 151                                     D->getLocation(), D->getIdentifier(), DI);
 152   else
 153     Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
 154                                   D->getLocation(), D->getIdentifier(), DI);
 155   if (Invalid)
 156     Typedef->setInvalidDecl();
 157
 158   // If the old typedef was the name for linkage purposes of an anonymous
 159   // tag decl, re-establish that relationship for the new typedef.
 160   if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) {
 161     TagDecl *oldTag = oldTagType->getDecl();
 162     if (oldTag->getTypedefNameForAnonDecl() == D) {
 163       TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl();
 164       assert(!newTag->getIdentifier() && !newTag->getTypedefNameForAnonDecl());
 165       newTag->setTypedefNameForAnonDecl(Typedef);
 166     }
 167   }
 168
 169   if (TypedefNameDecl *Prev = D->getPreviousDeclaration()) {
 170     NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev,
 171                                                        TemplateArgs);
 172     if (!InstPrev)
 173       return 0;
 174
 175     Typedef->setPreviousDeclaration(cast<TypedefNameDecl>(InstPrev));
 176   }
 177
 178   SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef);
 179
 180   Typedef->setAccess(D->getAccess());
 181
 182   return Typedef;
 183 }
 184
 185 Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) {
 186   Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/false);
 187   Owner->addDecl(Typedef);
 188   return Typedef;
 189 }
 190
 191 Decl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) {
 192   Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/true);
 193   Owner->addDecl(Typedef);
 194   return Typedef;
 195 }
 196
 197 Decl *
 198 TemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
 199   // Create a local instantiation scope for this type alias template, which
 200   // will contain the instantiations of the template parameters.
 201   LocalInstantiationScope Scope(SemaRef);
 202
 203   TemplateParameterList *TempParams = D->getTemplateParameters();
 204   TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
 205   if (!InstParams)
 206     return 0;
 207
 208   TypeAliasDecl *Pattern = D->getTemplatedDecl();
 209
 210   TypeAliasTemplateDecl *PrevAliasTemplate = 0;
 211   if (Pattern->getPreviousDeclaration()) {
 212     DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
 213     if (Found.first != Found.second) {
 214       PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(*Found.first);
 215     }
 216   }
 217
 218   TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>(
 219     InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true));
 220   if (!AliasInst)
 221     return 0;
 222
 223   TypeAliasTemplateDecl *Inst
 224     = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(),
 225                                     D->getDeclName(), InstParams, AliasInst);
 226   if (PrevAliasTemplate)
 227     Inst->setPreviousDeclaration(PrevAliasTemplate);
 228
 229   Inst->setAccess(D->getAccess());
 230
 231   if (!PrevAliasTemplate)
 232     Inst->setInstantiatedFromMemberTemplate(D);
 233
 234   Owner->addDecl(Inst);
 235
 236   return Inst;
 237 }
 238
 239 /// \brief Instantiate an initializer, breaking it into separate
 240 /// initialization arguments.
 241 ///
 242 /// \param S The semantic analysis object.
 243 ///
 244 /// \param Init The initializer to instantiate.
 245 ///
 246 /// \param TemplateArgs Template arguments to be substituted into the
 247 /// initializer.
 248 ///
 249 /// \param NewArgs Will be filled in with the instantiation arguments.
 250 ///
 251 /// \returns true if an error occurred, false otherwise
 252 static bool InstantiateInitializer(Sema &S, Expr *Init,
 253                             const MultiLevelTemplateArgumentList &TemplateArgs,
 254                                    SourceLocation &LParenLoc,
 255                                    ASTOwningVector<Expr*> &NewArgs,
 256                                    SourceLocation &RParenLoc) {
 257   NewArgs.clear();
 258   LParenLoc = SourceLocation();
 259   RParenLoc = SourceLocation();
 260
 261   if (!Init)
 262     return false;
 263
 264   if (ExprWithCleanups *ExprTemp = dyn_cast<ExprWithCleanups>(Init))
 265     Init = ExprTemp->getSubExpr();
 266
 267   while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init))
 268     Init = Binder->getSubExpr();
 269
 270   if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init))
 271     Init = ICE->getSubExprAsWritten();
 272
 273   if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
 274     LParenLoc = ParenList->getLParenLoc();
 275     RParenLoc = ParenList->getRParenLoc();
 276     return S.SubstExprs(ParenList->getExprs(), ParenList->getNumExprs(),
 277                         true, TemplateArgs, NewArgs);
 278   }
 279
 280   if (CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init)) {
 281     if (!isa<CXXTemporaryObjectExpr>(Construct)) {
 282       if (S.SubstExprs(Construct->getArgs(), Construct->getNumArgs(), true,
 283                        TemplateArgs, NewArgs))
 284         return true;
 285
 286       // FIXME: Fake locations!
 287       LParenLoc = S.PP.getLocForEndOfToken(Init->getLocStart());
 288       RParenLoc = LParenLoc;
 289       return false;
 290     }
 291   }
 292
 293   ExprResult Result = S.SubstExpr(Init, TemplateArgs);
 294   if (Result.isInvalid())
 295     return true;
 296
 297   NewArgs.push_back(Result.takeAs<Expr>());
 298   return false;
 299 }
 300
 301 Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) {
 302   // If this is the variable for an anonymous struct or union,
 303   // instantiate the anonymous struct/union type first.
 304   if (const RecordType *RecordTy = D->getType()->getAs<RecordType>())
 305     if (RecordTy->getDecl()->isAnonymousStructOrUnion())
 306       if (!VisitCXXRecordDecl(cast<CXXRecordDecl>(RecordTy->getDecl())))
 307         return 0;
 308
 309   // Do substitution on the type of the declaration
 310   TypeSourceInfo *DI = SemaRef.SubstType(D->getTypeSourceInfo(),
 311                                          TemplateArgs,
 312                                          D->getTypeSpecStartLoc(),
 313                                          D->getDeclName());
 314   if (!DI)
 315     return 0;
 316
 317   if (DI->getType()->isFunctionType()) {
 318     SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
 319       << D->isStaticDataMember() << DI->getType();
 320     return 0;
 321   }
 322
 323   // Build the instantiated declaration
 324   VarDecl *Var = VarDecl::Create(SemaRef.Context, Owner,
 325                                  D->getInnerLocStart(),
 326                                  D->getLocation(), D->getIdentifier(),
 327                                  DI->getType(), DI,
 328                                  D->getStorageClass(),
 329                                  D->getStorageClassAsWritten());
 330   Var->setThreadSpecified(D->isThreadSpecified());
 331   Var->setCXXDirectInitializer(D->hasCXXDirectInitializer());
 332   Var->setCXXForRangeDecl(D->isCXXForRangeDecl());
 333
 334   // Substitute the nested name specifier, if any.
 335   if (SubstQualifier(D, Var))
 336     return 0;
 337
 338   // If we are instantiating a static data member defined
 339   // out-of-line, the instantiation will have the same lexical
 340   // context (which will be a namespace scope) as the template.
 341   if (D->isOutOfLine())
 342     Var->setLexicalDeclContext(D->getLexicalDeclContext());
 343
 344   Var->setAccess(D->getAccess());
 345
 346   if (!D->isStaticDataMember()) {
 347     Var->setUsed(D->isUsed(false));
 348     Var->setReferenced(D->isReferenced());
 349   }
 350
 351   // FIXME: In theory, we could have a previous declaration for variables that
 352   // are not static data members.
 353   bool Redeclaration = false;
 354   // FIXME: having to fake up a LookupResult is dumb.
 355   LookupResult Previous(SemaRef, Var->getDeclName(), Var->getLocation(),
 356                         Sema::LookupOrdinaryName, Sema::ForRedeclaration);
 357   if (D->isStaticDataMember())
 358     SemaRef.LookupQualifiedName(Previous, Owner, false);
 359   SemaRef.CheckVariableDeclaration(Var, Previous, Redeclaration);
 360
 361   if (D->isOutOfLine()) {
 362     if (!D->isStaticDataMember())
 363       D->getLexicalDeclContext()->addDecl(Var);
 364     Owner->makeDeclVisibleInContext(Var);
 365   } else {
 366     Owner->addDecl(Var);
 367     if (Owner->isFunctionOrMethod())
 368       SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Var);
 369   }
 370   SemaRef.InstantiateAttrs(TemplateArgs, D, Var);
 371
 372   // Link instantiations of static data members back to the template from
 373   // which they were instantiated.
 374   if (Var->isStaticDataMember())
 375     SemaRef.Context.setInstantiatedFromStaticDataMember(Var, D,
 376                                                      TSK_ImplicitInstantiation);
 377
 378   if (Var->getAnyInitializer()) {
 379     // We already have an initializer in the class.
 380   } else if (D->getInit()) {
 381     if (Var->isStaticDataMember() && !D->isOutOfLine())
 382       SemaRef.PushExpressionEvaluationContext(Sema::Unevaluated);
 383     else
 384       SemaRef.PushExpressionEvaluationContext(Sema::PotentiallyEvaluated);
 385
 386     // Instantiate the initializer.
 387     SourceLocation LParenLoc, RParenLoc;
 388     ASTOwningVector<Expr*> InitArgs(SemaRef);
 389     if (!InstantiateInitializer(SemaRef, D->getInit(), TemplateArgs, LParenLoc,
 390                                 InitArgs, RParenLoc)) {
 391       bool TypeMayContainAuto = true;
 392       // Attach the initializer to the declaration, if we have one.
 393       if (InitArgs.size() == 0)
 394         SemaRef.ActOnUninitializedDecl(Var, TypeMayContainAuto);
 395       else if (D->hasCXXDirectInitializer()) {
 396         // Add the direct initializer to the declaration.
 397         SemaRef.AddCXXDirectInitializerToDecl(Var,
 398                                               LParenLoc,
 399                                               move_arg(InitArgs),
 400                                               RParenLoc,
 401                                               TypeMayContainAuto);
 402       } else {
 403         assert(InitArgs.size() == 1);
 404         Expr *Init = InitArgs.take()[0];
 405         SemaRef.AddInitializerToDecl(Var, Init, false, TypeMayContainAuto);
 406       }
 407     } else {
 408       // FIXME: Not too happy about invalidating the declaration
 409       // because of a bogus initializer.
 410       Var->setInvalidDecl();
 411     }
 412
 413     SemaRef.PopExpressionEvaluationContext();
 414   } else if ((!Var->isStaticDataMember() || Var->isOutOfLine()) &&
 415              !Var->isCXXForRangeDecl())
 416     SemaRef.ActOnUninitializedDecl(Var, false);
 417
 418   // Diagnose unused local variables.
 419   if (!Var->isInvalidDecl() && Owner->isFunctionOrMethod() && !Var->isUsed())
 420     SemaRef.DiagnoseUnusedDecl(Var);
 421
 422   return Var;
 423 }
 424
 425 Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) {
 426   AccessSpecDecl* AD
 427     = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner,
 428                              D->getAccessSpecifierLoc(), D->getColonLoc());
 429   Owner->addHiddenDecl(AD);
 430   return AD;
 431 }
 432
 433 Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
 434   bool Invalid = false;
 435   TypeSourceInfo *DI = D->getTypeSourceInfo();
 436   if (DI->getType()->isDependentType() ||
 437       DI->getType()->isVariablyModifiedType())  {
 438     DI = SemaRef.SubstType(DI, TemplateArgs,
 439                            D->getLocation(), D->getDeclName());
 440     if (!DI) {
 441       DI = D->getTypeSourceInfo();
 442       Invalid = true;
 443     } else if (DI->getType()->isFunctionType()) {
 444       // C++ [temp.arg.type]p3:
 445       //   If a declaration acquires a function type through a type
 446       //   dependent on a template-parameter and this causes a
 447       //   declaration that does not use the syntactic form of a
 448       //   function declarator to have function type, the program is
 449       //   ill-formed.
 450       SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
 451         << DI->getType();
 452       Invalid = true;
 453     }
 454   } else {
 455     SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
 456   }
 457
 458   Expr *BitWidth = D->getBitWidth();
 459   if (Invalid)
 460     BitWidth = 0;
 461   else if (BitWidth) {
 462     // The bit-width expression is not potentially evaluated.
 463     EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
 464
 465     ExprResult InstantiatedBitWidth
 466       = SemaRef.SubstExpr(BitWidth, TemplateArgs);
 467     if (InstantiatedBitWidth.isInvalid()) {
 468       Invalid = true;
 469       BitWidth = 0;
 470     } else
 471       BitWidth = InstantiatedBitWidth.takeAs<Expr>();
 472   }
 473
 474   FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(),
 475                                             DI->getType(), DI,
 476                                             cast<RecordDecl>(Owner),
 477                                             D->getLocation(),
 478                                             D->isMutable(),
 479                                             BitWidth,
 480                                             D->hasInClassInitializer(),
 481                                             D->getTypeSpecStartLoc(),
 482                                             D->getAccess(),
 483                                             0);
 484   if (!Field) {
 485     cast<Decl>(Owner)->setInvalidDecl();
 486     return 0;
 487   }
 488
 489   SemaRef.InstantiateAttrs(TemplateArgs, D, Field);
 490
 491   if (Invalid)
 492     Field->setInvalidDecl();
 493
 494   if (!Field->getDeclName()) {
 495     // Keep track of where this decl came from.
 496     SemaRef.Context.setInstantiatedFromUnnamedFieldDecl(Field, D);
 497   }
 498   if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) {
 499     if (Parent->isAnonymousStructOrUnion() &&
 500         Parent->getRedeclContext()->isFunctionOrMethod())
 501       SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field);
 502   }
 503
 504   Field->setImplicit(D->isImplicit());
 505   Field->setAccess(D->getAccess());
 506   Owner->addDecl(Field);
 507
 508   return Field;
 509 }
 510
 511 Decl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
 512   NamedDecl **NamedChain =
 513     new (SemaRef.Context)NamedDecl*[D->getChainingSize()];
 514
 515   int i = 0;
 516   for (IndirectFieldDecl::chain_iterator PI =
 517        D->chain_begin(), PE = D->chain_end();
 518        PI != PE; ++PI) {
 519     NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), *PI,
 520                                               TemplateArgs);
 521     if (!Next)
 522       return 0;
 523
 524     NamedChain[i++] = Next;
 525   }
 526
 527   QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
 528   IndirectFieldDecl* IndirectField
 529     = IndirectFieldDecl::Create(SemaRef.Context, Owner, D->getLocation(),
 530                                 D->getIdentifier(), T,
 531                                 NamedChain, D->getChainingSize());
 532
 533
 534   IndirectField->setImplicit(D->isImplicit());
 535   IndirectField->setAccess(D->getAccess());
 536   Owner->addDecl(IndirectField);
 537   return IndirectField;
 538 }
 539
 540 Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) {
 541   // Handle friend type expressions by simply substituting template
 542   // parameters into the pattern type and checking the result.
 543   if (TypeSourceInfo *Ty = D->getFriendType()) {
 544     TypeSourceInfo *InstTy;
 545     // If this is an unsupported friend, don't bother substituting template
 546     // arguments into it. The actual type referred to won't be used by any
 547     // parts of Clang, and may not be valid for instantiating. Just use the
 548     // same info for the instantiated friend.
 549     if (D->isUnsupportedFriend()) {
 550       InstTy = Ty;
 551     } else {
 552       InstTy = SemaRef.SubstType(Ty, TemplateArgs,
 553                                  D->getLocation(), DeclarationName());
 554     }
 555     if (!InstTy)
 556       return 0;
 557
 558     FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getFriendLoc(), InstTy);
 559     if (!FD)
 560       return 0;
 561
 562     FD->setAccess(AS_public);
 563     FD->setUnsupportedFriend(D->isUnsupportedFriend());
 564     Owner->addDecl(FD);
 565     return FD;
 566   }
 567
 568   NamedDecl *ND = D->getFriendDecl();
 569   assert(ND && "friend decl must be a decl or a type!");
 570
 571   // All of the Visit implementations for the various potential friend
 572   // declarations have to be carefully written to work for friend
 573   // objects, with the most important detail being that the target
 574   // decl should almost certainly not be placed in Owner.
 575   Decl *NewND = Visit(ND);
 576   if (!NewND) return 0;
 577
 578   FriendDecl *FD =
 579     FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(),
 580                        cast<NamedDecl>(NewND), D->getFriendLoc());
 581   FD->setAccess(AS_public);
 582   FD->setUnsupportedFriend(D->isUnsupportedFriend());
 583   Owner->addDecl(FD);
 584   return FD;
 585 }
 586
 587 Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) {
 588   Expr *AssertExpr = D->getAssertExpr();
 589
 590   // The expression in a static assertion is not potentially evaluated.
 591   EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
 592
 593   ExprResult InstantiatedAssertExpr
 594     = SemaRef.SubstExpr(AssertExpr, TemplateArgs);
 595   if (InstantiatedAssertExpr.isInvalid())
 596     return 0;
 597
 598   ExprResult Message(D->getMessage());
 599   D->getMessage();
 600   return SemaRef.ActOnStaticAssertDeclaration(D->getLocation(),
 601                                               InstantiatedAssertExpr.get(),
 602                                               Message.get(),
 603                                               D->getRParenLoc());
 604 }
 605
 606 Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) {
 607   EnumDecl *Enum = EnumDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
 608                                     D->getLocation(), D->getIdentifier(),
 609                                     /*PrevDecl=*/0, D->isScoped(),
 610                                     D->isScopedUsingClassTag(), D->isFixed());
 611   if (D->isFixed()) {
 612     if (TypeSourceInfo* TI = D->getIntegerTypeSourceInfo()) {
 613       // If we have type source information for the underlying type, it means it
 614       // has been explicitly set by the user. Perform substitution on it before
 615       // moving on.
 616       SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
 617       Enum->setIntegerTypeSourceInfo(SemaRef.SubstType(TI,
 618                                                        TemplateArgs,
 619                                                        UnderlyingLoc,
 620                                                        DeclarationName()));
 621
 622       if (!Enum->getIntegerTypeSourceInfo())
 623         Enum->setIntegerType(SemaRef.Context.IntTy);
 624     }
 625     else {
 626       assert(!D->getIntegerType()->isDependentType()
 627              && "Dependent type without type source info");
 628       Enum->setIntegerType(D->getIntegerType());
 629     }
 630   }
 631
 632   SemaRef.InstantiateAttrs(TemplateArgs, D, Enum);
 633
 634   Enum->setInstantiationOfMemberEnum(D);
 635   Enum->setAccess(D->getAccess());
 636   if (SubstQualifier(D, Enum)) return 0;
 637   Owner->addDecl(Enum);
 638   Enum->startDefinition();
 639
 640   if (D->getDeclContext()->isFunctionOrMethod())
 641     SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Enum);
 642
 643   llvm::SmallVector<Decl*, 4> Enumerators;
 644
 645   EnumConstantDecl *LastEnumConst = 0;
 646   for (EnumDecl::enumerator_iterator EC = D->enumerator_begin(),
 647          ECEnd = D->enumerator_end();
 648        EC != ECEnd; ++EC) {
 649     // The specified value for the enumerator.
 650     ExprResult Value = SemaRef.Owned((Expr *)0);
 651     if (Expr *UninstValue = EC->getInitExpr()) {
 652       // The enumerator's value expression is not potentially evaluated.
 653       EnterExpressionEvaluationContext Unevaluated(SemaRef,
 654                                                    Sema::Unevaluated);
 655
 656       Value = SemaRef.SubstExpr(UninstValue, TemplateArgs);
 657     }
 658
 659     // Drop the initial value and continue.
 660     bool isInvalid = false;
 661     if (Value.isInvalid()) {
 662       Value = SemaRef.Owned((Expr *)0);
 663       isInvalid = true;
 664     }
 665
 666     EnumConstantDecl *EnumConst
 667       = SemaRef.CheckEnumConstant(Enum, LastEnumConst,
 668                                   EC->getLocation(), EC->getIdentifier(),
 669                                   Value.get());
 670
 671     if (isInvalid) {
 672       if (EnumConst)
 673         EnumConst->setInvalidDecl();
 674       Enum->setInvalidDecl();
 675     }
 676
 677     if (EnumConst) {
 678       SemaRef.InstantiateAttrs(TemplateArgs, *EC, EnumConst);
 679
 680       EnumConst->setAccess(Enum->getAccess());
 681       Enum->addDecl(EnumConst);
 682       Enumerators.push_back(EnumConst);
 683       LastEnumConst = EnumConst;
 684
 685       if (D->getDeclContext()->isFunctionOrMethod()) {
 686         // If the enumeration is within a function or method, record the enum
 687         // constant as a local.
 688         SemaRef.CurrentInstantiationScope->InstantiatedLocal(*EC, EnumConst);
 689       }
 690     }
 691   }
 692
 693   // FIXME: Fixup LBraceLoc and RBraceLoc
 694   // FIXME: Empty Scope and AttributeList (required to handle attribute packed).
 695   SemaRef.ActOnEnumBody(Enum->getLocation(), SourceLocation(), SourceLocation(),
 696                         Enum,
 697                         Enumerators.data(), Enumerators.size(),
 698                         0, 0);
 699
 700   return Enum;
 701 }
 702
 703 Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) {
 704   assert(false && "EnumConstantDecls can only occur within EnumDecls.");
 705   return 0;
 706 }
 707
 708 Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
 709   bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
 710
 711   // Create a local instantiation scope for this class template, which
 712   // will contain the instantiations of the template parameters.
 713   LocalInstantiationScope Scope(SemaRef);
 714   TemplateParameterList *TempParams = D->getTemplateParameters();
 715   TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
 716   if (!InstParams)
 717     return NULL;
 718
 719   CXXRecordDecl *Pattern = D->getTemplatedDecl();
 720
 721   // Instantiate the qualifier.  We have to do this first in case
 722   // we're a friend declaration, because if we are then we need to put
 723   // the new declaration in the appropriate context.
 724   NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
 725   if (QualifierLoc) {
 726     QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
 727                                                        TemplateArgs);
 728     if (!QualifierLoc)
 729       return 0;
 730   }
 731
 732   CXXRecordDecl *PrevDecl = 0;
 733   ClassTemplateDecl *PrevClassTemplate = 0;
 734
 735   if (!isFriend && Pattern->getPreviousDeclaration()) {
 736     DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
 737     if (Found.first != Found.second) {
 738       PrevClassTemplate = dyn_cast<ClassTemplateDecl>(*Found.first);
 739       if (PrevClassTemplate)
 740         PrevDecl = PrevClassTemplate->getTemplatedDecl();
 741     }
 742   }
 743
 744   // If this isn't a friend, then it's a member template, in which
 745   // case we just want to build the instantiation in the
 746   // specialization.  If it is a friend, we want to build it in
 747   // the appropriate context.
 748   DeclContext *DC = Owner;
 749   if (isFriend) {
 750     if (QualifierLoc) {
 751       CXXScopeSpec SS;
 752       SS.Adopt(QualifierLoc);
 753       DC = SemaRef.computeDeclContext(SS);
 754       if (!DC) return 0;
 755     } else {
 756       DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(),
 757                                            Pattern->getDeclContext(),
 758                                            TemplateArgs);
 759     }
 760
 761     // Look for a previous declaration of the template in the owning
 762     // context.
 763     LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(),
 764                    Sema::LookupOrdinaryName, Sema::ForRedeclaration);
 765     SemaRef.LookupQualifiedName(R, DC);
 766
 767     if (R.isSingleResult()) {
 768       PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>();
 769       if (PrevClassTemplate)
 770         PrevDecl = PrevClassTemplate->getTemplatedDecl();
 771     }
 772
 773     if (!PrevClassTemplate && QualifierLoc) {
 774       SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope)
 775         << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC
 776         << QualifierLoc.getSourceRange();
 777       return 0;
 778     }
 779
 780     bool AdoptedPreviousTemplateParams = false;
 781     if (PrevClassTemplate) {
 782       bool Complain = true;
 783
 784       // HACK: libstdc++ 4.2.1 contains an ill-formed friend class
 785       // template for struct std::tr1::__detail::_Map_base, where the
 786       // template parameters of the friend declaration don't match the
 787       // template parameters of the original declaration. In this one
 788       // case, we don't complain about the ill-formed friend
 789       // declaration.
 790       if (isFriend && Pattern->getIdentifier() &&
 791           Pattern->getIdentifier()->isStr("_Map_base") &&
 792           DC->isNamespace() &&
 793           cast<NamespaceDecl>(DC)->getIdentifier() &&
 794           cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__detail")) {
 795         DeclContext *DCParent = DC->getParent();
 796         if (DCParent->isNamespace() &&
 797             cast<NamespaceDecl>(DCParent)->getIdentifier() &&
 798             cast<NamespaceDecl>(DCParent)->getIdentifier()->isStr("tr1")) {
 799           DeclContext *DCParent2 = DCParent->getParent();
 800           if (DCParent2->isNamespace() &&
 801               cast<NamespaceDecl>(DCParent2)->getIdentifier() &&
 802               cast<NamespaceDecl>(DCParent2)->getIdentifier()->isStr("std") &&
 803               DCParent2->getParent()->isTranslationUnit())
 804             Complain = false;
 805         }
 806       }
 807
 808       TemplateParameterList *PrevParams
 809         = PrevClassTemplate->getTemplateParameters();
 810
 811       // Make sure the parameter lists match.
 812       if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams,
 813                                                   Complain,
 814                                                   Sema::TPL_TemplateMatch)) {
 815         if (Complain)
 816           return 0;
 817
 818         AdoptedPreviousTemplateParams = true;
 819         InstParams = PrevParams;
 820       }
 821
 822       // Do some additional validation, then merge default arguments
 823       // from the existing declarations.
 824       if (!AdoptedPreviousTemplateParams &&
 825           SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
 826                                              Sema::TPC_ClassTemplate))
 827         return 0;
 828     }
 829   }
 830
 831   CXXRecordDecl *RecordInst
 832     = CXXRecordDecl::Create(SemaRef.Context, Pattern->getTagKind(), DC,
 833                             Pattern->getLocStart(), Pattern->getLocation(),
 834                             Pattern->getIdentifier(), PrevDecl,
 835                             /*DelayTypeCreation=*/true);
 836
 837   if (QualifierLoc)
 838     RecordInst->setQualifierInfo(QualifierLoc);
 839
 840   ClassTemplateDecl *Inst
 841     = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
 842                                 D->getIdentifier(), InstParams, RecordInst,
 843                                 PrevClassTemplate);
 844   RecordInst->setDescribedClassTemplate(Inst);
 845
 846   if (isFriend) {
 847     if (PrevClassTemplate)
 848       Inst->setAccess(PrevClassTemplate->getAccess());
 849     else
 850       Inst->setAccess(D->getAccess());
 851
 852     Inst->setObjectOfFriendDecl(PrevClassTemplate != 0);
 853     // TODO: do we want to track the instantiation progeny of this
 854     // friend target decl?
 855   } else {
 856     Inst->setAccess(D->getAccess());
 857     if (!PrevClassTemplate)
 858       Inst->setInstantiatedFromMemberTemplate(D);
 859   }
 860
 861   // Trigger creation of the type for the instantiation.
 862   SemaRef.Context.getInjectedClassNameType(RecordInst,
 863                                     Inst->getInjectedClassNameSpecialization());
 864
 865   // Finish handling of friends.
 866   if (isFriend) {
 867     DC->makeDeclVisibleInContext(Inst, /*Recoverable*/ false);
 868     return Inst;
 869   }
 870
 871   Owner->addDecl(Inst);
 872
 873   if (!PrevClassTemplate) {
 874     // Queue up any out-of-line partial specializations of this member
 875     // class template; the client will force their instantiation once
 876     // the enclosing class has been instantiated.
 877     llvm::SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
 878     D->getPartialSpecializations(PartialSpecs);
 879     for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
 880       if (PartialSpecs[I]->isOutOfLine())
 881         OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
 882   }
 883
 884   return Inst;
 885 }
 886
 887 Decl *
 888 TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
 889                                    ClassTemplatePartialSpecializationDecl *D) {
 890   ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
 891
 892   // Lookup the already-instantiated declaration in the instantiation
 893   // of the class template and return that.
 894   DeclContext::lookup_result Found
 895     = Owner->lookup(ClassTemplate->getDeclName());
 896   if (Found.first == Found.second)
 897     return 0;
 898
 899   ClassTemplateDecl *InstClassTemplate
 900     = dyn_cast<ClassTemplateDecl>(*Found.first);
 901   if (!InstClassTemplate)
 902     return 0;
 903
 904   if (ClassTemplatePartialSpecializationDecl *Result
 905         = InstClassTemplate->findPartialSpecInstantiatedFromMember(D))
 906     return Result;
 907
 908   return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D);
 909 }
 910
 911 Decl *
 912 TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
 913   // Create a local instantiation scope for this function template, which
 914   // will contain the instantiations of the template parameters and then get
 915   // merged with the local instantiation scope for the function template
 916   // itself.
 917   LocalInstantiationScope Scope(SemaRef);
 918
 919   TemplateParameterList *TempParams = D->getTemplateParameters();
 920   TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
 921   if (!InstParams)
 922     return NULL;
 923
 924   FunctionDecl *Instantiated = 0;
 925   if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl()))
 926     Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod,
 927                                                                  InstParams));
 928   else
 929     Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl(
 930                                                           D->getTemplatedDecl(),
 931                                                                 InstParams));
 932
 933   if (!Instantiated)
 934     return 0;
 935
 936   Instantiated->setAccess(D->getAccess());
 937
 938   // Link the instantiated function template declaration to the function
 939   // template from which it was instantiated.
 940   FunctionTemplateDecl *InstTemplate
 941     = Instantiated->getDescribedFunctionTemplate();
 942   InstTemplate->setAccess(D->getAccess());
 943   assert(InstTemplate &&
 944          "VisitFunctionDecl/CXXMethodDecl didn't create a template!");
 945
 946   bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None);
 947
 948   // Link the instantiation back to the pattern *unless* this is a
 949   // non-definition friend declaration.
 950   if (!InstTemplate->getInstantiatedFromMemberTemplate() &&
 951       !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition()))
 952     InstTemplate->setInstantiatedFromMemberTemplate(D);
 953
 954   // Make declarations visible in the appropriate context.
 955   if (!isFriend)
 956     Owner->addDecl(InstTemplate);
 957
 958   return InstTemplate;
 959 }
 960
 961 Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) {
 962   CXXRecordDecl *PrevDecl = 0;
 963   if (D->isInjectedClassName())
 964     PrevDecl = cast<CXXRecordDecl>(Owner);
 965   else if (D->getPreviousDeclaration()) {
 966     NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
 967                                                    D->getPreviousDeclaration(),
 968                                                    TemplateArgs);
 969     if (!Prev) return 0;
 970     PrevDecl = cast<CXXRecordDecl>(Prev);
 971   }
 972
 973   CXXRecordDecl *Record
 974     = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner,
 975                             D->getLocStart(), D->getLocation(),
 976                             D->getIdentifier(), PrevDecl);
 977
 978   // Substitute the nested name specifier, if any.
 979   if (SubstQualifier(D, Record))
 980     return 0;
 981
 982   Record->setImplicit(D->isImplicit());
 983   // FIXME: Check against AS_none is an ugly hack to work around the issue that
 984   // the tag decls introduced by friend class declarations don't have an access
 985   // specifier. Remove once this area of the code gets sorted out.
 986   if (D->getAccess() != AS_none)
 987     Record->setAccess(D->getAccess());
 988   if (!D->isInjectedClassName())
 989     Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
 990
 991   // If the original function was part of a friend declaration,
 992   // inherit its namespace state.
 993   if (Decl::FriendObjectKind FOK = D->getFriendObjectKind())
 994     Record->setObjectOfFriendDecl(FOK == Decl::FOK_Declared);
 995
 996   // Make sure that anonymous structs and unions are recorded.
 997   if (D->isAnonymousStructOrUnion()) {
 998     Record->setAnonymousStructOrUnion(true);
 999     if (Record->getDeclContext()->getRedeclContext()->isFunctionOrMethod())
1000       SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record);
1001   }
1002
1003   Owner->addDecl(Record);
1004   return Record;
1005 }
1006
1007 /// Normal class members are of more specific types and therefore
1008 /// don't make it here.  This function serves two purposes:
1009 ///   1) instantiating function templates
1010 ///   2) substituting friend declarations
1011 /// FIXME: preserve function definitions in case #2
1012 Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D,
1013                                        TemplateParameterList *TemplateParams) {
1014   // Check whether there is already a function template specialization for
1015   // this declaration.
1016   FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1017   void *InsertPos = 0;
1018   if (FunctionTemplate && !TemplateParams) {
1019     std::pair<const TemplateArgument *, unsigned> Innermost
1020       = TemplateArgs.getInnermost();
1021
1022     FunctionDecl *SpecFunc
1023       = FunctionTemplate->findSpecialization(Innermost.first, Innermost.second,
1024                                              InsertPos);
1025
1026     // If we already have a function template specialization, return it.
1027     if (SpecFunc)
1028       return SpecFunc;
1029   }
1030
1031   bool isFriend;
1032   if (FunctionTemplate)
1033     isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1034   else
1035     isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1036
1037   bool MergeWithParentScope = (TemplateParams != 0) ||
1038     Owner->isFunctionOrMethod() ||
1039     !(isa<Decl>(Owner) &&
1040       cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1041   LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1042
1043   llvm::SmallVector<ParmVarDecl *, 4> Params;
1044   TypeSourceInfo *TInfo = D->getTypeSourceInfo();
1045   TInfo = SubstFunctionType(D, Params);
1046   if (!TInfo)
1047     return 0;
1048   QualType T = TInfo->getType();
1049
1050   NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1051   if (QualifierLoc) {
1052     QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1053                                                        TemplateArgs);
1054     if (!QualifierLoc)
1055       return 0;
1056   }
1057
1058   // If we're instantiating a local function declaration, put the result
1059   // in the owner;  otherwise we need to find the instantiated context.
1060   DeclContext *DC;
1061   if (D->getDeclContext()->isFunctionOrMethod())
1062     DC = Owner;
1063   else if (isFriend && QualifierLoc) {
1064     CXXScopeSpec SS;
1065     SS.Adopt(QualifierLoc);
1066     DC = SemaRef.computeDeclContext(SS);
1067     if (!DC) return 0;
1068   } else {
1069     DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
1070                                          TemplateArgs);
1071   }
1072
1073   FunctionDecl *Function =
1074       FunctionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
1075                            D->getLocation(), D->getDeclName(), T, TInfo,
1076                            D->getStorageClass(), D->getStorageClassAsWritten(),
1077                            D->isInlineSpecified(), D->hasWrittenPrototype());
1078
1079   if (QualifierLoc)
1080     Function->setQualifierInfo(QualifierLoc);
1081
1082   DeclContext *LexicalDC = Owner;
1083   if (!isFriend && D->isOutOfLine()) {
1084     assert(D->getDeclContext()->isFileContext());
1085     LexicalDC = D->getDeclContext();
1086   }
1087
1088   Function->setLexicalDeclContext(LexicalDC);
1089
1090   // Attach the parameters
1091   for (unsigned P = 0; P < Params.size(); ++P)
1092     if (Params[P])
1093       Params[P]->setOwningFunction(Function);
1094   Function->setParams(Params.data(), Params.size());
1095
1096   SourceLocation InstantiateAtPOI;
1097   if (TemplateParams) {
1098     // Our resulting instantiation is actually a function template, since we
1099     // are substituting only the outer template parameters. For example, given
1100     //
1101     //   template<typename T>
1102     //   struct X {
1103     //     template<typename U> friend void f(T, U);
1104     //   };
1105     //
1106     //   X<int> x;
1107     //
1108     // We are instantiating the friend function template "f" within X<int>,
1109     // which means substituting int for T, but leaving "f" as a friend function
1110     // template.
1111     // Build the function template itself.
1112     FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC,
1113                                                     Function->getLocation(),
1114                                                     Function->getDeclName(),
1115                                                     TemplateParams, Function);
1116     Function->setDescribedFunctionTemplate(FunctionTemplate);
1117
1118     FunctionTemplate->setLexicalDeclContext(LexicalDC);
1119
1120     if (isFriend && D->isThisDeclarationADefinition()) {
1121       // TODO: should we remember this connection regardless of whether
1122       // the friend declaration provided a body?
1123       FunctionTemplate->setInstantiatedFromMemberTemplate(
1124                                            D->getDescribedFunctionTemplate());
1125     }
1126   } else if (FunctionTemplate) {
1127     // Record this function template specialization.
1128     std::pair<const TemplateArgument *, unsigned> Innermost
1129       = TemplateArgs.getInnermost();
1130     Function->setFunctionTemplateSpecialization(FunctionTemplate,
1131                             TemplateArgumentList::CreateCopy(SemaRef.Context,
1132                                                              Innermost.first,
1133                                                              Innermost.second),
1134                                                 InsertPos);
1135   } else if (isFriend && D->isThisDeclarationADefinition()) {
1136     // TODO: should we remember this connection regardless of whether
1137     // the friend declaration provided a body?
1138     Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
1139   }
1140
1141   if (InitFunctionInstantiation(Function, D))
1142     Function->setInvalidDecl();
1143
1144   bool Redeclaration = false;
1145   bool isExplicitSpecialization = false;
1146
1147   LookupResult Previous(SemaRef, Function->getDeclName(), SourceLocation(),
1148                         Sema::LookupOrdinaryName, Sema::ForRedeclaration);
1149
1150   if (DependentFunctionTemplateSpecializationInfo *Info
1151         = D->getDependentSpecializationInfo()) {
1152     assert(isFriend && "non-friend has dependent specialization info?");
1153
1154     // This needs to be set now for future sanity.
1155     Function->setObjectOfFriendDecl(/*HasPrevious*/ true);
1156
1157     // Instantiate the explicit template arguments.
1158     TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
1159                                           Info->getRAngleLoc());
1160     if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
1161                       ExplicitArgs, TemplateArgs))
1162       return 0;
1163
1164     // Map the candidate templates to their instantiations.
1165     for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
1166       Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
1167                                                 Info->getTemplate(I),
1168                                                 TemplateArgs);
1169       if (!Temp) return 0;
1170
1171       Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
1172     }
1173
1174     if (SemaRef.CheckFunctionTemplateSpecialization(Function,
1175                                                     &ExplicitArgs,
1176                                                     Previous))
1177       Function->setInvalidDecl();
1178
1179     isExplicitSpecialization = true;
1180
1181   } else if (TemplateParams || !FunctionTemplate) {
1182     // Look only into the namespace where the friend would be declared to
1183     // find a previous declaration. This is the innermost enclosing namespace,
1184     // as described in ActOnFriendFunctionDecl.
1185     SemaRef.LookupQualifiedName(Previous, DC);
1186
1187     // In C++, the previous declaration we find might be a tag type
1188     // (class or enum). In this case, the new declaration will hide the
1189     // tag type. Note that this does does not apply if we're declaring a
1190     // typedef (C++ [dcl.typedef]p4).
1191     if (Previous.isSingleTagDecl())
1192       Previous.clear();
1193   }
1194
1195   SemaRef.CheckFunctionDeclaration(/*Scope*/ 0, Function, Previous,
1196                                    isExplicitSpecialization, Redeclaration);
1197
1198   NamedDecl *PrincipalDecl = (TemplateParams
1199                               ? cast<NamedDecl>(FunctionTemplate)
1200                               : Function);
1201
1202   // If the original function was part of a friend declaration,
1203   // inherit its namespace state and add it to the owner.
1204   if (isFriend) {
1205     NamedDecl *PrevDecl;
1206     if (TemplateParams)
1207       PrevDecl = FunctionTemplate->getPreviousDeclaration();
1208     else
1209       PrevDecl = Function->getPreviousDeclaration();
1210
1211     PrincipalDecl->setObjectOfFriendDecl(PrevDecl != 0);
1212     DC->makeDeclVisibleInContext(PrincipalDecl, /*Recoverable=*/ false);
1213
1214     bool queuedInstantiation = false;
1215
1216     if (!SemaRef.getLangOptions().CPlusPlus0x &&
1217         D->isThisDeclarationADefinition()) {
1218       // Check for a function body.
1219       const FunctionDecl *Definition = 0;
1220       if (Function->isDefined(Definition) &&
1221           Definition->getTemplateSpecializationKind() == TSK_Undeclared) {
1222         SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
1223           << Function->getDeclName();
1224         SemaRef.Diag(Definition->getLocation(), diag::note_previous_definition);
1225         Function->setInvalidDecl();
1226       }
1227       // Check for redefinitions due to other instantiations of this or
1228       // a similar friend function.
1229       else for (FunctionDecl::redecl_iterator R = Function->redecls_begin(),
1230                                            REnd = Function->redecls_end();
1231                 R != REnd; ++R) {
1232         if (*R == Function)
1233           continue;
1234         switch (R->getFriendObjectKind()) {
1235         case Decl::FOK_None:
1236           if (!queuedInstantiation && R->isUsed(false)) {
1237             if (MemberSpecializationInfo *MSInfo
1238                 = Function->getMemberSpecializationInfo()) {
1239               if (MSInfo->getPointOfInstantiation().isInvalid()) {
1240                 SourceLocation Loc = R->getLocation(); // FIXME
1241                 MSInfo->setPointOfInstantiation(Loc);
1242                 SemaRef.PendingLocalImplicitInstantiations.push_back(
1243                                                  std::make_pair(Function, Loc));
1244                 queuedInstantiation = true;
1245               }
1246             }
1247           }
1248           break;
1249         default:
1250           if (const FunctionDecl *RPattern
1251               = R->getTemplateInstantiationPattern())
1252             if (RPattern->isDefined(RPattern)) {
1253               SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
1254                 << Function->getDeclName();
1255               SemaRef.Diag(R->getLocation(), diag::note_previous_definition);
1256               Function->setInvalidDecl();
1257               break;
1258             }
1259         }
1260       }
1261     }
1262   }
1263
1264   if (Function->isOverloadedOperator() && !DC->isRecord() &&
1265       PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
1266     PrincipalDecl->setNonMemberOperator();
1267
1268   assert(!D->isDefaulted() && "only methods should be defaulted");
1269   return Function;
1270 }
1271
1272 Decl *
1273 TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D,
1274                                       TemplateParameterList *TemplateParams) {
1275   FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1276   void *InsertPos = 0;
1277   if (FunctionTemplate && !TemplateParams) {
1278     // We are creating a function template specialization from a function
1279     // template. Check whether there is already a function template
1280     // specialization for this particular set of template arguments.
1281     std::pair<const TemplateArgument *, unsigned> Innermost
1282       = TemplateArgs.getInnermost();
1283
1284     FunctionDecl *SpecFunc
1285       = FunctionTemplate->findSpecialization(Innermost.first, Innermost.second,
1286                                              InsertPos);
1287
1288     // If we already have a function template specialization, return it.
1289     if (SpecFunc)
1290       return SpecFunc;
1291   }
1292
1293   bool isFriend;
1294   if (FunctionTemplate)
1295     isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1296   else
1297     isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1298
1299   bool MergeWithParentScope = (TemplateParams != 0) ||
1300     !(isa<Decl>(Owner) &&
1301       cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1302   LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1303
1304   // Instantiate enclosing template arguments for friends.
1305   llvm::SmallVector<TemplateParameterList *, 4> TempParamLists;
1306   unsigned NumTempParamLists = 0;
1307   if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) {
1308     TempParamLists.set_size(NumTempParamLists);
1309     for (unsigned I = 0; I != NumTempParamLists; ++I) {
1310       TemplateParameterList *TempParams = D->getTemplateParameterList(I);
1311       TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1312       if (!InstParams)
1313         return NULL;
1314       TempParamLists[I] = InstParams;
1315     }
1316   }
1317
1318   llvm::SmallVector<ParmVarDecl *, 4> Params;
1319   TypeSourceInfo *TInfo = D->getTypeSourceInfo();
1320   TInfo = SubstFunctionType(D, Params);
1321   if (!TInfo)
1322     return 0;
1323   QualType T = TInfo->getType();
1324
1325   // \brief If the type of this function, after ignoring parentheses,
1326   // is not *directly* a function type, then we're instantiating a function
1327   // that was declared via a typedef, e.g.,
1328   //
1329   //   typedef int functype(int, int);
1330   //   functype func;
1331   //
1332   // In this case, we'll just go instantiate the ParmVarDecls that we
1333   // synthesized in the method declaration.
1334   if (!isa<FunctionProtoType>(T.IgnoreParens())) {
1335     assert(!Params.size() && "Instantiating type could not yield parameters");
1336     llvm::SmallVector<QualType, 4> ParamTypes;
1337     if (SemaRef.SubstParmTypes(D->getLocation(), D->param_begin(),
1338                                D->getNumParams(), TemplateArgs, ParamTypes,
1339                                &Params))
1340       return 0;
1341   }
1342
1343   NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1344   if (QualifierLoc) {
1345     QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1346                                                  TemplateArgs);
1347     if (!QualifierLoc)
1348       return 0;
1349   }
1350
1351   DeclContext *DC = Owner;
1352   if (isFriend) {
1353     if (QualifierLoc) {
1354       CXXScopeSpec SS;
1355       SS.Adopt(QualifierLoc);
1356       DC = SemaRef.computeDeclContext(SS);
1357
1358       if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
1359         return 0;
1360     } else {
1361       DC = SemaRef.FindInstantiatedContext(D->getLocation(),
1362                                            D->getDeclContext(),
1363                                            TemplateArgs);
1364     }
1365     if (!DC) return 0;
1366   }
1367
1368   // Build the instantiated method declaration.
1369   CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
1370   CXXMethodDecl *Method = 0;
1371
1372   SourceLocation StartLoc = D->getInnerLocStart();
1373   DeclarationNameInfo NameInfo
1374     = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
1375   if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
1376     Method = CXXConstructorDecl::Create(SemaRef.Context, Record,
1377                                         StartLoc, NameInfo, T, TInfo,
1378                                         Constructor->isExplicit(),
1379                                         Constructor->isInlineSpecified(),
1380                                         false);
1381   } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
1382     Method = CXXDestructorDecl::Create(SemaRef.Context, Record,
1383                                        StartLoc, NameInfo, T, TInfo,
1384                                        Destructor->isInlineSpecified(),
1385                                        false);
1386   } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
1387     Method = CXXConversionDecl::Create(SemaRef.Context, Record,
1388                                        StartLoc, NameInfo, T, TInfo,
1389                                        Conversion->isInlineSpecified(),
1390                                        Conversion->isExplicit(),
1391                                        Conversion->getLocEnd());
1392   } else {
1393     Method = CXXMethodDecl::Create(SemaRef.Context, Record,
1394                                    StartLoc, NameInfo, T, TInfo,
1395                                    D->isStatic(),
1396                                    D->getStorageClassAsWritten(),
1397                                    D->isInlineSpecified(),
1398                                    D->getLocEnd());
1399   }
1400
1401   if (QualifierLoc)
1402     Method->setQualifierInfo(QualifierLoc);
1403
1404   if (TemplateParams) {
1405     // Our resulting instantiation is actually a function template, since we
1406     // are substituting only the outer template parameters. For example, given
1407     //
1408     //   template<typename T>
1409     //   struct X {
1410     //     template<typename U> void f(T, U);
1411     //   };
1412     //
1413     //   X<int> x;
1414     //
1415     // We are instantiating the member template "f" within X<int>, which means
1416     // substituting int for T, but leaving "f" as a member function template.
1417     // Build the function template itself.
1418     FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record,
1419                                                     Method->getLocation(),
1420                                                     Method->getDeclName(),
1421                                                     TemplateParams, Method);
1422     if (isFriend) {
1423       FunctionTemplate->setLexicalDeclContext(Owner);
1424       FunctionTemplate->setObjectOfFriendDecl(true);
1425     } else if (D->isOutOfLine())
1426       FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext());
1427     Method->setDescribedFunctionTemplate(FunctionTemplate);
1428   } else if (FunctionTemplate) {
1429     // Record this function template specialization.
1430     std::pair<const TemplateArgument *, unsigned> Innermost
1431       = TemplateArgs.getInnermost();
1432     Method->setFunctionTemplateSpecialization(FunctionTemplate,
1433                          TemplateArgumentList::CreateCopy(SemaRef.Context,
1434                                                           Innermost.first,
1435                                                           Innermost.second),
1436                                               InsertPos);
1437   } else if (!isFriend) {
1438     // Record that this is an instantiation of a member function.
1439     Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
1440   }
1441
1442   // If we are instantiating a member function defined
1443   // out-of-line, the instantiation will have the same lexical
1444   // context (which will be a namespace scope) as the template.
1445   if (isFriend) {
1446     if (NumTempParamLists)
1447       Method->setTemplateParameterListsInfo(SemaRef.Context,
1448                                             NumTempParamLists,
1449                                             TempParamLists.data());
1450
1451     Method->setLexicalDeclContext(Owner);
1452     Method->setObjectOfFriendDecl(true);
1453   } else if (D->isOutOfLine())
1454     Method->setLexicalDeclContext(D->getLexicalDeclContext());
1455
1456   // Attach the parameters
1457   for (unsigned P = 0; P < Params.size(); ++P)
1458     Params[P]->setOwningFunction(Method);
1459   Method->setParams(Params.data(), Params.size());
1460
1461   if (InitMethodInstantiation(Method, D))
1462     Method->setInvalidDecl();
1463
1464   LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName,
1465                         Sema::ForRedeclaration);
1466
1467   if (!FunctionTemplate || TemplateParams || isFriend) {
1468     SemaRef.LookupQualifiedName(Previous, Record);
1469
1470     // In C++, the previous declaration we find might be a tag type
1471     // (class or enum). In this case, the new declaration will hide the
1472     // tag type. Note that this does does not apply if we're declaring a
1473     // typedef (C++ [dcl.typedef]p4).
1474     if (Previous.isSingleTagDecl())
1475       Previous.clear();
1476   }
1477
1478   bool Redeclaration = false;
1479   SemaRef.CheckFunctionDeclaration(0, Method, Previous, false, Redeclaration);
1480
1481   if (D->isPure())
1482     SemaRef.CheckPureMethod(Method, SourceRange());
1483
1484   Method->setAccess(D->getAccess());
1485
1486   SemaRef.CheckOverrideControl(Method);
1487
1488   if (FunctionTemplate) {
1489     // If there's a function template, let our caller handle it.
1490   } else if (Method->isInvalidDecl() && !Previous.empty()) {
1491     // Don't hide a (potentially) valid declaration with an invalid one.
1492   } else {
1493     NamedDecl *DeclToAdd = (TemplateParams
1494                             ? cast<NamedDecl>(FunctionTemplate)
1495                             : Method);
1496     if (isFriend)
1497       Record->makeDeclVisibleInContext(DeclToAdd);
1498     else
1499       Owner->addDecl(DeclToAdd);
1500   }
1501
1502   if (D->isExplicitlyDefaulted()) {
1503     SemaRef.SetDeclDefaulted(Method, Method->getLocation());
1504   } else {
1505     assert(!D->isDefaulted() &&
1506            "should not implicitly default uninstantiated function");
1507   }
1508
1509   return Method;
1510 }
1511
1512 Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1513   return VisitCXXMethodDecl(D);
1514 }
1515
1516 Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1517   return VisitCXXMethodDecl(D);
1518 }
1519
1520 Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
1521   return VisitCXXMethodDecl(D);
1522 }
1523
1524 ParmVarDecl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
1525   return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0,
1526                                   llvm::Optional<unsigned>());
1527 }
1528
1529 Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
1530                                                     TemplateTypeParmDecl *D) {
1531   // TODO: don't always clone when decls are refcounted.
1532   assert(D->getTypeForDecl()->isTemplateTypeParmType());
1533
1534   TemplateTypeParmDecl *Inst =
1535     TemplateTypeParmDecl::Create(SemaRef.Context, Owner,
1536                                  D->getLocStart(), D->getLocation(),
1537                                  D->getDepth() - TemplateArgs.getNumLevels(),
1538                                  D->getIndex(), D->getIdentifier(),
1539                                  D->wasDeclaredWithTypename(),
1540                                  D->isParameterPack());
1541   Inst->setAccess(AS_public);
1542
1543   if (D->hasDefaultArgument())
1544     Inst->setDefaultArgument(D->getDefaultArgumentInfo(), false);
1545
1546   // Introduce this template parameter's instantiation into the instantiation
1547   // scope.
1548   SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);
1549
1550   return Inst;
1551 }
1552
1553 Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
1554                                                  NonTypeTemplateParmDecl *D) {
1555   // Substitute into the type of the non-type template parameter.
1556   TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc();
1557   llvm::SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten;
1558   llvm::SmallVector<QualType, 4> ExpandedParameterPackTypes;
1559   bool IsExpandedParameterPack = false;
1560   TypeSourceInfo *DI;
1561   QualType T;
1562   bool Invalid = false;
1563
1564   if (D->isExpandedParameterPack()) {
1565     // The non-type template parameter pack is an already-expanded pack
1566     // expansion of types. Substitute into each of the expanded types.
1567     ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes());
1568     ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes());
1569     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1570       TypeSourceInfo *NewDI =SemaRef.SubstType(D->getExpansionTypeSourceInfo(I),
1571                                                TemplateArgs,
1572                                                D->getLocation(),
1573                                                D->getDeclName());
1574       if (!NewDI)
1575         return 0;
1576
1577       ExpandedParameterPackTypesAsWritten.push_back(NewDI);
1578       QualType NewT =SemaRef.CheckNonTypeTemplateParameterType(NewDI->getType(),
1579                                                               D->getLocation());
1580       if (NewT.isNull())
1581         return 0;
1582       ExpandedParameterPackTypes.push_back(NewT);
1583     }
1584
1585     IsExpandedParameterPack = true;
1586     DI = D->getTypeSourceInfo();
1587     T = DI->getType();
1588   } else if (isa<PackExpansionTypeLoc>(TL)) {
1589     // The non-type template parameter pack's type is a pack expansion of types.
1590     // Determine whether we need to expand this parameter pack into separate
1591     // types.
1592     PackExpansionTypeLoc Expansion = cast<PackExpansionTypeLoc>(TL);
1593     TypeLoc Pattern = Expansion.getPatternLoc();
1594     llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded;
1595     SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
1596
1597     // Determine whether the set of unexpanded parameter packs can and should
1598     // be expanded.
1599     bool Expand = true;
1600     bool RetainExpansion = false;
1601     llvm::Optional<unsigned> OrigNumExpansions
1602       = Expansion.getTypePtr()->getNumExpansions();
1603     llvm::Optional<unsigned> NumExpansions = OrigNumExpansions;
1604     if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
1605                                                 Pattern.getSourceRange(),
1606                                                 Unexpanded.data(),
1607                                                 Unexpanded.size(),
1608                                                 TemplateArgs,
1609                                                 Expand, RetainExpansion,
1610                                                 NumExpansions))
1611       return 0;
1612
1613     if (Expand) {
1614       for (unsigned I = 0; I != *NumExpansions; ++I) {
1615         Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
1616         TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs,
1617                                                   D->getLocation(),
1618                                                   D->getDeclName());
1619         if (!NewDI)
1620           return 0;
1621
1622         ExpandedParameterPackTypesAsWritten.push_back(NewDI);
1623         QualType NewT = SemaRef.CheckNonTypeTemplateParameterType(
1624                                                               NewDI->getType(),
1625                                                               D->getLocation());
1626         if (NewT.isNull())
1627           return 0;
1628         ExpandedParameterPackTypes.push_back(NewT);
1629       }
1630
1631       // Note that we have an expanded parameter pack. The "type" of this
1632       // expanded parameter pack is the original expansion type, but callers
1633       // will end up using the expanded parameter pack types for type-checking.
1634       IsExpandedParameterPack = true;
1635       DI = D->getTypeSourceInfo();
1636       T = DI->getType();
1637     } else {
1638       // We cannot fully expand the pack expansion now, so substitute into the
1639       // pattern and create a new pack expansion type.
1640       Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
1641       TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs,
1642                                                      D->getLocation(),
1643                                                      D->getDeclName());
1644       if (!NewPattern)
1645         return 0;
1646
1647       DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(),
1648                                       NumExpansions);
1649       if (!DI)
1650         return 0;
1651
1652       T = DI->getType();
1653     }
1654   } else {
1655     // Simple case: substitution into a parameter that is not a parameter pack.
1656     DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
1657                            D->getLocation(), D->getDeclName());
1658     if (!DI)
1659       return 0;
1660
1661     // Check that this type is acceptable for a non-type template parameter.
1662     T = SemaRef.CheckNonTypeTemplateParameterType(DI->getType(),
1663                                                   D->getLocation());
1664     if (T.isNull()) {
1665       T = SemaRef.Context.IntTy;
1666       Invalid = true;
1667     }
1668   }
1669
1670   NonTypeTemplateParmDecl *Param;
1671   if (IsExpandedParameterPack)
1672     Param = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner,
1673                                             D->getInnerLocStart(),
1674                                             D->getLocation(),
1675                                     D->getDepth() - TemplateArgs.getNumLevels(),
1676                                             D->getPosition(),
1677                                             D->getIdentifier(), T,
1678                                             DI,
1679                                             ExpandedParameterPackTypes.data(),
1680                                             ExpandedParameterPackTypes.size(),
1681                                     ExpandedParameterPackTypesAsWritten.data());
1682   else
1683     Param = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner,
1684                                             D->getInnerLocStart(),
1685                                             D->getLocation(),
1686                                     D->getDepth() - TemplateArgs.getNumLevels(),
1687                                             D->getPosition(),
1688                                             D->getIdentifier(), T,
1689                                             D->isParameterPack(), DI);
1690
1691   Param->setAccess(AS_public);
1692   if (Invalid)
1693     Param->setInvalidDecl();
1694
1695   Param->setDefaultArgument(D->getDefaultArgument(), false);
1696
1697   // Introduce this template parameter's instantiation into the instantiation
1698   // scope.
1699   SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
1700   return Param;
1701 }
1702
1703 Decl *
1704 TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
1705                                                   TemplateTemplateParmDecl *D) {
1706   // Instantiate the template parameter list of the template template parameter.
1707   TemplateParameterList *TempParams = D->getTemplateParameters();
1708   TemplateParameterList *InstParams;
1709   {
1710     // Perform the actual substitution of template parameters within a new,
1711     // local instantiation scope.
1712     LocalInstantiationScope Scope(SemaRef);
1713     InstParams = SubstTemplateParams(TempParams);
1714     if (!InstParams)
1715       return NULL;
1716   }
1717
1718   // Build the template template parameter.
1719   TemplateTemplateParmDecl *Param
1720     = TemplateTemplateParmDecl::Create(SemaRef.Context, Owner, D->getLocation(),
1721                                    D->getDepth() - TemplateArgs.getNumLevels(),
1722                                        D->getPosition(), D->isParameterPack(),
1723                                        D->getIdentifier(), InstParams);
1724   Param->setDefaultArgument(D->getDefaultArgument(), false);
1725   Param->setAccess(AS_public);
1726
1727   // Introduce this template parameter's instantiation into the instantiation
1728   // scope.
1729   SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
1730
1731   return Param;
1732 }
1733
1734 Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1735   // Using directives are never dependent (and never contain any types or
1736   // expressions), so they require no explicit instantiation work.
1737
1738   UsingDirectiveDecl *Inst
1739     = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(),
1740                                  D->getNamespaceKeyLocation(),
1741                                  D->getQualifierLoc(),
1742                                  D->getIdentLocation(),
1743                                  D->getNominatedNamespace(),
1744                                  D->getCommonAncestor());
1745   Owner->addDecl(Inst);
1746   return Inst;
1747 }
1748
1749 Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {
1750
1751   // The nested name specifier may be dependent, for example
1752   //     template <typename T> struct t {
1753   //       struct s1 { T f1(); };
1754   //       struct s2 : s1 { using s1::f1; };
1755   //     };
1756   //     template struct t<int>;
1757   // Here, in using s1::f1, s1 refers to t<T>::s1;
1758   // we need to substitute for t<int>::s1.
1759   NestedNameSpecifierLoc QualifierLoc
1760     = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
1761                                           TemplateArgs);
1762   if (!QualifierLoc)
1763     return 0;
1764
1765   // The name info is non-dependent, so no transformation
1766   // is required.
1767   DeclarationNameInfo NameInfo = D->getNameInfo();
1768
1769   // We only need to do redeclaration lookups if we're in a class
1770   // scope (in fact, it's not really even possible in non-class
1771   // scopes).
1772   bool CheckRedeclaration = Owner->isRecord();
1773
1774   LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName,
1775                     Sema::ForRedeclaration);
1776
1777   UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner,
1778                                        D->getUsingLocation(),
1779                                        QualifierLoc,
1780                                        NameInfo,
1781                                        D->isTypeName());
1782
1783   CXXScopeSpec SS;
1784   SS.Adopt(QualifierLoc);
1785   if (CheckRedeclaration) {
1786     Prev.setHideTags(false);
1787     SemaRef.LookupQualifiedName(Prev, Owner);
1788
1789     // Check for invalid redeclarations.
1790     if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLocation(),
1791                                             D->isTypeName(), SS,
1792                                             D->getLocation(), Prev))
1793       NewUD->setInvalidDecl();
1794
1795   }
1796
1797   if (!NewUD->isInvalidDecl() &&
1798       SemaRef.CheckUsingDeclQualifier(D->getUsingLocation(), SS,
1799                                       D->getLocation()))
1800     NewUD->setInvalidDecl();
1801
1802   SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
1803   NewUD->setAccess(D->getAccess());
1804   Owner->addDecl(NewUD);
1805
1806   // Don't process the shadow decls for an invalid decl.
1807   if (NewUD->isInvalidDecl())
1808     return NewUD;
1809
1810   bool isFunctionScope = Owner->isFunctionOrMethod();
1811
1812   // Process the shadow decls.
1813   for (UsingDecl::shadow_iterator I = D->shadow_begin(), E = D->shadow_end();
1814          I != E; ++I) {
1815     UsingShadowDecl *Shadow = *I;
1816     NamedDecl *InstTarget =
1817       cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
1818                                                           Shadow->getLocation(),
1819                                                         Shadow->getTargetDecl(),
1820                                                            TemplateArgs));
1821     if (!InstTarget)
1822       return 0;
1823
1824     if (CheckRedeclaration &&
1825         SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev))
1826       continue;
1827
1828     UsingShadowDecl *InstShadow
1829       = SemaRef.BuildUsingShadowDecl(/*Scope*/ 0, NewUD, InstTarget);
1830     SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);
1831
1832     if (isFunctionScope)
1833       SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow);
1834   }
1835
1836   return NewUD;
1837 }
1838
1839 Decl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) {
1840   // Ignore these;  we handle them in bulk when processing the UsingDecl.
1841   return 0;
1842 }
1843
1844 Decl * TemplateDeclInstantiator
1845     ::VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) {
1846   NestedNameSpecifierLoc QualifierLoc
1847     = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
1848                                           TemplateArgs);
1849   if (!QualifierLoc)
1850     return 0;
1851
1852   CXXScopeSpec SS;
1853   SS.Adopt(QualifierLoc);
1854
1855   // Since NameInfo refers to a typename, it cannot be a C++ special name.
1856   // Hence, no tranformation is required for it.
1857   DeclarationNameInfo NameInfo(D->getDeclName(), D->getLocation());
1858   NamedDecl *UD =
1859     SemaRef.BuildUsingDeclaration(/*Scope*/ 0, D->getAccess(),
1860                                   D->getUsingLoc(), SS, NameInfo, 0,
1861                                   /*instantiation*/ true,
1862                                   /*typename*/ true, D->getTypenameLoc());
1863   if (UD)
1864     SemaRef.Context.setInstantiatedFromUsingDecl(cast<UsingDecl>(UD), D);
1865
1866   return UD;
1867 }
1868
1869 Decl * TemplateDeclInstantiator
1870     ::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1871   NestedNameSpecifierLoc QualifierLoc
1872       = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(), TemplateArgs);
1873   if (!QualifierLoc)
1874     return 0;
1875
1876   CXXScopeSpec SS;
1877   SS.Adopt(QualifierLoc);
1878
1879   DeclarationNameInfo NameInfo
1880     = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
1881
1882   NamedDecl *UD =
1883     SemaRef.BuildUsingDeclaration(/*Scope*/ 0, D->getAccess(),
1884                                   D->getUsingLoc(), SS, NameInfo, 0,
1885                                   /*instantiation*/ true,
1886                                   /*typename*/ false, SourceLocation());
1887   if (UD)
1888     SemaRef.Context.setInstantiatedFromUsingDecl(cast<UsingDecl>(UD), D);
1889
1890   return UD;
1891 }
1892
1893 Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
1894                       const MultiLevelTemplateArgumentList &TemplateArgs) {
1895   TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
1896   if (D->isInvalidDecl())
1897     return 0;
1898
1899   return Instantiator.Visit(D);
1900 }
1901
1902 /// \brief Instantiates a nested template parameter list in the current
1903 /// instantiation context.
1904 ///
1905 /// \param L The parameter list to instantiate
1906 ///
1907 /// \returns NULL if there was an error
1908 TemplateParameterList *
1909 TemplateDeclInstantiator::SubstTemplateParams(TemplateParameterList *L) {
1910   // Get errors for all the parameters before bailing out.
1911   bool Invalid = false;
1912
1913   unsigned N = L->size();
1914   typedef llvm::SmallVector<NamedDecl *, 8> ParamVector;
1915   ParamVector Params;
1916   Params.reserve(N);
1917   for (TemplateParameterList::iterator PI = L->begin(), PE = L->end();
1918        PI != PE; ++PI) {
1919     NamedDecl *D = cast_or_null<NamedDecl>(Visit(*PI));
1920     Params.push_back(D);
1921     Invalid = Invalid || !D || D->isInvalidDecl();
1922   }
1923
1924   // Clean up if we had an error.
1925   if (Invalid)
1926     return NULL;
1927
1928   TemplateParameterList *InstL
1929     = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
1930                                     L->getLAngleLoc(), &Params.front(), N,
1931                                     L->getRAngleLoc());
1932   return InstL;
1933 }
1934
1935 /// \brief Instantiate the declaration of a class template partial
1936 /// specialization.
1937 ///
1938 /// \param ClassTemplate the (instantiated) class template that is partially
1939 // specialized by the instantiation of \p PartialSpec.
1940 ///
1941 /// \param PartialSpec the (uninstantiated) class template partial
1942 /// specialization that we are instantiating.
1943 ///
1944 /// \returns The instantiated partial specialization, if successful; otherwise,
1945 /// NULL to indicate an error.
1946 ClassTemplatePartialSpecializationDecl *
1947 TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(
1948                                             ClassTemplateDecl *ClassTemplate,
1949                           ClassTemplatePartialSpecializationDecl *PartialSpec) {
1950   // Create a local instantiation scope for this class template partial
1951   // specialization, which will contain the instantiations of the template
1952   // parameters.
1953   LocalInstantiationScope Scope(SemaRef);
1954
1955   // Substitute into the template parameters of the class template partial
1956   // specialization.
1957   TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
1958   TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1959   if (!InstParams)
1960     return 0;
1961
1962   // Substitute into the template arguments of the class template partial
1963   // specialization.
1964   TemplateArgumentListInfo InstTemplateArgs; // no angle locations
1965   if (SemaRef.Subst(PartialSpec->getTemplateArgsAsWritten(),
1966                     PartialSpec->getNumTemplateArgsAsWritten(),
1967                     InstTemplateArgs, TemplateArgs))
1968     return 0;
1969
1970   // Check that the template argument list is well-formed for this
1971   // class template.
1972   llvm::SmallVector<TemplateArgument, 4> Converted;
1973   if (SemaRef.CheckTemplateArgumentList(ClassTemplate,
1974                                         PartialSpec->getLocation(),
1975                                         InstTemplateArgs,
1976                                         false,
1977                                         Converted))
1978     return 0;
1979
1980   // Figure out where to insert this class template partial specialization
1981   // in the member template's set of class template partial specializations.
1982   void *InsertPos = 0;
1983   ClassTemplateSpecializationDecl *PrevDecl
1984     = ClassTemplate->findPartialSpecialization(Converted.data(),
1985                                                Converted.size(), InsertPos);
1986
1987   // Build the canonical type that describes the converted template
1988   // arguments of the class template partial specialization.
1989   QualType CanonType
1990     = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate),
1991                                                     Converted.data(),
1992                                                     Converted.size());
1993
1994   // Build the fully-sugared type for this class template
1995   // specialization as the user wrote in the specialization
1996   // itself. This means that we'll pretty-print the type retrieved
1997   // from the specialization's declaration the way that the user
1998   // actually wrote the specialization, rather than formatting the
1999   // name based on the "canonical" representation used to store the
2000   // template arguments in the specialization.
2001   TypeSourceInfo *WrittenTy
2002     = SemaRef.Context.getTemplateSpecializationTypeInfo(
2003                                                     TemplateName(ClassTemplate),
2004                                                     PartialSpec->getLocation(),
2005                                                     InstTemplateArgs,
2006                                                     CanonType);
2007
2008   if (PrevDecl) {
2009     // We've already seen a partial specialization with the same template
2010     // parameters and template arguments. This can happen, for example, when
2011     // substituting the outer template arguments ends up causing two
2012     // class template partial specializations of a member class template
2013     // to have identical forms, e.g.,
2014     //
2015     //   template<typename T, typename U>
2016     //   struct Outer {
2017     //     template<typename X, typename Y> struct Inner;
2018     //     template<typename Y> struct Inner<T, Y>;
2019     //     template<typename Y> struct Inner<U, Y>;
2020     //   };
2021     //
2022     //   Outer<int, int> outer; // error: the partial specializations of Inner
2023     //                          // have the same signature.
2024     SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared)
2025       << WrittenTy->getType();
2026     SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here)
2027       << SemaRef.Context.getTypeDeclType(PrevDecl);
2028     return 0;
2029   }
2030
2031
2032   // Create the class template partial specialization declaration.
2033   ClassTemplatePartialSpecializationDecl *InstPartialSpec
2034     = ClassTemplatePartialSpecializationDecl::Create(SemaRef.Context,
2035                                                      PartialSpec->getTagKind(),
2036                                                      Owner,
2037                                                      PartialSpec->getLocStart(),
2038                                                      PartialSpec->getLocation(),
2039                                                      InstParams,
2040                                                      ClassTemplate,
2041                                                      Converted.data(),
2042                                                      Converted.size(),
2043                                                      InstTemplateArgs,
2044                                                      CanonType,
2045                                                      0,
2046                              ClassTemplate->getNextPartialSpecSequenceNumber());
2047   // Substitute the nested name specifier, if any.
2048   if (SubstQualifier(PartialSpec, InstPartialSpec))
2049     return 0;
2050
2051   InstPartialSpec->setInstantiatedFromMember(PartialSpec);
2052   InstPartialSpec->setTypeAsWritten(WrittenTy);
2053
2054   // Add this partial specialization to the set of class template partial
2055   // specializations.
2056   ClassTemplate->AddPartialSpecialization(InstPartialSpec, InsertPos);
2057   return InstPartialSpec;
2058 }
2059
2060 TypeSourceInfo*
2061 TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D,
2062                               llvm::SmallVectorImpl<ParmVarDecl *> &Params) {
2063   TypeSourceInfo *OldTInfo = D->getTypeSourceInfo();
2064   assert(OldTInfo && "substituting function without type source info");
2065   assert(Params.empty() && "parameter vector is non-empty at start");
2066   TypeSourceInfo *NewTInfo
2067     = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs,
2068                                     D->getTypeSpecStartLoc(),
2069                                     D->getDeclName());
2070   if (!NewTInfo)
2071     return 0;
2072
2073   if (NewTInfo != OldTInfo) {
2074     // Get parameters from the new type info.
2075     TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
2076     if (FunctionProtoTypeLoc *OldProtoLoc
2077                                   = dyn_cast<FunctionProtoTypeLoc>(&OldTL)) {
2078       TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();
2079       FunctionProtoTypeLoc *NewProtoLoc = cast<FunctionProtoTypeLoc>(&NewTL);
2080       assert(NewProtoLoc && "Missing prototype?");
2081       unsigned NewIdx = 0, NumNewParams = NewProtoLoc->getNumArgs();
2082       for (unsigned OldIdx = 0, NumOldParams = OldProtoLoc->getNumArgs();
2083            OldIdx != NumOldParams; ++OldIdx) {
2084         ParmVarDecl *OldParam = OldProtoLoc->getArg(OldIdx);
2085         if (!OldParam->isParameterPack() ||
2086             (NewIdx < NumNewParams &&
2087              NewProtoLoc->getArg(NewIdx)->isParameterPack())) {
2088           // Simple case: normal parameter, or a parameter pack that's
2089           // instantiated to a (still-dependent) parameter pack.
2090           ParmVarDecl *NewParam = NewProtoLoc->getArg(NewIdx++);
2091           Params.push_back(NewParam);
2092           SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldParam,
2093                                                                NewParam);
2094           continue;
2095         }
2096
2097         // Parameter pack: make the instantiation an argument pack.
2098         SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(
2099                                                                       OldParam);
2100         unsigned NumArgumentsInExpansion
2101           = SemaRef.getNumArgumentsInExpansion(OldParam->getType(),
2102                                                TemplateArgs);
2103         while (NumArgumentsInExpansion--) {
2104           ParmVarDecl *NewParam = NewProtoLoc->getArg(NewIdx++);
2105           Params.push_back(NewParam);
2106           SemaRef.CurrentInstantiationScope->InstantiatedLocalPackArg(OldParam,
2107                                                                       NewParam);
2108         }
2109       }
2110     }
2111   } else {
2112     // The function type itself was not dependent and therefore no
2113     // substitution occurred. However, we still need to instantiate
2114     // the function parameters themselves.
2115     TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
2116     if (FunctionProtoTypeLoc *OldProtoLoc
2117                                     = dyn_cast<FunctionProtoTypeLoc>(&OldTL)) {
2118       for (unsigned i = 0, i_end = OldProtoLoc->getNumArgs(); i != i_end; ++i) {
2119         ParmVarDecl *Parm = VisitParmVarDecl(OldProtoLoc->getArg(i));
2120         if (!Parm)
2121           return 0;
2122         Params.push_back(Parm);
2123       }
2124     }
2125   }
2126   return NewTInfo;
2127 }
2128
2129 /// \brief Initializes the common fields of an instantiation function
2130 /// declaration (New) from the corresponding fields of its template (Tmpl).
2131 ///
2132 /// \returns true if there was an error
2133 bool
2134 TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New,
2135                                                     FunctionDecl *Tmpl) {
2136   if (Tmpl->isDeletedAsWritten())
2137     New->setDeletedAsWritten();
2138
2139   // If we are performing substituting explicitly-specified template arguments
2140   // or deduced template arguments into a function template and we reach this
2141   // point, we are now past the point where SFINAE applies and have committed
2142   // to keeping the new function template specialization. We therefore
2143   // convert the active template instantiation for the function template
2144   // into a template instantiation for this specific function template
2145   // specialization, which is not a SFINAE context, so that we diagnose any
2146   // further errors in the declaration itself.
2147   typedef Sema::ActiveTemplateInstantiation ActiveInstType;
2148   ActiveInstType &ActiveInst = SemaRef.ActiveTemplateInstantiations.back();
2149   if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
2150       ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
2151     if (FunctionTemplateDecl *FunTmpl
2152           = dyn_cast<FunctionTemplateDecl>((Decl *)ActiveInst.Entity)) {
2153       assert(FunTmpl->getTemplatedDecl() == Tmpl &&
2154              "Deduction from the wrong function template?");
2155       (void) FunTmpl;
2156       ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
2157       ActiveInst.Entity = reinterpret_cast<uintptr_t>(New);
2158       --SemaRef.NonInstantiationEntries;
2159     }
2160   }
2161
2162   const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>();
2163   assert(Proto && "Function template without prototype?");
2164
2165   if (Proto->hasExceptionSpec() || Proto->getNoReturnAttr()) {
2166     // The function has an exception specification or a "noreturn"
2167     // attribute. Substitute into each of the exception types.
2168     llvm::SmallVector<QualType, 4> Exceptions;
2169     for (unsigned I = 0, N = Proto->getNumExceptions(); I != N; ++I) {
2170       // FIXME: Poor location information!
2171       if (const PackExpansionType *PackExpansion
2172             = Proto->getExceptionType(I)->getAs<PackExpansionType>()) {
2173         // We have a pack expansion. Instantiate it.
2174         llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2175         SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
2176                                                 Unexpanded);
2177         assert(!Unexpanded.empty() &&
2178                "Pack expansion without parameter packs?");
2179
2180         bool Expand = false;
2181         bool RetainExpansion = false;
2182         llvm::Optional<unsigned> NumExpansions
2183                                           = PackExpansion->getNumExpansions();
2184         if (SemaRef.CheckParameterPacksForExpansion(New->getLocation(),
2185                                                     SourceRange(),
2186                                                     Unexpanded.data(),
2187                                                     Unexpanded.size(),
2188                                                     TemplateArgs,
2189                                                     Expand,
2190                                                     RetainExpansion,
2191                                                     NumExpansions))
2192           break;
2193
2194         if (!Expand) {
2195           // We can't expand this pack expansion into separate arguments yet;
2196           // just substitute into the pattern and create a new pack expansion
2197           // type.
2198           Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2199           QualType T = SemaRef.SubstType(PackExpansion->getPattern(),
2200                                          TemplateArgs,
2201                                        New->getLocation(), New->getDeclName());
2202           if (T.isNull())
2203             break;
2204
2205           T = SemaRef.Context.getPackExpansionType(T, NumExpansions);
2206           Exceptions.push_back(T);
2207           continue;
2208         }
2209
2210         // Substitute into the pack expansion pattern for each template
2211         bool Invalid = false;
2212         for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
2213           Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, ArgIdx);
2214
2215           QualType T = SemaRef.SubstType(PackExpansion->getPattern(),
2216                                          TemplateArgs,
2217                                        New->getLocation(), New->getDeclName());
2218           if (T.isNull()) {
2219             Invalid = true;
2220             break;
2221           }
2222
2223           Exceptions.push_back(T);
2224         }
2225
2226         if (Invalid)
2227           break;
2228
2229         continue;
2230       }
2231
2232       QualType T
2233         = SemaRef.SubstType(Proto->getExceptionType(I), TemplateArgs,
2234                             New->getLocation(), New->getDeclName());
2235       if (T.isNull() ||
2236           SemaRef.CheckSpecifiedExceptionType(T, New->getLocation()))
2237         continue;
2238
2239       Exceptions.push_back(T);
2240     }
2241     Expr *NoexceptExpr = 0;
2242     if (Expr *OldNoexceptExpr = Proto->getNoexceptExpr()) {
2243       EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
2244       ExprResult E = SemaRef.SubstExpr(OldNoexceptExpr, TemplateArgs);
2245       if (E.isUsable())
2246         NoexceptExpr = E.take();
2247     }
2248
2249     // Rebuild the function type
2250
2251     FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
2252     EPI.ExceptionSpecType = Proto->getExceptionSpecType();
2253     EPI.NumExceptions = Exceptions.size();
2254     EPI.Exceptions = Exceptions.data();
2255     EPI.NoexceptExpr = NoexceptExpr;
2256     EPI.ExtInfo = Proto->getExtInfo();
2257
2258     const FunctionProtoType *NewProto
2259       = New->getType()->getAs<FunctionProtoType>();
2260     assert(NewProto && "Template instantiation without function prototype?");
2261     New->setType(SemaRef.Context.getFunctionType(NewProto->getResultType(),
2262                                                  NewProto->arg_type_begin(),
2263                                                  NewProto->getNumArgs(),
2264                                                  EPI));
2265   }
2266
2267   SemaRef.InstantiateAttrs(TemplateArgs, Tmpl, New);
2268
2269   return false;
2270 }
2271
2272 /// \brief Initializes common fields of an instantiated method
2273 /// declaration (New) from the corresponding fields of its template
2274 /// (Tmpl).
2275 ///
2276 /// \returns true if there was an error
2277 bool
2278 TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New,
2279                                                   CXXMethodDecl *Tmpl) {
2280   if (InitFunctionInstantiation(New, Tmpl))
2281     return true;
2282
2283   New->setAccess(Tmpl->getAccess());
2284   if (Tmpl->isVirtualAsWritten())
2285     New->setVirtualAsWritten(true);
2286
2287   // FIXME: attributes
2288   // FIXME: New needs a pointer to Tmpl
2289   return false;
2290 }
2291
2292 /// \brief Instantiate the definition of the given function from its
2293 /// template.
2294 ///
2295 /// \param PointOfInstantiation the point at which the instantiation was
2296 /// required. Note that this is not precisely a "point of instantiation"
2297 /// for the function, but it's close.
2298 ///
2299 /// \param Function the already-instantiated declaration of a
2300 /// function template specialization or member function of a class template
2301 /// specialization.
2302 ///
2303 /// \param Recursive if true, recursively instantiates any functions that
2304 /// are required by this instantiation.
2305 ///
2306 /// \param DefinitionRequired if true, then we are performing an explicit
2307 /// instantiation where the body of the function is required. Complain if
2308 /// there is no such body.
2309 void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
2310                                          FunctionDecl *Function,
2311                                          bool Recursive,
2312                                          bool DefinitionRequired) {
2313   if (Function->isInvalidDecl() || Function->isDefined())
2314     return;
2315
2316   // Never instantiate an explicit specialization.
2317   if (Function->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
2318     return;
2319
2320   // Find the function body that we'll be substituting.
2321   const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern();
2322   assert(PatternDecl && "instantiating a non-template");
2323
2324   Stmt *Pattern = PatternDecl->getBody(PatternDecl);
2325   assert(PatternDecl && "template definition is not a template");
2326   if (!Pattern) {
2327     // Try to find a defaulted definition
2328     PatternDecl->isDefined(PatternDecl);
2329   }
2330   assert(PatternDecl && "template definition is not a template");
2331
2332   // Postpone late parsed template instantiations.
2333   if (PatternDecl->isLateTemplateParsed() &&
2334       !LateTemplateParser) {
2335     PendingInstantiations.push_back(
2336       std::make_pair(Function, PointOfInstantiation));
2337     return;
2338   }
2339
2340   // Call the LateTemplateParser callback if there a need to late parse
2341   // a templated function definition.
2342   if (!Pattern && PatternDecl->isLateTemplateParsed() &&
2343       LateTemplateParser) {
2344     LateTemplateParser(OpaqueParser, PatternDecl);
2345     Pattern = PatternDecl->getBody(PatternDecl);
2346   }
2347
2348   if (!Pattern && !PatternDecl->isDefaulted()) {
2349     if (DefinitionRequired) {
2350       if (Function->getPrimaryTemplate())
2351         Diag(PointOfInstantiation,
2352              diag::err_explicit_instantiation_undefined_func_template)
2353           << Function->getPrimaryTemplate();
2354       else
2355         Diag(PointOfInstantiation,
2356              diag::err_explicit_instantiation_undefined_member)
2357           << 1 << Function->getDeclName() << Function->getDeclContext();
2358
2359       if (PatternDecl)
2360         Diag(PatternDecl->getLocation(),
2361              diag::note_explicit_instantiation_here);
2362       Function->setInvalidDecl();
2363     } else if (Function->getTemplateSpecializationKind()
2364                  == TSK_ExplicitInstantiationDefinition) {
2365       PendingInstantiations.push_back(
2366         std::make_pair(Function, PointOfInstantiation));
2367     }
2368
2369     return;
2370   }
2371
2372   // C++0x [temp.explicit]p9:
2373   //   Except for inline functions, other explicit instantiation declarations
2374   //   have the effect of suppressing the implicit instantiation of the entity
2375   //   to which they refer.
2376   if (Function->getTemplateSpecializationKind()
2377         == TSK_ExplicitInstantiationDeclaration &&
2378       !PatternDecl->isInlined())
2379     return;
2380
2381   InstantiatingTemplate Inst(*this, PointOfInstantiation, Function);
2382   if (Inst)
2383     return;
2384
2385   // If we're performing recursive template instantiation, create our own
2386   // queue of pending implicit instantiations that we will instantiate later,
2387   // while we're still within our own instantiation context.
2388   llvm::SmallVector<VTableUse, 16> SavedVTableUses;
2389   std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;
2390   if (Recursive) {
2391     VTableUses.swap(SavedVTableUses);
2392     PendingInstantiations.swap(SavedPendingInstantiations);
2393   }
2394
2395   EnterExpressionEvaluationContext EvalContext(*this,
2396                                                Sema::PotentiallyEvaluated);
2397   ActOnStartOfFunctionDef(0, Function);
2398
2399   // Introduce a new scope where local variable instantiations will be
2400   // recorded, unless we're actually a member function within a local
2401   // class, in which case we need to merge our results with the parent
2402   // scope (of the enclosing function).
2403   bool MergeWithParentScope = false;
2404   if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext()))
2405     MergeWithParentScope = Rec->isLocalClass();
2406
2407   LocalInstantiationScope Scope(*this, MergeWithParentScope);
2408
2409   // Introduce the instantiated function parameters into the local
2410   // instantiation scope, and set the parameter names to those used
2411   // in the template.
2412   unsigned FParamIdx = 0;
2413   for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
2414     const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
2415     if (!PatternParam->isParameterPack()) {
2416       // Simple case: not a parameter pack.
2417       assert(FParamIdx < Function->getNumParams());
2418       ParmVarDecl *FunctionParam = Function->getParamDecl(I);
2419       FunctionParam->setDeclName(PatternParam->getDeclName());
2420       Scope.InstantiatedLocal(PatternParam, FunctionParam);
2421       ++FParamIdx;
2422       continue;
2423     }
2424
2425     // Expand the parameter pack.
2426     Scope.MakeInstantiatedLocalArgPack(PatternParam);
2427     for (unsigned NumFParams = Function->getNumParams();
2428          FParamIdx < NumFParams;
2429          ++FParamIdx) {
2430       ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
2431       FunctionParam->setDeclName(PatternParam->getDeclName());
2432       Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
2433     }
2434   }
2435
2436   // Enter the scope of this instantiation. We don't use
2437   // PushDeclContext because we don't have a scope.
2438   Sema::ContextRAII savedContext(*this, Function);
2439
2440   MultiLevelTemplateArgumentList TemplateArgs =
2441     getTemplateInstantiationArgs(Function, 0, false, PatternDecl);
2442
2443   if (PatternDecl->isDefaulted()) {
2444     ActOnFinishFunctionBody(Function, 0, /*IsInstantiation=*/true);
2445
2446     SetDeclDefaulted(Function, PatternDecl->getLocation());
2447   } else {
2448     // If this is a constructor, instantiate the member initializers.
2449     if (const CXXConstructorDecl *Ctor =
2450           dyn_cast<CXXConstructorDecl>(PatternDecl)) {
2451       InstantiateMemInitializers(cast<CXXConstructorDecl>(Function), Ctor,
2452                                  TemplateArgs);
2453     }
2454
2455     // Instantiate the function body.
2456     StmtResult Body = SubstStmt(Pattern, TemplateArgs);
2457
2458     if (Body.isInvalid())
2459       Function->setInvalidDecl();
2460
2461     ActOnFinishFunctionBody(Function, Body.get(),
2462                             /*IsInstantiation=*/true);
2463   }
2464
2465   PerformDependentDiagnostics(PatternDecl, TemplateArgs);
2466
2467   savedContext.pop();
2468
2469   DeclGroupRef DG(Function);
2470   Consumer.HandleTopLevelDecl(DG);
2471
2472   // This class may have local implicit instantiations that need to be
2473   // instantiation within this scope.
2474   PerformPendingInstantiations(/*LocalOnly=*/true);
2475   Scope.Exit();
2476
2477   if (Recursive) {
2478     // Define any pending vtables.
2479     DefineUsedVTables();
2480
2481     // Instantiate any pending implicit instantiations found during the
2482     // instantiation of this template.
2483     PerformPendingInstantiations();
2484
2485     // Restore the set of pending vtables.
2486     assert(VTableUses.empty() &&
2487            "VTableUses should be empty before it is discarded.");
2488     VTableUses.swap(SavedVTableUses);
2489
2490     // Restore the set of pending implicit instantiations.
2491     assert(PendingInstantiations.empty() &&
2492            "PendingInstantiations should be empty before it is discarded.");
2493     PendingInstantiations.swap(SavedPendingInstantiations);
2494   }
2495 }
2496
2497 /// \brief Instantiate the definition of the given variable from its
2498 /// template.
2499 ///
2500 /// \param PointOfInstantiation the point at which the instantiation was
2501 /// required. Note that this is not precisely a "point of instantiation"
2502 /// for the function, but it's close.
2503 ///
2504 /// \param Var the already-instantiated declaration of a static member
2505 /// variable of a class template specialization.
2506 ///
2507 /// \param Recursive if true, recursively instantiates any functions that
2508 /// are required by this instantiation.
2509 ///
2510 /// \param DefinitionRequired if true, then we are performing an explicit
2511 /// instantiation where an out-of-line definition of the member variable
2512 /// is required. Complain if there is no such definition.
2513 void Sema::InstantiateStaticDataMemberDefinition(
2514                                           SourceLocation PointOfInstantiation,
2515                                                  VarDecl *Var,
2516                                                  bool Recursive,
2517                                                  bool DefinitionRequired) {
2518   if (Var->isInvalidDecl())
2519     return;
2520
2521   // Find the out-of-line definition of this static data member.
2522   VarDecl *Def = Var->getInstantiatedFromStaticDataMember();
2523   assert(Def && "This data member was not instantiated from a template?");
2524   assert(Def->isStaticDataMember() && "Not a static data member?");
2525   Def = Def->getOutOfLineDefinition();
2526
2527   if (!Def) {
2528     // We did not find an out-of-line definition of this static data member,
2529     // so we won't perform any instantiation. Rather, we rely on the user to
2530     // instantiate this definition (or provide a specialization for it) in
2531     // another translation unit.
2532     if (DefinitionRequired) {
2533       Def = Var->getInstantiatedFromStaticDataMember();
2534       Diag(PointOfInstantiation,
2535            diag::err_explicit_instantiation_undefined_member)
2536         << 2 << Var->getDeclName() << Var->getDeclContext();
2537       Diag(Def->getLocation(), diag::note_explicit_instantiation_here);
2538     } else if (Var->getTemplateSpecializationKind()
2539                  == TSK_ExplicitInstantiationDefinition) {
2540       PendingInstantiations.push_back(
2541         std::make_pair(Var, PointOfInstantiation));
2542     }
2543
2544     return;
2545   }
2546
2547   // Never instantiate an explicit specialization.
2548   if (Var->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
2549     return;
2550
2551   // C++0x [temp.explicit]p9:
2552   //   Except for inline functions, other explicit instantiation declarations
2553   //   have the effect of suppressing the implicit instantiation of the entity
2554   //   to which they refer.
2555   if (Var->getTemplateSpecializationKind()
2556         == TSK_ExplicitInstantiationDeclaration)
2557     return;
2558
2559   // If we already have a definition, we're done.
2560   if (Var->getDefinition())
2561     return;
2562
2563   InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
2564   if (Inst)
2565     return;
2566
2567   // If we're performing recursive template instantiation, create our own
2568   // queue of pending implicit instantiations that we will instantiate later,
2569   // while we're still within our own instantiation context.
2570   llvm::SmallVector<VTableUse, 16> SavedVTableUses;
2571   std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;
2572   if (Recursive) {
2573     VTableUses.swap(SavedVTableUses);
2574     PendingInstantiations.swap(SavedPendingInstantiations);
2575   }
2576
2577   // Enter the scope of this instantiation. We don't use
2578   // PushDeclContext because we don't have a scope.
2579   ContextRAII previousContext(*this, Var->getDeclContext());
2580
2581   VarDecl *OldVar = Var;
2582   Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(),
2583                                         getTemplateInstantiationArgs(Var)));
2584
2585   previousContext.pop();
2586
2587   if (Var) {
2588     MemberSpecializationInfo *MSInfo = OldVar->getMemberSpecializationInfo();
2589     assert(MSInfo && "Missing member specialization information?");
2590     Var->setTemplateSpecializationKind(MSInfo->getTemplateSpecializationKind(),
2591                                        MSInfo->getPointOfInstantiation());
2592     DeclGroupRef DG(Var);
2593     Consumer.HandleTopLevelDecl(DG);
2594   }
2595
2596   if (Recursive) {
2597     // Define any newly required vtables.
2598     DefineUsedVTables();
2599
2600     // Instantiate any pending implicit instantiations found during the
2601     // instantiation of this template.
2602     PerformPendingInstantiations();
2603
2604     // Restore the set of pending vtables.
2605     assert(VTableUses.empty() &&
2606            "VTableUses should be empty before it is discarded, "
2607            "while instantiating static data member.");
2608     VTableUses.swap(SavedVTableUses);
2609
2610     // Restore the set of pending implicit instantiations.
2611     assert(PendingInstantiations.empty() &&
2612            "PendingInstantiations should be empty before it is discarded, "
2613            "while instantiating static data member.");
2614     PendingInstantiations.swap(SavedPendingInstantiations);
2615   }
2616 }
2617
2618 void
2619 Sema::InstantiateMemInitializers(CXXConstructorDecl *New,
2620                                  const CXXConstructorDecl *Tmpl,
2621                            const MultiLevelTemplateArgumentList &TemplateArgs) {
2622
2623   llvm::SmallVector<MemInitTy*, 4> NewInits;
2624   bool AnyErrors = false;
2625
2626   // Instantiate all the initializers.
2627   for (CXXConstructorDecl::init_const_iterator Inits = Tmpl->init_begin(),
2628                                             InitsEnd = Tmpl->init_end();
2629        Inits != InitsEnd; ++Inits) {
2630     CXXCtorInitializer *Init = *Inits;
2631
2632     // Only instantiate written initializers, let Sema re-construct implicit
2633     // ones.
2634     if (!Init->isWritten())
2635       continue;
2636
2637     SourceLocation LParenLoc, RParenLoc;
2638     ASTOwningVector<Expr*> NewArgs(*this);
2639
2640     SourceLocation EllipsisLoc;
2641
2642     if (Init->isPackExpansion()) {
2643       // This is a pack expansion. We should expand it now.
2644       TypeLoc BaseTL = Init->getBaseClassInfo()->getTypeLoc();
2645       llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2646       collectUnexpandedParameterPacks(BaseTL, Unexpanded);
2647       bool ShouldExpand = false;
2648       bool RetainExpansion = false;
2649       llvm::Optional<unsigned> NumExpansions;
2650       if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(),
2651                                           BaseTL.getSourceRange(),
2652                                           Unexpanded.data(),
2653                                           Unexpanded.size(),
2654                                           TemplateArgs, ShouldExpand,
2655                                           RetainExpansion,
2656                                           NumExpansions)) {
2657         AnyErrors = true;
2658         New->setInvalidDecl();
2659         continue;
2660       }
2661       assert(ShouldExpand && "Partial instantiation of base initializer?");
2662
2663       // Loop over all of the arguments in the argument pack(s),
2664       for (unsigned I = 0; I != *NumExpansions; ++I) {
2665         Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
2666
2667         // Instantiate the initializer.
2668         if (InstantiateInitializer(*this, Init->getInit(), TemplateArgs,
2669                                    LParenLoc, NewArgs, RParenLoc)) {
2670           AnyErrors = true;
2671           break;
2672         }
2673
2674         // Instantiate the base type.
2675         TypeSourceInfo *BaseTInfo = SubstType(Init->getBaseClassInfo(),
2676                                               TemplateArgs,
2677                                               Init->getSourceLocation(),
2678                                               New->getDeclName());
2679         if (!BaseTInfo) {
2680           AnyErrors = true;
2681           break;
2682         }
2683
2684         // Build the initializer.
2685         MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(),
2686                                                      BaseTInfo,
2687                                                      (Expr **)NewArgs.data(),
2688                                                      NewArgs.size(),
2689                                                      Init->getLParenLoc(),
2690                                                      Init->getRParenLoc(),
2691                                                      New->getParent(),
2692                                                      SourceLocation());
2693         if (NewInit.isInvalid()) {
2694           AnyErrors = true;
2695           break;
2696         }
2697
2698         NewInits.push_back(NewInit.get());
2699         NewArgs.clear();
2700       }
2701
2702       continue;
2703     }
2704
2705     // Instantiate the initializer.
2706     if (InstantiateInitializer(*this, Init->getInit(), TemplateArgs,
2707                                LParenLoc, NewArgs, RParenLoc)) {
2708       AnyErrors = true;
2709       continue;
2710     }
2711
2712     MemInitResult NewInit;
2713     if (Init->isBaseInitializer()) {
2714       TypeSourceInfo *BaseTInfo = SubstType(Init->getBaseClassInfo(),
2715                                             TemplateArgs,
2716                                             Init->getSourceLocation(),
2717                                             New->getDeclName());
2718       if (!BaseTInfo) {
2719         AnyErrors = true;
2720         New->setInvalidDecl();
2721         continue;
2722       }
2723
2724       NewInit = BuildBaseInitializer(BaseTInfo->getType(), BaseTInfo,
2725                                      (Expr **)NewArgs.data(),
2726                                      NewArgs.size(),
2727                                      Init->getLParenLoc(),
2728                                      Init->getRParenLoc(),
2729                                      New->getParent(),
2730                                      EllipsisLoc);
2731     } else if (Init->isMemberInitializer()) {
2732       FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl(
2733                                                      Init->getMemberLocation(),
2734                                                      Init->getMember(),
2735                                                      TemplateArgs));
2736       if (!Member) {
2737         AnyErrors = true;
2738         New->setInvalidDecl();
2739         continue;
2740       }
2741
2742       NewInit = BuildMemberInitializer(Member, (Expr **)NewArgs.data(),
2743                                        NewArgs.size(),
2744                                        Init->getSourceLocation(),
2745                                        Init->getLParenLoc(),
2746                                        Init->getRParenLoc());
2747     } else if (Init->isIndirectMemberInitializer()) {
2748       IndirectFieldDecl *IndirectMember =
2749          cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl(
2750                                  Init->getMemberLocation(),
2751                                  Init->getIndirectMember(), TemplateArgs));
2752
2753       if (!IndirectMember) {
2754         AnyErrors = true;
2755         New->setInvalidDecl();
2756         continue;
2757       }
2758
2759       NewInit = BuildMemberInitializer(IndirectMember, (Expr **)NewArgs.data(),
2760                                        NewArgs.size(),
2761                                        Init->getSourceLocation(),
2762                                        Init->getLParenLoc(),
2763                                        Init->getRParenLoc());
2764     }
2765
2766     if (NewInit.isInvalid()) {
2767       AnyErrors = true;
2768       New->setInvalidDecl();
2769     } else {
2770       // FIXME: It would be nice if ASTOwningVector had a release function.
2771       NewArgs.take();
2772
2773       NewInits.push_back((MemInitTy *)NewInit.get());
2774     }
2775   }
2776
2777   // Assign all the initializers to the new constructor.
2778   ActOnMemInitializers(New,
2779                        /*FIXME: ColonLoc */
2780                        SourceLocation(),
2781                        NewInits.data(), NewInits.size(),
2782                        AnyErrors);
2783 }
2784
2785 // TODO: this could be templated if the various decl types used the
2786 // same method name.
2787 static bool isInstantiationOf(ClassTemplateDecl *Pattern,
2788                               ClassTemplateDecl *Instance) {
2789   Pattern = Pattern->getCanonicalDecl();
2790
2791   do {
2792     Instance = Instance->getCanonicalDecl();
2793     if (Pattern == Instance) return true;
2794     Instance = Instance->getInstantiatedFromMemberTemplate();
2795   } while (Instance);
2796
2797   return false;
2798 }
2799
2800 static bool isInstantiationOf(FunctionTemplateDecl *Pattern,
2801                               FunctionTemplateDecl *Instance) {
2802   Pattern = Pattern->getCanonicalDecl();
2803
2804   do {
2805     Instance = Instance->getCanonicalDecl();
2806     if (Pattern == Instance) return true;
2807     Instance = Instance->getInstantiatedFromMemberTemplate();
2808   } while (Instance);
2809
2810   return false;
2811 }
2812
2813 static bool
2814 isInstantiationOf(ClassTemplatePartialSpecializationDecl *Pattern,
2815                   ClassTemplatePartialSpecializationDecl *Instance) {
2816   Pattern
2817     = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl());
2818   do {
2819     Instance = cast<ClassTemplatePartialSpecializationDecl>(
2820                                                 Instance->getCanonicalDecl());
2821     if (Pattern == Instance)
2822       return true;
2823     Instance = Instance->getInstantiatedFromMember();
2824   } while (Instance);
2825
2826   return false;
2827 }
2828
2829 static bool isInstantiationOf(CXXRecordDecl *Pattern,
2830                               CXXRecordDecl *Instance) {
2831   Pattern = Pattern->getCanonicalDecl();
2832
2833   do {
2834     Instance = Instance->getCanonicalDecl();
2835     if (Pattern == Instance) return true;
2836     Instance = Instance->getInstantiatedFromMemberClass();
2837   } while (Instance);
2838
2839   return false;
2840 }
2841
2842 static bool isInstantiationOf(FunctionDecl *Pattern,
2843                               FunctionDecl *Instance) {
2844   Pattern = Pattern->getCanonicalDecl();
2845
2846   do {
2847     Instance = Instance->getCanonicalDecl();
2848     if (Pattern == Instance) return true;
2849     Instance = Instance->getInstantiatedFromMemberFunction();
2850   } while (Instance);
2851
2852   return false;
2853 }
2854
2855 static bool isInstantiationOf(EnumDecl *Pattern,
2856                               EnumDecl *Instance) {
2857   Pattern = Pattern->getCanonicalDecl();
2858
2859   do {
2860     Instance = Instance->getCanonicalDecl();
2861     if (Pattern == Instance) return true;
2862     Instance = Instance->getInstantiatedFromMemberEnum();
2863   } while (Instance);
2864
2865   return false;
2866 }
2867
2868 static bool isInstantiationOf(UsingShadowDecl *Pattern,
2869                               UsingShadowDecl *Instance,
2870                               ASTContext &C) {
2871   return C.getInstantiatedFromUsingShadowDecl(Instance) == Pattern;
2872 }
2873
2874 static bool isInstantiationOf(UsingDecl *Pattern,
2875                               UsingDecl *Instance,
2876                               ASTContext &C) {
2877   return C.getInstantiatedFromUsingDecl(Instance) == Pattern;
2878 }
2879
2880 static bool isInstantiationOf(UnresolvedUsingValueDecl *Pattern,
2881                               UsingDecl *Instance,
2882                               ASTContext &C) {
2883   return C.getInstantiatedFromUsingDecl(Instance) == Pattern;
2884 }
2885
2886 static bool isInstantiationOf(UnresolvedUsingTypenameDecl *Pattern,
2887                               UsingDecl *Instance,
2888                               ASTContext &C) {
2889   return C.getInstantiatedFromUsingDecl(Instance) == Pattern;
2890 }
2891
2892 static bool isInstantiationOfStaticDataMember(VarDecl *Pattern,
2893                                               VarDecl *Instance) {
2894   assert(Instance->isStaticDataMember());
2895
2896   Pattern = Pattern->getCanonicalDecl();
2897
2898   do {
2899     Instance = Instance->getCanonicalDecl();
2900     if (Pattern == Instance) return true;
2901     Instance = Instance->getInstantiatedFromStaticDataMember();
2902   } while (Instance);
2903
2904   return false;
2905 }
2906
2907 // Other is the prospective instantiation
2908 // D is the prospective pattern
2909 static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) {
2910   if (D->getKind() != Other->getKind()) {
2911     if (UnresolvedUsingTypenameDecl *UUD
2912           = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
2913       if (UsingDecl *UD = dyn_cast<UsingDecl>(Other)) {
2914         return isInstantiationOf(UUD, UD, Ctx);
2915       }
2916     }
2917
2918     if (UnresolvedUsingValueDecl *UUD
2919           = dyn_cast<UnresolvedUsingValueDecl>(D)) {
2920       if (UsingDecl *UD = dyn_cast<UsingDecl>(Other)) {
2921         return isInstantiationOf(UUD, UD, Ctx);
2922       }
2923     }
2924
2925     return false;
2926   }
2927
2928   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Other))
2929     return isInstantiationOf(cast<CXXRecordDecl>(D), Record);
2930
2931   if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Other))
2932     return isInstantiationOf(cast<FunctionDecl>(D), Function);
2933
2934   if (EnumDecl *Enum = dyn_cast<EnumDecl>(Other))
2935     return isInstantiationOf(cast<EnumDecl>(D), Enum);
2936
2937   if (VarDecl *Var = dyn_cast<VarDecl>(Other))
2938     if (Var->isStaticDataMember())
2939       return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var);
2940
2941   if (ClassTemplateDecl *Temp = dyn_cast<ClassTemplateDecl>(Other))
2942     return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp);
2943
2944   if (FunctionTemplateDecl *Temp = dyn_cast<FunctionTemplateDecl>(Other))
2945     return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp);
2946
2947   if (ClassTemplatePartialSpecializationDecl *PartialSpec
2948         = dyn_cast<ClassTemplatePartialSpecializationDecl>(Other))
2949     return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D),
2950                              PartialSpec);
2951
2952   if (FieldDecl *Field = dyn_cast<FieldDecl>(Other)) {
2953     if (!Field->getDeclName()) {
2954       // This is an unnamed field.
2955       return Ctx.getInstantiatedFromUnnamedFieldDecl(Field) ==
2956         cast<FieldDecl>(D);
2957     }
2958   }
2959
2960   if (UsingDecl *Using = dyn_cast<UsingDecl>(Other))
2961     return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx);
2962
2963   if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(Other))
2964     return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx);
2965
2966   return D->getDeclName() && isa<NamedDecl>(Other) &&
2967     D->getDeclName() == cast<NamedDecl>(Other)->getDeclName();
2968 }
2969
2970 template<typename ForwardIterator>
2971 static NamedDecl *findInstantiationOf(ASTContext &Ctx,
2972                                       NamedDecl *D,
2973                                       ForwardIterator first,
2974                                       ForwardIterator last) {
2975   for (; first != last; ++first)
2976     if (isInstantiationOf(Ctx, D, *first))
2977       return cast<NamedDecl>(*first);
2978
2979   return 0;
2980 }
2981
2982 /// \brief Finds the instantiation of the given declaration context
2983 /// within the current instantiation.
2984 ///
2985 /// \returns NULL if there was an error
2986 DeclContext *Sema::FindInstantiatedContext(SourceLocation Loc, DeclContext* DC,
2987                           const MultiLevelTemplateArgumentList &TemplateArgs) {
2988   if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
2989     Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs);
2990     return cast_or_null<DeclContext>(ID);
2991   } else return DC;
2992 }
2993
2994 /// \brief Find the instantiation of the given declaration within the
2995 /// current instantiation.
2996 ///
2997 /// This routine is intended to be used when \p D is a declaration
2998 /// referenced from within a template, that needs to mapped into the
2999 /// corresponding declaration within an instantiation. For example,
3000 /// given:
3001 ///
3002 /// \code
3003 /// template<typename T>
3004 /// struct X {
3005 ///   enum Kind {
3006 ///     KnownValue = sizeof(T)
3007 ///   };
3008 ///
3009 ///   bool getKind() const { return KnownValue; }
3010 /// };
3011 ///
3012 /// template struct X<int>;
3013 /// \endcode
3014 ///
3015 /// In the instantiation of X<int>::getKind(), we need to map the
3016 /// EnumConstantDecl for KnownValue (which refers to
3017 /// X<T>::<Kind>::KnownValue) to its instantiation
3018 /// (X<int>::<Kind>::KnownValue). InstantiateCurrentDeclRef() performs
3019 /// this mapping from within the instantiation of X<int>.
3020 NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
3021                           const MultiLevelTemplateArgumentList &TemplateArgs) {
3022   DeclContext *ParentDC = D->getDeclContext();
3023   if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
3024       isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
3025       (ParentDC->isFunctionOrMethod() && ParentDC->isDependentContext())) {
3026     // D is a local of some kind. Look into the map of local
3027     // declarations to their instantiations.
3028     typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
3029     llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
3030       = CurrentInstantiationScope->findInstantiationOf(D);
3031
3032     if (Found) {
3033       if (Decl *FD = Found->dyn_cast<Decl *>())
3034         return cast<NamedDecl>(FD);
3035
3036       unsigned PackIdx = ArgumentPackSubstitutionIndex;
3037       return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]);
3038     }
3039
3040     // If we didn't find the decl, then we must have a label decl that hasn't
3041     // been found yet.  Lazily instantiate it and return it now.
3042     assert(isa<LabelDecl>(D));
3043
3044     Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
3045     assert(Inst && "Failed to instantiate label??");
3046
3047     CurrentInstantiationScope->InstantiatedLocal(D, Inst);
3048     return cast<LabelDecl>(Inst);
3049   }
3050
3051   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
3052     if (!Record->isDependentContext())
3053       return D;
3054
3055     // If the RecordDecl is actually the injected-class-name or a
3056     // "templated" declaration for a class template, class template
3057     // partial specialization, or a member class of a class template,
3058     // substitute into the injected-class-name of the class template
3059     // or partial specialization to find the new DeclContext.
3060     QualType T;
3061     ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate();
3062
3063     if (ClassTemplate) {
3064       T = ClassTemplate->getInjectedClassNameSpecialization();
3065     } else if (ClassTemplatePartialSpecializationDecl *PartialSpec
3066                  = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) {
3067       ClassTemplate = PartialSpec->getSpecializedTemplate();
3068
3069       // If we call SubstType with an InjectedClassNameType here we
3070       // can end up in an infinite loop.
3071       T = Context.getTypeDeclType(Record);
3072       assert(isa<InjectedClassNameType>(T) &&
3073              "type of partial specialization is not an InjectedClassNameType");
3074       T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType();
3075     }
3076
3077     if (!T.isNull()) {
3078       // Substitute into the injected-class-name to get the type
3079       // corresponding to the instantiation we want, which may also be
3080       // the current instantiation (if we're in a template
3081       // definition). This substitution should never fail, since we
3082       // know we can instantiate the injected-class-name or we
3083       // wouldn't have gotten to the injected-class-name!
3084
3085       // FIXME: Can we use the CurrentInstantiationScope to avoid this
3086       // extra instantiation in the common case?
3087       T = SubstType(T, TemplateArgs, Loc, DeclarationName());
3088       assert(!T.isNull() && "Instantiation of injected-class-name cannot fail.");
3089
3090       if (!T->isDependentType()) {
3091         assert(T->isRecordType() && "Instantiation must produce a record type");
3092         return T->getAs<RecordType>()->getDecl();
3093       }
3094
3095       // We are performing "partial" template instantiation to create
3096       // the member declarations for the members of a class template
3097       // specialization. Therefore, D is actually referring to something
3098       // in the current instantiation. Look through the current
3099       // context, which contains actual instantiations, to find the
3100       // instantiation of the "current instantiation" that D refers
3101       // to.
3102       bool SawNonDependentContext = false;
3103       for (DeclContext *DC = CurContext; !DC->isFileContext();
3104            DC = DC->getParent()) {
3105         if (ClassTemplateSpecializationDecl *Spec
3106                           = dyn_cast<ClassTemplateSpecializationDecl>(DC))
3107           if (isInstantiationOf(ClassTemplate,
3108                                 Spec->getSpecializedTemplate()))
3109             return Spec;
3110
3111         if (!DC->isDependentContext())
3112           SawNonDependentContext = true;
3113       }
3114
3115       // We're performing "instantiation" of a member of the current
3116       // instantiation while we are type-checking the
3117       // definition. Compute the declaration context and return that.
3118       assert(!SawNonDependentContext &&
3119              "No dependent context while instantiating record");
3120       DeclContext *DC = computeDeclContext(T);
3121       assert(DC &&
3122              "Unable to find declaration for the current instantiation");
3123       return cast<CXXRecordDecl>(DC);
3124     }
3125
3126     // Fall through to deal with other dependent record types (e.g.,
3127     // anonymous unions in class templates).
3128   }
3129
3130   if (!ParentDC->isDependentContext())
3131     return D;
3132
3133   ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs);
3134   if (!ParentDC)
3135     return 0;
3136
3137   if (ParentDC != D->getDeclContext()) {
3138     // We performed some kind of instantiation in the parent context,
3139     // so now we need to look into the instantiated parent context to
3140     // find the instantiation of the declaration D.
3141
3142     // If our context used to be dependent, we may need to instantiate
3143     // it before performing lookup into that context.
3144     bool IsBeingInstantiated = false;
3145     if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
3146       if (!Spec->isDependentContext()) {
3147         QualType T = Context.getTypeDeclType(Spec);
3148         const RecordType *Tag = T->getAs<RecordType>();
3149         assert(Tag && "type of non-dependent record is not a RecordType");
3150         if (Tag->isBeingDefined())
3151           IsBeingInstantiated = true;
3152         if (!Tag->isBeingDefined() &&
3153             RequireCompleteType(Loc, T, diag::err_incomplete_type))
3154           return 0;
3155
3156         ParentDC = Tag->getDecl();
3157       }
3158     }
3159
3160     NamedDecl *Result = 0;
3161     if (D->getDeclName()) {
3162       DeclContext::lookup_result Found = ParentDC->lookup(D->getDeclName());
3163       Result = findInstantiationOf(Context, D, Found.first, Found.second);
3164     } else {
3165       // Since we don't have a name for the entity we're looking for,
3166       // our only option is to walk through all of the declarations to
3167       // find that name. This will occur in a few cases:
3168       //
3169       //   - anonymous struct/union within a template
3170       //   - unnamed class/struct/union/enum within a template
3171       //
3172       // FIXME: Find a better way to find these instantiations!
3173       Result = findInstantiationOf(Context, D,
3174                                    ParentDC->decls_begin(),
3175                                    ParentDC->decls_end());
3176     }
3177
3178     if (!Result) {
3179       if (isa<UsingShadowDecl>(D)) {
3180         // UsingShadowDecls can instantiate to nothing because of using hiding.
3181       } else if (Diags.hasErrorOccurred()) {
3182         // We've already complained about something, so most likely this
3183         // declaration failed to instantiate. There's no point in complaining
3184         // further, since this is normal in invalid code.
3185       } else if (IsBeingInstantiated) {
3186         // The class in which this member exists is currently being
3187         // instantiated, and we haven't gotten around to instantiating this
3188         // member yet. This can happen when the code uses forward declarations
3189         // of member classes, and introduces ordering dependencies via
3190         // template instantiation.
3191         Diag(Loc, diag::err_member_not_yet_instantiated)
3192           << D->getDeclName()
3193           << Context.getTypeDeclType(cast<CXXRecordDecl>(ParentDC));
3194         Diag(D->getLocation(), diag::note_non_instantiated_member_here);
3195       } else {
3196         // We should have found something, but didn't.
3197         llvm_unreachable("Unable to find instantiation of declaration!");
3198       }
3199     }
3200
3201     D = Result;
3202   }
3203
3204   return D;
3205 }
3206
3207 /// \brief Performs template instantiation for all implicit template
3208 /// instantiations we have seen until this point.
3209 void Sema::PerformPendingInstantiations(bool LocalOnly) {
3210   while (!PendingLocalImplicitInstantiations.empty() ||
3211          (!LocalOnly && !PendingInstantiations.empty())) {
3212     PendingImplicitInstantiation Inst;
3213
3214     if (PendingLocalImplicitInstantiations.empty()) {
3215       Inst = PendingInstantiations.front();
3216       PendingInstantiations.pop_front();
3217     } else {
3218       Inst = PendingLocalImplicitInstantiations.front();
3219       PendingLocalImplicitInstantiations.pop_front();
3220     }
3221
3222     // Instantiate function definitions
3223     if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) {
3224       PrettyDeclStackTraceEntry CrashInfo(*this, Function, SourceLocation(),
3225                                           "instantiating function definition");
3226       bool DefinitionRequired = Function->getTemplateSpecializationKind() ==
3227                                 TSK_ExplicitInstantiationDefinition;
3228       InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true,
3229                                     DefinitionRequired);
3230       continue;
3231     }
3232
3233     // Instantiate static data member definitions.
3234     VarDecl *Var = cast<VarDecl>(Inst.first);
3235     assert(Var->isStaticDataMember() && "Not a static data member?");
3236
3237     // Don't try to instantiate declarations if the most recent redeclaration
3238     // is invalid.
3239     if (Var->getMostRecentDeclaration()->isInvalidDecl())
3240       continue;
3241
3242     // Check if the most recent declaration has changed the specialization kind
3243     // and removed the need for implicit instantiation.
3244     switch (Var->getMostRecentDeclaration()->getTemplateSpecializationKind()) {
3245     case TSK_Undeclared:
3246       assert(false && "Cannot instantitiate an undeclared specialization.");
3247     case TSK_ExplicitInstantiationDeclaration:
3248     case TSK_ExplicitSpecialization:
3249       continue;  // No longer need to instantiate this type.
3250     case TSK_ExplicitInstantiationDefinition:
3251       // We only need an instantiation if the pending instantiation *is* the
3252       // explicit instantiation.
3253       if (Var != Var->getMostRecentDeclaration()) continue;
3254     case TSK_ImplicitInstantiation:
3255       break;
3256     }
3257
3258     PrettyDeclStackTraceEntry CrashInfo(*this, Var, Var->getLocation(),
3259                                         "instantiating static data member "
3260                                         "definition");
3261
3262     bool DefinitionRequired = Var->getTemplateSpecializationKind() ==
3263                               TSK_ExplicitInstantiationDefinition;
3264     InstantiateStaticDataMemberDefinition(/*FIXME:*/Inst.second, Var, true,
3265                                           DefinitionRequired);
3266   }
3267 }
3268
3269 void Sema::PerformDependentDiagnostics(const DeclContext *Pattern,
3270                        const MultiLevelTemplateArgumentList &TemplateArgs) {
3271   for (DeclContext::ddiag_iterator I = Pattern->ddiag_begin(),
3272          E = Pattern->ddiag_end(); I != E; ++I) {
3273     DependentDiagnostic *DD = *I;
3274
3275     switch (DD->getKind()) {
3276     case DependentDiagnostic::Access:
3277       HandleDependentAccessCheck(*DD, TemplateArgs);
3278       break;
3279     }
3280   }
3281 }