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