1 //===------- SemaTemplateInstantiate.cpp - C++ Template 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. 10 // 11 //===----------------------------------------------------------------------===/ 12 13 #include "clang/Sema/SemaInternal.h" 14 #include "TreeTransform.h" 15 #include "clang/Sema/DeclSpec.h" 16 #include "clang/Sema/Initialization.h" 17 #include "clang/Sema/Lookup.h" 18 #include "clang/Sema/Template.h" 19 #include "clang/Sema/TemplateDeduction.h" 20 #include "clang/AST/ASTConsumer.h" 21 #include "clang/AST/ASTContext.h" 22 #include "clang/AST/Expr.h" 23 #include "clang/AST/DeclTemplate.h" 24 #include "clang/Basic/LangOptions.h" 25 26 using namespace clang; 27 using namespace sema; 28 29 //===----------------------------------------------------------------------===/ 30 // Template Instantiation Support 31 //===----------------------------------------------------------------------===/ 32 33 /// \brief Retrieve the template argument list(s) that should be used to 34 /// instantiate the definition of the given declaration. 35 /// 36 /// \param D the declaration for which we are computing template instantiation 37 /// arguments. 38 /// 39 /// \param Innermost if non-NULL, the innermost template argument list. 40 /// 41 /// \param RelativeToPrimary true if we should get the template 42 /// arguments relative to the primary template, even when we're 43 /// dealing with a specialization. This is only relevant for function 44 /// template specializations. 45 /// 46 /// \param Pattern If non-NULL, indicates the pattern from which we will be 47 /// instantiating the definition of the given declaration, \p D. This is 48 /// used to determine the proper set of template instantiation arguments for 49 /// friend function template specializations. 50 MultiLevelTemplateArgumentList 51 Sema::getTemplateInstantiationArgs(NamedDecl *D, 52 const TemplateArgumentList *Innermost, 53 bool RelativeToPrimary, 54 const FunctionDecl *Pattern) { 55 // Accumulate the set of template argument lists in this structure. 56 MultiLevelTemplateArgumentList Result; 57 58 if (Innermost) 59 Result.addOuterTemplateArguments(Innermost); 60 61 DeclContext *Ctx = dyn_cast<DeclContext>(D); 62 if (!Ctx) { 63 Ctx = D->getDeclContext(); 64 65 // If we have a template template parameter with translation unit context, 66 // then we're performing substitution into a default template argument of 67 // this template template parameter before we've constructed the template 68 // that will own this template template parameter. In this case, we 69 // use empty template parameter lists for all of the outer templates 70 // to avoid performing any substitutions. 71 if (Ctx->isTranslationUnit()) { 72 if (TemplateTemplateParmDecl *TTP 73 = dyn_cast<TemplateTemplateParmDecl>(D)) { 74 for (unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I) 75 Result.addOuterTemplateArguments(0, 0); 76 return Result; 77 } 78 } 79 } 80 81 while (!Ctx->isFileContext()) { 82 // Add template arguments from a class template instantiation. 83 if (ClassTemplateSpecializationDecl *Spec 84 = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) { 85 // We're done when we hit an explicit specialization. 86 if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization && 87 !isa<ClassTemplatePartialSpecializationDecl>(Spec)) 88 break; 89 90 Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs()); 91 92 // If this class template specialization was instantiated from a 93 // specialized member that is a class template, we're done. 94 assert(Spec->getSpecializedTemplate() && "No class template?"); 95 if (Spec->getSpecializedTemplate()->isMemberSpecialization()) 96 break; 97 } 98 // Add template arguments from a function template specialization. 99 else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) { 100 if (!RelativeToPrimary && 101 (Function->getTemplateSpecializationKind() == 102 TSK_ExplicitSpecialization && 103 !Function->getClassScopeSpecializationPattern())) 104 break; 105 106 if (const TemplateArgumentList *TemplateArgs 107 = Function->getTemplateSpecializationArgs()) { 108 // Add the template arguments for this specialization. 109 Result.addOuterTemplateArguments(TemplateArgs); 110 111 // If this function was instantiated from a specialized member that is 112 // a function template, we're done. 113 assert(Function->getPrimaryTemplate() && "No function template?"); 114 if (Function->getPrimaryTemplate()->isMemberSpecialization()) 115 break; 116 } else if (FunctionTemplateDecl *FunTmpl 117 = Function->getDescribedFunctionTemplate()) { 118 // Add the "injected" template arguments. 119 std::pair<const TemplateArgument *, unsigned> 120 Injected = FunTmpl->getInjectedTemplateArgs(); 121 Result.addOuterTemplateArguments(Injected.first, Injected.second); 122 } 123 124 // If this is a friend declaration and it declares an entity at 125 // namespace scope, take arguments from its lexical parent 126 // instead of its semantic parent, unless of course the pattern we're 127 // instantiating actually comes from the file's context! 128 if (Function->getFriendObjectKind() && 129 Function->getDeclContext()->isFileContext() && 130 (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) { 131 Ctx = Function->getLexicalDeclContext(); 132 RelativeToPrimary = false; 133 continue; 134 } 135 } else if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) { 136 if (ClassTemplateDecl *ClassTemplate = Rec->getDescribedClassTemplate()) { 137 QualType T = ClassTemplate->getInjectedClassNameSpecialization(); 138 const TemplateSpecializationType *TST 139 = cast<TemplateSpecializationType>(Context.getCanonicalType(T)); 140 Result.addOuterTemplateArguments(TST->getArgs(), TST->getNumArgs()); 141 if (ClassTemplate->isMemberSpecialization()) 142 break; 143 } 144 } 145 146 Ctx = Ctx->getParent(); 147 RelativeToPrimary = false; 148 } 149 150 return Result; 151 } 152 153 bool Sema::ActiveTemplateInstantiation::isInstantiationRecord() const { 154 switch (Kind) { 155 case TemplateInstantiation: 156 case ExceptionSpecInstantiation: 157 case DefaultTemplateArgumentInstantiation: 158 case DefaultFunctionArgumentInstantiation: 159 case ExplicitTemplateArgumentSubstitution: 160 case DeducedTemplateArgumentSubstitution: 161 case PriorTemplateArgumentSubstitution: 162 return true; 163 164 case DefaultTemplateArgumentChecking: 165 return false; 166 } 167 168 llvm_unreachable("Invalid InstantiationKind!"); 169 } 170 171 Sema::InstantiatingTemplate:: 172 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 173 Decl *Entity, 174 SourceRange InstantiationRange) 175 : SemaRef(SemaRef), 176 SavedInNonInstantiationSFINAEContext( 177 SemaRef.InNonInstantiationSFINAEContext) 178 { 179 Invalid = CheckInstantiationDepth(PointOfInstantiation, 180 InstantiationRange); 181 if (!Invalid) { 182 ActiveTemplateInstantiation Inst; 183 Inst.Kind = ActiveTemplateInstantiation::TemplateInstantiation; 184 Inst.PointOfInstantiation = PointOfInstantiation; 185 Inst.Entity = reinterpret_cast<uintptr_t>(Entity); 186 Inst.TemplateArgs = 0; 187 Inst.NumTemplateArgs = 0; 188 Inst.InstantiationRange = InstantiationRange; 189 SemaRef.InNonInstantiationSFINAEContext = false; 190 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 191 } 192 } 193 194 Sema::InstantiatingTemplate:: 195 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 196 FunctionDecl *Entity, ExceptionSpecification, 197 SourceRange InstantiationRange) 198 : SemaRef(SemaRef), 199 SavedInNonInstantiationSFINAEContext( 200 SemaRef.InNonInstantiationSFINAEContext) 201 { 202 Invalid = CheckInstantiationDepth(PointOfInstantiation, 203 InstantiationRange); 204 if (!Invalid) { 205 ActiveTemplateInstantiation Inst; 206 Inst.Kind = ActiveTemplateInstantiation::ExceptionSpecInstantiation; 207 Inst.PointOfInstantiation = PointOfInstantiation; 208 Inst.Entity = reinterpret_cast<uintptr_t>(Entity); 209 Inst.TemplateArgs = 0; 210 Inst.NumTemplateArgs = 0; 211 Inst.InstantiationRange = InstantiationRange; 212 SemaRef.InNonInstantiationSFINAEContext = false; 213 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 214 } 215 } 216 217 Sema::InstantiatingTemplate:: 218 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 219 TemplateDecl *Template, 220 ArrayRef<TemplateArgument> TemplateArgs, 221 SourceRange InstantiationRange) 222 : SemaRef(SemaRef), 223 SavedInNonInstantiationSFINAEContext( 224 SemaRef.InNonInstantiationSFINAEContext) 225 { 226 Invalid = CheckInstantiationDepth(PointOfInstantiation, 227 InstantiationRange); 228 if (!Invalid) { 229 ActiveTemplateInstantiation Inst; 230 Inst.Kind 231 = ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation; 232 Inst.PointOfInstantiation = PointOfInstantiation; 233 Inst.Entity = reinterpret_cast<uintptr_t>(Template); 234 Inst.TemplateArgs = TemplateArgs.data(); 235 Inst.NumTemplateArgs = TemplateArgs.size(); 236 Inst.InstantiationRange = InstantiationRange; 237 SemaRef.InNonInstantiationSFINAEContext = false; 238 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 239 } 240 } 241 242 Sema::InstantiatingTemplate:: 243 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 244 FunctionTemplateDecl *FunctionTemplate, 245 ArrayRef<TemplateArgument> TemplateArgs, 246 ActiveTemplateInstantiation::InstantiationKind Kind, 247 sema::TemplateDeductionInfo &DeductionInfo, 248 SourceRange InstantiationRange) 249 : SemaRef(SemaRef), 250 SavedInNonInstantiationSFINAEContext( 251 SemaRef.InNonInstantiationSFINAEContext) 252 { 253 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange); 254 if (!Invalid) { 255 ActiveTemplateInstantiation Inst; 256 Inst.Kind = Kind; 257 Inst.PointOfInstantiation = PointOfInstantiation; 258 Inst.Entity = reinterpret_cast<uintptr_t>(FunctionTemplate); 259 Inst.TemplateArgs = TemplateArgs.data(); 260 Inst.NumTemplateArgs = TemplateArgs.size(); 261 Inst.DeductionInfo = &DeductionInfo; 262 Inst.InstantiationRange = InstantiationRange; 263 SemaRef.InNonInstantiationSFINAEContext = false; 264 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 265 266 if (!Inst.isInstantiationRecord()) 267 ++SemaRef.NonInstantiationEntries; 268 } 269 } 270 271 Sema::InstantiatingTemplate:: 272 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 273 ClassTemplatePartialSpecializationDecl *PartialSpec, 274 ArrayRef<TemplateArgument> TemplateArgs, 275 sema::TemplateDeductionInfo &DeductionInfo, 276 SourceRange InstantiationRange) 277 : SemaRef(SemaRef), 278 SavedInNonInstantiationSFINAEContext( 279 SemaRef.InNonInstantiationSFINAEContext) 280 { 281 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange); 282 if (!Invalid) { 283 ActiveTemplateInstantiation Inst; 284 Inst.Kind = ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution; 285 Inst.PointOfInstantiation = PointOfInstantiation; 286 Inst.Entity = reinterpret_cast<uintptr_t>(PartialSpec); 287 Inst.TemplateArgs = TemplateArgs.data(); 288 Inst.NumTemplateArgs = TemplateArgs.size(); 289 Inst.DeductionInfo = &DeductionInfo; 290 Inst.InstantiationRange = InstantiationRange; 291 SemaRef.InNonInstantiationSFINAEContext = false; 292 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 293 } 294 } 295 296 Sema::InstantiatingTemplate:: 297 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 298 ParmVarDecl *Param, 299 ArrayRef<TemplateArgument> TemplateArgs, 300 SourceRange InstantiationRange) 301 : SemaRef(SemaRef), 302 SavedInNonInstantiationSFINAEContext( 303 SemaRef.InNonInstantiationSFINAEContext) 304 { 305 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange); 306 if (!Invalid) { 307 ActiveTemplateInstantiation Inst; 308 Inst.Kind 309 = ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation; 310 Inst.PointOfInstantiation = PointOfInstantiation; 311 Inst.Entity = reinterpret_cast<uintptr_t>(Param); 312 Inst.TemplateArgs = TemplateArgs.data(); 313 Inst.NumTemplateArgs = TemplateArgs.size(); 314 Inst.InstantiationRange = InstantiationRange; 315 SemaRef.InNonInstantiationSFINAEContext = false; 316 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 317 } 318 } 319 320 Sema::InstantiatingTemplate:: 321 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 322 NamedDecl *Template, NonTypeTemplateParmDecl *Param, 323 ArrayRef<TemplateArgument> TemplateArgs, 324 SourceRange InstantiationRange) 325 : SemaRef(SemaRef), 326 SavedInNonInstantiationSFINAEContext( 327 SemaRef.InNonInstantiationSFINAEContext) 328 { 329 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange); 330 if (!Invalid) { 331 ActiveTemplateInstantiation Inst; 332 Inst.Kind = ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution; 333 Inst.PointOfInstantiation = PointOfInstantiation; 334 Inst.Template = Template; 335 Inst.Entity = reinterpret_cast<uintptr_t>(Param); 336 Inst.TemplateArgs = TemplateArgs.data(); 337 Inst.NumTemplateArgs = TemplateArgs.size(); 338 Inst.InstantiationRange = InstantiationRange; 339 SemaRef.InNonInstantiationSFINAEContext = false; 340 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 341 } 342 } 343 344 Sema::InstantiatingTemplate:: 345 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 346 NamedDecl *Template, TemplateTemplateParmDecl *Param, 347 ArrayRef<TemplateArgument> TemplateArgs, 348 SourceRange InstantiationRange) 349 : SemaRef(SemaRef), 350 SavedInNonInstantiationSFINAEContext( 351 SemaRef.InNonInstantiationSFINAEContext) 352 { 353 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange); 354 if (!Invalid) { 355 ActiveTemplateInstantiation Inst; 356 Inst.Kind = ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution; 357 Inst.PointOfInstantiation = PointOfInstantiation; 358 Inst.Template = Template; 359 Inst.Entity = reinterpret_cast<uintptr_t>(Param); 360 Inst.TemplateArgs = TemplateArgs.data(); 361 Inst.NumTemplateArgs = TemplateArgs.size(); 362 Inst.InstantiationRange = InstantiationRange; 363 SemaRef.InNonInstantiationSFINAEContext = false; 364 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 365 } 366 } 367 368 Sema::InstantiatingTemplate:: 369 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 370 TemplateDecl *Template, NamedDecl *Param, 371 ArrayRef<TemplateArgument> TemplateArgs, 372 SourceRange InstantiationRange) 373 : SemaRef(SemaRef), 374 SavedInNonInstantiationSFINAEContext( 375 SemaRef.InNonInstantiationSFINAEContext) 376 { 377 Invalid = false; 378 379 ActiveTemplateInstantiation Inst; 380 Inst.Kind = ActiveTemplateInstantiation::DefaultTemplateArgumentChecking; 381 Inst.PointOfInstantiation = PointOfInstantiation; 382 Inst.Template = Template; 383 Inst.Entity = reinterpret_cast<uintptr_t>(Param); 384 Inst.TemplateArgs = TemplateArgs.data(); 385 Inst.NumTemplateArgs = TemplateArgs.size(); 386 Inst.InstantiationRange = InstantiationRange; 387 SemaRef.InNonInstantiationSFINAEContext = false; 388 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 389 390 assert(!Inst.isInstantiationRecord()); 391 ++SemaRef.NonInstantiationEntries; 392 } 393 394 void Sema::InstantiatingTemplate::Clear() { 395 if (!Invalid) { 396 if (!SemaRef.ActiveTemplateInstantiations.back().isInstantiationRecord()) { 397 assert(SemaRef.NonInstantiationEntries > 0); 398 --SemaRef.NonInstantiationEntries; 399 } 400 SemaRef.InNonInstantiationSFINAEContext 401 = SavedInNonInstantiationSFINAEContext; 402 SemaRef.ActiveTemplateInstantiations.pop_back(); 403 Invalid = true; 404 } 405 } 406 407 bool Sema::InstantiatingTemplate::CheckInstantiationDepth( 408 SourceLocation PointOfInstantiation, 409 SourceRange InstantiationRange) { 410 assert(SemaRef.NonInstantiationEntries <= 411 SemaRef.ActiveTemplateInstantiations.size()); 412 if ((SemaRef.ActiveTemplateInstantiations.size() - 413 SemaRef.NonInstantiationEntries) 414 <= SemaRef.getLangOpts().InstantiationDepth) 415 return false; 416 417 SemaRef.Diag(PointOfInstantiation, 418 diag::err_template_recursion_depth_exceeded) 419 << SemaRef.getLangOpts().InstantiationDepth 420 << InstantiationRange; 421 SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth) 422 << SemaRef.getLangOpts().InstantiationDepth; 423 return true; 424 } 425 426 /// \brief Prints the current instantiation stack through a series of 427 /// notes. 428 void Sema::PrintInstantiationStack() { 429 // Determine which template instantiations to skip, if any. 430 unsigned SkipStart = ActiveTemplateInstantiations.size(), SkipEnd = SkipStart; 431 unsigned Limit = Diags.getTemplateBacktraceLimit(); 432 if (Limit && Limit < ActiveTemplateInstantiations.size()) { 433 SkipStart = Limit / 2 + Limit % 2; 434 SkipEnd = ActiveTemplateInstantiations.size() - Limit / 2; 435 } 436 437 // FIXME: In all of these cases, we need to show the template arguments 438 unsigned InstantiationIdx = 0; 439 for (SmallVector<ActiveTemplateInstantiation, 16>::reverse_iterator 440 Active = ActiveTemplateInstantiations.rbegin(), 441 ActiveEnd = ActiveTemplateInstantiations.rend(); 442 Active != ActiveEnd; 443 ++Active, ++InstantiationIdx) { 444 // Skip this instantiation? 445 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) { 446 if (InstantiationIdx == SkipStart) { 447 // Note that we're skipping instantiations. 448 Diags.Report(Active->PointOfInstantiation, 449 diag::note_instantiation_contexts_suppressed) 450 << unsigned(ActiveTemplateInstantiations.size() - Limit); 451 } 452 continue; 453 } 454 455 switch (Active->Kind) { 456 case ActiveTemplateInstantiation::TemplateInstantiation: { 457 Decl *D = reinterpret_cast<Decl *>(Active->Entity); 458 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) { 459 unsigned DiagID = diag::note_template_member_class_here; 460 if (isa<ClassTemplateSpecializationDecl>(Record)) 461 DiagID = diag::note_template_class_instantiation_here; 462 Diags.Report(Active->PointOfInstantiation, DiagID) 463 << Context.getTypeDeclType(Record) 464 << Active->InstantiationRange; 465 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 466 unsigned DiagID; 467 if (Function->getPrimaryTemplate()) 468 DiagID = diag::note_function_template_spec_here; 469 else 470 DiagID = diag::note_template_member_function_here; 471 Diags.Report(Active->PointOfInstantiation, DiagID) 472 << Function 473 << Active->InstantiationRange; 474 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 475 Diags.Report(Active->PointOfInstantiation, 476 diag::note_template_static_data_member_def_here) 477 << VD 478 << Active->InstantiationRange; 479 } else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) { 480 Diags.Report(Active->PointOfInstantiation, 481 diag::note_template_enum_def_here) 482 << ED 483 << Active->InstantiationRange; 484 } else { 485 Diags.Report(Active->PointOfInstantiation, 486 diag::note_template_type_alias_instantiation_here) 487 << cast<TypeAliasTemplateDecl>(D) 488 << Active->InstantiationRange; 489 } 490 break; 491 } 492 493 case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation: { 494 TemplateDecl *Template = cast<TemplateDecl>((Decl *)Active->Entity); 495 std::string TemplateArgsStr 496 = TemplateSpecializationType::PrintTemplateArgumentList( 497 Active->TemplateArgs, 498 Active->NumTemplateArgs, 499 getPrintingPolicy()); 500 Diags.Report(Active->PointOfInstantiation, 501 diag::note_default_arg_instantiation_here) 502 << (Template->getNameAsString() + TemplateArgsStr) 503 << Active->InstantiationRange; 504 break; 505 } 506 507 case ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution: { 508 FunctionTemplateDecl *FnTmpl 509 = cast<FunctionTemplateDecl>((Decl *)Active->Entity); 510 Diags.Report(Active->PointOfInstantiation, 511 diag::note_explicit_template_arg_substitution_here) 512 << FnTmpl 513 << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(), 514 Active->TemplateArgs, 515 Active->NumTemplateArgs) 516 << Active->InstantiationRange; 517 break; 518 } 519 520 case ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution: 521 if (ClassTemplatePartialSpecializationDecl *PartialSpec 522 = dyn_cast<ClassTemplatePartialSpecializationDecl>( 523 (Decl *)Active->Entity)) { 524 Diags.Report(Active->PointOfInstantiation, 525 diag::note_partial_spec_deduct_instantiation_here) 526 << Context.getTypeDeclType(PartialSpec) 527 << getTemplateArgumentBindingsText( 528 PartialSpec->getTemplateParameters(), 529 Active->TemplateArgs, 530 Active->NumTemplateArgs) 531 << Active->InstantiationRange; 532 } else { 533 FunctionTemplateDecl *FnTmpl 534 = cast<FunctionTemplateDecl>((Decl *)Active->Entity); 535 Diags.Report(Active->PointOfInstantiation, 536 diag::note_function_template_deduction_instantiation_here) 537 << FnTmpl 538 << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(), 539 Active->TemplateArgs, 540 Active->NumTemplateArgs) 541 << Active->InstantiationRange; 542 } 543 break; 544 545 case ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation: { 546 ParmVarDecl *Param = cast<ParmVarDecl>((Decl *)Active->Entity); 547 FunctionDecl *FD = cast<FunctionDecl>(Param->getDeclContext()); 548 549 std::string TemplateArgsStr 550 = TemplateSpecializationType::PrintTemplateArgumentList( 551 Active->TemplateArgs, 552 Active->NumTemplateArgs, 553 getPrintingPolicy()); 554 Diags.Report(Active->PointOfInstantiation, 555 diag::note_default_function_arg_instantiation_here) 556 << (FD->getNameAsString() + TemplateArgsStr) 557 << Active->InstantiationRange; 558 break; 559 } 560 561 case ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution: { 562 NamedDecl *Parm = cast<NamedDecl>((Decl *)Active->Entity); 563 std::string Name; 564 if (!Parm->getName().empty()) 565 Name = std::string(" '") + Parm->getName().str() + "'"; 566 567 TemplateParameterList *TemplateParams = 0; 568 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template)) 569 TemplateParams = Template->getTemplateParameters(); 570 else 571 TemplateParams = 572 cast<ClassTemplatePartialSpecializationDecl>(Active->Template) 573 ->getTemplateParameters(); 574 Diags.Report(Active->PointOfInstantiation, 575 diag::note_prior_template_arg_substitution) 576 << isa<TemplateTemplateParmDecl>(Parm) 577 << Name 578 << getTemplateArgumentBindingsText(TemplateParams, 579 Active->TemplateArgs, 580 Active->NumTemplateArgs) 581 << Active->InstantiationRange; 582 break; 583 } 584 585 case ActiveTemplateInstantiation::DefaultTemplateArgumentChecking: { 586 TemplateParameterList *TemplateParams = 0; 587 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template)) 588 TemplateParams = Template->getTemplateParameters(); 589 else 590 TemplateParams = 591 cast<ClassTemplatePartialSpecializationDecl>(Active->Template) 592 ->getTemplateParameters(); 593 594 Diags.Report(Active->PointOfInstantiation, 595 diag::note_template_default_arg_checking) 596 << getTemplateArgumentBindingsText(TemplateParams, 597 Active->TemplateArgs, 598 Active->NumTemplateArgs) 599 << Active->InstantiationRange; 600 break; 601 } 602 603 case ActiveTemplateInstantiation::ExceptionSpecInstantiation: 604 Diags.Report(Active->PointOfInstantiation, 605 diag::note_template_exception_spec_instantiation_here) 606 << cast<FunctionDecl>((Decl *)Active->Entity) 607 << Active->InstantiationRange; 608 break; 609 } 610 } 611 } 612 613 llvm::Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const { 614 if (InNonInstantiationSFINAEContext) 615 return llvm::Optional<TemplateDeductionInfo *>(0); 616 617 for (SmallVector<ActiveTemplateInstantiation, 16>::const_reverse_iterator 618 Active = ActiveTemplateInstantiations.rbegin(), 619 ActiveEnd = ActiveTemplateInstantiations.rend(); 620 Active != ActiveEnd; 621 ++Active) 622 { 623 switch(Active->Kind) { 624 case ActiveTemplateInstantiation::TemplateInstantiation: 625 // An instantiation of an alias template may or may not be a SFINAE 626 // context, depending on what else is on the stack. 627 if (isa<TypeAliasTemplateDecl>(reinterpret_cast<Decl *>(Active->Entity))) 628 break; 629 // Fall through. 630 case ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation: 631 case ActiveTemplateInstantiation::ExceptionSpecInstantiation: 632 // This is a template instantiation, so there is no SFINAE. 633 return llvm::Optional<TemplateDeductionInfo *>(); 634 635 case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation: 636 case ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution: 637 case ActiveTemplateInstantiation::DefaultTemplateArgumentChecking: 638 // A default template argument instantiation and substitution into 639 // template parameters with arguments for prior parameters may or may 640 // not be a SFINAE context; look further up the stack. 641 break; 642 643 case ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution: 644 case ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution: 645 // We're either substitution explicitly-specified template arguments 646 // or deduced template arguments, so SFINAE applies. 647 assert(Active->DeductionInfo && "Missing deduction info pointer"); 648 return Active->DeductionInfo; 649 } 650 } 651 652 return llvm::Optional<TemplateDeductionInfo *>(); 653 } 654 655 /// \brief Retrieve the depth and index of a parameter pack. 656 static std::pair<unsigned, unsigned> 657 getDepthAndIndex(NamedDecl *ND) { 658 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND)) 659 return std::make_pair(TTP->getDepth(), TTP->getIndex()); 660 661 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND)) 662 return std::make_pair(NTTP->getDepth(), NTTP->getIndex()); 663 664 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND); 665 return std::make_pair(TTP->getDepth(), TTP->getIndex()); 666 } 667 668 //===----------------------------------------------------------------------===/ 669 // Template Instantiation for Types 670 //===----------------------------------------------------------------------===/ 671 namespace { 672 class TemplateInstantiator : public TreeTransform<TemplateInstantiator> { 673 const MultiLevelTemplateArgumentList &TemplateArgs; 674 SourceLocation Loc; 675 DeclarationName Entity; 676 677 public: 678 typedef TreeTransform<TemplateInstantiator> inherited; 679 680 TemplateInstantiator(Sema &SemaRef, 681 const MultiLevelTemplateArgumentList &TemplateArgs, 682 SourceLocation Loc, 683 DeclarationName Entity) 684 : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc), 685 Entity(Entity) { } 686 687 /// \brief Determine whether the given type \p T has already been 688 /// transformed. 689 /// 690 /// For the purposes of template instantiation, a type has already been 691 /// transformed if it is NULL or if it is not dependent. 692 bool AlreadyTransformed(QualType T); 693 694 /// \brief Returns the location of the entity being instantiated, if known. 695 SourceLocation getBaseLocation() { return Loc; } 696 697 /// \brief Returns the name of the entity being instantiated, if any. 698 DeclarationName getBaseEntity() { return Entity; } 699 700 /// \brief Sets the "base" location and entity when that 701 /// information is known based on another transformation. 702 void setBase(SourceLocation Loc, DeclarationName Entity) { 703 this->Loc = Loc; 704 this->Entity = Entity; 705 } 706 707 bool TryExpandParameterPacks(SourceLocation EllipsisLoc, 708 SourceRange PatternRange, 709 llvm::ArrayRef<UnexpandedParameterPack> Unexpanded, 710 bool &ShouldExpand, 711 bool &RetainExpansion, 712 llvm::Optional<unsigned> &NumExpansions) { 713 return getSema().CheckParameterPacksForExpansion(EllipsisLoc, 714 PatternRange, Unexpanded, 715 TemplateArgs, 716 ShouldExpand, 717 RetainExpansion, 718 NumExpansions); 719 } 720 721 void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { 722 SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(Pack); 723 } 724 725 TemplateArgument ForgetPartiallySubstitutedPack() { 726 TemplateArgument Result; 727 if (NamedDecl *PartialPack 728 = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){ 729 MultiLevelTemplateArgumentList &TemplateArgs 730 = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs); 731 unsigned Depth, Index; 732 llvm::tie(Depth, Index) = getDepthAndIndex(PartialPack); 733 if (TemplateArgs.hasTemplateArgument(Depth, Index)) { 734 Result = TemplateArgs(Depth, Index); 735 TemplateArgs.setArgument(Depth, Index, TemplateArgument()); 736 } 737 } 738 739 return Result; 740 } 741 742 void RememberPartiallySubstitutedPack(TemplateArgument Arg) { 743 if (Arg.isNull()) 744 return; 745 746 if (NamedDecl *PartialPack 747 = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){ 748 MultiLevelTemplateArgumentList &TemplateArgs 749 = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs); 750 unsigned Depth, Index; 751 llvm::tie(Depth, Index) = getDepthAndIndex(PartialPack); 752 TemplateArgs.setArgument(Depth, Index, Arg); 753 } 754 } 755 756 /// \brief Transform the given declaration by instantiating a reference to 757 /// this declaration. 758 Decl *TransformDecl(SourceLocation Loc, Decl *D); 759 760 void transformAttrs(Decl *Old, Decl *New) { 761 SemaRef.InstantiateAttrs(TemplateArgs, Old, New); 762 } 763 764 void transformedLocalDecl(Decl *Old, Decl *New) { 765 SemaRef.CurrentInstantiationScope->InstantiatedLocal(Old, New); 766 } 767 768 /// \brief Transform the definition of the given declaration by 769 /// instantiating it. 770 Decl *TransformDefinition(SourceLocation Loc, Decl *D); 771 772 /// \bried Transform the first qualifier within a scope by instantiating the 773 /// declaration. 774 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc); 775 776 /// \brief Rebuild the exception declaration and register the declaration 777 /// as an instantiated local. 778 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, 779 TypeSourceInfo *Declarator, 780 SourceLocation StartLoc, 781 SourceLocation NameLoc, 782 IdentifierInfo *Name); 783 784 /// \brief Rebuild the Objective-C exception declaration and register the 785 /// declaration as an instantiated local. 786 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl, 787 TypeSourceInfo *TSInfo, QualType T); 788 789 /// \brief Check for tag mismatches when instantiating an 790 /// elaborated type. 791 QualType RebuildElaboratedType(SourceLocation KeywordLoc, 792 ElaboratedTypeKeyword Keyword, 793 NestedNameSpecifierLoc QualifierLoc, 794 QualType T); 795 796 TemplateName TransformTemplateName(CXXScopeSpec &SS, 797 TemplateName Name, 798 SourceLocation NameLoc, 799 QualType ObjectType = QualType(), 800 NamedDecl *FirstQualifierInScope = 0); 801 802 ExprResult TransformPredefinedExpr(PredefinedExpr *E); 803 ExprResult TransformDeclRefExpr(DeclRefExpr *E); 804 ExprResult TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E); 805 ExprResult TransformTemplateParmRefExpr(DeclRefExpr *E, 806 NonTypeTemplateParmDecl *D); 807 ExprResult TransformSubstNonTypeTemplateParmPackExpr( 808 SubstNonTypeTemplateParmPackExpr *E); 809 810 QualType TransformFunctionProtoType(TypeLocBuilder &TLB, 811 FunctionProtoTypeLoc TL); 812 QualType TransformFunctionProtoType(TypeLocBuilder &TLB, 813 FunctionProtoTypeLoc TL, 814 CXXRecordDecl *ThisContext, 815 unsigned ThisTypeQuals); 816 817 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm, 818 int indexAdjustment, 819 llvm::Optional<unsigned> NumExpansions, 820 bool ExpectParameterPack); 821 822 /// \brief Transforms a template type parameter type by performing 823 /// substitution of the corresponding template type argument. 824 QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB, 825 TemplateTypeParmTypeLoc TL); 826 827 /// \brief Transforms an already-substituted template type parameter pack 828 /// into either itself (if we aren't substituting into its pack expansion) 829 /// or the appropriate substituted argument. 830 QualType TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB, 831 SubstTemplateTypeParmPackTypeLoc TL); 832 833 ExprResult TransformCallExpr(CallExpr *CE) { 834 getSema().CallsUndergoingInstantiation.push_back(CE); 835 ExprResult Result = 836 TreeTransform<TemplateInstantiator>::TransformCallExpr(CE); 837 getSema().CallsUndergoingInstantiation.pop_back(); 838 return Result; 839 } 840 841 ExprResult TransformLambdaExpr(LambdaExpr *E) { 842 LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true); 843 return TreeTransform<TemplateInstantiator>::TransformLambdaExpr(E); 844 } 845 846 ExprResult TransformLambdaScope(LambdaExpr *E, 847 CXXMethodDecl *CallOperator) { 848 CallOperator->setInstantiationOfMemberFunction(E->getCallOperator(), 849 TSK_ImplicitInstantiation); 850 return TreeTransform<TemplateInstantiator>:: 851 TransformLambdaScope(E, CallOperator); 852 } 853 854 private: 855 ExprResult transformNonTypeTemplateParmRef(NonTypeTemplateParmDecl *parm, 856 SourceLocation loc, 857 TemplateArgument arg); 858 }; 859 } 860 861 bool TemplateInstantiator::AlreadyTransformed(QualType T) { 862 if (T.isNull()) 863 return true; 864 865 if (T->isInstantiationDependentType() || T->isVariablyModifiedType()) 866 return false; 867 868 getSema().MarkDeclarationsReferencedInType(Loc, T); 869 return true; 870 } 871 872 Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) { 873 if (!D) 874 return 0; 875 876 if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) { 877 if (TTP->getDepth() < TemplateArgs.getNumLevels()) { 878 // If the corresponding template argument is NULL or non-existent, it's 879 // because we are performing instantiation from explicitly-specified 880 // template arguments in a function template, but there were some 881 // arguments left unspecified. 882 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(), 883 TTP->getPosition())) 884 return D; 885 886 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition()); 887 888 if (TTP->isParameterPack()) { 889 assert(Arg.getKind() == TemplateArgument::Pack && 890 "Missing argument pack"); 891 892 assert(getSema().ArgumentPackSubstitutionIndex >= 0); 893 assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size()); 894 Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex]; 895 } 896 897 TemplateName Template = Arg.getAsTemplate(); 898 assert(!Template.isNull() && Template.getAsTemplateDecl() && 899 "Wrong kind of template template argument"); 900 return Template.getAsTemplateDecl(); 901 } 902 903 // Fall through to find the instantiated declaration for this template 904 // template parameter. 905 } 906 907 return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs); 908 } 909 910 Decl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) { 911 Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs); 912 if (!Inst) 913 return 0; 914 915 getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst); 916 return Inst; 917 } 918 919 NamedDecl * 920 TemplateInstantiator::TransformFirstQualifierInScope(NamedDecl *D, 921 SourceLocation Loc) { 922 // If the first part of the nested-name-specifier was a template type 923 // parameter, instantiate that type parameter down to a tag type. 924 if (TemplateTypeParmDecl *TTPD = dyn_cast_or_null<TemplateTypeParmDecl>(D)) { 925 const TemplateTypeParmType *TTP 926 = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD)); 927 928 if (TTP->getDepth() < TemplateArgs.getNumLevels()) { 929 // FIXME: This needs testing w/ member access expressions. 930 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getIndex()); 931 932 if (TTP->isParameterPack()) { 933 assert(Arg.getKind() == TemplateArgument::Pack && 934 "Missing argument pack"); 935 936 if (getSema().ArgumentPackSubstitutionIndex == -1) 937 return 0; 938 939 assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size()); 940 Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex]; 941 } 942 943 QualType T = Arg.getAsType(); 944 if (T.isNull()) 945 return cast_or_null<NamedDecl>(TransformDecl(Loc, D)); 946 947 if (const TagType *Tag = T->getAs<TagType>()) 948 return Tag->getDecl(); 949 950 // The resulting type is not a tag; complain. 951 getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T; 952 return 0; 953 } 954 } 955 956 return cast_or_null<NamedDecl>(TransformDecl(Loc, D)); 957 } 958 959 VarDecl * 960 TemplateInstantiator::RebuildExceptionDecl(VarDecl *ExceptionDecl, 961 TypeSourceInfo *Declarator, 962 SourceLocation StartLoc, 963 SourceLocation NameLoc, 964 IdentifierInfo *Name) { 965 VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator, 966 StartLoc, NameLoc, Name); 967 if (Var) 968 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var); 969 return Var; 970 } 971 972 VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(VarDecl *ExceptionDecl, 973 TypeSourceInfo *TSInfo, 974 QualType T) { 975 VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T); 976 if (Var) 977 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var); 978 return Var; 979 } 980 981 QualType 982 TemplateInstantiator::RebuildElaboratedType(SourceLocation KeywordLoc, 983 ElaboratedTypeKeyword Keyword, 984 NestedNameSpecifierLoc QualifierLoc, 985 QualType T) { 986 if (const TagType *TT = T->getAs<TagType>()) { 987 TagDecl* TD = TT->getDecl(); 988 989 SourceLocation TagLocation = KeywordLoc; 990 991 IdentifierInfo *Id = TD->getIdentifier(); 992 993 // TODO: should we even warn on struct/class mismatches for this? Seems 994 // like it's likely to produce a lot of spurious errors. 995 if (Id && Keyword != ETK_None && Keyword != ETK_Typename) { 996 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword); 997 if (!SemaRef.isAcceptableTagRedeclaration(TD, Kind, /*isDefinition*/false, 998 TagLocation, *Id)) { 999 SemaRef.Diag(TagLocation, diag::err_use_with_wrong_tag) 1000 << Id 1001 << FixItHint::CreateReplacement(SourceRange(TagLocation), 1002 TD->getKindName()); 1003 SemaRef.Diag(TD->getLocation(), diag::note_previous_use); 1004 } 1005 } 1006 } 1007 1008 return TreeTransform<TemplateInstantiator>::RebuildElaboratedType(KeywordLoc, 1009 Keyword, 1010 QualifierLoc, 1011 T); 1012 } 1013 1014 TemplateName TemplateInstantiator::TransformTemplateName(CXXScopeSpec &SS, 1015 TemplateName Name, 1016 SourceLocation NameLoc, 1017 QualType ObjectType, 1018 NamedDecl *FirstQualifierInScope) { 1019 if (TemplateTemplateParmDecl *TTP 1020 = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) { 1021 if (TTP->getDepth() < TemplateArgs.getNumLevels()) { 1022 // If the corresponding template argument is NULL or non-existent, it's 1023 // because we are performing instantiation from explicitly-specified 1024 // template arguments in a function template, but there were some 1025 // arguments left unspecified. 1026 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(), 1027 TTP->getPosition())) 1028 return Name; 1029 1030 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition()); 1031 1032 if (TTP->isParameterPack()) { 1033 assert(Arg.getKind() == TemplateArgument::Pack && 1034 "Missing argument pack"); 1035 1036 if (getSema().ArgumentPackSubstitutionIndex == -1) { 1037 // We have the template argument pack to substitute, but we're not 1038 // actually expanding the enclosing pack expansion yet. So, just 1039 // keep the entire argument pack. 1040 return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg); 1041 } 1042 1043 assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size()); 1044 Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex]; 1045 } 1046 1047 TemplateName Template = Arg.getAsTemplate(); 1048 assert(!Template.isNull() && "Null template template argument"); 1049 1050 // We don't ever want to substitute for a qualified template name, since 1051 // the qualifier is handled separately. So, look through the qualified 1052 // template name to its underlying declaration. 1053 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 1054 Template = TemplateName(QTN->getTemplateDecl()); 1055 1056 Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template); 1057 return Template; 1058 } 1059 } 1060 1061 if (SubstTemplateTemplateParmPackStorage *SubstPack 1062 = Name.getAsSubstTemplateTemplateParmPack()) { 1063 if (getSema().ArgumentPackSubstitutionIndex == -1) 1064 return Name; 1065 1066 const TemplateArgument &ArgPack = SubstPack->getArgumentPack(); 1067 assert(getSema().ArgumentPackSubstitutionIndex < (int)ArgPack.pack_size() && 1068 "Pack substitution index out-of-range"); 1069 return ArgPack.pack_begin()[getSema().ArgumentPackSubstitutionIndex] 1070 .getAsTemplate(); 1071 } 1072 1073 return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType, 1074 FirstQualifierInScope); 1075 } 1076 1077 ExprResult 1078 TemplateInstantiator::TransformPredefinedExpr(PredefinedExpr *E) { 1079 if (!E->isTypeDependent()) 1080 return SemaRef.Owned(E); 1081 1082 FunctionDecl *currentDecl = getSema().getCurFunctionDecl(); 1083 assert(currentDecl && "Must have current function declaration when " 1084 "instantiating."); 1085 1086 PredefinedExpr::IdentType IT = E->getIdentType(); 1087 1088 unsigned Length = PredefinedExpr::ComputeName(IT, currentDecl).length(); 1089 1090 llvm::APInt LengthI(32, Length + 1); 1091 QualType ResTy; 1092 if (IT == PredefinedExpr::LFunction) 1093 ResTy = getSema().Context.WCharTy.withConst(); 1094 else 1095 ResTy = getSema().Context.CharTy.withConst(); 1096 ResTy = getSema().Context.getConstantArrayType(ResTy, LengthI, 1097 ArrayType::Normal, 0); 1098 PredefinedExpr *PE = 1099 new (getSema().Context) PredefinedExpr(E->getLocation(), ResTy, IT); 1100 return getSema().Owned(PE); 1101 } 1102 1103 ExprResult 1104 TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E, 1105 NonTypeTemplateParmDecl *NTTP) { 1106 // If the corresponding template argument is NULL or non-existent, it's 1107 // because we are performing instantiation from explicitly-specified 1108 // template arguments in a function template, but there were some 1109 // arguments left unspecified. 1110 if (!TemplateArgs.hasTemplateArgument(NTTP->getDepth(), 1111 NTTP->getPosition())) 1112 return SemaRef.Owned(E); 1113 1114 TemplateArgument Arg = TemplateArgs(NTTP->getDepth(), NTTP->getPosition()); 1115 if (NTTP->isParameterPack()) { 1116 assert(Arg.getKind() == TemplateArgument::Pack && 1117 "Missing argument pack"); 1118 1119 if (getSema().ArgumentPackSubstitutionIndex == -1) { 1120 // We have an argument pack, but we can't select a particular argument 1121 // out of it yet. Therefore, we'll build an expression to hold on to that 1122 // argument pack. 1123 QualType TargetType = SemaRef.SubstType(NTTP->getType(), TemplateArgs, 1124 E->getLocation(), 1125 NTTP->getDeclName()); 1126 if (TargetType.isNull()) 1127 return ExprError(); 1128 1129 return new (SemaRef.Context) SubstNonTypeTemplateParmPackExpr(TargetType, 1130 NTTP, 1131 E->getLocation(), 1132 Arg); 1133 } 1134 1135 assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size()); 1136 Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex]; 1137 } 1138 1139 return transformNonTypeTemplateParmRef(NTTP, E->getLocation(), Arg); 1140 } 1141 1142 ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef( 1143 NonTypeTemplateParmDecl *parm, 1144 SourceLocation loc, 1145 TemplateArgument arg) { 1146 ExprResult result; 1147 QualType type; 1148 1149 // If the argument is a pack expansion, the parameter must actually be a 1150 // parameter pack, and we should substitute the pattern itself, producing 1151 // an expression which contains an unexpanded parameter pack. 1152 if (arg.isPackExpansion()) { 1153 assert(parm->isParameterPack() && "pack expansion for non-pack"); 1154 arg = arg.getPackExpansionPattern(); 1155 } 1156 1157 // The template argument itself might be an expression, in which 1158 // case we just return that expression. 1159 if (arg.getKind() == TemplateArgument::Expression) { 1160 Expr *argExpr = arg.getAsExpr(); 1161 result = SemaRef.Owned(argExpr); 1162 type = argExpr->getType(); 1163 1164 } else if (arg.getKind() == TemplateArgument::Declaration) { 1165 ValueDecl *VD; 1166 if (Decl *D = arg.getAsDecl()) { 1167 VD = cast<ValueDecl>(D); 1168 1169 // Find the instantiation of the template argument. This is 1170 // required for nested templates. 1171 VD = cast_or_null<ValueDecl>( 1172 getSema().FindInstantiatedDecl(loc, VD, TemplateArgs)); 1173 if (!VD) 1174 return ExprError(); 1175 } else { 1176 // Propagate NULL template argument. 1177 VD = 0; 1178 } 1179 1180 // Derive the type we want the substituted decl to have. This had 1181 // better be non-dependent, or these checks will have serious problems. 1182 if (parm->isExpandedParameterPack()) { 1183 type = parm->getExpansionType(SemaRef.ArgumentPackSubstitutionIndex); 1184 } else if (parm->isParameterPack() && 1185 isa<PackExpansionType>(parm->getType())) { 1186 type = SemaRef.SubstType( 1187 cast<PackExpansionType>(parm->getType())->getPattern(), 1188 TemplateArgs, loc, parm->getDeclName()); 1189 } else { 1190 type = SemaRef.SubstType(parm->getType(), TemplateArgs, 1191 loc, parm->getDeclName()); 1192 } 1193 assert(!type.isNull() && "type substitution failed for param type"); 1194 assert(!type->isDependentType() && "param type still dependent"); 1195 result = SemaRef.BuildExpressionFromDeclTemplateArgument(arg, type, loc); 1196 1197 if (!result.isInvalid()) type = result.get()->getType(); 1198 } else { 1199 result = SemaRef.BuildExpressionFromIntegralTemplateArgument(arg, loc); 1200 1201 // Note that this type can be different from the type of 'result', 1202 // e.g. if it's an enum type. 1203 type = arg.getIntegralType(); 1204 } 1205 if (result.isInvalid()) return ExprError(); 1206 1207 Expr *resultExpr = result.take(); 1208 return SemaRef.Owned(new (SemaRef.Context) 1209 SubstNonTypeTemplateParmExpr(type, 1210 resultExpr->getValueKind(), 1211 loc, parm, resultExpr)); 1212 } 1213 1214 ExprResult 1215 TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr( 1216 SubstNonTypeTemplateParmPackExpr *E) { 1217 if (getSema().ArgumentPackSubstitutionIndex == -1) { 1218 // We aren't expanding the parameter pack, so just return ourselves. 1219 return getSema().Owned(E); 1220 } 1221 1222 const TemplateArgument &ArgPack = E->getArgumentPack(); 1223 unsigned Index = (unsigned)getSema().ArgumentPackSubstitutionIndex; 1224 assert(Index < ArgPack.pack_size() && "Substitution index out-of-range"); 1225 1226 const TemplateArgument &Arg = ArgPack.pack_begin()[Index]; 1227 return transformNonTypeTemplateParmRef(E->getParameterPack(), 1228 E->getParameterPackLocation(), 1229 Arg); 1230 } 1231 1232 ExprResult 1233 TemplateInstantiator::TransformDeclRefExpr(DeclRefExpr *E) { 1234 NamedDecl *D = E->getDecl(); 1235 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) { 1236 if (NTTP->getDepth() < TemplateArgs.getNumLevels()) 1237 return TransformTemplateParmRefExpr(E, NTTP); 1238 1239 // We have a non-type template parameter that isn't fully substituted; 1240 // FindInstantiatedDecl will find it in the local instantiation scope. 1241 } 1242 1243 return TreeTransform<TemplateInstantiator>::TransformDeclRefExpr(E); 1244 } 1245 1246 ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr( 1247 CXXDefaultArgExpr *E) { 1248 assert(!cast<FunctionDecl>(E->getParam()->getDeclContext())-> 1249 getDescribedFunctionTemplate() && 1250 "Default arg expressions are never formed in dependent cases."); 1251 return SemaRef.BuildCXXDefaultArgExpr(E->getUsedLocation(), 1252 cast<FunctionDecl>(E->getParam()->getDeclContext()), 1253 E->getParam()); 1254 } 1255 1256 QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB, 1257 FunctionProtoTypeLoc TL) { 1258 // We need a local instantiation scope for this function prototype. 1259 LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true); 1260 return inherited::TransformFunctionProtoType(TLB, TL); 1261 } 1262 1263 QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB, 1264 FunctionProtoTypeLoc TL, 1265 CXXRecordDecl *ThisContext, 1266 unsigned ThisTypeQuals) { 1267 // We need a local instantiation scope for this function prototype. 1268 LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true); 1269 return inherited::TransformFunctionProtoType(TLB, TL, ThisContext, 1270 ThisTypeQuals); 1271 } 1272 1273 ParmVarDecl * 1274 TemplateInstantiator::TransformFunctionTypeParam(ParmVarDecl *OldParm, 1275 int indexAdjustment, 1276 llvm::Optional<unsigned> NumExpansions, 1277 bool ExpectParameterPack) { 1278 return SemaRef.SubstParmVarDecl(OldParm, TemplateArgs, indexAdjustment, 1279 NumExpansions, ExpectParameterPack); 1280 } 1281 1282 QualType 1283 TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB, 1284 TemplateTypeParmTypeLoc TL) { 1285 const TemplateTypeParmType *T = TL.getTypePtr(); 1286 if (T->getDepth() < TemplateArgs.getNumLevels()) { 1287 // Replace the template type parameter with its corresponding 1288 // template argument. 1289 1290 // If the corresponding template argument is NULL or doesn't exist, it's 1291 // because we are performing instantiation from explicitly-specified 1292 // template arguments in a function template class, but there were some 1293 // arguments left unspecified. 1294 if (!TemplateArgs.hasTemplateArgument(T->getDepth(), T->getIndex())) { 1295 TemplateTypeParmTypeLoc NewTL 1296 = TLB.push<TemplateTypeParmTypeLoc>(TL.getType()); 1297 NewTL.setNameLoc(TL.getNameLoc()); 1298 return TL.getType(); 1299 } 1300 1301 TemplateArgument Arg = TemplateArgs(T->getDepth(), T->getIndex()); 1302 1303 if (T->isParameterPack()) { 1304 assert(Arg.getKind() == TemplateArgument::Pack && 1305 "Missing argument pack"); 1306 1307 if (getSema().ArgumentPackSubstitutionIndex == -1) { 1308 // We have the template argument pack, but we're not expanding the 1309 // enclosing pack expansion yet. Just save the template argument 1310 // pack for later substitution. 1311 QualType Result 1312 = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg); 1313 SubstTemplateTypeParmPackTypeLoc NewTL 1314 = TLB.push<SubstTemplateTypeParmPackTypeLoc>(Result); 1315 NewTL.setNameLoc(TL.getNameLoc()); 1316 return Result; 1317 } 1318 1319 assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size()); 1320 Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex]; 1321 } 1322 1323 assert(Arg.getKind() == TemplateArgument::Type && 1324 "Template argument kind mismatch"); 1325 1326 QualType Replacement = Arg.getAsType(); 1327 1328 // TODO: only do this uniquing once, at the start of instantiation. 1329 QualType Result 1330 = getSema().Context.getSubstTemplateTypeParmType(T, Replacement); 1331 SubstTemplateTypeParmTypeLoc NewTL 1332 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result); 1333 NewTL.setNameLoc(TL.getNameLoc()); 1334 return Result; 1335 } 1336 1337 // The template type parameter comes from an inner template (e.g., 1338 // the template parameter list of a member template inside the 1339 // template we are instantiating). Create a new template type 1340 // parameter with the template "level" reduced by one. 1341 TemplateTypeParmDecl *NewTTPDecl = 0; 1342 if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl()) 1343 NewTTPDecl = cast_or_null<TemplateTypeParmDecl>( 1344 TransformDecl(TL.getNameLoc(), OldTTPDecl)); 1345 1346 QualType Result 1347 = getSema().Context.getTemplateTypeParmType(T->getDepth() 1348 - TemplateArgs.getNumLevels(), 1349 T->getIndex(), 1350 T->isParameterPack(), 1351 NewTTPDecl); 1352 TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result); 1353 NewTL.setNameLoc(TL.getNameLoc()); 1354 return Result; 1355 } 1356 1357 QualType 1358 TemplateInstantiator::TransformSubstTemplateTypeParmPackType( 1359 TypeLocBuilder &TLB, 1360 SubstTemplateTypeParmPackTypeLoc TL) { 1361 if (getSema().ArgumentPackSubstitutionIndex == -1) { 1362 // We aren't expanding the parameter pack, so just return ourselves. 1363 SubstTemplateTypeParmPackTypeLoc NewTL 1364 = TLB.push<SubstTemplateTypeParmPackTypeLoc>(TL.getType()); 1365 NewTL.setNameLoc(TL.getNameLoc()); 1366 return TL.getType(); 1367 } 1368 1369 const TemplateArgument &ArgPack = TL.getTypePtr()->getArgumentPack(); 1370 unsigned Index = (unsigned)getSema().ArgumentPackSubstitutionIndex; 1371 assert(Index < ArgPack.pack_size() && "Substitution index out-of-range"); 1372 1373 QualType Result = ArgPack.pack_begin()[Index].getAsType(); 1374 Result = getSema().Context.getSubstTemplateTypeParmType( 1375 TL.getTypePtr()->getReplacedParameter(), 1376 Result); 1377 SubstTemplateTypeParmTypeLoc NewTL 1378 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result); 1379 NewTL.setNameLoc(TL.getNameLoc()); 1380 return Result; 1381 } 1382 1383 /// \brief Perform substitution on the type T with a given set of template 1384 /// arguments. 1385 /// 1386 /// This routine substitutes the given template arguments into the 1387 /// type T and produces the instantiated type. 1388 /// 1389 /// \param T the type into which the template arguments will be 1390 /// substituted. If this type is not dependent, it will be returned 1391 /// immediately. 1392 /// 1393 /// \param Args the template arguments that will be 1394 /// substituted for the top-level template parameters within T. 1395 /// 1396 /// \param Loc the location in the source code where this substitution 1397 /// is being performed. It will typically be the location of the 1398 /// declarator (if we're instantiating the type of some declaration) 1399 /// or the location of the type in the source code (if, e.g., we're 1400 /// instantiating the type of a cast expression). 1401 /// 1402 /// \param Entity the name of the entity associated with a declaration 1403 /// being instantiated (if any). May be empty to indicate that there 1404 /// is no such entity (if, e.g., this is a type that occurs as part of 1405 /// a cast expression) or that the entity has no name (e.g., an 1406 /// unnamed function parameter). 1407 /// 1408 /// \returns If the instantiation succeeds, the instantiated 1409 /// type. Otherwise, produces diagnostics and returns a NULL type. 1410 TypeSourceInfo *Sema::SubstType(TypeSourceInfo *T, 1411 const MultiLevelTemplateArgumentList &Args, 1412 SourceLocation Loc, 1413 DeclarationName Entity) { 1414 assert(!ActiveTemplateInstantiations.empty() && 1415 "Cannot perform an instantiation without some context on the " 1416 "instantiation stack"); 1417 1418 if (!T->getType()->isInstantiationDependentType() && 1419 !T->getType()->isVariablyModifiedType()) 1420 return T; 1421 1422 TemplateInstantiator Instantiator(*this, Args, Loc, Entity); 1423 return Instantiator.TransformType(T); 1424 } 1425 1426 TypeSourceInfo *Sema::SubstType(TypeLoc TL, 1427 const MultiLevelTemplateArgumentList &Args, 1428 SourceLocation Loc, 1429 DeclarationName Entity) { 1430 assert(!ActiveTemplateInstantiations.empty() && 1431 "Cannot perform an instantiation without some context on the " 1432 "instantiation stack"); 1433 1434 if (TL.getType().isNull()) 1435 return 0; 1436 1437 if (!TL.getType()->isInstantiationDependentType() && 1438 !TL.getType()->isVariablyModifiedType()) { 1439 // FIXME: Make a copy of the TypeLoc data here, so that we can 1440 // return a new TypeSourceInfo. Inefficient! 1441 TypeLocBuilder TLB; 1442 TLB.pushFullCopy(TL); 1443 return TLB.getTypeSourceInfo(Context, TL.getType()); 1444 } 1445 1446 TemplateInstantiator Instantiator(*this, Args, Loc, Entity); 1447 TypeLocBuilder TLB; 1448 TLB.reserve(TL.getFullDataSize()); 1449 QualType Result = Instantiator.TransformType(TLB, TL); 1450 if (Result.isNull()) 1451 return 0; 1452 1453 return TLB.getTypeSourceInfo(Context, Result); 1454 } 1455 1456 /// Deprecated form of the above. 1457 QualType Sema::SubstType(QualType T, 1458 const MultiLevelTemplateArgumentList &TemplateArgs, 1459 SourceLocation Loc, DeclarationName Entity) { 1460 assert(!ActiveTemplateInstantiations.empty() && 1461 "Cannot perform an instantiation without some context on the " 1462 "instantiation stack"); 1463 1464 // If T is not a dependent type or a variably-modified type, there 1465 // is nothing to do. 1466 if (!T->isInstantiationDependentType() && !T->isVariablyModifiedType()) 1467 return T; 1468 1469 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, Entity); 1470 return Instantiator.TransformType(T); 1471 } 1472 1473 static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T) { 1474 if (T->getType()->isInstantiationDependentType() || 1475 T->getType()->isVariablyModifiedType()) 1476 return true; 1477 1478 TypeLoc TL = T->getTypeLoc().IgnoreParens(); 1479 if (!isa<FunctionProtoTypeLoc>(TL)) 1480 return false; 1481 1482 FunctionProtoTypeLoc FP = cast<FunctionProtoTypeLoc>(TL); 1483 for (unsigned I = 0, E = FP.getNumArgs(); I != E; ++I) { 1484 ParmVarDecl *P = FP.getArg(I); 1485 1486 // The parameter's type as written might be dependent even if the 1487 // decayed type was not dependent. 1488 if (TypeSourceInfo *TSInfo = P->getTypeSourceInfo()) 1489 if (TSInfo->getType()->isInstantiationDependentType()) 1490 return true; 1491 1492 // TODO: currently we always rebuild expressions. When we 1493 // properly get lazier about this, we should use the same 1494 // logic to avoid rebuilding prototypes here. 1495 if (P->hasDefaultArg()) 1496 return true; 1497 } 1498 1499 return false; 1500 } 1501 1502 /// A form of SubstType intended specifically for instantiating the 1503 /// type of a FunctionDecl. Its purpose is solely to force the 1504 /// instantiation of default-argument expressions. 1505 TypeSourceInfo *Sema::SubstFunctionDeclType(TypeSourceInfo *T, 1506 const MultiLevelTemplateArgumentList &Args, 1507 SourceLocation Loc, 1508 DeclarationName Entity, 1509 CXXRecordDecl *ThisContext, 1510 unsigned ThisTypeQuals) { 1511 assert(!ActiveTemplateInstantiations.empty() && 1512 "Cannot perform an instantiation without some context on the " 1513 "instantiation stack"); 1514 1515 if (!NeedsInstantiationAsFunctionType(T)) 1516 return T; 1517 1518 TemplateInstantiator Instantiator(*this, Args, Loc, Entity); 1519 1520 TypeLocBuilder TLB; 1521 1522 TypeLoc TL = T->getTypeLoc(); 1523 TLB.reserve(TL.getFullDataSize()); 1524 1525 QualType Result; 1526 1527 if (FunctionProtoTypeLoc *Proto = dyn_cast<FunctionProtoTypeLoc>(&TL)) { 1528 Result = Instantiator.TransformFunctionProtoType(TLB, *Proto, ThisContext, 1529 ThisTypeQuals); 1530 } else { 1531 Result = Instantiator.TransformType(TLB, TL); 1532 } 1533 if (Result.isNull()) 1534 return 0; 1535 1536 return TLB.getTypeSourceInfo(Context, Result); 1537 } 1538 1539 ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm, 1540 const MultiLevelTemplateArgumentList &TemplateArgs, 1541 int indexAdjustment, 1542 llvm::Optional<unsigned> NumExpansions, 1543 bool ExpectParameterPack) { 1544 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); 1545 TypeSourceInfo *NewDI = 0; 1546 1547 TypeLoc OldTL = OldDI->getTypeLoc(); 1548 if (isa<PackExpansionTypeLoc>(OldTL)) { 1549 PackExpansionTypeLoc ExpansionTL = cast<PackExpansionTypeLoc>(OldTL); 1550 1551 // We have a function parameter pack. Substitute into the pattern of the 1552 // expansion. 1553 NewDI = SubstType(ExpansionTL.getPatternLoc(), TemplateArgs, 1554 OldParm->getLocation(), OldParm->getDeclName()); 1555 if (!NewDI) 1556 return 0; 1557 1558 if (NewDI->getType()->containsUnexpandedParameterPack()) { 1559 // We still have unexpanded parameter packs, which means that 1560 // our function parameter is still a function parameter pack. 1561 // Therefore, make its type a pack expansion type. 1562 NewDI = CheckPackExpansion(NewDI, ExpansionTL.getEllipsisLoc(), 1563 NumExpansions); 1564 } else if (ExpectParameterPack) { 1565 // We expected to get a parameter pack but didn't (because the type 1566 // itself is not a pack expansion type), so complain. This can occur when 1567 // the substitution goes through an alias template that "loses" the 1568 // pack expansion. 1569 Diag(OldParm->getLocation(), 1570 diag::err_function_parameter_pack_without_parameter_packs) 1571 << NewDI->getType(); 1572 return 0; 1573 } 1574 } else { 1575 NewDI = SubstType(OldDI, TemplateArgs, OldParm->getLocation(), 1576 OldParm->getDeclName()); 1577 } 1578 1579 if (!NewDI) 1580 return 0; 1581 1582 if (NewDI->getType()->isVoidType()) { 1583 Diag(OldParm->getLocation(), diag::err_param_with_void_type); 1584 return 0; 1585 } 1586 1587 ParmVarDecl *NewParm = CheckParameter(Context.getTranslationUnitDecl(), 1588 OldParm->getInnerLocStart(), 1589 OldParm->getLocation(), 1590 OldParm->getIdentifier(), 1591 NewDI->getType(), NewDI, 1592 OldParm->getStorageClass(), 1593 OldParm->getStorageClassAsWritten()); 1594 if (!NewParm) 1595 return 0; 1596 1597 // Mark the (new) default argument as uninstantiated (if any). 1598 if (OldParm->hasUninstantiatedDefaultArg()) { 1599 Expr *Arg = OldParm->getUninstantiatedDefaultArg(); 1600 NewParm->setUninstantiatedDefaultArg(Arg); 1601 } else if (OldParm->hasUnparsedDefaultArg()) { 1602 NewParm->setUnparsedDefaultArg(); 1603 UnparsedDefaultArgInstantiations[OldParm].push_back(NewParm); 1604 } else if (Expr *Arg = OldParm->getDefaultArg()) 1605 // FIXME: if we non-lazily instantiated non-dependent default args for 1606 // non-dependent parameter types we could remove a bunch of duplicate 1607 // conversion warnings for such arguments. 1608 NewParm->setUninstantiatedDefaultArg(Arg); 1609 1610 NewParm->setHasInheritedDefaultArg(OldParm->hasInheritedDefaultArg()); 1611 1612 if (OldParm->isParameterPack() && !NewParm->isParameterPack()) { 1613 // Add the new parameter to the instantiated parameter pack. 1614 CurrentInstantiationScope->InstantiatedLocalPackArg(OldParm, NewParm); 1615 } else { 1616 // Introduce an Old -> New mapping 1617 CurrentInstantiationScope->InstantiatedLocal(OldParm, NewParm); 1618 } 1619 1620 // FIXME: OldParm may come from a FunctionProtoType, in which case CurContext 1621 // can be anything, is this right ? 1622 NewParm->setDeclContext(CurContext); 1623 1624 NewParm->setScopeInfo(OldParm->getFunctionScopeDepth(), 1625 OldParm->getFunctionScopeIndex() + indexAdjustment); 1626 1627 return NewParm; 1628 } 1629 1630 /// \brief Substitute the given template arguments into the given set of 1631 /// parameters, producing the set of parameter types that would be generated 1632 /// from such a substitution. 1633 bool Sema::SubstParmTypes(SourceLocation Loc, 1634 ParmVarDecl **Params, unsigned NumParams, 1635 const MultiLevelTemplateArgumentList &TemplateArgs, 1636 SmallVectorImpl<QualType> &ParamTypes, 1637 SmallVectorImpl<ParmVarDecl *> *OutParams) { 1638 assert(!ActiveTemplateInstantiations.empty() && 1639 "Cannot perform an instantiation without some context on the " 1640 "instantiation stack"); 1641 1642 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, 1643 DeclarationName()); 1644 return Instantiator.TransformFunctionTypeParams(Loc, Params, NumParams, 0, 1645 ParamTypes, OutParams); 1646 } 1647 1648 /// \brief Perform substitution on the base class specifiers of the 1649 /// given class template specialization. 1650 /// 1651 /// Produces a diagnostic and returns true on error, returns false and 1652 /// attaches the instantiated base classes to the class template 1653 /// specialization if successful. 1654 bool 1655 Sema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation, 1656 CXXRecordDecl *Pattern, 1657 const MultiLevelTemplateArgumentList &TemplateArgs) { 1658 bool Invalid = false; 1659 SmallVector<CXXBaseSpecifier*, 4> InstantiatedBases; 1660 for (ClassTemplateSpecializationDecl::base_class_iterator 1661 Base = Pattern->bases_begin(), BaseEnd = Pattern->bases_end(); 1662 Base != BaseEnd; ++Base) { 1663 if (!Base->getType()->isDependentType()) { 1664 InstantiatedBases.push_back(new (Context) CXXBaseSpecifier(*Base)); 1665 continue; 1666 } 1667 1668 SourceLocation EllipsisLoc; 1669 TypeSourceInfo *BaseTypeLoc; 1670 if (Base->isPackExpansion()) { 1671 // This is a pack expansion. See whether we should expand it now, or 1672 // wait until later. 1673 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 1674 collectUnexpandedParameterPacks(Base->getTypeSourceInfo()->getTypeLoc(), 1675 Unexpanded); 1676 bool ShouldExpand = false; 1677 bool RetainExpansion = false; 1678 llvm::Optional<unsigned> NumExpansions; 1679 if (CheckParameterPacksForExpansion(Base->getEllipsisLoc(), 1680 Base->getSourceRange(), 1681 Unexpanded, 1682 TemplateArgs, ShouldExpand, 1683 RetainExpansion, 1684 NumExpansions)) { 1685 Invalid = true; 1686 continue; 1687 } 1688 1689 // If we should expand this pack expansion now, do so. 1690 if (ShouldExpand) { 1691 for (unsigned I = 0; I != *NumExpansions; ++I) { 1692 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I); 1693 1694 TypeSourceInfo *BaseTypeLoc = SubstType(Base->getTypeSourceInfo(), 1695 TemplateArgs, 1696 Base->getSourceRange().getBegin(), 1697 DeclarationName()); 1698 if (!BaseTypeLoc) { 1699 Invalid = true; 1700 continue; 1701 } 1702 1703 if (CXXBaseSpecifier *InstantiatedBase 1704 = CheckBaseSpecifier(Instantiation, 1705 Base->getSourceRange(), 1706 Base->isVirtual(), 1707 Base->getAccessSpecifierAsWritten(), 1708 BaseTypeLoc, 1709 SourceLocation())) 1710 InstantiatedBases.push_back(InstantiatedBase); 1711 else 1712 Invalid = true; 1713 } 1714 1715 continue; 1716 } 1717 1718 // The resulting base specifier will (still) be a pack expansion. 1719 EllipsisLoc = Base->getEllipsisLoc(); 1720 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1); 1721 BaseTypeLoc = SubstType(Base->getTypeSourceInfo(), 1722 TemplateArgs, 1723 Base->getSourceRange().getBegin(), 1724 DeclarationName()); 1725 } else { 1726 BaseTypeLoc = SubstType(Base->getTypeSourceInfo(), 1727 TemplateArgs, 1728 Base->getSourceRange().getBegin(), 1729 DeclarationName()); 1730 } 1731 1732 if (!BaseTypeLoc) { 1733 Invalid = true; 1734 continue; 1735 } 1736 1737 if (CXXBaseSpecifier *InstantiatedBase 1738 = CheckBaseSpecifier(Instantiation, 1739 Base->getSourceRange(), 1740 Base->isVirtual(), 1741 Base->getAccessSpecifierAsWritten(), 1742 BaseTypeLoc, 1743 EllipsisLoc)) 1744 InstantiatedBases.push_back(InstantiatedBase); 1745 else 1746 Invalid = true; 1747 } 1748 1749 if (!Invalid && 1750 AttachBaseSpecifiers(Instantiation, InstantiatedBases.data(), 1751 InstantiatedBases.size())) 1752 Invalid = true; 1753 1754 return Invalid; 1755 } 1756 1757 // Defined via #include from SemaTemplateInstantiateDecl.cpp 1758 namespace clang { 1759 namespace sema { 1760 Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S, 1761 const MultiLevelTemplateArgumentList &TemplateArgs); 1762 } 1763 } 1764 1765 /// Determine whether we would be unable to instantiate this template (because 1766 /// it either has no definition, or is in the process of being instantiated). 1767 static bool DiagnoseUninstantiableTemplate(Sema &S, 1768 SourceLocation PointOfInstantiation, 1769 TagDecl *Instantiation, 1770 bool InstantiatedFromMember, 1771 TagDecl *Pattern, 1772 TagDecl *PatternDef, 1773 TemplateSpecializationKind TSK, 1774 bool Complain = true) { 1775 if (PatternDef && !PatternDef->isBeingDefined()) 1776 return false; 1777 1778 if (!Complain || (PatternDef && PatternDef->isInvalidDecl())) { 1779 // Say nothing 1780 } else if (PatternDef) { 1781 assert(PatternDef->isBeingDefined()); 1782 S.Diag(PointOfInstantiation, 1783 diag::err_template_instantiate_within_definition) 1784 << (TSK != TSK_ImplicitInstantiation) 1785 << S.Context.getTypeDeclType(Instantiation); 1786 // Not much point in noting the template declaration here, since 1787 // we're lexically inside it. 1788 Instantiation->setInvalidDecl(); 1789 } else if (InstantiatedFromMember) { 1790 S.Diag(PointOfInstantiation, 1791 diag::err_implicit_instantiate_member_undefined) 1792 << S.Context.getTypeDeclType(Instantiation); 1793 S.Diag(Pattern->getLocation(), diag::note_member_of_template_here); 1794 } else { 1795 S.Diag(PointOfInstantiation, diag::err_template_instantiate_undefined) 1796 << (TSK != TSK_ImplicitInstantiation) 1797 << S.Context.getTypeDeclType(Instantiation); 1798 S.Diag(Pattern->getLocation(), diag::note_template_decl_here); 1799 } 1800 1801 // In general, Instantiation isn't marked invalid to get more than one 1802 // error for multiple undefined instantiations. But the code that does 1803 // explicit declaration -> explicit definition conversion can't handle 1804 // invalid declarations, so mark as invalid in that case. 1805 if (TSK == TSK_ExplicitInstantiationDeclaration) 1806 Instantiation->setInvalidDecl(); 1807 return true; 1808 } 1809 1810 /// \brief Instantiate the definition of a class from a given pattern. 1811 /// 1812 /// \param PointOfInstantiation The point of instantiation within the 1813 /// source code. 1814 /// 1815 /// \param Instantiation is the declaration whose definition is being 1816 /// instantiated. This will be either a class template specialization 1817 /// or a member class of a class template specialization. 1818 /// 1819 /// \param Pattern is the pattern from which the instantiation 1820 /// occurs. This will be either the declaration of a class template or 1821 /// the declaration of a member class of a class template. 1822 /// 1823 /// \param TemplateArgs The template arguments to be substituted into 1824 /// the pattern. 1825 /// 1826 /// \param TSK the kind of implicit or explicit instantiation to perform. 1827 /// 1828 /// \param Complain whether to complain if the class cannot be instantiated due 1829 /// to the lack of a definition. 1830 /// 1831 /// \returns true if an error occurred, false otherwise. 1832 bool 1833 Sema::InstantiateClass(SourceLocation PointOfInstantiation, 1834 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, 1835 const MultiLevelTemplateArgumentList &TemplateArgs, 1836 TemplateSpecializationKind TSK, 1837 bool Complain) { 1838 CXXRecordDecl *PatternDef 1839 = cast_or_null<CXXRecordDecl>(Pattern->getDefinition()); 1840 if (DiagnoseUninstantiableTemplate(*this, PointOfInstantiation, Instantiation, 1841 Instantiation->getInstantiatedFromMemberClass(), 1842 Pattern, PatternDef, TSK, Complain)) 1843 return true; 1844 Pattern = PatternDef; 1845 1846 // \brief Record the point of instantiation. 1847 if (MemberSpecializationInfo *MSInfo 1848 = Instantiation->getMemberSpecializationInfo()) { 1849 MSInfo->setTemplateSpecializationKind(TSK); 1850 MSInfo->setPointOfInstantiation(PointOfInstantiation); 1851 } else if (ClassTemplateSpecializationDecl *Spec 1852 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) { 1853 Spec->setTemplateSpecializationKind(TSK); 1854 Spec->setPointOfInstantiation(PointOfInstantiation); 1855 } 1856 1857 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation); 1858 if (Inst) 1859 return true; 1860 1861 // Enter the scope of this instantiation. We don't use 1862 // PushDeclContext because we don't have a scope. 1863 ContextRAII SavedContext(*this, Instantiation); 1864 EnterExpressionEvaluationContext EvalContext(*this, 1865 Sema::PotentiallyEvaluated); 1866 1867 // If this is an instantiation of a local class, merge this local 1868 // instantiation scope with the enclosing scope. Otherwise, every 1869 // instantiation of a class has its own local instantiation scope. 1870 bool MergeWithParentScope = !Instantiation->isDefinedOutsideFunctionOrMethod(); 1871 LocalInstantiationScope Scope(*this, MergeWithParentScope); 1872 1873 // Pull attributes from the pattern onto the instantiation. 1874 InstantiateAttrs(TemplateArgs, Pattern, Instantiation); 1875 1876 // Start the definition of this instantiation. 1877 Instantiation->startDefinition(); 1878 1879 Instantiation->setTagKind(Pattern->getTagKind()); 1880 1881 // Do substitution on the base class specifiers. 1882 if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs)) 1883 Instantiation->setInvalidDecl(); 1884 1885 TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs); 1886 SmallVector<Decl*, 4> Fields; 1887 SmallVector<std::pair<FieldDecl*, FieldDecl*>, 4> 1888 FieldsWithMemberInitializers; 1889 // Delay instantiation of late parsed attributes. 1890 LateInstantiatedAttrVec LateAttrs; 1891 Instantiator.enableLateAttributeInstantiation(&LateAttrs); 1892 1893 for (RecordDecl::decl_iterator Member = Pattern->decls_begin(), 1894 MemberEnd = Pattern->decls_end(); 1895 Member != MemberEnd; ++Member) { 1896 // Don't instantiate members not belonging in this semantic context. 1897 // e.g. for: 1898 // @code 1899 // template <int i> class A { 1900 // class B *g; 1901 // }; 1902 // @endcode 1903 // 'class B' has the template as lexical context but semantically it is 1904 // introduced in namespace scope. 1905 if ((*Member)->getDeclContext() != Pattern) 1906 continue; 1907 1908 if ((*Member)->isInvalidDecl()) { 1909 Instantiation->setInvalidDecl(); 1910 continue; 1911 } 1912 1913 Decl *NewMember = Instantiator.Visit(*Member); 1914 if (NewMember) { 1915 if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) { 1916 Fields.push_back(Field); 1917 FieldDecl *OldField = cast<FieldDecl>(*Member); 1918 if (OldField->getInClassInitializer()) 1919 FieldsWithMemberInitializers.push_back(std::make_pair(OldField, 1920 Field)); 1921 } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) { 1922 // C++11 [temp.inst]p1: The implicit instantiation of a class template 1923 // specialization causes the implicit instantiation of the definitions 1924 // of unscoped member enumerations. 1925 // Record a point of instantiation for this implicit instantiation. 1926 if (TSK == TSK_ImplicitInstantiation && !Enum->isScoped() && 1927 Enum->isCompleteDefinition()) { 1928 MemberSpecializationInfo *MSInfo =Enum->getMemberSpecializationInfo(); 1929 assert(MSInfo && "no spec info for member enum specialization"); 1930 MSInfo->setTemplateSpecializationKind(TSK_ImplicitInstantiation); 1931 MSInfo->setPointOfInstantiation(PointOfInstantiation); 1932 } 1933 } else if (StaticAssertDecl *SA = dyn_cast<StaticAssertDecl>(NewMember)) { 1934 if (SA->isFailed()) { 1935 // A static_assert failed. Bail out; instantiating this 1936 // class is probably not meaningful. 1937 Instantiation->setInvalidDecl(); 1938 break; 1939 } 1940 } 1941 1942 if (NewMember->isInvalidDecl()) 1943 Instantiation->setInvalidDecl(); 1944 } else { 1945 // FIXME: Eventually, a NULL return will mean that one of the 1946 // instantiations was a semantic disaster, and we'll want to mark the 1947 // declaration invalid. 1948 // For now, we expect to skip some members that we can't yet handle. 1949 } 1950 } 1951 1952 // Finish checking fields. 1953 ActOnFields(0, Instantiation->getLocation(), Instantiation, Fields, 1954 SourceLocation(), SourceLocation(), 0); 1955 CheckCompletedCXXClass(Instantiation); 1956 1957 // Attach any in-class member initializers now the class is complete. 1958 if (!FieldsWithMemberInitializers.empty()) { 1959 // C++11 [expr.prim.general]p4: 1960 // Otherwise, if a member-declarator declares a non-static data member 1961 // (9.2) of a class X, the expression this is a prvalue of type "pointer 1962 // to X" within the optional brace-or-equal-initializer. It shall not 1963 // appear elsewhere in the member-declarator. 1964 CXXThisScopeRAII ThisScope(*this, Instantiation, (unsigned)0); 1965 1966 for (unsigned I = 0, N = FieldsWithMemberInitializers.size(); I != N; ++I) { 1967 FieldDecl *OldField = FieldsWithMemberInitializers[I].first; 1968 FieldDecl *NewField = FieldsWithMemberInitializers[I].second; 1969 Expr *OldInit = OldField->getInClassInitializer(); 1970 1971 ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs, 1972 /*CXXDirectInit=*/false); 1973 if (NewInit.isInvalid()) 1974 NewField->setInvalidDecl(); 1975 else { 1976 Expr *Init = NewInit.take(); 1977 assert(Init && "no-argument initializer in class"); 1978 assert(!isa<ParenListExpr>(Init) && "call-style init in class"); 1979 ActOnCXXInClassMemberInitializer(NewField, Init->getLocStart(), Init); 1980 } 1981 } 1982 } 1983 // Instantiate late parsed attributes, and attach them to their decls. 1984 // See Sema::InstantiateAttrs 1985 for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(), 1986 E = LateAttrs.end(); I != E; ++I) { 1987 assert(CurrentInstantiationScope == Instantiator.getStartingScope()); 1988 CurrentInstantiationScope = I->Scope; 1989 Attr *NewAttr = 1990 instantiateTemplateAttribute(I->TmplAttr, Context, *this, TemplateArgs); 1991 I->NewDecl->addAttr(NewAttr); 1992 LocalInstantiationScope::deleteScopes(I->Scope, 1993 Instantiator.getStartingScope()); 1994 } 1995 Instantiator.disableLateAttributeInstantiation(); 1996 LateAttrs.clear(); 1997 1998 ActOnFinishDelayedMemberInitializers(Instantiation); 1999 2000 if (TSK == TSK_ImplicitInstantiation) { 2001 Instantiation->setLocation(Pattern->getLocation()); 2002 Instantiation->setLocStart(Pattern->getInnerLocStart()); 2003 Instantiation->setRBraceLoc(Pattern->getRBraceLoc()); 2004 } 2005 2006 if (!Instantiation->isInvalidDecl()) { 2007 // Perform any dependent diagnostics from the pattern. 2008 PerformDependentDiagnostics(Pattern, TemplateArgs); 2009 2010 // Instantiate any out-of-line class template partial 2011 // specializations now. 2012 for (TemplateDeclInstantiator::delayed_partial_spec_iterator 2013 P = Instantiator.delayed_partial_spec_begin(), 2014 PEnd = Instantiator.delayed_partial_spec_end(); 2015 P != PEnd; ++P) { 2016 if (!Instantiator.InstantiateClassTemplatePartialSpecialization( 2017 P->first, 2018 P->second)) { 2019 Instantiation->setInvalidDecl(); 2020 break; 2021 } 2022 } 2023 } 2024 2025 // Exit the scope of this instantiation. 2026 SavedContext.pop(); 2027 2028 if (!Instantiation->isInvalidDecl()) { 2029 Consumer.HandleTagDeclDefinition(Instantiation); 2030 2031 // Always emit the vtable for an explicit instantiation definition 2032 // of a polymorphic class template specialization. 2033 if (TSK == TSK_ExplicitInstantiationDefinition) 2034 MarkVTableUsed(PointOfInstantiation, Instantiation, true); 2035 } 2036 2037 return Instantiation->isInvalidDecl(); 2038 } 2039 2040 /// \brief Instantiate the definition of an enum from a given pattern. 2041 /// 2042 /// \param PointOfInstantiation The point of instantiation within the 2043 /// source code. 2044 /// \param Instantiation is the declaration whose definition is being 2045 /// instantiated. This will be a member enumeration of a class 2046 /// temploid specialization, or a local enumeration within a 2047 /// function temploid specialization. 2048 /// \param Pattern The templated declaration from which the instantiation 2049 /// occurs. 2050 /// \param TemplateArgs The template arguments to be substituted into 2051 /// the pattern. 2052 /// \param TSK The kind of implicit or explicit instantiation to perform. 2053 /// 2054 /// \return \c true if an error occurred, \c false otherwise. 2055 bool Sema::InstantiateEnum(SourceLocation PointOfInstantiation, 2056 EnumDecl *Instantiation, EnumDecl *Pattern, 2057 const MultiLevelTemplateArgumentList &TemplateArgs, 2058 TemplateSpecializationKind TSK) { 2059 EnumDecl *PatternDef = Pattern->getDefinition(); 2060 if (DiagnoseUninstantiableTemplate(*this, PointOfInstantiation, Instantiation, 2061 Instantiation->getInstantiatedFromMemberEnum(), 2062 Pattern, PatternDef, TSK,/*Complain*/true)) 2063 return true; 2064 Pattern = PatternDef; 2065 2066 // Record the point of instantiation. 2067 if (MemberSpecializationInfo *MSInfo 2068 = Instantiation->getMemberSpecializationInfo()) { 2069 MSInfo->setTemplateSpecializationKind(TSK); 2070 MSInfo->setPointOfInstantiation(PointOfInstantiation); 2071 } 2072 2073 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation); 2074 if (Inst) 2075 return true; 2076 2077 // Enter the scope of this instantiation. We don't use 2078 // PushDeclContext because we don't have a scope. 2079 ContextRAII SavedContext(*this, Instantiation); 2080 EnterExpressionEvaluationContext EvalContext(*this, 2081 Sema::PotentiallyEvaluated); 2082 2083 LocalInstantiationScope Scope(*this, /*MergeWithParentScope*/true); 2084 2085 // Pull attributes from the pattern onto the instantiation. 2086 InstantiateAttrs(TemplateArgs, Pattern, Instantiation); 2087 2088 TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs); 2089 Instantiator.InstantiateEnumDefinition(Instantiation, Pattern); 2090 2091 // Exit the scope of this instantiation. 2092 SavedContext.pop(); 2093 2094 return Instantiation->isInvalidDecl(); 2095 } 2096 2097 namespace { 2098 /// \brief A partial specialization whose template arguments have matched 2099 /// a given template-id. 2100 struct PartialSpecMatchResult { 2101 ClassTemplatePartialSpecializationDecl *Partial; 2102 TemplateArgumentList *Args; 2103 }; 2104 } 2105 2106 bool 2107 Sema::InstantiateClassTemplateSpecialization( 2108 SourceLocation PointOfInstantiation, 2109 ClassTemplateSpecializationDecl *ClassTemplateSpec, 2110 TemplateSpecializationKind TSK, 2111 bool Complain) { 2112 // Perform the actual instantiation on the canonical declaration. 2113 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>( 2114 ClassTemplateSpec->getCanonicalDecl()); 2115 2116 // Check whether we have already instantiated or specialized this class 2117 // template specialization. 2118 if (ClassTemplateSpec->getSpecializationKind() != TSK_Undeclared) { 2119 if (ClassTemplateSpec->getSpecializationKind() == 2120 TSK_ExplicitInstantiationDeclaration && 2121 TSK == TSK_ExplicitInstantiationDefinition) { 2122 // An explicit instantiation definition follows an explicit instantiation 2123 // declaration (C++0x [temp.explicit]p10); go ahead and perform the 2124 // explicit instantiation. 2125 ClassTemplateSpec->setSpecializationKind(TSK); 2126 2127 // If this is an explicit instantiation definition, mark the 2128 // vtable as used. 2129 if (TSK == TSK_ExplicitInstantiationDefinition && 2130 !ClassTemplateSpec->isInvalidDecl()) 2131 MarkVTableUsed(PointOfInstantiation, ClassTemplateSpec, true); 2132 2133 return false; 2134 } 2135 2136 // We can only instantiate something that hasn't already been 2137 // instantiated or specialized. Fail without any diagnostics: our 2138 // caller will provide an error message. 2139 return true; 2140 } 2141 2142 if (ClassTemplateSpec->isInvalidDecl()) 2143 return true; 2144 2145 ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate(); 2146 CXXRecordDecl *Pattern = 0; 2147 2148 // C++ [temp.class.spec.match]p1: 2149 // When a class template is used in a context that requires an 2150 // instantiation of the class, it is necessary to determine 2151 // whether the instantiation is to be generated using the primary 2152 // template or one of the partial specializations. This is done by 2153 // matching the template arguments of the class template 2154 // specialization with the template argument lists of the partial 2155 // specializations. 2156 typedef PartialSpecMatchResult MatchResult; 2157 SmallVector<MatchResult, 4> Matched; 2158 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs; 2159 Template->getPartialSpecializations(PartialSpecs); 2160 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) { 2161 ClassTemplatePartialSpecializationDecl *Partial = PartialSpecs[I]; 2162 TemplateDeductionInfo Info(Context, PointOfInstantiation); 2163 if (TemplateDeductionResult Result 2164 = DeduceTemplateArguments(Partial, 2165 ClassTemplateSpec->getTemplateArgs(), 2166 Info)) { 2167 // FIXME: Store the failed-deduction information for use in 2168 // diagnostics, later. 2169 (void)Result; 2170 } else { 2171 Matched.push_back(PartialSpecMatchResult()); 2172 Matched.back().Partial = Partial; 2173 Matched.back().Args = Info.take(); 2174 } 2175 } 2176 2177 // If we're dealing with a member template where the template parameters 2178 // have been instantiated, this provides the original template parameters 2179 // from which the member template's parameters were instantiated. 2180 SmallVector<const NamedDecl *, 4> InstantiatedTemplateParameters; 2181 2182 if (Matched.size() >= 1) { 2183 SmallVector<MatchResult, 4>::iterator Best = Matched.begin(); 2184 if (Matched.size() == 1) { 2185 // -- If exactly one matching specialization is found, the 2186 // instantiation is generated from that specialization. 2187 // We don't need to do anything for this. 2188 } else { 2189 // -- If more than one matching specialization is found, the 2190 // partial order rules (14.5.4.2) are used to determine 2191 // whether one of the specializations is more specialized 2192 // than the others. If none of the specializations is more 2193 // specialized than all of the other matching 2194 // specializations, then the use of the class template is 2195 // ambiguous and the program is ill-formed. 2196 for (SmallVector<MatchResult, 4>::iterator P = Best + 1, 2197 PEnd = Matched.end(); 2198 P != PEnd; ++P) { 2199 if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial, 2200 PointOfInstantiation) 2201 == P->Partial) 2202 Best = P; 2203 } 2204 2205 // Determine if the best partial specialization is more specialized than 2206 // the others. 2207 bool Ambiguous = false; 2208 for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(), 2209 PEnd = Matched.end(); 2210 P != PEnd; ++P) { 2211 if (P != Best && 2212 getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial, 2213 PointOfInstantiation) 2214 != Best->Partial) { 2215 Ambiguous = true; 2216 break; 2217 } 2218 } 2219 2220 if (Ambiguous) { 2221 // Partial ordering did not produce a clear winner. Complain. 2222 ClassTemplateSpec->setInvalidDecl(); 2223 Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous) 2224 << ClassTemplateSpec; 2225 2226 // Print the matching partial specializations. 2227 for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(), 2228 PEnd = Matched.end(); 2229 P != PEnd; ++P) 2230 Diag(P->Partial->getLocation(), diag::note_partial_spec_match) 2231 << getTemplateArgumentBindingsText( 2232 P->Partial->getTemplateParameters(), 2233 *P->Args); 2234 2235 return true; 2236 } 2237 } 2238 2239 // Instantiate using the best class template partial specialization. 2240 ClassTemplatePartialSpecializationDecl *OrigPartialSpec = Best->Partial; 2241 while (OrigPartialSpec->getInstantiatedFromMember()) { 2242 // If we've found an explicit specialization of this class template, 2243 // stop here and use that as the pattern. 2244 if (OrigPartialSpec->isMemberSpecialization()) 2245 break; 2246 2247 OrigPartialSpec = OrigPartialSpec->getInstantiatedFromMember(); 2248 } 2249 2250 Pattern = OrigPartialSpec; 2251 ClassTemplateSpec->setInstantiationOf(Best->Partial, Best->Args); 2252 } else { 2253 // -- If no matches are found, the instantiation is generated 2254 // from the primary template. 2255 ClassTemplateDecl *OrigTemplate = Template; 2256 while (OrigTemplate->getInstantiatedFromMemberTemplate()) { 2257 // If we've found an explicit specialization of this class template, 2258 // stop here and use that as the pattern. 2259 if (OrigTemplate->isMemberSpecialization()) 2260 break; 2261 2262 OrigTemplate = OrigTemplate->getInstantiatedFromMemberTemplate(); 2263 } 2264 2265 Pattern = OrigTemplate->getTemplatedDecl(); 2266 } 2267 2268 bool Result = InstantiateClass(PointOfInstantiation, ClassTemplateSpec, 2269 Pattern, 2270 getTemplateInstantiationArgs(ClassTemplateSpec), 2271 TSK, 2272 Complain); 2273 2274 return Result; 2275 } 2276 2277 /// \brief Instantiates the definitions of all of the member 2278 /// of the given class, which is an instantiation of a class template 2279 /// or a member class of a template. 2280 void 2281 Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation, 2282 CXXRecordDecl *Instantiation, 2283 const MultiLevelTemplateArgumentList &TemplateArgs, 2284 TemplateSpecializationKind TSK) { 2285 for (DeclContext::decl_iterator D = Instantiation->decls_begin(), 2286 DEnd = Instantiation->decls_end(); 2287 D != DEnd; ++D) { 2288 bool SuppressNew = false; 2289 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(*D)) { 2290 if (FunctionDecl *Pattern 2291 = Function->getInstantiatedFromMemberFunction()) { 2292 MemberSpecializationInfo *MSInfo 2293 = Function->getMemberSpecializationInfo(); 2294 assert(MSInfo && "No member specialization information?"); 2295 if (MSInfo->getTemplateSpecializationKind() 2296 == TSK_ExplicitSpecialization) 2297 continue; 2298 2299 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK, 2300 Function, 2301 MSInfo->getTemplateSpecializationKind(), 2302 MSInfo->getPointOfInstantiation(), 2303 SuppressNew) || 2304 SuppressNew) 2305 continue; 2306 2307 if (Function->isDefined()) 2308 continue; 2309 2310 if (TSK == TSK_ExplicitInstantiationDefinition) { 2311 // C++0x [temp.explicit]p8: 2312 // An explicit instantiation definition that names a class template 2313 // specialization explicitly instantiates the class template 2314 // specialization and is only an explicit instantiation definition 2315 // of members whose definition is visible at the point of 2316 // instantiation. 2317 if (!Pattern->isDefined()) 2318 continue; 2319 2320 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation); 2321 2322 InstantiateFunctionDefinition(PointOfInstantiation, Function); 2323 } else { 2324 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation); 2325 } 2326 } 2327 } else if (VarDecl *Var = dyn_cast<VarDecl>(*D)) { 2328 if (Var->isStaticDataMember()) { 2329 MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo(); 2330 assert(MSInfo && "No member specialization information?"); 2331 if (MSInfo->getTemplateSpecializationKind() 2332 == TSK_ExplicitSpecialization) 2333 continue; 2334 2335 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK, 2336 Var, 2337 MSInfo->getTemplateSpecializationKind(), 2338 MSInfo->getPointOfInstantiation(), 2339 SuppressNew) || 2340 SuppressNew) 2341 continue; 2342 2343 if (TSK == TSK_ExplicitInstantiationDefinition) { 2344 // C++0x [temp.explicit]p8: 2345 // An explicit instantiation definition that names a class template 2346 // specialization explicitly instantiates the class template 2347 // specialization and is only an explicit instantiation definition 2348 // of members whose definition is visible at the point of 2349 // instantiation. 2350 if (!Var->getInstantiatedFromStaticDataMember() 2351 ->getOutOfLineDefinition()) 2352 continue; 2353 2354 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation); 2355 InstantiateStaticDataMemberDefinition(PointOfInstantiation, Var); 2356 } else { 2357 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation); 2358 } 2359 } 2360 } else if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(*D)) { 2361 // Always skip the injected-class-name, along with any 2362 // redeclarations of nested classes, since both would cause us 2363 // to try to instantiate the members of a class twice. 2364 if (Record->isInjectedClassName() || Record->getPreviousDecl()) 2365 continue; 2366 2367 MemberSpecializationInfo *MSInfo = Record->getMemberSpecializationInfo(); 2368 assert(MSInfo && "No member specialization information?"); 2369 2370 if (MSInfo->getTemplateSpecializationKind() 2371 == TSK_ExplicitSpecialization) 2372 continue; 2373 2374 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK, 2375 Record, 2376 MSInfo->getTemplateSpecializationKind(), 2377 MSInfo->getPointOfInstantiation(), 2378 SuppressNew) || 2379 SuppressNew) 2380 continue; 2381 2382 CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass(); 2383 assert(Pattern && "Missing instantiated-from-template information"); 2384 2385 if (!Record->getDefinition()) { 2386 if (!Pattern->getDefinition()) { 2387 // C++0x [temp.explicit]p8: 2388 // An explicit instantiation definition that names a class template 2389 // specialization explicitly instantiates the class template 2390 // specialization and is only an explicit instantiation definition 2391 // of members whose definition is visible at the point of 2392 // instantiation. 2393 if (TSK == TSK_ExplicitInstantiationDeclaration) { 2394 MSInfo->setTemplateSpecializationKind(TSK); 2395 MSInfo->setPointOfInstantiation(PointOfInstantiation); 2396 } 2397 2398 continue; 2399 } 2400 2401 InstantiateClass(PointOfInstantiation, Record, Pattern, 2402 TemplateArgs, 2403 TSK); 2404 } else { 2405 if (TSK == TSK_ExplicitInstantiationDefinition && 2406 Record->getTemplateSpecializationKind() == 2407 TSK_ExplicitInstantiationDeclaration) { 2408 Record->setTemplateSpecializationKind(TSK); 2409 MarkVTableUsed(PointOfInstantiation, Record, true); 2410 } 2411 } 2412 2413 Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition()); 2414 if (Pattern) 2415 InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs, 2416 TSK); 2417 } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(*D)) { 2418 MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo(); 2419 assert(MSInfo && "No member specialization information?"); 2420 2421 if (MSInfo->getTemplateSpecializationKind() 2422 == TSK_ExplicitSpecialization) 2423 continue; 2424 2425 if (CheckSpecializationInstantiationRedecl( 2426 PointOfInstantiation, TSK, Enum, 2427 MSInfo->getTemplateSpecializationKind(), 2428 MSInfo->getPointOfInstantiation(), SuppressNew) || 2429 SuppressNew) 2430 continue; 2431 2432 if (Enum->getDefinition()) 2433 continue; 2434 2435 EnumDecl *Pattern = Enum->getInstantiatedFromMemberEnum(); 2436 assert(Pattern && "Missing instantiated-from-template information"); 2437 2438 if (TSK == TSK_ExplicitInstantiationDefinition) { 2439 if (!Pattern->getDefinition()) 2440 continue; 2441 2442 InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK); 2443 } else { 2444 MSInfo->setTemplateSpecializationKind(TSK); 2445 MSInfo->setPointOfInstantiation(PointOfInstantiation); 2446 } 2447 } 2448 } 2449 } 2450 2451 /// \brief Instantiate the definitions of all of the members of the 2452 /// given class template specialization, which was named as part of an 2453 /// explicit instantiation. 2454 void 2455 Sema::InstantiateClassTemplateSpecializationMembers( 2456 SourceLocation PointOfInstantiation, 2457 ClassTemplateSpecializationDecl *ClassTemplateSpec, 2458 TemplateSpecializationKind TSK) { 2459 // C++0x [temp.explicit]p7: 2460 // An explicit instantiation that names a class template 2461 // specialization is an explicit instantion of the same kind 2462 // (declaration or definition) of each of its members (not 2463 // including members inherited from base classes) that has not 2464 // been previously explicitly specialized in the translation unit 2465 // containing the explicit instantiation, except as described 2466 // below. 2467 InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec, 2468 getTemplateInstantiationArgs(ClassTemplateSpec), 2469 TSK); 2470 } 2471 2472 StmtResult 2473 Sema::SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs) { 2474 if (!S) 2475 return Owned(S); 2476 2477 TemplateInstantiator Instantiator(*this, TemplateArgs, 2478 SourceLocation(), 2479 DeclarationName()); 2480 return Instantiator.TransformStmt(S); 2481 } 2482 2483 ExprResult 2484 Sema::SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs) { 2485 if (!E) 2486 return Owned(E); 2487 2488 TemplateInstantiator Instantiator(*this, TemplateArgs, 2489 SourceLocation(), 2490 DeclarationName()); 2491 return Instantiator.TransformExpr(E); 2492 } 2493 2494 bool Sema::SubstExprs(Expr **Exprs, unsigned NumExprs, bool IsCall, 2495 const MultiLevelTemplateArgumentList &TemplateArgs, 2496 SmallVectorImpl<Expr *> &Outputs) { 2497 if (NumExprs == 0) 2498 return false; 2499 2500 TemplateInstantiator Instantiator(*this, TemplateArgs, 2501 SourceLocation(), 2502 DeclarationName()); 2503 return Instantiator.TransformExprs(Exprs, NumExprs, IsCall, Outputs); 2504 } 2505 2506 NestedNameSpecifierLoc 2507 Sema::SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, 2508 const MultiLevelTemplateArgumentList &TemplateArgs) { 2509 if (!NNS) 2510 return NestedNameSpecifierLoc(); 2511 2512 TemplateInstantiator Instantiator(*this, TemplateArgs, NNS.getBeginLoc(), 2513 DeclarationName()); 2514 return Instantiator.TransformNestedNameSpecifierLoc(NNS); 2515 } 2516 2517 /// \brief Do template substitution on declaration name info. 2518 DeclarationNameInfo 2519 Sema::SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, 2520 const MultiLevelTemplateArgumentList &TemplateArgs) { 2521 TemplateInstantiator Instantiator(*this, TemplateArgs, NameInfo.getLoc(), 2522 NameInfo.getName()); 2523 return Instantiator.TransformDeclarationNameInfo(NameInfo); 2524 } 2525 2526 TemplateName 2527 Sema::SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, 2528 TemplateName Name, SourceLocation Loc, 2529 const MultiLevelTemplateArgumentList &TemplateArgs) { 2530 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, 2531 DeclarationName()); 2532 CXXScopeSpec SS; 2533 SS.Adopt(QualifierLoc); 2534 return Instantiator.TransformTemplateName(SS, Name, Loc); 2535 } 2536 2537 bool Sema::Subst(const TemplateArgumentLoc *Args, unsigned NumArgs, 2538 TemplateArgumentListInfo &Result, 2539 const MultiLevelTemplateArgumentList &TemplateArgs) { 2540 TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(), 2541 DeclarationName()); 2542 2543 return Instantiator.TransformTemplateArguments(Args, NumArgs, Result); 2544 } 2545 2546 llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> * 2547 LocalInstantiationScope::findInstantiationOf(const Decl *D) { 2548 for (LocalInstantiationScope *Current = this; Current; 2549 Current = Current->Outer) { 2550 2551 // Check if we found something within this scope. 2552 const Decl *CheckD = D; 2553 do { 2554 LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD); 2555 if (Found != Current->LocalDecls.end()) 2556 return &Found->second; 2557 2558 // If this is a tag declaration, it's possible that we need to look for 2559 // a previous declaration. 2560 if (const TagDecl *Tag = dyn_cast<TagDecl>(CheckD)) 2561 CheckD = Tag->getPreviousDecl(); 2562 else 2563 CheckD = 0; 2564 } while (CheckD); 2565 2566 // If we aren't combined with our outer scope, we're done. 2567 if (!Current->CombineWithOuterScope) 2568 break; 2569 } 2570 2571 // If we didn't find the decl, then we either have a sema bug, or we have a 2572 // forward reference to a label declaration. Return null to indicate that 2573 // we have an uninstantiated label. 2574 assert(isa<LabelDecl>(D) && "declaration not instantiated in this scope"); 2575 return 0; 2576 } 2577 2578 void LocalInstantiationScope::InstantiatedLocal(const Decl *D, Decl *Inst) { 2579 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D]; 2580 if (Stored.isNull()) 2581 Stored = Inst; 2582 else if (Stored.is<Decl *>()) { 2583 assert(Stored.get<Decl *>() == Inst && "Already instantiated this local"); 2584 Stored = Inst; 2585 } else 2586 LocalDecls[D].get<DeclArgumentPack *>()->push_back(Inst); 2587 } 2588 2589 void LocalInstantiationScope::InstantiatedLocalPackArg(const Decl *D, 2590 Decl *Inst) { 2591 DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>(); 2592 Pack->push_back(Inst); 2593 } 2594 2595 void LocalInstantiationScope::MakeInstantiatedLocalArgPack(const Decl *D) { 2596 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D]; 2597 assert(Stored.isNull() && "Already instantiated this local"); 2598 DeclArgumentPack *Pack = new DeclArgumentPack; 2599 Stored = Pack; 2600 ArgumentPacks.push_back(Pack); 2601 } 2602 2603 void LocalInstantiationScope::SetPartiallySubstitutedPack(NamedDecl *Pack, 2604 const TemplateArgument *ExplicitArgs, 2605 unsigned NumExplicitArgs) { 2606 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && 2607 "Already have a partially-substituted pack"); 2608 assert((!PartiallySubstitutedPack 2609 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && 2610 "Wrong number of arguments in partially-substituted pack"); 2611 PartiallySubstitutedPack = Pack; 2612 ArgsInPartiallySubstitutedPack = ExplicitArgs; 2613 NumArgsInPartiallySubstitutedPack = NumExplicitArgs; 2614 } 2615 2616 NamedDecl *LocalInstantiationScope::getPartiallySubstitutedPack( 2617 const TemplateArgument **ExplicitArgs, 2618 unsigned *NumExplicitArgs) const { 2619 if (ExplicitArgs) 2620 *ExplicitArgs = 0; 2621 if (NumExplicitArgs) 2622 *NumExplicitArgs = 0; 2623 2624 for (const LocalInstantiationScope *Current = this; Current; 2625 Current = Current->Outer) { 2626 if (Current->PartiallySubstitutedPack) { 2627 if (ExplicitArgs) 2628 *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack; 2629 if (NumExplicitArgs) 2630 *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack; 2631 2632 return Current->PartiallySubstitutedPack; 2633 } 2634 2635 if (!Current->CombineWithOuterScope) 2636 break; 2637 } 2638 2639 return 0; 2640 } 2641
