lib/Sema/SemaTemplateInstantiateDecl.cpp

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