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