1193326Sed//===--- SemaTemplateInstantiateDecl.cpp - C++ Template Decl Instantiation ===/ 2193326Sed// 3193326Sed// The LLVM Compiler Infrastructure 4193326Sed// 5193326Sed// This file is distributed under the University of Illinois Open Source 6193326Sed// License. See LICENSE.TXT for details. 7193326Sed//===----------------------------------------------------------------------===/ 8193326Sed// 9193326Sed// This file implements C++ template instantiation for declarations. 10193326Sed// 11193326Sed//===----------------------------------------------------------------------===/ 12212904Sdim#include "clang/Sema/SemaInternal.h" 13193326Sed#include "clang/AST/ASTConsumer.h" 14193326Sed#include "clang/AST/ASTContext.h" 15193326Sed#include "clang/AST/DeclTemplate.h" 16193326Sed#include "clang/AST/DeclVisitor.h" 17206084Srdivacky#include "clang/AST/DependentDiagnostic.h" 18193326Sed#include "clang/AST/Expr.h" 19200583Srdivacky#include "clang/AST/ExprCXX.h" 20205219Srdivacky#include "clang/AST/TypeLoc.h" 21198092Srdivacky#include "clang/Lex/Preprocessor.h" 22249423Sdim#include "clang/Sema/Lookup.h" 23249423Sdim#include "clang/Sema/PrettyDeclStackTrace.h" 24249423Sdim#include "clang/Sema/Template.h" 25193326Sed 26193326Sedusing namespace clang; 27193326Sed 28205219Srdivackybool TemplateDeclInstantiator::SubstQualifier(const DeclaratorDecl *OldDecl, 29205219Srdivacky DeclaratorDecl *NewDecl) { 30219077Sdim if (!OldDecl->getQualifierLoc()) 31219077Sdim return false; 32226633Sdim 33219077Sdim NestedNameSpecifierLoc NewQualifierLoc 34226633Sdim = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(), 35219077Sdim TemplateArgs); 36226633Sdim 37219077Sdim if (!NewQualifierLoc) 38205219Srdivacky return true; 39226633Sdim 40219077Sdim NewDecl->setQualifierInfo(NewQualifierLoc); 41205219Srdivacky return false; 42205219Srdivacky} 43205219Srdivacky 44205219Srdivackybool TemplateDeclInstantiator::SubstQualifier(const TagDecl *OldDecl, 45205219Srdivacky TagDecl *NewDecl) { 46219077Sdim if (!OldDecl->getQualifierLoc()) 47219077Sdim return false; 48226633Sdim 49219077Sdim NestedNameSpecifierLoc NewQualifierLoc 50226633Sdim = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(), 51219077Sdim TemplateArgs); 52226633Sdim 53219077Sdim if (!NewQualifierLoc) 54205219Srdivacky return true; 55226633Sdim 56219077Sdim NewDecl->setQualifierInfo(NewQualifierLoc); 57205219Srdivacky return false; 58205219Srdivacky} 59205219Srdivacky 60234353Sdim// Include attribute instantiation code. 61234353Sdim#include "clang/Sema/AttrTemplateInstantiate.inc" 62234353Sdim 63249423Sdimstatic void instantiateDependentAlignedAttr( 64249423Sdim Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, 65249423Sdim const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion) { 66249423Sdim if (Aligned->isAlignmentExpr()) { 67249423Sdim // The alignment expression is a constant expression. 68249423Sdim EnterExpressionEvaluationContext Unevaluated(S, Sema::ConstantEvaluated); 69249423Sdim ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs); 70249423Sdim if (!Result.isInvalid()) 71249423Sdim S.AddAlignedAttr(Aligned->getLocation(), New, Result.takeAs<Expr>(), 72249423Sdim Aligned->getSpellingListIndex(), IsPackExpansion); 73249423Sdim } else { 74249423Sdim TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(), 75249423Sdim TemplateArgs, Aligned->getLocation(), 76249423Sdim DeclarationName()); 77249423Sdim if (Result) 78249423Sdim S.AddAlignedAttr(Aligned->getLocation(), New, Result, 79249423Sdim Aligned->getSpellingListIndex(), IsPackExpansion); 80249423Sdim } 81249423Sdim} 82249423Sdim 83249423Sdimstatic void instantiateDependentAlignedAttr( 84249423Sdim Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, 85249423Sdim const AlignedAttr *Aligned, Decl *New) { 86249423Sdim if (!Aligned->isPackExpansion()) { 87249423Sdim instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false); 88249423Sdim return; 89249423Sdim } 90249423Sdim 91249423Sdim SmallVector<UnexpandedParameterPack, 2> Unexpanded; 92249423Sdim if (Aligned->isAlignmentExpr()) 93249423Sdim S.collectUnexpandedParameterPacks(Aligned->getAlignmentExpr(), 94249423Sdim Unexpanded); 95249423Sdim else 96249423Sdim S.collectUnexpandedParameterPacks(Aligned->getAlignmentType()->getTypeLoc(), 97249423Sdim Unexpanded); 98249423Sdim assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 99249423Sdim 100249423Sdim // Determine whether we can expand this attribute pack yet. 101249423Sdim bool Expand = true, RetainExpansion = false; 102249423Sdim Optional<unsigned> NumExpansions; 103249423Sdim // FIXME: Use the actual location of the ellipsis. 104249423Sdim SourceLocation EllipsisLoc = Aligned->getLocation(); 105249423Sdim if (S.CheckParameterPacksForExpansion(EllipsisLoc, Aligned->getRange(), 106249423Sdim Unexpanded, TemplateArgs, Expand, 107249423Sdim RetainExpansion, NumExpansions)) 108249423Sdim return; 109249423Sdim 110249423Sdim if (!Expand) { 111249423Sdim Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, -1); 112249423Sdim instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, true); 113249423Sdim } else { 114249423Sdim for (unsigned I = 0; I != *NumExpansions; ++I) { 115249423Sdim Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, I); 116249423Sdim instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false); 117249423Sdim } 118249423Sdim } 119249423Sdim} 120249423Sdim 121212904Sdimvoid Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, 122234353Sdim const Decl *Tmpl, Decl *New, 123234353Sdim LateInstantiatedAttrVec *LateAttrs, 124234353Sdim LocalInstantiationScope *OuterMostScope) { 125212904Sdim for (AttrVec::const_iterator i = Tmpl->attr_begin(), e = Tmpl->attr_end(); 126212904Sdim i != e; ++i) { 127212904Sdim const Attr *TmplAttr = *i; 128234353Sdim 129210299Sed // FIXME: This should be generalized to more than just the AlignedAttr. 130249423Sdim const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr); 131249423Sdim if (Aligned && Aligned->isAlignmentDependent()) { 132249423Sdim instantiateDependentAlignedAttr(*this, TemplateArgs, Aligned, New); 133249423Sdim continue; 134210299Sed } 135210299Sed 136249423Sdim assert(!TmplAttr->isPackExpansion()); 137234353Sdim if (TmplAttr->isLateParsed() && LateAttrs) { 138234353Sdim // Late parsed attributes must be instantiated and attached after the 139234353Sdim // enclosing class has been instantiated. See Sema::InstantiateClass. 140234353Sdim LocalInstantiationScope *Saved = 0; 141234353Sdim if (CurrentInstantiationScope) 142234353Sdim Saved = CurrentInstantiationScope->cloneScopes(OuterMostScope); 143234353Sdim LateAttrs->push_back(LateInstantiatedAttribute(TmplAttr, Saved, New)); 144234353Sdim } else { 145234353Sdim Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context, 146234353Sdim *this, TemplateArgs); 147239462Sdim if (NewAttr) 148239462Sdim New->addAttr(NewAttr); 149234353Sdim } 150199482Srdivacky } 151199482Srdivacky} 152199482Srdivacky 153193326SedDecl * 154193326SedTemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 155226633Sdim llvm_unreachable("Translation units cannot be instantiated"); 156193326Sed} 157193326Sed 158193326SedDecl * 159218893SdimTemplateDeclInstantiator::VisitLabelDecl(LabelDecl *D) { 160218893Sdim LabelDecl *Inst = LabelDecl::Create(SemaRef.Context, Owner, D->getLocation(), 161218893Sdim D->getIdentifier()); 162218893Sdim Owner->addDecl(Inst); 163218893Sdim return Inst; 164218893Sdim} 165218893Sdim 166218893SdimDecl * 167193326SedTemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) { 168226633Sdim llvm_unreachable("Namespaces cannot be instantiated"); 169193326Sed} 170193326Sed 171203955SrdivackyDecl * 172203955SrdivackyTemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 173203955Srdivacky NamespaceAliasDecl *Inst 174203955Srdivacky = NamespaceAliasDecl::Create(SemaRef.Context, Owner, 175203955Srdivacky D->getNamespaceLoc(), 176203955Srdivacky D->getAliasLoc(), 177219077Sdim D->getIdentifier(), 178219077Sdim D->getQualifierLoc(), 179203955Srdivacky D->getTargetNameLoc(), 180203955Srdivacky D->getNamespace()); 181203955Srdivacky Owner->addDecl(Inst); 182203955Srdivacky return Inst; 183203955Srdivacky} 184203955Srdivacky 185223017SdimDecl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D, 186223017Sdim bool IsTypeAlias) { 187193326Sed bool Invalid = false; 188200583Srdivacky TypeSourceInfo *DI = D->getTypeSourceInfo(); 189224145Sdim if (DI->getType()->isInstantiationDependentType() || 190208600Srdivacky DI->getType()->isVariablyModifiedType()) { 191198893Srdivacky DI = SemaRef.SubstType(DI, TemplateArgs, 192198893Srdivacky D->getLocation(), D->getDeclName()); 193198893Srdivacky if (!DI) { 194193326Sed Invalid = true; 195200583Srdivacky DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy); 196193326Sed } 197208600Srdivacky } else { 198208600Srdivacky SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType()); 199193326Sed } 200198092Srdivacky 201243830Sdim // HACK: g++ has a bug where it gets the value kind of ?: wrong. 202243830Sdim // libstdc++ relies upon this bug in its implementation of common_type. 203243830Sdim // If we happen to be processing that implementation, fake up the g++ ?: 204243830Sdim // semantics. See LWG issue 2141 for more information on the bug. 205243830Sdim const DecltypeType *DT = DI->getType()->getAs<DecltypeType>(); 206243830Sdim CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext()); 207243830Sdim if (DT && RD && isa<ConditionalOperator>(DT->getUnderlyingExpr()) && 208243830Sdim DT->isReferenceType() && 209243830Sdim RD->getEnclosingNamespaceContext() == SemaRef.getStdNamespace() && 210243830Sdim RD->getIdentifier() && RD->getIdentifier()->isStr("common_type") && 211243830Sdim D->getIdentifier() && D->getIdentifier()->isStr("type") && 212243830Sdim SemaRef.getSourceManager().isInSystemHeader(D->getLocStart())) 213243830Sdim // Fold it to the (non-reference) type which g++ would have produced. 214243830Sdim DI = SemaRef.Context.getTrivialTypeSourceInfo( 215243830Sdim DI->getType().getNonReferenceType()); 216243830Sdim 217193326Sed // Create the new typedef 218221345Sdim TypedefNameDecl *Typedef; 219221345Sdim if (IsTypeAlias) 220221345Sdim Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getLocStart(), 221221345Sdim D->getLocation(), D->getIdentifier(), DI); 222221345Sdim else 223221345Sdim Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getLocStart(), 224221345Sdim D->getLocation(), D->getIdentifier(), DI); 225193326Sed if (Invalid) 226193326Sed Typedef->setInvalidDecl(); 227193326Sed 228218893Sdim // If the old typedef was the name for linkage purposes of an anonymous 229218893Sdim // tag decl, re-establish that relationship for the new typedef. 230218893Sdim if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) { 231218893Sdim TagDecl *oldTag = oldTagType->getDecl(); 232249423Sdim if (oldTag->getTypedefNameForAnonDecl() == D && !Invalid) { 233218893Sdim TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl(); 234249423Sdim assert(!newTag->hasNameForLinkage()); 235221345Sdim newTag->setTypedefNameForAnonDecl(Typedef); 236218893Sdim } 237207619Srdivacky } 238226633Sdim 239234353Sdim if (TypedefNameDecl *Prev = D->getPreviousDecl()) { 240204643Srdivacky NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev, 241204643Srdivacky TemplateArgs); 242221345Sdim if (!InstPrev) 243221345Sdim return 0; 244226633Sdim 245234353Sdim TypedefNameDecl *InstPrevTypedef = cast<TypedefNameDecl>(InstPrev); 246234353Sdim 247234353Sdim // If the typedef types are not identical, reject them. 248234353Sdim SemaRef.isIncompatibleTypedef(InstPrevTypedef, Typedef); 249234353Sdim 250234353Sdim Typedef->setPreviousDeclaration(InstPrevTypedef); 251201361Srdivacky } 252201361Srdivacky 253212904Sdim SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef); 254207619Srdivacky 255202879Srdivacky Typedef->setAccess(D->getAccess()); 256198092Srdivacky 257193326Sed return Typedef; 258193326Sed} 259193326Sed 260221345SdimDecl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) { 261223017Sdim Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/false); 262223017Sdim Owner->addDecl(Typedef); 263223017Sdim return Typedef; 264221345Sdim} 265221345Sdim 266221345SdimDecl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) { 267223017Sdim Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/true); 268223017Sdim Owner->addDecl(Typedef); 269223017Sdim return Typedef; 270221345Sdim} 271221345Sdim 272223017SdimDecl * 273223017SdimTemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { 274223017Sdim // Create a local instantiation scope for this type alias template, which 275223017Sdim // will contain the instantiations of the template parameters. 276223017Sdim LocalInstantiationScope Scope(SemaRef); 277223017Sdim 278223017Sdim TemplateParameterList *TempParams = D->getTemplateParameters(); 279223017Sdim TemplateParameterList *InstParams = SubstTemplateParams(TempParams); 280223017Sdim if (!InstParams) 281223017Sdim return 0; 282223017Sdim 283223017Sdim TypeAliasDecl *Pattern = D->getTemplatedDecl(); 284223017Sdim 285223017Sdim TypeAliasTemplateDecl *PrevAliasTemplate = 0; 286234353Sdim if (Pattern->getPreviousDecl()) { 287223017Sdim DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName()); 288249423Sdim if (!Found.empty()) { 289249423Sdim PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Found.front()); 290223017Sdim } 291223017Sdim } 292223017Sdim 293223017Sdim TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>( 294223017Sdim InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true)); 295223017Sdim if (!AliasInst) 296223017Sdim return 0; 297223017Sdim 298223017Sdim TypeAliasTemplateDecl *Inst 299223017Sdim = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(), 300223017Sdim D->getDeclName(), InstParams, AliasInst); 301223017Sdim if (PrevAliasTemplate) 302223017Sdim Inst->setPreviousDeclaration(PrevAliasTemplate); 303223017Sdim 304223017Sdim Inst->setAccess(D->getAccess()); 305223017Sdim 306223017Sdim if (!PrevAliasTemplate) 307223017Sdim Inst->setInstantiatedFromMemberTemplate(D); 308226633Sdim 309223017Sdim Owner->addDecl(Inst); 310223017Sdim 311223017Sdim return Inst; 312223017Sdim} 313223017Sdim 314193326SedDecl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) { 315208600Srdivacky // If this is the variable for an anonymous struct or union, 316208600Srdivacky // instantiate the anonymous struct/union type first. 317208600Srdivacky if (const RecordType *RecordTy = D->getType()->getAs<RecordType>()) 318208600Srdivacky if (RecordTy->getDecl()->isAnonymousStructOrUnion()) 319208600Srdivacky if (!VisitCXXRecordDecl(cast<CXXRecordDecl>(RecordTy->getDecl()))) 320208600Srdivacky return 0; 321208600Srdivacky 322198092Srdivacky // Do substitution on the type of the declaration 323200583Srdivacky TypeSourceInfo *DI = SemaRef.SubstType(D->getTypeSourceInfo(), 324198398Srdivacky TemplateArgs, 325198398Srdivacky D->getTypeSpecStartLoc(), 326198398Srdivacky D->getDeclName()); 327198398Srdivacky if (!DI) 328193326Sed return 0; 329193326Sed 330218893Sdim if (DI->getType()->isFunctionType()) { 331218893Sdim SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function) 332218893Sdim << D->isStaticDataMember() << DI->getType(); 333218893Sdim return 0; 334218893Sdim } 335226633Sdim 336193326Sed // Build the instantiated declaration 337193326Sed VarDecl *Var = VarDecl::Create(SemaRef.Context, Owner, 338221345Sdim D->getInnerLocStart(), 339193326Sed D->getLocation(), D->getIdentifier(), 340198398Srdivacky DI->getType(), DI, 341249423Sdim D->getStorageClass()); 342251662Sdim Var->setTSCSpec(D->getTSCSpec()); 343234353Sdim Var->setInitStyle(D->getInitStyle()); 344221345Sdim Var->setCXXForRangeDecl(D->isCXXForRangeDecl()); 345234353Sdim Var->setConstexpr(D->isConstexpr()); 346198092Srdivacky 347205219Srdivacky // Substitute the nested name specifier, if any. 348205219Srdivacky if (SubstQualifier(D, Var)) 349205219Srdivacky return 0; 350205219Srdivacky 351198092Srdivacky // If we are instantiating a static data member defined 352198092Srdivacky // out-of-line, the instantiation will have the same lexical 353198092Srdivacky // context (which will be a namespace scope) as the template. 354198092Srdivacky if (D->isOutOfLine()) 355198092Srdivacky Var->setLexicalDeclContext(D->getLexicalDeclContext()); 356198092Srdivacky 357202879Srdivacky Var->setAccess(D->getAccess()); 358226633Sdim 359221345Sdim if (!D->isStaticDataMember()) { 360210299Sed Var->setUsed(D->isUsed(false)); 361221345Sdim Var->setReferenced(D->isReferenced()); 362221345Sdim } 363226633Sdim 364249423Sdim SemaRef.InstantiateAttrs(TemplateArgs, D, Var, LateAttrs, StartingScope); 365249423Sdim 366249423Sdim if (Var->hasAttrs()) 367249423Sdim SemaRef.CheckAlignasUnderalignment(Var); 368249423Sdim 369193326Sed // FIXME: In theory, we could have a previous declaration for variables that 370193326Sed // are not static data members. 371199512Srdivacky // FIXME: having to fake up a LookupResult is dumb. 372199512Srdivacky LookupResult Previous(SemaRef, Var->getDeclName(), Var->getLocation(), 373204643Srdivacky Sema::LookupOrdinaryName, Sema::ForRedeclaration); 374203955Srdivacky if (D->isStaticDataMember()) 375203955Srdivacky SemaRef.LookupQualifiedName(Previous, Owner, false); 376234353Sdim 377234353Sdim // In ARC, infer 'retaining' for variables of retainable type. 378234353Sdim if (SemaRef.getLangOpts().ObjCAutoRefCount && 379234353Sdim SemaRef.inferObjCARCLifetime(Var)) 380234353Sdim Var->setInvalidDecl(); 381234353Sdim 382226633Sdim SemaRef.CheckVariableDeclaration(Var, Previous); 383193326Sed 384198092Srdivacky if (D->isOutOfLine()) { 385234353Sdim D->getLexicalDeclContext()->addDecl(Var); 386198092Srdivacky Owner->makeDeclVisibleInContext(Var); 387198092Srdivacky } else { 388198092Srdivacky Owner->addDecl(Var); 389207619Srdivacky if (Owner->isFunctionOrMethod()) 390207619Srdivacky SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Var); 391198092Srdivacky } 392226633Sdim 393198092Srdivacky // Link instantiations of static data members back to the template from 394198092Srdivacky // which they were instantiated. 395198092Srdivacky if (Var->isStaticDataMember()) 396226633Sdim SemaRef.Context.setInstantiatedFromStaticDataMember(Var, D, 397198893Srdivacky TSK_ImplicitInstantiation); 398226633Sdim 399203955Srdivacky if (Var->getAnyInitializer()) { 400203955Srdivacky // We already have an initializer in the class. 401203955Srdivacky } else if (D->getInit()) { 402200583Srdivacky if (Var->isStaticDataMember() && !D->isOutOfLine()) 403239462Sdim SemaRef.PushExpressionEvaluationContext(Sema::ConstantEvaluated, D); 404200583Srdivacky else 405239462Sdim SemaRef.PushExpressionEvaluationContext(Sema::PotentiallyEvaluated, D); 406200583Srdivacky 407204643Srdivacky // Instantiate the initializer. 408234353Sdim ExprResult Init = SemaRef.SubstInitializer(D->getInit(), TemplateArgs, 409234353Sdim D->getInitStyle() == VarDecl::CallInit); 410234353Sdim if (!Init.isInvalid()) { 411218893Sdim bool TypeMayContainAuto = true; 412234353Sdim if (Init.get()) { 413234353Sdim bool DirectInit = D->isDirectInit(); 414234353Sdim SemaRef.AddInitializerToDecl(Var, Init.take(), DirectInit, 415234353Sdim TypeMayContainAuto); 416234353Sdim } else 417218893Sdim SemaRef.ActOnUninitializedDecl(Var, TypeMayContainAuto); 418200583Srdivacky } else { 419204643Srdivacky // FIXME: Not too happy about invalidating the declaration 420204643Srdivacky // because of a bogus initializer. 421204643Srdivacky Var->setInvalidDecl(); 422200583Srdivacky } 423226633Sdim 424200583Srdivacky SemaRef.PopExpressionEvaluationContext(); 425221345Sdim } else if ((!Var->isStaticDataMember() || Var->isOutOfLine()) && 426221345Sdim !Var->isCXXForRangeDecl()) 427212904Sdim SemaRef.ActOnUninitializedDecl(Var, false); 428193326Sed 429224145Sdim // Diagnose unused local variables with dependent types, where the diagnostic 430224145Sdim // will have been deferred. 431224145Sdim if (!Var->isInvalidDecl() && Owner->isFunctionOrMethod() && !Var->isUsed() && 432224145Sdim D->getType()->isDependentType()) 433208600Srdivacky SemaRef.DiagnoseUnusedDecl(Var); 434212904Sdim 435193326Sed return Var; 436193326Sed} 437193326Sed 438210299SedDecl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) { 439210299Sed AccessSpecDecl* AD 440210299Sed = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner, 441210299Sed D->getAccessSpecifierLoc(), D->getColonLoc()); 442210299Sed Owner->addHiddenDecl(AD); 443210299Sed return AD; 444210299Sed} 445210299Sed 446193326SedDecl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) { 447193326Sed bool Invalid = false; 448200583Srdivacky TypeSourceInfo *DI = D->getTypeSourceInfo(); 449224145Sdim if (DI->getType()->isInstantiationDependentType() || 450208600Srdivacky DI->getType()->isVariablyModifiedType()) { 451198398Srdivacky DI = SemaRef.SubstType(DI, TemplateArgs, 452198398Srdivacky D->getLocation(), D->getDeclName()); 453198398Srdivacky if (!DI) { 454200583Srdivacky DI = D->getTypeSourceInfo(); 455198398Srdivacky Invalid = true; 456198398Srdivacky } else if (DI->getType()->isFunctionType()) { 457193326Sed // C++ [temp.arg.type]p3: 458193326Sed // If a declaration acquires a function type through a type 459193326Sed // dependent on a template-parameter and this causes a 460193326Sed // declaration that does not use the syntactic form of a 461193326Sed // function declarator to have function type, the program is 462193326Sed // ill-formed. 463193326Sed SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function) 464198398Srdivacky << DI->getType(); 465193326Sed Invalid = true; 466193326Sed } 467208600Srdivacky } else { 468208600Srdivacky SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType()); 469193326Sed } 470193326Sed 471193326Sed Expr *BitWidth = D->getBitWidth(); 472193326Sed if (Invalid) 473193326Sed BitWidth = 0; 474193326Sed else if (BitWidth) { 475234353Sdim // The bit-width expression is a constant expression. 476234353Sdim EnterExpressionEvaluationContext Unevaluated(SemaRef, 477234353Sdim Sema::ConstantEvaluated); 478198092Srdivacky 479212904Sdim ExprResult InstantiatedBitWidth 480198092Srdivacky = SemaRef.SubstExpr(BitWidth, TemplateArgs); 481193326Sed if (InstantiatedBitWidth.isInvalid()) { 482193326Sed Invalid = true; 483193326Sed BitWidth = 0; 484193326Sed } else 485193326Sed BitWidth = InstantiatedBitWidth.takeAs<Expr>(); 486193326Sed } 487193326Sed 488198398Srdivacky FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(), 489198398Srdivacky DI->getType(), DI, 490198092Srdivacky cast<RecordDecl>(Owner), 491193326Sed D->getLocation(), 492193326Sed D->isMutable(), 493193326Sed BitWidth, 494239462Sdim D->getInClassInitStyle(), 495239462Sdim D->getInnerLocStart(), 496193326Sed D->getAccess(), 497193326Sed 0); 498198112Srdivacky if (!Field) { 499198112Srdivacky cast<Decl>(Owner)->setInvalidDecl(); 500198092Srdivacky return 0; 501198112Srdivacky } 502198092Srdivacky 503234353Sdim SemaRef.InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope); 504226633Sdim 505249423Sdim if (Field->hasAttrs()) 506249423Sdim SemaRef.CheckAlignasUnderalignment(Field); 507249423Sdim 508198092Srdivacky if (Invalid) 509198092Srdivacky Field->setInvalidDecl(); 510198092Srdivacky 511198092Srdivacky if (!Field->getDeclName()) { 512198092Srdivacky // Keep track of where this decl came from. 513198092Srdivacky SemaRef.Context.setInstantiatedFromUnnamedFieldDecl(Field, D); 514226633Sdim } 515208600Srdivacky if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) { 516208600Srdivacky if (Parent->isAnonymousStructOrUnion() && 517212904Sdim Parent->getRedeclContext()->isFunctionOrMethod()) 518208600Srdivacky SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field); 519193326Sed } 520193326Sed 521198092Srdivacky Field->setImplicit(D->isImplicit()); 522202879Srdivacky Field->setAccess(D->getAccess()); 523198092Srdivacky Owner->addDecl(Field); 524198092Srdivacky 525193326Sed return Field; 526193326Sed} 527193326Sed 528251662SdimDecl *TemplateDeclInstantiator::VisitMSPropertyDecl(MSPropertyDecl *D) { 529251662Sdim bool Invalid = false; 530251662Sdim TypeSourceInfo *DI = D->getTypeSourceInfo(); 531251662Sdim 532251662Sdim if (DI->getType()->isVariablyModifiedType()) { 533251662Sdim SemaRef.Diag(D->getLocation(), diag::err_property_is_variably_modified) 534251662Sdim << D->getName(); 535251662Sdim Invalid = true; 536251662Sdim } else if (DI->getType()->isInstantiationDependentType()) { 537251662Sdim DI = SemaRef.SubstType(DI, TemplateArgs, 538251662Sdim D->getLocation(), D->getDeclName()); 539251662Sdim if (!DI) { 540251662Sdim DI = D->getTypeSourceInfo(); 541251662Sdim Invalid = true; 542251662Sdim } else if (DI->getType()->isFunctionType()) { 543251662Sdim // C++ [temp.arg.type]p3: 544251662Sdim // If a declaration acquires a function type through a type 545251662Sdim // dependent on a template-parameter and this causes a 546251662Sdim // declaration that does not use the syntactic form of a 547251662Sdim // function declarator to have function type, the program is 548251662Sdim // ill-formed. 549251662Sdim SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function) 550251662Sdim << DI->getType(); 551251662Sdim Invalid = true; 552251662Sdim } 553251662Sdim } else { 554251662Sdim SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType()); 555251662Sdim } 556251662Sdim 557251662Sdim MSPropertyDecl *Property = new (SemaRef.Context) 558251662Sdim MSPropertyDecl(Owner, D->getLocation(), 559251662Sdim D->getDeclName(), DI->getType(), DI, 560251662Sdim D->getLocStart(), 561251662Sdim D->getGetterId(), D->getSetterId()); 562251662Sdim 563251662Sdim SemaRef.InstantiateAttrs(TemplateArgs, D, Property, LateAttrs, 564251662Sdim StartingScope); 565251662Sdim 566251662Sdim if (Invalid) 567251662Sdim Property->setInvalidDecl(); 568251662Sdim 569251662Sdim Property->setAccess(D->getAccess()); 570251662Sdim Owner->addDecl(Property); 571251662Sdim 572251662Sdim return Property; 573251662Sdim} 574251662Sdim 575218893SdimDecl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) { 576218893Sdim NamedDecl **NamedChain = 577218893Sdim new (SemaRef.Context)NamedDecl*[D->getChainingSize()]; 578218893Sdim 579218893Sdim int i = 0; 580218893Sdim for (IndirectFieldDecl::chain_iterator PI = 581218893Sdim D->chain_begin(), PE = D->chain_end(); 582221345Sdim PI != PE; ++PI) { 583226633Sdim NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), *PI, 584221345Sdim TemplateArgs); 585221345Sdim if (!Next) 586221345Sdim return 0; 587226633Sdim 588221345Sdim NamedChain[i++] = Next; 589221345Sdim } 590218893Sdim 591218893Sdim QualType T = cast<FieldDecl>(NamedChain[i-1])->getType(); 592218893Sdim IndirectFieldDecl* IndirectField 593218893Sdim = IndirectFieldDecl::Create(SemaRef.Context, Owner, D->getLocation(), 594218893Sdim D->getIdentifier(), T, 595218893Sdim NamedChain, D->getChainingSize()); 596218893Sdim 597218893Sdim 598218893Sdim IndirectField->setImplicit(D->isImplicit()); 599218893Sdim IndirectField->setAccess(D->getAccess()); 600218893Sdim Owner->addDecl(IndirectField); 601218893Sdim return IndirectField; 602218893Sdim} 603218893Sdim 604198092SrdivackyDecl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) { 605198092Srdivacky // Handle friend type expressions by simply substituting template 606207619Srdivacky // parameters into the pattern type and checking the result. 607206084Srdivacky if (TypeSourceInfo *Ty = D->getFriendType()) { 608221345Sdim TypeSourceInfo *InstTy; 609221345Sdim // If this is an unsupported friend, don't bother substituting template 610221345Sdim // arguments into it. The actual type referred to won't be used by any 611221345Sdim // parts of Clang, and may not be valid for instantiating. Just use the 612221345Sdim // same info for the instantiated friend. 613221345Sdim if (D->isUnsupportedFriend()) { 614221345Sdim InstTy = Ty; 615221345Sdim } else { 616221345Sdim InstTy = SemaRef.SubstType(Ty, TemplateArgs, 617221345Sdim D->getLocation(), DeclarationName()); 618221345Sdim } 619221345Sdim if (!InstTy) 620207619Srdivacky return 0; 621198092Srdivacky 622243830Sdim FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getLocStart(), 623234353Sdim D->getFriendLoc(), InstTy); 624207619Srdivacky if (!FD) 625201361Srdivacky return 0; 626226633Sdim 627207619Srdivacky FD->setAccess(AS_public); 628218893Sdim FD->setUnsupportedFriend(D->isUnsupportedFriend()); 629207619Srdivacky Owner->addDecl(FD); 630207619Srdivacky return FD; 631226633Sdim } 632226633Sdim 633207619Srdivacky NamedDecl *ND = D->getFriendDecl(); 634207619Srdivacky assert(ND && "friend decl must be a decl or a type!"); 635198092Srdivacky 636207619Srdivacky // All of the Visit implementations for the various potential friend 637207619Srdivacky // declarations have to be carefully written to work for friend 638207619Srdivacky // objects, with the most important detail being that the target 639207619Srdivacky // decl should almost certainly not be placed in Owner. 640207619Srdivacky Decl *NewND = Visit(ND); 641207619Srdivacky if (!NewND) return 0; 642198092Srdivacky 643198092Srdivacky FriendDecl *FD = 644226633Sdim FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(), 645207619Srdivacky cast<NamedDecl>(NewND), D->getFriendLoc()); 646198092Srdivacky FD->setAccess(AS_public); 647218893Sdim FD->setUnsupportedFriend(D->isUnsupportedFriend()); 648198092Srdivacky Owner->addDecl(FD); 649198092Srdivacky return FD; 650198092Srdivacky} 651198092Srdivacky 652193326SedDecl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) { 653193326Sed Expr *AssertExpr = D->getAssertExpr(); 654198092Srdivacky 655234353Sdim // The expression in a static assertion is a constant expression. 656234353Sdim EnterExpressionEvaluationContext Unevaluated(SemaRef, 657234353Sdim Sema::ConstantEvaluated); 658198092Srdivacky 659212904Sdim ExprResult InstantiatedAssertExpr 660198092Srdivacky = SemaRef.SubstExpr(AssertExpr, TemplateArgs); 661193326Sed if (InstantiatedAssertExpr.isInvalid()) 662193326Sed return 0; 663193326Sed 664239462Sdim return SemaRef.BuildStaticAssertDeclaration(D->getLocation(), 665212904Sdim InstantiatedAssertExpr.get(), 666239462Sdim D->getMessage(), 667239462Sdim D->getRParenLoc(), 668239462Sdim D->isFailed()); 669193326Sed} 670193326Sed 671193326SedDecl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) { 672234353Sdim EnumDecl *PrevDecl = 0; 673234353Sdim if (D->getPreviousDecl()) { 674234353Sdim NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(), 675234353Sdim D->getPreviousDecl(), 676234353Sdim TemplateArgs); 677234353Sdim if (!Prev) return 0; 678234353Sdim PrevDecl = cast<EnumDecl>(Prev); 679234353Sdim } 680234353Sdim 681221345Sdim EnumDecl *Enum = EnumDecl::Create(SemaRef.Context, Owner, D->getLocStart(), 682193326Sed D->getLocation(), D->getIdentifier(), 683234353Sdim PrevDecl, D->isScoped(), 684218893Sdim D->isScopedUsingClassTag(), D->isFixed()); 685218893Sdim if (D->isFixed()) { 686234353Sdim if (TypeSourceInfo *TI = D->getIntegerTypeSourceInfo()) { 687218893Sdim // If we have type source information for the underlying type, it means it 688218893Sdim // has been explicitly set by the user. Perform substitution on it before 689218893Sdim // moving on. 690218893Sdim SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc(); 691234353Sdim TypeSourceInfo *NewTI = SemaRef.SubstType(TI, TemplateArgs, UnderlyingLoc, 692234353Sdim DeclarationName()); 693234353Sdim if (!NewTI || SemaRef.CheckEnumUnderlyingType(NewTI)) 694218893Sdim Enum->setIntegerType(SemaRef.Context.IntTy); 695234353Sdim else 696234353Sdim Enum->setIntegerTypeSourceInfo(NewTI); 697234353Sdim } else { 698218893Sdim assert(!D->getIntegerType()->isDependentType() 699218893Sdim && "Dependent type without type source info"); 700218893Sdim Enum->setIntegerType(D->getIntegerType()); 701218893Sdim } 702218893Sdim } 703218893Sdim 704218893Sdim SemaRef.InstantiateAttrs(TemplateArgs, D, Enum); 705218893Sdim 706234353Sdim Enum->setInstantiationOfMemberEnum(D, TSK_ImplicitInstantiation); 707193326Sed Enum->setAccess(D->getAccess()); 708205219Srdivacky if (SubstQualifier(D, Enum)) return 0; 709195341Sed Owner->addDecl(Enum); 710193326Sed 711234353Sdim EnumDecl *Def = D->getDefinition(); 712234353Sdim if (Def && Def != D) { 713234353Sdim // If this is an out-of-line definition of an enum member template, check 714234353Sdim // that the underlying types match in the instantiation of both 715234353Sdim // declarations. 716234353Sdim if (TypeSourceInfo *TI = Def->getIntegerTypeSourceInfo()) { 717234353Sdim SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc(); 718234353Sdim QualType DefnUnderlying = 719234353Sdim SemaRef.SubstType(TI->getType(), TemplateArgs, 720234353Sdim UnderlyingLoc, DeclarationName()); 721234353Sdim SemaRef.CheckEnumRedeclaration(Def->getLocation(), Def->isScoped(), 722234353Sdim DefnUnderlying, Enum); 723234353Sdim } 724234353Sdim } 725234353Sdim 726204643Srdivacky if (D->getDeclContext()->isFunctionOrMethod()) 727204643Srdivacky SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Enum); 728193326Sed 729234353Sdim // C++11 [temp.inst]p1: The implicit instantiation of a class template 730234353Sdim // specialization causes the implicit instantiation of the declarations, but 731234353Sdim // not the definitions of scoped member enumerations. 732234353Sdim // FIXME: There appears to be no wording for what happens for an enum defined 733234353Sdim // within a block scope, but we treat that much like a member template. Only 734234353Sdim // instantiate the definition when visiting the definition in that case, since 735234353Sdim // we will visit all redeclarations. 736234353Sdim if (!Enum->isScoped() && Def && 737234353Sdim (!D->getDeclContext()->isFunctionOrMethod() || D->isCompleteDefinition())) 738234353Sdim InstantiateEnumDefinition(Enum, Def); 739234353Sdim 740234353Sdim return Enum; 741234353Sdim} 742234353Sdim 743234353Sdimvoid TemplateDeclInstantiator::InstantiateEnumDefinition( 744234353Sdim EnumDecl *Enum, EnumDecl *Pattern) { 745234353Sdim Enum->startDefinition(); 746234353Sdim 747234353Sdim // Update the location to refer to the definition. 748234353Sdim Enum->setLocation(Pattern->getLocation()); 749234353Sdim 750226633Sdim SmallVector<Decl*, 4> Enumerators; 751226633Sdim 752193326Sed EnumConstantDecl *LastEnumConst = 0; 753234353Sdim for (EnumDecl::enumerator_iterator EC = Pattern->enumerator_begin(), 754234353Sdim ECEnd = Pattern->enumerator_end(); 755193326Sed EC != ECEnd; ++EC) { 756193326Sed // The specified value for the enumerator. 757212904Sdim ExprResult Value = SemaRef.Owned((Expr *)0); 758194711Sed if (Expr *UninstValue = EC->getInitExpr()) { 759234353Sdim // The enumerator's value expression is a constant expression. 760198092Srdivacky EnterExpressionEvaluationContext Unevaluated(SemaRef, 761234353Sdim Sema::ConstantEvaluated); 762198092Srdivacky 763198092Srdivacky Value = SemaRef.SubstExpr(UninstValue, TemplateArgs); 764194711Sed } 765193326Sed 766193326Sed // Drop the initial value and continue. 767193326Sed bool isInvalid = false; 768193326Sed if (Value.isInvalid()) { 769193326Sed Value = SemaRef.Owned((Expr *)0); 770193326Sed isInvalid = true; 771193326Sed } 772193326Sed 773198092Srdivacky EnumConstantDecl *EnumConst 774193326Sed = SemaRef.CheckEnumConstant(Enum, LastEnumConst, 775193326Sed EC->getLocation(), EC->getIdentifier(), 776212904Sdim Value.get()); 777193326Sed 778193326Sed if (isInvalid) { 779193326Sed if (EnumConst) 780193326Sed EnumConst->setInvalidDecl(); 781193326Sed Enum->setInvalidDecl(); 782193326Sed } 783193326Sed 784193326Sed if (EnumConst) { 785218893Sdim SemaRef.InstantiateAttrs(TemplateArgs, *EC, EnumConst); 786218893Sdim 787203955Srdivacky EnumConst->setAccess(Enum->getAccess()); 788195341Sed Enum->addDecl(EnumConst); 789212904Sdim Enumerators.push_back(EnumConst); 790193326Sed LastEnumConst = EnumConst; 791226633Sdim 792234353Sdim if (Pattern->getDeclContext()->isFunctionOrMethod() && 793234353Sdim !Enum->isScoped()) { 794204643Srdivacky // If the enumeration is within a function or method, record the enum 795204643Srdivacky // constant as a local. 796204643Srdivacky SemaRef.CurrentInstantiationScope->InstantiatedLocal(*EC, EnumConst); 797204643Srdivacky } 798193326Sed } 799193326Sed } 800198092Srdivacky 801234353Sdim // FIXME: Fixup LBraceLoc 802234353Sdim SemaRef.ActOnEnumBody(Enum->getLocation(), SourceLocation(), 803234353Sdim Enum->getRBraceLoc(), Enum, 804251662Sdim Enumerators, 805198092Srdivacky 0, 0); 806193326Sed} 807193326Sed 808193326SedDecl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) { 809226633Sdim llvm_unreachable("EnumConstantDecls can only occur within EnumDecls."); 810193326Sed} 811193326Sed 812198092SrdivackyDecl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) { 813206084Srdivacky bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None); 814206084Srdivacky 815198893Srdivacky // Create a local instantiation scope for this class template, which 816198893Srdivacky // will contain the instantiations of the template parameters. 817212904Sdim LocalInstantiationScope Scope(SemaRef); 818198092Srdivacky TemplateParameterList *TempParams = D->getTemplateParameters(); 819198092Srdivacky TemplateParameterList *InstParams = SubstTemplateParams(TempParams); 820198092Srdivacky if (!InstParams) 821198092Srdivacky return NULL; 822198092Srdivacky 823198092Srdivacky CXXRecordDecl *Pattern = D->getTemplatedDecl(); 824206084Srdivacky 825206084Srdivacky // Instantiate the qualifier. We have to do this first in case 826206084Srdivacky // we're a friend declaration, because if we are then we need to put 827206084Srdivacky // the new declaration in the appropriate context. 828219077Sdim NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc(); 829219077Sdim if (QualifierLoc) { 830219077Sdim QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, 831219077Sdim TemplateArgs); 832219077Sdim if (!QualifierLoc) 833219077Sdim return 0; 834206084Srdivacky } 835206084Srdivacky 836206084Srdivacky CXXRecordDecl *PrevDecl = 0; 837206084Srdivacky ClassTemplateDecl *PrevClassTemplate = 0; 838206084Srdivacky 839234353Sdim if (!isFriend && Pattern->getPreviousDecl()) { 840218893Sdim DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName()); 841249423Sdim if (!Found.empty()) { 842249423Sdim PrevClassTemplate = dyn_cast<ClassTemplateDecl>(Found.front()); 843218893Sdim if (PrevClassTemplate) 844218893Sdim PrevDecl = PrevClassTemplate->getTemplatedDecl(); 845218893Sdim } 846218893Sdim } 847218893Sdim 848206084Srdivacky // If this isn't a friend, then it's a member template, in which 849206084Srdivacky // case we just want to build the instantiation in the 850206084Srdivacky // specialization. If it is a friend, we want to build it in 851206084Srdivacky // the appropriate context. 852206084Srdivacky DeclContext *DC = Owner; 853206084Srdivacky if (isFriend) { 854219077Sdim if (QualifierLoc) { 855206084Srdivacky CXXScopeSpec SS; 856219077Sdim SS.Adopt(QualifierLoc); 857206084Srdivacky DC = SemaRef.computeDeclContext(SS); 858206084Srdivacky if (!DC) return 0; 859206084Srdivacky } else { 860206084Srdivacky DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(), 861206084Srdivacky Pattern->getDeclContext(), 862206084Srdivacky TemplateArgs); 863206084Srdivacky } 864206084Srdivacky 865206084Srdivacky // Look for a previous declaration of the template in the owning 866206084Srdivacky // context. 867206084Srdivacky LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(), 868206084Srdivacky Sema::LookupOrdinaryName, Sema::ForRedeclaration); 869206084Srdivacky SemaRef.LookupQualifiedName(R, DC); 870206084Srdivacky 871206084Srdivacky if (R.isSingleResult()) { 872206084Srdivacky PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>(); 873206084Srdivacky if (PrevClassTemplate) 874206084Srdivacky PrevDecl = PrevClassTemplate->getTemplatedDecl(); 875206084Srdivacky } 876206084Srdivacky 877219077Sdim if (!PrevClassTemplate && QualifierLoc) { 878206084Srdivacky SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope) 879206084Srdivacky << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC 880219077Sdim << QualifierLoc.getSourceRange(); 881206084Srdivacky return 0; 882206084Srdivacky } 883206084Srdivacky 884207619Srdivacky bool AdoptedPreviousTemplateParams = false; 885206084Srdivacky if (PrevClassTemplate) { 886207619Srdivacky bool Complain = true; 887207619Srdivacky 888207619Srdivacky // HACK: libstdc++ 4.2.1 contains an ill-formed friend class 889207619Srdivacky // template for struct std::tr1::__detail::_Map_base, where the 890207619Srdivacky // template parameters of the friend declaration don't match the 891207619Srdivacky // template parameters of the original declaration. In this one 892207619Srdivacky // case, we don't complain about the ill-formed friend 893207619Srdivacky // declaration. 894226633Sdim if (isFriend && Pattern->getIdentifier() && 895207619Srdivacky Pattern->getIdentifier()->isStr("_Map_base") && 896207619Srdivacky DC->isNamespace() && 897207619Srdivacky cast<NamespaceDecl>(DC)->getIdentifier() && 898207619Srdivacky cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__detail")) { 899207619Srdivacky DeclContext *DCParent = DC->getParent(); 900207619Srdivacky if (DCParent->isNamespace() && 901207619Srdivacky cast<NamespaceDecl>(DCParent)->getIdentifier() && 902207619Srdivacky cast<NamespaceDecl>(DCParent)->getIdentifier()->isStr("tr1")) { 903207619Srdivacky DeclContext *DCParent2 = DCParent->getParent(); 904207619Srdivacky if (DCParent2->isNamespace() && 905207619Srdivacky cast<NamespaceDecl>(DCParent2)->getIdentifier() && 906207619Srdivacky cast<NamespaceDecl>(DCParent2)->getIdentifier()->isStr("std") && 907207619Srdivacky DCParent2->getParent()->isTranslationUnit()) 908207619Srdivacky Complain = false; 909207619Srdivacky } 910207619Srdivacky } 911207619Srdivacky 912206084Srdivacky TemplateParameterList *PrevParams 913206084Srdivacky = PrevClassTemplate->getTemplateParameters(); 914206084Srdivacky 915206084Srdivacky // Make sure the parameter lists match. 916206084Srdivacky if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams, 917226633Sdim Complain, 918207619Srdivacky Sema::TPL_TemplateMatch)) { 919207619Srdivacky if (Complain) 920207619Srdivacky return 0; 921206084Srdivacky 922207619Srdivacky AdoptedPreviousTemplateParams = true; 923207619Srdivacky InstParams = PrevParams; 924207619Srdivacky } 925207619Srdivacky 926206084Srdivacky // Do some additional validation, then merge default arguments 927206084Srdivacky // from the existing declarations. 928207619Srdivacky if (!AdoptedPreviousTemplateParams && 929207619Srdivacky SemaRef.CheckTemplateParameterList(InstParams, PrevParams, 930206084Srdivacky Sema::TPC_ClassTemplate)) 931206084Srdivacky return 0; 932206084Srdivacky } 933206084Srdivacky } 934206084Srdivacky 935198092Srdivacky CXXRecordDecl *RecordInst 936206084Srdivacky = CXXRecordDecl::Create(SemaRef.Context, Pattern->getTagKind(), DC, 937221345Sdim Pattern->getLocStart(), Pattern->getLocation(), 938221345Sdim Pattern->getIdentifier(), PrevDecl, 939198092Srdivacky /*DelayTypeCreation=*/true); 940198092Srdivacky 941219077Sdim if (QualifierLoc) 942219077Sdim RecordInst->setQualifierInfo(QualifierLoc); 943205219Srdivacky 944198092Srdivacky ClassTemplateDecl *Inst 945206084Srdivacky = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(), 946206084Srdivacky D->getIdentifier(), InstParams, RecordInst, 947206084Srdivacky PrevClassTemplate); 948198092Srdivacky RecordInst->setDescribedClassTemplate(Inst); 949207619Srdivacky 950206084Srdivacky if (isFriend) { 951207619Srdivacky if (PrevClassTemplate) 952207619Srdivacky Inst->setAccess(PrevClassTemplate->getAccess()); 953207619Srdivacky else 954207619Srdivacky Inst->setAccess(D->getAccess()); 955207619Srdivacky 956206084Srdivacky Inst->setObjectOfFriendDecl(PrevClassTemplate != 0); 957206084Srdivacky // TODO: do we want to track the instantiation progeny of this 958206084Srdivacky // friend target decl? 959206084Srdivacky } else { 960198893Srdivacky Inst->setAccess(D->getAccess()); 961218893Sdim if (!PrevClassTemplate) 962218893Sdim Inst->setInstantiatedFromMemberTemplate(D); 963206084Srdivacky } 964226633Sdim 965198092Srdivacky // Trigger creation of the type for the instantiation. 966204962Srdivacky SemaRef.Context.getInjectedClassNameType(RecordInst, 967210299Sed Inst->getInjectedClassNameSpecialization()); 968207619Srdivacky 969198893Srdivacky // Finish handling of friends. 970206084Srdivacky if (isFriend) { 971234353Sdim DC->makeDeclVisibleInContext(Inst); 972234353Sdim Inst->setLexicalDeclContext(Owner); 973234353Sdim RecordInst->setLexicalDeclContext(Owner); 974198893Srdivacky return Inst; 975198893Srdivacky } 976226633Sdim 977234353Sdim if (D->isOutOfLine()) { 978234353Sdim Inst->setLexicalDeclContext(D->getLexicalDeclContext()); 979234353Sdim RecordInst->setLexicalDeclContext(D->getLexicalDeclContext()); 980234353Sdim } 981234353Sdim 982198092Srdivacky Owner->addDecl(Inst); 983218893Sdim 984218893Sdim if (!PrevClassTemplate) { 985218893Sdim // Queue up any out-of-line partial specializations of this member 986218893Sdim // class template; the client will force their instantiation once 987218893Sdim // the enclosing class has been instantiated. 988226633Sdim SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs; 989218893Sdim D->getPartialSpecializations(PartialSpecs); 990218893Sdim for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) 991218893Sdim if (PartialSpecs[I]->isOutOfLine()) 992218893Sdim OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I])); 993218893Sdim } 994218893Sdim 995198092Srdivacky return Inst; 996198092Srdivacky} 997198092Srdivacky 998198092SrdivackyDecl * 999198092SrdivackyTemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl( 1000198092Srdivacky ClassTemplatePartialSpecializationDecl *D) { 1001198893Srdivacky ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate(); 1002226633Sdim 1003198893Srdivacky // Lookup the already-instantiated declaration in the instantiation 1004198893Srdivacky // of the class template and return that. 1005198893Srdivacky DeclContext::lookup_result Found 1006198893Srdivacky = Owner->lookup(ClassTemplate->getDeclName()); 1007249423Sdim if (Found.empty()) 1008198893Srdivacky return 0; 1009226633Sdim 1010198893Srdivacky ClassTemplateDecl *InstClassTemplate 1011249423Sdim = dyn_cast<ClassTemplateDecl>(Found.front()); 1012198893Srdivacky if (!InstClassTemplate) 1013198893Srdivacky return 0; 1014226633Sdim 1015218893Sdim if (ClassTemplatePartialSpecializationDecl *Result 1016218893Sdim = InstClassTemplate->findPartialSpecInstantiatedFromMember(D)) 1017218893Sdim return Result; 1018218893Sdim 1019218893Sdim return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D); 1020198092Srdivacky} 1021198092Srdivacky 1022198092SrdivackyDecl * 1023198092SrdivackyTemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 1024198893Srdivacky // Create a local instantiation scope for this function template, which 1025198893Srdivacky // will contain the instantiations of the template parameters and then get 1026226633Sdim // merged with the local instantiation scope for the function template 1027198893Srdivacky // itself. 1028212904Sdim LocalInstantiationScope Scope(SemaRef); 1029207619Srdivacky 1030198092Srdivacky TemplateParameterList *TempParams = D->getTemplateParameters(); 1031198092Srdivacky TemplateParameterList *InstParams = SubstTemplateParams(TempParams); 1032198092Srdivacky if (!InstParams) 1033198092Srdivacky return NULL; 1034226633Sdim 1035198092Srdivacky FunctionDecl *Instantiated = 0; 1036198092Srdivacky if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl())) 1037226633Sdim Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod, 1038198092Srdivacky InstParams)); 1039198092Srdivacky else 1040198092Srdivacky Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl( 1041226633Sdim D->getTemplatedDecl(), 1042198092Srdivacky InstParams)); 1043226633Sdim 1044198092Srdivacky if (!Instantiated) 1045198092Srdivacky return 0; 1046198092Srdivacky 1047198092Srdivacky // Link the instantiated function template declaration to the function 1048198092Srdivacky // template from which it was instantiated. 1049226633Sdim FunctionTemplateDecl *InstTemplate 1050198092Srdivacky = Instantiated->getDescribedFunctionTemplate(); 1051198092Srdivacky InstTemplate->setAccess(D->getAccess()); 1052226633Sdim assert(InstTemplate && 1053198092Srdivacky "VisitFunctionDecl/CXXMethodDecl didn't create a template!"); 1054200583Srdivacky 1055206084Srdivacky bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None); 1056206084Srdivacky 1057200583Srdivacky // Link the instantiation back to the pattern *unless* this is a 1058200583Srdivacky // non-definition friend declaration. 1059200583Srdivacky if (!InstTemplate->getInstantiatedFromMemberTemplate() && 1060206084Srdivacky !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition())) 1061198092Srdivacky InstTemplate->setInstantiatedFromMemberTemplate(D); 1062226633Sdim 1063206084Srdivacky // Make declarations visible in the appropriate context. 1064239462Sdim if (!isFriend) { 1065198092Srdivacky Owner->addDecl(InstTemplate); 1066239462Sdim } else if (InstTemplate->getDeclContext()->isRecord() && 1067239462Sdim !D->getPreviousDecl()) { 1068239462Sdim SemaRef.CheckFriendAccess(InstTemplate); 1069239462Sdim } 1070206084Srdivacky 1071198092Srdivacky return InstTemplate; 1072198092Srdivacky} 1073198092Srdivacky 1074193326SedDecl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) { 1075193326Sed CXXRecordDecl *PrevDecl = 0; 1076193326Sed if (D->isInjectedClassName()) 1077193326Sed PrevDecl = cast<CXXRecordDecl>(Owner); 1078234353Sdim else if (D->getPreviousDecl()) { 1079204643Srdivacky NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(), 1080234353Sdim D->getPreviousDecl(), 1081201361Srdivacky TemplateArgs); 1082201361Srdivacky if (!Prev) return 0; 1083201361Srdivacky PrevDecl = cast<CXXRecordDecl>(Prev); 1084201361Srdivacky } 1085193326Sed 1086193326Sed CXXRecordDecl *Record 1087198092Srdivacky = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner, 1088221345Sdim D->getLocStart(), D->getLocation(), 1089221345Sdim D->getIdentifier(), PrevDecl); 1090205219Srdivacky 1091205219Srdivacky // Substitute the nested name specifier, if any. 1092205219Srdivacky if (SubstQualifier(D, Record)) 1093205219Srdivacky return 0; 1094205219Srdivacky 1095193326Sed Record->setImplicit(D->isImplicit()); 1096198092Srdivacky // FIXME: Check against AS_none is an ugly hack to work around the issue that 1097198092Srdivacky // the tag decls introduced by friend class declarations don't have an access 1098198092Srdivacky // specifier. Remove once this area of the code gets sorted out. 1099198092Srdivacky if (D->getAccess() != AS_none) 1100198092Srdivacky Record->setAccess(D->getAccess()); 1101193326Sed if (!D->isInjectedClassName()) 1102198092Srdivacky Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation); 1103193326Sed 1104198092Srdivacky // If the original function was part of a friend declaration, 1105198092Srdivacky // inherit its namespace state. 1106198092Srdivacky if (Decl::FriendObjectKind FOK = D->getFriendObjectKind()) 1107198092Srdivacky Record->setObjectOfFriendDecl(FOK == Decl::FOK_Declared); 1108198092Srdivacky 1109208600Srdivacky // Make sure that anonymous structs and unions are recorded. 1110208600Srdivacky if (D->isAnonymousStructOrUnion()) { 1111208600Srdivacky Record->setAnonymousStructOrUnion(true); 1112212904Sdim if (Record->getDeclContext()->getRedeclContext()->isFunctionOrMethod()) 1113208600Srdivacky SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record); 1114208600Srdivacky } 1115198092Srdivacky 1116195341Sed Owner->addDecl(Record); 1117193326Sed return Record; 1118193326Sed} 1119193326Sed 1120243830Sdim/// \brief Adjust the given function type for an instantiation of the 1121243830Sdim/// given declaration, to cope with modifications to the function's type that 1122243830Sdim/// aren't reflected in the type-source information. 1123243830Sdim/// 1124243830Sdim/// \param D The declaration we're instantiating. 1125243830Sdim/// \param TInfo The already-instantiated type. 1126243830Sdimstatic QualType adjustFunctionTypeForInstantiation(ASTContext &Context, 1127243830Sdim FunctionDecl *D, 1128243830Sdim TypeSourceInfo *TInfo) { 1129243830Sdim const FunctionProtoType *OrigFunc 1130243830Sdim = D->getType()->castAs<FunctionProtoType>(); 1131243830Sdim const FunctionProtoType *NewFunc 1132243830Sdim = TInfo->getType()->castAs<FunctionProtoType>(); 1133243830Sdim if (OrigFunc->getExtInfo() == NewFunc->getExtInfo()) 1134243830Sdim return TInfo->getType(); 1135243830Sdim 1136243830Sdim FunctionProtoType::ExtProtoInfo NewEPI = NewFunc->getExtProtoInfo(); 1137243830Sdim NewEPI.ExtInfo = OrigFunc->getExtInfo(); 1138243830Sdim return Context.getFunctionType(NewFunc->getResultType(), 1139249423Sdim ArrayRef<QualType>(NewFunc->arg_type_begin(), 1140249423Sdim NewFunc->getNumArgs()), 1141243830Sdim NewEPI); 1142243830Sdim} 1143243830Sdim 1144198092Srdivacky/// Normal class members are of more specific types and therefore 1145198092Srdivacky/// don't make it here. This function serves two purposes: 1146198092Srdivacky/// 1) instantiating function templates 1147198092Srdivacky/// 2) substituting friend declarations 1148198092Srdivacky/// FIXME: preserve function definitions in case #2 1149201361SrdivackyDecl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D, 1150198092Srdivacky TemplateParameterList *TemplateParams) { 1151195341Sed // Check whether there is already a function template specialization for 1152195341Sed // this declaration. 1153195341Sed FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate(); 1154198092Srdivacky if (FunctionTemplate && !TemplateParams) { 1155251662Sdim ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost(); 1156198092Srdivacky 1157234353Sdim void *InsertPos = 0; 1158212904Sdim FunctionDecl *SpecFunc 1159251662Sdim = FunctionTemplate->findSpecialization(Innermost.begin(), Innermost.size(), 1160212904Sdim InsertPos); 1161198092Srdivacky 1162195341Sed // If we already have a function template specialization, return it. 1163212904Sdim if (SpecFunc) 1164212904Sdim return SpecFunc; 1165195341Sed } 1166198092Srdivacky 1167206084Srdivacky bool isFriend; 1168206084Srdivacky if (FunctionTemplate) 1169206084Srdivacky isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None); 1170206084Srdivacky else 1171206084Srdivacky isFriend = (D->getFriendObjectKind() != Decl::FOK_None); 1172206084Srdivacky 1173202879Srdivacky bool MergeWithParentScope = (TemplateParams != 0) || 1174208600Srdivacky Owner->isFunctionOrMethod() || 1175226633Sdim !(isa<Decl>(Owner) && 1176202879Srdivacky cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod()); 1177212904Sdim LocalInstantiationScope Scope(SemaRef, MergeWithParentScope); 1178198092Srdivacky 1179226633Sdim SmallVector<ParmVarDecl *, 4> Params; 1180234353Sdim TypeSourceInfo *TInfo = SubstFunctionType(D, Params); 1181205219Srdivacky if (!TInfo) 1182193326Sed return 0; 1183243830Sdim QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo); 1184198092Srdivacky 1185219077Sdim NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc(); 1186219077Sdim if (QualifierLoc) { 1187219077Sdim QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, 1188219077Sdim TemplateArgs); 1189219077Sdim if (!QualifierLoc) 1190219077Sdim return 0; 1191206084Srdivacky } 1192206084Srdivacky 1193203955Srdivacky // If we're instantiating a local function declaration, put the result 1194203955Srdivacky // in the owner; otherwise we need to find the instantiated context. 1195203955Srdivacky DeclContext *DC; 1196203955Srdivacky if (D->getDeclContext()->isFunctionOrMethod()) 1197203955Srdivacky DC = Owner; 1198219077Sdim else if (isFriend && QualifierLoc) { 1199206084Srdivacky CXXScopeSpec SS; 1200219077Sdim SS.Adopt(QualifierLoc); 1201206084Srdivacky DC = SemaRef.computeDeclContext(SS); 1202206084Srdivacky if (!DC) return 0; 1203206084Srdivacky } else { 1204226633Sdim DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(), 1205204643Srdivacky TemplateArgs); 1206206084Srdivacky } 1207203955Srdivacky 1208198092Srdivacky FunctionDecl *Function = 1209221345Sdim FunctionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(), 1210243830Sdim D->getNameInfo(), T, TInfo, 1211251662Sdim D->getCanonicalDecl()->getStorageClass(), 1212226633Sdim D->isInlineSpecified(), D->hasWrittenPrototype(), 1213234353Sdim D->isConstexpr()); 1214205219Srdivacky 1215249423Sdim if (D->isInlined()) 1216249423Sdim Function->setImplicitlyInline(); 1217249423Sdim 1218219077Sdim if (QualifierLoc) 1219219077Sdim Function->setQualifierInfo(QualifierLoc); 1220205219Srdivacky 1221206084Srdivacky DeclContext *LexicalDC = Owner; 1222206084Srdivacky if (!isFriend && D->isOutOfLine()) { 1223206084Srdivacky assert(D->getDeclContext()->isFileContext()); 1224206084Srdivacky LexicalDC = D->getDeclContext(); 1225206084Srdivacky } 1226198092Srdivacky 1227206084Srdivacky Function->setLexicalDeclContext(LexicalDC); 1228206084Srdivacky 1229195099Sed // Attach the parameters 1230224145Sdim if (isa<FunctionProtoType>(Function->getType().IgnoreParens())) { 1231224145Sdim // Adopt the already-instantiated parameters into our own context. 1232224145Sdim for (unsigned P = 0; P < Params.size(); ++P) 1233224145Sdim if (Params[P]) 1234224145Sdim Params[P]->setOwningFunction(Function); 1235224145Sdim } else { 1236224145Sdim // Since we were instantiated via a typedef of a function type, create 1237224145Sdim // new parameters. 1238224145Sdim const FunctionProtoType *Proto 1239224145Sdim = Function->getType()->getAs<FunctionProtoType>(); 1240224145Sdim assert(Proto && "No function prototype in template instantiation?"); 1241224145Sdim for (FunctionProtoType::arg_type_iterator AI = Proto->arg_type_begin(), 1242224145Sdim AE = Proto->arg_type_end(); AI != AE; ++AI) { 1243224145Sdim ParmVarDecl *Param 1244224145Sdim = SemaRef.BuildParmVarDeclForTypedef(Function, Function->getLocation(), 1245224145Sdim *AI); 1246224145Sdim Param->setScopeInfo(0, Params.size()); 1247224145Sdim Params.push_back(Param); 1248224145Sdim } 1249224145Sdim } 1250226633Sdim Function->setParams(Params); 1251198092Srdivacky 1252208600Srdivacky SourceLocation InstantiateAtPOI; 1253198092Srdivacky if (TemplateParams) { 1254198092Srdivacky // Our resulting instantiation is actually a function template, since we 1255198092Srdivacky // are substituting only the outer template parameters. For example, given 1256198092Srdivacky // 1257198092Srdivacky // template<typename T> 1258198092Srdivacky // struct X { 1259198092Srdivacky // template<typename U> friend void f(T, U); 1260198092Srdivacky // }; 1261198092Srdivacky // 1262198092Srdivacky // X<int> x; 1263198092Srdivacky // 1264226633Sdim // We are instantiating the friend function template "f" within X<int>, 1265198092Srdivacky // which means substituting int for T, but leaving "f" as a friend function 1266198092Srdivacky // template. 1267198092Srdivacky // Build the function template itself. 1268206084Srdivacky FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC, 1269198092Srdivacky Function->getLocation(), 1270198092Srdivacky Function->getDeclName(), 1271198092Srdivacky TemplateParams, Function); 1272198092Srdivacky Function->setDescribedFunctionTemplate(FunctionTemplate); 1273206084Srdivacky 1274206084Srdivacky FunctionTemplate->setLexicalDeclContext(LexicalDC); 1275206084Srdivacky 1276206084Srdivacky if (isFriend && D->isThisDeclarationADefinition()) { 1277206084Srdivacky // TODO: should we remember this connection regardless of whether 1278206084Srdivacky // the friend declaration provided a body? 1279206084Srdivacky FunctionTemplate->setInstantiatedFromMemberTemplate( 1280206084Srdivacky D->getDescribedFunctionTemplate()); 1281206084Srdivacky } 1282199482Srdivacky } else if (FunctionTemplate) { 1283199482Srdivacky // Record this function template specialization. 1284251662Sdim ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost(); 1285203955Srdivacky Function->setFunctionTemplateSpecialization(FunctionTemplate, 1286218893Sdim TemplateArgumentList::CreateCopy(SemaRef.Context, 1287251662Sdim Innermost.begin(), 1288251662Sdim Innermost.size()), 1289234353Sdim /*InsertPos=*/0); 1290226633Sdim } else if (isFriend) { 1291226633Sdim // Note, we need this connection even if the friend doesn't have a body. 1292226633Sdim // Its body may exist but not have been attached yet due to deferred 1293226633Sdim // parsing. 1294226633Sdim // FIXME: It might be cleaner to set this when attaching the body to the 1295226633Sdim // friend function declaration, however that would require finding all the 1296226633Sdim // instantiations and modifying them. 1297206084Srdivacky Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation); 1298198092Srdivacky } 1299226633Sdim 1300195099Sed if (InitFunctionInstantiation(Function, D)) 1301195099Sed Function->setInvalidDecl(); 1302198092Srdivacky 1303207619Srdivacky bool isExplicitSpecialization = false; 1304226633Sdim 1305199512Srdivacky LookupResult Previous(SemaRef, Function->getDeclName(), SourceLocation(), 1306199512Srdivacky Sema::LookupOrdinaryName, Sema::ForRedeclaration); 1307199512Srdivacky 1308207619Srdivacky if (DependentFunctionTemplateSpecializationInfo *Info 1309207619Srdivacky = D->getDependentSpecializationInfo()) { 1310207619Srdivacky assert(isFriend && "non-friend has dependent specialization info?"); 1311207619Srdivacky 1312207619Srdivacky // This needs to be set now for future sanity. 1313207619Srdivacky Function->setObjectOfFriendDecl(/*HasPrevious*/ true); 1314207619Srdivacky 1315207619Srdivacky // Instantiate the explicit template arguments. 1316207619Srdivacky TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(), 1317207619Srdivacky Info->getRAngleLoc()); 1318218893Sdim if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(), 1319218893Sdim ExplicitArgs, TemplateArgs)) 1320218893Sdim return 0; 1321207619Srdivacky 1322207619Srdivacky // Map the candidate templates to their instantiations. 1323207619Srdivacky for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) { 1324207619Srdivacky Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(), 1325207619Srdivacky Info->getTemplate(I), 1326207619Srdivacky TemplateArgs); 1327207619Srdivacky if (!Temp) return 0; 1328207619Srdivacky 1329207619Srdivacky Previous.addDecl(cast<FunctionTemplateDecl>(Temp)); 1330207619Srdivacky } 1331207619Srdivacky 1332207619Srdivacky if (SemaRef.CheckFunctionTemplateSpecialization(Function, 1333207619Srdivacky &ExplicitArgs, 1334207619Srdivacky Previous)) 1335207619Srdivacky Function->setInvalidDecl(); 1336226633Sdim 1337207619Srdivacky isExplicitSpecialization = true; 1338207619Srdivacky 1339207619Srdivacky } else if (TemplateParams || !FunctionTemplate) { 1340226633Sdim // Look only into the namespace where the friend would be declared to 1341226633Sdim // find a previous declaration. This is the innermost enclosing namespace, 1342198092Srdivacky // as described in ActOnFriendFunctionDecl. 1343199512Srdivacky SemaRef.LookupQualifiedName(Previous, DC); 1344226633Sdim 1345198092Srdivacky // In C++, the previous declaration we find might be a tag type 1346198092Srdivacky // (class or enum). In this case, the new declaration will hide the 1347198092Srdivacky // tag type. Note that this does does not apply if we're declaring a 1348198092Srdivacky // typedef (C++ [dcl.typedef]p4). 1349199512Srdivacky if (Previous.isSingleTagDecl()) 1350199512Srdivacky Previous.clear(); 1351198092Srdivacky } 1352226633Sdim 1353200583Srdivacky SemaRef.CheckFunctionDeclaration(/*Scope*/ 0, Function, Previous, 1354226633Sdim isExplicitSpecialization); 1355193326Sed 1356207619Srdivacky NamedDecl *PrincipalDecl = (TemplateParams 1357207619Srdivacky ? cast<NamedDecl>(FunctionTemplate) 1358207619Srdivacky : Function); 1359207619Srdivacky 1360198092Srdivacky // If the original function was part of a friend declaration, 1361198092Srdivacky // inherit its namespace state and add it to the owner. 1362206084Srdivacky if (isFriend) { 1363199512Srdivacky NamedDecl *PrevDecl; 1364207619Srdivacky if (TemplateParams) 1365234353Sdim PrevDecl = FunctionTemplate->getPreviousDecl(); 1366207619Srdivacky else 1367234353Sdim PrevDecl = Function->getPreviousDecl(); 1368207619Srdivacky 1369207619Srdivacky PrincipalDecl->setObjectOfFriendDecl(PrevDecl != 0); 1370234353Sdim DC->makeDeclVisibleInContext(PrincipalDecl); 1371212904Sdim 1372212904Sdim bool queuedInstantiation = false; 1373212904Sdim 1374234353Sdim // C++98 [temp.friend]p5: When a function is defined in a friend function 1375234353Sdim // declaration in a class template, the function is defined at each 1376234353Sdim // instantiation of the class template. The function is defined even if it 1377234353Sdim // is never used. 1378234353Sdim // C++11 [temp.friend]p4: When a function is defined in a friend function 1379234353Sdim // declaration in a class template, the function is instantiated when the 1380234353Sdim // function is odr-used. 1381234353Sdim // 1382234353Sdim // If -Wc++98-compat is enabled, we go through the motions of checking for a 1383234353Sdim // redefinition, but don't instantiate the function. 1384249423Sdim if ((!SemaRef.getLangOpts().CPlusPlus11 || 1385234353Sdim SemaRef.Diags.getDiagnosticLevel( 1386234353Sdim diag::warn_cxx98_compat_friend_redefinition, 1387234353Sdim Function->getLocation()) 1388234353Sdim != DiagnosticsEngine::Ignored) && 1389208600Srdivacky D->isThisDeclarationADefinition()) { 1390208600Srdivacky // Check for a function body. 1391208600Srdivacky const FunctionDecl *Definition = 0; 1392223017Sdim if (Function->isDefined(Definition) && 1393208600Srdivacky Definition->getTemplateSpecializationKind() == TSK_Undeclared) { 1394234353Sdim SemaRef.Diag(Function->getLocation(), 1395249423Sdim SemaRef.getLangOpts().CPlusPlus11 ? 1396234353Sdim diag::warn_cxx98_compat_friend_redefinition : 1397234353Sdim diag::err_redefinition) << Function->getDeclName(); 1398208600Srdivacky SemaRef.Diag(Definition->getLocation(), diag::note_previous_definition); 1399249423Sdim if (!SemaRef.getLangOpts().CPlusPlus11) 1400234353Sdim Function->setInvalidDecl(); 1401226633Sdim } 1402208600Srdivacky // Check for redefinitions due to other instantiations of this or 1403208600Srdivacky // a similar friend function. 1404208600Srdivacky else for (FunctionDecl::redecl_iterator R = Function->redecls_begin(), 1405208600Srdivacky REnd = Function->redecls_end(); 1406208600Srdivacky R != REnd; ++R) { 1407212904Sdim if (*R == Function) 1408212904Sdim continue; 1409212904Sdim switch (R->getFriendObjectKind()) { 1410212904Sdim case Decl::FOK_None: 1411249423Sdim if (!SemaRef.getLangOpts().CPlusPlus11 && 1412234353Sdim !queuedInstantiation && R->isUsed(false)) { 1413212904Sdim if (MemberSpecializationInfo *MSInfo 1414212904Sdim = Function->getMemberSpecializationInfo()) { 1415212904Sdim if (MSInfo->getPointOfInstantiation().isInvalid()) { 1416212904Sdim SourceLocation Loc = R->getLocation(); // FIXME 1417212904Sdim MSInfo->setPointOfInstantiation(Loc); 1418212904Sdim SemaRef.PendingLocalImplicitInstantiations.push_back( 1419212904Sdim std::make_pair(Function, Loc)); 1420212904Sdim queuedInstantiation = true; 1421212904Sdim } 1422212904Sdim } 1423212904Sdim } 1424212904Sdim break; 1425212904Sdim default: 1426208600Srdivacky if (const FunctionDecl *RPattern 1427212904Sdim = R->getTemplateInstantiationPattern()) 1428223017Sdim if (RPattern->isDefined(RPattern)) { 1429234353Sdim SemaRef.Diag(Function->getLocation(), 1430249423Sdim SemaRef.getLangOpts().CPlusPlus11 ? 1431234353Sdim diag::warn_cxx98_compat_friend_redefinition : 1432234353Sdim diag::err_redefinition) 1433208600Srdivacky << Function->getDeclName(); 1434212904Sdim SemaRef.Diag(R->getLocation(), diag::note_previous_definition); 1435249423Sdim if (!SemaRef.getLangOpts().CPlusPlus11) 1436234353Sdim Function->setInvalidDecl(); 1437208600Srdivacky break; 1438208600Srdivacky } 1439208600Srdivacky } 1440208600Srdivacky } 1441208600Srdivacky } 1442198092Srdivacky } 1443198092Srdivacky 1444207619Srdivacky if (Function->isOverloadedOperator() && !DC->isRecord() && 1445207619Srdivacky PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 1446207619Srdivacky PrincipalDecl->setNonMemberOperator(); 1447207619Srdivacky 1448223017Sdim assert(!D->isDefaulted() && "only methods should be defaulted"); 1449195099Sed return Function; 1450195099Sed} 1451195099Sed 1452198092SrdivackyDecl * 1453198092SrdivackyTemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D, 1454226633Sdim TemplateParameterList *TemplateParams, 1455226633Sdim bool IsClassScopeSpecialization) { 1456198092Srdivacky FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate(); 1457198092Srdivacky if (FunctionTemplate && !TemplateParams) { 1458198092Srdivacky // We are creating a function template specialization from a function 1459198092Srdivacky // template. Check whether there is already a function template 1460198092Srdivacky // specialization for this particular set of template arguments. 1461251662Sdim ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost(); 1462198092Srdivacky 1463234353Sdim void *InsertPos = 0; 1464212904Sdim FunctionDecl *SpecFunc 1465251662Sdim = FunctionTemplate->findSpecialization(Innermost.begin(), 1466251662Sdim Innermost.size(), 1467212904Sdim InsertPos); 1468198092Srdivacky 1469198092Srdivacky // If we already have a function template specialization, return it. 1470212904Sdim if (SpecFunc) 1471212904Sdim return SpecFunc; 1472198092Srdivacky } 1473198092Srdivacky 1474206084Srdivacky bool isFriend; 1475206084Srdivacky if (FunctionTemplate) 1476206084Srdivacky isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None); 1477206084Srdivacky else 1478206084Srdivacky isFriend = (D->getFriendObjectKind() != Decl::FOK_None); 1479206084Srdivacky 1480202879Srdivacky bool MergeWithParentScope = (TemplateParams != 0) || 1481226633Sdim !(isa<Decl>(Owner) && 1482202879Srdivacky cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod()); 1483212904Sdim LocalInstantiationScope Scope(SemaRef, MergeWithParentScope); 1484193326Sed 1485218893Sdim // Instantiate enclosing template arguments for friends. 1486226633Sdim SmallVector<TemplateParameterList *, 4> TempParamLists; 1487218893Sdim unsigned NumTempParamLists = 0; 1488218893Sdim if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) { 1489218893Sdim TempParamLists.set_size(NumTempParamLists); 1490218893Sdim for (unsigned I = 0; I != NumTempParamLists; ++I) { 1491218893Sdim TemplateParameterList *TempParams = D->getTemplateParameterList(I); 1492218893Sdim TemplateParameterList *InstParams = SubstTemplateParams(TempParams); 1493218893Sdim if (!InstParams) 1494218893Sdim return NULL; 1495218893Sdim TempParamLists[I] = InstParams; 1496218893Sdim } 1497218893Sdim } 1498218893Sdim 1499226633Sdim SmallVector<ParmVarDecl *, 4> Params; 1500234353Sdim TypeSourceInfo *TInfo = SubstFunctionType(D, Params); 1501205219Srdivacky if (!TInfo) 1502193326Sed return 0; 1503243830Sdim QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo); 1504193326Sed 1505218893Sdim // \brief If the type of this function, after ignoring parentheses, 1506218893Sdim // is not *directly* a function type, then we're instantiating a function 1507218893Sdim // that was declared via a typedef, e.g., 1508207632Srdivacky // 1509207632Srdivacky // typedef int functype(int, int); 1510207632Srdivacky // functype func; 1511207632Srdivacky // 1512207632Srdivacky // In this case, we'll just go instantiate the ParmVarDecls that we 1513207632Srdivacky // synthesized in the method declaration. 1514218893Sdim if (!isa<FunctionProtoType>(T.IgnoreParens())) { 1515207632Srdivacky assert(!Params.size() && "Instantiating type could not yield parameters"); 1516226633Sdim SmallVector<QualType, 4> ParamTypes; 1517226633Sdim if (SemaRef.SubstParmTypes(D->getLocation(), D->param_begin(), 1518226633Sdim D->getNumParams(), TemplateArgs, ParamTypes, 1519218893Sdim &Params)) 1520226633Sdim return 0; 1521207632Srdivacky } 1522207632Srdivacky 1523219077Sdim NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc(); 1524219077Sdim if (QualifierLoc) { 1525219077Sdim QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, 1526206084Srdivacky TemplateArgs); 1527226633Sdim if (!QualifierLoc) 1528219077Sdim return 0; 1529206084Srdivacky } 1530206084Srdivacky 1531206084Srdivacky DeclContext *DC = Owner; 1532206084Srdivacky if (isFriend) { 1533219077Sdim if (QualifierLoc) { 1534206084Srdivacky CXXScopeSpec SS; 1535219077Sdim SS.Adopt(QualifierLoc); 1536206084Srdivacky DC = SemaRef.computeDeclContext(SS); 1537218893Sdim 1538218893Sdim if (DC && SemaRef.RequireCompleteDeclContext(SS, DC)) 1539218893Sdim return 0; 1540206084Srdivacky } else { 1541206084Srdivacky DC = SemaRef.FindInstantiatedContext(D->getLocation(), 1542206084Srdivacky D->getDeclContext(), 1543206084Srdivacky TemplateArgs); 1544206084Srdivacky } 1545206084Srdivacky if (!DC) return 0; 1546206084Srdivacky } 1547206084Srdivacky 1548193326Sed // Build the instantiated method declaration. 1549206084Srdivacky CXXRecordDecl *Record = cast<CXXRecordDecl>(DC); 1550198092Srdivacky CXXMethodDecl *Method = 0; 1551193326Sed 1552221345Sdim SourceLocation StartLoc = D->getInnerLocStart(); 1553212904Sdim DeclarationNameInfo NameInfo 1554212904Sdim = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs); 1555198092Srdivacky if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) { 1556198092Srdivacky Method = CXXConstructorDecl::Create(SemaRef.Context, Record, 1557221345Sdim StartLoc, NameInfo, T, TInfo, 1558198092Srdivacky Constructor->isExplicit(), 1559207619Srdivacky Constructor->isInlineSpecified(), 1560234353Sdim false, Constructor->isConstexpr()); 1561251662Sdim 1562251662Sdim // Claim that the instantiation of a constructor or constructor template 1563251662Sdim // inherits the same constructor that the template does. 1564251662Sdim if (CXXConstructorDecl *Inh = const_cast<CXXConstructorDecl *>( 1565251662Sdim Constructor->getInheritedConstructor())) { 1566251662Sdim // If we're instantiating a specialization of a function template, our 1567251662Sdim // "inherited constructor" will actually itself be a function template. 1568251662Sdim // Instantiate a declaration of it, too. 1569251662Sdim if (FunctionTemplate) { 1570251662Sdim assert(!TemplateParams && Inh->getDescribedFunctionTemplate() && 1571251662Sdim !Inh->getParent()->isDependentContext() && 1572251662Sdim "inheriting constructor template in dependent context?"); 1573251662Sdim Sema::InstantiatingTemplate Inst(SemaRef, Constructor->getLocation(), 1574251662Sdim Inh); 1575251662Sdim if (Inst) 1576251662Sdim return 0; 1577251662Sdim Sema::ContextRAII SavedContext(SemaRef, Inh->getDeclContext()); 1578251662Sdim LocalInstantiationScope LocalScope(SemaRef); 1579251662Sdim 1580251662Sdim // Use the same template arguments that we deduced for the inheriting 1581251662Sdim // constructor. There's no way they could be deduced differently. 1582251662Sdim MultiLevelTemplateArgumentList InheritedArgs; 1583251662Sdim InheritedArgs.addOuterTemplateArguments(TemplateArgs.getInnermost()); 1584251662Sdim Inh = cast_or_null<CXXConstructorDecl>( 1585251662Sdim SemaRef.SubstDecl(Inh, Inh->getDeclContext(), InheritedArgs)); 1586251662Sdim if (!Inh) 1587251662Sdim return 0; 1588251662Sdim } 1589251662Sdim cast<CXXConstructorDecl>(Method)->setInheritedConstructor(Inh); 1590251662Sdim } 1591198092Srdivacky } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) { 1592198092Srdivacky Method = CXXDestructorDecl::Create(SemaRef.Context, Record, 1593221345Sdim StartLoc, NameInfo, T, TInfo, 1594212904Sdim Destructor->isInlineSpecified(), 1595207619Srdivacky false); 1596198092Srdivacky } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) { 1597198092Srdivacky Method = CXXConversionDecl::Create(SemaRef.Context, Record, 1598221345Sdim StartLoc, NameInfo, T, TInfo, 1599198893Srdivacky Conversion->isInlineSpecified(), 1600221345Sdim Conversion->isExplicit(), 1601234353Sdim Conversion->isConstexpr(), 1602221345Sdim Conversion->getLocEnd()); 1603198092Srdivacky } else { 1604251662Sdim StorageClass SC = D->isStatic() ? SC_Static : SC_None; 1605212904Sdim Method = CXXMethodDecl::Create(SemaRef.Context, Record, 1606221345Sdim StartLoc, NameInfo, T, TInfo, 1607251662Sdim SC, D->isInlineSpecified(), 1608234353Sdim D->isConstexpr(), D->getLocEnd()); 1609198092Srdivacky } 1610198092Srdivacky 1611249423Sdim if (D->isInlined()) 1612249423Sdim Method->setImplicitlyInline(); 1613249423Sdim 1614219077Sdim if (QualifierLoc) 1615219077Sdim Method->setQualifierInfo(QualifierLoc); 1616205219Srdivacky 1617198092Srdivacky if (TemplateParams) { 1618198092Srdivacky // Our resulting instantiation is actually a function template, since we 1619198092Srdivacky // are substituting only the outer template parameters. For example, given 1620198092Srdivacky // 1621198092Srdivacky // template<typename T> 1622198092Srdivacky // struct X { 1623198092Srdivacky // template<typename U> void f(T, U); 1624198092Srdivacky // }; 1625198092Srdivacky // 1626198092Srdivacky // X<int> x; 1627198092Srdivacky // 1628198092Srdivacky // We are instantiating the member template "f" within X<int>, which means 1629198092Srdivacky // substituting int for T, but leaving "f" as a member function template. 1630198092Srdivacky // Build the function template itself. 1631198092Srdivacky FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record, 1632198092Srdivacky Method->getLocation(), 1633198092Srdivacky Method->getDeclName(), 1634198092Srdivacky TemplateParams, Method); 1635206084Srdivacky if (isFriend) { 1636206084Srdivacky FunctionTemplate->setLexicalDeclContext(Owner); 1637206084Srdivacky FunctionTemplate->setObjectOfFriendDecl(true); 1638206084Srdivacky } else if (D->isOutOfLine()) 1639198092Srdivacky FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext()); 1640198092Srdivacky Method->setDescribedFunctionTemplate(FunctionTemplate); 1641199482Srdivacky } else if (FunctionTemplate) { 1642199482Srdivacky // Record this function template specialization. 1643251662Sdim ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost(); 1644203955Srdivacky Method->setFunctionTemplateSpecialization(FunctionTemplate, 1645218893Sdim TemplateArgumentList::CreateCopy(SemaRef.Context, 1646251662Sdim Innermost.begin(), 1647251662Sdim Innermost.size()), 1648234353Sdim /*InsertPos=*/0); 1649206084Srdivacky } else if (!isFriend) { 1650199482Srdivacky // Record that this is an instantiation of a member function. 1651198092Srdivacky Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation); 1652199482Srdivacky } 1653226633Sdim 1654198092Srdivacky // If we are instantiating a member function defined 1655198092Srdivacky // out-of-line, the instantiation will have the same lexical 1656198092Srdivacky // context (which will be a namespace scope) as the template. 1657206084Srdivacky if (isFriend) { 1658218893Sdim if (NumTempParamLists) 1659218893Sdim Method->setTemplateParameterListsInfo(SemaRef.Context, 1660218893Sdim NumTempParamLists, 1661218893Sdim TempParamLists.data()); 1662218893Sdim 1663206084Srdivacky Method->setLexicalDeclContext(Owner); 1664206084Srdivacky Method->setObjectOfFriendDecl(true); 1665206084Srdivacky } else if (D->isOutOfLine()) 1666198092Srdivacky Method->setLexicalDeclContext(D->getLexicalDeclContext()); 1667198092Srdivacky 1668193326Sed // Attach the parameters 1669193326Sed for (unsigned P = 0; P < Params.size(); ++P) 1670193326Sed Params[P]->setOwningFunction(Method); 1671226633Sdim Method->setParams(Params); 1672193326Sed 1673193326Sed if (InitMethodInstantiation(Method, D)) 1674193326Sed Method->setInvalidDecl(); 1675193326Sed 1676212904Sdim LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName, 1677212904Sdim Sema::ForRedeclaration); 1678198092Srdivacky 1679206084Srdivacky if (!FunctionTemplate || TemplateParams || isFriend) { 1680206084Srdivacky SemaRef.LookupQualifiedName(Previous, Record); 1681198092Srdivacky 1682198092Srdivacky // In C++, the previous declaration we find might be a tag type 1683198092Srdivacky // (class or enum). In this case, the new declaration will hide the 1684198092Srdivacky // tag type. Note that this does does not apply if we're declaring a 1685198092Srdivacky // typedef (C++ [dcl.typedef]p4). 1686199512Srdivacky if (Previous.isSingleTagDecl()) 1687199512Srdivacky Previous.clear(); 1688198092Srdivacky } 1689198092Srdivacky 1690226633Sdim if (!IsClassScopeSpecialization) 1691226633Sdim SemaRef.CheckFunctionDeclaration(0, Method, Previous, false); 1692193326Sed 1693200583Srdivacky if (D->isPure()) 1694200583Srdivacky SemaRef.CheckPureMethod(Method, SourceRange()); 1695200583Srdivacky 1696239462Sdim // Propagate access. For a non-friend declaration, the access is 1697239462Sdim // whatever we're propagating from. For a friend, it should be the 1698239462Sdim // previous declaration we just found. 1699239462Sdim if (isFriend && Method->getPreviousDecl()) 1700239462Sdim Method->setAccess(Method->getPreviousDecl()->getAccess()); 1701239462Sdim else 1702239462Sdim Method->setAccess(D->getAccess()); 1703239462Sdim if (FunctionTemplate) 1704239462Sdim FunctionTemplate->setAccess(Method->getAccess()); 1705202879Srdivacky 1706218893Sdim SemaRef.CheckOverrideControl(Method); 1707218893Sdim 1708234353Sdim // If a function is defined as defaulted or deleted, mark it as such now. 1709249423Sdim if (D->isExplicitlyDefaulted()) 1710249423Sdim SemaRef.SetDeclDefaulted(Method, Method->getLocation()); 1711234353Sdim if (D->isDeletedAsWritten()) 1712249423Sdim SemaRef.SetDeclDeleted(Method, Method->getLocation()); 1713234353Sdim 1714239462Sdim // If there's a function template, let our caller handle it. 1715206084Srdivacky if (FunctionTemplate) { 1716239462Sdim // do nothing 1717239462Sdim 1718239462Sdim // Don't hide a (potentially) valid declaration with an invalid one. 1719206084Srdivacky } else if (Method->isInvalidDecl() && !Previous.empty()) { 1720239462Sdim // do nothing 1721239462Sdim 1722239462Sdim // Otherwise, check access to friends and make them visible. 1723239462Sdim } else if (isFriend) { 1724239462Sdim // We only need to re-check access for methods which we didn't 1725239462Sdim // manage to match during parsing. 1726239462Sdim if (!D->getPreviousDecl()) 1727239462Sdim SemaRef.CheckFriendAccess(Method); 1728239462Sdim 1729239462Sdim Record->makeDeclVisibleInContext(Method); 1730239462Sdim 1731239462Sdim // Otherwise, add the declaration. We don't need to do this for 1732239462Sdim // class-scope specializations because we'll have matched them with 1733239462Sdim // the appropriate template. 1734239462Sdim } else if (!IsClassScopeSpecialization) { 1735239462Sdim Owner->addDecl(Method); 1736206084Srdivacky } 1737223017Sdim 1738193326Sed return Method; 1739193326Sed} 1740193326Sed 1741193326SedDecl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 1742198092Srdivacky return VisitCXXMethodDecl(D); 1743193326Sed} 1744193326Sed 1745193326SedDecl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 1746198092Srdivacky return VisitCXXMethodDecl(D); 1747193326Sed} 1748193326Sed 1749193326SedDecl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) { 1750198092Srdivacky return VisitCXXMethodDecl(D); 1751193326Sed} 1752193326Sed 1753193326SedParmVarDecl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) { 1754249423Sdim return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0, None, 1755249423Sdim /*ExpectParameterPack=*/ false); 1756193326Sed} 1757193326Sed 1758198092SrdivackyDecl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl( 1759198092Srdivacky TemplateTypeParmDecl *D) { 1760198092Srdivacky // TODO: don't always clone when decls are refcounted. 1761221345Sdim assert(D->getTypeForDecl()->isTemplateTypeParmType()); 1762198092Srdivacky 1763198092Srdivacky TemplateTypeParmDecl *Inst = 1764221345Sdim TemplateTypeParmDecl::Create(SemaRef.Context, Owner, 1765221345Sdim D->getLocStart(), D->getLocation(), 1766221345Sdim D->getDepth() - TemplateArgs.getNumLevels(), 1767221345Sdim D->getIndex(), D->getIdentifier(), 1768198092Srdivacky D->wasDeclaredWithTypename(), 1769198092Srdivacky D->isParameterPack()); 1770221345Sdim Inst->setAccess(AS_public); 1771226633Sdim 1772199482Srdivacky if (D->hasDefaultArgument()) 1773226633Sdim Inst->setDefaultArgument(D->getDefaultArgumentInfo(), false); 1774198092Srdivacky 1775226633Sdim // Introduce this template parameter's instantiation into the instantiation 1776198893Srdivacky // scope. 1777198893Srdivacky SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst); 1778226633Sdim 1779198092Srdivacky return Inst; 1780198092Srdivacky} 1781198092Srdivacky 1782198893SrdivackyDecl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl( 1783198893Srdivacky NonTypeTemplateParmDecl *D) { 1784198893Srdivacky // Substitute into the type of the non-type template parameter. 1785218893Sdim TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc(); 1786226633Sdim SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten; 1787226633Sdim SmallVector<QualType, 4> ExpandedParameterPackTypes; 1788218893Sdim bool IsExpandedParameterPack = false; 1789226633Sdim TypeSourceInfo *DI; 1790198893Srdivacky QualType T; 1791218893Sdim bool Invalid = false; 1792218893Sdim 1793218893Sdim if (D->isExpandedParameterPack()) { 1794226633Sdim // The non-type template parameter pack is an already-expanded pack 1795218893Sdim // expansion of types. Substitute into each of the expanded types. 1796218893Sdim ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes()); 1797218893Sdim ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes()); 1798218893Sdim for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) { 1799218893Sdim TypeSourceInfo *NewDI =SemaRef.SubstType(D->getExpansionTypeSourceInfo(I), 1800218893Sdim TemplateArgs, 1801226633Sdim D->getLocation(), 1802218893Sdim D->getDeclName()); 1803218893Sdim if (!NewDI) 1804218893Sdim return 0; 1805226633Sdim 1806218893Sdim ExpandedParameterPackTypesAsWritten.push_back(NewDI); 1807218893Sdim QualType NewT =SemaRef.CheckNonTypeTemplateParameterType(NewDI->getType(), 1808218893Sdim D->getLocation()); 1809218893Sdim if (NewT.isNull()) 1810218893Sdim return 0; 1811218893Sdim ExpandedParameterPackTypes.push_back(NewT); 1812218893Sdim } 1813226633Sdim 1814218893Sdim IsExpandedParameterPack = true; 1815218893Sdim DI = D->getTypeSourceInfo(); 1816218893Sdim T = DI->getType(); 1817243830Sdim } else if (D->isPackExpansion()) { 1818218893Sdim // The non-type template parameter pack's type is a pack expansion of types. 1819218893Sdim // Determine whether we need to expand this parameter pack into separate 1820218893Sdim // types. 1821249423Sdim PackExpansionTypeLoc Expansion = TL.castAs<PackExpansionTypeLoc>(); 1822218893Sdim TypeLoc Pattern = Expansion.getPatternLoc(); 1823226633Sdim SmallVector<UnexpandedParameterPack, 2> Unexpanded; 1824218893Sdim SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded); 1825226633Sdim 1826218893Sdim // Determine whether the set of unexpanded parameter packs can and should 1827218893Sdim // be expanded. 1828218893Sdim bool Expand = true; 1829218893Sdim bool RetainExpansion = false; 1830249423Sdim Optional<unsigned> OrigNumExpansions 1831218893Sdim = Expansion.getTypePtr()->getNumExpansions(); 1832249423Sdim Optional<unsigned> NumExpansions = OrigNumExpansions; 1833218893Sdim if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(), 1834218893Sdim Pattern.getSourceRange(), 1835226633Sdim Unexpanded, 1836218893Sdim TemplateArgs, 1837226633Sdim Expand, RetainExpansion, 1838218893Sdim NumExpansions)) 1839218893Sdim return 0; 1840226633Sdim 1841218893Sdim if (Expand) { 1842218893Sdim for (unsigned I = 0; I != *NumExpansions; ++I) { 1843218893Sdim Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I); 1844218893Sdim TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs, 1845226633Sdim D->getLocation(), 1846218893Sdim D->getDeclName()); 1847218893Sdim if (!NewDI) 1848218893Sdim return 0; 1849226633Sdim 1850218893Sdim ExpandedParameterPackTypesAsWritten.push_back(NewDI); 1851218893Sdim QualType NewT = SemaRef.CheckNonTypeTemplateParameterType( 1852218893Sdim NewDI->getType(), 1853218893Sdim D->getLocation()); 1854218893Sdim if (NewT.isNull()) 1855218893Sdim return 0; 1856218893Sdim ExpandedParameterPackTypes.push_back(NewT); 1857218893Sdim } 1858226633Sdim 1859218893Sdim // Note that we have an expanded parameter pack. The "type" of this 1860218893Sdim // expanded parameter pack is the original expansion type, but callers 1861218893Sdim // will end up using the expanded parameter pack types for type-checking. 1862218893Sdim IsExpandedParameterPack = true; 1863218893Sdim DI = D->getTypeSourceInfo(); 1864218893Sdim T = DI->getType(); 1865218893Sdim } else { 1866218893Sdim // We cannot fully expand the pack expansion now, so substitute into the 1867218893Sdim // pattern and create a new pack expansion type. 1868218893Sdim Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1); 1869218893Sdim TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs, 1870226633Sdim D->getLocation(), 1871218893Sdim D->getDeclName()); 1872218893Sdim if (!NewPattern) 1873218893Sdim return 0; 1874226633Sdim 1875218893Sdim DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(), 1876218893Sdim NumExpansions); 1877218893Sdim if (!DI) 1878218893Sdim return 0; 1879226633Sdim 1880218893Sdim T = DI->getType(); 1881218893Sdim } 1882198893Srdivacky } else { 1883218893Sdim // Simple case: substitution into a parameter that is not a parameter pack. 1884226633Sdim DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs, 1885218893Sdim D->getLocation(), D->getDeclName()); 1886218893Sdim if (!DI) 1887218893Sdim return 0; 1888226633Sdim 1889218893Sdim // Check that this type is acceptable for a non-type template parameter. 1890226633Sdim T = SemaRef.CheckNonTypeTemplateParameterType(DI->getType(), 1891218893Sdim D->getLocation()); 1892218893Sdim if (T.isNull()) { 1893218893Sdim T = SemaRef.Context.IntTy; 1894218893Sdim Invalid = true; 1895218893Sdim } 1896198893Srdivacky } 1897226633Sdim 1898218893Sdim NonTypeTemplateParmDecl *Param; 1899218893Sdim if (IsExpandedParameterPack) 1900226633Sdim Param = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner, 1901221345Sdim D->getInnerLocStart(), 1902221345Sdim D->getLocation(), 1903226633Sdim D->getDepth() - TemplateArgs.getNumLevels(), 1904226633Sdim D->getPosition(), 1905218893Sdim D->getIdentifier(), T, 1906218893Sdim DI, 1907218893Sdim ExpandedParameterPackTypes.data(), 1908218893Sdim ExpandedParameterPackTypes.size(), 1909218893Sdim ExpandedParameterPackTypesAsWritten.data()); 1910218893Sdim else 1911226633Sdim Param = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner, 1912221345Sdim D->getInnerLocStart(), 1913218893Sdim D->getLocation(), 1914226633Sdim D->getDepth() - TemplateArgs.getNumLevels(), 1915226633Sdim D->getPosition(), 1916226633Sdim D->getIdentifier(), T, 1917218893Sdim D->isParameterPack(), DI); 1918226633Sdim 1919221345Sdim Param->setAccess(AS_public); 1920198893Srdivacky if (Invalid) 1921198893Srdivacky Param->setInvalidDecl(); 1922226633Sdim 1923210299Sed Param->setDefaultArgument(D->getDefaultArgument(), false); 1924226633Sdim 1925226633Sdim // Introduce this template parameter's instantiation into the instantiation 1926198893Srdivacky // scope. 1927198893Srdivacky SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param); 1928198893Srdivacky return Param; 1929198893Srdivacky} 1930198893Srdivacky 1931243830Sdimstatic void collectUnexpandedParameterPacks( 1932243830Sdim Sema &S, 1933243830Sdim TemplateParameterList *Params, 1934243830Sdim SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) { 1935243830Sdim for (TemplateParameterList::const_iterator I = Params->begin(), 1936243830Sdim E = Params->end(); I != E; ++I) { 1937243830Sdim if ((*I)->isTemplateParameterPack()) 1938243830Sdim continue; 1939243830Sdim if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*I)) 1940243830Sdim S.collectUnexpandedParameterPacks(NTTP->getTypeSourceInfo()->getTypeLoc(), 1941243830Sdim Unexpanded); 1942243830Sdim if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(*I)) 1943243830Sdim collectUnexpandedParameterPacks(S, TTP->getTemplateParameters(), 1944243830Sdim Unexpanded); 1945243830Sdim } 1946243830Sdim} 1947243830Sdim 1948198092SrdivackyDecl * 1949199482SrdivackyTemplateDeclInstantiator::VisitTemplateTemplateParmDecl( 1950199482Srdivacky TemplateTemplateParmDecl *D) { 1951199482Srdivacky // Instantiate the template parameter list of the template template parameter. 1952199482Srdivacky TemplateParameterList *TempParams = D->getTemplateParameters(); 1953199482Srdivacky TemplateParameterList *InstParams; 1954243830Sdim SmallVector<TemplateParameterList*, 8> ExpandedParams; 1955243830Sdim 1956243830Sdim bool IsExpandedParameterPack = false; 1957243830Sdim 1958243830Sdim if (D->isExpandedParameterPack()) { 1959243830Sdim // The template template parameter pack is an already-expanded pack 1960243830Sdim // expansion of template parameters. Substitute into each of the expanded 1961243830Sdim // parameters. 1962243830Sdim ExpandedParams.reserve(D->getNumExpansionTemplateParameters()); 1963243830Sdim for (unsigned I = 0, N = D->getNumExpansionTemplateParameters(); 1964243830Sdim I != N; ++I) { 1965243830Sdim LocalInstantiationScope Scope(SemaRef); 1966243830Sdim TemplateParameterList *Expansion = 1967243830Sdim SubstTemplateParams(D->getExpansionTemplateParameters(I)); 1968243830Sdim if (!Expansion) 1969243830Sdim return 0; 1970243830Sdim ExpandedParams.push_back(Expansion); 1971243830Sdim } 1972243830Sdim 1973243830Sdim IsExpandedParameterPack = true; 1974243830Sdim InstParams = TempParams; 1975243830Sdim } else if (D->isPackExpansion()) { 1976243830Sdim // The template template parameter pack expands to a pack of template 1977243830Sdim // template parameters. Determine whether we need to expand this parameter 1978243830Sdim // pack into separate parameters. 1979243830Sdim SmallVector<UnexpandedParameterPack, 2> Unexpanded; 1980243830Sdim collectUnexpandedParameterPacks(SemaRef, D->getTemplateParameters(), 1981243830Sdim Unexpanded); 1982243830Sdim 1983243830Sdim // Determine whether the set of unexpanded parameter packs can and should 1984243830Sdim // be expanded. 1985243830Sdim bool Expand = true; 1986243830Sdim bool RetainExpansion = false; 1987249423Sdim Optional<unsigned> NumExpansions; 1988243830Sdim if (SemaRef.CheckParameterPacksForExpansion(D->getLocation(), 1989243830Sdim TempParams->getSourceRange(), 1990243830Sdim Unexpanded, 1991243830Sdim TemplateArgs, 1992243830Sdim Expand, RetainExpansion, 1993243830Sdim NumExpansions)) 1994243830Sdim return 0; 1995243830Sdim 1996243830Sdim if (Expand) { 1997243830Sdim for (unsigned I = 0; I != *NumExpansions; ++I) { 1998243830Sdim Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I); 1999243830Sdim LocalInstantiationScope Scope(SemaRef); 2000243830Sdim TemplateParameterList *Expansion = SubstTemplateParams(TempParams); 2001243830Sdim if (!Expansion) 2002243830Sdim return 0; 2003243830Sdim ExpandedParams.push_back(Expansion); 2004243830Sdim } 2005243830Sdim 2006243830Sdim // Note that we have an expanded parameter pack. The "type" of this 2007243830Sdim // expanded parameter pack is the original expansion type, but callers 2008243830Sdim // will end up using the expanded parameter pack types for type-checking. 2009243830Sdim IsExpandedParameterPack = true; 2010243830Sdim InstParams = TempParams; 2011243830Sdim } else { 2012243830Sdim // We cannot fully expand the pack expansion now, so just substitute 2013243830Sdim // into the pattern. 2014243830Sdim Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1); 2015243830Sdim 2016243830Sdim LocalInstantiationScope Scope(SemaRef); 2017243830Sdim InstParams = SubstTemplateParams(TempParams); 2018243830Sdim if (!InstParams) 2019243830Sdim return 0; 2020243830Sdim } 2021243830Sdim } else { 2022199482Srdivacky // Perform the actual substitution of template parameters within a new, 2023199482Srdivacky // local instantiation scope. 2024212904Sdim LocalInstantiationScope Scope(SemaRef); 2025199482Srdivacky InstParams = SubstTemplateParams(TempParams); 2026199482Srdivacky if (!InstParams) 2027243830Sdim return 0; 2028226633Sdim } 2029226633Sdim 2030199482Srdivacky // Build the template template parameter. 2031243830Sdim TemplateTemplateParmDecl *Param; 2032243830Sdim if (IsExpandedParameterPack) 2033243830Sdim Param = TemplateTemplateParmDecl::Create(SemaRef.Context, Owner, 2034243830Sdim D->getLocation(), 2035226633Sdim D->getDepth() - TemplateArgs.getNumLevels(), 2036243830Sdim D->getPosition(), 2037243830Sdim D->getIdentifier(), InstParams, 2038243830Sdim ExpandedParams); 2039243830Sdim else 2040243830Sdim Param = TemplateTemplateParmDecl::Create(SemaRef.Context, Owner, 2041243830Sdim D->getLocation(), 2042243830Sdim D->getDepth() - TemplateArgs.getNumLevels(), 2043243830Sdim D->getPosition(), 2044243830Sdim D->isParameterPack(), 2045243830Sdim D->getIdentifier(), InstParams); 2046210299Sed Param->setDefaultArgument(D->getDefaultArgument(), false); 2047221345Sdim Param->setAccess(AS_public); 2048226633Sdim 2049226633Sdim // Introduce this template parameter's instantiation into the instantiation 2050199482Srdivacky // scope. 2051199482Srdivacky SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param); 2052226633Sdim 2053199482Srdivacky return Param; 2054199482Srdivacky} 2055199482Srdivacky 2056199482SrdivackyDecl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 2057219077Sdim // Using directives are never dependent (and never contain any types or 2058219077Sdim // expressions), so they require no explicit instantiation work. 2059226633Sdim 2060199482Srdivacky UsingDirectiveDecl *Inst 2061199482Srdivacky = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(), 2062226633Sdim D->getNamespaceKeyLocation(), 2063219077Sdim D->getQualifierLoc(), 2064226633Sdim D->getIdentLocation(), 2065226633Sdim D->getNominatedNamespace(), 2066199482Srdivacky D->getCommonAncestor()); 2067243830Sdim 2068243830Sdim // Add the using directive to its declaration context 2069243830Sdim // only if this is not a function or method. 2070243830Sdim if (!Owner->isFunctionOrMethod()) 2071243830Sdim Owner->addDecl(Inst); 2072243830Sdim 2073199482Srdivacky return Inst; 2074199482Srdivacky} 2075199482Srdivacky 2076200583SrdivackyDecl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) { 2077218893Sdim 2078218893Sdim // The nested name specifier may be dependent, for example 2079218893Sdim // template <typename T> struct t { 2080218893Sdim // struct s1 { T f1(); }; 2081218893Sdim // struct s2 : s1 { using s1::f1; }; 2082218893Sdim // }; 2083218893Sdim // template struct t<int>; 2084218893Sdim // Here, in using s1::f1, s1 refers to t<T>::s1; 2085218893Sdim // we need to substitute for t<int>::s1. 2086219077Sdim NestedNameSpecifierLoc QualifierLoc 2087219077Sdim = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(), 2088219077Sdim TemplateArgs); 2089219077Sdim if (!QualifierLoc) 2090219077Sdim return 0; 2091218893Sdim 2092218893Sdim // The name info is non-dependent, so no transformation 2093218893Sdim // is required. 2094212904Sdim DeclarationNameInfo NameInfo = D->getNameInfo(); 2095200583Srdivacky 2096200583Srdivacky // We only need to do redeclaration lookups if we're in a class 2097200583Srdivacky // scope (in fact, it's not really even possible in non-class 2098200583Srdivacky // scopes). 2099200583Srdivacky bool CheckRedeclaration = Owner->isRecord(); 2100200583Srdivacky 2101212904Sdim LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName, 2102212904Sdim Sema::ForRedeclaration); 2103200583Srdivacky 2104200583Srdivacky UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner, 2105200583Srdivacky D->getUsingLocation(), 2106219077Sdim QualifierLoc, 2107212904Sdim NameInfo, 2108200583Srdivacky D->isTypeName()); 2109200583Srdivacky 2110200583Srdivacky CXXScopeSpec SS; 2111219077Sdim SS.Adopt(QualifierLoc); 2112200583Srdivacky if (CheckRedeclaration) { 2113200583Srdivacky Prev.setHideTags(false); 2114200583Srdivacky SemaRef.LookupQualifiedName(Prev, Owner); 2115200583Srdivacky 2116200583Srdivacky // Check for invalid redeclarations. 2117200583Srdivacky if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLocation(), 2118200583Srdivacky D->isTypeName(), SS, 2119200583Srdivacky D->getLocation(), Prev)) 2120200583Srdivacky NewUD->setInvalidDecl(); 2121200583Srdivacky 2122200583Srdivacky } 2123200583Srdivacky 2124200583Srdivacky if (!NewUD->isInvalidDecl() && 2125200583Srdivacky SemaRef.CheckUsingDeclQualifier(D->getUsingLocation(), SS, 2126200583Srdivacky D->getLocation())) 2127200583Srdivacky NewUD->setInvalidDecl(); 2128200583Srdivacky 2129200583Srdivacky SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D); 2130200583Srdivacky NewUD->setAccess(D->getAccess()); 2131200583Srdivacky Owner->addDecl(NewUD); 2132200583Srdivacky 2133200583Srdivacky // Don't process the shadow decls for an invalid decl. 2134200583Srdivacky if (NewUD->isInvalidDecl()) 2135200583Srdivacky return NewUD; 2136200583Srdivacky 2137234353Sdim if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName) { 2138234353Sdim if (SemaRef.CheckInheritingConstructorUsingDecl(NewUD)) 2139234353Sdim NewUD->setInvalidDecl(); 2140234353Sdim return NewUD; 2141234353Sdim } 2142234353Sdim 2143201361Srdivacky bool isFunctionScope = Owner->isFunctionOrMethod(); 2144201361Srdivacky 2145200583Srdivacky // Process the shadow decls. 2146200583Srdivacky for (UsingDecl::shadow_iterator I = D->shadow_begin(), E = D->shadow_end(); 2147200583Srdivacky I != E; ++I) { 2148200583Srdivacky UsingShadowDecl *Shadow = *I; 2149200583Srdivacky NamedDecl *InstTarget = 2150221345Sdim cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl( 2151221345Sdim Shadow->getLocation(), 2152221345Sdim Shadow->getTargetDecl(), 2153221345Sdim TemplateArgs)); 2154221345Sdim if (!InstTarget) 2155221345Sdim return 0; 2156200583Srdivacky 2157200583Srdivacky if (CheckRedeclaration && 2158200583Srdivacky SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev)) 2159200583Srdivacky continue; 2160200583Srdivacky 2161200583Srdivacky UsingShadowDecl *InstShadow 2162200583Srdivacky = SemaRef.BuildUsingShadowDecl(/*Scope*/ 0, NewUD, InstTarget); 2163200583Srdivacky SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow); 2164201361Srdivacky 2165201361Srdivacky if (isFunctionScope) 2166201361Srdivacky SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow); 2167200583Srdivacky } 2168200583Srdivacky 2169200583Srdivacky return NewUD; 2170200583Srdivacky} 2171200583Srdivacky 2172200583SrdivackyDecl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) { 2173200583Srdivacky // Ignore these; we handle them in bulk when processing the UsingDecl. 2174200583Srdivacky return 0; 2175200583Srdivacky} 2176200583Srdivacky 2177199482SrdivackyDecl * TemplateDeclInstantiator 2178199482Srdivacky ::VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) { 2179219077Sdim NestedNameSpecifierLoc QualifierLoc 2180226633Sdim = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(), 2181219077Sdim TemplateArgs); 2182219077Sdim if (!QualifierLoc) 2183198092Srdivacky return 0; 2184198092Srdivacky 2185198092Srdivacky CXXScopeSpec SS; 2186219077Sdim SS.Adopt(QualifierLoc); 2187198092Srdivacky 2188212904Sdim // Since NameInfo refers to a typename, it cannot be a C++ special name. 2189249423Sdim // Hence, no transformation is required for it. 2190212904Sdim DeclarationNameInfo NameInfo(D->getDeclName(), D->getLocation()); 2191198092Srdivacky NamedDecl *UD = 2192199482Srdivacky SemaRef.BuildUsingDeclaration(/*Scope*/ 0, D->getAccess(), 2193212904Sdim D->getUsingLoc(), SS, NameInfo, 0, 2194199482Srdivacky /*instantiation*/ true, 2195199482Srdivacky /*typename*/ true, D->getTypenameLoc()); 2196198092Srdivacky if (UD) 2197200583Srdivacky SemaRef.Context.setInstantiatedFromUsingDecl(cast<UsingDecl>(UD), D); 2198200583Srdivacky 2199198092Srdivacky return UD; 2200198092Srdivacky} 2201198092Srdivacky 2202199482SrdivackyDecl * TemplateDeclInstantiator 2203199482Srdivacky ::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { 2204219077Sdim NestedNameSpecifierLoc QualifierLoc 2205219077Sdim = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(), TemplateArgs); 2206219077Sdim if (!QualifierLoc) 2207199482Srdivacky return 0; 2208226633Sdim 2209199482Srdivacky CXXScopeSpec SS; 2210219077Sdim SS.Adopt(QualifierLoc); 2211199482Srdivacky 2212212904Sdim DeclarationNameInfo NameInfo 2213212904Sdim = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs); 2214212904Sdim 2215199482Srdivacky NamedDecl *UD = 2216199482Srdivacky SemaRef.BuildUsingDeclaration(/*Scope*/ 0, D->getAccess(), 2217212904Sdim D->getUsingLoc(), SS, NameInfo, 0, 2218199482Srdivacky /*instantiation*/ true, 2219199482Srdivacky /*typename*/ false, SourceLocation()); 2220199482Srdivacky if (UD) 2221200583Srdivacky SemaRef.Context.setInstantiatedFromUsingDecl(cast<UsingDecl>(UD), D); 2222200583Srdivacky 2223199482Srdivacky return UD; 2224199482Srdivacky} 2225199482Srdivacky 2226226633Sdim 2227226633SdimDecl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl( 2228226633Sdim ClassScopeFunctionSpecializationDecl *Decl) { 2229226633Sdim CXXMethodDecl *OldFD = Decl->getSpecialization(); 2230239462Sdim CXXMethodDecl *NewFD = cast<CXXMethodDecl>(VisitCXXMethodDecl(OldFD, 2231239462Sdim 0, true)); 2232226633Sdim 2233226633Sdim LookupResult Previous(SemaRef, NewFD->getNameInfo(), Sema::LookupOrdinaryName, 2234226633Sdim Sema::ForRedeclaration); 2235226633Sdim 2236239462Sdim TemplateArgumentListInfo TemplateArgs; 2237239462Sdim TemplateArgumentListInfo* TemplateArgsPtr = 0; 2238239462Sdim if (Decl->hasExplicitTemplateArgs()) { 2239239462Sdim TemplateArgs = Decl->templateArgs(); 2240239462Sdim TemplateArgsPtr = &TemplateArgs; 2241239462Sdim } 2242239462Sdim 2243226633Sdim SemaRef.LookupQualifiedName(Previous, SemaRef.CurContext); 2244239462Sdim if (SemaRef.CheckFunctionTemplateSpecialization(NewFD, TemplateArgsPtr, 2245239462Sdim Previous)) { 2246226633Sdim NewFD->setInvalidDecl(); 2247226633Sdim return NewFD; 2248226633Sdim } 2249226633Sdim 2250226633Sdim // Associate the specialization with the pattern. 2251226633Sdim FunctionDecl *Specialization = cast<FunctionDecl>(Previous.getFoundDecl()); 2252226633Sdim assert(Specialization && "Class scope Specialization is null"); 2253226633Sdim SemaRef.Context.setClassScopeSpecializationPattern(Specialization, OldFD); 2254226633Sdim 2255226633Sdim return NewFD; 2256226633Sdim} 2257226633Sdim 2258249423SdimDecl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl( 2259249423Sdim OMPThreadPrivateDecl *D) { 2260249423Sdim SmallVector<DeclRefExpr *, 5> Vars; 2261249423Sdim for (ArrayRef<DeclRefExpr *>::iterator I = D->varlist_begin(), 2262249423Sdim E = D->varlist_end(); 2263249423Sdim I != E; ++I) { 2264249423Sdim Expr *Var = SemaRef.SubstExpr(*I, TemplateArgs).take(); 2265249423Sdim assert(isa<DeclRefExpr>(Var) && "threadprivate arg is not a DeclRefExpr"); 2266249423Sdim Vars.push_back(cast<DeclRefExpr>(Var)); 2267249423Sdim } 2268249423Sdim 2269249423Sdim OMPThreadPrivateDecl *TD = 2270249423Sdim SemaRef.CheckOMPThreadPrivateDecl(D->getLocation(), Vars); 2271249423Sdim 2272249423Sdim return TD; 2273249423Sdim} 2274249423Sdim 2275198092SrdivackyDecl *Sema::SubstDecl(Decl *D, DeclContext *Owner, 2276198092Srdivacky const MultiLevelTemplateArgumentList &TemplateArgs) { 2277193326Sed TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs); 2278204643Srdivacky if (D->isInvalidDecl()) 2279204643Srdivacky return 0; 2280204643Srdivacky 2281193326Sed return Instantiator.Visit(D); 2282193326Sed} 2283193326Sed 2284198092Srdivacky/// \brief Instantiates a nested template parameter list in the current 2285198092Srdivacky/// instantiation context. 2286193326Sed/// 2287198092Srdivacky/// \param L The parameter list to instantiate 2288193326Sed/// 2289198092Srdivacky/// \returns NULL if there was an error 2290198092SrdivackyTemplateParameterList * 2291198092SrdivackyTemplateDeclInstantiator::SubstTemplateParams(TemplateParameterList *L) { 2292198092Srdivacky // Get errors for all the parameters before bailing out. 2293198092Srdivacky bool Invalid = false; 2294198092Srdivacky 2295198092Srdivacky unsigned N = L->size(); 2296226633Sdim typedef SmallVector<NamedDecl *, 8> ParamVector; 2297198092Srdivacky ParamVector Params; 2298198092Srdivacky Params.reserve(N); 2299198092Srdivacky for (TemplateParameterList::iterator PI = L->begin(), PE = L->end(); 2300198092Srdivacky PI != PE; ++PI) { 2301198092Srdivacky NamedDecl *D = cast_or_null<NamedDecl>(Visit(*PI)); 2302198092Srdivacky Params.push_back(D); 2303199482Srdivacky Invalid = Invalid || !D || D->isInvalidDecl(); 2304198092Srdivacky } 2305198092Srdivacky 2306198092Srdivacky // Clean up if we had an error. 2307212904Sdim if (Invalid) 2308198092Srdivacky return NULL; 2309198092Srdivacky 2310198092Srdivacky TemplateParameterList *InstL 2311198092Srdivacky = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(), 2312198092Srdivacky L->getLAngleLoc(), &Params.front(), N, 2313198092Srdivacky L->getRAngleLoc()); 2314198092Srdivacky return InstL; 2315198092Srdivacky} 2316198092Srdivacky 2317226633Sdim/// \brief Instantiate the declaration of a class template partial 2318198893Srdivacky/// specialization. 2319198893Srdivacky/// 2320198893Srdivacky/// \param ClassTemplate the (instantiated) class template that is partially 2321198893Srdivacky// specialized by the instantiation of \p PartialSpec. 2322198893Srdivacky/// 2323226633Sdim/// \param PartialSpec the (uninstantiated) class template partial 2324198893Srdivacky/// specialization that we are instantiating. 2325198893Srdivacky/// 2326218893Sdim/// \returns The instantiated partial specialization, if successful; otherwise, 2327218893Sdim/// NULL to indicate an error. 2328218893SdimClassTemplatePartialSpecializationDecl * 2329198893SrdivackyTemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization( 2330198893Srdivacky ClassTemplateDecl *ClassTemplate, 2331198893Srdivacky ClassTemplatePartialSpecializationDecl *PartialSpec) { 2332198893Srdivacky // Create a local instantiation scope for this class template partial 2333198893Srdivacky // specialization, which will contain the instantiations of the template 2334198893Srdivacky // parameters. 2335212904Sdim LocalInstantiationScope Scope(SemaRef); 2336226633Sdim 2337198893Srdivacky // Substitute into the template parameters of the class template partial 2338198893Srdivacky // specialization. 2339198893Srdivacky TemplateParameterList *TempParams = PartialSpec->getTemplateParameters(); 2340198893Srdivacky TemplateParameterList *InstParams = SubstTemplateParams(TempParams); 2341198893Srdivacky if (!InstParams) 2342218893Sdim return 0; 2343226633Sdim 2344198893Srdivacky // Substitute into the template arguments of the class template partial 2345198893Srdivacky // specialization. 2346199990Srdivacky TemplateArgumentListInfo InstTemplateArgs; // no angle locations 2347226633Sdim if (SemaRef.Subst(PartialSpec->getTemplateArgsAsWritten(), 2348226633Sdim PartialSpec->getNumTemplateArgsAsWritten(), 2349218893Sdim InstTemplateArgs, TemplateArgs)) 2350218893Sdim return 0; 2351226633Sdim 2352198893Srdivacky // Check that the template argument list is well-formed for this 2353198893Srdivacky // class template. 2354226633Sdim SmallVector<TemplateArgument, 4> Converted; 2355226633Sdim if (SemaRef.CheckTemplateArgumentList(ClassTemplate, 2356198893Srdivacky PartialSpec->getLocation(), 2357226633Sdim InstTemplateArgs, 2358198893Srdivacky false, 2359198893Srdivacky Converted)) 2360218893Sdim return 0; 2361198893Srdivacky 2362198893Srdivacky // Figure out where to insert this class template partial specialization 2363198893Srdivacky // in the member template's set of class template partial specializations. 2364198893Srdivacky void *InsertPos = 0; 2365198893Srdivacky ClassTemplateSpecializationDecl *PrevDecl 2366218893Sdim = ClassTemplate->findPartialSpecialization(Converted.data(), 2367218893Sdim Converted.size(), InsertPos); 2368226633Sdim 2369198893Srdivacky // Build the canonical type that describes the converted template 2370198893Srdivacky // arguments of the class template partial specialization. 2371226633Sdim QualType CanonType 2372198893Srdivacky = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate), 2373218893Sdim Converted.data(), 2374218893Sdim Converted.size()); 2375198893Srdivacky 2376198893Srdivacky // Build the fully-sugared type for this class template 2377198893Srdivacky // specialization as the user wrote in the specialization 2378198893Srdivacky // itself. This means that we'll pretty-print the type retrieved 2379198893Srdivacky // from the specialization's declaration the way that the user 2380198893Srdivacky // actually wrote the specialization, rather than formatting the 2381198893Srdivacky // name based on the "canonical" representation used to store the 2382198893Srdivacky // template arguments in the specialization. 2383204962Srdivacky TypeSourceInfo *WrittenTy 2384204962Srdivacky = SemaRef.Context.getTemplateSpecializationTypeInfo( 2385204962Srdivacky TemplateName(ClassTemplate), 2386204962Srdivacky PartialSpec->getLocation(), 2387199990Srdivacky InstTemplateArgs, 2388198893Srdivacky CanonType); 2389226633Sdim 2390198893Srdivacky if (PrevDecl) { 2391198893Srdivacky // We've already seen a partial specialization with the same template 2392198893Srdivacky // parameters and template arguments. This can happen, for example, when 2393198893Srdivacky // substituting the outer template arguments ends up causing two 2394198893Srdivacky // class template partial specializations of a member class template 2395198893Srdivacky // to have identical forms, e.g., 2396198893Srdivacky // 2397198893Srdivacky // template<typename T, typename U> 2398198893Srdivacky // struct Outer { 2399198893Srdivacky // template<typename X, typename Y> struct Inner; 2400198893Srdivacky // template<typename Y> struct Inner<T, Y>; 2401198893Srdivacky // template<typename Y> struct Inner<U, Y>; 2402198893Srdivacky // }; 2403198893Srdivacky // 2404198893Srdivacky // Outer<int, int> outer; // error: the partial specializations of Inner 2405198893Srdivacky // // have the same signature. 2406198893Srdivacky SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared) 2407218893Sdim << WrittenTy->getType(); 2408198893Srdivacky SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here) 2409198893Srdivacky << SemaRef.Context.getTypeDeclType(PrevDecl); 2410218893Sdim return 0; 2411198893Srdivacky } 2412226633Sdim 2413226633Sdim 2414198893Srdivacky // Create the class template partial specialization declaration. 2415198893Srdivacky ClassTemplatePartialSpecializationDecl *InstPartialSpec 2416226633Sdim = ClassTemplatePartialSpecializationDecl::Create(SemaRef.Context, 2417208600Srdivacky PartialSpec->getTagKind(), 2418226633Sdim Owner, 2419221345Sdim PartialSpec->getLocStart(), 2420221345Sdim PartialSpec->getLocation(), 2421198893Srdivacky InstParams, 2422226633Sdim ClassTemplate, 2423218893Sdim Converted.data(), 2424218893Sdim Converted.size(), 2425199990Srdivacky InstTemplateArgs, 2426204962Srdivacky CanonType, 2427207619Srdivacky 0, 2428212904Sdim ClassTemplate->getNextPartialSpecSequenceNumber()); 2429205219Srdivacky // Substitute the nested name specifier, if any. 2430205219Srdivacky if (SubstQualifier(PartialSpec, InstPartialSpec)) 2431205219Srdivacky return 0; 2432205219Srdivacky 2433198893Srdivacky InstPartialSpec->setInstantiatedFromMember(PartialSpec); 2434198893Srdivacky InstPartialSpec->setTypeAsWritten(WrittenTy); 2435226633Sdim 2436198893Srdivacky // Add this partial specialization to the set of class template partial 2437198893Srdivacky // specializations. 2438234353Sdim ClassTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/0); 2439218893Sdim return InstPartialSpec; 2440198893Srdivacky} 2441198893Srdivacky 2442205219SrdivackyTypeSourceInfo* 2443198092SrdivackyTemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D, 2444226633Sdim SmallVectorImpl<ParmVarDecl *> &Params) { 2445205219Srdivacky TypeSourceInfo *OldTInfo = D->getTypeSourceInfo(); 2446205219Srdivacky assert(OldTInfo && "substituting function without type source info"); 2447205219Srdivacky assert(Params.empty() && "parameter vector is non-empty at start"); 2448234982Sdim 2449234982Sdim CXXRecordDecl *ThisContext = 0; 2450234982Sdim unsigned ThisTypeQuals = 0; 2451234982Sdim if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 2452234982Sdim ThisContext = Method->getParent(); 2453234982Sdim ThisTypeQuals = Method->getTypeQualifiers(); 2454234982Sdim } 2455234982Sdim 2456207619Srdivacky TypeSourceInfo *NewTInfo 2457207619Srdivacky = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs, 2458207619Srdivacky D->getTypeSpecStartLoc(), 2459234982Sdim D->getDeclName(), 2460234982Sdim ThisContext, ThisTypeQuals); 2461205219Srdivacky if (!NewTInfo) 2462205219Srdivacky return 0; 2463193326Sed 2464207619Srdivacky if (NewTInfo != OldTInfo) { 2465207619Srdivacky // Get parameters from the new type info. 2466218893Sdim TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens(); 2467249423Sdim if (FunctionProtoTypeLoc OldProtoLoc = 2468249423Sdim OldTL.getAs<FunctionProtoTypeLoc>()) { 2469218893Sdim TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens(); 2470249423Sdim FunctionProtoTypeLoc NewProtoLoc = NewTL.castAs<FunctionProtoTypeLoc>(); 2471239462Sdim unsigned NewIdx = 0; 2472249423Sdim for (unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumArgs(); 2473218893Sdim OldIdx != NumOldParams; ++OldIdx) { 2474249423Sdim ParmVarDecl *OldParam = OldProtoLoc.getArg(OldIdx); 2475239462Sdim LocalInstantiationScope *Scope = SemaRef.CurrentInstantiationScope; 2476239462Sdim 2477249423Sdim Optional<unsigned> NumArgumentsInExpansion; 2478239462Sdim if (OldParam->isParameterPack()) 2479239462Sdim NumArgumentsInExpansion = 2480239462Sdim SemaRef.getNumArgumentsInExpansion(OldParam->getType(), 2481239462Sdim TemplateArgs); 2482239462Sdim if (!NumArgumentsInExpansion) { 2483226633Sdim // Simple case: normal parameter, or a parameter pack that's 2484218893Sdim // instantiated to a (still-dependent) parameter pack. 2485249423Sdim ParmVarDecl *NewParam = NewProtoLoc.getArg(NewIdx++); 2486218893Sdim Params.push_back(NewParam); 2487239462Sdim Scope->InstantiatedLocal(OldParam, NewParam); 2488239462Sdim } else { 2489239462Sdim // Parameter pack expansion: make the instantiation an argument pack. 2490239462Sdim Scope->MakeInstantiatedLocalArgPack(OldParam); 2491239462Sdim for (unsigned I = 0; I != *NumArgumentsInExpansion; ++I) { 2492249423Sdim ParmVarDecl *NewParam = NewProtoLoc.getArg(NewIdx++); 2493239462Sdim Params.push_back(NewParam); 2494239462Sdim Scope->InstantiatedLocalPackArg(OldParam, NewParam); 2495239462Sdim } 2496218893Sdim } 2497207619Srdivacky } 2498207619Srdivacky } 2499207619Srdivacky } else { 2500207619Srdivacky // The function type itself was not dependent and therefore no 2501207619Srdivacky // substitution occurred. However, we still need to instantiate 2502207619Srdivacky // the function parameters themselves. 2503218893Sdim TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens(); 2504249423Sdim if (FunctionProtoTypeLoc OldProtoLoc = 2505249423Sdim OldTL.getAs<FunctionProtoTypeLoc>()) { 2506249423Sdim for (unsigned i = 0, i_end = OldProtoLoc.getNumArgs(); i != i_end; ++i) { 2507249423Sdim ParmVarDecl *Parm = VisitParmVarDecl(OldProtoLoc.getArg(i)); 2508207619Srdivacky if (!Parm) 2509207619Srdivacky return 0; 2510207619Srdivacky Params.push_back(Parm); 2511207619Srdivacky } 2512207619Srdivacky } 2513207619Srdivacky } 2514205219Srdivacky return NewTInfo; 2515193326Sed} 2516193326Sed 2517234982Sdim/// Introduce the instantiated function parameters into the local 2518234982Sdim/// instantiation scope, and set the parameter names to those used 2519234982Sdim/// in the template. 2520234982Sdimstatic void addInstantiatedParametersToScope(Sema &S, FunctionDecl *Function, 2521234982Sdim const FunctionDecl *PatternDecl, 2522234982Sdim LocalInstantiationScope &Scope, 2523234982Sdim const MultiLevelTemplateArgumentList &TemplateArgs) { 2524234982Sdim unsigned FParamIdx = 0; 2525234982Sdim for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) { 2526234982Sdim const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I); 2527234982Sdim if (!PatternParam->isParameterPack()) { 2528234982Sdim // Simple case: not a parameter pack. 2529234982Sdim assert(FParamIdx < Function->getNumParams()); 2530234982Sdim ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx); 2531234982Sdim FunctionParam->setDeclName(PatternParam->getDeclName()); 2532234982Sdim Scope.InstantiatedLocal(PatternParam, FunctionParam); 2533234982Sdim ++FParamIdx; 2534234982Sdim continue; 2535234982Sdim } 2536234982Sdim 2537234982Sdim // Expand the parameter pack. 2538234982Sdim Scope.MakeInstantiatedLocalArgPack(PatternParam); 2539249423Sdim Optional<unsigned> NumArgumentsInExpansion 2540234982Sdim = S.getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs); 2541239462Sdim assert(NumArgumentsInExpansion && 2542239462Sdim "should only be called when all template arguments are known"); 2543239462Sdim for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) { 2544234982Sdim ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx); 2545234982Sdim FunctionParam->setDeclName(PatternParam->getDeclName()); 2546234982Sdim Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam); 2547234982Sdim ++FParamIdx; 2548234982Sdim } 2549234982Sdim } 2550234982Sdim} 2551234982Sdim 2552234982Sdimstatic void InstantiateExceptionSpec(Sema &SemaRef, FunctionDecl *New, 2553234982Sdim const FunctionProtoType *Proto, 2554234982Sdim const MultiLevelTemplateArgumentList &TemplateArgs) { 2555234982Sdim assert(Proto->getExceptionSpecType() != EST_Uninstantiated); 2556234982Sdim 2557234982Sdim // C++11 [expr.prim.general]p3: 2558234982Sdim // If a declaration declares a member function or member function 2559234982Sdim // template of a class X, the expression this is a prvalue of type 2560234982Sdim // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq 2561234982Sdim // and the end of the function-definition, member-declarator, or 2562234982Sdim // declarator. 2563234982Sdim CXXRecordDecl *ThisContext = 0; 2564234982Sdim unsigned ThisTypeQuals = 0; 2565234982Sdim if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(New)) { 2566234982Sdim ThisContext = Method->getParent(); 2567234982Sdim ThisTypeQuals = Method->getTypeQualifiers(); 2568234982Sdim } 2569234982Sdim Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals, 2570249423Sdim SemaRef.getLangOpts().CPlusPlus11); 2571234982Sdim 2572234982Sdim // The function has an exception specification or a "noreturn" 2573234982Sdim // attribute. Substitute into each of the exception types. 2574234982Sdim SmallVector<QualType, 4> Exceptions; 2575234982Sdim for (unsigned I = 0, N = Proto->getNumExceptions(); I != N; ++I) { 2576234982Sdim // FIXME: Poor location information! 2577234982Sdim if (const PackExpansionType *PackExpansion 2578234982Sdim = Proto->getExceptionType(I)->getAs<PackExpansionType>()) { 2579234982Sdim // We have a pack expansion. Instantiate it. 2580234982Sdim SmallVector<UnexpandedParameterPack, 2> Unexpanded; 2581234982Sdim SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(), 2582234982Sdim Unexpanded); 2583234982Sdim assert(!Unexpanded.empty() && 2584234982Sdim "Pack expansion without parameter packs?"); 2585234982Sdim 2586234982Sdim bool Expand = false; 2587234982Sdim bool RetainExpansion = false; 2588249423Sdim Optional<unsigned> NumExpansions 2589234982Sdim = PackExpansion->getNumExpansions(); 2590234982Sdim if (SemaRef.CheckParameterPacksForExpansion(New->getLocation(), 2591234982Sdim SourceRange(), 2592234982Sdim Unexpanded, 2593234982Sdim TemplateArgs, 2594234982Sdim Expand, 2595234982Sdim RetainExpansion, 2596234982Sdim NumExpansions)) 2597234982Sdim break; 2598234982Sdim 2599234982Sdim if (!Expand) { 2600234982Sdim // We can't expand this pack expansion into separate arguments yet; 2601234982Sdim // just substitute into the pattern and create a new pack expansion 2602234982Sdim // type. 2603234982Sdim Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1); 2604234982Sdim QualType T = SemaRef.SubstType(PackExpansion->getPattern(), 2605234982Sdim TemplateArgs, 2606234982Sdim New->getLocation(), New->getDeclName()); 2607234982Sdim if (T.isNull()) 2608234982Sdim break; 2609234982Sdim 2610234982Sdim T = SemaRef.Context.getPackExpansionType(T, NumExpansions); 2611234982Sdim Exceptions.push_back(T); 2612234982Sdim continue; 2613234982Sdim } 2614234982Sdim 2615234982Sdim // Substitute into the pack expansion pattern for each template 2616234982Sdim bool Invalid = false; 2617234982Sdim for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) { 2618234982Sdim Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, ArgIdx); 2619234982Sdim 2620234982Sdim QualType T = SemaRef.SubstType(PackExpansion->getPattern(), 2621234982Sdim TemplateArgs, 2622234982Sdim New->getLocation(), New->getDeclName()); 2623234982Sdim if (T.isNull()) { 2624234982Sdim Invalid = true; 2625234982Sdim break; 2626234982Sdim } 2627234982Sdim 2628234982Sdim Exceptions.push_back(T); 2629234982Sdim } 2630234982Sdim 2631234982Sdim if (Invalid) 2632234982Sdim break; 2633234982Sdim 2634234982Sdim continue; 2635234982Sdim } 2636234982Sdim 2637234982Sdim QualType T 2638234982Sdim = SemaRef.SubstType(Proto->getExceptionType(I), TemplateArgs, 2639234982Sdim New->getLocation(), New->getDeclName()); 2640234982Sdim if (T.isNull() || 2641234982Sdim SemaRef.CheckSpecifiedExceptionType(T, New->getLocation())) 2642234982Sdim continue; 2643234982Sdim 2644234982Sdim Exceptions.push_back(T); 2645234982Sdim } 2646234982Sdim Expr *NoexceptExpr = 0; 2647234982Sdim if (Expr *OldNoexceptExpr = Proto->getNoexceptExpr()) { 2648234982Sdim EnterExpressionEvaluationContext Unevaluated(SemaRef, 2649234982Sdim Sema::ConstantEvaluated); 2650234982Sdim ExprResult E = SemaRef.SubstExpr(OldNoexceptExpr, TemplateArgs); 2651234982Sdim if (E.isUsable()) 2652234982Sdim E = SemaRef.CheckBooleanCondition(E.get(), E.get()->getLocStart()); 2653234982Sdim 2654234982Sdim if (E.isUsable()) { 2655234982Sdim NoexceptExpr = E.take(); 2656234982Sdim if (!NoexceptExpr->isTypeDependent() && 2657234982Sdim !NoexceptExpr->isValueDependent()) 2658239462Sdim NoexceptExpr 2659239462Sdim = SemaRef.VerifyIntegerConstantExpression(NoexceptExpr, 2660239462Sdim 0, diag::err_noexcept_needs_constant_expression, 2661239462Sdim /*AllowFold*/ false).take(); 2662234982Sdim } 2663234982Sdim } 2664234982Sdim 2665234982Sdim // Rebuild the function type 2666234982Sdim const FunctionProtoType *NewProto 2667234982Sdim = New->getType()->getAs<FunctionProtoType>(); 2668234982Sdim assert(NewProto && "Template instantiation without function prototype?"); 2669234982Sdim 2670234982Sdim FunctionProtoType::ExtProtoInfo EPI = NewProto->getExtProtoInfo(); 2671234982Sdim EPI.ExceptionSpecType = Proto->getExceptionSpecType(); 2672234982Sdim EPI.NumExceptions = Exceptions.size(); 2673234982Sdim EPI.Exceptions = Exceptions.data(); 2674234982Sdim EPI.NoexceptExpr = NoexceptExpr; 2675234982Sdim 2676234982Sdim New->setType(SemaRef.Context.getFunctionType(NewProto->getResultType(), 2677249423Sdim ArrayRef<QualType>(NewProto->arg_type_begin(), 2678249423Sdim NewProto->getNumArgs()), 2679234982Sdim EPI)); 2680234982Sdim} 2681234982Sdim 2682234982Sdimvoid Sema::InstantiateExceptionSpec(SourceLocation PointOfInstantiation, 2683234982Sdim FunctionDecl *Decl) { 2684234982Sdim const FunctionProtoType *Proto = Decl->getType()->castAs<FunctionProtoType>(); 2685234982Sdim if (Proto->getExceptionSpecType() != EST_Uninstantiated) 2686234982Sdim return; 2687234982Sdim 2688234982Sdim InstantiatingTemplate Inst(*this, PointOfInstantiation, Decl, 2689234982Sdim InstantiatingTemplate::ExceptionSpecification()); 2690239462Sdim if (Inst) { 2691239462Sdim // We hit the instantiation depth limit. Clear the exception specification 2692239462Sdim // so that our callers don't have to cope with EST_Uninstantiated. 2693239462Sdim FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo(); 2694239462Sdim EPI.ExceptionSpecType = EST_None; 2695239462Sdim Decl->setType(Context.getFunctionType(Proto->getResultType(), 2696249423Sdim ArrayRef<QualType>(Proto->arg_type_begin(), 2697249423Sdim Proto->getNumArgs()), 2698239462Sdim EPI)); 2699234982Sdim return; 2700239462Sdim } 2701234982Sdim 2702234982Sdim // Enter the scope of this instantiation. We don't use 2703234982Sdim // PushDeclContext because we don't have a scope. 2704234982Sdim Sema::ContextRAII savedContext(*this, Decl); 2705234982Sdim LocalInstantiationScope Scope(*this); 2706234982Sdim 2707234982Sdim MultiLevelTemplateArgumentList TemplateArgs = 2708234982Sdim getTemplateInstantiationArgs(Decl, 0, /*RelativeToPrimary*/true); 2709234982Sdim 2710234982Sdim FunctionDecl *Template = Proto->getExceptionSpecTemplate(); 2711234982Sdim addInstantiatedParametersToScope(*this, Decl, Template, Scope, TemplateArgs); 2712234982Sdim 2713234982Sdim ::InstantiateExceptionSpec(*this, Decl, 2714234982Sdim Template->getType()->castAs<FunctionProtoType>(), 2715234982Sdim TemplateArgs); 2716234982Sdim} 2717234982Sdim 2718198092Srdivacky/// \brief Initializes the common fields of an instantiation function 2719195099Sed/// declaration (New) from the corresponding fields of its template (Tmpl). 2720195099Sed/// 2721195099Sed/// \returns true if there was an error 2722198092Srdivackybool 2723198092SrdivackyTemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New, 2724195099Sed FunctionDecl *Tmpl) { 2725239462Sdim if (Tmpl->isDeleted()) 2726223017Sdim New->setDeletedAsWritten(); 2727198092Srdivacky 2728195341Sed // If we are performing substituting explicitly-specified template arguments 2729195341Sed // or deduced template arguments into a function template and we reach this 2730195341Sed // point, we are now past the point where SFINAE applies and have committed 2731198092Srdivacky // to keeping the new function template specialization. We therefore 2732198092Srdivacky // convert the active template instantiation for the function template 2733195341Sed // into a template instantiation for this specific function template 2734195341Sed // specialization, which is not a SFINAE context, so that we diagnose any 2735195341Sed // further errors in the declaration itself. 2736195341Sed typedef Sema::ActiveTemplateInstantiation ActiveInstType; 2737195341Sed ActiveInstType &ActiveInst = SemaRef.ActiveTemplateInstantiations.back(); 2738195341Sed if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution || 2739195341Sed ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) { 2740198092Srdivacky if (FunctionTemplateDecl *FunTmpl 2741249423Sdim = dyn_cast<FunctionTemplateDecl>(ActiveInst.Entity)) { 2742198092Srdivacky assert(FunTmpl->getTemplatedDecl() == Tmpl && 2743195341Sed "Deduction from the wrong function template?"); 2744198092Srdivacky (void) FunTmpl; 2745195341Sed ActiveInst.Kind = ActiveInstType::TemplateInstantiation; 2746249423Sdim ActiveInst.Entity = New; 2747195341Sed } 2748195341Sed } 2749198092Srdivacky 2750200583Srdivacky const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>(); 2751200583Srdivacky assert(Proto && "Function template without prototype?"); 2752200583Srdivacky 2753221345Sdim if (Proto->hasExceptionSpec() || Proto->getNoReturnAttr()) { 2754234982Sdim FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo(); 2755221345Sdim 2756234982Sdim // DR1330: In C++11, defer instantiation of a non-trivial 2757234982Sdim // exception specification. 2758249423Sdim if (SemaRef.getLangOpts().CPlusPlus11 && 2759234982Sdim EPI.ExceptionSpecType != EST_None && 2760234982Sdim EPI.ExceptionSpecType != EST_DynamicNone && 2761234982Sdim EPI.ExceptionSpecType != EST_BasicNoexcept) { 2762234982Sdim FunctionDecl *ExceptionSpecTemplate = Tmpl; 2763234982Sdim if (EPI.ExceptionSpecType == EST_Uninstantiated) 2764234982Sdim ExceptionSpecTemplate = EPI.ExceptionSpecTemplate; 2765251662Sdim ExceptionSpecificationType NewEST = EST_Uninstantiated; 2766251662Sdim if (EPI.ExceptionSpecType == EST_Unevaluated) 2767251662Sdim NewEST = EST_Unevaluated; 2768221345Sdim 2769234982Sdim // Mark the function has having an uninstantiated exception specification. 2770234982Sdim const FunctionProtoType *NewProto 2771234982Sdim = New->getType()->getAs<FunctionProtoType>(); 2772234982Sdim assert(NewProto && "Template instantiation without function prototype?"); 2773234982Sdim EPI = NewProto->getExtProtoInfo(); 2774251662Sdim EPI.ExceptionSpecType = NewEST; 2775234982Sdim EPI.ExceptionSpecDecl = New; 2776234982Sdim EPI.ExceptionSpecTemplate = ExceptionSpecTemplate; 2777234982Sdim New->setType(SemaRef.Context.getFunctionType(NewProto->getResultType(), 2778249423Sdim ArrayRef<QualType>(NewProto->arg_type_begin(), 2779249423Sdim NewProto->getNumArgs()), 2780234982Sdim EPI)); 2781234982Sdim } else { 2782234982Sdim ::InstantiateExceptionSpec(SemaRef, New, Proto, TemplateArgs); 2783200583Srdivacky } 2784200583Srdivacky } 2785200583Srdivacky 2786224145Sdim // Get the definition. Leaves the variable unchanged if undefined. 2787234982Sdim const FunctionDecl *Definition = Tmpl; 2788224145Sdim Tmpl->isDefined(Definition); 2789224145Sdim 2790234353Sdim SemaRef.InstantiateAttrs(TemplateArgs, Definition, New, 2791234353Sdim LateAttrs, StartingScope); 2792224145Sdim 2793195099Sed return false; 2794195099Sed} 2795195099Sed 2796193326Sed/// \brief Initializes common fields of an instantiated method 2797193326Sed/// declaration (New) from the corresponding fields of its template 2798193326Sed/// (Tmpl). 2799193326Sed/// 2800193326Sed/// \returns true if there was an error 2801198092Srdivackybool 2802198092SrdivackyTemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New, 2803193326Sed CXXMethodDecl *Tmpl) { 2804195099Sed if (InitFunctionInstantiation(New, Tmpl)) 2805195099Sed return true; 2806198092Srdivacky 2807193326Sed New->setAccess(Tmpl->getAccess()); 2808200583Srdivacky if (Tmpl->isVirtualAsWritten()) 2809218893Sdim New->setVirtualAsWritten(true); 2810193326Sed 2811193326Sed // FIXME: New needs a pointer to Tmpl 2812193326Sed return false; 2813193326Sed} 2814193326Sed 2815193326Sed/// \brief Instantiate the definition of the given function from its 2816193326Sed/// template. 2817193326Sed/// 2818195341Sed/// \param PointOfInstantiation the point at which the instantiation was 2819195341Sed/// required. Note that this is not precisely a "point of instantiation" 2820195341Sed/// for the function, but it's close. 2821195341Sed/// 2822193326Sed/// \param Function the already-instantiated declaration of a 2823195341Sed/// function template specialization or member function of a class template 2824195341Sed/// specialization. 2825195341Sed/// 2826195341Sed/// \param Recursive if true, recursively instantiates any functions that 2827195341Sed/// are required by this instantiation. 2828198398Srdivacky/// 2829198398Srdivacky/// \param DefinitionRequired if true, then we are performing an explicit 2830198398Srdivacky/// instantiation where the body of the function is required. Complain if 2831198398Srdivacky/// there is no such body. 2832193326Sedvoid Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, 2833195341Sed FunctionDecl *Function, 2834198398Srdivacky bool Recursive, 2835198398Srdivacky bool DefinitionRequired) { 2836223017Sdim if (Function->isInvalidDecl() || Function->isDefined()) 2837193326Sed return; 2838193326Sed 2839226633Sdim // Never instantiate an explicit specialization except if it is a class scope 2840226633Sdim // explicit specialization. 2841226633Sdim if (Function->getTemplateSpecializationKind() == TSK_ExplicitSpecialization && 2842226633Sdim !Function->getClassScopeSpecializationPattern()) 2843198092Srdivacky return; 2844208600Srdivacky 2845193326Sed // Find the function body that we'll be substituting. 2846198893Srdivacky const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern(); 2847223017Sdim assert(PatternDecl && "instantiating a non-template"); 2848193326Sed 2849223017Sdim Stmt *Pattern = PatternDecl->getBody(PatternDecl); 2850223017Sdim assert(PatternDecl && "template definition is not a template"); 2851223017Sdim if (!Pattern) { 2852223017Sdim // Try to find a defaulted definition 2853223017Sdim PatternDecl->isDefined(PatternDecl); 2854223017Sdim } 2855223017Sdim assert(PatternDecl && "template definition is not a template"); 2856223017Sdim 2857221345Sdim // Postpone late parsed template instantiations. 2858223017Sdim if (PatternDecl->isLateTemplateParsed() && 2859223017Sdim !LateTemplateParser) { 2860221345Sdim PendingInstantiations.push_back( 2861221345Sdim std::make_pair(Function, PointOfInstantiation)); 2862221345Sdim return; 2863221345Sdim } 2864221345Sdim 2865221345Sdim // Call the LateTemplateParser callback if there a need to late parse 2866226633Sdim // a templated function definition. 2867223017Sdim if (!Pattern && PatternDecl->isLateTemplateParsed() && 2868221345Sdim LateTemplateParser) { 2869221345Sdim LateTemplateParser(OpaqueParser, PatternDecl); 2870221345Sdim Pattern = PatternDecl->getBody(PatternDecl); 2871221345Sdim } 2872221345Sdim 2873223017Sdim if (!Pattern && !PatternDecl->isDefaulted()) { 2874198398Srdivacky if (DefinitionRequired) { 2875198398Srdivacky if (Function->getPrimaryTemplate()) 2876226633Sdim Diag(PointOfInstantiation, 2877198398Srdivacky diag::err_explicit_instantiation_undefined_func_template) 2878198398Srdivacky << Function->getPrimaryTemplate(); 2879198398Srdivacky else 2880226633Sdim Diag(PointOfInstantiation, 2881198398Srdivacky diag::err_explicit_instantiation_undefined_member) 2882198398Srdivacky << 1 << Function->getDeclName() << Function->getDeclContext(); 2883226633Sdim 2884198398Srdivacky if (PatternDecl) 2885226633Sdim Diag(PatternDecl->getLocation(), 2886198398Srdivacky diag::note_explicit_instantiation_here); 2887208600Srdivacky Function->setInvalidDecl(); 2888212904Sdim } else if (Function->getTemplateSpecializationKind() 2889212904Sdim == TSK_ExplicitInstantiationDefinition) { 2890212904Sdim PendingInstantiations.push_back( 2891212904Sdim std::make_pair(Function, PointOfInstantiation)); 2892198398Srdivacky } 2893212904Sdim 2894193326Sed return; 2895198398Srdivacky } 2896193326Sed 2897251662Sdim // C++1y [temp.explicit]p10: 2898251662Sdim // Except for inline functions, declarations with types deduced from their 2899251662Sdim // initializer or return value, and class template specializations, other 2900251662Sdim // explicit instantiation declarations have the effect of suppressing the 2901251662Sdim // implicit instantiation of the entity to which they refer. 2902198092Srdivacky if (Function->getTemplateSpecializationKind() 2903198092Srdivacky == TSK_ExplicitInstantiationDeclaration && 2904251662Sdim !PatternDecl->isInlined() && 2905251662Sdim !PatternDecl->getResultType()->isUndeducedType()) 2906198092Srdivacky return; 2907198092Srdivacky 2908249423Sdim if (PatternDecl->isInlined()) 2909249423Sdim Function->setImplicitlyInline(); 2910249423Sdim 2911193326Sed InstantiatingTemplate Inst(*this, PointOfInstantiation, Function); 2912193326Sed if (Inst) 2913226633Sdim return; 2914226633Sdim 2915234353Sdim // Copy the inner loc start from the pattern. 2916234353Sdim Function->setInnerLocStart(PatternDecl->getInnerLocStart()); 2917234353Sdim 2918195341Sed // If we're performing recursive template instantiation, create our own 2919195341Sed // queue of pending implicit instantiations that we will instantiate later, 2920195341Sed // while we're still within our own instantiation context. 2921226633Sdim SmallVector<VTableUse, 16> SavedVTableUses; 2922212904Sdim std::deque<PendingImplicitInstantiation> SavedPendingInstantiations; 2923218893Sdim if (Recursive) { 2924218893Sdim VTableUses.swap(SavedVTableUses); 2925212904Sdim PendingInstantiations.swap(SavedPendingInstantiations); 2926218893Sdim } 2927198092Srdivacky 2928226633Sdim EnterExpressionEvaluationContext EvalContext(*this, 2929212904Sdim Sema::PotentiallyEvaluated); 2930193326Sed 2931193326Sed // Introduce a new scope where local variable instantiations will be 2932202879Srdivacky // recorded, unless we're actually a member function within a local 2933202879Srdivacky // class, in which case we need to merge our results with the parent 2934202879Srdivacky // scope (of the enclosing function). 2935202879Srdivacky bool MergeWithParentScope = false; 2936202879Srdivacky if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext())) 2937202879Srdivacky MergeWithParentScope = Rec->isLocalClass(); 2938198092Srdivacky 2939202879Srdivacky LocalInstantiationScope Scope(*this, MergeWithParentScope); 2940202879Srdivacky 2941249423Sdim if (PatternDecl->isDefaulted()) 2942249423Sdim SetDeclDefaulted(Function, PatternDecl->getLocation()); 2943249423Sdim else { 2944249423Sdim ActOnStartOfFunctionDef(0, Function); 2945234353Sdim 2946249423Sdim // Enter the scope of this instantiation. We don't use 2947249423Sdim // PushDeclContext because we don't have a scope. 2948249423Sdim Sema::ContextRAII savedContext(*this, Function); 2949234353Sdim 2950249423Sdim MultiLevelTemplateArgumentList TemplateArgs = 2951249423Sdim getTemplateInstantiationArgs(Function, 0, false, PatternDecl); 2952226633Sdim 2953249423Sdim addInstantiatedParametersToScope(*this, Function, PatternDecl, Scope, 2954249423Sdim TemplateArgs); 2955198092Srdivacky 2956223017Sdim // If this is a constructor, instantiate the member initializers. 2957223017Sdim if (const CXXConstructorDecl *Ctor = 2958223017Sdim dyn_cast<CXXConstructorDecl>(PatternDecl)) { 2959223017Sdim InstantiateMemInitializers(cast<CXXConstructorDecl>(Function), Ctor, 2960223017Sdim TemplateArgs); 2961223017Sdim } 2962193326Sed 2963223017Sdim // Instantiate the function body. 2964223017Sdim StmtResult Body = SubstStmt(Pattern, TemplateArgs); 2965193326Sed 2966223017Sdim if (Body.isInvalid()) 2967223017Sdim Function->setInvalidDecl(); 2968226633Sdim 2969223017Sdim ActOnFinishFunctionBody(Function, Body.get(), 2970223017Sdim /*IsInstantiation=*/true); 2971223017Sdim 2972249423Sdim PerformDependentDiagnostics(PatternDecl, TemplateArgs); 2973206084Srdivacky 2974249423Sdim savedContext.pop(); 2975249423Sdim } 2976193326Sed 2977193326Sed DeclGroupRef DG(Function); 2978193326Sed Consumer.HandleTopLevelDecl(DG); 2979198092Srdivacky 2980202879Srdivacky // This class may have local implicit instantiations that need to be 2981202879Srdivacky // instantiation within this scope. 2982212904Sdim PerformPendingInstantiations(/*LocalOnly=*/true); 2983202879Srdivacky Scope.Exit(); 2984202879Srdivacky 2985195341Sed if (Recursive) { 2986218893Sdim // Define any pending vtables. 2987218893Sdim DefineUsedVTables(); 2988218893Sdim 2989195341Sed // Instantiate any pending implicit instantiations found during the 2990198092Srdivacky // instantiation of this template. 2991212904Sdim PerformPendingInstantiations(); 2992198092Srdivacky 2993218893Sdim // Restore the set of pending vtables. 2994223017Sdim assert(VTableUses.empty() && 2995223017Sdim "VTableUses should be empty before it is discarded."); 2996218893Sdim VTableUses.swap(SavedVTableUses); 2997218893Sdim 2998195341Sed // Restore the set of pending implicit instantiations. 2999223017Sdim assert(PendingInstantiations.empty() && 3000223017Sdim "PendingInstantiations should be empty before it is discarded."); 3001212904Sdim PendingInstantiations.swap(SavedPendingInstantiations); 3002195341Sed } 3003193326Sed} 3004193326Sed 3005193326Sed/// \brief Instantiate the definition of the given variable from its 3006193326Sed/// template. 3007193326Sed/// 3008198092Srdivacky/// \param PointOfInstantiation the point at which the instantiation was 3009198092Srdivacky/// required. Note that this is not precisely a "point of instantiation" 3010198092Srdivacky/// for the function, but it's close. 3011198092Srdivacky/// 3012198092Srdivacky/// \param Var the already-instantiated declaration of a static member 3013198092Srdivacky/// variable of a class template specialization. 3014198092Srdivacky/// 3015198092Srdivacky/// \param Recursive if true, recursively instantiates any functions that 3016198092Srdivacky/// are required by this instantiation. 3017198398Srdivacky/// 3018198398Srdivacky/// \param DefinitionRequired if true, then we are performing an explicit 3019198398Srdivacky/// instantiation where an out-of-line definition of the member variable 3020198398Srdivacky/// is required. Complain if there is no such definition. 3021198092Srdivackyvoid Sema::InstantiateStaticDataMemberDefinition( 3022198092Srdivacky SourceLocation PointOfInstantiation, 3023198092Srdivacky VarDecl *Var, 3024198398Srdivacky bool Recursive, 3025198398Srdivacky bool DefinitionRequired) { 3026198092Srdivacky if (Var->isInvalidDecl()) 3027198092Srdivacky return; 3028198092Srdivacky 3029198092Srdivacky // Find the out-of-line definition of this static data member. 3030198092Srdivacky VarDecl *Def = Var->getInstantiatedFromStaticDataMember(); 3031198092Srdivacky assert(Def && "This data member was not instantiated from a template?"); 3032226633Sdim assert(Def->isStaticDataMember() && "Not a static data member?"); 3033198893Srdivacky Def = Def->getOutOfLineDefinition(); 3034198092Srdivacky 3035198893Srdivacky if (!Def) { 3036198092Srdivacky // We did not find an out-of-line definition of this static data member, 3037198092Srdivacky // so we won't perform any instantiation. Rather, we rely on the user to 3038198092Srdivacky // instantiate this definition (or provide a specialization for it) in 3039198092Srdivacky // another translation unit. 3040198398Srdivacky if (DefinitionRequired) { 3041198893Srdivacky Def = Var->getInstantiatedFromStaticDataMember(); 3042226633Sdim Diag(PointOfInstantiation, 3043198398Srdivacky diag::err_explicit_instantiation_undefined_member) 3044198398Srdivacky << 2 << Var->getDeclName() << Var->getDeclContext(); 3045198398Srdivacky Diag(Def->getLocation(), diag::note_explicit_instantiation_here); 3046212904Sdim } else if (Var->getTemplateSpecializationKind() 3047212904Sdim == TSK_ExplicitInstantiationDefinition) { 3048212904Sdim PendingInstantiations.push_back( 3049212904Sdim std::make_pair(Var, PointOfInstantiation)); 3050212904Sdim } 3051212904Sdim 3052198092Srdivacky return; 3053198092Srdivacky } 3054198092Srdivacky 3055234353Sdim TemplateSpecializationKind TSK = Var->getTemplateSpecializationKind(); 3056234353Sdim 3057198092Srdivacky // Never instantiate an explicit specialization. 3058234353Sdim if (TSK == TSK_ExplicitSpecialization) 3059198092Srdivacky return; 3060226633Sdim 3061198092Srdivacky // C++0x [temp.explicit]p9: 3062198092Srdivacky // Except for inline functions, other explicit instantiation declarations 3063198092Srdivacky // have the effect of suppressing the implicit instantiation of the entity 3064198092Srdivacky // to which they refer. 3065234353Sdim if (TSK == TSK_ExplicitInstantiationDeclaration) 3066198092Srdivacky return; 3067198092Srdivacky 3068249423Sdim // Make sure to pass the instantiated variable to the consumer at the end. 3069249423Sdim struct PassToConsumerRAII { 3070249423Sdim ASTConsumer &Consumer; 3071249423Sdim VarDecl *Var; 3072234353Sdim 3073249423Sdim PassToConsumerRAII(ASTConsumer &Consumer, VarDecl *Var) 3074249423Sdim : Consumer(Consumer), Var(Var) { } 3075249423Sdim 3076249423Sdim ~PassToConsumerRAII() { 3077249423Sdim Consumer.HandleCXXStaticMemberVarInstantiation(Var); 3078249423Sdim } 3079249423Sdim } PassToConsumerRAII(Consumer, Var); 3080249423Sdim 3081223017Sdim // If we already have a definition, we're done. 3082234353Sdim if (VarDecl *Def = Var->getDefinition()) { 3083234353Sdim // We may be explicitly instantiating something we've already implicitly 3084234353Sdim // instantiated. 3085234353Sdim Def->setTemplateSpecializationKind(Var->getTemplateSpecializationKind(), 3086234353Sdim PointOfInstantiation); 3087223017Sdim return; 3088234353Sdim } 3089223017Sdim 3090198092Srdivacky InstantiatingTemplate Inst(*this, PointOfInstantiation, Var); 3091198092Srdivacky if (Inst) 3092198092Srdivacky return; 3093198092Srdivacky 3094198092Srdivacky // If we're performing recursive template instantiation, create our own 3095198092Srdivacky // queue of pending implicit instantiations that we will instantiate later, 3096198092Srdivacky // while we're still within our own instantiation context. 3097226633Sdim SmallVector<VTableUse, 16> SavedVTableUses; 3098212904Sdim std::deque<PendingImplicitInstantiation> SavedPendingInstantiations; 3099223017Sdim if (Recursive) { 3100223017Sdim VTableUses.swap(SavedVTableUses); 3101212904Sdim PendingInstantiations.swap(SavedPendingInstantiations); 3102223017Sdim } 3103198092Srdivacky 3104198092Srdivacky // Enter the scope of this instantiation. We don't use 3105198092Srdivacky // PushDeclContext because we don't have a scope. 3106218893Sdim ContextRAII previousContext(*this, Var->getDeclContext()); 3107234353Sdim LocalInstantiationScope Local(*this); 3108234353Sdim 3109198112Srdivacky VarDecl *OldVar = Var; 3110198092Srdivacky Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(), 3111218893Sdim getTemplateInstantiationArgs(Var))); 3112198092Srdivacky 3113218893Sdim previousContext.pop(); 3114218893Sdim 3115198092Srdivacky if (Var) { 3116249423Sdim PassToConsumerRAII.Var = Var; 3117198398Srdivacky MemberSpecializationInfo *MSInfo = OldVar->getMemberSpecializationInfo(); 3118198398Srdivacky assert(MSInfo && "Missing member specialization information?"); 3119198398Srdivacky Var->setTemplateSpecializationKind(MSInfo->getTemplateSpecializationKind(), 3120198398Srdivacky MSInfo->getPointOfInstantiation()); 3121198092Srdivacky } 3122234353Sdim Local.Exit(); 3123234353Sdim 3124198092Srdivacky if (Recursive) { 3125223017Sdim // Define any newly required vtables. 3126223017Sdim DefineUsedVTables(); 3127223017Sdim 3128198092Srdivacky // Instantiate any pending implicit instantiations found during the 3129198092Srdivacky // instantiation of this template. 3130212904Sdim PerformPendingInstantiations(); 3131198092Srdivacky 3132223017Sdim // Restore the set of pending vtables. 3133223017Sdim assert(VTableUses.empty() && 3134223017Sdim "VTableUses should be empty before it is discarded, " 3135223017Sdim "while instantiating static data member."); 3136223017Sdim VTableUses.swap(SavedVTableUses); 3137223017Sdim 3138198092Srdivacky // Restore the set of pending implicit instantiations. 3139223017Sdim assert(PendingInstantiations.empty() && 3140223017Sdim "PendingInstantiations should be empty before it is discarded, " 3141223017Sdim "while instantiating static data member."); 3142212904Sdim PendingInstantiations.swap(SavedPendingInstantiations); 3143198092Srdivacky } 3144193326Sed} 3145193326Sed 3146198092Srdivackyvoid 3147198092SrdivackySema::InstantiateMemInitializers(CXXConstructorDecl *New, 3148198092Srdivacky const CXXConstructorDecl *Tmpl, 3149198092Srdivacky const MultiLevelTemplateArgumentList &TemplateArgs) { 3150198092Srdivacky 3151226633Sdim SmallVector<CXXCtorInitializer*, 4> NewInits; 3152243830Sdim bool AnyErrors = Tmpl->isInvalidDecl(); 3153226633Sdim 3154198092Srdivacky // Instantiate all the initializers. 3155198092Srdivacky for (CXXConstructorDecl::init_const_iterator Inits = Tmpl->init_begin(), 3156198092Srdivacky InitsEnd = Tmpl->init_end(); 3157198092Srdivacky Inits != InitsEnd; ++Inits) { 3158218893Sdim CXXCtorInitializer *Init = *Inits; 3159198092Srdivacky 3160212904Sdim // Only instantiate written initializers, let Sema re-construct implicit 3161212904Sdim // ones. 3162212904Sdim if (!Init->isWritten()) 3163212904Sdim continue; 3164212904Sdim 3165218893Sdim SourceLocation EllipsisLoc; 3166226633Sdim 3167218893Sdim if (Init->isPackExpansion()) { 3168218893Sdim // This is a pack expansion. We should expand it now. 3169234353Sdim TypeLoc BaseTL = Init->getTypeSourceInfo()->getTypeLoc(); 3170226633Sdim SmallVector<UnexpandedParameterPack, 2> Unexpanded; 3171218893Sdim collectUnexpandedParameterPacks(BaseTL, Unexpanded); 3172218893Sdim bool ShouldExpand = false; 3173218893Sdim bool RetainExpansion = false; 3174249423Sdim Optional<unsigned> NumExpansions; 3175226633Sdim if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(), 3176218893Sdim BaseTL.getSourceRange(), 3177226633Sdim Unexpanded, 3178226633Sdim TemplateArgs, ShouldExpand, 3179218893Sdim RetainExpansion, 3180218893Sdim NumExpansions)) { 3181218893Sdim AnyErrors = true; 3182218893Sdim New->setInvalidDecl(); 3183218893Sdim continue; 3184218893Sdim } 3185218893Sdim assert(ShouldExpand && "Partial instantiation of base initializer?"); 3186226633Sdim 3187226633Sdim // Loop over all of the arguments in the argument pack(s), 3188218893Sdim for (unsigned I = 0; I != *NumExpansions; ++I) { 3189218893Sdim Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I); 3190218893Sdim 3191218893Sdim // Instantiate the initializer. 3192234353Sdim ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs, 3193234353Sdim /*CXXDirectInit=*/true); 3194234353Sdim if (TempInit.isInvalid()) { 3195218893Sdim AnyErrors = true; 3196218893Sdim break; 3197218893Sdim } 3198218893Sdim 3199218893Sdim // Instantiate the base type. 3200234353Sdim TypeSourceInfo *BaseTInfo = SubstType(Init->getTypeSourceInfo(), 3201226633Sdim TemplateArgs, 3202226633Sdim Init->getSourceLocation(), 3203218893Sdim New->getDeclName()); 3204218893Sdim if (!BaseTInfo) { 3205218893Sdim AnyErrors = true; 3206218893Sdim break; 3207218893Sdim } 3208218893Sdim 3209218893Sdim // Build the initializer. 3210226633Sdim MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(), 3211234353Sdim BaseTInfo, TempInit.take(), 3212218893Sdim New->getParent(), 3213218893Sdim SourceLocation()); 3214218893Sdim if (NewInit.isInvalid()) { 3215218893Sdim AnyErrors = true; 3216218893Sdim break; 3217218893Sdim } 3218226633Sdim 3219218893Sdim NewInits.push_back(NewInit.get()); 3220218893Sdim } 3221226633Sdim 3222218893Sdim continue; 3223218893Sdim } 3224218893Sdim 3225204643Srdivacky // Instantiate the initializer. 3226234353Sdim ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs, 3227234353Sdim /*CXXDirectInit=*/true); 3228234353Sdim if (TempInit.isInvalid()) { 3229204643Srdivacky AnyErrors = true; 3230204643Srdivacky continue; 3231198092Srdivacky } 3232226633Sdim 3233198092Srdivacky MemInitResult NewInit; 3234234353Sdim if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) { 3235234353Sdim TypeSourceInfo *TInfo = SubstType(Init->getTypeSourceInfo(), 3236234353Sdim TemplateArgs, 3237234353Sdim Init->getSourceLocation(), 3238234353Sdim New->getDeclName()); 3239234353Sdim if (!TInfo) { 3240203955Srdivacky AnyErrors = true; 3241200583Srdivacky New->setInvalidDecl(); 3242200583Srdivacky continue; 3243200583Srdivacky } 3244226633Sdim 3245234353Sdim if (Init->isBaseInitializer()) 3246234353Sdim NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.take(), 3247234353Sdim New->getParent(), EllipsisLoc); 3248234353Sdim else 3249234353Sdim NewInit = BuildDelegatingInitializer(TInfo, TempInit.take(), 3250234353Sdim cast<CXXRecordDecl>(CurContext->getParent())); 3251198092Srdivacky } else if (Init->isMemberInitializer()) { 3252221345Sdim FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl( 3253218893Sdim Init->getMemberLocation(), 3254218893Sdim Init->getMember(), 3255218893Sdim TemplateArgs)); 3256221345Sdim if (!Member) { 3257221345Sdim AnyErrors = true; 3258221345Sdim New->setInvalidDecl(); 3259221345Sdim continue; 3260221345Sdim } 3261198092Srdivacky 3262234353Sdim NewInit = BuildMemberInitializer(Member, TempInit.take(), 3263226633Sdim Init->getSourceLocation()); 3264218893Sdim } else if (Init->isIndirectMemberInitializer()) { 3265218893Sdim IndirectFieldDecl *IndirectMember = 3266221345Sdim cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl( 3267218893Sdim Init->getMemberLocation(), 3268218893Sdim Init->getIndirectMember(), TemplateArgs)); 3269218893Sdim 3270221345Sdim if (!IndirectMember) { 3271221345Sdim AnyErrors = true; 3272221345Sdim New->setInvalidDecl(); 3273226633Sdim continue; 3274221345Sdim } 3275226633Sdim 3276234353Sdim NewInit = BuildMemberInitializer(IndirectMember, TempInit.take(), 3277226633Sdim Init->getSourceLocation()); 3278198092Srdivacky } 3279198092Srdivacky 3280203955Srdivacky if (NewInit.isInvalid()) { 3281203955Srdivacky AnyErrors = true; 3282198092Srdivacky New->setInvalidDecl(); 3283203955Srdivacky } else { 3284226633Sdim NewInits.push_back(NewInit.get()); 3285198092Srdivacky } 3286198092Srdivacky } 3287198092Srdivacky 3288198092Srdivacky // Assign all the initializers to the new constructor. 3289212904Sdim ActOnMemInitializers(New, 3290198092Srdivacky /*FIXME: ColonLoc */ 3291198092Srdivacky SourceLocation(), 3292249423Sdim NewInits, 3293203955Srdivacky AnyErrors); 3294198092Srdivacky} 3295198092Srdivacky 3296198092Srdivacky// TODO: this could be templated if the various decl types used the 3297198092Srdivacky// same method name. 3298198092Srdivackystatic bool isInstantiationOf(ClassTemplateDecl *Pattern, 3299198092Srdivacky ClassTemplateDecl *Instance) { 3300198092Srdivacky Pattern = Pattern->getCanonicalDecl(); 3301198092Srdivacky 3302198092Srdivacky do { 3303198092Srdivacky Instance = Instance->getCanonicalDecl(); 3304198092Srdivacky if (Pattern == Instance) return true; 3305198092Srdivacky Instance = Instance->getInstantiatedFromMemberTemplate(); 3306198092Srdivacky } while (Instance); 3307198092Srdivacky 3308198092Srdivacky return false; 3309198092Srdivacky} 3310198092Srdivacky 3311198092Srdivackystatic bool isInstantiationOf(FunctionTemplateDecl *Pattern, 3312198092Srdivacky FunctionTemplateDecl *Instance) { 3313198092Srdivacky Pattern = Pattern->getCanonicalDecl(); 3314226633Sdim 3315198092Srdivacky do { 3316198092Srdivacky Instance = Instance->getCanonicalDecl(); 3317198092Srdivacky if (Pattern == Instance) return true; 3318198092Srdivacky Instance = Instance->getInstantiatedFromMemberTemplate(); 3319198092Srdivacky } while (Instance); 3320226633Sdim 3321198092Srdivacky return false; 3322198092Srdivacky} 3323198092Srdivacky 3324226633Sdimstatic bool 3325198893SrdivackyisInstantiationOf(ClassTemplatePartialSpecializationDecl *Pattern, 3326198893Srdivacky ClassTemplatePartialSpecializationDecl *Instance) { 3327226633Sdim Pattern 3328198893Srdivacky = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl()); 3329198893Srdivacky do { 3330198893Srdivacky Instance = cast<ClassTemplatePartialSpecializationDecl>( 3331198893Srdivacky Instance->getCanonicalDecl()); 3332198893Srdivacky if (Pattern == Instance) 3333198893Srdivacky return true; 3334198893Srdivacky Instance = Instance->getInstantiatedFromMember(); 3335198893Srdivacky } while (Instance); 3336226633Sdim 3337198893Srdivacky return false; 3338198893Srdivacky} 3339198893Srdivacky 3340198092Srdivackystatic bool isInstantiationOf(CXXRecordDecl *Pattern, 3341198092Srdivacky CXXRecordDecl *Instance) { 3342198092Srdivacky Pattern = Pattern->getCanonicalDecl(); 3343198092Srdivacky 3344198092Srdivacky do { 3345198092Srdivacky Instance = Instance->getCanonicalDecl(); 3346198092Srdivacky if (Pattern == Instance) return true; 3347198092Srdivacky Instance = Instance->getInstantiatedFromMemberClass(); 3348198092Srdivacky } while (Instance); 3349198092Srdivacky 3350198092Srdivacky return false; 3351198092Srdivacky} 3352198092Srdivacky 3353198092Srdivackystatic bool isInstantiationOf(FunctionDecl *Pattern, 3354198092Srdivacky FunctionDecl *Instance) { 3355198092Srdivacky Pattern = Pattern->getCanonicalDecl(); 3356198092Srdivacky 3357198092Srdivacky do { 3358198092Srdivacky Instance = Instance->getCanonicalDecl(); 3359198092Srdivacky if (Pattern == Instance) return true; 3360198092Srdivacky Instance = Instance->getInstantiatedFromMemberFunction(); 3361198092Srdivacky } while (Instance); 3362198092Srdivacky 3363198092Srdivacky return false; 3364198092Srdivacky} 3365198092Srdivacky 3366198092Srdivackystatic bool isInstantiationOf(EnumDecl *Pattern, 3367198092Srdivacky EnumDecl *Instance) { 3368198092Srdivacky Pattern = Pattern->getCanonicalDecl(); 3369198092Srdivacky 3370198092Srdivacky do { 3371198092Srdivacky Instance = Instance->getCanonicalDecl(); 3372198092Srdivacky if (Pattern == Instance) return true; 3373198092Srdivacky Instance = Instance->getInstantiatedFromMemberEnum(); 3374198092Srdivacky } while (Instance); 3375198092Srdivacky 3376198092Srdivacky return false; 3377198092Srdivacky} 3378198092Srdivacky 3379200583Srdivackystatic bool isInstantiationOf(UsingShadowDecl *Pattern, 3380200583Srdivacky UsingShadowDecl *Instance, 3381200583Srdivacky ASTContext &C) { 3382200583Srdivacky return C.getInstantiatedFromUsingShadowDecl(Instance) == Pattern; 3383200583Srdivacky} 3384200583Srdivacky 3385200583Srdivackystatic bool isInstantiationOf(UsingDecl *Pattern, 3386200583Srdivacky UsingDecl *Instance, 3387200583Srdivacky ASTContext &C) { 3388200583Srdivacky return C.getInstantiatedFromUsingDecl(Instance) == Pattern; 3389200583Srdivacky} 3390200583Srdivacky 3391199482Srdivackystatic bool isInstantiationOf(UnresolvedUsingValueDecl *Pattern, 3392198092Srdivacky UsingDecl *Instance, 3393198092Srdivacky ASTContext &C) { 3394200583Srdivacky return C.getInstantiatedFromUsingDecl(Instance) == Pattern; 3395198092Srdivacky} 3396198092Srdivacky 3397199482Srdivackystatic bool isInstantiationOf(UnresolvedUsingTypenameDecl *Pattern, 3398199482Srdivacky UsingDecl *Instance, 3399199482Srdivacky ASTContext &C) { 3400200583Srdivacky return C.getInstantiatedFromUsingDecl(Instance) == Pattern; 3401199482Srdivacky} 3402199482Srdivacky 3403198092Srdivackystatic bool isInstantiationOfStaticDataMember(VarDecl *Pattern, 3404198092Srdivacky VarDecl *Instance) { 3405198092Srdivacky assert(Instance->isStaticDataMember()); 3406198092Srdivacky 3407198092Srdivacky Pattern = Pattern->getCanonicalDecl(); 3408198092Srdivacky 3409198092Srdivacky do { 3410198092Srdivacky Instance = Instance->getCanonicalDecl(); 3411198092Srdivacky if (Pattern == Instance) return true; 3412198092Srdivacky Instance = Instance->getInstantiatedFromStaticDataMember(); 3413198092Srdivacky } while (Instance); 3414198092Srdivacky 3415198092Srdivacky return false; 3416198092Srdivacky} 3417198092Srdivacky 3418200583Srdivacky// Other is the prospective instantiation 3419200583Srdivacky// D is the prospective pattern 3420193326Sedstatic bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) { 3421198092Srdivacky if (D->getKind() != Other->getKind()) { 3422199482Srdivacky if (UnresolvedUsingTypenameDecl *UUD 3423199482Srdivacky = dyn_cast<UnresolvedUsingTypenameDecl>(D)) { 3424198092Srdivacky if (UsingDecl *UD = dyn_cast<UsingDecl>(Other)) { 3425198092Srdivacky return isInstantiationOf(UUD, UD, Ctx); 3426198092Srdivacky } 3427198092Srdivacky } 3428198092Srdivacky 3429199482Srdivacky if (UnresolvedUsingValueDecl *UUD 3430199482Srdivacky = dyn_cast<UnresolvedUsingValueDecl>(D)) { 3431199482Srdivacky if (UsingDecl *UD = dyn_cast<UsingDecl>(Other)) { 3432199482Srdivacky return isInstantiationOf(UUD, UD, Ctx); 3433199482Srdivacky } 3434199482Srdivacky } 3435199482Srdivacky 3436193326Sed return false; 3437198092Srdivacky } 3438193326Sed 3439193326Sed if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Other)) 3440198092Srdivacky return isInstantiationOf(cast<CXXRecordDecl>(D), Record); 3441193326Sed 3442193326Sed if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Other)) 3443198092Srdivacky return isInstantiationOf(cast<FunctionDecl>(D), Function); 3444193326Sed 3445193326Sed if (EnumDecl *Enum = dyn_cast<EnumDecl>(Other)) 3446198092Srdivacky return isInstantiationOf(cast<EnumDecl>(D), Enum); 3447193326Sed 3448198092Srdivacky if (VarDecl *Var = dyn_cast<VarDecl>(Other)) 3449198092Srdivacky if (Var->isStaticDataMember()) 3450198092Srdivacky return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var); 3451193326Sed 3452198092Srdivacky if (ClassTemplateDecl *Temp = dyn_cast<ClassTemplateDecl>(Other)) 3453198092Srdivacky return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp); 3454198092Srdivacky 3455198092Srdivacky if (FunctionTemplateDecl *Temp = dyn_cast<FunctionTemplateDecl>(Other)) 3456198092Srdivacky return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp); 3457198092Srdivacky 3458198893Srdivacky if (ClassTemplatePartialSpecializationDecl *PartialSpec 3459198893Srdivacky = dyn_cast<ClassTemplatePartialSpecializationDecl>(Other)) 3460198893Srdivacky return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D), 3461198893Srdivacky PartialSpec); 3462198893Srdivacky 3463198092Srdivacky if (FieldDecl *Field = dyn_cast<FieldDecl>(Other)) { 3464198092Srdivacky if (!Field->getDeclName()) { 3465198092Srdivacky // This is an unnamed field. 3466198092Srdivacky return Ctx.getInstantiatedFromUnnamedFieldDecl(Field) == 3467198092Srdivacky cast<FieldDecl>(D); 3468198092Srdivacky } 3469198092Srdivacky } 3470198092Srdivacky 3471200583Srdivacky if (UsingDecl *Using = dyn_cast<UsingDecl>(Other)) 3472200583Srdivacky return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx); 3473200583Srdivacky 3474200583Srdivacky if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(Other)) 3475200583Srdivacky return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx); 3476200583Srdivacky 3477193326Sed return D->getDeclName() && isa<NamedDecl>(Other) && 3478193326Sed D->getDeclName() == cast<NamedDecl>(Other)->getDeclName(); 3479193326Sed} 3480193326Sed 3481193326Sedtemplate<typename ForwardIterator> 3482198092Srdivackystatic NamedDecl *findInstantiationOf(ASTContext &Ctx, 3483193326Sed NamedDecl *D, 3484193326Sed ForwardIterator first, 3485193326Sed ForwardIterator last) { 3486193326Sed for (; first != last; ++first) 3487193326Sed if (isInstantiationOf(Ctx, D, *first)) 3488193326Sed return cast<NamedDecl>(*first); 3489193326Sed 3490193326Sed return 0; 3491193326Sed} 3492193326Sed 3493198092Srdivacky/// \brief Finds the instantiation of the given declaration context 3494198092Srdivacky/// within the current instantiation. 3495198092Srdivacky/// 3496198092Srdivacky/// \returns NULL if there was an error 3497204643SrdivackyDeclContext *Sema::FindInstantiatedContext(SourceLocation Loc, DeclContext* DC, 3498198092Srdivacky const MultiLevelTemplateArgumentList &TemplateArgs) { 3499198092Srdivacky if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) { 3500204643Srdivacky Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs); 3501198092Srdivacky return cast_or_null<DeclContext>(ID); 3502198092Srdivacky } else return DC; 3503198092Srdivacky} 3504198092Srdivacky 3505193326Sed/// \brief Find the instantiation of the given declaration within the 3506193326Sed/// current instantiation. 3507193326Sed/// 3508193326Sed/// This routine is intended to be used when \p D is a declaration 3509193326Sed/// referenced from within a template, that needs to mapped into the 3510193326Sed/// corresponding declaration within an instantiation. For example, 3511193326Sed/// given: 3512193326Sed/// 3513193326Sed/// \code 3514193326Sed/// template<typename T> 3515193326Sed/// struct X { 3516193326Sed/// enum Kind { 3517193326Sed/// KnownValue = sizeof(T) 3518193326Sed/// }; 3519193326Sed/// 3520193326Sed/// bool getKind() const { return KnownValue; } 3521193326Sed/// }; 3522193326Sed/// 3523193326Sed/// template struct X<int>; 3524193326Sed/// \endcode 3525193326Sed/// 3526193326Sed/// In the instantiation of X<int>::getKind(), we need to map the 3527193326Sed/// EnumConstantDecl for KnownValue (which refers to 3528239462Sdim/// X<T>::\<Kind>\::KnownValue) to its instantiation 3529239462Sdim/// (X<int>::\<Kind>\::KnownValue). InstantiateCurrentDeclRef() performs 3530193326Sed/// this mapping from within the instantiation of X<int>. 3531204643SrdivackyNamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, 3532198092Srdivacky const MultiLevelTemplateArgumentList &TemplateArgs) { 3533193326Sed DeclContext *ParentDC = D->getDeclContext(); 3534198893Srdivacky if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) || 3535203955Srdivacky isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) || 3536234353Sdim (ParentDC->isFunctionOrMethod() && ParentDC->isDependentContext()) || 3537234353Sdim (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda())) { 3538193326Sed // D is a local of some kind. Look into the map of local 3539193326Sed // declarations to their instantiations. 3540218893Sdim typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack; 3541218893Sdim llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found 3542218893Sdim = CurrentInstantiationScope->findInstantiationOf(D); 3543226633Sdim 3544218893Sdim if (Found) { 3545218893Sdim if (Decl *FD = Found->dyn_cast<Decl *>()) 3546218893Sdim return cast<NamedDecl>(FD); 3547226633Sdim 3548243830Sdim int PackIdx = ArgumentPackSubstitutionIndex; 3549243830Sdim assert(PackIdx != -1 && "found declaration pack but not pack expanding"); 3550218893Sdim return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]); 3551218893Sdim } 3552218893Sdim 3553218893Sdim // If we didn't find the decl, then we must have a label decl that hasn't 3554218893Sdim // been found yet. Lazily instantiate it and return it now. 3555218893Sdim assert(isa<LabelDecl>(D)); 3556226633Sdim 3557218893Sdim Decl *Inst = SubstDecl(D, CurContext, TemplateArgs); 3558218893Sdim assert(Inst && "Failed to instantiate label??"); 3559226633Sdim 3560218893Sdim CurrentInstantiationScope->InstantiatedLocal(D, Inst); 3561218893Sdim return cast<LabelDecl>(Inst); 3562193326Sed } 3563193326Sed 3564198092Srdivacky if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) { 3565198092Srdivacky if (!Record->isDependentContext()) 3566198092Srdivacky return D; 3567226633Sdim 3568234353Sdim // Determine whether this record is the "templated" declaration describing 3569234353Sdim // a class template or class template partial specialization. 3570198092Srdivacky ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate(); 3571234353Sdim if (ClassTemplate) 3572234353Sdim ClassTemplate = ClassTemplate->getCanonicalDecl(); 3573234353Sdim else if (ClassTemplatePartialSpecializationDecl *PartialSpec 3574234353Sdim = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) 3575234353Sdim ClassTemplate = PartialSpec->getSpecializedTemplate()->getCanonicalDecl(); 3576234353Sdim 3577234353Sdim // Walk the current context to find either the record or an instantiation of 3578234353Sdim // it. 3579234353Sdim DeclContext *DC = CurContext; 3580234353Sdim while (!DC->isFileContext()) { 3581234353Sdim // If we're performing substitution while we're inside the template 3582234353Sdim // definition, we'll find our own context. We're done. 3583234353Sdim if (DC->Equals(Record)) 3584234353Sdim return Record; 3585234353Sdim 3586234353Sdim if (CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) { 3587234353Sdim // Check whether we're in the process of instantiating a class template 3588234353Sdim // specialization of the template we're mapping. 3589234353Sdim if (ClassTemplateSpecializationDecl *InstSpec 3590234353Sdim = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){ 3591234353Sdim ClassTemplateDecl *SpecTemplate = InstSpec->getSpecializedTemplate(); 3592234353Sdim if (ClassTemplate && isInstantiationOf(ClassTemplate, SpecTemplate)) 3593234353Sdim return InstRecord; 3594234353Sdim } 3595234353Sdim 3596234353Sdim // Check whether we're in the process of instantiating a member class. 3597234353Sdim if (isInstantiationOf(Record, InstRecord)) 3598234353Sdim return InstRecord; 3599198092Srdivacky } 3600234353Sdim 3601234353Sdim 3602234353Sdim // Move to the outer template scope. 3603234353Sdim if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) { 3604234353Sdim if (FD->getFriendObjectKind() && FD->getDeclContext()->isFileContext()){ 3605234353Sdim DC = FD->getLexicalDeclContext(); 3606234353Sdim continue; 3607234353Sdim } 3608198092Srdivacky } 3609234353Sdim 3610234353Sdim DC = DC->getParent(); 3611198092Srdivacky } 3612203955Srdivacky 3613198092Srdivacky // Fall through to deal with other dependent record types (e.g., 3614198092Srdivacky // anonymous unions in class templates). 3615193326Sed } 3616193326Sed 3617198092Srdivacky if (!ParentDC->isDependentContext()) 3618198092Srdivacky return D; 3619226633Sdim 3620204643Srdivacky ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs); 3621198092Srdivacky if (!ParentDC) 3622198092Srdivacky return 0; 3623198092Srdivacky 3624193326Sed if (ParentDC != D->getDeclContext()) { 3625193326Sed // We performed some kind of instantiation in the parent context, 3626193326Sed // so now we need to look into the instantiated parent context to 3627193326Sed // find the instantiation of the declaration D. 3628204643Srdivacky 3629204962Srdivacky // If our context used to be dependent, we may need to instantiate 3630204962Srdivacky // it before performing lookup into that context. 3631221345Sdim bool IsBeingInstantiated = false; 3632204962Srdivacky if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) { 3633204643Srdivacky if (!Spec->isDependentContext()) { 3634204643Srdivacky QualType T = Context.getTypeDeclType(Spec); 3635204962Srdivacky const RecordType *Tag = T->getAs<RecordType>(); 3636204962Srdivacky assert(Tag && "type of non-dependent record is not a RecordType"); 3637221345Sdim if (Tag->isBeingDefined()) 3638221345Sdim IsBeingInstantiated = true; 3639204962Srdivacky if (!Tag->isBeingDefined() && 3640204962Srdivacky RequireCompleteType(Loc, T, diag::err_incomplete_type)) 3641204962Srdivacky return 0; 3642218893Sdim 3643218893Sdim ParentDC = Tag->getDecl(); 3644204643Srdivacky } 3645204643Srdivacky } 3646204643Srdivacky 3647193326Sed NamedDecl *Result = 0; 3648193326Sed if (D->getDeclName()) { 3649195341Sed DeclContext::lookup_result Found = ParentDC->lookup(D->getDeclName()); 3650249423Sdim Result = findInstantiationOf(Context, D, Found.begin(), Found.end()); 3651193326Sed } else { 3652193326Sed // Since we don't have a name for the entity we're looking for, 3653193326Sed // our only option is to walk through all of the declarations to 3654193326Sed // find that name. This will occur in a few cases: 3655193326Sed // 3656193326Sed // - anonymous struct/union within a template 3657193326Sed // - unnamed class/struct/union/enum within a template 3658193326Sed // 3659193326Sed // FIXME: Find a better way to find these instantiations! 3660198092Srdivacky Result = findInstantiationOf(Context, D, 3661195341Sed ParentDC->decls_begin(), 3662195341Sed ParentDC->decls_end()); 3663193326Sed } 3664198092Srdivacky 3665221345Sdim if (!Result) { 3666221345Sdim if (isa<UsingShadowDecl>(D)) { 3667221345Sdim // UsingShadowDecls can instantiate to nothing because of using hiding. 3668221345Sdim } else if (Diags.hasErrorOccurred()) { 3669221345Sdim // We've already complained about something, so most likely this 3670221345Sdim // declaration failed to instantiate. There's no point in complaining 3671221345Sdim // further, since this is normal in invalid code. 3672221345Sdim } else if (IsBeingInstantiated) { 3673226633Sdim // The class in which this member exists is currently being 3674221345Sdim // instantiated, and we haven't gotten around to instantiating this 3675221345Sdim // member yet. This can happen when the code uses forward declarations 3676221345Sdim // of member classes, and introduces ordering dependencies via 3677221345Sdim // template instantiation. 3678221345Sdim Diag(Loc, diag::err_member_not_yet_instantiated) 3679221345Sdim << D->getDeclName() 3680221345Sdim << Context.getTypeDeclType(cast<CXXRecordDecl>(ParentDC)); 3681221345Sdim Diag(D->getLocation(), diag::note_non_instantiated_member_here); 3682234353Sdim } else if (EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) { 3683234353Sdim // This enumeration constant was found when the template was defined, 3684234353Sdim // but can't be found in the instantiation. This can happen if an 3685234353Sdim // unscoped enumeration member is explicitly specialized. 3686234353Sdim EnumDecl *Enum = cast<EnumDecl>(ED->getLexicalDeclContext()); 3687234353Sdim EnumDecl *Spec = cast<EnumDecl>(FindInstantiatedDecl(Loc, Enum, 3688234353Sdim TemplateArgs)); 3689234353Sdim assert(Spec->getTemplateSpecializationKind() == 3690234353Sdim TSK_ExplicitSpecialization); 3691234353Sdim Diag(Loc, diag::err_enumerator_does_not_exist) 3692234353Sdim << D->getDeclName() 3693234353Sdim << Context.getTypeDeclType(cast<TypeDecl>(Spec->getDeclContext())); 3694234353Sdim Diag(Spec->getLocation(), diag::note_enum_specialized_here) 3695234353Sdim << Context.getTypeDeclType(Spec); 3696221345Sdim } else { 3697221345Sdim // We should have found something, but didn't. 3698221345Sdim llvm_unreachable("Unable to find instantiation of declaration!"); 3699221345Sdim } 3700221345Sdim } 3701226633Sdim 3702193326Sed D = Result; 3703193326Sed } 3704193326Sed 3705193326Sed return D; 3706193326Sed} 3707194711Sed 3708198092Srdivacky/// \brief Performs template instantiation for all implicit template 3709194711Sed/// instantiations we have seen until this point. 3710223017Sdimvoid Sema::PerformPendingInstantiations(bool LocalOnly) { 3711226633Sdim // Load pending instantiations from the external source. 3712226633Sdim if (!LocalOnly && ExternalSource) { 3713239462Sdim SmallVector<PendingImplicitInstantiation, 4> Pending; 3714226633Sdim ExternalSource->ReadPendingInstantiations(Pending); 3715226633Sdim PendingInstantiations.insert(PendingInstantiations.begin(), 3716226633Sdim Pending.begin(), Pending.end()); 3717226633Sdim } 3718226633Sdim 3719202879Srdivacky while (!PendingLocalImplicitInstantiations.empty() || 3720212904Sdim (!LocalOnly && !PendingInstantiations.empty())) { 3721202879Srdivacky PendingImplicitInstantiation Inst; 3722198092Srdivacky 3723202879Srdivacky if (PendingLocalImplicitInstantiations.empty()) { 3724212904Sdim Inst = PendingInstantiations.front(); 3725212904Sdim PendingInstantiations.pop_front(); 3726202879Srdivacky } else { 3727202879Srdivacky Inst = PendingLocalImplicitInstantiations.front(); 3728202879Srdivacky PendingLocalImplicitInstantiations.pop_front(); 3729202879Srdivacky } 3730202879Srdivacky 3731198092Srdivacky // Instantiate function definitions 3732198092Srdivacky if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) { 3733212904Sdim PrettyDeclStackTraceEntry CrashInfo(*this, Function, SourceLocation(), 3734212904Sdim "instantiating function definition"); 3735212904Sdim bool DefinitionRequired = Function->getTemplateSpecializationKind() == 3736212904Sdim TSK_ExplicitInstantiationDefinition; 3737212904Sdim InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true, 3738212904Sdim DefinitionRequired); 3739198092Srdivacky continue; 3740198092Srdivacky } 3741198092Srdivacky 3742198092Srdivacky // Instantiate static data member definitions. 3743198092Srdivacky VarDecl *Var = cast<VarDecl>(Inst.first); 3744198092Srdivacky assert(Var->isStaticDataMember() && "Not a static data member?"); 3745198092Srdivacky 3746203955Srdivacky // Don't try to instantiate declarations if the most recent redeclaration 3747203955Srdivacky // is invalid. 3748234353Sdim if (Var->getMostRecentDecl()->isInvalidDecl()) 3749203955Srdivacky continue; 3750203955Srdivacky 3751203955Srdivacky // Check if the most recent declaration has changed the specialization kind 3752203955Srdivacky // and removed the need for implicit instantiation. 3753234353Sdim switch (Var->getMostRecentDecl()->getTemplateSpecializationKind()) { 3754203955Srdivacky case TSK_Undeclared: 3755226633Sdim llvm_unreachable("Cannot instantitiate an undeclared specialization."); 3756203955Srdivacky case TSK_ExplicitInstantiationDeclaration: 3757212904Sdim case TSK_ExplicitSpecialization: 3758212904Sdim continue; // No longer need to instantiate this type. 3759203955Srdivacky case TSK_ExplicitInstantiationDefinition: 3760212904Sdim // We only need an instantiation if the pending instantiation *is* the 3761212904Sdim // explicit instantiation. 3762234353Sdim if (Var != Var->getMostRecentDecl()) continue; 3763203955Srdivacky case TSK_ImplicitInstantiation: 3764203955Srdivacky break; 3765203955Srdivacky } 3766203955Srdivacky 3767212904Sdim PrettyDeclStackTraceEntry CrashInfo(*this, Var, Var->getLocation(), 3768212904Sdim "instantiating static data member " 3769212904Sdim "definition"); 3770198092Srdivacky 3771212904Sdim bool DefinitionRequired = Var->getTemplateSpecializationKind() == 3772212904Sdim TSK_ExplicitInstantiationDefinition; 3773212904Sdim InstantiateStaticDataMemberDefinition(/*FIXME:*/Inst.second, Var, true, 3774212904Sdim DefinitionRequired); 3775194711Sed } 3776194711Sed} 3777206084Srdivacky 3778206084Srdivackyvoid Sema::PerformDependentDiagnostics(const DeclContext *Pattern, 3779206084Srdivacky const MultiLevelTemplateArgumentList &TemplateArgs) { 3780206084Srdivacky for (DeclContext::ddiag_iterator I = Pattern->ddiag_begin(), 3781206084Srdivacky E = Pattern->ddiag_end(); I != E; ++I) { 3782206084Srdivacky DependentDiagnostic *DD = *I; 3783206084Srdivacky 3784206084Srdivacky switch (DD->getKind()) { 3785206084Srdivacky case DependentDiagnostic::Access: 3786206084Srdivacky HandleDependentAccessCheck(*DD, TemplateArgs); 3787206084Srdivacky break; 3788206084Srdivacky } 3789206084Srdivacky } 3790206084Srdivacky} 3791