SemaTemplateInstantiateDecl.cpp revision 390b4cc8b45a05612349269ef08faab3e4688f06
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/ASTContext.h" 14#include "clang/AST/DeclTemplate.h" 15#include "clang/AST/DeclVisitor.h" 16#include "clang/AST/Expr.h" 17#include "llvm/Support/Compiler.h" 18 19using namespace clang; 20 21namespace { 22 class VISIBILITY_HIDDEN TemplateDeclInstantiator 23 : public DeclVisitor<TemplateDeclInstantiator, Decl *> { 24 Sema &SemaRef; 25 DeclContext *Owner; 26 const TemplateArgumentList &TemplateArgs; 27 28 public: 29 typedef Sema::OwningExprResult OwningExprResult; 30 31 TemplateDeclInstantiator(Sema &SemaRef, DeclContext *Owner, 32 const TemplateArgumentList &TemplateArgs) 33 : SemaRef(SemaRef), Owner(Owner), TemplateArgs(TemplateArgs) { } 34 35 // FIXME: Once we get closer to completion, replace these manually-written 36 // declarations with automatically-generated ones from 37 // clang/AST/DeclNodes.def. 38 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D); 39 Decl *VisitNamespaceDecl(NamespaceDecl *D); 40 Decl *VisitTypedefDecl(TypedefDecl *D); 41 Decl *VisitVarDecl(VarDecl *D); 42 Decl *VisitFieldDecl(FieldDecl *D); 43 Decl *VisitStaticAssertDecl(StaticAssertDecl *D); 44 Decl *VisitEnumDecl(EnumDecl *D); 45 Decl *VisitEnumConstantDecl(EnumConstantDecl *D); 46 Decl *VisitCXXRecordDecl(CXXRecordDecl *D); 47 Decl *VisitCXXMethodDecl(CXXMethodDecl *D); 48 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D); 49 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D); 50 Decl *VisitCXXConversionDecl(CXXConversionDecl *D); 51 ParmVarDecl *VisitParmVarDecl(ParmVarDecl *D); 52 Decl *VisitOriginalParmVarDecl(OriginalParmVarDecl *D); 53 54 // Base case. FIXME: Remove once we can instantiate everything. 55 Decl *VisitDecl(Decl *) { 56 assert(false && "Template instantiation of unknown declaration kind!"); 57 return 0; 58 } 59 60 // Helper functions for instantiating methods. 61 QualType InstantiateFunctionType(FunctionDecl *D, 62 llvm::SmallVectorImpl<ParmVarDecl *> &Params); 63 bool InitMethodInstantiation(CXXMethodDecl *New, CXXMethodDecl *Tmpl); 64 }; 65} 66 67Decl * 68TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 69 assert(false && "Translation units cannot be instantiated"); 70 return D; 71} 72 73Decl * 74TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) { 75 assert(false && "Namespaces cannot be instantiated"); 76 return D; 77} 78 79Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) { 80 bool Invalid = false; 81 QualType T = D->getUnderlyingType(); 82 if (T->isDependentType()) { 83 T = SemaRef.InstantiateType(T, TemplateArgs, 84 D->getLocation(), D->getDeclName()); 85 if (T.isNull()) { 86 Invalid = true; 87 T = SemaRef.Context.IntTy; 88 } 89 } 90 91 // Create the new typedef 92 TypedefDecl *Typedef 93 = TypedefDecl::Create(SemaRef.Context, Owner, D->getLocation(), 94 D->getIdentifier(), T); 95 if (Invalid) 96 Typedef->setInvalidDecl(); 97 98 Owner->addDecl(SemaRef.Context, Typedef); 99 return Typedef; 100} 101 102Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) { 103 // Instantiate the type of the declaration 104 QualType T = SemaRef.InstantiateType(D->getType(), TemplateArgs, 105 D->getTypeSpecStartLoc(), 106 D->getDeclName()); 107 if (T.isNull()) 108 return 0; 109 110 // Build the instantiated declaration 111 VarDecl *Var = VarDecl::Create(SemaRef.Context, Owner, 112 D->getLocation(), D->getIdentifier(), 113 T, D->getStorageClass(), 114 D->getTypeSpecStartLoc()); 115 Var->setThreadSpecified(D->isThreadSpecified()); 116 Var->setCXXDirectInitializer(D->hasCXXDirectInitializer()); 117 Var->setDeclaredInCondition(D->isDeclaredInCondition()); 118 119 // FIXME: In theory, we could have a previous declaration for variables that 120 // are not static data members. 121 bool Redeclaration = false; 122 SemaRef.CheckVariableDeclaration(Var, 0, Redeclaration); 123 Owner->addDecl(SemaRef.Context, Var); 124 125 if (D->getInit()) { 126 OwningExprResult Init 127 = SemaRef.InstantiateExpr(D->getInit(), TemplateArgs); 128 if (Init.isInvalid()) 129 Var->setInvalidDecl(); 130 else 131 SemaRef.AddInitializerToDecl(Sema::DeclPtrTy::make(Var), move(Init), 132 D->hasCXXDirectInitializer()); 133 } 134 135 return Var; 136} 137 138Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) { 139 bool Invalid = false; 140 QualType T = D->getType(); 141 if (T->isDependentType()) { 142 T = SemaRef.InstantiateType(T, TemplateArgs, 143 D->getLocation(), D->getDeclName()); 144 if (!T.isNull() && T->isFunctionType()) { 145 // C++ [temp.arg.type]p3: 146 // If a declaration acquires a function type through a type 147 // dependent on a template-parameter and this causes a 148 // declaration that does not use the syntactic form of a 149 // function declarator to have function type, the program is 150 // ill-formed. 151 SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function) 152 << T; 153 T = QualType(); 154 Invalid = true; 155 } 156 } 157 158 Expr *BitWidth = D->getBitWidth(); 159 if (Invalid) 160 BitWidth = 0; 161 else if (BitWidth) { 162 OwningExprResult InstantiatedBitWidth 163 = SemaRef.InstantiateExpr(BitWidth, TemplateArgs); 164 if (InstantiatedBitWidth.isInvalid()) { 165 Invalid = true; 166 BitWidth = 0; 167 } else 168 BitWidth = InstantiatedBitWidth.takeAs<Expr>(); 169 } 170 171 FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(), T, 172 cast<RecordDecl>(Owner), 173 D->getLocation(), 174 D->isMutable(), 175 BitWidth, 176 D->getAccess(), 177 0); 178 if (Field) { 179 if (Invalid) 180 Field->setInvalidDecl(); 181 182 Owner->addDecl(SemaRef.Context, Field); 183 } 184 185 return Field; 186} 187 188Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) { 189 Expr *AssertExpr = D->getAssertExpr(); 190 191 OwningExprResult InstantiatedAssertExpr 192 = SemaRef.InstantiateExpr(AssertExpr, TemplateArgs); 193 if (InstantiatedAssertExpr.isInvalid()) 194 return 0; 195 196 OwningExprResult Message = SemaRef.Clone(D->getMessage()); 197 Decl *StaticAssert 198 = SemaRef.ActOnStaticAssertDeclaration(D->getLocation(), 199 move(InstantiatedAssertExpr), 200 move(Message)).getAs<Decl>(); 201 return StaticAssert; 202} 203 204Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) { 205 EnumDecl *Enum = EnumDecl::Create(SemaRef.Context, Owner, 206 D->getLocation(), D->getIdentifier(), 207 /*PrevDecl=*/0); 208 Enum->setAccess(D->getAccess()); 209 Owner->addDecl(SemaRef.Context, Enum); 210 Enum->startDefinition(); 211 212 llvm::SmallVector<Sema::DeclPtrTy, 16> Enumerators; 213 214 EnumConstantDecl *LastEnumConst = 0; 215 for (EnumDecl::enumerator_iterator EC = D->enumerator_begin(SemaRef.Context), 216 ECEnd = D->enumerator_end(SemaRef.Context); 217 EC != ECEnd; ++EC) { 218 // The specified value for the enumerator. 219 OwningExprResult Value = SemaRef.Owned((Expr *)0); 220 if (Expr *UninstValue = EC->getInitExpr()) 221 Value = SemaRef.InstantiateExpr(UninstValue, TemplateArgs); 222 223 // Drop the initial value and continue. 224 bool isInvalid = false; 225 if (Value.isInvalid()) { 226 Value = SemaRef.Owned((Expr *)0); 227 isInvalid = true; 228 } 229 230 EnumConstantDecl *EnumConst 231 = SemaRef.CheckEnumConstant(Enum, LastEnumConst, 232 EC->getLocation(), EC->getIdentifier(), 233 move(Value)); 234 235 if (isInvalid) { 236 if (EnumConst) 237 EnumConst->setInvalidDecl(); 238 Enum->setInvalidDecl(); 239 } 240 241 if (EnumConst) { 242 Enum->addDecl(SemaRef.Context, EnumConst); 243 Enumerators.push_back(Sema::DeclPtrTy::make(EnumConst)); 244 LastEnumConst = EnumConst; 245 } 246 } 247 248 // FIXME: Fixup LBraceLoc and RBraceLoc 249 SemaRef.ActOnEnumBody(Enum->getLocation(), SourceLocation(), SourceLocation(), 250 Sema::DeclPtrTy::make(Enum), 251 &Enumerators[0], Enumerators.size()); 252 253 return Enum; 254} 255 256Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) { 257 assert(false && "EnumConstantDecls can only occur within EnumDecls."); 258 return 0; 259} 260 261Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) { 262 CXXRecordDecl *PrevDecl = 0; 263 if (D->isInjectedClassName()) 264 PrevDecl = cast<CXXRecordDecl>(Owner); 265 266 CXXRecordDecl *Record 267 = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner, 268 D->getLocation(), D->getIdentifier(), PrevDecl); 269 Record->setImplicit(D->isImplicit()); 270 Record->setAccess(D->getAccess()); 271 if (!D->isInjectedClassName()) 272 Record->setInstantiationOfMemberClass(D); 273 274 Owner->addDecl(SemaRef.Context, Record); 275 return Record; 276} 277 278Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D) { 279 // Only handle actual methods; we'll deal with constructors, 280 // destructors, etc. separately. 281 if (D->getKind() != Decl::CXXMethod) 282 return 0; 283 284 Sema::LocalInstantiationScope Scope(SemaRef); 285 286 llvm::SmallVector<ParmVarDecl *, 16> Params; 287 QualType T = InstantiateFunctionType(D, Params); 288 if (T.isNull()) 289 return 0; 290 291 // Build the instantiated method declaration. 292 CXXRecordDecl *Record = cast<CXXRecordDecl>(Owner); 293 CXXMethodDecl *Method 294 = CXXMethodDecl::Create(SemaRef.Context, Record, D->getLocation(), 295 D->getDeclName(), T, D->isStatic(), 296 D->isInline()); 297 Method->setInstantiationOfMemberFunction(D); 298 299 // Attach the parameters 300 for (unsigned P = 0; P < Params.size(); ++P) 301 Params[P]->setOwningFunction(Method); 302 Method->setParams(SemaRef.Context, &Params[0], Params.size()); 303 304 if (InitMethodInstantiation(Method, D)) 305 Method->setInvalidDecl(); 306 307 NamedDecl *PrevDecl 308 = SemaRef.LookupQualifiedName(Owner, Method->getDeclName(), 309 Sema::LookupOrdinaryName, true); 310 // In C++, the previous declaration we find might be a tag type 311 // (class or enum). In this case, the new declaration will hide the 312 // tag type. Note that this does does not apply if we're declaring a 313 // typedef (C++ [dcl.typedef]p4). 314 if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag) 315 PrevDecl = 0; 316 bool Redeclaration = false; 317 bool OverloadableAttrRequired = false; 318 SemaRef.CheckFunctionDeclaration(Method, PrevDecl, Redeclaration, 319 /*FIXME:*/OverloadableAttrRequired); 320 321 if (!Method->isInvalidDecl() || !PrevDecl) 322 Owner->addDecl(SemaRef.Context, Method); 323 return Method; 324} 325 326Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 327 Sema::LocalInstantiationScope Scope(SemaRef); 328 329 llvm::SmallVector<ParmVarDecl *, 16> Params; 330 QualType T = InstantiateFunctionType(D, Params); 331 if (T.isNull()) 332 return 0; 333 334 // Build the instantiated method declaration. 335 CXXRecordDecl *Record = cast<CXXRecordDecl>(Owner); 336 QualType ClassTy = SemaRef.Context.getTypeDeclType(Record); 337 DeclarationName Name 338 = SemaRef.Context.DeclarationNames.getCXXConstructorName( 339 SemaRef.Context.getCanonicalType(ClassTy)); 340 CXXConstructorDecl *Constructor 341 = CXXConstructorDecl::Create(SemaRef.Context, Record, D->getLocation(), 342 Name, T, D->isExplicit(), D->isInline(), 343 false); 344 Constructor->setInstantiationOfMemberFunction(D); 345 346 // Attach the parameters 347 for (unsigned P = 0; P < Params.size(); ++P) 348 Params[P]->setOwningFunction(Constructor); 349 Constructor->setParams(SemaRef.Context, &Params[0], Params.size()); 350 351 if (InitMethodInstantiation(Constructor, D)) 352 Constructor->setInvalidDecl(); 353 354 NamedDecl *PrevDecl 355 = SemaRef.LookupQualifiedName(Owner, Name, Sema::LookupOrdinaryName, true); 356 357 // In C++, the previous declaration we find might be a tag type 358 // (class or enum). In this case, the new declaration will hide the 359 // tag type. Note that this does does not apply if we're declaring a 360 // typedef (C++ [dcl.typedef]p4). 361 if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag) 362 PrevDecl = 0; 363 bool Redeclaration = false; 364 bool OverloadableAttrRequired = false; 365 SemaRef.CheckFunctionDeclaration(Constructor, PrevDecl, Redeclaration, 366 /*FIXME:*/OverloadableAttrRequired); 367 368 Record->addedConstructor(SemaRef.Context, Constructor); 369 Owner->addDecl(SemaRef.Context, Constructor); 370 return Constructor; 371} 372 373Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 374 Sema::LocalInstantiationScope Scope(SemaRef); 375 376 llvm::SmallVector<ParmVarDecl *, 16> Params; 377 QualType T = InstantiateFunctionType(D, Params); 378 if (T.isNull()) 379 return 0; 380 assert(Params.size() == 0 && "Destructor with parameters?"); 381 382 // Build the instantiated destructor declaration. 383 CXXRecordDecl *Record = cast<CXXRecordDecl>(Owner); 384 QualType ClassTy = 385 SemaRef.Context.getCanonicalType(SemaRef.Context.getTypeDeclType(Record)); 386 CXXDestructorDecl *Destructor 387 = CXXDestructorDecl::Create(SemaRef.Context, Record, 388 D->getLocation(), 389 SemaRef.Context.DeclarationNames.getCXXDestructorName(ClassTy), 390 T, D->isInline(), false); 391 Destructor->setInstantiationOfMemberFunction(D); 392 if (InitMethodInstantiation(Destructor, D)) 393 Destructor->setInvalidDecl(); 394 395 bool Redeclaration = false; 396 bool OverloadableAttrRequired = false; 397 NamedDecl *PrevDecl = 0; 398 SemaRef.CheckFunctionDeclaration(Destructor, PrevDecl, Redeclaration, 399 /*FIXME:*/OverloadableAttrRequired); 400 Owner->addDecl(SemaRef.Context, Destructor); 401 return Destructor; 402} 403 404Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) { 405 Sema::LocalInstantiationScope Scope(SemaRef); 406 407 llvm::SmallVector<ParmVarDecl *, 16> Params; 408 QualType T = InstantiateFunctionType(D, Params); 409 if (T.isNull()) 410 return 0; 411 assert(Params.size() == 0 && "Destructor with parameters?"); 412 413 // Build the instantiated conversion declaration. 414 CXXRecordDecl *Record = cast<CXXRecordDecl>(Owner); 415 QualType ClassTy = SemaRef.Context.getTypeDeclType(Record); 416 QualType ConvTy 417 = SemaRef.Context.getCanonicalType(T->getAsFunctionType()->getResultType()); 418 CXXConversionDecl *Conversion 419 = CXXConversionDecl::Create(SemaRef.Context, Record, 420 D->getLocation(), 421 SemaRef.Context.DeclarationNames.getCXXConversionFunctionName(ConvTy), 422 T, D->isInline(), D->isExplicit()); 423 Conversion->setInstantiationOfMemberFunction(D); 424 if (InitMethodInstantiation(Conversion, D)) 425 Conversion->setInvalidDecl(); 426 427 bool Redeclaration = false; 428 bool OverloadableAttrRequired = false; 429 NamedDecl *PrevDecl = 0; 430 SemaRef.CheckFunctionDeclaration(Conversion, PrevDecl, Redeclaration, 431 /*FIXME:*/OverloadableAttrRequired); 432 Owner->addDecl(SemaRef.Context, Conversion); 433 return Conversion; 434} 435 436ParmVarDecl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) { 437 QualType OrigT = SemaRef.InstantiateType(D->getOriginalType(), TemplateArgs, 438 D->getLocation(), D->getDeclName()); 439 if (OrigT.isNull()) 440 return 0; 441 442 QualType T = SemaRef.adjustParameterType(OrigT); 443 444 if (D->getDefaultArg()) { 445 // FIXME: Leave a marker for "uninstantiated" default 446 // arguments. They only get instantiated on demand at the call 447 // site. 448 unsigned DiagID = SemaRef.Diags.getCustomDiagID(Diagnostic::Warning, 449 "sorry, dropping default argument during template instantiation"); 450 SemaRef.Diag(D->getDefaultArg()->getSourceRange().getBegin(), DiagID) 451 << D->getDefaultArg()->getSourceRange(); 452 } 453 454 // Allocate the parameter 455 ParmVarDecl *Param = 0; 456 if (T == OrigT) 457 Param = ParmVarDecl::Create(SemaRef.Context, Owner, D->getLocation(), 458 D->getIdentifier(), T, D->getStorageClass(), 459 0); 460 else 461 Param = OriginalParmVarDecl::Create(SemaRef.Context, Owner, 462 D->getLocation(), D->getIdentifier(), 463 T, OrigT, D->getStorageClass(), 0); 464 465 // Note: we don't try to instantiate function parameters until after 466 // we've instantiated the function's type. Therefore, we don't have 467 // to check for 'void' parameter types here. 468 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param); 469 return Param; 470} 471 472Decl * 473TemplateDeclInstantiator::VisitOriginalParmVarDecl(OriginalParmVarDecl *D) { 474 // Since parameter types can decay either before or after 475 // instantiation, we simply treat OriginalParmVarDecls as 476 // ParmVarDecls the same way, and create one or the other depending 477 // on what happens after template instantiation. 478 return VisitParmVarDecl(D); 479} 480 481Decl *Sema::InstantiateDecl(Decl *D, DeclContext *Owner, 482 const TemplateArgumentList &TemplateArgs) { 483 TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs); 484 return Instantiator.Visit(D); 485} 486 487/// \brief Instantiates the type of the given function, including 488/// instantiating all of the function parameters. 489/// 490/// \param D The function that we will be instantiated 491/// 492/// \param Params the instantiated parameter declarations 493 494/// \returns the instantiated function's type if successfull, a NULL 495/// type if there was an error. 496QualType 497TemplateDeclInstantiator::InstantiateFunctionType(FunctionDecl *D, 498 llvm::SmallVectorImpl<ParmVarDecl *> &Params) { 499 bool InvalidDecl = false; 500 501 // Instantiate the function parameters 502 TemplateDeclInstantiator ParamInstantiator(SemaRef, 0, TemplateArgs); 503 llvm::SmallVector<QualType, 16> ParamTys; 504 for (FunctionDecl::param_iterator P = D->param_begin(), 505 PEnd = D->param_end(); 506 P != PEnd; ++P) { 507 if (ParmVarDecl *PInst = ParamInstantiator.VisitParmVarDecl(*P)) { 508 if (PInst->getType()->isVoidType()) { 509 SemaRef.Diag(PInst->getLocation(), diag::err_param_with_void_type); 510 PInst->setInvalidDecl(); 511 } 512 else if (SemaRef.RequireNonAbstractType(PInst->getLocation(), 513 PInst->getType(), 514 diag::err_abstract_type_in_decl, 515 Sema::AbstractParamType)) 516 PInst->setInvalidDecl(); 517 518 Params.push_back(PInst); 519 ParamTys.push_back(PInst->getType()); 520 521 if (PInst->isInvalidDecl()) 522 InvalidDecl = true; 523 } else 524 InvalidDecl = true; 525 } 526 527 // FIXME: Deallocate dead declarations. 528 if (InvalidDecl) 529 return QualType(); 530 531 const FunctionProtoType *Proto = D->getType()->getAsFunctionProtoType(); 532 assert(Proto && "Missing prototype?"); 533 QualType ResultType 534 = SemaRef.InstantiateType(Proto->getResultType(), TemplateArgs, 535 D->getLocation(), D->getDeclName()); 536 if (ResultType.isNull()) 537 return QualType(); 538 539 return SemaRef.BuildFunctionType(ResultType, &ParamTys[0], ParamTys.size(), 540 Proto->isVariadic(), Proto->getTypeQuals(), 541 D->getLocation(), D->getDeclName()); 542} 543 544/// \brief Initializes common fields of an instantiated method 545/// declaration (New) from the corresponding fields of its template 546/// (Tmpl). 547/// 548/// \returns true if there was an error 549bool 550TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New, 551 CXXMethodDecl *Tmpl) { 552 CXXRecordDecl *Record = cast<CXXRecordDecl>(Owner); 553 New->setAccess(Tmpl->getAccess()); 554 if (Tmpl->isVirtualAsWritten()) { 555 New->setVirtualAsWritten(true); 556 Record->setAggregate(false); 557 Record->setPOD(false); 558 Record->setPolymorphic(true); 559 } 560 if (Tmpl->isDeleted()) 561 New->setDeleted(); 562 if (Tmpl->isPure()) { 563 New->setPure(); 564 Record->setAbstract(true); 565 } 566 567 // FIXME: attributes 568 // FIXME: New needs a pointer to Tmpl 569 return false; 570} 571 572/// \brief Instantiate the definition of the given function from its 573/// template. 574/// 575/// \param Function the already-instantiated declaration of a 576/// function. 577void Sema::InstantiateFunctionDefinition(FunctionDecl *Function) { 578 // FIXME: make this work for function template specializations, too. 579 580 if (Function->isInvalidDecl()) 581 return; 582 583 // Find the function body that we'll be substituting. 584 const FunctionDecl *PatternDecl 585 = Function->getInstantiatedFromMemberFunction(); 586 Stmt *Pattern = 0; 587 if (PatternDecl) 588 Pattern = PatternDecl->getBody(Context, PatternDecl); 589 590 if (!Pattern) 591 return; 592 593 // FIXME: add to the instantiation stack. 594 595 ActOnStartOfFunctionDef(0, DeclPtrTy::make(Function)); 596 597 // Introduce a new scope where local variable instantiations will be 598 // recorded. 599 LocalInstantiationScope Scope(*this); 600 601 // Introduce the instantiated function parameters into the local 602 // instantiation scope. 603 for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) 604 Scope.InstantiatedLocal(PatternDecl->getParamDecl(I), 605 Function->getParamDecl(I)); 606 607 // Enter the scope of this instantiation. We don't use 608 // PushDeclContext because we don't have a scope. 609 DeclContext *PreviousContext = CurContext; 610 CurContext = Function; 611 612 // Instantiate the function body. 613 OwningStmtResult Body 614 = InstantiateStmt(Pattern, getTemplateInstantiationArgs(Function)); 615 616 ActOnFinishFunctionBody(DeclPtrTy::make(Function), move(Body), 617 /*IsInstantiation=*/true); 618 619 CurContext = PreviousContext; 620} 621 622/// \brief Instantiate the definition of the given variable from its 623/// template. 624/// 625/// \param Var the already-instantiated declaration of a variable. 626void Sema::InstantiateVariableDefinition(VarDecl *Var) { 627 // FIXME: Implement this! 628} 629