SemaTemplateInstantiateDecl.cpp revision 9060d0e1f3cf3feccdc9022a33b79b4063fe7cd4
1//===--- SemaTemplateInstantiateDecl.cpp - C++ Template Decl Instantiation ===/ 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7//===----------------------------------------------------------------------===/ 8// 9// This file implements C++ template instantiation for declarations. 10// 11//===----------------------------------------------------------------------===/ 12#include "Sema.h" 13#include "clang/AST/ASTConsumer.h" 14#include "clang/AST/ASTContext.h" 15#include "clang/AST/DeclTemplate.h" 16#include "clang/AST/DeclVisitor.h" 17#include "clang/AST/Expr.h" 18#include "llvm/Support/Compiler.h" 19 20using namespace clang; 21 22namespace { 23 class VISIBILITY_HIDDEN TemplateDeclInstantiator 24 : public DeclVisitor<TemplateDeclInstantiator, Decl *> { 25 Sema &SemaRef; 26 DeclContext *Owner; 27 const TemplateArgumentList &TemplateArgs; 28 29 public: 30 typedef Sema::OwningExprResult OwningExprResult; 31 32 TemplateDeclInstantiator(Sema &SemaRef, DeclContext *Owner, 33 const TemplateArgumentList &TemplateArgs) 34 : SemaRef(SemaRef), Owner(Owner), TemplateArgs(TemplateArgs) { } 35 36 // FIXME: Once we get closer to completion, replace these manually-written 37 // declarations with automatically-generated ones from 38 // clang/AST/DeclNodes.def. 39 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D); 40 Decl *VisitNamespaceDecl(NamespaceDecl *D); 41 Decl *VisitTypedefDecl(TypedefDecl *D); 42 Decl *VisitVarDecl(VarDecl *D); 43 Decl *VisitFieldDecl(FieldDecl *D); 44 Decl *VisitStaticAssertDecl(StaticAssertDecl *D); 45 Decl *VisitEnumDecl(EnumDecl *D); 46 Decl *VisitEnumConstantDecl(EnumConstantDecl *D); 47 Decl *VisitFunctionDecl(FunctionDecl *D); 48 Decl *VisitCXXRecordDecl(CXXRecordDecl *D); 49 Decl *VisitCXXMethodDecl(CXXMethodDecl *D); 50 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D); 51 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D); 52 Decl *VisitCXXConversionDecl(CXXConversionDecl *D); 53 ParmVarDecl *VisitParmVarDecl(ParmVarDecl *D); 54 Decl *VisitOriginalParmVarDecl(OriginalParmVarDecl *D); 55 56 // Base case. FIXME: Remove once we can instantiate everything. 57 Decl *VisitDecl(Decl *) { 58 assert(false && "Template instantiation of unknown declaration kind!"); 59 return 0; 60 } 61 62 // Helper functions for instantiating methods. 63 QualType InstantiateFunctionType(FunctionDecl *D, 64 llvm::SmallVectorImpl<ParmVarDecl *> &Params); 65 bool InitFunctionInstantiation(FunctionDecl *New, FunctionDecl *Tmpl); 66 bool InitMethodInstantiation(CXXMethodDecl *New, CXXMethodDecl *Tmpl); 67 }; 68} 69 70Decl * 71TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 72 assert(false && "Translation units cannot be instantiated"); 73 return D; 74} 75 76Decl * 77TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) { 78 assert(false && "Namespaces cannot be instantiated"); 79 return D; 80} 81 82Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) { 83 bool Invalid = false; 84 QualType T = D->getUnderlyingType(); 85 if (T->isDependentType()) { 86 T = SemaRef.InstantiateType(T, TemplateArgs, 87 D->getLocation(), D->getDeclName()); 88 if (T.isNull()) { 89 Invalid = true; 90 T = SemaRef.Context.IntTy; 91 } 92 } 93 94 // Create the new typedef 95 TypedefDecl *Typedef 96 = TypedefDecl::Create(SemaRef.Context, Owner, D->getLocation(), 97 D->getIdentifier(), T); 98 if (Invalid) 99 Typedef->setInvalidDecl(); 100 101 Owner->addDecl(Typedef); 102 103 return Typedef; 104} 105 106Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) { 107 // Instantiate the type of the declaration 108 QualType T = SemaRef.InstantiateType(D->getType(), TemplateArgs, 109 D->getTypeSpecStartLoc(), 110 D->getDeclName()); 111 if (T.isNull()) 112 return 0; 113 114 // Build the instantiated declaration 115 VarDecl *Var = VarDecl::Create(SemaRef.Context, Owner, 116 D->getLocation(), D->getIdentifier(), 117 T, D->getStorageClass(), 118 D->getTypeSpecStartLoc()); 119 Var->setThreadSpecified(D->isThreadSpecified()); 120 Var->setCXXDirectInitializer(D->hasCXXDirectInitializer()); 121 Var->setDeclaredInCondition(D->isDeclaredInCondition()); 122 123 // FIXME: In theory, we could have a previous declaration for variables that 124 // are not static data members. 125 bool Redeclaration = false; 126 SemaRef.CheckVariableDeclaration(Var, 0, Redeclaration); 127 Owner->addDecl(Var); 128 129 if (D->getInit()) { 130 OwningExprResult Init 131 = SemaRef.InstantiateExpr(D->getInit(), TemplateArgs); 132 if (Init.isInvalid()) 133 Var->setInvalidDecl(); 134 else 135 SemaRef.AddInitializerToDecl(Sema::DeclPtrTy::make(Var), move(Init), 136 D->hasCXXDirectInitializer()); 137 } else { 138 // FIXME: Call ActOnUninitializedDecl? (Not always) 139 } 140 141 return Var; 142} 143 144Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) { 145 bool Invalid = false; 146 QualType T = D->getType(); 147 if (T->isDependentType()) { 148 T = SemaRef.InstantiateType(T, TemplateArgs, 149 D->getLocation(), D->getDeclName()); 150 if (!T.isNull() && T->isFunctionType()) { 151 // C++ [temp.arg.type]p3: 152 // If a declaration acquires a function type through a type 153 // dependent on a template-parameter and this causes a 154 // declaration that does not use the syntactic form of a 155 // function declarator to have function type, the program is 156 // ill-formed. 157 SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function) 158 << T; 159 T = QualType(); 160 Invalid = true; 161 } 162 } 163 164 Expr *BitWidth = D->getBitWidth(); 165 if (Invalid) 166 BitWidth = 0; 167 else if (BitWidth) { 168 // The bit-width expression is not potentially evaluated. 169 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 170 171 OwningExprResult InstantiatedBitWidth 172 = SemaRef.InstantiateExpr(BitWidth, TemplateArgs); 173 if (InstantiatedBitWidth.isInvalid()) { 174 Invalid = true; 175 BitWidth = 0; 176 } else 177 BitWidth = InstantiatedBitWidth.takeAs<Expr>(); 178 } 179 180 FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(), T, 181 cast<RecordDecl>(Owner), 182 D->getLocation(), 183 D->isMutable(), 184 BitWidth, 185 D->getTypeSpecStartLoc(), 186 D->getAccess(), 187 0); 188 if (Field) { 189 if (Invalid) 190 Field->setInvalidDecl(); 191 192 Owner->addDecl(Field); 193 } 194 195 return Field; 196} 197 198Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) { 199 Expr *AssertExpr = D->getAssertExpr(); 200 201 // The expression in a static assertion is not potentially evaluated. 202 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 203 204 OwningExprResult InstantiatedAssertExpr 205 = SemaRef.InstantiateExpr(AssertExpr, TemplateArgs); 206 if (InstantiatedAssertExpr.isInvalid()) 207 return 0; 208 209 OwningExprResult Message = SemaRef.Clone(D->getMessage()); 210 Decl *StaticAssert 211 = SemaRef.ActOnStaticAssertDeclaration(D->getLocation(), 212 move(InstantiatedAssertExpr), 213 move(Message)).getAs<Decl>(); 214 return StaticAssert; 215} 216 217Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) { 218 EnumDecl *Enum = EnumDecl::Create(SemaRef.Context, Owner, 219 D->getLocation(), D->getIdentifier(), 220 D->getTagKeywordLoc(), 221 /*PrevDecl=*/0); 222 Enum->setInstantiationOfMemberEnum(D); 223 Enum->setAccess(D->getAccess()); 224 Owner->addDecl(Enum); 225 Enum->startDefinition(); 226 227 llvm::SmallVector<Sema::DeclPtrTy, 4> Enumerators; 228 229 EnumConstantDecl *LastEnumConst = 0; 230 for (EnumDecl::enumerator_iterator EC = D->enumerator_begin(), 231 ECEnd = D->enumerator_end(); 232 EC != ECEnd; ++EC) { 233 // The specified value for the enumerator. 234 OwningExprResult Value = SemaRef.Owned((Expr *)0); 235 if (Expr *UninstValue = EC->getInitExpr()) { 236 // The enumerator's value expression is not potentially evaluated. 237 EnterExpressionEvaluationContext Unevaluated(SemaRef, 238 Action::Unevaluated); 239 240 Value = SemaRef.InstantiateExpr(UninstValue, TemplateArgs); 241 } 242 243 // Drop the initial value and continue. 244 bool isInvalid = false; 245 if (Value.isInvalid()) { 246 Value = SemaRef.Owned((Expr *)0); 247 isInvalid = true; 248 } 249 250 EnumConstantDecl *EnumConst 251 = SemaRef.CheckEnumConstant(Enum, LastEnumConst, 252 EC->getLocation(), EC->getIdentifier(), 253 move(Value)); 254 255 if (isInvalid) { 256 if (EnumConst) 257 EnumConst->setInvalidDecl(); 258 Enum->setInvalidDecl(); 259 } 260 261 if (EnumConst) { 262 Enum->addDecl(EnumConst); 263 Enumerators.push_back(Sema::DeclPtrTy::make(EnumConst)); 264 LastEnumConst = EnumConst; 265 } 266 } 267 268 // FIXME: Fixup LBraceLoc and RBraceLoc 269 SemaRef.ActOnEnumBody(Enum->getLocation(), SourceLocation(), SourceLocation(), 270 Sema::DeclPtrTy::make(Enum), 271 &Enumerators[0], Enumerators.size()); 272 273 return Enum; 274} 275 276Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) { 277 assert(false && "EnumConstantDecls can only occur within EnumDecls."); 278 return 0; 279} 280 281Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) { 282 CXXRecordDecl *PrevDecl = 0; 283 if (D->isInjectedClassName()) 284 PrevDecl = cast<CXXRecordDecl>(Owner); 285 286 CXXRecordDecl *Record 287 = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner, 288 D->getLocation(), D->getIdentifier(), 289 D->getTagKeywordLoc(), PrevDecl); 290 Record->setImplicit(D->isImplicit()); 291 Record->setAccess(D->getAccess()); 292 if (!D->isInjectedClassName()) 293 Record->setInstantiationOfMemberClass(D); 294 295 Owner->addDecl(Record); 296 return Record; 297} 298 299Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D) { 300 // Check whether there is already a function template specialization for 301 // this declaration. 302 FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate(); 303 void *InsertPos = 0; 304 if (FunctionTemplate) { 305 llvm::FoldingSetNodeID ID; 306 FunctionTemplateSpecializationInfo::Profile(ID, 307 TemplateArgs.getFlatArgumentList(), 308 TemplateArgs.flat_size()); 309 310 FunctionTemplateSpecializationInfo *Info 311 = FunctionTemplate->getSpecializations().FindNodeOrInsertPos(ID, 312 InsertPos); 313 314 // If we already have a function template specialization, return it. 315 if (Info) 316 return Info->Function; 317 } 318 319 Sema::LocalInstantiationScope Scope(SemaRef); 320 321 llvm::SmallVector<ParmVarDecl *, 4> Params; 322 QualType T = InstantiateFunctionType(D, Params); 323 if (T.isNull()) 324 return 0; 325 326 // Build the instantiated method declaration. 327 FunctionDecl *Function 328 = FunctionDecl::Create(SemaRef.Context, Owner, D->getLocation(), 329 D->getDeclName(), T, D->getStorageClass(), 330 D->isInline(), D->hasWrittenPrototype(), 331 D->getTypeSpecStartLoc()); 332 333 // FIXME: friend functions 334 335 // Attach the parameters 336 for (unsigned P = 0; P < Params.size(); ++P) 337 Params[P]->setOwningFunction(Function); 338 Function->setParams(SemaRef.Context, Params.data(), Params.size()); 339 340 if (InitFunctionInstantiation(Function, D)) 341 Function->setInvalidDecl(); 342 343 bool Redeclaration = false; 344 bool OverloadableAttrRequired = false; 345 NamedDecl *PrevDecl = 0; 346 SemaRef.CheckFunctionDeclaration(Function, PrevDecl, Redeclaration, 347 /*FIXME:*/OverloadableAttrRequired); 348 349 if (FunctionTemplate) { 350 // Record this function template specialization. 351 Function->setFunctionTemplateSpecialization(SemaRef.Context, 352 FunctionTemplate, 353 &TemplateArgs, 354 InsertPos); 355 } 356 357 return Function; 358} 359 360Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D) { 361 // FIXME: Look for existing, explicit specializations. 362 Sema::LocalInstantiationScope Scope(SemaRef); 363 364 llvm::SmallVector<ParmVarDecl *, 4> Params; 365 QualType T = InstantiateFunctionType(D, Params); 366 if (T.isNull()) 367 return 0; 368 369 // Build the instantiated method declaration. 370 CXXRecordDecl *Record = cast<CXXRecordDecl>(Owner); 371 CXXMethodDecl *Method 372 = CXXMethodDecl::Create(SemaRef.Context, Record, D->getLocation(), 373 D->getDeclName(), T, D->isStatic(), 374 D->isInline()); 375 Method->setInstantiationOfMemberFunction(D); 376 377 // Attach the parameters 378 for (unsigned P = 0; P < Params.size(); ++P) 379 Params[P]->setOwningFunction(Method); 380 Method->setParams(SemaRef.Context, Params.data(), Params.size()); 381 382 if (InitMethodInstantiation(Method, D)) 383 Method->setInvalidDecl(); 384 385 NamedDecl *PrevDecl 386 = SemaRef.LookupQualifiedName(Owner, Method->getDeclName(), 387 Sema::LookupOrdinaryName, true); 388 // In C++, the previous declaration we find might be a tag type 389 // (class or enum). In this case, the new declaration will hide the 390 // tag type. Note that this does does not apply if we're declaring a 391 // typedef (C++ [dcl.typedef]p4). 392 if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag) 393 PrevDecl = 0; 394 bool Redeclaration = false; 395 bool OverloadableAttrRequired = false; 396 SemaRef.CheckFunctionDeclaration(Method, PrevDecl, Redeclaration, 397 /*FIXME:*/OverloadableAttrRequired); 398 399 if (!Method->isInvalidDecl() || !PrevDecl) 400 Owner->addDecl(Method); 401 return Method; 402} 403 404Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 405 // FIXME: Look for existing, explicit specializations. 406 Sema::LocalInstantiationScope Scope(SemaRef); 407 408 llvm::SmallVector<ParmVarDecl *, 4> Params; 409 QualType T = InstantiateFunctionType(D, Params); 410 if (T.isNull()) 411 return 0; 412 413 // Build the instantiated method declaration. 414 CXXRecordDecl *Record = cast<CXXRecordDecl>(Owner); 415 QualType ClassTy = SemaRef.Context.getTypeDeclType(Record); 416 DeclarationName Name 417 = SemaRef.Context.DeclarationNames.getCXXConstructorName( 418 SemaRef.Context.getCanonicalType(ClassTy)); 419 CXXConstructorDecl *Constructor 420 = CXXConstructorDecl::Create(SemaRef.Context, Record, D->getLocation(), 421 Name, T, D->isExplicit(), D->isInline(), 422 false); 423 Constructor->setInstantiationOfMemberFunction(D); 424 425 // Attach the parameters 426 for (unsigned P = 0; P < Params.size(); ++P) 427 Params[P]->setOwningFunction(Constructor); 428 Constructor->setParams(SemaRef.Context, Params.data(), Params.size()); 429 430 if (InitMethodInstantiation(Constructor, D)) 431 Constructor->setInvalidDecl(); 432 433 NamedDecl *PrevDecl 434 = SemaRef.LookupQualifiedName(Owner, Name, Sema::LookupOrdinaryName, true); 435 436 // In C++, the previous declaration we find might be a tag type 437 // (class or enum). In this case, the new declaration will hide the 438 // tag type. Note that this does does not apply if we're declaring a 439 // typedef (C++ [dcl.typedef]p4). 440 if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag) 441 PrevDecl = 0; 442 bool Redeclaration = false; 443 bool OverloadableAttrRequired = false; 444 SemaRef.CheckFunctionDeclaration(Constructor, PrevDecl, Redeclaration, 445 /*FIXME:*/OverloadableAttrRequired); 446 447 Record->addedConstructor(SemaRef.Context, Constructor); 448 Owner->addDecl(Constructor); 449 return Constructor; 450} 451 452Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 453 // FIXME: Look for existing, explicit specializations. 454 Sema::LocalInstantiationScope Scope(SemaRef); 455 456 llvm::SmallVector<ParmVarDecl *, 4> Params; 457 QualType T = InstantiateFunctionType(D, Params); 458 if (T.isNull()) 459 return 0; 460 assert(Params.size() == 0 && "Destructor with parameters?"); 461 462 // Build the instantiated destructor declaration. 463 CXXRecordDecl *Record = cast<CXXRecordDecl>(Owner); 464 QualType ClassTy = 465 SemaRef.Context.getCanonicalType(SemaRef.Context.getTypeDeclType(Record)); 466 CXXDestructorDecl *Destructor 467 = CXXDestructorDecl::Create(SemaRef.Context, Record, 468 D->getLocation(), 469 SemaRef.Context.DeclarationNames.getCXXDestructorName(ClassTy), 470 T, D->isInline(), false); 471 Destructor->setInstantiationOfMemberFunction(D); 472 if (InitMethodInstantiation(Destructor, D)) 473 Destructor->setInvalidDecl(); 474 475 bool Redeclaration = false; 476 bool OverloadableAttrRequired = false; 477 NamedDecl *PrevDecl = 0; 478 SemaRef.CheckFunctionDeclaration(Destructor, PrevDecl, Redeclaration, 479 /*FIXME:*/OverloadableAttrRequired); 480 Owner->addDecl(Destructor); 481 return Destructor; 482} 483 484Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) { 485 // FIXME: Look for existing, explicit specializations. 486 Sema::LocalInstantiationScope Scope(SemaRef); 487 488 llvm::SmallVector<ParmVarDecl *, 4> Params; 489 QualType T = InstantiateFunctionType(D, Params); 490 if (T.isNull()) 491 return 0; 492 assert(Params.size() == 0 && "Destructor with parameters?"); 493 494 // Build the instantiated conversion declaration. 495 CXXRecordDecl *Record = cast<CXXRecordDecl>(Owner); 496 QualType ClassTy = SemaRef.Context.getTypeDeclType(Record); 497 QualType ConvTy 498 = SemaRef.Context.getCanonicalType(T->getAsFunctionType()->getResultType()); 499 CXXConversionDecl *Conversion 500 = CXXConversionDecl::Create(SemaRef.Context, Record, 501 D->getLocation(), 502 SemaRef.Context.DeclarationNames.getCXXConversionFunctionName(ConvTy), 503 T, D->isInline(), D->isExplicit()); 504 Conversion->setInstantiationOfMemberFunction(D); 505 if (InitMethodInstantiation(Conversion, D)) 506 Conversion->setInvalidDecl(); 507 508 bool Redeclaration = false; 509 bool OverloadableAttrRequired = false; 510 NamedDecl *PrevDecl = 0; 511 SemaRef.CheckFunctionDeclaration(Conversion, PrevDecl, Redeclaration, 512 /*FIXME:*/OverloadableAttrRequired); 513 Owner->addDecl(Conversion); 514 return Conversion; 515} 516 517ParmVarDecl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) { 518 QualType OrigT = SemaRef.InstantiateType(D->getOriginalType(), TemplateArgs, 519 D->getLocation(), D->getDeclName()); 520 if (OrigT.isNull()) 521 return 0; 522 523 QualType T = SemaRef.adjustParameterType(OrigT); 524 525 if (D->getDefaultArg()) { 526 // FIXME: Leave a marker for "uninstantiated" default 527 // arguments. They only get instantiated on demand at the call 528 // site. 529 unsigned DiagID = SemaRef.Diags.getCustomDiagID(Diagnostic::Warning, 530 "sorry, dropping default argument during template instantiation"); 531 SemaRef.Diag(D->getDefaultArg()->getSourceRange().getBegin(), DiagID) 532 << D->getDefaultArg()->getSourceRange(); 533 } 534 535 // Allocate the parameter 536 ParmVarDecl *Param = 0; 537 if (T == OrigT) 538 Param = ParmVarDecl::Create(SemaRef.Context, Owner, D->getLocation(), 539 D->getIdentifier(), T, D->getStorageClass(), 540 0); 541 else 542 Param = OriginalParmVarDecl::Create(SemaRef.Context, Owner, 543 D->getLocation(), D->getIdentifier(), 544 T, OrigT, D->getStorageClass(), 0); 545 546 // Note: we don't try to instantiate function parameters until after 547 // we've instantiated the function's type. Therefore, we don't have 548 // to check for 'void' parameter types here. 549 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param); 550 return Param; 551} 552 553Decl * 554TemplateDeclInstantiator::VisitOriginalParmVarDecl(OriginalParmVarDecl *D) { 555 // Since parameter types can decay either before or after 556 // instantiation, we simply treat OriginalParmVarDecls as 557 // ParmVarDecls the same way, and create one or the other depending 558 // on what happens after template instantiation. 559 return VisitParmVarDecl(D); 560} 561 562Decl *Sema::InstantiateDecl(Decl *D, DeclContext *Owner, 563 const TemplateArgumentList &TemplateArgs) { 564 TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs); 565 return Instantiator.Visit(D); 566} 567 568/// \brief Instantiates the type of the given function, including 569/// instantiating all of the function parameters. 570/// 571/// \param D The function that we will be instantiated 572/// 573/// \param Params the instantiated parameter declarations 574 575/// \returns the instantiated function's type if successfull, a NULL 576/// type if there was an error. 577QualType 578TemplateDeclInstantiator::InstantiateFunctionType(FunctionDecl *D, 579 llvm::SmallVectorImpl<ParmVarDecl *> &Params) { 580 bool InvalidDecl = false; 581 582 // Instantiate the function parameters 583 TemplateDeclInstantiator ParamInstantiator(SemaRef, 0, TemplateArgs); 584 llvm::SmallVector<QualType, 4> ParamTys; 585 for (FunctionDecl::param_iterator P = D->param_begin(), 586 PEnd = D->param_end(); 587 P != PEnd; ++P) { 588 if (ParmVarDecl *PInst = ParamInstantiator.VisitParmVarDecl(*P)) { 589 if (PInst->getType()->isVoidType()) { 590 SemaRef.Diag(PInst->getLocation(), diag::err_param_with_void_type); 591 PInst->setInvalidDecl(); 592 } 593 else if (SemaRef.RequireNonAbstractType(PInst->getLocation(), 594 PInst->getType(), 595 diag::err_abstract_type_in_decl, 596 Sema::AbstractParamType)) 597 PInst->setInvalidDecl(); 598 599 Params.push_back(PInst); 600 ParamTys.push_back(PInst->getType()); 601 602 if (PInst->isInvalidDecl()) 603 InvalidDecl = true; 604 } else 605 InvalidDecl = true; 606 } 607 608 // FIXME: Deallocate dead declarations. 609 if (InvalidDecl) 610 return QualType(); 611 612 const FunctionProtoType *Proto = D->getType()->getAsFunctionProtoType(); 613 assert(Proto && "Missing prototype?"); 614 QualType ResultType 615 = SemaRef.InstantiateType(Proto->getResultType(), TemplateArgs, 616 D->getLocation(), D->getDeclName()); 617 if (ResultType.isNull()) 618 return QualType(); 619 620 return SemaRef.BuildFunctionType(ResultType, ParamTys.data(), ParamTys.size(), 621 Proto->isVariadic(), Proto->getTypeQuals(), 622 D->getLocation(), D->getDeclName()); 623} 624 625/// \brief Initializes the common fields of an instantiation function 626/// declaration (New) from the corresponding fields of its template (Tmpl). 627/// 628/// \returns true if there was an error 629bool 630TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New, 631 FunctionDecl *Tmpl) { 632 if (Tmpl->isDeleted()) 633 New->setDeleted(); 634 635 // If we are performing substituting explicitly-specified template arguments 636 // or deduced template arguments into a function template and we reach this 637 // point, we are now past the point where SFINAE applies and have committed 638 // to keeping the new function template specialization. We therefore 639 // convert the active template instantiation for the function template 640 // into a template instantiation for this specific function template 641 // specialization, which is not a SFINAE context, so that we diagnose any 642 // further errors in the declaration itself. 643 typedef Sema::ActiveTemplateInstantiation ActiveInstType; 644 ActiveInstType &ActiveInst = SemaRef.ActiveTemplateInstantiations.back(); 645 if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution || 646 ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) { 647 if (FunctionTemplateDecl *FunTmpl 648 = dyn_cast<FunctionTemplateDecl>((Decl *)ActiveInst.Entity)) { 649 assert(FunTmpl->getTemplatedDecl() == Tmpl && 650 "Deduction from the wrong function template?"); 651 (void) FunTmpl; 652 ActiveInst.Kind = ActiveInstType::TemplateInstantiation; 653 ActiveInst.Entity = reinterpret_cast<uintptr_t>(New); 654 } 655 } 656 657 return false; 658} 659 660/// \brief Initializes common fields of an instantiated method 661/// declaration (New) from the corresponding fields of its template 662/// (Tmpl). 663/// 664/// \returns true if there was an error 665bool 666TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New, 667 CXXMethodDecl *Tmpl) { 668 if (InitFunctionInstantiation(New, Tmpl)) 669 return true; 670 671 CXXRecordDecl *Record = cast<CXXRecordDecl>(Owner); 672 New->setAccess(Tmpl->getAccess()); 673 if (Tmpl->isVirtualAsWritten()) { 674 New->setVirtualAsWritten(true); 675 Record->setAggregate(false); 676 Record->setPOD(false); 677 Record->setPolymorphic(true); 678 } 679 if (Tmpl->isPure()) { 680 New->setPure(); 681 Record->setAbstract(true); 682 } 683 684 // FIXME: attributes 685 // FIXME: New needs a pointer to Tmpl 686 return false; 687} 688 689/// \brief Instantiate the definition of the given function from its 690/// template. 691/// 692/// \param PointOfInstantiation the point at which the instantiation was 693/// required. Note that this is not precisely a "point of instantiation" 694/// for the function, but it's close. 695/// 696/// \param Function the already-instantiated declaration of a 697/// function template specialization or member function of a class template 698/// specialization. 699/// 700/// \param Recursive if true, recursively instantiates any functions that 701/// are required by this instantiation. 702void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, 703 FunctionDecl *Function, 704 bool Recursive) { 705 if (Function->isInvalidDecl()) 706 return; 707 708 assert(!Function->getBody() && "Already instantiated!"); 709 710 // Find the function body that we'll be substituting. 711 const FunctionDecl *PatternDecl = 0; 712 if (FunctionTemplateDecl *Primary = Function->getPrimaryTemplate()) 713 PatternDecl = Primary->getTemplatedDecl(); 714 else 715 PatternDecl = Function->getInstantiatedFromMemberFunction(); 716 Stmt *Pattern = 0; 717 if (PatternDecl) 718 Pattern = PatternDecl->getBody(PatternDecl); 719 720 if (!Pattern) 721 return; 722 723 InstantiatingTemplate Inst(*this, PointOfInstantiation, Function); 724 if (Inst) 725 return; 726 727 // If we're performing recursive template instantiation, create our own 728 // queue of pending implicit instantiations that we will instantiate later, 729 // while we're still within our own instantiation context. 730 std::deque<PendingImplicitInstantiation> SavedPendingImplicitInstantiations; 731 if (Recursive) 732 PendingImplicitInstantiations.swap(SavedPendingImplicitInstantiations); 733 734 ActOnStartOfFunctionDef(0, DeclPtrTy::make(Function)); 735 736 // Introduce a new scope where local variable instantiations will be 737 // recorded. 738 LocalInstantiationScope Scope(*this); 739 740 // Introduce the instantiated function parameters into the local 741 // instantiation scope. 742 for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) 743 Scope.InstantiatedLocal(PatternDecl->getParamDecl(I), 744 Function->getParamDecl(I)); 745 746 // Enter the scope of this instantiation. We don't use 747 // PushDeclContext because we don't have a scope. 748 DeclContext *PreviousContext = CurContext; 749 CurContext = Function; 750 751 // Instantiate the function body. 752 OwningStmtResult Body 753 = InstantiateStmt(Pattern, getTemplateInstantiationArgs(Function)); 754 755 ActOnFinishFunctionBody(DeclPtrTy::make(Function), move(Body), 756 /*IsInstantiation=*/true); 757 758 CurContext = PreviousContext; 759 760 DeclGroupRef DG(Function); 761 Consumer.HandleTopLevelDecl(DG); 762 763 if (Recursive) { 764 // Instantiate any pending implicit instantiations found during the 765 // instantiation of this template. 766 PerformPendingImplicitInstantiations(); 767 768 // Restore the set of pending implicit instantiations. 769 PendingImplicitInstantiations.swap(SavedPendingImplicitInstantiations); 770 } 771} 772 773/// \brief Instantiate the definition of the given variable from its 774/// template. 775/// 776/// \param Var the already-instantiated declaration of a variable. 777void Sema::InstantiateVariableDefinition(VarDecl *Var) { 778 // FIXME: Implement this! 779} 780 781static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) { 782 if (D->getKind() != Other->getKind()) 783 return false; 784 785 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Other)) 786 return Record->getInstantiatedFromMemberClass()->getCanonicalDecl() 787 == D->getCanonicalDecl(); 788 789 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Other)) 790 return Function->getInstantiatedFromMemberFunction()->getCanonicalDecl() 791 == D->getCanonicalDecl(); 792 793 if (EnumDecl *Enum = dyn_cast<EnumDecl>(Other)) 794 return Enum->getInstantiatedFromMemberEnum()->getCanonicalDecl() 795 == D->getCanonicalDecl(); 796 797 // FIXME: How can we find instantiations of anonymous unions? 798 799 return D->getDeclName() && isa<NamedDecl>(Other) && 800 D->getDeclName() == cast<NamedDecl>(Other)->getDeclName(); 801} 802 803template<typename ForwardIterator> 804static NamedDecl *findInstantiationOf(ASTContext &Ctx, 805 NamedDecl *D, 806 ForwardIterator first, 807 ForwardIterator last) { 808 for (; first != last; ++first) 809 if (isInstantiationOf(Ctx, D, *first)) 810 return cast<NamedDecl>(*first); 811 812 return 0; 813} 814 815/// \brief Find the instantiation of the given declaration within the 816/// current instantiation. 817/// 818/// This routine is intended to be used when \p D is a declaration 819/// referenced from within a template, that needs to mapped into the 820/// corresponding declaration within an instantiation. For example, 821/// given: 822/// 823/// \code 824/// template<typename T> 825/// struct X { 826/// enum Kind { 827/// KnownValue = sizeof(T) 828/// }; 829/// 830/// bool getKind() const { return KnownValue; } 831/// }; 832/// 833/// template struct X<int>; 834/// \endcode 835/// 836/// In the instantiation of X<int>::getKind(), we need to map the 837/// EnumConstantDecl for KnownValue (which refers to 838/// X<T>::<Kind>::KnownValue) to its instantiation 839/// (X<int>::<Kind>::KnownValue). InstantiateCurrentDeclRef() performs 840/// this mapping from within the instantiation of X<int>. 841NamedDecl * Sema::InstantiateCurrentDeclRef(NamedDecl *D) { 842 DeclContext *ParentDC = D->getDeclContext(); 843 if (isa<ParmVarDecl>(D) || ParentDC->isFunctionOrMethod()) { 844 // D is a local of some kind. Look into the map of local 845 // declarations to their instantiations. 846 return cast<NamedDecl>(CurrentInstantiationScope->getInstantiationOf(D)); 847 } 848 849 if (NamedDecl *ParentDecl = dyn_cast<NamedDecl>(ParentDC)) { 850 ParentDecl = InstantiateCurrentDeclRef(ParentDecl); 851 if (!ParentDecl) 852 return 0; 853 854 ParentDC = cast<DeclContext>(ParentDecl); 855 } 856 857 if (ParentDC != D->getDeclContext()) { 858 // We performed some kind of instantiation in the parent context, 859 // so now we need to look into the instantiated parent context to 860 // find the instantiation of the declaration D. 861 NamedDecl *Result = 0; 862 if (D->getDeclName()) { 863 DeclContext::lookup_result Found = ParentDC->lookup(D->getDeclName()); 864 Result = findInstantiationOf(Context, D, Found.first, Found.second); 865 } else { 866 // Since we don't have a name for the entity we're looking for, 867 // our only option is to walk through all of the declarations to 868 // find that name. This will occur in a few cases: 869 // 870 // - anonymous struct/union within a template 871 // - unnamed class/struct/union/enum within a template 872 // 873 // FIXME: Find a better way to find these instantiations! 874 Result = findInstantiationOf(Context, D, 875 ParentDC->decls_begin(), 876 ParentDC->decls_end()); 877 } 878 assert(Result && "Unable to find instantiation of declaration!"); 879 D = Result; 880 } 881 882 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) 883 if (ClassTemplateDecl *ClassTemplate 884 = Record->getDescribedClassTemplate()) { 885 // When the declaration D was parsed, it referred to the current 886 // instantiation. Therefore, look through the current context, 887 // which contains actual instantiations, to find the 888 // instantiation of the "current instantiation" that D refers 889 // to. Alternatively, we could just instantiate the 890 // injected-class-name with the current template arguments, but 891 // such an instantiation is far more expensive. 892 for (DeclContext *DC = CurContext; !DC->isFileContext(); 893 DC = DC->getParent()) { 894 if (ClassTemplateSpecializationDecl *Spec 895 = dyn_cast<ClassTemplateSpecializationDecl>(DC)) 896 if (Spec->getSpecializedTemplate()->getCanonicalDecl() 897 == ClassTemplate->getCanonicalDecl()) 898 return Spec; 899 } 900 901 assert(false && 902 "Unable to find declaration for the current instantiation"); 903 } 904 905 return D; 906} 907 908/// \brief Performs template instantiation for all implicit template 909/// instantiations we have seen until this point. 910void Sema::PerformPendingImplicitInstantiations() { 911 while (!PendingImplicitInstantiations.empty()) { 912 PendingImplicitInstantiation Inst = PendingImplicitInstantiations.front(); 913 PendingImplicitInstantiations.pop_front(); 914 915 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) 916 if (!Function->getBody()) 917 InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true); 918 919 // FIXME: instantiate static member variables 920 } 921} 922