SemaTemplateInstantiateDecl.cpp revision 06935f32645c8965e398bbd141f9800eacdfd439 
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 "clang/Sema/SemaInternal.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/DependentDiagnostic.h"
18#include "clang/AST/Expr.h"
19#include "clang/AST/ExprCXX.h"
20#include "clang/AST/TypeLoc.h"
21#include "clang/Lex/Preprocessor.h"
22#include "clang/Sema/Lookup.h"
23#include "clang/Sema/PrettyDeclStackTrace.h"
24#include "clang/Sema/Template.h"
25
26using namespace clang;
27
28bool TemplateDeclInstantiator::SubstQualifier(const DeclaratorDecl *OldDecl,
29                                              DeclaratorDecl *NewDecl) {
30  if (!OldDecl->getQualifierLoc())
31    return false;
32
33  NestedNameSpecifierLoc NewQualifierLoc
34    = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
35                                          TemplateArgs);
36
37  if (!NewQualifierLoc)
38    return true;
39
40  NewDecl->setQualifierInfo(NewQualifierLoc);
41  return false;
42}
43
44bool TemplateDeclInstantiator::SubstQualifier(const TagDecl *OldDecl,
45                                              TagDecl *NewDecl) {
46  if (!OldDecl->getQualifierLoc())
47    return false;
48
49  NestedNameSpecifierLoc NewQualifierLoc
50  = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
51                                        TemplateArgs);
52
53  if (!NewQualifierLoc)
54    return true;
55
56  NewDecl->setQualifierInfo(NewQualifierLoc);
57  return false;
58}
59
60// Include attribute instantiation code.
61#include "clang/Sema/AttrTemplateInstantiate.inc"
62
63static void instantiateDependentAlignedAttr(
64    Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
65    const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion) {
66  if (Aligned->isAlignmentExpr()) {
67    // The alignment expression is a constant expression.
68    EnterExpressionEvaluationContext Unevaluated(S, Sema::ConstantEvaluated);
69    ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs);
70    if (!Result.isInvalid())
71      S.AddAlignedAttr(Aligned->getLocation(), New, Result.takeAs<Expr>(),
72                       Aligned->getSpellingListIndex(), IsPackExpansion);
73  } else {
74    TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(),
75                                         TemplateArgs, Aligned->getLocation(),
76                                         DeclarationName());
77    if (Result)
78      S.AddAlignedAttr(Aligned->getLocation(), New, Result,
79                       Aligned->getSpellingListIndex(), IsPackExpansion);
80  }
81}
82
83static void instantiateDependentAlignedAttr(
84    Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
85    const AlignedAttr *Aligned, Decl *New) {
86  if (!Aligned->isPackExpansion()) {
87    instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
88    return;
89  }
90
91  SmallVector<UnexpandedParameterPack, 2> Unexpanded;
92  if (Aligned->isAlignmentExpr())
93    S.collectUnexpandedParameterPacks(Aligned->getAlignmentExpr(),
94                                      Unexpanded);
95  else
96    S.collectUnexpandedParameterPacks(Aligned->getAlignmentType()->getTypeLoc(),
97                                      Unexpanded);
98  assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
99
100  // Determine whether we can expand this attribute pack yet.
101  bool Expand = true, RetainExpansion = false;
102  Optional<unsigned> NumExpansions;
103  // FIXME: Use the actual location of the ellipsis.
104  SourceLocation EllipsisLoc = Aligned->getLocation();
105  if (S.CheckParameterPacksForExpansion(EllipsisLoc, Aligned->getRange(),
106                                        Unexpanded, TemplateArgs, Expand,
107                                        RetainExpansion, NumExpansions))
108    return;
109
110  if (!Expand) {
111    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, -1);
112    instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, true);
113  } else {
114    for (unsigned I = 0; I != *NumExpansions; ++I) {
115      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, I);
116      instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
117    }
118  }
119}
120
121void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
122                            const Decl *Tmpl, Decl *New,
123                            LateInstantiatedAttrVec *LateAttrs,
124                            LocalInstantiationScope *OuterMostScope) {
125  for (AttrVec::const_iterator i = Tmpl->attr_begin(), e = Tmpl->attr_end();
126       i != e; ++i) {
127    const Attr *TmplAttr = *i;
128
129    // FIXME: This should be generalized to more than just the AlignedAttr.
130    const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
131    if (Aligned && Aligned->isAlignmentDependent()) {
132      instantiateDependentAlignedAttr(*this, TemplateArgs, Aligned, New);
133      continue;
134    }
135
136    assert(!TmplAttr->isPackExpansion());
137    if (TmplAttr->isLateParsed() && LateAttrs) {
138      // Late parsed attributes must be instantiated and attached after the
139      // enclosing class has been instantiated.  See Sema::InstantiateClass.
140      LocalInstantiationScope *Saved = 0;
141      if (CurrentInstantiationScope)
142        Saved = CurrentInstantiationScope->cloneScopes(OuterMostScope);
143      LateAttrs->push_back(LateInstantiatedAttribute(TmplAttr, Saved, New));
144    } else {
145      // Allow 'this' within late-parsed attributes.
146      NamedDecl *ND = dyn_cast<NamedDecl>(New);
147      CXXRecordDecl *ThisContext =
148          dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
149      CXXThisScopeRAII ThisScope(*this, ThisContext, /*TypeQuals*/0,
150                                 ND && ND->isCXXInstanceMember());
151
152      Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context,
153                                                         *this, TemplateArgs);
154      if (NewAttr)
155        New->addAttr(NewAttr);
156    }
157  }
158}
159
160Decl *
161TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
162  llvm_unreachable("Translation units cannot be instantiated");
163}
164
165Decl *
166TemplateDeclInstantiator::VisitLabelDecl(LabelDecl *D) {
167  LabelDecl *Inst = LabelDecl::Create(SemaRef.Context, Owner, D->getLocation(),
168                                      D->getIdentifier());
169  Owner->addDecl(Inst);
170  return Inst;
171}
172
173Decl *
174TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) {
175  llvm_unreachable("Namespaces cannot be instantiated");
176}
177
178Decl *
179TemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
180  NamespaceAliasDecl *Inst
181    = NamespaceAliasDecl::Create(SemaRef.Context, Owner,
182                                 D->getNamespaceLoc(),
183                                 D->getAliasLoc(),
184                                 D->getIdentifier(),
185                                 D->getQualifierLoc(),
186                                 D->getTargetNameLoc(),
187                                 D->getNamespace());
188  Owner->addDecl(Inst);
189  return Inst;
190}
191
192Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D,
193                                                           bool IsTypeAlias) {
194  bool Invalid = false;
195  TypeSourceInfo *DI = D->getTypeSourceInfo();
196  if (DI->getType()->isInstantiationDependentType() ||
197      DI->getType()->isVariablyModifiedType()) {
198    DI = SemaRef.SubstType(DI, TemplateArgs,
199                           D->getLocation(), D->getDeclName());
200    if (!DI) {
201      Invalid = true;
202      DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
203    }
204  } else {
205    SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
206  }
207
208  // HACK: g++ has a bug where it gets the value kind of ?: wrong.
209  // libstdc++ relies upon this bug in its implementation of common_type.
210  // If we happen to be processing that implementation, fake up the g++ ?:
211  // semantics. See LWG issue 2141 for more information on the bug.
212  const DecltypeType *DT = DI->getType()->getAs<DecltypeType>();
213  CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
214  if (DT && RD && isa<ConditionalOperator>(DT->getUnderlyingExpr()) &&
215      DT->isReferenceType() &&
216      RD->getEnclosingNamespaceContext() == SemaRef.getStdNamespace() &&
217      RD->getIdentifier() && RD->getIdentifier()->isStr("common_type") &&
218      D->getIdentifier() && D->getIdentifier()->isStr("type") &&
219      SemaRef.getSourceManager().isInSystemHeader(D->getLocStart()))
220    // Fold it to the (non-reference) type which g++ would have produced.
221    DI = SemaRef.Context.getTrivialTypeSourceInfo(
222      DI->getType().getNonReferenceType());
223
224  // Create the new typedef
225  TypedefNameDecl *Typedef;
226  if (IsTypeAlias)
227    Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
228                                    D->getLocation(), D->getIdentifier(), DI);
229  else
230    Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
231                                  D->getLocation(), D->getIdentifier(), DI);
232  if (Invalid)
233    Typedef->setInvalidDecl();
234
235  // If the old typedef was the name for linkage purposes of an anonymous
236  // tag decl, re-establish that relationship for the new typedef.
237  if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) {
238    TagDecl *oldTag = oldTagType->getDecl();
239    if (oldTag->getTypedefNameForAnonDecl() == D && !Invalid) {
240      TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl();
241      assert(!newTag->hasNameForLinkage());
242      newTag->setTypedefNameForAnonDecl(Typedef);
243    }
244  }
245
246  if (TypedefNameDecl *Prev = D->getPreviousDecl()) {
247    NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev,
248                                                       TemplateArgs);
249    if (!InstPrev)
250      return 0;
251
252    TypedefNameDecl *InstPrevTypedef = cast<TypedefNameDecl>(InstPrev);
253
254    // If the typedef types are not identical, reject them.
255    SemaRef.isIncompatibleTypedef(InstPrevTypedef, Typedef);
256
257    Typedef->setPreviousDeclaration(InstPrevTypedef);
258  }
259
260  SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef);
261
262  Typedef->setAccess(D->getAccess());
263
264  return Typedef;
265}
266
267Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) {
268  Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/false);
269  Owner->addDecl(Typedef);
270  return Typedef;
271}
272
273Decl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) {
274  Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/true);
275  Owner->addDecl(Typedef);
276  return Typedef;
277}
278
279Decl *
280TemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
281  // Create a local instantiation scope for this type alias template, which
282  // will contain the instantiations of the template parameters.
283  LocalInstantiationScope Scope(SemaRef);
284
285  TemplateParameterList *TempParams = D->getTemplateParameters();
286  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
287  if (!InstParams)
288    return 0;
289
290  TypeAliasDecl *Pattern = D->getTemplatedDecl();
291
292  TypeAliasTemplateDecl *PrevAliasTemplate = 0;
293  if (Pattern->getPreviousDecl()) {
294    DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
295    if (!Found.empty()) {
296      PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Found.front());
297    }
298  }
299
300  TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>(
301    InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true));
302  if (!AliasInst)
303    return 0;
304
305  TypeAliasTemplateDecl *Inst
306    = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(),
307                                    D->getDeclName(), InstParams, AliasInst);
308  if (PrevAliasTemplate)
309    Inst->setPreviousDeclaration(PrevAliasTemplate);
310
311  Inst->setAccess(D->getAccess());
312
313  if (!PrevAliasTemplate)
314    Inst->setInstantiatedFromMemberTemplate(D);
315
316  Owner->addDecl(Inst);
317
318  return Inst;
319}
320
321// FIXME: Revise for static member templates.
322Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) {
323  return VisitVarDecl(D, /*ForVarTemplate=*/false);
324}
325
326Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D, bool ForVarTemplate) {
327
328  // If this is the variable for an anonymous struct or union,
329  // instantiate the anonymous struct/union type first.
330  if (const RecordType *RecordTy = D->getType()->getAs<RecordType>())
331    if (RecordTy->getDecl()->isAnonymousStructOrUnion())
332      if (!VisitCXXRecordDecl(cast<CXXRecordDecl>(RecordTy->getDecl())))
333        return 0;
334
335  // Do substitution on the type of the declaration
336  TypeSourceInfo *DI = SemaRef.SubstType(D->getTypeSourceInfo(),
337                                         TemplateArgs,
338                                         D->getTypeSpecStartLoc(),
339                                         D->getDeclName());
340  if (!DI)
341    return 0;
342
343  if (DI->getType()->isFunctionType()) {
344    SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
345      << D->isStaticDataMember() << DI->getType();
346    return 0;
347  }
348
349  // Build the instantiated declaration.
350  VarDecl *Var = VarDecl::Create(SemaRef.Context, Owner, D->getInnerLocStart(),
351                                 D->getLocation(), D->getIdentifier(),
352                                 DI->getType(), DI, D->getStorageClass());
353
354  // In ARC, infer 'retaining' for variables of retainable type.
355  if (SemaRef.getLangOpts().ObjCAutoRefCount &&
356      SemaRef.inferObjCARCLifetime(Var))
357    Var->setInvalidDecl();
358
359  // Substitute the nested name specifier, if any.
360  if (SubstQualifier(D, Var))
361    return 0;
362
363  SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs,
364                                     StartingScope, ForVarTemplate);
365  return Var;
366}
367
368Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) {
369  AccessSpecDecl* AD
370    = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner,
371                             D->getAccessSpecifierLoc(), D->getColonLoc());
372  Owner->addHiddenDecl(AD);
373  return AD;
374}
375
376Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
377  bool Invalid = false;
378  TypeSourceInfo *DI = D->getTypeSourceInfo();
379  if (DI->getType()->isInstantiationDependentType() ||
380      DI->getType()->isVariablyModifiedType())  {
381    DI = SemaRef.SubstType(DI, TemplateArgs,
382                           D->getLocation(), D->getDeclName());
383    if (!DI) {
384      DI = D->getTypeSourceInfo();
385      Invalid = true;
386    } else if (DI->getType()->isFunctionType()) {
387      // C++ [temp.arg.type]p3:
388      //   If a declaration acquires a function type through a type
389      //   dependent on a template-parameter and this causes a
390      //   declaration that does not use the syntactic form of a
391      //   function declarator to have function type, the program is
392      //   ill-formed.
393      SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
394        << DI->getType();
395      Invalid = true;
396    }
397  } else {
398    SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
399  }
400
401  Expr *BitWidth = D->getBitWidth();
402  if (Invalid)
403    BitWidth = 0;
404  else if (BitWidth) {
405    // The bit-width expression is a constant expression.
406    EnterExpressionEvaluationContext Unevaluated(SemaRef,
407                                                 Sema::ConstantEvaluated);
408
409    ExprResult InstantiatedBitWidth
410      = SemaRef.SubstExpr(BitWidth, TemplateArgs);
411    if (InstantiatedBitWidth.isInvalid()) {
412      Invalid = true;
413      BitWidth = 0;
414    } else
415      BitWidth = InstantiatedBitWidth.takeAs<Expr>();
416  }
417
418  FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(),
419                                            DI->getType(), DI,
420                                            cast<RecordDecl>(Owner),
421                                            D->getLocation(),
422                                            D->isMutable(),
423                                            BitWidth,
424                                            D->getInClassInitStyle(),
425                                            D->getInnerLocStart(),
426                                            D->getAccess(),
427                                            0);
428  if (!Field) {
429    cast<Decl>(Owner)->setInvalidDecl();
430    return 0;
431  }
432
433  SemaRef.InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope);
434
435  if (Field->hasAttrs())
436    SemaRef.CheckAlignasUnderalignment(Field);
437
438  if (Invalid)
439    Field->setInvalidDecl();
440
441  if (!Field->getDeclName()) {
442    // Keep track of where this decl came from.
443    SemaRef.Context.setInstantiatedFromUnnamedFieldDecl(Field, D);
444  }
445  if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) {
446    if (Parent->isAnonymousStructOrUnion() &&
447        Parent->getRedeclContext()->isFunctionOrMethod())
448      SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field);
449  }
450
451  Field->setImplicit(D->isImplicit());
452  Field->setAccess(D->getAccess());
453  Owner->addDecl(Field);
454
455  return Field;
456}
457
458Decl *TemplateDeclInstantiator::VisitMSPropertyDecl(MSPropertyDecl *D) {
459  bool Invalid = false;
460  TypeSourceInfo *DI = D->getTypeSourceInfo();
461
462  if (DI->getType()->isVariablyModifiedType()) {
463    SemaRef.Diag(D->getLocation(), diag::err_property_is_variably_modified)
464    << D->getName();
465    Invalid = true;
466  } else if (DI->getType()->isInstantiationDependentType())  {
467    DI = SemaRef.SubstType(DI, TemplateArgs,
468                           D->getLocation(), D->getDeclName());
469    if (!DI) {
470      DI = D->getTypeSourceInfo();
471      Invalid = true;
472    } else if (DI->getType()->isFunctionType()) {
473      // C++ [temp.arg.type]p3:
474      //   If a declaration acquires a function type through a type
475      //   dependent on a template-parameter and this causes a
476      //   declaration that does not use the syntactic form of a
477      //   function declarator to have function type, the program is
478      //   ill-formed.
479      SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
480      << DI->getType();
481      Invalid = true;
482    }
483  } else {
484    SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
485  }
486
487  MSPropertyDecl *Property = new (SemaRef.Context)
488      MSPropertyDecl(Owner, D->getLocation(),
489                     D->getDeclName(), DI->getType(), DI,
490                     D->getLocStart(),
491                     D->getGetterId(), D->getSetterId());
492
493  SemaRef.InstantiateAttrs(TemplateArgs, D, Property, LateAttrs,
494                           StartingScope);
495
496  if (Invalid)
497    Property->setInvalidDecl();
498
499  Property->setAccess(D->getAccess());
500  Owner->addDecl(Property);
501
502  return Property;
503}
504
505Decl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
506  NamedDecl **NamedChain =
507    new (SemaRef.Context)NamedDecl*[D->getChainingSize()];
508
509  int i = 0;
510  for (IndirectFieldDecl::chain_iterator PI =
511       D->chain_begin(), PE = D->chain_end();
512       PI != PE; ++PI) {
513    NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), *PI,
514                                              TemplateArgs);
515    if (!Next)
516      return 0;
517
518    NamedChain[i++] = Next;
519  }
520
521  QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
522  IndirectFieldDecl* IndirectField
523    = IndirectFieldDecl::Create(SemaRef.Context, Owner, D->getLocation(),
524                                D->getIdentifier(), T,
525                                NamedChain, D->getChainingSize());
526
527
528  IndirectField->setImplicit(D->isImplicit());
529  IndirectField->setAccess(D->getAccess());
530  Owner->addDecl(IndirectField);
531  return IndirectField;
532}
533
534Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) {
535  // Handle friend type expressions by simply substituting template
536  // parameters into the pattern type and checking the result.
537  if (TypeSourceInfo *Ty = D->getFriendType()) {
538    TypeSourceInfo *InstTy;
539    // If this is an unsupported friend, don't bother substituting template
540    // arguments into it. The actual type referred to won't be used by any
541    // parts of Clang, and may not be valid for instantiating. Just use the
542    // same info for the instantiated friend.
543    if (D->isUnsupportedFriend()) {
544      InstTy = Ty;
545    } else {
546      InstTy = SemaRef.SubstType(Ty, TemplateArgs,
547                                 D->getLocation(), DeclarationName());
548    }
549    if (!InstTy)
550      return 0;
551
552    FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getLocStart(),
553                                                 D->getFriendLoc(), InstTy);
554    if (!FD)
555      return 0;
556
557    FD->setAccess(AS_public);
558    FD->setUnsupportedFriend(D->isUnsupportedFriend());
559    Owner->addDecl(FD);
560    return FD;
561  }
562
563  NamedDecl *ND = D->getFriendDecl();
564  assert(ND && "friend decl must be a decl or a type!");
565
566  // All of the Visit implementations for the various potential friend
567  // declarations have to be carefully written to work for friend
568  // objects, with the most important detail being that the target
569  // decl should almost certainly not be placed in Owner.
570  Decl *NewND = Visit(ND);
571  if (!NewND) return 0;
572
573  FriendDecl *FD =
574    FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(),
575                       cast<NamedDecl>(NewND), D->getFriendLoc());
576  FD->setAccess(AS_public);
577  FD->setUnsupportedFriend(D->isUnsupportedFriend());
578  Owner->addDecl(FD);
579  return FD;
580}
581
582Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) {
583  Expr *AssertExpr = D->getAssertExpr();
584
585  // The expression in a static assertion is a constant expression.
586  EnterExpressionEvaluationContext Unevaluated(SemaRef,
587                                               Sema::ConstantEvaluated);
588
589  ExprResult InstantiatedAssertExpr
590    = SemaRef.SubstExpr(AssertExpr, TemplateArgs);
591  if (InstantiatedAssertExpr.isInvalid())
592    return 0;
593
594  return SemaRef.BuildStaticAssertDeclaration(D->getLocation(),
595                                              InstantiatedAssertExpr.get(),
596                                              D->getMessage(),
597                                              D->getRParenLoc(),
598                                              D->isFailed());
599}
600
601Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) {
602  EnumDecl *PrevDecl = 0;
603  if (D->getPreviousDecl()) {
604    NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
605                                                   D->getPreviousDecl(),
606                                                   TemplateArgs);
607    if (!Prev) return 0;
608    PrevDecl = cast<EnumDecl>(Prev);
609  }
610
611  EnumDecl *Enum = EnumDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
612                                    D->getLocation(), D->getIdentifier(),
613                                    PrevDecl, D->isScoped(),
614                                    D->isScopedUsingClassTag(), D->isFixed());
615  if (D->isFixed()) {
616    if (TypeSourceInfo *TI = D->getIntegerTypeSourceInfo()) {
617      // If we have type source information for the underlying type, it means it
618      // has been explicitly set by the user. Perform substitution on it before
619      // moving on.
620      SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
621      TypeSourceInfo *NewTI = SemaRef.SubstType(TI, TemplateArgs, UnderlyingLoc,
622                                                DeclarationName());
623      if (!NewTI || SemaRef.CheckEnumUnderlyingType(NewTI))
624        Enum->setIntegerType(SemaRef.Context.IntTy);
625      else
626        Enum->setIntegerTypeSourceInfo(NewTI);
627    } else {
628      assert(!D->getIntegerType()->isDependentType()
629             && "Dependent type without type source info");
630      Enum->setIntegerType(D->getIntegerType());
631    }
632  }
633
634  SemaRef.InstantiateAttrs(TemplateArgs, D, Enum);
635
636  Enum->setInstantiationOfMemberEnum(D, TSK_ImplicitInstantiation);
637  Enum->setAccess(D->getAccess());
638  if (SubstQualifier(D, Enum)) return 0;
639  Owner->addDecl(Enum);
640
641  EnumDecl *Def = D->getDefinition();
642  if (Def && Def != D) {
643    // If this is an out-of-line definition of an enum member template, check
644    // that the underlying types match in the instantiation of both
645    // declarations.
646    if (TypeSourceInfo *TI = Def->getIntegerTypeSourceInfo()) {
647      SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
648      QualType DefnUnderlying =
649        SemaRef.SubstType(TI->getType(), TemplateArgs,
650                          UnderlyingLoc, DeclarationName());
651      SemaRef.CheckEnumRedeclaration(Def->getLocation(), Def->isScoped(),
652                                     DefnUnderlying, Enum);
653    }
654  }
655
656  if (D->getDeclContext()->isFunctionOrMethod())
657    SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Enum);
658
659  // C++11 [temp.inst]p1: The implicit instantiation of a class template
660  // specialization causes the implicit instantiation of the declarations, but
661  // not the definitions of scoped member enumerations.
662  // FIXME: There appears to be no wording for what happens for an enum defined
663  // within a block scope, but we treat that much like a member template. Only
664  // instantiate the definition when visiting the definition in that case, since
665  // we will visit all redeclarations.
666  if (!Enum->isScoped() && Def &&
667      (!D->getDeclContext()->isFunctionOrMethod() || D->isCompleteDefinition()))
668    InstantiateEnumDefinition(Enum, Def);
669
670  return Enum;
671}
672
673void TemplateDeclInstantiator::InstantiateEnumDefinition(
674    EnumDecl *Enum, EnumDecl *Pattern) {
675  Enum->startDefinition();
676
677  // Update the location to refer to the definition.
678  Enum->setLocation(Pattern->getLocation());
679
680  SmallVector<Decl*, 4> Enumerators;
681
682  EnumConstantDecl *LastEnumConst = 0;
683  for (EnumDecl::enumerator_iterator EC = Pattern->enumerator_begin(),
684         ECEnd = Pattern->enumerator_end();
685       EC != ECEnd; ++EC) {
686    // The specified value for the enumerator.
687    ExprResult Value = SemaRef.Owned((Expr *)0);
688    if (Expr *UninstValue = EC->getInitExpr()) {
689      // The enumerator's value expression is a constant expression.
690      EnterExpressionEvaluationContext Unevaluated(SemaRef,
691                                                   Sema::ConstantEvaluated);
692
693      Value = SemaRef.SubstExpr(UninstValue, TemplateArgs);
694    }
695
696    // Drop the initial value and continue.
697    bool isInvalid = false;
698    if (Value.isInvalid()) {
699      Value = SemaRef.Owned((Expr *)0);
700      isInvalid = true;
701    }
702
703    EnumConstantDecl *EnumConst
704      = SemaRef.CheckEnumConstant(Enum, LastEnumConst,
705                                  EC->getLocation(), EC->getIdentifier(),
706                                  Value.get());
707
708    if (isInvalid) {
709      if (EnumConst)
710        EnumConst->setInvalidDecl();
711      Enum->setInvalidDecl();
712    }
713
714    if (EnumConst) {
715      SemaRef.InstantiateAttrs(TemplateArgs, *EC, EnumConst);
716
717      EnumConst->setAccess(Enum->getAccess());
718      Enum->addDecl(EnumConst);
719      Enumerators.push_back(EnumConst);
720      LastEnumConst = EnumConst;
721
722      if (Pattern->getDeclContext()->isFunctionOrMethod() &&
723          !Enum->isScoped()) {
724        // If the enumeration is within a function or method, record the enum
725        // constant as a local.
726        SemaRef.CurrentInstantiationScope->InstantiatedLocal(*EC, EnumConst);
727      }
728    }
729  }
730
731  // FIXME: Fixup LBraceLoc
732  SemaRef.ActOnEnumBody(Enum->getLocation(), SourceLocation(),
733                        Enum->getRBraceLoc(), Enum,
734                        Enumerators,
735                        0, 0);
736}
737
738Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) {
739  llvm_unreachable("EnumConstantDecls can only occur within EnumDecls.");
740}
741
742Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
743  bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
744
745  // Create a local instantiation scope for this class template, which
746  // will contain the instantiations of the template parameters.
747  LocalInstantiationScope Scope(SemaRef);
748  TemplateParameterList *TempParams = D->getTemplateParameters();
749  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
750  if (!InstParams)
751    return NULL;
752
753  CXXRecordDecl *Pattern = D->getTemplatedDecl();
754
755  // Instantiate the qualifier.  We have to do this first in case
756  // we're a friend declaration, because if we are then we need to put
757  // the new declaration in the appropriate context.
758  NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
759  if (QualifierLoc) {
760    QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
761                                                       TemplateArgs);
762    if (!QualifierLoc)
763      return 0;
764  }
765
766  CXXRecordDecl *PrevDecl = 0;
767  ClassTemplateDecl *PrevClassTemplate = 0;
768
769  if (!isFriend && Pattern->getPreviousDecl()) {
770    DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
771    if (!Found.empty()) {
772      PrevClassTemplate = dyn_cast<ClassTemplateDecl>(Found.front());
773      if (PrevClassTemplate)
774        PrevDecl = PrevClassTemplate->getTemplatedDecl();
775    }
776  }
777
778  // If this isn't a friend, then it's a member template, in which
779  // case we just want to build the instantiation in the
780  // specialization.  If it is a friend, we want to build it in
781  // the appropriate context.
782  DeclContext *DC = Owner;
783  if (isFriend) {
784    if (QualifierLoc) {
785      CXXScopeSpec SS;
786      SS.Adopt(QualifierLoc);
787      DC = SemaRef.computeDeclContext(SS);
788      if (!DC) return 0;
789    } else {
790      DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(),
791                                           Pattern->getDeclContext(),
792                                           TemplateArgs);
793    }
794
795    // Look for a previous declaration of the template in the owning
796    // context.
797    LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(),
798                   Sema::LookupOrdinaryName, Sema::ForRedeclaration);
799    SemaRef.LookupQualifiedName(R, DC);
800
801    if (R.isSingleResult()) {
802      PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>();
803      if (PrevClassTemplate)
804        PrevDecl = PrevClassTemplate->getTemplatedDecl();
805    }
806
807    if (!PrevClassTemplate && QualifierLoc) {
808      SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope)
809        << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC
810        << QualifierLoc.getSourceRange();
811      return 0;
812    }
813
814    bool AdoptedPreviousTemplateParams = false;
815    if (PrevClassTemplate) {
816      bool Complain = true;
817
818      // HACK: libstdc++ 4.2.1 contains an ill-formed friend class
819      // template for struct std::tr1::__detail::_Map_base, where the
820      // template parameters of the friend declaration don't match the
821      // template parameters of the original declaration. In this one
822      // case, we don't complain about the ill-formed friend
823      // declaration.
824      if (isFriend && Pattern->getIdentifier() &&
825          Pattern->getIdentifier()->isStr("_Map_base") &&
826          DC->isNamespace() &&
827          cast<NamespaceDecl>(DC)->getIdentifier() &&
828          cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__detail")) {
829        DeclContext *DCParent = DC->getParent();
830        if (DCParent->isNamespace() &&
831            cast<NamespaceDecl>(DCParent)->getIdentifier() &&
832            cast<NamespaceDecl>(DCParent)->getIdentifier()->isStr("tr1")) {
833          DeclContext *DCParent2 = DCParent->getParent();
834          if (DCParent2->isNamespace() &&
835              cast<NamespaceDecl>(DCParent2)->getIdentifier() &&
836              cast<NamespaceDecl>(DCParent2)->getIdentifier()->isStr("std") &&
837              DCParent2->getParent()->isTranslationUnit())
838            Complain = false;
839        }
840      }
841
842      TemplateParameterList *PrevParams
843        = PrevClassTemplate->getTemplateParameters();
844
845      // Make sure the parameter lists match.
846      if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams,
847                                                  Complain,
848                                                  Sema::TPL_TemplateMatch)) {
849        if (Complain)
850          return 0;
851
852        AdoptedPreviousTemplateParams = true;
853        InstParams = PrevParams;
854      }
855
856      // Do some additional validation, then merge default arguments
857      // from the existing declarations.
858      if (!AdoptedPreviousTemplateParams &&
859          SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
860                                             Sema::TPC_ClassTemplate))
861        return 0;
862    }
863  }
864
865  CXXRecordDecl *RecordInst
866    = CXXRecordDecl::Create(SemaRef.Context, Pattern->getTagKind(), DC,
867                            Pattern->getLocStart(), Pattern->getLocation(),
868                            Pattern->getIdentifier(), PrevDecl,
869                            /*DelayTypeCreation=*/true);
870
871  if (QualifierLoc)
872    RecordInst->setQualifierInfo(QualifierLoc);
873
874  ClassTemplateDecl *Inst
875    = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
876                                D->getIdentifier(), InstParams, RecordInst,
877                                PrevClassTemplate);
878  RecordInst->setDescribedClassTemplate(Inst);
879
880  if (isFriend) {
881    if (PrevClassTemplate)
882      Inst->setAccess(PrevClassTemplate->getAccess());
883    else
884      Inst->setAccess(D->getAccess());
885
886    Inst->setObjectOfFriendDecl();
887    // TODO: do we want to track the instantiation progeny of this
888    // friend target decl?
889  } else {
890    Inst->setAccess(D->getAccess());
891    if (!PrevClassTemplate)
892      Inst->setInstantiatedFromMemberTemplate(D);
893  }
894
895  // Trigger creation of the type for the instantiation.
896  SemaRef.Context.getInjectedClassNameType(RecordInst,
897                                    Inst->getInjectedClassNameSpecialization());
898
899  // Finish handling of friends.
900  if (isFriend) {
901    DC->makeDeclVisibleInContext(Inst);
902    Inst->setLexicalDeclContext(Owner);
903    RecordInst->setLexicalDeclContext(Owner);
904    return Inst;
905  }
906
907  if (D->isOutOfLine()) {
908    Inst->setLexicalDeclContext(D->getLexicalDeclContext());
909    RecordInst->setLexicalDeclContext(D->getLexicalDeclContext());
910  }
911
912  Owner->addDecl(Inst);
913
914  if (!PrevClassTemplate) {
915    // Queue up any out-of-line partial specializations of this member
916    // class template; the client will force their instantiation once
917    // the enclosing class has been instantiated.
918    SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
919    D->getPartialSpecializations(PartialSpecs);
920    for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
921      if (PartialSpecs[I]->isOutOfLine())
922        OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
923  }
924
925  return Inst;
926}
927
928Decl *
929TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
930                                   ClassTemplatePartialSpecializationDecl *D) {
931  ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
932
933  // Lookup the already-instantiated declaration in the instantiation
934  // of the class template and return that.
935  DeclContext::lookup_result Found
936    = Owner->lookup(ClassTemplate->getDeclName());
937  if (Found.empty())
938    return 0;
939
940  ClassTemplateDecl *InstClassTemplate
941    = dyn_cast<ClassTemplateDecl>(Found.front());
942  if (!InstClassTemplate)
943    return 0;
944
945  if (ClassTemplatePartialSpecializationDecl *Result
946        = InstClassTemplate->findPartialSpecInstantiatedFromMember(D))
947    return Result;
948
949  return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D);
950}
951
952Decl *TemplateDeclInstantiator::VisitVarTemplateDecl(VarTemplateDecl *D) {
953  assert(D->getTemplatedDecl()->isStaticDataMember() &&
954         "Only static data member templates are allowed.");
955  // FIXME: Also only when instantiating a class?
956
957  // Create a local instantiation scope for this variable template, which
958  // will contain the instantiations of the template parameters.
959  LocalInstantiationScope Scope(SemaRef);
960  TemplateParameterList *TempParams = D->getTemplateParameters();
961  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
962  if (!InstParams)
963    return NULL;
964
965  VarDecl *Pattern = D->getTemplatedDecl();
966  VarTemplateDecl *PrevVarTemplate = 0;
967
968  if (Pattern->getPreviousDecl()) {
969    DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
970    if (!Found.empty())
971      PrevVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
972  }
973
974  // FIXME: This, and ForVarTemplate, is a hack that is probably unnecessary.
975  // We should use a simplified version of VisitVarDecl.
976  VarDecl *VarInst = cast_or_null<VarDecl>(VisitVarDecl(Pattern, /*ForVarTemplate=*/true));
977
978  DeclContext *DC = Owner;
979
980  /* FIXME: This should be handled in VisitVarDecl, as used to produce
981     VarInst above.
982  // Instantiate the qualifier.
983  NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
984  if (QualifierLoc) {
985    QualifierLoc =
986        SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs);
987    if (!QualifierLoc)
988      return 0;
989  }
990
991  if (QualifierLoc)
992    VarInst->setQualifierInfo(QualifierLoc);
993  */
994
995  VarTemplateDecl *Inst = VarTemplateDecl::Create(
996      SemaRef.Context, DC, D->getLocation(), D->getIdentifier(), InstParams,
997      VarInst, PrevVarTemplate);
998  VarInst->setDescribedVarTemplate(Inst);
999
1000  Inst->setAccess(D->getAccess());
1001  if (!PrevVarTemplate)
1002    Inst->setInstantiatedFromMemberTemplate(D);
1003
1004  if (D->isOutOfLine()) {
1005    Inst->setLexicalDeclContext(D->getLexicalDeclContext());
1006    VarInst->setLexicalDeclContext(D->getLexicalDeclContext());
1007  }
1008
1009  Owner->addDecl(Inst);
1010
1011  if (!PrevVarTemplate) {
1012    // Queue up any out-of-line partial specializations of this member
1013    // variable template; the client will force their instantiation once
1014    // the enclosing class has been instantiated.
1015    SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
1016    D->getPartialSpecializations(PartialSpecs);
1017    for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1018      if (PartialSpecs[I]->isOutOfLine())
1019        OutOfLineVarPartialSpecs.push_back(
1020            std::make_pair(Inst, PartialSpecs[I]));
1021  }
1022
1023  return Inst;
1024}
1025
1026Decl *TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl(
1027    VarTemplatePartialSpecializationDecl *D) {
1028  assert(D->isStaticDataMember() &&
1029         "Only static data member templates are allowed.");
1030  // FIXME: Also only when instantiating a class?
1031
1032  VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
1033
1034  // Lookup the already-instantiated declaration and return that.
1035  DeclContext::lookup_result Found = Owner->lookup(VarTemplate->getDeclName());
1036  assert(!Found.empty() && "Instantiation found nothing?");
1037
1038  VarTemplateDecl *InstVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
1039  assert(InstVarTemplate && "Instantiation did not find a variable template?");
1040
1041  if (VarTemplatePartialSpecializationDecl *Result =
1042          InstVarTemplate->findPartialSpecInstantiatedFromMember(D))
1043    return Result;
1044
1045  return InstantiateVarTemplatePartialSpecialization(InstVarTemplate, D);
1046}
1047
1048Decl *
1049TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1050  // Create a local instantiation scope for this function template, which
1051  // will contain the instantiations of the template parameters and then get
1052  // merged with the local instantiation scope for the function template
1053  // itself.
1054  LocalInstantiationScope Scope(SemaRef);
1055
1056  TemplateParameterList *TempParams = D->getTemplateParameters();
1057  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1058  if (!InstParams)
1059    return NULL;
1060
1061  FunctionDecl *Instantiated = 0;
1062  if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl()))
1063    Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod,
1064                                                                 InstParams));
1065  else
1066    Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl(
1067                                                          D->getTemplatedDecl(),
1068                                                                InstParams));
1069
1070  if (!Instantiated)
1071    return 0;
1072
1073  // Link the instantiated function template declaration to the function
1074  // template from which it was instantiated.
1075  FunctionTemplateDecl *InstTemplate
1076    = Instantiated->getDescribedFunctionTemplate();
1077  InstTemplate->setAccess(D->getAccess());
1078  assert(InstTemplate &&
1079         "VisitFunctionDecl/CXXMethodDecl didn't create a template!");
1080
1081  bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None);
1082
1083  // Link the instantiation back to the pattern *unless* this is a
1084  // non-definition friend declaration.
1085  if (!InstTemplate->getInstantiatedFromMemberTemplate() &&
1086      !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition()))
1087    InstTemplate->setInstantiatedFromMemberTemplate(D);
1088
1089  // Make declarations visible in the appropriate context.
1090  if (!isFriend) {
1091    Owner->addDecl(InstTemplate);
1092  } else if (InstTemplate->getDeclContext()->isRecord() &&
1093             !D->getPreviousDecl()) {
1094    SemaRef.CheckFriendAccess(InstTemplate);
1095  }
1096
1097  return InstTemplate;
1098}
1099
1100Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) {
1101  CXXRecordDecl *PrevDecl = 0;
1102  if (D->isInjectedClassName())
1103    PrevDecl = cast<CXXRecordDecl>(Owner);
1104  else if (D->getPreviousDecl()) {
1105    NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
1106                                                   D->getPreviousDecl(),
1107                                                   TemplateArgs);
1108    if (!Prev) return 0;
1109    PrevDecl = cast<CXXRecordDecl>(Prev);
1110  }
1111
1112  CXXRecordDecl *Record
1113    = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner,
1114                            D->getLocStart(), D->getLocation(),
1115                            D->getIdentifier(), PrevDecl);
1116
1117  // Substitute the nested name specifier, if any.
1118  if (SubstQualifier(D, Record))
1119    return 0;
1120
1121  Record->setImplicit(D->isImplicit());
1122  // FIXME: Check against AS_none is an ugly hack to work around the issue that
1123  // the tag decls introduced by friend class declarations don't have an access
1124  // specifier. Remove once this area of the code gets sorted out.
1125  if (D->getAccess() != AS_none)
1126    Record->setAccess(D->getAccess());
1127  if (!D->isInjectedClassName())
1128    Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
1129
1130  // If the original function was part of a friend declaration,
1131  // inherit its namespace state.
1132  if (D->getFriendObjectKind())
1133    Record->setObjectOfFriendDecl();
1134
1135  // Make sure that anonymous structs and unions are recorded.
1136  if (D->isAnonymousStructOrUnion()) {
1137    Record->setAnonymousStructOrUnion(true);
1138    if (Record->getDeclContext()->getRedeclContext()->isFunctionOrMethod())
1139      SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record);
1140  }
1141
1142  Owner->addDecl(Record);
1143  return Record;
1144}
1145
1146/// \brief Adjust the given function type for an instantiation of the
1147/// given declaration, to cope with modifications to the function's type that
1148/// aren't reflected in the type-source information.
1149///
1150/// \param D The declaration we're instantiating.
1151/// \param TInfo The already-instantiated type.
1152static QualType adjustFunctionTypeForInstantiation(ASTContext &Context,
1153                                                   FunctionDecl *D,
1154                                                   TypeSourceInfo *TInfo) {
1155  const FunctionProtoType *OrigFunc
1156    = D->getType()->castAs<FunctionProtoType>();
1157  const FunctionProtoType *NewFunc
1158    = TInfo->getType()->castAs<FunctionProtoType>();
1159  if (OrigFunc->getExtInfo() == NewFunc->getExtInfo())
1160    return TInfo->getType();
1161
1162  FunctionProtoType::ExtProtoInfo NewEPI = NewFunc->getExtProtoInfo();
1163  NewEPI.ExtInfo = OrigFunc->getExtInfo();
1164  return Context.getFunctionType(NewFunc->getResultType(),
1165                                 NewFunc->getArgTypes(), NewEPI);
1166}
1167
1168/// Normal class members are of more specific types and therefore
1169/// don't make it here.  This function serves two purposes:
1170///   1) instantiating function templates
1171///   2) substituting friend declarations
1172/// FIXME: preserve function definitions in case #2
1173Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D,
1174                                       TemplateParameterList *TemplateParams) {
1175  // Check whether there is already a function template specialization for
1176  // this declaration.
1177  FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1178  if (FunctionTemplate && !TemplateParams) {
1179    ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1180
1181    void *InsertPos = 0;
1182    FunctionDecl *SpecFunc
1183      = FunctionTemplate->findSpecialization(Innermost.begin(), Innermost.size(),
1184                                             InsertPos);
1185
1186    // If we already have a function template specialization, return it.
1187    if (SpecFunc)
1188      return SpecFunc;
1189  }
1190
1191  bool isFriend;
1192  if (FunctionTemplate)
1193    isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1194  else
1195    isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1196
1197  bool MergeWithParentScope = (TemplateParams != 0) ||
1198    Owner->isFunctionOrMethod() ||
1199    !(isa<Decl>(Owner) &&
1200      cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1201  LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1202
1203  SmallVector<ParmVarDecl *, 4> Params;
1204  TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1205  if (!TInfo)
1206    return 0;
1207  QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
1208
1209  NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1210  if (QualifierLoc) {
1211    QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1212                                                       TemplateArgs);
1213    if (!QualifierLoc)
1214      return 0;
1215  }
1216
1217  // If we're instantiating a local function declaration, put the result
1218  // in the owner;  otherwise we need to find the instantiated context.
1219  DeclContext *DC;
1220  if (D->getDeclContext()->isFunctionOrMethod())
1221    DC = Owner;
1222  else if (isFriend && QualifierLoc) {
1223    CXXScopeSpec SS;
1224    SS.Adopt(QualifierLoc);
1225    DC = SemaRef.computeDeclContext(SS);
1226    if (!DC) return 0;
1227  } else {
1228    DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
1229                                         TemplateArgs);
1230  }
1231
1232  FunctionDecl *Function =
1233      FunctionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
1234                           D->getNameInfo(), T, TInfo,
1235                           D->getCanonicalDecl()->getStorageClass(),
1236                           D->isInlineSpecified(), D->hasWrittenPrototype(),
1237                           D->isConstexpr());
1238  Function->setRangeEnd(D->getSourceRange().getEnd());
1239
1240  if (D->isInlined())
1241    Function->setImplicitlyInline();
1242
1243  if (QualifierLoc)
1244    Function->setQualifierInfo(QualifierLoc);
1245
1246  DeclContext *LexicalDC = Owner;
1247  if (!isFriend && D->isOutOfLine()) {
1248    assert(D->getDeclContext()->isFileContext());
1249    LexicalDC = D->getDeclContext();
1250  }
1251
1252  Function->setLexicalDeclContext(LexicalDC);
1253
1254  // Attach the parameters
1255  for (unsigned P = 0; P < Params.size(); ++P)
1256    if (Params[P])
1257      Params[P]->setOwningFunction(Function);
1258  Function->setParams(Params);
1259
1260  SourceLocation InstantiateAtPOI;
1261  if (TemplateParams) {
1262    // Our resulting instantiation is actually a function template, since we
1263    // are substituting only the outer template parameters. For example, given
1264    //
1265    //   template<typename T>
1266    //   struct X {
1267    //     template<typename U> friend void f(T, U);
1268    //   };
1269    //
1270    //   X<int> x;
1271    //
1272    // We are instantiating the friend function template "f" within X<int>,
1273    // which means substituting int for T, but leaving "f" as a friend function
1274    // template.
1275    // Build the function template itself.
1276    FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC,
1277                                                    Function->getLocation(),
1278                                                    Function->getDeclName(),
1279                                                    TemplateParams, Function);
1280    Function->setDescribedFunctionTemplate(FunctionTemplate);
1281
1282    FunctionTemplate->setLexicalDeclContext(LexicalDC);
1283
1284    if (isFriend && D->isThisDeclarationADefinition()) {
1285      // TODO: should we remember this connection regardless of whether
1286      // the friend declaration provided a body?
1287      FunctionTemplate->setInstantiatedFromMemberTemplate(
1288                                           D->getDescribedFunctionTemplate());
1289    }
1290  } else if (FunctionTemplate) {
1291    // Record this function template specialization.
1292    ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1293    Function->setFunctionTemplateSpecialization(FunctionTemplate,
1294                            TemplateArgumentList::CreateCopy(SemaRef.Context,
1295                                                             Innermost.begin(),
1296                                                             Innermost.size()),
1297                                                /*InsertPos=*/0);
1298  } else if (isFriend) {
1299    // Note, we need this connection even if the friend doesn't have a body.
1300    // Its body may exist but not have been attached yet due to deferred
1301    // parsing.
1302    // FIXME: It might be cleaner to set this when attaching the body to the
1303    // friend function declaration, however that would require finding all the
1304    // instantiations and modifying them.
1305    Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
1306  }
1307
1308  if (InitFunctionInstantiation(Function, D))
1309    Function->setInvalidDecl();
1310
1311  bool isExplicitSpecialization = false;
1312
1313  LookupResult Previous(SemaRef, Function->getDeclName(), SourceLocation(),
1314                        Sema::LookupOrdinaryName, Sema::ForRedeclaration);
1315
1316  if (DependentFunctionTemplateSpecializationInfo *Info
1317        = D->getDependentSpecializationInfo()) {
1318    assert(isFriend && "non-friend has dependent specialization info?");
1319
1320    // This needs to be set now for future sanity.
1321    Function->setObjectOfFriendDecl();
1322
1323    // Instantiate the explicit template arguments.
1324    TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
1325                                          Info->getRAngleLoc());
1326    if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
1327                      ExplicitArgs, TemplateArgs))
1328      return 0;
1329
1330    // Map the candidate templates to their instantiations.
1331    for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
1332      Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
1333                                                Info->getTemplate(I),
1334                                                TemplateArgs);
1335      if (!Temp) return 0;
1336
1337      Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
1338    }
1339
1340    if (SemaRef.CheckFunctionTemplateSpecialization(Function,
1341                                                    &ExplicitArgs,
1342                                                    Previous))
1343      Function->setInvalidDecl();
1344
1345    isExplicitSpecialization = true;
1346
1347  } else if (TemplateParams || !FunctionTemplate) {
1348    // Look only into the namespace where the friend would be declared to
1349    // find a previous declaration. This is the innermost enclosing namespace,
1350    // as described in ActOnFriendFunctionDecl.
1351    SemaRef.LookupQualifiedName(Previous, DC);
1352
1353    // In C++, the previous declaration we find might be a tag type
1354    // (class or enum). In this case, the new declaration will hide the
1355    // tag type. Note that this does does not apply if we're declaring a
1356    // typedef (C++ [dcl.typedef]p4).
1357    if (Previous.isSingleTagDecl())
1358      Previous.clear();
1359  }
1360
1361  SemaRef.CheckFunctionDeclaration(/*Scope*/ 0, Function, Previous,
1362                                   isExplicitSpecialization);
1363
1364  NamedDecl *PrincipalDecl = (TemplateParams
1365                              ? cast<NamedDecl>(FunctionTemplate)
1366                              : Function);
1367
1368  // If the original function was part of a friend declaration,
1369  // inherit its namespace state and add it to the owner.
1370  if (isFriend) {
1371    PrincipalDecl->setObjectOfFriendDecl();
1372    DC->makeDeclVisibleInContext(PrincipalDecl);
1373
1374    bool queuedInstantiation = false;
1375
1376    // C++98 [temp.friend]p5: When a function is defined in a friend function
1377    //   declaration in a class template, the function is defined at each
1378    //   instantiation of the class template. The function is defined even if it
1379    //   is never used.
1380    // C++11 [temp.friend]p4: When a function is defined in a friend function
1381    //   declaration in a class template, the function is instantiated when the
1382    //   function is odr-used.
1383    //
1384    // If -Wc++98-compat is enabled, we go through the motions of checking for a
1385    // redefinition, but don't instantiate the function.
1386    if ((!SemaRef.getLangOpts().CPlusPlus11 ||
1387         SemaRef.Diags.getDiagnosticLevel(
1388             diag::warn_cxx98_compat_friend_redefinition,
1389             Function->getLocation())
1390           != DiagnosticsEngine::Ignored) &&
1391        D->isThisDeclarationADefinition()) {
1392      // Check for a function body.
1393      const FunctionDecl *Definition = 0;
1394      if (Function->isDefined(Definition) &&
1395          Definition->getTemplateSpecializationKind() == TSK_Undeclared) {
1396        SemaRef.Diag(Function->getLocation(),
1397                     SemaRef.getLangOpts().CPlusPlus11 ?
1398                       diag::warn_cxx98_compat_friend_redefinition :
1399                       diag::err_redefinition) << Function->getDeclName();
1400        SemaRef.Diag(Definition->getLocation(), diag::note_previous_definition);
1401        if (!SemaRef.getLangOpts().CPlusPlus11)
1402          Function->setInvalidDecl();
1403      }
1404      // Check for redefinitions due to other instantiations of this or
1405      // a similar friend function.
1406      else for (FunctionDecl::redecl_iterator R = Function->redecls_begin(),
1407                                           REnd = Function->redecls_end();
1408                R != REnd; ++R) {
1409        if (*R == Function)
1410          continue;
1411        switch (R->getFriendObjectKind()) {
1412        case Decl::FOK_None:
1413          if (!SemaRef.getLangOpts().CPlusPlus11 &&
1414              !queuedInstantiation && R->isUsed(false)) {
1415            if (MemberSpecializationInfo *MSInfo
1416                = Function->getMemberSpecializationInfo()) {
1417              if (MSInfo->getPointOfInstantiation().isInvalid()) {
1418                SourceLocation Loc = R->getLocation(); // FIXME
1419                MSInfo->setPointOfInstantiation(Loc);
1420                SemaRef.PendingLocalImplicitInstantiations.push_back(
1421                                                 std::make_pair(Function, Loc));
1422                queuedInstantiation = true;
1423              }
1424            }
1425          }
1426          break;
1427        default:
1428          if (const FunctionDecl *RPattern
1429              = R->getTemplateInstantiationPattern())
1430            if (RPattern->isDefined(RPattern)) {
1431              SemaRef.Diag(Function->getLocation(),
1432                           SemaRef.getLangOpts().CPlusPlus11 ?
1433                             diag::warn_cxx98_compat_friend_redefinition :
1434                             diag::err_redefinition)
1435                << Function->getDeclName();
1436              SemaRef.Diag(R->getLocation(), diag::note_previous_definition);
1437              if (!SemaRef.getLangOpts().CPlusPlus11)
1438                Function->setInvalidDecl();
1439              break;
1440            }
1441        }
1442      }
1443    }
1444  }
1445
1446  if (Function->isOverloadedOperator() && !DC->isRecord() &&
1447      PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
1448    PrincipalDecl->setNonMemberOperator();
1449
1450  assert(!D->isDefaulted() && "only methods should be defaulted");
1451  return Function;
1452}
1453
1454Decl *
1455TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D,
1456                                      TemplateParameterList *TemplateParams,
1457                                      bool IsClassScopeSpecialization) {
1458  FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1459  if (FunctionTemplate && !TemplateParams) {
1460    // We are creating a function template specialization from a function
1461    // template. Check whether there is already a function template
1462    // specialization for this particular set of template arguments.
1463    ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1464
1465    void *InsertPos = 0;
1466    FunctionDecl *SpecFunc
1467      = FunctionTemplate->findSpecialization(Innermost.begin(),
1468                                             Innermost.size(),
1469                                             InsertPos);
1470
1471    // If we already have a function template specialization, return it.
1472    if (SpecFunc)
1473      return SpecFunc;
1474  }
1475
1476  bool isFriend;
1477  if (FunctionTemplate)
1478    isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1479  else
1480    isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1481
1482  bool MergeWithParentScope = (TemplateParams != 0) ||
1483    !(isa<Decl>(Owner) &&
1484      cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1485  LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1486
1487  // Instantiate enclosing template arguments for friends.
1488  SmallVector<TemplateParameterList *, 4> TempParamLists;
1489  unsigned NumTempParamLists = 0;
1490  if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) {
1491    TempParamLists.set_size(NumTempParamLists);
1492    for (unsigned I = 0; I != NumTempParamLists; ++I) {
1493      TemplateParameterList *TempParams = D->getTemplateParameterList(I);
1494      TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1495      if (!InstParams)
1496        return NULL;
1497      TempParamLists[I] = InstParams;
1498    }
1499  }
1500
1501  SmallVector<ParmVarDecl *, 4> Params;
1502  TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1503  if (!TInfo)
1504    return 0;
1505  QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
1506
1507  NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1508  if (QualifierLoc) {
1509    QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1510                                                 TemplateArgs);
1511    if (!QualifierLoc)
1512      return 0;
1513  }
1514
1515  DeclContext *DC = Owner;
1516  if (isFriend) {
1517    if (QualifierLoc) {
1518      CXXScopeSpec SS;
1519      SS.Adopt(QualifierLoc);
1520      DC = SemaRef.computeDeclContext(SS);
1521
1522      if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
1523        return 0;
1524    } else {
1525      DC = SemaRef.FindInstantiatedContext(D->getLocation(),
1526                                           D->getDeclContext(),
1527                                           TemplateArgs);
1528    }
1529    if (!DC) return 0;
1530  }
1531
1532  // Build the instantiated method declaration.
1533  CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
1534  CXXMethodDecl *Method = 0;
1535
1536  SourceLocation StartLoc = D->getInnerLocStart();
1537  DeclarationNameInfo NameInfo
1538    = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
1539  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
1540    Method = CXXConstructorDecl::Create(SemaRef.Context, Record,
1541                                        StartLoc, NameInfo, T, TInfo,
1542                                        Constructor->isExplicit(),
1543                                        Constructor->isInlineSpecified(),
1544                                        false, Constructor->isConstexpr());
1545
1546    // Claim that the instantiation of a constructor or constructor template
1547    // inherits the same constructor that the template does.
1548    if (CXXConstructorDecl *Inh = const_cast<CXXConstructorDecl *>(
1549            Constructor->getInheritedConstructor())) {
1550      // If we're instantiating a specialization of a function template, our
1551      // "inherited constructor" will actually itself be a function template.
1552      // Instantiate a declaration of it, too.
1553      if (FunctionTemplate) {
1554        assert(!TemplateParams && Inh->getDescribedFunctionTemplate() &&
1555               !Inh->getParent()->isDependentContext() &&
1556               "inheriting constructor template in dependent context?");
1557        Sema::InstantiatingTemplate Inst(SemaRef, Constructor->getLocation(),
1558                                         Inh);
1559        if (Inst)
1560          return 0;
1561        Sema::ContextRAII SavedContext(SemaRef, Inh->getDeclContext());
1562        LocalInstantiationScope LocalScope(SemaRef);
1563
1564        // Use the same template arguments that we deduced for the inheriting
1565        // constructor. There's no way they could be deduced differently.
1566        MultiLevelTemplateArgumentList InheritedArgs;
1567        InheritedArgs.addOuterTemplateArguments(TemplateArgs.getInnermost());
1568        Inh = cast_or_null<CXXConstructorDecl>(
1569            SemaRef.SubstDecl(Inh, Inh->getDeclContext(), InheritedArgs));
1570        if (!Inh)
1571          return 0;
1572      }
1573      cast<CXXConstructorDecl>(Method)->setInheritedConstructor(Inh);
1574    }
1575  } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
1576    Method = CXXDestructorDecl::Create(SemaRef.Context, Record,
1577                                       StartLoc, NameInfo, T, TInfo,
1578                                       Destructor->isInlineSpecified(),
1579                                       false);
1580  } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
1581    Method = CXXConversionDecl::Create(SemaRef.Context, Record,
1582                                       StartLoc, NameInfo, T, TInfo,
1583                                       Conversion->isInlineSpecified(),
1584                                       Conversion->isExplicit(),
1585                                       Conversion->isConstexpr(),
1586                                       Conversion->getLocEnd());
1587  } else {
1588    StorageClass SC = D->isStatic() ? SC_Static : SC_None;
1589    Method = CXXMethodDecl::Create(SemaRef.Context, Record,
1590                                   StartLoc, NameInfo, T, TInfo,
1591                                   SC, D->isInlineSpecified(),
1592                                   D->isConstexpr(), D->getLocEnd());
1593  }
1594
1595  if (D->isInlined())
1596    Method->setImplicitlyInline();
1597
1598  if (QualifierLoc)
1599    Method->setQualifierInfo(QualifierLoc);
1600
1601  if (TemplateParams) {
1602    // Our resulting instantiation is actually a function template, since we
1603    // are substituting only the outer template parameters. For example, given
1604    //
1605    //   template<typename T>
1606    //   struct X {
1607    //     template<typename U> void f(T, U);
1608    //   };
1609    //
1610    //   X<int> x;
1611    //
1612    // We are instantiating the member template "f" within X<int>, which means
1613    // substituting int for T, but leaving "f" as a member function template.
1614    // Build the function template itself.
1615    FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record,
1616                                                    Method->getLocation(),
1617                                                    Method->getDeclName(),
1618                                                    TemplateParams, Method);
1619    if (isFriend) {
1620      FunctionTemplate->setLexicalDeclContext(Owner);
1621      FunctionTemplate->setObjectOfFriendDecl();
1622    } else if (D->isOutOfLine())
1623      FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext());
1624    Method->setDescribedFunctionTemplate(FunctionTemplate);
1625  } else if (FunctionTemplate) {
1626    // Record this function template specialization.
1627    ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1628    Method->setFunctionTemplateSpecialization(FunctionTemplate,
1629                         TemplateArgumentList::CreateCopy(SemaRef.Context,
1630                                                          Innermost.begin(),
1631                                                          Innermost.size()),
1632                                              /*InsertPos=*/0);
1633  } else if (!isFriend) {
1634    // Record that this is an instantiation of a member function.
1635    Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
1636  }
1637
1638  // If we are instantiating a member function defined
1639  // out-of-line, the instantiation will have the same lexical
1640  // context (which will be a namespace scope) as the template.
1641  if (isFriend) {
1642    if (NumTempParamLists)
1643      Method->setTemplateParameterListsInfo(SemaRef.Context,
1644                                            NumTempParamLists,
1645                                            TempParamLists.data());
1646
1647    Method->setLexicalDeclContext(Owner);
1648    Method->setObjectOfFriendDecl();
1649  } else if (D->isOutOfLine())
1650    Method->setLexicalDeclContext(D->getLexicalDeclContext());
1651
1652  // Attach the parameters
1653  for (unsigned P = 0; P < Params.size(); ++P)
1654    Params[P]->setOwningFunction(Method);
1655  Method->setParams(Params);
1656
1657  if (InitMethodInstantiation(Method, D))
1658    Method->setInvalidDecl();
1659
1660  LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName,
1661                        Sema::ForRedeclaration);
1662
1663  if (!FunctionTemplate || TemplateParams || isFriend) {
1664    SemaRef.LookupQualifiedName(Previous, Record);
1665
1666    // In C++, the previous declaration we find might be a tag type
1667    // (class or enum). In this case, the new declaration will hide the
1668    // tag type. Note that this does does not apply if we're declaring a
1669    // typedef (C++ [dcl.typedef]p4).
1670    if (Previous.isSingleTagDecl())
1671      Previous.clear();
1672  }
1673
1674  if (!IsClassScopeSpecialization)
1675    SemaRef.CheckFunctionDeclaration(0, Method, Previous, false);
1676
1677  if (D->isPure())
1678    SemaRef.CheckPureMethod(Method, SourceRange());
1679
1680  // Propagate access.  For a non-friend declaration, the access is
1681  // whatever we're propagating from.  For a friend, it should be the
1682  // previous declaration we just found.
1683  if (isFriend && Method->getPreviousDecl())
1684    Method->setAccess(Method->getPreviousDecl()->getAccess());
1685  else
1686    Method->setAccess(D->getAccess());
1687  if (FunctionTemplate)
1688    FunctionTemplate->setAccess(Method->getAccess());
1689
1690  SemaRef.CheckOverrideControl(Method);
1691
1692  // If a function is defined as defaulted or deleted, mark it as such now.
1693  if (D->isExplicitlyDefaulted())
1694    SemaRef.SetDeclDefaulted(Method, Method->getLocation());
1695  if (D->isDeletedAsWritten())
1696    SemaRef.SetDeclDeleted(Method, Method->getLocation());
1697
1698  // If there's a function template, let our caller handle it.
1699  if (FunctionTemplate) {
1700    // do nothing
1701
1702  // Don't hide a (potentially) valid declaration with an invalid one.
1703  } else if (Method->isInvalidDecl() && !Previous.empty()) {
1704    // do nothing
1705
1706  // Otherwise, check access to friends and make them visible.
1707  } else if (isFriend) {
1708    // We only need to re-check access for methods which we didn't
1709    // manage to match during parsing.
1710    if (!D->getPreviousDecl())
1711      SemaRef.CheckFriendAccess(Method);
1712
1713    Record->makeDeclVisibleInContext(Method);
1714
1715  // Otherwise, add the declaration.  We don't need to do this for
1716  // class-scope specializations because we'll have matched them with
1717  // the appropriate template.
1718  } else if (!IsClassScopeSpecialization) {
1719    Owner->addDecl(Method);
1720  }
1721
1722  return Method;
1723}
1724
1725Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1726  return VisitCXXMethodDecl(D);
1727}
1728
1729Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1730  return VisitCXXMethodDecl(D);
1731}
1732
1733Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
1734  return VisitCXXMethodDecl(D);
1735}
1736
1737Decl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
1738  return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0, None,
1739                                  /*ExpectParameterPack=*/ false);
1740}
1741
1742Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
1743                                                    TemplateTypeParmDecl *D) {
1744  // TODO: don't always clone when decls are refcounted.
1745  assert(D->getTypeForDecl()->isTemplateTypeParmType());
1746
1747  TemplateTypeParmDecl *Inst =
1748    TemplateTypeParmDecl::Create(SemaRef.Context, Owner,
1749                                 D->getLocStart(), D->getLocation(),
1750                                 D->getDepth() - TemplateArgs.getNumLevels(),
1751                                 D->getIndex(), D->getIdentifier(),
1752                                 D->wasDeclaredWithTypename(),
1753                                 D->isParameterPack());
1754  Inst->setAccess(AS_public);
1755
1756  if (D->hasDefaultArgument())
1757    Inst->setDefaultArgument(D->getDefaultArgumentInfo(), false);
1758
1759  // Introduce this template parameter's instantiation into the instantiation
1760  // scope.
1761  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);
1762
1763  return Inst;
1764}
1765
1766Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
1767                                                 NonTypeTemplateParmDecl *D) {
1768  // Substitute into the type of the non-type template parameter.
1769  TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc();
1770  SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten;
1771  SmallVector<QualType, 4> ExpandedParameterPackTypes;
1772  bool IsExpandedParameterPack = false;
1773  TypeSourceInfo *DI;
1774  QualType T;
1775  bool Invalid = false;
1776
1777  if (D->isExpandedParameterPack()) {
1778    // The non-type template parameter pack is an already-expanded pack
1779    // expansion of types. Substitute into each of the expanded types.
1780    ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes());
1781    ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes());
1782    for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1783      TypeSourceInfo *NewDI =SemaRef.SubstType(D->getExpansionTypeSourceInfo(I),
1784                                               TemplateArgs,
1785                                               D->getLocation(),
1786                                               D->getDeclName());
1787      if (!NewDI)
1788        return 0;
1789
1790      ExpandedParameterPackTypesAsWritten.push_back(NewDI);
1791      QualType NewT =SemaRef.CheckNonTypeTemplateParameterType(NewDI->getType(),
1792                                                              D->getLocation());
1793      if (NewT.isNull())
1794        return 0;
1795      ExpandedParameterPackTypes.push_back(NewT);
1796    }
1797
1798    IsExpandedParameterPack = true;
1799    DI = D->getTypeSourceInfo();
1800    T = DI->getType();
1801  } else if (D->isPackExpansion()) {
1802    // The non-type template parameter pack's type is a pack expansion of types.
1803    // Determine whether we need to expand this parameter pack into separate
1804    // types.
1805    PackExpansionTypeLoc Expansion = TL.castAs<PackExpansionTypeLoc>();
1806    TypeLoc Pattern = Expansion.getPatternLoc();
1807    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
1808    SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
1809
1810    // Determine whether the set of unexpanded parameter packs can and should
1811    // be expanded.
1812    bool Expand = true;
1813    bool RetainExpansion = false;
1814    Optional<unsigned> OrigNumExpansions
1815      = Expansion.getTypePtr()->getNumExpansions();
1816    Optional<unsigned> NumExpansions = OrigNumExpansions;
1817    if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
1818                                                Pattern.getSourceRange(),
1819                                                Unexpanded,
1820                                                TemplateArgs,
1821                                                Expand, RetainExpansion,
1822                                                NumExpansions))
1823      return 0;
1824
1825    if (Expand) {
1826      for (unsigned I = 0; I != *NumExpansions; ++I) {
1827        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
1828        TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs,
1829                                                  D->getLocation(),
1830                                                  D->getDeclName());
1831        if (!NewDI)
1832          return 0;
1833
1834        ExpandedParameterPackTypesAsWritten.push_back(NewDI);
1835        QualType NewT = SemaRef.CheckNonTypeTemplateParameterType(
1836                                                              NewDI->getType(),
1837                                                              D->getLocation());
1838        if (NewT.isNull())
1839          return 0;
1840        ExpandedParameterPackTypes.push_back(NewT);
1841      }
1842
1843      // Note that we have an expanded parameter pack. The "type" of this
1844      // expanded parameter pack is the original expansion type, but callers
1845      // will end up using the expanded parameter pack types for type-checking.
1846      IsExpandedParameterPack = true;
1847      DI = D->getTypeSourceInfo();
1848      T = DI->getType();
1849    } else {
1850      // We cannot fully expand the pack expansion now, so substitute into the
1851      // pattern and create a new pack expansion type.
1852      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
1853      TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs,
1854                                                     D->getLocation(),
1855                                                     D->getDeclName());
1856      if (!NewPattern)
1857        return 0;
1858
1859      DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(),
1860                                      NumExpansions);
1861      if (!DI)
1862        return 0;
1863
1864      T = DI->getType();
1865    }
1866  } else {
1867    // Simple case: substitution into a parameter that is not a parameter pack.
1868    DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
1869                           D->getLocation(), D->getDeclName());
1870    if (!DI)
1871      return 0;
1872
1873    // Check that this type is acceptable for a non-type template parameter.
1874    T = SemaRef.CheckNonTypeTemplateParameterType(DI->getType(),
1875                                                  D->getLocation());
1876    if (T.isNull()) {
1877      T = SemaRef.Context.IntTy;
1878      Invalid = true;
1879    }
1880  }
1881
1882  NonTypeTemplateParmDecl *Param;
1883  if (IsExpandedParameterPack)
1884    Param = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner,
1885                                            D->getInnerLocStart(),
1886                                            D->getLocation(),
1887                                    D->getDepth() - TemplateArgs.getNumLevels(),
1888                                            D->getPosition(),
1889                                            D->getIdentifier(), T,
1890                                            DI,
1891                                            ExpandedParameterPackTypes.data(),
1892                                            ExpandedParameterPackTypes.size(),
1893                                    ExpandedParameterPackTypesAsWritten.data());
1894  else
1895    Param = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner,
1896                                            D->getInnerLocStart(),
1897                                            D->getLocation(),
1898                                    D->getDepth() - TemplateArgs.getNumLevels(),
1899                                            D->getPosition(),
1900                                            D->getIdentifier(), T,
1901                                            D->isParameterPack(), DI);
1902
1903  Param->setAccess(AS_public);
1904  if (Invalid)
1905    Param->setInvalidDecl();
1906
1907  Param->setDefaultArgument(D->getDefaultArgument(), false);
1908
1909  // Introduce this template parameter's instantiation into the instantiation
1910  // scope.
1911  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
1912  return Param;
1913}
1914
1915static void collectUnexpandedParameterPacks(
1916    Sema &S,
1917    TemplateParameterList *Params,
1918    SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
1919  for (TemplateParameterList::const_iterator I = Params->begin(),
1920                                             E = Params->end(); I != E; ++I) {
1921    if ((*I)->isTemplateParameterPack())
1922      continue;
1923    if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*I))
1924      S.collectUnexpandedParameterPacks(NTTP->getTypeSourceInfo()->getTypeLoc(),
1925                                        Unexpanded);
1926    if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(*I))
1927      collectUnexpandedParameterPacks(S, TTP->getTemplateParameters(),
1928                                      Unexpanded);
1929  }
1930}
1931
1932Decl *
1933TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
1934                                                  TemplateTemplateParmDecl *D) {
1935  // Instantiate the template parameter list of the template template parameter.
1936  TemplateParameterList *TempParams = D->getTemplateParameters();
1937  TemplateParameterList *InstParams;
1938  SmallVector<TemplateParameterList*, 8> ExpandedParams;
1939
1940  bool IsExpandedParameterPack = false;
1941
1942  if (D->isExpandedParameterPack()) {
1943    // The template template parameter pack is an already-expanded pack
1944    // expansion of template parameters. Substitute into each of the expanded
1945    // parameters.
1946    ExpandedParams.reserve(D->getNumExpansionTemplateParameters());
1947    for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1948         I != N; ++I) {
1949      LocalInstantiationScope Scope(SemaRef);
1950      TemplateParameterList *Expansion =
1951        SubstTemplateParams(D->getExpansionTemplateParameters(I));
1952      if (!Expansion)
1953        return 0;
1954      ExpandedParams.push_back(Expansion);
1955    }
1956
1957    IsExpandedParameterPack = true;
1958    InstParams = TempParams;
1959  } else if (D->isPackExpansion()) {
1960    // The template template parameter pack expands to a pack of template
1961    // template parameters. Determine whether we need to expand this parameter
1962    // pack into separate parameters.
1963    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
1964    collectUnexpandedParameterPacks(SemaRef, D->getTemplateParameters(),
1965                                    Unexpanded);
1966
1967    // Determine whether the set of unexpanded parameter packs can and should
1968    // be expanded.
1969    bool Expand = true;
1970    bool RetainExpansion = false;
1971    Optional<unsigned> NumExpansions;
1972    if (SemaRef.CheckParameterPacksForExpansion(D->getLocation(),
1973                                                TempParams->getSourceRange(),
1974                                                Unexpanded,
1975                                                TemplateArgs,
1976                                                Expand, RetainExpansion,
1977                                                NumExpansions))
1978      return 0;
1979
1980    if (Expand) {
1981      for (unsigned I = 0; I != *NumExpansions; ++I) {
1982        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
1983        LocalInstantiationScope Scope(SemaRef);
1984        TemplateParameterList *Expansion = SubstTemplateParams(TempParams);
1985        if (!Expansion)
1986          return 0;
1987        ExpandedParams.push_back(Expansion);
1988      }
1989
1990      // Note that we have an expanded parameter pack. The "type" of this
1991      // expanded parameter pack is the original expansion type, but callers
1992      // will end up using the expanded parameter pack types for type-checking.
1993      IsExpandedParameterPack = true;
1994      InstParams = TempParams;
1995    } else {
1996      // We cannot fully expand the pack expansion now, so just substitute
1997      // into the pattern.
1998      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
1999
2000      LocalInstantiationScope Scope(SemaRef);
2001      InstParams = SubstTemplateParams(TempParams);
2002      if (!InstParams)
2003        return 0;
2004    }
2005  } else {
2006    // Perform the actual substitution of template parameters within a new,
2007    // local instantiation scope.
2008    LocalInstantiationScope Scope(SemaRef);
2009    InstParams = SubstTemplateParams(TempParams);
2010    if (!InstParams)
2011      return 0;
2012  }
2013
2014  // Build the template template parameter.
2015  TemplateTemplateParmDecl *Param;
2016  if (IsExpandedParameterPack)
2017    Param = TemplateTemplateParmDecl::Create(SemaRef.Context, Owner,
2018                                             D->getLocation(),
2019                                   D->getDepth() - TemplateArgs.getNumLevels(),
2020                                             D->getPosition(),
2021                                             D->getIdentifier(), InstParams,
2022                                             ExpandedParams);
2023  else
2024    Param = TemplateTemplateParmDecl::Create(SemaRef.Context, Owner,
2025                                             D->getLocation(),
2026                                   D->getDepth() - TemplateArgs.getNumLevels(),
2027                                             D->getPosition(),
2028                                             D->isParameterPack(),
2029                                             D->getIdentifier(), InstParams);
2030  Param->setDefaultArgument(D->getDefaultArgument(), false);
2031  Param->setAccess(AS_public);
2032
2033  // Introduce this template parameter's instantiation into the instantiation
2034  // scope.
2035  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
2036
2037  return Param;
2038}
2039
2040Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
2041  // Using directives are never dependent (and never contain any types or
2042  // expressions), so they require no explicit instantiation work.
2043
2044  UsingDirectiveDecl *Inst
2045    = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(),
2046                                 D->getNamespaceKeyLocation(),
2047                                 D->getQualifierLoc(),
2048                                 D->getIdentLocation(),
2049                                 D->getNominatedNamespace(),
2050                                 D->getCommonAncestor());
2051
2052  // Add the using directive to its declaration context
2053  // only if this is not a function or method.
2054  if (!Owner->isFunctionOrMethod())
2055    Owner->addDecl(Inst);
2056
2057  return Inst;
2058}
2059
2060Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {
2061
2062  // The nested name specifier may be dependent, for example
2063  //     template <typename T> struct t {
2064  //       struct s1 { T f1(); };
2065  //       struct s2 : s1 { using s1::f1; };
2066  //     };
2067  //     template struct t<int>;
2068  // Here, in using s1::f1, s1 refers to t<T>::s1;
2069  // we need to substitute for t<int>::s1.
2070  NestedNameSpecifierLoc QualifierLoc
2071    = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
2072                                          TemplateArgs);
2073  if (!QualifierLoc)
2074    return 0;
2075
2076  // The name info is non-dependent, so no transformation
2077  // is required.
2078  DeclarationNameInfo NameInfo = D->getNameInfo();
2079
2080  // We only need to do redeclaration lookups if we're in a class
2081  // scope (in fact, it's not really even possible in non-class
2082  // scopes).
2083  bool CheckRedeclaration = Owner->isRecord();
2084
2085  LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName,
2086                    Sema::ForRedeclaration);
2087
2088  UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner,
2089                                       D->getUsingLoc(),
2090                                       QualifierLoc,
2091                                       NameInfo,
2092                                       D->hasTypename());
2093
2094  CXXScopeSpec SS;
2095  SS.Adopt(QualifierLoc);
2096  if (CheckRedeclaration) {
2097    Prev.setHideTags(false);
2098    SemaRef.LookupQualifiedName(Prev, Owner);
2099
2100    // Check for invalid redeclarations.
2101    if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLoc(),
2102                                            D->hasTypename(), SS,
2103                                            D->getLocation(), Prev))
2104      NewUD->setInvalidDecl();
2105
2106  }
2107
2108  if (!NewUD->isInvalidDecl() &&
2109      SemaRef.CheckUsingDeclQualifier(D->getUsingLoc(), SS,
2110                                      D->getLocation()))
2111    NewUD->setInvalidDecl();
2112
2113  SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
2114  NewUD->setAccess(D->getAccess());
2115  Owner->addDecl(NewUD);
2116
2117  // Don't process the shadow decls for an invalid decl.
2118  if (NewUD->isInvalidDecl())
2119    return NewUD;
2120
2121  if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName) {
2122    if (SemaRef.CheckInheritingConstructorUsingDecl(NewUD))
2123      NewUD->setInvalidDecl();
2124    return NewUD;
2125  }
2126
2127  bool isFunctionScope = Owner->isFunctionOrMethod();
2128
2129  // Process the shadow decls.
2130  for (UsingDecl::shadow_iterator I = D->shadow_begin(), E = D->shadow_end();
2131         I != E; ++I) {
2132    UsingShadowDecl *Shadow = *I;
2133    NamedDecl *InstTarget =
2134      cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
2135                                                          Shadow->getLocation(),
2136                                                        Shadow->getTargetDecl(),
2137                                                           TemplateArgs));
2138    if (!InstTarget)
2139      return 0;
2140
2141    if (CheckRedeclaration &&
2142        SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev))
2143      continue;
2144
2145    UsingShadowDecl *InstShadow
2146      = SemaRef.BuildUsingShadowDecl(/*Scope*/ 0, NewUD, InstTarget);
2147    SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);
2148
2149    if (isFunctionScope)
2150      SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow);
2151  }
2152
2153  return NewUD;
2154}
2155
2156Decl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) {
2157  // Ignore these;  we handle them in bulk when processing the UsingDecl.
2158  return 0;
2159}
2160
2161Decl * TemplateDeclInstantiator
2162    ::VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) {
2163  NestedNameSpecifierLoc QualifierLoc
2164    = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
2165                                          TemplateArgs);
2166  if (!QualifierLoc)
2167    return 0;
2168
2169  CXXScopeSpec SS;
2170  SS.Adopt(QualifierLoc);
2171
2172  // Since NameInfo refers to a typename, it cannot be a C++ special name.
2173  // Hence, no transformation is required for it.
2174  DeclarationNameInfo NameInfo(D->getDeclName(), D->getLocation());
2175  NamedDecl *UD =
2176    SemaRef.BuildUsingDeclaration(/*Scope*/ 0, D->getAccess(),
2177                                  D->getUsingLoc(), SS, NameInfo, 0,
2178                                  /*instantiation*/ true,
2179                                  /*typename*/ true, D->getTypenameLoc());
2180  if (UD)
2181    SemaRef.Context.setInstantiatedFromUsingDecl(cast<UsingDecl>(UD), D);
2182
2183  return UD;
2184}
2185
2186Decl * TemplateDeclInstantiator
2187    ::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
2188  NestedNameSpecifierLoc QualifierLoc
2189      = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(), TemplateArgs);
2190  if (!QualifierLoc)
2191    return 0;
2192
2193  CXXScopeSpec SS;
2194  SS.Adopt(QualifierLoc);
2195
2196  DeclarationNameInfo NameInfo
2197    = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
2198
2199  NamedDecl *UD =
2200    SemaRef.BuildUsingDeclaration(/*Scope*/ 0, D->getAccess(),
2201                                  D->getUsingLoc(), SS, NameInfo, 0,
2202                                  /*instantiation*/ true,
2203                                  /*typename*/ false, SourceLocation());
2204  if (UD)
2205    SemaRef.Context.setInstantiatedFromUsingDecl(cast<UsingDecl>(UD), D);
2206
2207  return UD;
2208}
2209
2210
2211Decl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl(
2212                                     ClassScopeFunctionSpecializationDecl *Decl) {
2213  CXXMethodDecl *OldFD = Decl->getSpecialization();
2214  CXXMethodDecl *NewFD = cast<CXXMethodDecl>(VisitCXXMethodDecl(OldFD,
2215                                                                0, true));
2216
2217  LookupResult Previous(SemaRef, NewFD->getNameInfo(), Sema::LookupOrdinaryName,
2218                        Sema::ForRedeclaration);
2219
2220  TemplateArgumentListInfo TemplateArgs;
2221  TemplateArgumentListInfo* TemplateArgsPtr = 0;
2222  if (Decl->hasExplicitTemplateArgs()) {
2223    TemplateArgs = Decl->templateArgs();
2224    TemplateArgsPtr = &TemplateArgs;
2225  }
2226
2227  SemaRef.LookupQualifiedName(Previous, SemaRef.CurContext);
2228  if (SemaRef.CheckFunctionTemplateSpecialization(NewFD, TemplateArgsPtr,
2229                                                  Previous)) {
2230    NewFD->setInvalidDecl();
2231    return NewFD;
2232  }
2233
2234  // Associate the specialization with the pattern.
2235  FunctionDecl *Specialization = cast<FunctionDecl>(Previous.getFoundDecl());
2236  assert(Specialization && "Class scope Specialization is null");
2237  SemaRef.Context.setClassScopeSpecializationPattern(Specialization, OldFD);
2238
2239  return NewFD;
2240}
2241
2242Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
2243                                     OMPThreadPrivateDecl *D) {
2244  SmallVector<Expr *, 5> Vars;
2245  for (ArrayRef<Expr *>::iterator I = D->varlist_begin(),
2246                                  E = D->varlist_end();
2247       I != E; ++I) {
2248    Expr *Var = SemaRef.SubstExpr(*I, TemplateArgs).take();
2249    assert(isa<DeclRefExpr>(Var) && "threadprivate arg is not a DeclRefExpr");
2250    Vars.push_back(Var);
2251  }
2252
2253  OMPThreadPrivateDecl *TD =
2254    SemaRef.CheckOMPThreadPrivateDecl(D->getLocation(), Vars);
2255
2256  return TD;
2257}
2258
2259Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D) {
2260  return VisitFunctionDecl(D, 0);
2261}
2262
2263Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D) {
2264  return VisitCXXMethodDecl(D, 0);
2265}
2266
2267Decl *TemplateDeclInstantiator::VisitRecordDecl(RecordDecl *D) {
2268  llvm_unreachable("There are only CXXRecordDecls in C++");
2269}
2270
2271Decl *
2272TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
2273    ClassTemplateSpecializationDecl *D) {
2274  llvm_unreachable("Only ClassTemplatePartialSpecializationDecls occur"
2275                   "inside templates");
2276}
2277
2278Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
2279    VarTemplateSpecializationDecl *D) {
2280
2281  TemplateArgumentListInfo VarTemplateArgsInfo;
2282  VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
2283  assert(VarTemplate &&
2284         "A template specialization without specialized template?");
2285
2286  // Substitute the current template arguments.
2287  const TemplateArgumentListInfo &TemplateArgsInfo = D->getTemplateArgsInfo();
2288  VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo.getLAngleLoc());
2289  VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo.getRAngleLoc());
2290
2291  if (SemaRef.Subst(TemplateArgsInfo.getArgumentArray(),
2292                    TemplateArgsInfo.size(), VarTemplateArgsInfo, TemplateArgs))
2293    return 0;
2294
2295  // Check that the template argument list is well-formed for this template.
2296  SmallVector<TemplateArgument, 4> Converted;
2297  bool ExpansionIntoFixedList = false;
2298  if (SemaRef.CheckTemplateArgumentList(
2299          VarTemplate, VarTemplate->getLocStart(),
2300          const_cast<TemplateArgumentListInfo &>(VarTemplateArgsInfo), false,
2301          Converted, &ExpansionIntoFixedList))
2302    return 0;
2303
2304  // Find the variable template specialization declaration that
2305  // corresponds to these arguments.
2306  void *InsertPos = 0;
2307  if (VarTemplateSpecializationDecl *VarSpec = VarTemplate->findSpecialization(
2308          Converted.data(), Converted.size(), InsertPos))
2309    // If we already have a variable template specialization, return it.
2310    return VarSpec;
2311
2312  return VisitVarTemplateSpecializationDecl(VarTemplate, D, InsertPos,
2313                                            VarTemplateArgsInfo, Converted);
2314}
2315
2316Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
2317    VarTemplateDecl *VarTemplate, VarDecl *D, void *InsertPos,
2318    const TemplateArgumentListInfo &TemplateArgsInfo,
2319    SmallVectorImpl<TemplateArgument> &Converted) {
2320
2321  // If this is the variable for an anonymous struct or union,
2322  // instantiate the anonymous struct/union type first.
2323  if (const RecordType *RecordTy = D->getType()->getAs<RecordType>())
2324    if (RecordTy->getDecl()->isAnonymousStructOrUnion())
2325      if (!VisitCXXRecordDecl(cast<CXXRecordDecl>(RecordTy->getDecl())))
2326        return 0;
2327
2328  // Do substitution on the type of the declaration
2329  TypeSourceInfo *DI =
2330      SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
2331                        D->getTypeSpecStartLoc(), D->getDeclName());
2332  if (!DI)
2333    return 0;
2334
2335  if (DI->getType()->isFunctionType()) {
2336    SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
2337        << D->isStaticDataMember() << DI->getType();
2338    return 0;
2339  }
2340
2341  // Build the instantiated declaration
2342  VarTemplateSpecializationDecl *Var = VarTemplateSpecializationDecl::Create(
2343      SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
2344      VarTemplate, DI->getType(), DI, D->getStorageClass(), Converted.data(),
2345      Converted.size());
2346  Var->setTemplateArgsInfo(TemplateArgsInfo);
2347  VarTemplate->AddSpecialization(Var, InsertPos);
2348
2349  // Substitute the nested name specifier, if any.
2350  if (SubstQualifier(D, Var))
2351    return 0;
2352
2353  SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs,
2354                                     StartingScope);
2355
2356  return Var;
2357}
2358
2359Decl *TemplateDeclInstantiator::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
2360  llvm_unreachable("@defs is not supported in Objective-C++");
2361}
2362
2363Decl *TemplateDeclInstantiator::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
2364  // FIXME: We need to be able to instantiate FriendTemplateDecls.
2365  unsigned DiagID = SemaRef.getDiagnostics().getCustomDiagID(
2366                                               DiagnosticsEngine::Error,
2367                                               "cannot instantiate %0 yet");
2368  SemaRef.Diag(D->getLocation(), DiagID)
2369    << D->getDeclKindName();
2370
2371  return 0;
2372}
2373
2374Decl *TemplateDeclInstantiator::VisitDecl(Decl *D) {
2375  llvm_unreachable("Unexpected decl");
2376}
2377
2378Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
2379                      const MultiLevelTemplateArgumentList &TemplateArgs) {
2380  TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
2381  if (D->isInvalidDecl())
2382    return 0;
2383
2384  return Instantiator.Visit(D);
2385}
2386
2387/// \brief Instantiates a nested template parameter list in the current
2388/// instantiation context.
2389///
2390/// \param L The parameter list to instantiate
2391///
2392/// \returns NULL if there was an error
2393TemplateParameterList *
2394TemplateDeclInstantiator::SubstTemplateParams(TemplateParameterList *L) {
2395  // Get errors for all the parameters before bailing out.
2396  bool Invalid = false;
2397
2398  unsigned N = L->size();
2399  typedef SmallVector<NamedDecl *, 8> ParamVector;
2400  ParamVector Params;
2401  Params.reserve(N);
2402  for (TemplateParameterList::iterator PI = L->begin(), PE = L->end();
2403       PI != PE; ++PI) {
2404    NamedDecl *D = cast_or_null<NamedDecl>(Visit(*PI));
2405    Params.push_back(D);
2406    Invalid = Invalid || !D || D->isInvalidDecl();
2407  }
2408
2409  // Clean up if we had an error.
2410  if (Invalid)
2411    return NULL;
2412
2413  TemplateParameterList *InstL
2414    = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
2415                                    L->getLAngleLoc(), &Params.front(), N,
2416                                    L->getRAngleLoc());
2417  return InstL;
2418}
2419
2420/// \brief Instantiate the declaration of a class template partial
2421/// specialization.
2422///
2423/// \param ClassTemplate the (instantiated) class template that is partially
2424// specialized by the instantiation of \p PartialSpec.
2425///
2426/// \param PartialSpec the (uninstantiated) class template partial
2427/// specialization that we are instantiating.
2428///
2429/// \returns The instantiated partial specialization, if successful; otherwise,
2430/// NULL to indicate an error.
2431ClassTemplatePartialSpecializationDecl *
2432TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(
2433                                            ClassTemplateDecl *ClassTemplate,
2434                          ClassTemplatePartialSpecializationDecl *PartialSpec) {
2435  // Create a local instantiation scope for this class template partial
2436  // specialization, which will contain the instantiations of the template
2437  // parameters.
2438  LocalInstantiationScope Scope(SemaRef);
2439
2440  // Substitute into the template parameters of the class template partial
2441  // specialization.
2442  TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
2443  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
2444  if (!InstParams)
2445    return 0;
2446
2447  // Substitute into the template arguments of the class template partial
2448  // specialization.
2449  TemplateArgumentListInfo InstTemplateArgs; // no angle locations
2450  if (SemaRef.Subst(PartialSpec->getTemplateArgsAsWritten(),
2451                    PartialSpec->getNumTemplateArgsAsWritten(),
2452                    InstTemplateArgs, TemplateArgs))
2453    return 0;
2454
2455  // Check that the template argument list is well-formed for this
2456  // class template.
2457  SmallVector<TemplateArgument, 4> Converted;
2458  if (SemaRef.CheckTemplateArgumentList(ClassTemplate,
2459                                        PartialSpec->getLocation(),
2460                                        InstTemplateArgs,
2461                                        false,
2462                                        Converted))
2463    return 0;
2464
2465  // Figure out where to insert this class template partial specialization
2466  // in the member template's set of class template partial specializations.
2467  void *InsertPos = 0;
2468  ClassTemplateSpecializationDecl *PrevDecl
2469    = ClassTemplate->findPartialSpecialization(Converted.data(),
2470                                               Converted.size(), InsertPos);
2471
2472  // Build the canonical type that describes the converted template
2473  // arguments of the class template partial specialization.
2474  QualType CanonType
2475    = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate),
2476                                                    Converted.data(),
2477                                                    Converted.size());
2478
2479  // Build the fully-sugared type for this class template
2480  // specialization as the user wrote in the specialization
2481  // itself. This means that we'll pretty-print the type retrieved
2482  // from the specialization's declaration the way that the user
2483  // actually wrote the specialization, rather than formatting the
2484  // name based on the "canonical" representation used to store the
2485  // template arguments in the specialization.
2486  TypeSourceInfo *WrittenTy
2487    = SemaRef.Context.getTemplateSpecializationTypeInfo(
2488                                                    TemplateName(ClassTemplate),
2489                                                    PartialSpec->getLocation(),
2490                                                    InstTemplateArgs,
2491                                                    CanonType);
2492
2493  if (PrevDecl) {
2494    // We've already seen a partial specialization with the same template
2495    // parameters and template arguments. This can happen, for example, when
2496    // substituting the outer template arguments ends up causing two
2497    // class template partial specializations of a member class template
2498    // to have identical forms, e.g.,
2499    //
2500    //   template<typename T, typename U>
2501    //   struct Outer {
2502    //     template<typename X, typename Y> struct Inner;
2503    //     template<typename Y> struct Inner<T, Y>;
2504    //     template<typename Y> struct Inner<U, Y>;
2505    //   };
2506    //
2507    //   Outer<int, int> outer; // error: the partial specializations of Inner
2508    //                          // have the same signature.
2509    SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared)
2510      << WrittenTy->getType();
2511    SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here)
2512      << SemaRef.Context.getTypeDeclType(PrevDecl);
2513    return 0;
2514  }
2515
2516
2517  // Create the class template partial specialization declaration.
2518  ClassTemplatePartialSpecializationDecl *InstPartialSpec
2519    = ClassTemplatePartialSpecializationDecl::Create(SemaRef.Context,
2520                                                     PartialSpec->getTagKind(),
2521                                                     Owner,
2522                                                     PartialSpec->getLocStart(),
2523                                                     PartialSpec->getLocation(),
2524                                                     InstParams,
2525                                                     ClassTemplate,
2526                                                     Converted.data(),
2527                                                     Converted.size(),
2528                                                     InstTemplateArgs,
2529                                                     CanonType,
2530                                                     0,
2531                             ClassTemplate->getNextPartialSpecSequenceNumber());
2532  // Substitute the nested name specifier, if any.
2533  if (SubstQualifier(PartialSpec, InstPartialSpec))
2534    return 0;
2535
2536  InstPartialSpec->setInstantiatedFromMember(PartialSpec);
2537  InstPartialSpec->setTypeAsWritten(WrittenTy);
2538
2539  // Add this partial specialization to the set of class template partial
2540  // specializations.
2541  ClassTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/0);
2542  return InstPartialSpec;
2543}
2544
2545/// \brief Instantiate the declaration of a variable template partial
2546/// specialization.
2547///
2548/// \param VarTemplate the (instantiated) variable template that is partially
2549/// specialized by the instantiation of \p PartialSpec.
2550///
2551/// \param PartialSpec the (uninstantiated) variable template partial
2552/// specialization that we are instantiating.
2553///
2554/// \returns The instantiated partial specialization, if successful; otherwise,
2555/// NULL to indicate an error.
2556VarTemplatePartialSpecializationDecl *
2557TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(
2558    VarTemplateDecl *VarTemplate,
2559    VarTemplatePartialSpecializationDecl *PartialSpec) {
2560  // Create a local instantiation scope for this variable template partial
2561  // specialization, which will contain the instantiations of the template
2562  // parameters.
2563  LocalInstantiationScope Scope(SemaRef);
2564
2565  // Substitute into the template parameters of the variable template partial
2566  // specialization.
2567  TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
2568  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
2569  if (!InstParams)
2570    return 0;
2571
2572  // Substitute into the template arguments of the variable template partial
2573  // specialization.
2574  TemplateArgumentListInfo InstTemplateArgs; // no angle locations
2575  if (SemaRef.Subst(PartialSpec->getTemplateArgsAsWritten(),
2576                    PartialSpec->getNumTemplateArgsAsWritten(),
2577                    InstTemplateArgs, TemplateArgs))
2578    return 0;
2579
2580  // Check that the template argument list is well-formed for this
2581  // class template.
2582  SmallVector<TemplateArgument, 4> Converted;
2583  if (SemaRef.CheckTemplateArgumentList(VarTemplate, PartialSpec->getLocation(),
2584                                        InstTemplateArgs, false, Converted))
2585    return 0;
2586
2587  // Figure out where to insert this variable template partial specialization
2588  // in the member template's set of variable template partial specializations.
2589  void *InsertPos = 0;
2590  VarTemplateSpecializationDecl *PrevDecl =
2591      VarTemplate->findPartialSpecialization(Converted.data(), Converted.size(),
2592                                             InsertPos);
2593
2594  // Build the canonical type that describes the converted template
2595  // arguments of the variable template partial specialization.
2596  QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
2597      TemplateName(VarTemplate), Converted.data(), Converted.size());
2598
2599  // Build the fully-sugared type for this variable template
2600  // specialization as the user wrote in the specialization
2601  // itself. This means that we'll pretty-print the type retrieved
2602  // from the specialization's declaration the way that the user
2603  // actually wrote the specialization, rather than formatting the
2604  // name based on the "canonical" representation used to store the
2605  // template arguments in the specialization.
2606  TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
2607      TemplateName(VarTemplate), PartialSpec->getLocation(), InstTemplateArgs,
2608      CanonType);
2609
2610  if (PrevDecl) {
2611    // We've already seen a partial specialization with the same template
2612    // parameters and template arguments. This can happen, for example, when
2613    // substituting the outer template arguments ends up causing two
2614    // variable template partial specializations of a member variable template
2615    // to have identical forms, e.g.,
2616    //
2617    //   template<typename T, typename U>
2618    //   struct Outer {
2619    //     template<typename X, typename Y> pair<X,Y> p;
2620    //     template<typename Y> pair<T, Y> p;
2621    //     template<typename Y> pair<U, Y> p;
2622    //   };
2623    //
2624    //   Outer<int, int> outer; // error: the partial specializations of Inner
2625    //                          // have the same signature.
2626    SemaRef.Diag(PartialSpec->getLocation(),
2627                 diag::err_var_partial_spec_redeclared)
2628        << WrittenTy->getType();
2629    SemaRef.Diag(PrevDecl->getLocation(),
2630                 diag::note_var_prev_partial_spec_here);
2631    return 0;
2632  }
2633
2634  // Do substitution on the type of the declaration
2635  TypeSourceInfo *DI = SemaRef.SubstType(
2636      PartialSpec->getTypeSourceInfo(), TemplateArgs,
2637      PartialSpec->getTypeSpecStartLoc(), PartialSpec->getDeclName());
2638  if (!DI)
2639    return 0;
2640
2641  if (DI->getType()->isFunctionType()) {
2642    SemaRef.Diag(PartialSpec->getLocation(),
2643                 diag::err_variable_instantiates_to_function)
2644        << PartialSpec->isStaticDataMember() << DI->getType();
2645    return 0;
2646  }
2647
2648  // Create the variable template partial specialization declaration.
2649  VarTemplatePartialSpecializationDecl *InstPartialSpec =
2650      VarTemplatePartialSpecializationDecl::Create(
2651          SemaRef.Context, Owner, PartialSpec->getInnerLocStart(),
2652          PartialSpec->getLocation(), InstParams, VarTemplate, DI->getType(),
2653          DI, PartialSpec->getStorageClass(), Converted.data(),
2654          Converted.size(), InstTemplateArgs,
2655          VarTemplate->getNextPartialSpecSequenceNumber());
2656
2657  // Substitute the nested name specifier, if any.
2658  if (SubstQualifier(PartialSpec, InstPartialSpec))
2659    return 0;
2660
2661  InstPartialSpec->setInstantiatedFromMember(PartialSpec);
2662  InstPartialSpec->setTypeAsWritten(WrittenTy);
2663
2664  InstPartialSpec->setAccess(PartialSpec->getAccess());
2665  // FIXME: How much of BuildVariableInstantiation() should go in here?
2666
2667  // Add this partial specialization to the set of variable template partial
2668  // specializations. The instantiation of the initializer is not necessary.
2669  VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/0);
2670  return InstPartialSpec;
2671}
2672
2673TypeSourceInfo*
2674TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D,
2675                              SmallVectorImpl<ParmVarDecl *> &Params) {
2676  TypeSourceInfo *OldTInfo = D->getTypeSourceInfo();
2677  assert(OldTInfo && "substituting function without type source info");
2678  assert(Params.empty() && "parameter vector is non-empty at start");
2679
2680  CXXRecordDecl *ThisContext = 0;
2681  unsigned ThisTypeQuals = 0;
2682  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
2683    ThisContext = cast<CXXRecordDecl>(Owner);
2684    ThisTypeQuals = Method->getTypeQualifiers();
2685  }
2686
2687  TypeSourceInfo *NewTInfo
2688    = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs,
2689                                    D->getTypeSpecStartLoc(),
2690                                    D->getDeclName(),
2691                                    ThisContext, ThisTypeQuals);
2692  if (!NewTInfo)
2693    return 0;
2694
2695  TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
2696  if (FunctionProtoTypeLoc OldProtoLoc = OldTL.getAs<FunctionProtoTypeLoc>()) {
2697    if (NewTInfo != OldTInfo) {
2698      // Get parameters from the new type info.
2699      TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();
2700      FunctionProtoTypeLoc NewProtoLoc = NewTL.castAs<FunctionProtoTypeLoc>();
2701      unsigned NewIdx = 0;
2702      for (unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumArgs();
2703           OldIdx != NumOldParams; ++OldIdx) {
2704        ParmVarDecl *OldParam = OldProtoLoc.getArg(OldIdx);
2705        LocalInstantiationScope *Scope = SemaRef.CurrentInstantiationScope;
2706
2707        Optional<unsigned> NumArgumentsInExpansion;
2708        if (OldParam->isParameterPack())
2709          NumArgumentsInExpansion =
2710              SemaRef.getNumArgumentsInExpansion(OldParam->getType(),
2711                                                 TemplateArgs);
2712        if (!NumArgumentsInExpansion) {
2713          // Simple case: normal parameter, or a parameter pack that's
2714          // instantiated to a (still-dependent) parameter pack.
2715          ParmVarDecl *NewParam = NewProtoLoc.getArg(NewIdx++);
2716          Params.push_back(NewParam);
2717          Scope->InstantiatedLocal(OldParam, NewParam);
2718        } else {
2719          // Parameter pack expansion: make the instantiation an argument pack.
2720          Scope->MakeInstantiatedLocalArgPack(OldParam);
2721          for (unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
2722            ParmVarDecl *NewParam = NewProtoLoc.getArg(NewIdx++);
2723            Params.push_back(NewParam);
2724            Scope->InstantiatedLocalPackArg(OldParam, NewParam);
2725          }
2726        }
2727      }
2728    } else {
2729      // The function type itself was not dependent and therefore no
2730      // substitution occurred. However, we still need to instantiate
2731      // the function parameters themselves.
2732      const FunctionProtoType *OldProto =
2733          cast<FunctionProtoType>(OldProtoLoc.getType());
2734      for (unsigned i = 0, i_end = OldProtoLoc.getNumArgs(); i != i_end; ++i) {
2735        ParmVarDecl *OldParam = OldProtoLoc.getArg(i);
2736        if (!OldParam) {
2737          Params.push_back(SemaRef.BuildParmVarDeclForTypedef(
2738              D, D->getLocation(), OldProto->getArgType(i)));
2739          continue;
2740        }
2741
2742        ParmVarDecl *Parm =
2743            cast_or_null<ParmVarDecl>(VisitParmVarDecl(OldParam));
2744        if (!Parm)
2745          return 0;
2746        Params.push_back(Parm);
2747      }
2748    }
2749  } else {
2750    // If the type of this function, after ignoring parentheses, is not
2751    // *directly* a function type, then we're instantiating a function that
2752    // was declared via a typedef or with attributes, e.g.,
2753    //
2754    //   typedef int functype(int, int);
2755    //   functype func;
2756    //   int __cdecl meth(int, int);
2757    //
2758    // In this case, we'll just go instantiate the ParmVarDecls that we
2759    // synthesized in the method declaration.
2760    SmallVector<QualType, 4> ParamTypes;
2761    if (SemaRef.SubstParmTypes(D->getLocation(), D->param_begin(),
2762                               D->getNumParams(), TemplateArgs, ParamTypes,
2763                               &Params))
2764      return 0;
2765  }
2766
2767  return NewTInfo;
2768}
2769
2770/// Introduce the instantiated function parameters into the local
2771/// instantiation scope, and set the parameter names to those used
2772/// in the template.
2773static void addInstantiatedParametersToScope(Sema &S, FunctionDecl *Function,
2774                                             const FunctionDecl *PatternDecl,
2775                                             LocalInstantiationScope &Scope,
2776                           const MultiLevelTemplateArgumentList &TemplateArgs) {
2777  unsigned FParamIdx = 0;
2778  for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
2779    const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
2780    if (!PatternParam->isParameterPack()) {
2781      // Simple case: not a parameter pack.
2782      assert(FParamIdx < Function->getNumParams());
2783      ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
2784      FunctionParam->setDeclName(PatternParam->getDeclName());
2785      Scope.InstantiatedLocal(PatternParam, FunctionParam);
2786      ++FParamIdx;
2787      continue;
2788    }
2789
2790    // Expand the parameter pack.
2791    Scope.MakeInstantiatedLocalArgPack(PatternParam);
2792    Optional<unsigned> NumArgumentsInExpansion
2793      = S.getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
2794    assert(NumArgumentsInExpansion &&
2795           "should only be called when all template arguments are known");
2796    for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
2797      ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
2798      FunctionParam->setDeclName(PatternParam->getDeclName());
2799      Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
2800      ++FParamIdx;
2801    }
2802  }
2803}
2804
2805static void InstantiateExceptionSpec(Sema &SemaRef, FunctionDecl *New,
2806                                     const FunctionProtoType *Proto,
2807                           const MultiLevelTemplateArgumentList &TemplateArgs) {
2808  assert(Proto->getExceptionSpecType() != EST_Uninstantiated);
2809
2810  // C++11 [expr.prim.general]p3:
2811  //   If a declaration declares a member function or member function
2812  //   template of a class X, the expression this is a prvalue of type
2813  //   "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
2814  //   and the end of the function-definition, member-declarator, or
2815  //   declarator.
2816  CXXRecordDecl *ThisContext = 0;
2817  unsigned ThisTypeQuals = 0;
2818  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(New)) {
2819    ThisContext = Method->getParent();
2820    ThisTypeQuals = Method->getTypeQualifiers();
2821  }
2822  Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals,
2823                                   SemaRef.getLangOpts().CPlusPlus11);
2824
2825  // The function has an exception specification or a "noreturn"
2826  // attribute. Substitute into each of the exception types.
2827  SmallVector<QualType, 4> Exceptions;
2828  for (unsigned I = 0, N = Proto->getNumExceptions(); I != N; ++I) {
2829    // FIXME: Poor location information!
2830    if (const PackExpansionType *PackExpansion
2831          = Proto->getExceptionType(I)->getAs<PackExpansionType>()) {
2832      // We have a pack expansion. Instantiate it.
2833      SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2834      SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
2835                                              Unexpanded);
2836      assert(!Unexpanded.empty() &&
2837             "Pack expansion without parameter packs?");
2838
2839      bool Expand = false;
2840      bool RetainExpansion = false;
2841      Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
2842      if (SemaRef.CheckParameterPacksForExpansion(New->getLocation(),
2843                                                  SourceRange(),
2844                                                  Unexpanded,
2845                                                  TemplateArgs,
2846                                                  Expand,
2847                                                  RetainExpansion,
2848                                                  NumExpansions))
2849        break;
2850
2851      if (!Expand) {
2852        // We can't expand this pack expansion into separate arguments yet;
2853        // just substitute into the pattern and create a new pack expansion
2854        // type.
2855        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2856        QualType T = SemaRef.SubstType(PackExpansion->getPattern(),
2857                                       TemplateArgs,
2858                                     New->getLocation(), New->getDeclName());
2859        if (T.isNull())
2860          break;
2861
2862        T = SemaRef.Context.getPackExpansionType(T, NumExpansions);
2863        Exceptions.push_back(T);
2864        continue;
2865      }
2866
2867      // Substitute into the pack expansion pattern for each template
2868      bool Invalid = false;
2869      for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
2870        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, ArgIdx);
2871
2872        QualType T = SemaRef.SubstType(PackExpansion->getPattern(),
2873                                       TemplateArgs,
2874                                     New->getLocation(), New->getDeclName());
2875        if (T.isNull()) {
2876          Invalid = true;
2877          break;
2878        }
2879
2880        Exceptions.push_back(T);
2881      }
2882
2883      if (Invalid)
2884        break;
2885
2886      continue;
2887    }
2888
2889    QualType T
2890      = SemaRef.SubstType(Proto->getExceptionType(I), TemplateArgs,
2891                          New->getLocation(), New->getDeclName());
2892    if (T.isNull() ||
2893        SemaRef.CheckSpecifiedExceptionType(T, New->getLocation()))
2894      continue;
2895
2896    Exceptions.push_back(T);
2897  }
2898  Expr *NoexceptExpr = 0;
2899  if (Expr *OldNoexceptExpr = Proto->getNoexceptExpr()) {
2900    EnterExpressionEvaluationContext Unevaluated(SemaRef,
2901                                                 Sema::ConstantEvaluated);
2902    ExprResult E = SemaRef.SubstExpr(OldNoexceptExpr, TemplateArgs);
2903    if (E.isUsable())
2904      E = SemaRef.CheckBooleanCondition(E.get(), E.get()->getLocStart());
2905
2906    if (E.isUsable()) {
2907      NoexceptExpr = E.take();
2908      if (!NoexceptExpr->isTypeDependent() &&
2909          !NoexceptExpr->isValueDependent())
2910        NoexceptExpr
2911          = SemaRef.VerifyIntegerConstantExpression(NoexceptExpr,
2912              0, diag::err_noexcept_needs_constant_expression,
2913              /*AllowFold*/ false).take();
2914    }
2915  }
2916
2917  // Rebuild the function type
2918  const FunctionProtoType *NewProto
2919    = New->getType()->getAs<FunctionProtoType>();
2920  assert(NewProto && "Template instantiation without function prototype?");
2921
2922  FunctionProtoType::ExtProtoInfo EPI = NewProto->getExtProtoInfo();
2923  EPI.ExceptionSpecType = Proto->getExceptionSpecType();
2924  EPI.NumExceptions = Exceptions.size();
2925  EPI.Exceptions = Exceptions.data();
2926  EPI.NoexceptExpr = NoexceptExpr;
2927
2928  New->setType(SemaRef.Context.getFunctionType(NewProto->getResultType(),
2929                                               NewProto->getArgTypes(), EPI));
2930}
2931
2932void Sema::InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
2933                                    FunctionDecl *Decl) {
2934  const FunctionProtoType *Proto = Decl->getType()->castAs<FunctionProtoType>();
2935  if (Proto->getExceptionSpecType() != EST_Uninstantiated)
2936    return;
2937
2938  InstantiatingTemplate Inst(*this, PointOfInstantiation, Decl,
2939                             InstantiatingTemplate::ExceptionSpecification());
2940  if (Inst) {
2941    // We hit the instantiation depth limit. Clear the exception specification
2942    // so that our callers don't have to cope with EST_Uninstantiated.
2943    FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
2944    EPI.ExceptionSpecType = EST_None;
2945    Decl->setType(Context.getFunctionType(Proto->getResultType(),
2946                                          Proto->getArgTypes(), EPI));
2947    return;
2948  }
2949
2950  // Enter the scope of this instantiation. We don't use
2951  // PushDeclContext because we don't have a scope.
2952  Sema::ContextRAII savedContext(*this, Decl);
2953  LocalInstantiationScope Scope(*this);
2954
2955  MultiLevelTemplateArgumentList TemplateArgs =
2956    getTemplateInstantiationArgs(Decl, 0, /*RelativeToPrimary*/true);
2957
2958  FunctionDecl *Template = Proto->getExceptionSpecTemplate();
2959  addInstantiatedParametersToScope(*this, Decl, Template, Scope, TemplateArgs);
2960
2961  ::InstantiateExceptionSpec(*this, Decl,
2962                             Template->getType()->castAs<FunctionProtoType>(),
2963                             TemplateArgs);
2964}
2965
2966/// \brief Initializes the common fields of an instantiation function
2967/// declaration (New) from the corresponding fields of its template (Tmpl).
2968///
2969/// \returns true if there was an error
2970bool
2971TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New,
2972                                                    FunctionDecl *Tmpl) {
2973  if (Tmpl->isDeleted())
2974    New->setDeletedAsWritten();
2975
2976  // If we are performing substituting explicitly-specified template arguments
2977  // or deduced template arguments into a function template and we reach this
2978  // point, we are now past the point where SFINAE applies and have committed
2979  // to keeping the new function template specialization. We therefore
2980  // convert the active template instantiation for the function template
2981  // into a template instantiation for this specific function template
2982  // specialization, which is not a SFINAE context, so that we diagnose any
2983  // further errors in the declaration itself.
2984  typedef Sema::ActiveTemplateInstantiation ActiveInstType;
2985  ActiveInstType &ActiveInst = SemaRef.ActiveTemplateInstantiations.back();
2986  if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
2987      ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
2988    if (FunctionTemplateDecl *FunTmpl
2989          = dyn_cast<FunctionTemplateDecl>(ActiveInst.Entity)) {
2990      assert(FunTmpl->getTemplatedDecl() == Tmpl &&
2991             "Deduction from the wrong function template?");
2992      (void) FunTmpl;
2993      ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
2994      ActiveInst.Entity = New;
2995    }
2996  }
2997
2998  const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>();
2999  assert(Proto && "Function template without prototype?");
3000
3001  if (Proto->hasExceptionSpec() || Proto->getNoReturnAttr()) {
3002    FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
3003
3004    // DR1330: In C++11, defer instantiation of a non-trivial
3005    // exception specification.
3006    if (SemaRef.getLangOpts().CPlusPlus11 &&
3007        EPI.ExceptionSpecType != EST_None &&
3008        EPI.ExceptionSpecType != EST_DynamicNone &&
3009        EPI.ExceptionSpecType != EST_BasicNoexcept) {
3010      FunctionDecl *ExceptionSpecTemplate = Tmpl;
3011      if (EPI.ExceptionSpecType == EST_Uninstantiated)
3012        ExceptionSpecTemplate = EPI.ExceptionSpecTemplate;
3013      ExceptionSpecificationType NewEST = EST_Uninstantiated;
3014      if (EPI.ExceptionSpecType == EST_Unevaluated)
3015        NewEST = EST_Unevaluated;
3016
3017      // Mark the function has having an uninstantiated exception specification.
3018      const FunctionProtoType *NewProto
3019        = New->getType()->getAs<FunctionProtoType>();
3020      assert(NewProto && "Template instantiation without function prototype?");
3021      EPI = NewProto->getExtProtoInfo();
3022      EPI.ExceptionSpecType = NewEST;
3023      EPI.ExceptionSpecDecl = New;
3024      EPI.ExceptionSpecTemplate = ExceptionSpecTemplate;
3025      New->setType(SemaRef.Context.getFunctionType(
3026          NewProto->getResultType(), NewProto->getArgTypes(), EPI));
3027    } else {
3028      ::InstantiateExceptionSpec(SemaRef, New, Proto, TemplateArgs);
3029    }
3030  }
3031
3032  // Get the definition. Leaves the variable unchanged if undefined.
3033  const FunctionDecl *Definition = Tmpl;
3034  Tmpl->isDefined(Definition);
3035
3036  SemaRef.InstantiateAttrs(TemplateArgs, Definition, New,
3037                           LateAttrs, StartingScope);
3038
3039  return false;
3040}
3041
3042/// \brief Initializes common fields of an instantiated method
3043/// declaration (New) from the corresponding fields of its template
3044/// (Tmpl).
3045///
3046/// \returns true if there was an error
3047bool
3048TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New,
3049                                                  CXXMethodDecl *Tmpl) {
3050  if (InitFunctionInstantiation(New, Tmpl))
3051    return true;
3052
3053  New->setAccess(Tmpl->getAccess());
3054  if (Tmpl->isVirtualAsWritten())
3055    New->setVirtualAsWritten(true);
3056
3057  // FIXME: New needs a pointer to Tmpl
3058  return false;
3059}
3060
3061/// \brief Instantiate the definition of the given function from its
3062/// template.
3063///
3064/// \param PointOfInstantiation the point at which the instantiation was
3065/// required. Note that this is not precisely a "point of instantiation"
3066/// for the function, but it's close.
3067///
3068/// \param Function the already-instantiated declaration of a
3069/// function template specialization or member function of a class template
3070/// specialization.
3071///
3072/// \param Recursive if true, recursively instantiates any functions that
3073/// are required by this instantiation.
3074///
3075/// \param DefinitionRequired if true, then we are performing an explicit
3076/// instantiation where the body of the function is required. Complain if
3077/// there is no such body.
3078void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
3079                                         FunctionDecl *Function,
3080                                         bool Recursive,
3081                                         bool DefinitionRequired) {
3082  if (Function->isInvalidDecl() || Function->isDefined())
3083    return;
3084
3085  // Never instantiate an explicit specialization except if it is a class scope
3086  // explicit specialization.
3087  if (Function->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
3088      !Function->getClassScopeSpecializationPattern())
3089    return;
3090
3091  // Find the function body that we'll be substituting.
3092  const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern();
3093  assert(PatternDecl && "instantiating a non-template");
3094
3095  Stmt *Pattern = PatternDecl->getBody(PatternDecl);
3096  assert(PatternDecl && "template definition is not a template");
3097  if (!Pattern) {
3098    // Try to find a defaulted definition
3099    PatternDecl->isDefined(PatternDecl);
3100  }
3101  assert(PatternDecl && "template definition is not a template");
3102
3103  // Postpone late parsed template instantiations.
3104  if (PatternDecl->isLateTemplateParsed() &&
3105      !LateTemplateParser) {
3106    PendingInstantiations.push_back(
3107      std::make_pair(Function, PointOfInstantiation));
3108    return;
3109  }
3110
3111  // Call the LateTemplateParser callback if there a need to late parse
3112  // a templated function definition.
3113  if (!Pattern && PatternDecl->isLateTemplateParsed() &&
3114      LateTemplateParser) {
3115    LateTemplateParser(OpaqueParser, PatternDecl);
3116    Pattern = PatternDecl->getBody(PatternDecl);
3117  }
3118
3119  if (!Pattern && !PatternDecl->isDefaulted()) {
3120    if (DefinitionRequired) {
3121      if (Function->getPrimaryTemplate())
3122        Diag(PointOfInstantiation,
3123             diag::err_explicit_instantiation_undefined_func_template)
3124          << Function->getPrimaryTemplate();
3125      else
3126        Diag(PointOfInstantiation,
3127             diag::err_explicit_instantiation_undefined_member)
3128          << 1 << Function->getDeclName() << Function->getDeclContext();
3129
3130      if (PatternDecl)
3131        Diag(PatternDecl->getLocation(),
3132             diag::note_explicit_instantiation_here);
3133      Function->setInvalidDecl();
3134    } else if (Function->getTemplateSpecializationKind()
3135                 == TSK_ExplicitInstantiationDefinition) {
3136      PendingInstantiations.push_back(
3137        std::make_pair(Function, PointOfInstantiation));
3138    }
3139
3140    return;
3141  }
3142
3143  // C++1y [temp.explicit]p10:
3144  //   Except for inline functions, declarations with types deduced from their
3145  //   initializer or return value, and class template specializations, other
3146  //   explicit instantiation declarations have the effect of suppressing the
3147  //   implicit instantiation of the entity to which they refer.
3148  if (Function->getTemplateSpecializationKind()
3149        == TSK_ExplicitInstantiationDeclaration &&
3150      !PatternDecl->isInlined() &&
3151      !PatternDecl->getResultType()->isUndeducedType())
3152    return;
3153
3154  if (PatternDecl->isInlined())
3155    Function->setImplicitlyInline();
3156
3157  InstantiatingTemplate Inst(*this, PointOfInstantiation, Function);
3158  if (Inst)
3159    return;
3160
3161  // Copy the inner loc start from the pattern.
3162  Function->setInnerLocStart(PatternDecl->getInnerLocStart());
3163
3164  // If we're performing recursive template instantiation, create our own
3165  // queue of pending implicit instantiations that we will instantiate later,
3166  // while we're still within our own instantiation context.
3167  SmallVector<VTableUse, 16> SavedVTableUses;
3168  std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;
3169  std::deque<PendingImplicitInstantiation>
3170                              SavedPendingLocalImplicitInstantiations;
3171  SavedPendingLocalImplicitInstantiations.swap(
3172                                  PendingLocalImplicitInstantiations);
3173  if (Recursive) {
3174    VTableUses.swap(SavedVTableUses);
3175    PendingInstantiations.swap(SavedPendingInstantiations);
3176  }
3177
3178  EnterExpressionEvaluationContext EvalContext(*this,
3179                                               Sema::PotentiallyEvaluated);
3180
3181  // Introduce a new scope where local variable instantiations will be
3182  // recorded, unless we're actually a member function within a local
3183  // class, in which case we need to merge our results with the parent
3184  // scope (of the enclosing function).
3185  bool MergeWithParentScope = false;
3186  if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext()))
3187    MergeWithParentScope = Rec->isLocalClass();
3188
3189  LocalInstantiationScope Scope(*this, MergeWithParentScope);
3190
3191  if (PatternDecl->isDefaulted())
3192    SetDeclDefaulted(Function, PatternDecl->getLocation());
3193  else {
3194    ActOnStartOfFunctionDef(0, Function);
3195
3196    // Enter the scope of this instantiation. We don't use
3197    // PushDeclContext because we don't have a scope.
3198    Sema::ContextRAII savedContext(*this, Function);
3199
3200    MultiLevelTemplateArgumentList TemplateArgs =
3201      getTemplateInstantiationArgs(Function, 0, false, PatternDecl);
3202
3203    addInstantiatedParametersToScope(*this, Function, PatternDecl, Scope,
3204                                     TemplateArgs);
3205
3206    // If this is a constructor, instantiate the member initializers.
3207    if (const CXXConstructorDecl *Ctor =
3208          dyn_cast<CXXConstructorDecl>(PatternDecl)) {
3209      InstantiateMemInitializers(cast<CXXConstructorDecl>(Function), Ctor,
3210                                 TemplateArgs);
3211    }
3212
3213    // Instantiate the function body.
3214    StmtResult Body = SubstStmt(Pattern, TemplateArgs);
3215
3216    if (Body.isInvalid())
3217      Function->setInvalidDecl();
3218
3219    ActOnFinishFunctionBody(Function, Body.get(),
3220                            /*IsInstantiation=*/true);
3221
3222    PerformDependentDiagnostics(PatternDecl, TemplateArgs);
3223
3224    savedContext.pop();
3225  }
3226
3227  DeclGroupRef DG(Function);
3228  Consumer.HandleTopLevelDecl(DG);
3229
3230  // This class may have local implicit instantiations that need to be
3231  // instantiation within this scope.
3232  PerformPendingInstantiations(/*LocalOnly=*/true);
3233  Scope.Exit();
3234
3235  if (Recursive) {
3236    // Define any pending vtables.
3237    DefineUsedVTables();
3238
3239    // Instantiate any pending implicit instantiations found during the
3240    // instantiation of this template.
3241    PerformPendingInstantiations();
3242
3243    // Restore the set of pending vtables.
3244    assert(VTableUses.empty() &&
3245           "VTableUses should be empty before it is discarded.");
3246    VTableUses.swap(SavedVTableUses);
3247
3248    // Restore the set of pending implicit instantiations.
3249    assert(PendingInstantiations.empty() &&
3250           "PendingInstantiations should be empty before it is discarded.");
3251    PendingInstantiations.swap(SavedPendingInstantiations);
3252  }
3253  SavedPendingLocalImplicitInstantiations.swap(
3254                            PendingLocalImplicitInstantiations);
3255}
3256
3257VarTemplateSpecializationDecl *Sema::BuildVarTemplateInstantiation(
3258    VarTemplateDecl *VarTemplate, VarDecl *FromVar,
3259    const TemplateArgumentList &TemplateArgList,
3260    const TemplateArgumentListInfo &TemplateArgsInfo,
3261    SmallVectorImpl<TemplateArgument> &Converted,
3262    SourceLocation PointOfInstantiation, void *InsertPos,
3263    LateInstantiatedAttrVec *LateAttrs,
3264    LocalInstantiationScope *StartingScope) {
3265  if (FromVar->isInvalidDecl())
3266    return 0;
3267
3268  InstantiatingTemplate Inst(*this, PointOfInstantiation, FromVar);
3269  if (Inst)
3270    return 0;
3271
3272  MultiLevelTemplateArgumentList TemplateArgLists;
3273  TemplateArgLists.addOuterTemplateArguments(&TemplateArgList);
3274
3275  TemplateDeclInstantiator Instantiator(
3276      *this, VarTemplate->getDeclContext(),
3277      MultiLevelTemplateArgumentList(TemplateArgList));
3278
3279  // TODO: Set LateAttrs and StartingScope ...
3280
3281  return cast_or_null<VarTemplateSpecializationDecl>(
3282      Instantiator.VisitVarTemplateSpecializationDecl(
3283          VarTemplate, FromVar, InsertPos, TemplateArgsInfo, Converted));
3284}
3285
3286/// \brief Instantiates a variable template specialization by completing it
3287/// with appropriate type information and initializer.
3288VarTemplateSpecializationDecl *Sema::CompleteVarTemplateSpecializationDecl(
3289    VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
3290    const MultiLevelTemplateArgumentList &TemplateArgs) {
3291
3292  // Do substitution on the type of the declaration
3293  TypeSourceInfo *DI =
3294      SubstType(PatternDecl->getTypeSourceInfo(), TemplateArgs,
3295                PatternDecl->getTypeSpecStartLoc(), PatternDecl->getDeclName());
3296  if (!DI)
3297    return 0;
3298
3299  // Update the type of this variable template specialization.
3300  VarSpec->setType(DI->getType());
3301
3302  // Instantiate the initializer.
3303  InstantiateVariableInitializer(VarSpec, PatternDecl, TemplateArgs);
3304
3305  return VarSpec;
3306}
3307
3308/// BuildVariableInstantiation - Used after a new variable has been created.
3309/// Sets basic variable data and decides whether to postpone the
3310/// variable instantiation.
3311void Sema::BuildVariableInstantiation(
3312    VarDecl *NewVar, VarDecl *OldVar,
3313    const MultiLevelTemplateArgumentList &TemplateArgs,
3314    LateInstantiatedAttrVec *LateAttrs,
3315    LocalInstantiationScope *StartingScope,
3316    bool ForVarTemplate) {
3317
3318  // If we are instantiating a static data member defined
3319  // out-of-line, the instantiation will have the same lexical
3320  // context (which will be a namespace scope) as the template.
3321  if (OldVar->isOutOfLine())
3322    NewVar->setLexicalDeclContext(OldVar->getLexicalDeclContext());
3323  NewVar->setTSCSpec(OldVar->getTSCSpec());
3324  NewVar->setInitStyle(OldVar->getInitStyle());
3325  NewVar->setCXXForRangeDecl(OldVar->isCXXForRangeDecl());
3326  NewVar->setConstexpr(OldVar->isConstexpr());
3327  NewVar->setAccess(OldVar->getAccess());
3328
3329  if (!OldVar->isStaticDataMember()) {
3330    NewVar->setUsed(OldVar->isUsed(false));
3331    NewVar->setReferenced(OldVar->isReferenced());
3332  }
3333
3334  InstantiateAttrs(TemplateArgs, OldVar, NewVar, LateAttrs, StartingScope);
3335
3336  if (NewVar->hasAttrs())
3337    CheckAlignasUnderalignment(NewVar);
3338
3339  // FIXME: In theory, we could have a previous declaration for variables that
3340  // are not static data members.
3341  // FIXME: having to fake up a LookupResult is dumb.
3342  LookupResult Previous(*this, NewVar->getDeclName(), NewVar->getLocation(),
3343                        Sema::LookupOrdinaryName, Sema::ForRedeclaration);
3344
3345  if (!isa<VarTemplateSpecializationDecl>(NewVar))
3346    LookupQualifiedName(Previous, NewVar->getDeclContext(), false);
3347
3348  CheckVariableDeclaration(NewVar, Previous);
3349
3350  if (OldVar->isOutOfLine()) {
3351    OldVar->getLexicalDeclContext()->addDecl(NewVar);
3352    if (!ForVarTemplate)
3353      NewVar->getDeclContext()->makeDeclVisibleInContext(NewVar);
3354  } else {
3355    if (!ForVarTemplate)
3356      NewVar->getDeclContext()->addDecl(NewVar);
3357    if (NewVar->getDeclContext()->isFunctionOrMethod())
3358      CurrentInstantiationScope->InstantiatedLocal(OldVar, NewVar);
3359  }
3360
3361  // Link instantiations of static data members back to the template from
3362  // which they were instantiated.
3363  if (NewVar->isStaticDataMember() && !ForVarTemplate)
3364    NewVar->setInstantiationOfStaticDataMember(OldVar,
3365                                               TSK_ImplicitInstantiation);
3366
3367  if (isa<VarTemplateSpecializationDecl>(NewVar)) {
3368    // Do not instantiate the variable just yet.
3369  } else
3370    InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
3371
3372  // Diagnose unused local variables with dependent types, where the diagnostic
3373  // will have been deferred.
3374  if (!NewVar->isInvalidDecl() &&
3375      NewVar->getDeclContext()->isFunctionOrMethod() && !NewVar->isUsed() &&
3376      OldVar->getType()->isDependentType())
3377    DiagnoseUnusedDecl(NewVar);
3378}
3379
3380/// \brief Instantiate the initializer of a variable.
3381void Sema::InstantiateVariableInitializer(
3382    VarDecl *Var, VarDecl *OldVar,
3383    const MultiLevelTemplateArgumentList &TemplateArgs) {
3384
3385  if (Var->getAnyInitializer())
3386    // We already have an initializer in the class.
3387    return;
3388
3389  if (OldVar->getInit()) {
3390    if (Var->isStaticDataMember() && !OldVar->isOutOfLine())
3391      PushExpressionEvaluationContext(Sema::ConstantEvaluated, OldVar);
3392    else
3393      PushExpressionEvaluationContext(Sema::PotentiallyEvaluated, OldVar);
3394
3395    // Instantiate the initializer.
3396    ExprResult Init =
3397        SubstInitializer(OldVar->getInit(), TemplateArgs,
3398                         OldVar->getInitStyle() == VarDecl::CallInit);
3399    if (!Init.isInvalid()) {
3400      bool TypeMayContainAuto = true;
3401      if (Init.get()) {
3402        bool DirectInit = OldVar->isDirectInit();
3403        AddInitializerToDecl(Var, Init.take(), DirectInit, TypeMayContainAuto);
3404      } else
3405        ActOnUninitializedDecl(Var, TypeMayContainAuto);
3406    } else {
3407      // FIXME: Not too happy about invalidating the declaration
3408      // because of a bogus initializer.
3409      Var->setInvalidDecl();
3410    }
3411
3412    PopExpressionEvaluationContext();
3413  } else if ((!Var->isStaticDataMember() || Var->isOutOfLine()) &&
3414             !Var->isCXXForRangeDecl())
3415    ActOnUninitializedDecl(Var, false);
3416}
3417
3418/// \brief Instantiate the definition of the given variable from its
3419/// template.
3420///
3421/// \param PointOfInstantiation the point at which the instantiation was
3422/// required. Note that this is not precisely a "point of instantiation"
3423/// for the function, but it's close.
3424///
3425/// \param Var the already-instantiated declaration of a static member
3426/// variable of a class template specialization.
3427///
3428/// \param Recursive if true, recursively instantiates any functions that
3429/// are required by this instantiation.
3430///
3431/// \param DefinitionRequired if true, then we are performing an explicit
3432/// instantiation where an out-of-line definition of the member variable
3433/// is required. Complain if there is no such definition.
3434void Sema::InstantiateStaticDataMemberDefinition(
3435                                          SourceLocation PointOfInstantiation,
3436                                                 VarDecl *Var,
3437                                                 bool Recursive,
3438                                                 bool DefinitionRequired) {
3439  InstantiateVariableDefinition(PointOfInstantiation, Var, Recursive,
3440                                DefinitionRequired);
3441}
3442
3443void Sema::InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
3444                                         VarDecl *Var, bool Recursive,
3445                                         bool DefinitionRequired) {
3446
3447  if (Var->isInvalidDecl())
3448    return;
3449
3450  VarTemplateSpecializationDecl *VarSpec =
3451      dyn_cast<VarTemplateSpecializationDecl>(Var);
3452  assert((VarSpec || Var->isStaticDataMember()) &&
3453         "Not a static data member, nor a variable template specialization?");
3454  VarDecl *PatternDecl = 0;
3455
3456  // If this is a variable template specialization, make sure that it is
3457  // non-dependent, then find its instantiation pattern.
3458  if (VarSpec) {
3459    bool InstantiationDependent = false;
3460    assert(!TemplateSpecializationType::anyDependentTemplateArguments(
3461               VarSpec->getTemplateArgsInfo(), InstantiationDependent) &&
3462           "Only instantiate variable template specializations that are "
3463           "not type-dependent");
3464
3465    // Find the variable initialization that we'll be substituting.
3466    assert(VarSpec->getSpecializedTemplate() &&
3467           "Specialization without specialized template?");
3468    llvm::PointerUnion<VarTemplateDecl *,
3469                       VarTemplatePartialSpecializationDecl *> PatternPtr =
3470        VarSpec->getSpecializedTemplateOrPartial();
3471    if (PatternPtr.is<VarTemplatePartialSpecializationDecl *>())
3472      PatternDecl = cast<VarDecl>(
3473          PatternPtr.get<VarTemplatePartialSpecializationDecl *>());
3474    else
3475      PatternDecl = (PatternPtr.get<VarTemplateDecl *>())->getTemplatedDecl();
3476    assert(PatternDecl && "instantiating a non-template");
3477  }
3478
3479  // If this is a static data member, find its out-of-line definition.
3480  VarDecl *Def = Var->getInstantiatedFromStaticDataMember();
3481  if (Var->isStaticDataMember()) {
3482    assert(Def && "This data member was not instantiated from a template?");
3483    assert(Def->isStaticDataMember() && "Not a static data member?");
3484    Def = Def->getOutOfLineDefinition();
3485  }
3486
3487  // If the instantiation pattern does not have an initializer, or if an
3488  // out-of-line definition is not found, we won't perform any instantiation.
3489  // Rather, we rely on the user to instantiate this definition (or provide
3490  // a specialization for it) in another translation unit.
3491  if ((VarSpec && !PatternDecl->getInit()) ||
3492      (!VarSpec && Var->isStaticDataMember() && !Def)) {
3493    if (DefinitionRequired) {
3494      if (!Var->isStaticDataMember()) {
3495        Diag(PointOfInstantiation,
3496             diag::err_explicit_instantiation_undefined_var_template)
3497            << PatternDecl;
3498        Diag(PatternDecl->getLocation(),
3499             diag::note_explicit_instantiation_here);
3500      } else {
3501        Def = Var->getInstantiatedFromStaticDataMember();
3502        Diag(PointOfInstantiation,
3503             diag::err_explicit_instantiation_undefined_member)
3504            << 3 << Var->getDeclName() << Var->getDeclContext();
3505        Diag(Def->getLocation(), diag::note_explicit_instantiation_here);
3506      }
3507      if (VarSpec)
3508        Var->setInvalidDecl();
3509    } else if (Var->getTemplateSpecializationKind()
3510                 == TSK_ExplicitInstantiationDefinition) {
3511      PendingInstantiations.push_back(
3512        std::make_pair(Var, PointOfInstantiation));
3513    }
3514
3515    return;
3516  }
3517
3518  TemplateSpecializationKind TSK = Var->getTemplateSpecializationKind();
3519
3520  // Never instantiate an explicit specialization.
3521  if (TSK == TSK_ExplicitSpecialization)
3522    return;
3523
3524  // C++0x [temp.explicit]p9:
3525  //   Except for inline functions, other explicit instantiation declarations
3526  //   have the effect of suppressing the implicit instantiation of the entity
3527  //   to which they refer.
3528  //
3529  // C++11 [temp.explicit]p10:
3530  //   Except for inline functions, [...] explicit instantiation declarations
3531  //   have the effect of suppressing the implicit instantiation of the entity
3532  //   to which they refer.
3533  if (TSK == TSK_ExplicitInstantiationDeclaration)
3534    return;
3535
3536  // Make sure to pass the instantiated variable to the consumer at the end.
3537  struct PassToConsumerRAII {
3538    ASTConsumer &Consumer;
3539    VarDecl *Var;
3540
3541    PassToConsumerRAII(ASTConsumer &Consumer, VarDecl *Var)
3542      : Consumer(Consumer), Var(Var) { }
3543
3544    ~PassToConsumerRAII() {
3545      if (Var->isStaticDataMember())
3546        Consumer.HandleCXXStaticMemberVarInstantiation(Var);
3547      else {
3548        DeclGroupRef DG(Var);
3549        Consumer.HandleTopLevelDecl(DG);
3550      }
3551    }
3552  } PassToConsumerRAII(Consumer, Var);
3553
3554  if (!VarSpec) {
3555    // If we already have a definition, we're done.
3556    if (VarDecl *Def = Var->getDefinition()) {
3557      // We may be explicitly instantiating something we've already implicitly
3558      // instantiated.
3559      Def->setTemplateSpecializationKind(Var->getTemplateSpecializationKind(),
3560                                         PointOfInstantiation);
3561      return;
3562    }
3563  }
3564
3565  InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
3566  if (Inst)
3567    return;
3568
3569  // If we're performing recursive template instantiation, create our own
3570  // queue of pending implicit instantiations that we will instantiate later,
3571  // while we're still within our own instantiation context.
3572  SmallVector<VTableUse, 16> SavedVTableUses;
3573  std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;
3574  if (Recursive) {
3575    VTableUses.swap(SavedVTableUses);
3576    PendingInstantiations.swap(SavedPendingInstantiations);
3577  }
3578
3579  // Enter the scope of this instantiation. We don't use
3580  // PushDeclContext because we don't have a scope.
3581  ContextRAII PreviousContext(*this, Var->getDeclContext());
3582  LocalInstantiationScope Local(*this);
3583
3584  VarDecl *OldVar = Var;
3585  if (!VarSpec)
3586    Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(),
3587                                          getTemplateInstantiationArgs(Var)));
3588  else
3589    // Construct a VarTemplateSpecializationDecl to avoid name clashing with
3590    // the primary template. (Note that unlike function declarations, variable
3591    // declarations cannot be overloaded.)
3592    // In fact, there is no need to construct a new declaration from scratch.
3593    // Thus, simply complete its definition with an appropriately substituted
3594    // type and initializer.
3595    Var = CompleteVarTemplateSpecializationDecl(
3596        VarSpec, PatternDecl, getTemplateInstantiationArgs(Var));
3597
3598  PreviousContext.pop();
3599
3600  if (Var) {
3601    MemberSpecializationInfo *MSInfo = OldVar->getMemberSpecializationInfo();
3602    if (!VarSpec)
3603      assert(MSInfo && "Missing member specialization information?");
3604
3605    PassToConsumerRAII.Var = Var;
3606    if (MSInfo)
3607      Var->setTemplateSpecializationKind(
3608          MSInfo->getTemplateSpecializationKind(),
3609          MSInfo->getPointOfInstantiation());
3610  }
3611
3612  // This variable may have local implicit instantiations that need to be
3613  // instantiated within this scope.
3614  PerformPendingInstantiations(/*LocalOnly=*/true);
3615
3616  Local.Exit();
3617
3618  if (Recursive) {
3619    // Define any newly required vtables.
3620    DefineUsedVTables();
3621
3622    // Instantiate any pending implicit instantiations found during the
3623    // instantiation of this template.
3624    PerformPendingInstantiations();
3625
3626    // Restore the set of pending vtables.
3627    assert(VTableUses.empty() &&
3628           "VTableUses should be empty before it is discarded.");
3629    VTableUses.swap(SavedVTableUses);
3630
3631    // Restore the set of pending implicit instantiations.
3632    assert(PendingInstantiations.empty() &&
3633           "PendingInstantiations should be empty before it is discarded.");
3634    PendingInstantiations.swap(SavedPendingInstantiations);
3635  }
3636}
3637
3638void
3639Sema::InstantiateMemInitializers(CXXConstructorDecl *New,
3640                                 const CXXConstructorDecl *Tmpl,
3641                           const MultiLevelTemplateArgumentList &TemplateArgs) {
3642
3643  SmallVector<CXXCtorInitializer*, 4> NewInits;
3644  bool AnyErrors = Tmpl->isInvalidDecl();
3645
3646  // Instantiate all the initializers.
3647  for (CXXConstructorDecl::init_const_iterator Inits = Tmpl->init_begin(),
3648                                            InitsEnd = Tmpl->init_end();
3649       Inits != InitsEnd; ++Inits) {
3650    CXXCtorInitializer *Init = *Inits;
3651
3652    // Only instantiate written initializers, let Sema re-construct implicit
3653    // ones.
3654    if (!Init->isWritten())
3655      continue;
3656
3657    SourceLocation EllipsisLoc;
3658
3659    if (Init->isPackExpansion()) {
3660      // This is a pack expansion. We should expand it now.
3661      TypeLoc BaseTL = Init->getTypeSourceInfo()->getTypeLoc();
3662      SmallVector<UnexpandedParameterPack, 4> Unexpanded;
3663      collectUnexpandedParameterPacks(BaseTL, Unexpanded);
3664      collectUnexpandedParameterPacks(Init->getInit(), Unexpanded);
3665      bool ShouldExpand = false;
3666      bool RetainExpansion = false;
3667      Optional<unsigned> NumExpansions;
3668      if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(),
3669                                          BaseTL.getSourceRange(),
3670                                          Unexpanded,
3671                                          TemplateArgs, ShouldExpand,
3672                                          RetainExpansion,
3673                                          NumExpansions)) {
3674        AnyErrors = true;
3675        New->setInvalidDecl();
3676        continue;
3677      }
3678      assert(ShouldExpand && "Partial instantiation of base initializer?");
3679
3680      // Loop over all of the arguments in the argument pack(s),
3681      for (unsigned I = 0; I != *NumExpansions; ++I) {
3682        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
3683
3684        // Instantiate the initializer.
3685        ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
3686                                               /*CXXDirectInit=*/true);
3687        if (TempInit.isInvalid()) {
3688          AnyErrors = true;
3689          break;
3690        }
3691
3692        // Instantiate the base type.
3693        TypeSourceInfo *BaseTInfo = SubstType(Init->getTypeSourceInfo(),
3694                                              TemplateArgs,
3695                                              Init->getSourceLocation(),
3696                                              New->getDeclName());
3697        if (!BaseTInfo) {
3698          AnyErrors = true;
3699          break;
3700        }
3701
3702        // Build the initializer.
3703        MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(),
3704                                                     BaseTInfo, TempInit.take(),
3705                                                     New->getParent(),
3706                                                     SourceLocation());
3707        if (NewInit.isInvalid()) {
3708          AnyErrors = true;
3709          break;
3710        }
3711
3712        NewInits.push_back(NewInit.get());
3713      }
3714
3715      continue;
3716    }
3717
3718    // Instantiate the initializer.
3719    ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
3720                                           /*CXXDirectInit=*/true);
3721    if (TempInit.isInvalid()) {
3722      AnyErrors = true;
3723      continue;
3724    }
3725
3726    MemInitResult NewInit;
3727    if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) {
3728      TypeSourceInfo *TInfo = SubstType(Init->getTypeSourceInfo(),
3729                                        TemplateArgs,
3730                                        Init->getSourceLocation(),
3731                                        New->getDeclName());
3732      if (!TInfo) {
3733        AnyErrors = true;
3734        New->setInvalidDecl();
3735        continue;
3736      }
3737
3738      if (Init->isBaseInitializer())
3739        NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.take(),
3740                                       New->getParent(), EllipsisLoc);
3741      else
3742        NewInit = BuildDelegatingInitializer(TInfo, TempInit.take(),
3743                                  cast<CXXRecordDecl>(CurContext->getParent()));
3744    } else if (Init->isMemberInitializer()) {
3745      FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl(
3746                                                     Init->getMemberLocation(),
3747                                                     Init->getMember(),
3748                                                     TemplateArgs));
3749      if (!Member) {
3750        AnyErrors = true;
3751        New->setInvalidDecl();
3752        continue;
3753      }
3754
3755      NewInit = BuildMemberInitializer(Member, TempInit.take(),
3756                                       Init->getSourceLocation());
3757    } else if (Init->isIndirectMemberInitializer()) {
3758      IndirectFieldDecl *IndirectMember =
3759         cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl(
3760                                 Init->getMemberLocation(),
3761                                 Init->getIndirectMember(), TemplateArgs));
3762
3763      if (!IndirectMember) {
3764        AnyErrors = true;
3765        New->setInvalidDecl();
3766        continue;
3767      }
3768
3769      NewInit = BuildMemberInitializer(IndirectMember, TempInit.take(),
3770                                       Init->getSourceLocation());
3771    }
3772
3773    if (NewInit.isInvalid()) {
3774      AnyErrors = true;
3775      New->setInvalidDecl();
3776    } else {
3777      NewInits.push_back(NewInit.get());
3778    }
3779  }
3780
3781  // Assign all the initializers to the new constructor.
3782  ActOnMemInitializers(New,
3783                       /*FIXME: ColonLoc */
3784                       SourceLocation(),
3785                       NewInits,
3786                       AnyErrors);
3787}
3788
3789// TODO: this could be templated if the various decl types used the
3790// same method name.
3791static bool isInstantiationOf(ClassTemplateDecl *Pattern,
3792                              ClassTemplateDecl *Instance) {
3793  Pattern = Pattern->getCanonicalDecl();
3794
3795  do {
3796    Instance = Instance->getCanonicalDecl();
3797    if (Pattern == Instance) return true;
3798    Instance = Instance->getInstantiatedFromMemberTemplate();
3799  } while (Instance);
3800
3801  return false;
3802}
3803
3804static bool isInstantiationOf(FunctionTemplateDecl *Pattern,
3805                              FunctionTemplateDecl *Instance) {
3806  Pattern = Pattern->getCanonicalDecl();
3807
3808  do {
3809    Instance = Instance->getCanonicalDecl();
3810    if (Pattern == Instance) return true;
3811    Instance = Instance->getInstantiatedFromMemberTemplate();
3812  } while (Instance);
3813
3814  return false;
3815}
3816
3817static bool
3818isInstantiationOf(ClassTemplatePartialSpecializationDecl *Pattern,
3819                  ClassTemplatePartialSpecializationDecl *Instance) {
3820  Pattern
3821    = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl());
3822  do {
3823    Instance = cast<ClassTemplatePartialSpecializationDecl>(
3824                                                Instance->getCanonicalDecl());
3825    if (Pattern == Instance)
3826      return true;
3827    Instance = Instance->getInstantiatedFromMember();
3828  } while (Instance);
3829
3830  return false;
3831}
3832
3833static bool isInstantiationOf(CXXRecordDecl *Pattern,
3834                              CXXRecordDecl *Instance) {
3835  Pattern = Pattern->getCanonicalDecl();
3836
3837  do {
3838    Instance = Instance->getCanonicalDecl();
3839    if (Pattern == Instance) return true;
3840    Instance = Instance->getInstantiatedFromMemberClass();
3841  } while (Instance);
3842
3843  return false;
3844}
3845
3846static bool isInstantiationOf(FunctionDecl *Pattern,
3847                              FunctionDecl *Instance) {
3848  Pattern = Pattern->getCanonicalDecl();
3849
3850  do {
3851    Instance = Instance->getCanonicalDecl();
3852    if (Pattern == Instance) return true;
3853    Instance = Instance->getInstantiatedFromMemberFunction();
3854  } while (Instance);
3855
3856  return false;
3857}
3858
3859static bool isInstantiationOf(EnumDecl *Pattern,
3860                              EnumDecl *Instance) {
3861  Pattern = Pattern->getCanonicalDecl();
3862
3863  do {
3864    Instance = Instance->getCanonicalDecl();
3865    if (Pattern == Instance) return true;
3866    Instance = Instance->getInstantiatedFromMemberEnum();
3867  } while (Instance);
3868
3869  return false;
3870}
3871
3872static bool isInstantiationOf(UsingShadowDecl *Pattern,
3873                              UsingShadowDecl *Instance,
3874                              ASTContext &C) {
3875  return C.getInstantiatedFromUsingShadowDecl(Instance) == Pattern;
3876}
3877
3878static bool isInstantiationOf(UsingDecl *Pattern,
3879                              UsingDecl *Instance,
3880                              ASTContext &C) {
3881  return C.getInstantiatedFromUsingDecl(Instance) == Pattern;
3882}
3883
3884static bool isInstantiationOf(UnresolvedUsingValueDecl *Pattern,
3885                              UsingDecl *Instance,
3886                              ASTContext &C) {
3887  return C.getInstantiatedFromUsingDecl(Instance) == Pattern;
3888}
3889
3890static bool isInstantiationOf(UnresolvedUsingTypenameDecl *Pattern,
3891                              UsingDecl *Instance,
3892                              ASTContext &C) {
3893  return C.getInstantiatedFromUsingDecl(Instance) == Pattern;
3894}
3895
3896static bool isInstantiationOfStaticDataMember(VarDecl *Pattern,
3897                                              VarDecl *Instance) {
3898  assert(Instance->isStaticDataMember());
3899
3900  Pattern = Pattern->getCanonicalDecl();
3901
3902  do {
3903    Instance = Instance->getCanonicalDecl();
3904    if (Pattern == Instance) return true;
3905    Instance = Instance->getInstantiatedFromStaticDataMember();
3906  } while (Instance);
3907
3908  return false;
3909}
3910
3911// Other is the prospective instantiation
3912// D is the prospective pattern
3913static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) {
3914  if (D->getKind() != Other->getKind()) {
3915    if (UnresolvedUsingTypenameDecl *UUD
3916          = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
3917      if (UsingDecl *UD = dyn_cast<UsingDecl>(Other)) {
3918        return isInstantiationOf(UUD, UD, Ctx);
3919      }
3920    }
3921
3922    if (UnresolvedUsingValueDecl *UUD
3923          = dyn_cast<UnresolvedUsingValueDecl>(D)) {
3924      if (UsingDecl *UD = dyn_cast<UsingDecl>(Other)) {
3925        return isInstantiationOf(UUD, UD, Ctx);
3926      }
3927    }
3928
3929    return false;
3930  }
3931
3932  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Other))
3933    return isInstantiationOf(cast<CXXRecordDecl>(D), Record);
3934
3935  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Other))
3936    return isInstantiationOf(cast<FunctionDecl>(D), Function);
3937
3938  if (EnumDecl *Enum = dyn_cast<EnumDecl>(Other))
3939    return isInstantiationOf(cast<EnumDecl>(D), Enum);
3940
3941  if (VarDecl *Var = dyn_cast<VarDecl>(Other))
3942    if (Var->isStaticDataMember())
3943      return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var);
3944
3945  if (ClassTemplateDecl *Temp = dyn_cast<ClassTemplateDecl>(Other))
3946    return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp);
3947
3948  if (FunctionTemplateDecl *Temp = dyn_cast<FunctionTemplateDecl>(Other))
3949    return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp);
3950
3951  if (ClassTemplatePartialSpecializationDecl *PartialSpec
3952        = dyn_cast<ClassTemplatePartialSpecializationDecl>(Other))
3953    return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D),
3954                             PartialSpec);
3955
3956  if (FieldDecl *Field = dyn_cast<FieldDecl>(Other)) {
3957    if (!Field->getDeclName()) {
3958      // This is an unnamed field.
3959      return Ctx.getInstantiatedFromUnnamedFieldDecl(Field) ==
3960        cast<FieldDecl>(D);
3961    }
3962  }
3963
3964  if (UsingDecl *Using = dyn_cast<UsingDecl>(Other))
3965    return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx);
3966
3967  if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(Other))
3968    return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx);
3969
3970  return D->getDeclName() && isa<NamedDecl>(Other) &&
3971    D->getDeclName() == cast<NamedDecl>(Other)->getDeclName();
3972}
3973
3974template<typename ForwardIterator>
3975static NamedDecl *findInstantiationOf(ASTContext &Ctx,
3976                                      NamedDecl *D,
3977                                      ForwardIterator first,
3978                                      ForwardIterator last) {
3979  for (; first != last; ++first)
3980    if (isInstantiationOf(Ctx, D, *first))
3981      return cast<NamedDecl>(*first);
3982
3983  return 0;
3984}
3985
3986/// \brief Finds the instantiation of the given declaration context
3987/// within the current instantiation.
3988///
3989/// \returns NULL if there was an error
3990DeclContext *Sema::FindInstantiatedContext(SourceLocation Loc, DeclContext* DC,
3991                          const MultiLevelTemplateArgumentList &TemplateArgs) {
3992  if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
3993    Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs);
3994    return cast_or_null<DeclContext>(ID);
3995  } else return DC;
3996}
3997
3998/// \brief Find the instantiation of the given declaration within the
3999/// current instantiation.
4000///
4001/// This routine is intended to be used when \p D is a declaration
4002/// referenced from within a template, that needs to mapped into the
4003/// corresponding declaration within an instantiation. For example,
4004/// given:
4005///
4006/// \code
4007/// template<typename T>
4008/// struct X {
4009///   enum Kind {
4010///     KnownValue = sizeof(T)
4011///   };
4012///
4013///   bool getKind() const { return KnownValue; }
4014/// };
4015///
4016/// template struct X<int>;
4017/// \endcode
4018///
4019/// In the instantiation of <tt>X<int>::getKind()</tt>, we need to map the
4020/// \p EnumConstantDecl for \p KnownValue (which refers to
4021/// <tt>X<T>::<Kind>::KnownValue</tt>) to its instantiation
4022/// (<tt>X<int>::<Kind>::KnownValue</tt>). \p FindInstantiatedDecl performs
4023/// this mapping from within the instantiation of <tt>X<int></tt>.
4024NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
4025                          const MultiLevelTemplateArgumentList &TemplateArgs) {
4026  DeclContext *ParentDC = D->getDeclContext();
4027  if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
4028      isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
4029      (ParentDC->isFunctionOrMethod() && ParentDC->isDependentContext()) ||
4030      (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda())) {
4031    // D is a local of some kind. Look into the map of local
4032    // declarations to their instantiations.
4033    typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
4034    llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
4035      = CurrentInstantiationScope->findInstantiationOf(D);
4036
4037    if (Found) {
4038      if (Decl *FD = Found->dyn_cast<Decl *>())
4039        return cast<NamedDecl>(FD);
4040
4041      int PackIdx = ArgumentPackSubstitutionIndex;
4042      assert(PackIdx != -1 && "found declaration pack but not pack expanding");
4043      return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]);
4044    }
4045
4046    // If we're performing a partial substitution during template argument
4047    // deduction, we may not have values for template parameters yet. They
4048    // just map to themselves.
4049    if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
4050        isa<TemplateTemplateParmDecl>(D))
4051      return D;
4052
4053    // If we didn't find the decl, then we must have a label decl that hasn't
4054    // been found yet.  Lazily instantiate it and return it now.
4055    assert(isa<LabelDecl>(D));
4056
4057    Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
4058    assert(Inst && "Failed to instantiate label??");
4059
4060    CurrentInstantiationScope->InstantiatedLocal(D, Inst);
4061    return cast<LabelDecl>(Inst);
4062  }
4063
4064  // For variable template specializations, update those that are still
4065  // type-dependent.
4066  if (VarTemplateSpecializationDecl *VarSpec =
4067          dyn_cast<VarTemplateSpecializationDecl>(D)) {
4068    bool InstantiationDependent = false;
4069    const TemplateArgumentListInfo &VarTemplateArgs =
4070        VarSpec->getTemplateArgsInfo();
4071    if (TemplateSpecializationType::anyDependentTemplateArguments(
4072            VarTemplateArgs, InstantiationDependent))
4073      D = cast<NamedDecl>(
4074          SubstDecl(D, VarSpec->getDeclContext(), TemplateArgs));
4075    return D;
4076  }
4077
4078  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
4079    if (!Record->isDependentContext())
4080      return D;
4081
4082    // Determine whether this record is the "templated" declaration describing
4083    // a class template or class template partial specialization.
4084    ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate();
4085    if (ClassTemplate)
4086      ClassTemplate = ClassTemplate->getCanonicalDecl();
4087    else if (ClassTemplatePartialSpecializationDecl *PartialSpec
4088               = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record))
4089      ClassTemplate = PartialSpec->getSpecializedTemplate()->getCanonicalDecl();
4090
4091    // Walk the current context to find either the record or an instantiation of
4092    // it.
4093    DeclContext *DC = CurContext;
4094    while (!DC->isFileContext()) {
4095      // If we're performing substitution while we're inside the template
4096      // definition, we'll find our own context. We're done.
4097      if (DC->Equals(Record))
4098        return Record;
4099
4100      if (CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) {
4101        // Check whether we're in the process of instantiating a class template
4102        // specialization of the template we're mapping.
4103        if (ClassTemplateSpecializationDecl *InstSpec
4104                      = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){
4105          ClassTemplateDecl *SpecTemplate = InstSpec->getSpecializedTemplate();
4106          if (ClassTemplate && isInstantiationOf(ClassTemplate, SpecTemplate))
4107            return InstRecord;
4108        }
4109
4110        // Check whether we're in the process of instantiating a member class.
4111        if (isInstantiationOf(Record, InstRecord))
4112          return InstRecord;
4113      }
4114
4115      // Move to the outer template scope.
4116      if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) {
4117        if (FD->getFriendObjectKind() && FD->getDeclContext()->isFileContext()){
4118          DC = FD->getLexicalDeclContext();
4119          continue;
4120        }
4121      }
4122
4123      DC = DC->getParent();
4124    }
4125
4126    // Fall through to deal with other dependent record types (e.g.,
4127    // anonymous unions in class templates).
4128  }
4129
4130  if (!ParentDC->isDependentContext())
4131    return D;
4132
4133  ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs);
4134  if (!ParentDC)
4135    return 0;
4136
4137  if (ParentDC != D->getDeclContext()) {
4138    // We performed some kind of instantiation in the parent context,
4139    // so now we need to look into the instantiated parent context to
4140    // find the instantiation of the declaration D.
4141
4142    // If our context used to be dependent, we may need to instantiate
4143    // it before performing lookup into that context.
4144    bool IsBeingInstantiated = false;
4145    if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
4146      if (!Spec->isDependentContext()) {
4147        QualType T = Context.getTypeDeclType(Spec);
4148        const RecordType *Tag = T->getAs<RecordType>();
4149        assert(Tag && "type of non-dependent record is not a RecordType");
4150        if (Tag->isBeingDefined())
4151          IsBeingInstantiated = true;
4152        if (!Tag->isBeingDefined() &&
4153            RequireCompleteType(Loc, T, diag::err_incomplete_type))
4154          return 0;
4155
4156        ParentDC = Tag->getDecl();
4157      }
4158    }
4159
4160    NamedDecl *Result = 0;
4161    if (D->getDeclName()) {
4162      DeclContext::lookup_result Found = ParentDC->lookup(D->getDeclName());
4163      Result = findInstantiationOf(Context, D, Found.begin(), Found.end());
4164    } else {
4165      // Since we don't have a name for the entity we're looking for,
4166      // our only option is to walk through all of the declarations to
4167      // find that name. This will occur in a few cases:
4168      //
4169      //   - anonymous struct/union within a template
4170      //   - unnamed class/struct/union/enum within a template
4171      //
4172      // FIXME: Find a better way to find these instantiations!
4173      Result = findInstantiationOf(Context, D,
4174                                   ParentDC->decls_begin(),
4175                                   ParentDC->decls_end());
4176    }
4177
4178    if (!Result) {
4179      if (isa<UsingShadowDecl>(D)) {
4180        // UsingShadowDecls can instantiate to nothing because of using hiding.
4181      } else if (Diags.hasErrorOccurred()) {
4182        // We've already complained about something, so most likely this
4183        // declaration failed to instantiate. There's no point in complaining
4184        // further, since this is normal in invalid code.
4185      } else if (IsBeingInstantiated) {
4186        // The class in which this member exists is currently being
4187        // instantiated, and we haven't gotten around to instantiating this
4188        // member yet. This can happen when the code uses forward declarations
4189        // of member classes, and introduces ordering dependencies via
4190        // template instantiation.
4191        Diag(Loc, diag::err_member_not_yet_instantiated)
4192          << D->getDeclName()
4193          << Context.getTypeDeclType(cast<CXXRecordDecl>(ParentDC));
4194        Diag(D->getLocation(), diag::note_non_instantiated_member_here);
4195      } else if (EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) {
4196        // This enumeration constant was found when the template was defined,
4197        // but can't be found in the instantiation. This can happen if an
4198        // unscoped enumeration member is explicitly specialized.
4199        EnumDecl *Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
4200        EnumDecl *Spec = cast<EnumDecl>(FindInstantiatedDecl(Loc, Enum,
4201                                                             TemplateArgs));
4202        assert(Spec->getTemplateSpecializationKind() ==
4203                 TSK_ExplicitSpecialization);
4204        Diag(Loc, diag::err_enumerator_does_not_exist)
4205          << D->getDeclName()
4206          << Context.getTypeDeclType(cast<TypeDecl>(Spec->getDeclContext()));
4207        Diag(Spec->getLocation(), diag::note_enum_specialized_here)
4208          << Context.getTypeDeclType(Spec);
4209      } else {
4210        // We should have found something, but didn't.
4211        llvm_unreachable("Unable to find instantiation of declaration!");
4212      }
4213    }
4214
4215    D = Result;
4216  }
4217
4218  return D;
4219}
4220
4221/// \brief Performs template instantiation for all implicit template
4222/// instantiations we have seen until this point.
4223void Sema::PerformPendingInstantiations(bool LocalOnly) {
4224  // Load pending instantiations from the external source.
4225  if (!LocalOnly && ExternalSource) {
4226    SmallVector<PendingImplicitInstantiation, 4> Pending;
4227    ExternalSource->ReadPendingInstantiations(Pending);
4228    PendingInstantiations.insert(PendingInstantiations.begin(),
4229                                 Pending.begin(), Pending.end());
4230  }
4231
4232  while (!PendingLocalImplicitInstantiations.empty() ||
4233         (!LocalOnly && !PendingInstantiations.empty())) {
4234    PendingImplicitInstantiation Inst;
4235
4236    if (PendingLocalImplicitInstantiations.empty()) {
4237      Inst = PendingInstantiations.front();
4238      PendingInstantiations.pop_front();
4239    } else {
4240      Inst = PendingLocalImplicitInstantiations.front();
4241      PendingLocalImplicitInstantiations.pop_front();
4242    }
4243
4244    // Instantiate function definitions
4245    if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) {
4246      PrettyDeclStackTraceEntry CrashInfo(*this, Function, SourceLocation(),
4247                                          "instantiating function definition");
4248      bool DefinitionRequired = Function->getTemplateSpecializationKind() ==
4249                                TSK_ExplicitInstantiationDefinition;
4250      InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true,
4251                                    DefinitionRequired);
4252      continue;
4253    }
4254
4255    // Instantiate variable definitions
4256    VarDecl *Var = cast<VarDecl>(Inst.first);
4257
4258    assert((Var->isStaticDataMember() ||
4259            isa<VarTemplateSpecializationDecl>(Var)) &&
4260           "Not a static data member, nor a variable template"
4261           " specialization?");
4262
4263    // Don't try to instantiate declarations if the most recent redeclaration
4264    // is invalid.
4265    if (Var->getMostRecentDecl()->isInvalidDecl())
4266      continue;
4267
4268    // Check if the most recent declaration has changed the specialization kind
4269    // and removed the need for implicit instantiation.
4270    switch (Var->getMostRecentDecl()->getTemplateSpecializationKind()) {
4271    case TSK_Undeclared:
4272      llvm_unreachable("Cannot instantitiate an undeclared specialization.");
4273    case TSK_ExplicitInstantiationDeclaration:
4274    case TSK_ExplicitSpecialization:
4275      continue;  // No longer need to instantiate this type.
4276    case TSK_ExplicitInstantiationDefinition:
4277      // We only need an instantiation if the pending instantiation *is* the
4278      // explicit instantiation.
4279      if (Var != Var->getMostRecentDecl()) continue;
4280    case TSK_ImplicitInstantiation:
4281      break;
4282    }
4283
4284    PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
4285                                        "instantiating variable definition");
4286    bool DefinitionRequired = Var->getTemplateSpecializationKind() ==
4287                              TSK_ExplicitInstantiationDefinition;
4288
4289    // Instantiate static data member definitions or variable template
4290    // specializations.
4291    InstantiateVariableDefinition(/*FIXME:*/ Inst.second, Var, true,
4292                                  DefinitionRequired);
4293  }
4294}
4295
4296void Sema::PerformDependentDiagnostics(const DeclContext *Pattern,
4297                       const MultiLevelTemplateArgumentList &TemplateArgs) {
4298  for (DeclContext::ddiag_iterator I = Pattern->ddiag_begin(),
4299         E = Pattern->ddiag_end(); I != E; ++I) {
4300    DependentDiagnostic *DD = *I;
4301
4302    switch (DD->getKind()) {
4303    case DependentDiagnostic::Access:
4304      HandleDependentAccessCheck(*DD, TemplateArgs);
4305      break;
4306    }
4307  }
4308}
4309