1193326Sed//===------- SemaTemplateInstantiate.cpp - C++ Template 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. 10193326Sed// 11193326Sed//===----------------------------------------------------------------------===/ 12193326Sed 13212904Sdim#include "clang/Sema/SemaInternal.h" 14198092Srdivacky#include "TreeTransform.h" 15249423Sdim#include "clang/AST/ASTConsumer.h" 16249423Sdim#include "clang/AST/ASTContext.h" 17263508Sdim#include "clang/AST/ASTLambda.h" 18249423Sdim#include "clang/AST/DeclTemplate.h" 19249423Sdim#include "clang/AST/Expr.h" 20249423Sdim#include "clang/Basic/LangOptions.h" 21212904Sdim#include "clang/Sema/DeclSpec.h" 22223017Sdim#include "clang/Sema/Initialization.h" 23212904Sdim#include "clang/Sema/Lookup.h" 24212904Sdim#include "clang/Sema/Template.h" 25212904Sdim#include "clang/Sema/TemplateDeduction.h" 26193326Sed 27193326Sedusing namespace clang; 28212904Sdimusing namespace sema; 29193326Sed 30193326Sed//===----------------------------------------------------------------------===/ 31193326Sed// Template Instantiation Support 32193326Sed//===----------------------------------------------------------------------===/ 33193326Sed 34198092Srdivacky/// \brief Retrieve the template argument list(s) that should be used to 35198092Srdivacky/// instantiate the definition of the given declaration. 36199482Srdivacky/// 37199482Srdivacky/// \param D the declaration for which we are computing template instantiation 38199482Srdivacky/// arguments. 39199482Srdivacky/// 40199482Srdivacky/// \param Innermost if non-NULL, the innermost template argument list. 41203955Srdivacky/// 42203955Srdivacky/// \param RelativeToPrimary true if we should get the template 43203955Srdivacky/// arguments relative to the primary template, even when we're 44203955Srdivacky/// dealing with a specialization. This is only relevant for function 45203955Srdivacky/// template specializations. 46207619Srdivacky/// 47207619Srdivacky/// \param Pattern If non-NULL, indicates the pattern from which we will be 48207619Srdivacky/// instantiating the definition of the given declaration, \p D. This is 49207619Srdivacky/// used to determine the proper set of template instantiation arguments for 50207619Srdivacky/// friend function template specializations. 51198092SrdivackyMultiLevelTemplateArgumentList 52199482SrdivackySema::getTemplateInstantiationArgs(NamedDecl *D, 53203955Srdivacky const TemplateArgumentList *Innermost, 54207619Srdivacky bool RelativeToPrimary, 55207619Srdivacky const FunctionDecl *Pattern) { 56198092Srdivacky // Accumulate the set of template argument lists in this structure. 57198092Srdivacky MultiLevelTemplateArgumentList Result; 58193326Sed 59199482Srdivacky if (Innermost) 60199482Srdivacky Result.addOuterTemplateArguments(Innermost); 61199482Srdivacky 62198092Srdivacky DeclContext *Ctx = dyn_cast<DeclContext>(D); 63223017Sdim if (!Ctx) { 64198092Srdivacky Ctx = D->getDeclContext(); 65263508Sdim 66263508Sdim // Add template arguments from a variable template instantiation. 67263508Sdim if (VarTemplateSpecializationDecl *Spec = 68263508Sdim dyn_cast<VarTemplateSpecializationDecl>(D)) { 69263508Sdim // We're done when we hit an explicit specialization. 70263508Sdim if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization && 71263508Sdim !isa<VarTemplatePartialSpecializationDecl>(Spec)) 72263508Sdim return Result; 73263508Sdim 74263508Sdim Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs()); 75263508Sdim 76263508Sdim // If this variable template specialization was instantiated from a 77263508Sdim // specialized member that is a variable template, we're done. 78263508Sdim assert(Spec->getSpecializedTemplate() && "No variable template?"); 79263508Sdim if (Spec->getSpecializedTemplate()->isMemberSpecialization()) 80263508Sdim return Result; 81263508Sdim } 82263508Sdim 83224145Sdim // If we have a template template parameter with translation unit context, 84224145Sdim // then we're performing substitution into a default template argument of 85224145Sdim // this template template parameter before we've constructed the template 86224145Sdim // that will own this template template parameter. In this case, we 87224145Sdim // use empty template parameter lists for all of the outer templates 88224145Sdim // to avoid performing any substitutions. 89224145Sdim if (Ctx->isTranslationUnit()) { 90224145Sdim if (TemplateTemplateParmDecl *TTP 91224145Sdim = dyn_cast<TemplateTemplateParmDecl>(D)) { 92224145Sdim for (unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I) 93263508Sdim Result.addOuterTemplateArguments(None); 94224145Sdim return Result; 95224145Sdim } 96224145Sdim } 97223017Sdim } 98223017Sdim 99198092Srdivacky while (!Ctx->isFileContext()) { 100198092Srdivacky // Add template arguments from a class template instantiation. 101198092Srdivacky if (ClassTemplateSpecializationDecl *Spec 102198092Srdivacky = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) { 103198092Srdivacky // We're done when we hit an explicit specialization. 104210299Sed if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization && 105210299Sed !isa<ClassTemplatePartialSpecializationDecl>(Spec)) 106198092Srdivacky break; 107198092Srdivacky 108198092Srdivacky Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs()); 109195099Sed 110198092Srdivacky // If this class template specialization was instantiated from a 111198092Srdivacky // specialized member that is a class template, we're done. 112198092Srdivacky assert(Spec->getSpecializedTemplate() && "No class template?"); 113198092Srdivacky if (Spec->getSpecializedTemplate()->isMemberSpecialization()) 114198092Srdivacky break; 115198092Srdivacky } 116198092Srdivacky // Add template arguments from a function template specialization. 117198092Srdivacky else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) { 118203955Srdivacky if (!RelativeToPrimary && 119226633Sdim (Function->getTemplateSpecializationKind() == 120226633Sdim TSK_ExplicitSpecialization && 121226633Sdim !Function->getClassScopeSpecializationPattern())) 122198092Srdivacky break; 123198092Srdivacky 124198092Srdivacky if (const TemplateArgumentList *TemplateArgs 125198092Srdivacky = Function->getTemplateSpecializationArgs()) { 126198092Srdivacky // Add the template arguments for this specialization. 127198092Srdivacky Result.addOuterTemplateArguments(TemplateArgs); 128198092Srdivacky 129198092Srdivacky // If this function was instantiated from a specialized member that is 130198092Srdivacky // a function template, we're done. 131198092Srdivacky assert(Function->getPrimaryTemplate() && "No function template?"); 132198092Srdivacky if (Function->getPrimaryTemplate()->isMemberSpecialization()) 133198092Srdivacky break; 134263508Sdim 135263508Sdim // If this function is a generic lambda specialization, we are done. 136263508Sdim if (isGenericLambdaCallOperatorSpecialization(Function)) 137263508Sdim break; 138263508Sdim 139221345Sdim } else if (FunctionTemplateDecl *FunTmpl 140221345Sdim = Function->getDescribedFunctionTemplate()) { 141221345Sdim // Add the "injected" template arguments. 142263508Sdim Result.addOuterTemplateArguments(FunTmpl->getInjectedTemplateArgs()); 143198092Srdivacky } 144198092Srdivacky 145198092Srdivacky // If this is a friend declaration and it declares an entity at 146198092Srdivacky // namespace scope, take arguments from its lexical parent 147207619Srdivacky // instead of its semantic parent, unless of course the pattern we're 148207619Srdivacky // instantiating actually comes from the file's context! 149198092Srdivacky if (Function->getFriendObjectKind() && 150207619Srdivacky Function->getDeclContext()->isFileContext() && 151207619Srdivacky (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) { 152198092Srdivacky Ctx = Function->getLexicalDeclContext(); 153203955Srdivacky RelativeToPrimary = false; 154198092Srdivacky continue; 155198092Srdivacky } 156210299Sed } else if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) { 157210299Sed if (ClassTemplateDecl *ClassTemplate = Rec->getDescribedClassTemplate()) { 158210299Sed QualType T = ClassTemplate->getInjectedClassNameSpecialization(); 159263508Sdim const TemplateSpecializationType *TST = 160263508Sdim cast<TemplateSpecializationType>(Context.getCanonicalType(T)); 161263508Sdim Result.addOuterTemplateArguments( 162263508Sdim llvm::makeArrayRef(TST->getArgs(), TST->getNumArgs())); 163210299Sed if (ClassTemplate->isMemberSpecialization()) 164210299Sed break; 165210299Sed } 166198092Srdivacky } 167198092Srdivacky 168198092Srdivacky Ctx = Ctx->getParent(); 169203955Srdivacky RelativeToPrimary = false; 170193326Sed } 171193326Sed 172198092Srdivacky return Result; 173193326Sed} 174193326Sed 175199482Srdivackybool Sema::ActiveTemplateInstantiation::isInstantiationRecord() const { 176199482Srdivacky switch (Kind) { 177199482Srdivacky case TemplateInstantiation: 178234982Sdim case ExceptionSpecInstantiation: 179199482Srdivacky case DefaultTemplateArgumentInstantiation: 180199482Srdivacky case DefaultFunctionArgumentInstantiation: 181199482Srdivacky case ExplicitTemplateArgumentSubstitution: 182199482Srdivacky case DeducedTemplateArgumentSubstitution: 183199482Srdivacky case PriorTemplateArgumentSubstitution: 184239462Sdim return true; 185239462Sdim 186199482Srdivacky case DefaultTemplateArgumentChecking: 187199482Srdivacky return false; 188199482Srdivacky } 189234353Sdim 190234353Sdim llvm_unreachable("Invalid InstantiationKind!"); 191199482Srdivacky} 192199482Srdivacky 193193326SedSema::InstantiatingTemplate:: 194193326SedInstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 195193326Sed Decl *Entity, 196193326Sed SourceRange InstantiationRange) 197218893Sdim : SemaRef(SemaRef), 198218893Sdim SavedInNonInstantiationSFINAEContext( 199218893Sdim SemaRef.InNonInstantiationSFINAEContext) 200218893Sdim{ 201193326Sed Invalid = CheckInstantiationDepth(PointOfInstantiation, 202193326Sed InstantiationRange); 203193326Sed if (!Invalid) { 204193326Sed ActiveTemplateInstantiation Inst; 205193326Sed Inst.Kind = ActiveTemplateInstantiation::TemplateInstantiation; 206193326Sed Inst.PointOfInstantiation = PointOfInstantiation; 207249423Sdim Inst.Entity = Entity; 208193326Sed Inst.TemplateArgs = 0; 209193326Sed Inst.NumTemplateArgs = 0; 210193326Sed Inst.InstantiationRange = InstantiationRange; 211218893Sdim SemaRef.InNonInstantiationSFINAEContext = false; 212193326Sed SemaRef.ActiveTemplateInstantiations.push_back(Inst); 213193326Sed } 214193326Sed} 215193326Sed 216234982SdimSema::InstantiatingTemplate:: 217234982SdimInstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 218234982Sdim FunctionDecl *Entity, ExceptionSpecification, 219234982Sdim SourceRange InstantiationRange) 220234982Sdim : SemaRef(SemaRef), 221234982Sdim SavedInNonInstantiationSFINAEContext( 222234982Sdim SemaRef.InNonInstantiationSFINAEContext) 223234982Sdim{ 224234982Sdim Invalid = CheckInstantiationDepth(PointOfInstantiation, 225234982Sdim InstantiationRange); 226234982Sdim if (!Invalid) { 227234982Sdim ActiveTemplateInstantiation Inst; 228234982Sdim Inst.Kind = ActiveTemplateInstantiation::ExceptionSpecInstantiation; 229234982Sdim Inst.PointOfInstantiation = PointOfInstantiation; 230249423Sdim Inst.Entity = Entity; 231234982Sdim Inst.TemplateArgs = 0; 232234982Sdim Inst.NumTemplateArgs = 0; 233234982Sdim Inst.InstantiationRange = InstantiationRange; 234234982Sdim SemaRef.InNonInstantiationSFINAEContext = false; 235234982Sdim SemaRef.ActiveTemplateInstantiations.push_back(Inst); 236234982Sdim } 237234982Sdim} 238234982Sdim 239239462SdimSema::InstantiatingTemplate:: 240239462SdimInstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 241239462Sdim TemplateDecl *Template, 242239462Sdim ArrayRef<TemplateArgument> TemplateArgs, 243239462Sdim SourceRange InstantiationRange) 244218893Sdim : SemaRef(SemaRef), 245218893Sdim SavedInNonInstantiationSFINAEContext( 246218893Sdim SemaRef.InNonInstantiationSFINAEContext) 247218893Sdim{ 248193326Sed Invalid = CheckInstantiationDepth(PointOfInstantiation, 249193326Sed InstantiationRange); 250193326Sed if (!Invalid) { 251193326Sed ActiveTemplateInstantiation Inst; 252198092Srdivacky Inst.Kind 253193326Sed = ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation; 254193326Sed Inst.PointOfInstantiation = PointOfInstantiation; 255249423Sdim Inst.Entity = Template; 256239462Sdim Inst.TemplateArgs = TemplateArgs.data(); 257239462Sdim Inst.NumTemplateArgs = TemplateArgs.size(); 258193326Sed Inst.InstantiationRange = InstantiationRange; 259218893Sdim SemaRef.InNonInstantiationSFINAEContext = false; 260193326Sed SemaRef.ActiveTemplateInstantiations.push_back(Inst); 261193326Sed } 262193326Sed} 263193326Sed 264239462SdimSema::InstantiatingTemplate:: 265239462SdimInstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 266239462Sdim FunctionTemplateDecl *FunctionTemplate, 267239462Sdim ArrayRef<TemplateArgument> TemplateArgs, 268239462Sdim ActiveTemplateInstantiation::InstantiationKind Kind, 269239462Sdim sema::TemplateDeductionInfo &DeductionInfo, 270239462Sdim SourceRange InstantiationRange) 271218893Sdim : SemaRef(SemaRef), 272218893Sdim SavedInNonInstantiationSFINAEContext( 273218893Sdim SemaRef.InNonInstantiationSFINAEContext) 274218893Sdim{ 275239462Sdim Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange); 276195341Sed if (!Invalid) { 277195341Sed ActiveTemplateInstantiation Inst; 278195341Sed Inst.Kind = Kind; 279195341Sed Inst.PointOfInstantiation = PointOfInstantiation; 280249423Sdim Inst.Entity = FunctionTemplate; 281239462Sdim Inst.TemplateArgs = TemplateArgs.data(); 282239462Sdim Inst.NumTemplateArgs = TemplateArgs.size(); 283218893Sdim Inst.DeductionInfo = &DeductionInfo; 284195341Sed Inst.InstantiationRange = InstantiationRange; 285218893Sdim SemaRef.InNonInstantiationSFINAEContext = false; 286195341Sed SemaRef.ActiveTemplateInstantiations.push_back(Inst); 287199482Srdivacky 288199482Srdivacky if (!Inst.isInstantiationRecord()) 289199482Srdivacky ++SemaRef.NonInstantiationEntries; 290195341Sed } 291195341Sed} 292195341Sed 293239462SdimSema::InstantiatingTemplate:: 294239462SdimInstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 295239462Sdim ClassTemplatePartialSpecializationDecl *PartialSpec, 296239462Sdim ArrayRef<TemplateArgument> TemplateArgs, 297239462Sdim sema::TemplateDeductionInfo &DeductionInfo, 298239462Sdim SourceRange InstantiationRange) 299218893Sdim : SemaRef(SemaRef), 300218893Sdim SavedInNonInstantiationSFINAEContext( 301218893Sdim SemaRef.InNonInstantiationSFINAEContext) 302218893Sdim{ 303239462Sdim Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange); 304239462Sdim if (!Invalid) { 305239462Sdim ActiveTemplateInstantiation Inst; 306239462Sdim Inst.Kind = ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution; 307239462Sdim Inst.PointOfInstantiation = PointOfInstantiation; 308249423Sdim Inst.Entity = PartialSpec; 309239462Sdim Inst.TemplateArgs = TemplateArgs.data(); 310239462Sdim Inst.NumTemplateArgs = TemplateArgs.size(); 311239462Sdim Inst.DeductionInfo = &DeductionInfo; 312239462Sdim Inst.InstantiationRange = InstantiationRange; 313239462Sdim SemaRef.InNonInstantiationSFINAEContext = false; 314239462Sdim SemaRef.ActiveTemplateInstantiations.push_back(Inst); 315239462Sdim } 316194179Sed} 317194179Sed 318263508SdimSema::InstantiatingTemplate::InstantiatingTemplate( 319263508Sdim Sema &SemaRef, SourceLocation PointOfInstantiation, 320263508Sdim VarTemplatePartialSpecializationDecl *PartialSpec, 321263508Sdim ArrayRef<TemplateArgument> TemplateArgs, 322263508Sdim sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange) 323263508Sdim : SemaRef(SemaRef), SavedInNonInstantiationSFINAEContext( 324263508Sdim SemaRef.InNonInstantiationSFINAEContext) { 325263508Sdim Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange); 326263508Sdim if (!Invalid) { 327263508Sdim ActiveTemplateInstantiation Inst; 328263508Sdim Inst.Kind = 329263508Sdim ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution; 330263508Sdim Inst.PointOfInstantiation = PointOfInstantiation; 331263508Sdim Inst.Entity = PartialSpec; 332263508Sdim Inst.TemplateArgs = TemplateArgs.data(); 333263508Sdim Inst.NumTemplateArgs = TemplateArgs.size(); 334263508Sdim Inst.DeductionInfo = &DeductionInfo; 335263508Sdim Inst.InstantiationRange = InstantiationRange; 336263508Sdim SemaRef.InNonInstantiationSFINAEContext = false; 337263508Sdim SemaRef.ActiveTemplateInstantiations.push_back(Inst); 338263508Sdim } 339263508Sdim} 340263508Sdim 341239462SdimSema::InstantiatingTemplate:: 342239462SdimInstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 343239462Sdim ParmVarDecl *Param, 344239462Sdim ArrayRef<TemplateArgument> TemplateArgs, 345239462Sdim SourceRange InstantiationRange) 346218893Sdim : SemaRef(SemaRef), 347218893Sdim SavedInNonInstantiationSFINAEContext( 348218893Sdim SemaRef.InNonInstantiationSFINAEContext) 349218893Sdim{ 350199482Srdivacky Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange); 351198092Srdivacky if (!Invalid) { 352198092Srdivacky ActiveTemplateInstantiation Inst; 353198092Srdivacky Inst.Kind 354198092Srdivacky = ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation; 355199482Srdivacky Inst.PointOfInstantiation = PointOfInstantiation; 356249423Sdim Inst.Entity = Param; 357239462Sdim Inst.TemplateArgs = TemplateArgs.data(); 358239462Sdim Inst.NumTemplateArgs = TemplateArgs.size(); 359198092Srdivacky Inst.InstantiationRange = InstantiationRange; 360218893Sdim SemaRef.InNonInstantiationSFINAEContext = false; 361198092Srdivacky SemaRef.ActiveTemplateInstantiations.push_back(Inst); 362198092Srdivacky } 363198092Srdivacky} 364198092Srdivacky 365199482SrdivackySema::InstantiatingTemplate:: 366199482SrdivackyInstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 367239462Sdim NamedDecl *Template, NonTypeTemplateParmDecl *Param, 368239462Sdim ArrayRef<TemplateArgument> TemplateArgs, 369239462Sdim SourceRange InstantiationRange) 370218893Sdim : SemaRef(SemaRef), 371218893Sdim SavedInNonInstantiationSFINAEContext( 372218893Sdim SemaRef.InNonInstantiationSFINAEContext) 373218893Sdim{ 374239462Sdim Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange); 375239462Sdim if (!Invalid) { 376239462Sdim ActiveTemplateInstantiation Inst; 377239462Sdim Inst.Kind = ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution; 378239462Sdim Inst.PointOfInstantiation = PointOfInstantiation; 379239462Sdim Inst.Template = Template; 380249423Sdim Inst.Entity = Param; 381239462Sdim Inst.TemplateArgs = TemplateArgs.data(); 382239462Sdim Inst.NumTemplateArgs = TemplateArgs.size(); 383239462Sdim Inst.InstantiationRange = InstantiationRange; 384239462Sdim SemaRef.InNonInstantiationSFINAEContext = false; 385239462Sdim SemaRef.ActiveTemplateInstantiations.push_back(Inst); 386239462Sdim } 387199482Srdivacky} 388199482Srdivacky 389199482SrdivackySema::InstantiatingTemplate:: 390199482SrdivackyInstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 391239462Sdim NamedDecl *Template, TemplateTemplateParmDecl *Param, 392239462Sdim ArrayRef<TemplateArgument> TemplateArgs, 393239462Sdim SourceRange InstantiationRange) 394218893Sdim : SemaRef(SemaRef), 395218893Sdim SavedInNonInstantiationSFINAEContext( 396218893Sdim SemaRef.InNonInstantiationSFINAEContext) 397218893Sdim{ 398239462Sdim Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange); 399239462Sdim if (!Invalid) { 400239462Sdim ActiveTemplateInstantiation Inst; 401239462Sdim Inst.Kind = ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution; 402239462Sdim Inst.PointOfInstantiation = PointOfInstantiation; 403239462Sdim Inst.Template = Template; 404249423Sdim Inst.Entity = Param; 405239462Sdim Inst.TemplateArgs = TemplateArgs.data(); 406239462Sdim Inst.NumTemplateArgs = TemplateArgs.size(); 407239462Sdim Inst.InstantiationRange = InstantiationRange; 408239462Sdim SemaRef.InNonInstantiationSFINAEContext = false; 409239462Sdim SemaRef.ActiveTemplateInstantiations.push_back(Inst); 410239462Sdim } 411199482Srdivacky} 412199482Srdivacky 413199482SrdivackySema::InstantiatingTemplate:: 414199482SrdivackyInstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 415239462Sdim TemplateDecl *Template, NamedDecl *Param, 416239462Sdim ArrayRef<TemplateArgument> TemplateArgs, 417239462Sdim SourceRange InstantiationRange) 418218893Sdim : SemaRef(SemaRef), 419218893Sdim SavedInNonInstantiationSFINAEContext( 420218893Sdim SemaRef.InNonInstantiationSFINAEContext) 421218893Sdim{ 422199482Srdivacky Invalid = false; 423199482Srdivacky 424199482Srdivacky ActiveTemplateInstantiation Inst; 425199482Srdivacky Inst.Kind = ActiveTemplateInstantiation::DefaultTemplateArgumentChecking; 426199482Srdivacky Inst.PointOfInstantiation = PointOfInstantiation; 427199482Srdivacky Inst.Template = Template; 428249423Sdim Inst.Entity = Param; 429239462Sdim Inst.TemplateArgs = TemplateArgs.data(); 430239462Sdim Inst.NumTemplateArgs = TemplateArgs.size(); 431199482Srdivacky Inst.InstantiationRange = InstantiationRange; 432218893Sdim SemaRef.InNonInstantiationSFINAEContext = false; 433199482Srdivacky SemaRef.ActiveTemplateInstantiations.push_back(Inst); 434199482Srdivacky 435199482Srdivacky assert(!Inst.isInstantiationRecord()); 436199482Srdivacky ++SemaRef.NonInstantiationEntries; 437199482Srdivacky} 438199482Srdivacky 439193326Sedvoid Sema::InstantiatingTemplate::Clear() { 440193326Sed if (!Invalid) { 441199482Srdivacky if (!SemaRef.ActiveTemplateInstantiations.back().isInstantiationRecord()) { 442199482Srdivacky assert(SemaRef.NonInstantiationEntries > 0); 443199482Srdivacky --SemaRef.NonInstantiationEntries; 444199482Srdivacky } 445218893Sdim SemaRef.InNonInstantiationSFINAEContext 446218893Sdim = SavedInNonInstantiationSFINAEContext; 447263508Sdim 448263508Sdim // Name lookup no longer looks in this template's defining module. 449263508Sdim assert(SemaRef.ActiveTemplateInstantiations.size() >= 450263508Sdim SemaRef.ActiveTemplateInstantiationLookupModules.size() && 451263508Sdim "forgot to remove a lookup module for a template instantiation"); 452263508Sdim if (SemaRef.ActiveTemplateInstantiations.size() == 453263508Sdim SemaRef.ActiveTemplateInstantiationLookupModules.size()) { 454263508Sdim if (Module *M = SemaRef.ActiveTemplateInstantiationLookupModules.back()) 455263508Sdim SemaRef.LookupModulesCache.erase(M); 456263508Sdim SemaRef.ActiveTemplateInstantiationLookupModules.pop_back(); 457263508Sdim } 458263508Sdim 459193326Sed SemaRef.ActiveTemplateInstantiations.pop_back(); 460193326Sed Invalid = true; 461193326Sed } 462193326Sed} 463193326Sed 464193326Sedbool Sema::InstantiatingTemplate::CheckInstantiationDepth( 465193326Sed SourceLocation PointOfInstantiation, 466193326Sed SourceRange InstantiationRange) { 467199482Srdivacky assert(SemaRef.NonInstantiationEntries <= 468199482Srdivacky SemaRef.ActiveTemplateInstantiations.size()); 469199482Srdivacky if ((SemaRef.ActiveTemplateInstantiations.size() - 470199482Srdivacky SemaRef.NonInstantiationEntries) 471234353Sdim <= SemaRef.getLangOpts().InstantiationDepth) 472193326Sed return false; 473193326Sed 474198092Srdivacky SemaRef.Diag(PointOfInstantiation, 475193326Sed diag::err_template_recursion_depth_exceeded) 476234353Sdim << SemaRef.getLangOpts().InstantiationDepth 477193326Sed << InstantiationRange; 478193326Sed SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth) 479234353Sdim << SemaRef.getLangOpts().InstantiationDepth; 480193326Sed return true; 481193326Sed} 482193326Sed 483193326Sed/// \brief Prints the current instantiation stack through a series of 484193326Sed/// notes. 485193326Sedvoid Sema::PrintInstantiationStack() { 486207619Srdivacky // Determine which template instantiations to skip, if any. 487207619Srdivacky unsigned SkipStart = ActiveTemplateInstantiations.size(), SkipEnd = SkipStart; 488207619Srdivacky unsigned Limit = Diags.getTemplateBacktraceLimit(); 489207619Srdivacky if (Limit && Limit < ActiveTemplateInstantiations.size()) { 490207619Srdivacky SkipStart = Limit / 2 + Limit % 2; 491207619Srdivacky SkipEnd = ActiveTemplateInstantiations.size() - Limit / 2; 492207619Srdivacky } 493207619Srdivacky 494195341Sed // FIXME: In all of these cases, we need to show the template arguments 495207619Srdivacky unsigned InstantiationIdx = 0; 496263508Sdim for (SmallVectorImpl<ActiveTemplateInstantiation>::reverse_iterator 497193326Sed Active = ActiveTemplateInstantiations.rbegin(), 498193326Sed ActiveEnd = ActiveTemplateInstantiations.rend(); 499193326Sed Active != ActiveEnd; 500207619Srdivacky ++Active, ++InstantiationIdx) { 501207619Srdivacky // Skip this instantiation? 502207619Srdivacky if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) { 503207619Srdivacky if (InstantiationIdx == SkipStart) { 504207619Srdivacky // Note that we're skipping instantiations. 505218893Sdim Diags.Report(Active->PointOfInstantiation, 506207619Srdivacky diag::note_instantiation_contexts_suppressed) 507207619Srdivacky << unsigned(ActiveTemplateInstantiations.size() - Limit); 508207619Srdivacky } 509207619Srdivacky continue; 510207619Srdivacky } 511207619Srdivacky 512193326Sed switch (Active->Kind) { 513193326Sed case ActiveTemplateInstantiation::TemplateInstantiation: { 514249423Sdim Decl *D = Active->Entity; 515193326Sed if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) { 516193326Sed unsigned DiagID = diag::note_template_member_class_here; 517193326Sed if (isa<ClassTemplateSpecializationDecl>(Record)) 518193326Sed DiagID = diag::note_template_class_instantiation_here; 519218893Sdim Diags.Report(Active->PointOfInstantiation, DiagID) 520193326Sed << Context.getTypeDeclType(Record) 521193326Sed << Active->InstantiationRange; 522198092Srdivacky } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 523195099Sed unsigned DiagID; 524195099Sed if (Function->getPrimaryTemplate()) 525195099Sed DiagID = diag::note_function_template_spec_here; 526195099Sed else 527195099Sed DiagID = diag::note_template_member_function_here; 528218893Sdim Diags.Report(Active->PointOfInstantiation, DiagID) 529193326Sed << Function 530193326Sed << Active->InstantiationRange; 531223017Sdim } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 532218893Sdim Diags.Report(Active->PointOfInstantiation, 533263508Sdim VD->isStaticDataMember()? 534263508Sdim diag::note_template_static_data_member_def_here 535263508Sdim : diag::note_template_variable_def_here) 536223017Sdim << VD 537198092Srdivacky << Active->InstantiationRange; 538234353Sdim } else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) { 539234353Sdim Diags.Report(Active->PointOfInstantiation, 540234353Sdim diag::note_template_enum_def_here) 541234353Sdim << ED 542234353Sdim << Active->InstantiationRange; 543223017Sdim } else { 544223017Sdim Diags.Report(Active->PointOfInstantiation, 545223017Sdim diag::note_template_type_alias_instantiation_here) 546223017Sdim << cast<TypeAliasTemplateDecl>(D) 547223017Sdim << Active->InstantiationRange; 548193326Sed } 549193326Sed break; 550193326Sed } 551193326Sed 552193326Sed case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation: { 553249423Sdim TemplateDecl *Template = cast<TemplateDecl>(Active->Entity); 554249423Sdim SmallVector<char, 128> TemplateArgsStr; 555249423Sdim llvm::raw_svector_ostream OS(TemplateArgsStr); 556249423Sdim Template->printName(OS); 557249423Sdim TemplateSpecializationType::PrintTemplateArgumentList(OS, 558198092Srdivacky Active->TemplateArgs, 559193326Sed Active->NumTemplateArgs, 560226633Sdim getPrintingPolicy()); 561218893Sdim Diags.Report(Active->PointOfInstantiation, 562193326Sed diag::note_default_arg_instantiation_here) 563249423Sdim << OS.str() 564193326Sed << Active->InstantiationRange; 565193326Sed break; 566193326Sed } 567194179Sed 568195341Sed case ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution: { 569249423Sdim FunctionTemplateDecl *FnTmpl = cast<FunctionTemplateDecl>(Active->Entity); 570218893Sdim Diags.Report(Active->PointOfInstantiation, 571195341Sed diag::note_explicit_template_arg_substitution_here) 572206084Srdivacky << FnTmpl 573206084Srdivacky << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(), 574206084Srdivacky Active->TemplateArgs, 575206084Srdivacky Active->NumTemplateArgs) 576206084Srdivacky << Active->InstantiationRange; 577194179Sed break; 578193326Sed } 579198092Srdivacky 580195341Sed case ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution: 581249423Sdim if (ClassTemplatePartialSpecializationDecl *PartialSpec = 582249423Sdim dyn_cast<ClassTemplatePartialSpecializationDecl>(Active->Entity)) { 583218893Sdim Diags.Report(Active->PointOfInstantiation, 584195341Sed diag::note_partial_spec_deduct_instantiation_here) 585195341Sed << Context.getTypeDeclType(PartialSpec) 586206084Srdivacky << getTemplateArgumentBindingsText( 587206084Srdivacky PartialSpec->getTemplateParameters(), 588206084Srdivacky Active->TemplateArgs, 589206084Srdivacky Active->NumTemplateArgs) 590195341Sed << Active->InstantiationRange; 591195341Sed } else { 592195341Sed FunctionTemplateDecl *FnTmpl 593249423Sdim = cast<FunctionTemplateDecl>(Active->Entity); 594218893Sdim Diags.Report(Active->PointOfInstantiation, 595195341Sed diag::note_function_template_deduction_instantiation_here) 596206084Srdivacky << FnTmpl 597206084Srdivacky << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(), 598206084Srdivacky Active->TemplateArgs, 599206084Srdivacky Active->NumTemplateArgs) 600206084Srdivacky << Active->InstantiationRange; 601195341Sed } 602195341Sed break; 603194179Sed 604198092Srdivacky case ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation: { 605249423Sdim ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity); 606198092Srdivacky FunctionDecl *FD = cast<FunctionDecl>(Param->getDeclContext()); 607198092Srdivacky 608249423Sdim SmallVector<char, 128> TemplateArgsStr; 609249423Sdim llvm::raw_svector_ostream OS(TemplateArgsStr); 610249423Sdim FD->printName(OS); 611249423Sdim TemplateSpecializationType::PrintTemplateArgumentList(OS, 612198092Srdivacky Active->TemplateArgs, 613198092Srdivacky Active->NumTemplateArgs, 614226633Sdim getPrintingPolicy()); 615218893Sdim Diags.Report(Active->PointOfInstantiation, 616198092Srdivacky diag::note_default_function_arg_instantiation_here) 617249423Sdim << OS.str() 618198092Srdivacky << Active->InstantiationRange; 619198092Srdivacky break; 620194179Sed } 621198092Srdivacky 622199482Srdivacky case ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution: { 623249423Sdim NamedDecl *Parm = cast<NamedDecl>(Active->Entity); 624199482Srdivacky std::string Name; 625199482Srdivacky if (!Parm->getName().empty()) 626199482Srdivacky Name = std::string(" '") + Parm->getName().str() + "'"; 627218893Sdim 628218893Sdim TemplateParameterList *TemplateParams = 0; 629218893Sdim if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template)) 630218893Sdim TemplateParams = Template->getTemplateParameters(); 631218893Sdim else 632218893Sdim TemplateParams = 633218893Sdim cast<ClassTemplatePartialSpecializationDecl>(Active->Template) 634218893Sdim ->getTemplateParameters(); 635218893Sdim Diags.Report(Active->PointOfInstantiation, 636199482Srdivacky diag::note_prior_template_arg_substitution) 637199482Srdivacky << isa<TemplateTemplateParmDecl>(Parm) 638199482Srdivacky << Name 639218893Sdim << getTemplateArgumentBindingsText(TemplateParams, 640199482Srdivacky Active->TemplateArgs, 641199482Srdivacky Active->NumTemplateArgs) 642199482Srdivacky << Active->InstantiationRange; 643199482Srdivacky break; 644198092Srdivacky } 645199482Srdivacky 646199482Srdivacky case ActiveTemplateInstantiation::DefaultTemplateArgumentChecking: { 647218893Sdim TemplateParameterList *TemplateParams = 0; 648218893Sdim if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template)) 649218893Sdim TemplateParams = Template->getTemplateParameters(); 650218893Sdim else 651218893Sdim TemplateParams = 652218893Sdim cast<ClassTemplatePartialSpecializationDecl>(Active->Template) 653218893Sdim ->getTemplateParameters(); 654218893Sdim 655218893Sdim Diags.Report(Active->PointOfInstantiation, 656199482Srdivacky diag::note_template_default_arg_checking) 657218893Sdim << getTemplateArgumentBindingsText(TemplateParams, 658199482Srdivacky Active->TemplateArgs, 659199482Srdivacky Active->NumTemplateArgs) 660199482Srdivacky << Active->InstantiationRange; 661199482Srdivacky break; 662199482Srdivacky } 663234982Sdim 664234982Sdim case ActiveTemplateInstantiation::ExceptionSpecInstantiation: 665234982Sdim Diags.Report(Active->PointOfInstantiation, 666234982Sdim diag::note_template_exception_spec_instantiation_here) 667249423Sdim << cast<FunctionDecl>(Active->Entity) 668234982Sdim << Active->InstantiationRange; 669234982Sdim break; 670199482Srdivacky } 671193326Sed } 672193326Sed} 673193326Sed 674249423SdimOptional<TemplateDeductionInfo *> Sema::isSFINAEContext() const { 675218893Sdim if (InNonInstantiationSFINAEContext) 676249423Sdim return Optional<TemplateDeductionInfo *>(0); 677218893Sdim 678263508Sdim for (SmallVectorImpl<ActiveTemplateInstantiation>::const_reverse_iterator 679194179Sed Active = ActiveTemplateInstantiations.rbegin(), 680194179Sed ActiveEnd = ActiveTemplateInstantiations.rend(); 681194179Sed Active != ActiveEnd; 682199482Srdivacky ++Active) 683199482Srdivacky { 684194179Sed switch(Active->Kind) { 685239462Sdim case ActiveTemplateInstantiation::TemplateInstantiation: 686239462Sdim // An instantiation of an alias template may or may not be a SFINAE 687239462Sdim // context, depending on what else is on the stack. 688249423Sdim if (isa<TypeAliasTemplateDecl>(Active->Entity)) 689239462Sdim break; 690239462Sdim // Fall through. 691218893Sdim case ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation: 692234982Sdim case ActiveTemplateInstantiation::ExceptionSpecInstantiation: 693195341Sed // This is a template instantiation, so there is no SFINAE. 694249423Sdim return None; 695198092Srdivacky 696194179Sed case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation: 697199482Srdivacky case ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution: 698199482Srdivacky case ActiveTemplateInstantiation::DefaultTemplateArgumentChecking: 699199482Srdivacky // A default template argument instantiation and substitution into 700199482Srdivacky // template parameters with arguments for prior parameters may or may 701199482Srdivacky // not be a SFINAE context; look further up the stack. 702194179Sed break; 703198092Srdivacky 704195341Sed case ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution: 705195341Sed case ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution: 706195341Sed // We're either substitution explicitly-specified template arguments 707195341Sed // or deduced template arguments, so SFINAE applies. 708218893Sdim assert(Active->DeductionInfo && "Missing deduction info pointer"); 709218893Sdim return Active->DeductionInfo; 710194179Sed } 711194179Sed } 712194179Sed 713249423Sdim return None; 714194179Sed} 715194179Sed 716218893Sdim/// \brief Retrieve the depth and index of a parameter pack. 717218893Sdimstatic std::pair<unsigned, unsigned> 718218893SdimgetDepthAndIndex(NamedDecl *ND) { 719218893Sdim if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND)) 720218893Sdim return std::make_pair(TTP->getDepth(), TTP->getIndex()); 721218893Sdim 722218893Sdim if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND)) 723218893Sdim return std::make_pair(NTTP->getDepth(), NTTP->getIndex()); 724218893Sdim 725218893Sdim TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND); 726218893Sdim return std::make_pair(TTP->getDepth(), TTP->getIndex()); 727218893Sdim} 728218893Sdim 729193326Sed//===----------------------------------------------------------------------===/ 730193326Sed// Template Instantiation for Types 731193326Sed//===----------------------------------------------------------------------===/ 732193326Sednamespace { 733207619Srdivacky class TemplateInstantiator : public TreeTransform<TemplateInstantiator> { 734198092Srdivacky const MultiLevelTemplateArgumentList &TemplateArgs; 735193326Sed SourceLocation Loc; 736193326Sed DeclarationName Entity; 737193326Sed 738193326Sed public: 739198092Srdivacky typedef TreeTransform<TemplateInstantiator> inherited; 740193326Sed 741198092Srdivacky TemplateInstantiator(Sema &SemaRef, 742198092Srdivacky const MultiLevelTemplateArgumentList &TemplateArgs, 743198092Srdivacky SourceLocation Loc, 744198092Srdivacky DeclarationName Entity) 745198092Srdivacky : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc), 746198092Srdivacky Entity(Entity) { } 747193326Sed 748198092Srdivacky /// \brief Determine whether the given type \p T has already been 749198092Srdivacky /// transformed. 750198092Srdivacky /// 751198092Srdivacky /// For the purposes of template instantiation, a type has already been 752198092Srdivacky /// transformed if it is NULL or if it is not dependent. 753208600Srdivacky bool AlreadyTransformed(QualType T); 754193326Sed 755198092Srdivacky /// \brief Returns the location of the entity being instantiated, if known. 756198092Srdivacky SourceLocation getBaseLocation() { return Loc; } 757193326Sed 758198092Srdivacky /// \brief Returns the name of the entity being instantiated, if any. 759198092Srdivacky DeclarationName getBaseEntity() { return Entity; } 760193326Sed 761198893Srdivacky /// \brief Sets the "base" location and entity when that 762198893Srdivacky /// information is known based on another transformation. 763198893Srdivacky void setBase(SourceLocation Loc, DeclarationName Entity) { 764198893Srdivacky this->Loc = Loc; 765198893Srdivacky this->Entity = Entity; 766198893Srdivacky } 767218893Sdim 768218893Sdim bool TryExpandParameterPacks(SourceLocation EllipsisLoc, 769218893Sdim SourceRange PatternRange, 770263508Sdim ArrayRef<UnexpandedParameterPack> Unexpanded, 771263508Sdim bool &ShouldExpand, bool &RetainExpansion, 772249423Sdim Optional<unsigned> &NumExpansions) { 773218893Sdim return getSema().CheckParameterPacksForExpansion(EllipsisLoc, 774218893Sdim PatternRange, Unexpanded, 775218893Sdim TemplateArgs, 776218893Sdim ShouldExpand, 777218893Sdim RetainExpansion, 778218893Sdim NumExpansions); 779218893Sdim } 780218893Sdim 781218893Sdim void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { 782218893Sdim SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(Pack); 783218893Sdim } 784218893Sdim 785218893Sdim TemplateArgument ForgetPartiallySubstitutedPack() { 786218893Sdim TemplateArgument Result; 787218893Sdim if (NamedDecl *PartialPack 788218893Sdim = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){ 789218893Sdim MultiLevelTemplateArgumentList &TemplateArgs 790218893Sdim = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs); 791218893Sdim unsigned Depth, Index; 792218893Sdim llvm::tie(Depth, Index) = getDepthAndIndex(PartialPack); 793218893Sdim if (TemplateArgs.hasTemplateArgument(Depth, Index)) { 794218893Sdim Result = TemplateArgs(Depth, Index); 795218893Sdim TemplateArgs.setArgument(Depth, Index, TemplateArgument()); 796218893Sdim } 797218893Sdim } 798198893Srdivacky 799218893Sdim return Result; 800218893Sdim } 801218893Sdim 802218893Sdim void RememberPartiallySubstitutedPack(TemplateArgument Arg) { 803218893Sdim if (Arg.isNull()) 804218893Sdim return; 805218893Sdim 806218893Sdim if (NamedDecl *PartialPack 807218893Sdim = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){ 808218893Sdim MultiLevelTemplateArgumentList &TemplateArgs 809218893Sdim = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs); 810218893Sdim unsigned Depth, Index; 811218893Sdim llvm::tie(Depth, Index) = getDepthAndIndex(PartialPack); 812218893Sdim TemplateArgs.setArgument(Depth, Index, Arg); 813218893Sdim } 814218893Sdim } 815218893Sdim 816198092Srdivacky /// \brief Transform the given declaration by instantiating a reference to 817198092Srdivacky /// this declaration. 818204643Srdivacky Decl *TransformDecl(SourceLocation Loc, Decl *D); 819193326Sed 820234353Sdim void transformAttrs(Decl *Old, Decl *New) { 821234353Sdim SemaRef.InstantiateAttrs(TemplateArgs, Old, New); 822234353Sdim } 823234353Sdim 824234353Sdim void transformedLocalDecl(Decl *Old, Decl *New) { 825234353Sdim SemaRef.CurrentInstantiationScope->InstantiatedLocal(Old, New); 826234353Sdim } 827234353Sdim 828198092Srdivacky /// \brief Transform the definition of the given declaration by 829198092Srdivacky /// instantiating it. 830204643Srdivacky Decl *TransformDefinition(SourceLocation Loc, Decl *D); 831193326Sed 832243830Sdim /// \brief Transform the first qualifier within a scope by instantiating the 833198398Srdivacky /// declaration. 834198398Srdivacky NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc); 835198398Srdivacky 836198092Srdivacky /// \brief Rebuild the exception declaration and register the declaration 837198092Srdivacky /// as an instantiated local. 838218893Sdim VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, 839200583Srdivacky TypeSourceInfo *Declarator, 840221345Sdim SourceLocation StartLoc, 841221345Sdim SourceLocation NameLoc, 842221345Sdim IdentifierInfo *Name); 843193326Sed 844207619Srdivacky /// \brief Rebuild the Objective-C exception declaration and register the 845207619Srdivacky /// declaration as an instantiated local. 846207619Srdivacky VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl, 847207619Srdivacky TypeSourceInfo *TSInfo, QualType T); 848207619Srdivacky 849198092Srdivacky /// \brief Check for tag mismatches when instantiating an 850198092Srdivacky /// elaborated type. 851218893Sdim QualType RebuildElaboratedType(SourceLocation KeywordLoc, 852218893Sdim ElaboratedTypeKeyword Keyword, 853221345Sdim NestedNameSpecifierLoc QualifierLoc, 854221345Sdim QualType T); 855193326Sed 856221345Sdim TemplateName TransformTemplateName(CXXScopeSpec &SS, 857221345Sdim TemplateName Name, 858221345Sdim SourceLocation NameLoc, 859218893Sdim QualType ObjectType = QualType(), 860218893Sdim NamedDecl *FirstQualifierInScope = 0); 861218893Sdim 862212904Sdim ExprResult TransformPredefinedExpr(PredefinedExpr *E); 863212904Sdim ExprResult TransformDeclRefExpr(DeclRefExpr *E); 864212904Sdim ExprResult TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E); 865243830Sdim 866212904Sdim ExprResult TransformTemplateParmRefExpr(DeclRefExpr *E, 867218893Sdim NonTypeTemplateParmDecl *D); 868218893Sdim ExprResult TransformSubstNonTypeTemplateParmPackExpr( 869218893Sdim SubstNonTypeTemplateParmPackExpr *E); 870243830Sdim 871243830Sdim /// \brief Rebuild a DeclRefExpr for a ParmVarDecl reference. 872243830Sdim ExprResult RebuildParmVarDeclRefExpr(ParmVarDecl *PD, SourceLocation Loc); 873243830Sdim 874243830Sdim /// \brief Transform a reference to a function parameter pack. 875243830Sdim ExprResult TransformFunctionParmPackRefExpr(DeclRefExpr *E, 876243830Sdim ParmVarDecl *PD); 877243830Sdim 878243830Sdim /// \brief Transform a FunctionParmPackExpr which was built when we couldn't 879243830Sdim /// expand a function parameter pack reference which refers to an expanded 880243830Sdim /// pack. 881243830Sdim ExprResult TransformFunctionParmPackExpr(FunctionParmPackExpr *E); 882243830Sdim 883207619Srdivacky QualType TransformFunctionProtoType(TypeLocBuilder &TLB, 884218893Sdim FunctionProtoTypeLoc TL); 885234982Sdim QualType TransformFunctionProtoType(TypeLocBuilder &TLB, 886234982Sdim FunctionProtoTypeLoc TL, 887234982Sdim CXXRecordDecl *ThisContext, 888234982Sdim unsigned ThisTypeQuals); 889234982Sdim 890218893Sdim ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm, 891221345Sdim int indexAdjustment, 892249423Sdim Optional<unsigned> NumExpansions, 893234353Sdim bool ExpectParameterPack); 894205219Srdivacky 895198092Srdivacky /// \brief Transforms a template type parameter type by performing 896198092Srdivacky /// substitution of the corresponding template type argument. 897198398Srdivacky QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB, 898218893Sdim TemplateTypeParmTypeLoc TL); 899210299Sed 900218893Sdim /// \brief Transforms an already-substituted template type parameter pack 901218893Sdim /// into either itself (if we aren't substituting into its pack expansion) 902218893Sdim /// or the appropriate substituted argument. 903218893Sdim QualType TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB, 904218893Sdim SubstTemplateTypeParmPackTypeLoc TL); 905218893Sdim 906212904Sdim ExprResult TransformCallExpr(CallExpr *CE) { 907210299Sed getSema().CallsUndergoingInstantiation.push_back(CE); 908212904Sdim ExprResult Result = 909210299Sed TreeTransform<TemplateInstantiator>::TransformCallExpr(CE); 910210299Sed getSema().CallsUndergoingInstantiation.pop_back(); 911243830Sdim return Result; 912210299Sed } 913224145Sdim 914239462Sdim ExprResult TransformLambdaExpr(LambdaExpr *E) { 915239462Sdim LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true); 916239462Sdim return TreeTransform<TemplateInstantiator>::TransformLambdaExpr(E); 917239462Sdim } 918239462Sdim 919239462Sdim ExprResult TransformLambdaScope(LambdaExpr *E, 920263508Sdim CXXMethodDecl *NewCallOperator, 921263508Sdim ArrayRef<InitCaptureInfoTy> InitCaptureExprsAndTypes) { 922263508Sdim CXXMethodDecl *const OldCallOperator = E->getCallOperator(); 923263508Sdim // In the generic lambda case, we set the NewTemplate to be considered 924263508Sdim // an "instantiation" of the OldTemplate. 925263508Sdim if (FunctionTemplateDecl *const NewCallOperatorTemplate = 926263508Sdim NewCallOperator->getDescribedFunctionTemplate()) { 927263508Sdim 928263508Sdim FunctionTemplateDecl *const OldCallOperatorTemplate = 929263508Sdim OldCallOperator->getDescribedFunctionTemplate(); 930263508Sdim NewCallOperatorTemplate->setInstantiatedFromMemberTemplate( 931263508Sdim OldCallOperatorTemplate); 932263508Sdim // Mark the NewCallOperatorTemplate a specialization. 933263508Sdim NewCallOperatorTemplate->setMemberSpecialization(); 934263508Sdim } else 935263508Sdim // For a non-generic lambda we set the NewCallOperator to 936263508Sdim // be an instantiation of the OldCallOperator. 937263508Sdim NewCallOperator->setInstantiationOfMemberFunction(OldCallOperator, 938263508Sdim TSK_ImplicitInstantiation); 939263508Sdim 940263508Sdim return inherited::TransformLambdaScope(E, NewCallOperator, 941263508Sdim InitCaptureExprsAndTypes); 942239462Sdim } 943263508Sdim TemplateParameterList *TransformTemplateParameterList( 944263508Sdim TemplateParameterList *OrigTPL) { 945263508Sdim if (!OrigTPL || !OrigTPL->size()) return OrigTPL; 946263508Sdim 947263508Sdim DeclContext *Owner = OrigTPL->getParam(0)->getDeclContext(); 948263508Sdim TemplateDeclInstantiator DeclInstantiator(getSema(), 949263508Sdim /* DeclContext *Owner */ Owner, TemplateArgs); 950263508Sdim return DeclInstantiator.SubstTemplateParams(OrigTPL); 951263508Sdim } 952224145Sdim private: 953224145Sdim ExprResult transformNonTypeTemplateParmRef(NonTypeTemplateParmDecl *parm, 954224145Sdim SourceLocation loc, 955239462Sdim TemplateArgument arg); 956198092Srdivacky }; 957193326Sed} 958193326Sed 959208600Srdivackybool TemplateInstantiator::AlreadyTransformed(QualType T) { 960208600Srdivacky if (T.isNull()) 961208600Srdivacky return true; 962208600Srdivacky 963224145Sdim if (T->isInstantiationDependentType() || T->isVariablyModifiedType()) 964208600Srdivacky return false; 965208600Srdivacky 966208600Srdivacky getSema().MarkDeclarationsReferencedInType(Loc, T); 967208600Srdivacky return true; 968208600Srdivacky} 969208600Srdivacky 970263508Sdimstatic TemplateArgument 971263508SdimgetPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg) { 972263508Sdim assert(S.ArgumentPackSubstitutionIndex >= 0); 973263508Sdim assert(S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size()); 974263508Sdim Arg = Arg.pack_begin()[S.ArgumentPackSubstitutionIndex]; 975263508Sdim if (Arg.isPackExpansion()) 976263508Sdim Arg = Arg.getPackExpansionPattern(); 977263508Sdim return Arg; 978263508Sdim} 979263508Sdim 980204643SrdivackyDecl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) { 981198092Srdivacky if (!D) 982198092Srdivacky return 0; 983193326Sed 984198092Srdivacky if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) { 985198092Srdivacky if (TTP->getDepth() < TemplateArgs.getNumLevels()) { 986203955Srdivacky // If the corresponding template argument is NULL or non-existent, it's 987203955Srdivacky // because we are performing instantiation from explicitly-specified 988203955Srdivacky // template arguments in a function template, but there were some 989203955Srdivacky // arguments left unspecified. 990203955Srdivacky if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(), 991203955Srdivacky TTP->getPosition())) 992203955Srdivacky return D; 993203955Srdivacky 994218893Sdim TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition()); 995218893Sdim 996218893Sdim if (TTP->isParameterPack()) { 997218893Sdim assert(Arg.getKind() == TemplateArgument::Pack && 998218893Sdim "Missing argument pack"); 999263508Sdim Arg = getPackSubstitutedTemplateArgument(getSema(), Arg); 1000218893Sdim } 1001218893Sdim 1002218893Sdim TemplateName Template = Arg.getAsTemplate(); 1003199482Srdivacky assert(!Template.isNull() && Template.getAsTemplateDecl() && 1004198092Srdivacky "Wrong kind of template template argument"); 1005199482Srdivacky return Template.getAsTemplateDecl(); 1006198092Srdivacky } 1007193326Sed 1008199482Srdivacky // Fall through to find the instantiated declaration for this template 1009199482Srdivacky // template parameter. 1010198092Srdivacky } 1011194179Sed 1012204643Srdivacky return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs); 1013193326Sed} 1014193326Sed 1015204643SrdivackyDecl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) { 1016198092Srdivacky Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs); 1017198092Srdivacky if (!Inst) 1018198092Srdivacky return 0; 1019193326Sed 1020198092Srdivacky getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst); 1021198092Srdivacky return Inst; 1022193326Sed} 1023193326Sed 1024198398SrdivackyNamedDecl * 1025198398SrdivackyTemplateInstantiator::TransformFirstQualifierInScope(NamedDecl *D, 1026198398Srdivacky SourceLocation Loc) { 1027198398Srdivacky // If the first part of the nested-name-specifier was a template type 1028198398Srdivacky // parameter, instantiate that type parameter down to a tag type. 1029198398Srdivacky if (TemplateTypeParmDecl *TTPD = dyn_cast_or_null<TemplateTypeParmDecl>(D)) { 1030198398Srdivacky const TemplateTypeParmType *TTP 1031198398Srdivacky = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD)); 1032218893Sdim 1033198398Srdivacky if (TTP->getDepth() < TemplateArgs.getNumLevels()) { 1034218893Sdim // FIXME: This needs testing w/ member access expressions. 1035218893Sdim TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getIndex()); 1036218893Sdim 1037218893Sdim if (TTP->isParameterPack()) { 1038218893Sdim assert(Arg.getKind() == TemplateArgument::Pack && 1039218893Sdim "Missing argument pack"); 1040218893Sdim 1041218893Sdim if (getSema().ArgumentPackSubstitutionIndex == -1) 1042218893Sdim return 0; 1043218893Sdim 1044263508Sdim Arg = getPackSubstitutedTemplateArgument(getSema(), Arg); 1045218893Sdim } 1046218893Sdim 1047218893Sdim QualType T = Arg.getAsType(); 1048198398Srdivacky if (T.isNull()) 1049204643Srdivacky return cast_or_null<NamedDecl>(TransformDecl(Loc, D)); 1050198398Srdivacky 1051198398Srdivacky if (const TagType *Tag = T->getAs<TagType>()) 1052198398Srdivacky return Tag->getDecl(); 1053198398Srdivacky 1054198398Srdivacky // The resulting type is not a tag; complain. 1055198398Srdivacky getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T; 1056198398Srdivacky return 0; 1057198398Srdivacky } 1058198398Srdivacky } 1059198398Srdivacky 1060204643Srdivacky return cast_or_null<NamedDecl>(TransformDecl(Loc, D)); 1061198398Srdivacky} 1062198398Srdivacky 1063198092SrdivackyVarDecl * 1064198092SrdivackyTemplateInstantiator::RebuildExceptionDecl(VarDecl *ExceptionDecl, 1065200583Srdivacky TypeSourceInfo *Declarator, 1066221345Sdim SourceLocation StartLoc, 1067221345Sdim SourceLocation NameLoc, 1068221345Sdim IdentifierInfo *Name) { 1069218893Sdim VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator, 1070221345Sdim StartLoc, NameLoc, Name); 1071207619Srdivacky if (Var) 1072198092Srdivacky getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var); 1073198092Srdivacky return Var; 1074193326Sed} 1075193326Sed 1076207619SrdivackyVarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(VarDecl *ExceptionDecl, 1077207619Srdivacky TypeSourceInfo *TSInfo, 1078207619Srdivacky QualType T) { 1079207619Srdivacky VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T); 1080207619Srdivacky if (Var) 1081207619Srdivacky getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var); 1082207619Srdivacky return Var; 1083207619Srdivacky} 1084207619Srdivacky 1085193326SedQualType 1086218893SdimTemplateInstantiator::RebuildElaboratedType(SourceLocation KeywordLoc, 1087218893Sdim ElaboratedTypeKeyword Keyword, 1088221345Sdim NestedNameSpecifierLoc QualifierLoc, 1089208600Srdivacky QualType T) { 1090198092Srdivacky if (const TagType *TT = T->getAs<TagType>()) { 1091198092Srdivacky TagDecl* TD = TT->getDecl(); 1092193326Sed 1093218893Sdim SourceLocation TagLocation = KeywordLoc; 1094193326Sed 1095198092Srdivacky IdentifierInfo *Id = TD->getIdentifier(); 1096194613Sed 1097198092Srdivacky // TODO: should we even warn on struct/class mismatches for this? Seems 1098198092Srdivacky // like it's likely to produce a lot of spurious errors. 1099239462Sdim if (Id && Keyword != ETK_None && Keyword != ETK_Typename) { 1100208600Srdivacky TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword); 1101223017Sdim if (!SemaRef.isAcceptableTagRedeclaration(TD, Kind, /*isDefinition*/false, 1102223017Sdim TagLocation, *Id)) { 1103208600Srdivacky SemaRef.Diag(TagLocation, diag::err_use_with_wrong_tag) 1104208600Srdivacky << Id 1105208600Srdivacky << FixItHint::CreateReplacement(SourceRange(TagLocation), 1106208600Srdivacky TD->getKindName()); 1107208600Srdivacky SemaRef.Diag(TD->getLocation(), diag::note_previous_use); 1108208600Srdivacky } 1109198092Srdivacky } 1110194613Sed } 1111194613Sed 1112218893Sdim return TreeTransform<TemplateInstantiator>::RebuildElaboratedType(KeywordLoc, 1113218893Sdim Keyword, 1114221345Sdim QualifierLoc, 1115221345Sdim T); 1116194613Sed} 1117194613Sed 1118221345SdimTemplateName TemplateInstantiator::TransformTemplateName(CXXScopeSpec &SS, 1119221345Sdim TemplateName Name, 1120221345Sdim SourceLocation NameLoc, 1121218893Sdim QualType ObjectType, 1122218893Sdim NamedDecl *FirstQualifierInScope) { 1123218893Sdim if (TemplateTemplateParmDecl *TTP 1124218893Sdim = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) { 1125218893Sdim if (TTP->getDepth() < TemplateArgs.getNumLevels()) { 1126218893Sdim // If the corresponding template argument is NULL or non-existent, it's 1127218893Sdim // because we are performing instantiation from explicitly-specified 1128218893Sdim // template arguments in a function template, but there were some 1129218893Sdim // arguments left unspecified. 1130218893Sdim if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(), 1131218893Sdim TTP->getPosition())) 1132218893Sdim return Name; 1133218893Sdim 1134218893Sdim TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition()); 1135218893Sdim 1136218893Sdim if (TTP->isParameterPack()) { 1137218893Sdim assert(Arg.getKind() == TemplateArgument::Pack && 1138218893Sdim "Missing argument pack"); 1139218893Sdim 1140218893Sdim if (getSema().ArgumentPackSubstitutionIndex == -1) { 1141218893Sdim // We have the template argument pack to substitute, but we're not 1142218893Sdim // actually expanding the enclosing pack expansion yet. So, just 1143218893Sdim // keep the entire argument pack. 1144218893Sdim return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg); 1145218893Sdim } 1146263508Sdim 1147263508Sdim Arg = getPackSubstitutedTemplateArgument(getSema(), Arg); 1148218893Sdim } 1149218893Sdim 1150218893Sdim TemplateName Template = Arg.getAsTemplate(); 1151223017Sdim assert(!Template.isNull() && "Null template template argument"); 1152224145Sdim 1153221345Sdim // We don't ever want to substitute for a qualified template name, since 1154221345Sdim // the qualifier is handled separately. So, look through the qualified 1155221345Sdim // template name to its underlying declaration. 1156221345Sdim if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 1157221345Sdim Template = TemplateName(QTN->getTemplateDecl()); 1158224145Sdim 1159224145Sdim Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template); 1160218893Sdim return Template; 1161218893Sdim } 1162218893Sdim } 1163218893Sdim 1164218893Sdim if (SubstTemplateTemplateParmPackStorage *SubstPack 1165221345Sdim = Name.getAsSubstTemplateTemplateParmPack()) { 1166218893Sdim if (getSema().ArgumentPackSubstitutionIndex == -1) 1167218893Sdim return Name; 1168221345Sdim 1169263508Sdim TemplateArgument Arg = SubstPack->getArgumentPack(); 1170263508Sdim Arg = getPackSubstitutedTemplateArgument(getSema(), Arg); 1171263508Sdim return Arg.getAsTemplate(); 1172218893Sdim } 1173218893Sdim 1174221345Sdim return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType, 1175221345Sdim FirstQualifierInScope); 1176218893Sdim} 1177218893Sdim 1178212904SdimExprResult 1179200583SrdivackyTemplateInstantiator::TransformPredefinedExpr(PredefinedExpr *E) { 1180198092Srdivacky if (!E->isTypeDependent()) 1181218893Sdim return SemaRef.Owned(E); 1182193326Sed 1183263508Sdim return getSema().BuildPredefinedExpr(E->getLocation(), E->getIdentType()); 1184193326Sed} 1185193326Sed 1186212904SdimExprResult 1187203955SrdivackyTemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E, 1188203955Srdivacky NonTypeTemplateParmDecl *NTTP) { 1189203955Srdivacky // If the corresponding template argument is NULL or non-existent, it's 1190203955Srdivacky // because we are performing instantiation from explicitly-specified 1191203955Srdivacky // template arguments in a function template, but there were some 1192203955Srdivacky // arguments left unspecified. 1193203955Srdivacky if (!TemplateArgs.hasTemplateArgument(NTTP->getDepth(), 1194203955Srdivacky NTTP->getPosition())) 1195218893Sdim return SemaRef.Owned(E); 1196193326Sed 1197218893Sdim TemplateArgument Arg = TemplateArgs(NTTP->getDepth(), NTTP->getPosition()); 1198218893Sdim if (NTTP->isParameterPack()) { 1199218893Sdim assert(Arg.getKind() == TemplateArgument::Pack && 1200218893Sdim "Missing argument pack"); 1201218893Sdim 1202218893Sdim if (getSema().ArgumentPackSubstitutionIndex == -1) { 1203218893Sdim // We have an argument pack, but we can't select a particular argument 1204218893Sdim // out of it yet. Therefore, we'll build an expression to hold on to that 1205218893Sdim // argument pack. 1206218893Sdim QualType TargetType = SemaRef.SubstType(NTTP->getType(), TemplateArgs, 1207218893Sdim E->getLocation(), 1208218893Sdim NTTP->getDeclName()); 1209218893Sdim if (TargetType.isNull()) 1210218893Sdim return ExprError(); 1211218893Sdim 1212218893Sdim return new (SemaRef.Context) SubstNonTypeTemplateParmPackExpr(TargetType, 1213218893Sdim NTTP, 1214218893Sdim E->getLocation(), 1215218893Sdim Arg); 1216218893Sdim } 1217218893Sdim 1218263508Sdim Arg = getPackSubstitutedTemplateArgument(getSema(), Arg); 1219218893Sdim } 1220193326Sed 1221224145Sdim return transformNonTypeTemplateParmRef(NTTP, E->getLocation(), Arg); 1222224145Sdim} 1223224145Sdim 1224224145SdimExprResult TemplateInstantiator::transformNonTypeTemplateParmRef( 1225224145Sdim NonTypeTemplateParmDecl *parm, 1226224145Sdim SourceLocation loc, 1227239462Sdim TemplateArgument arg) { 1228224145Sdim ExprResult result; 1229224145Sdim QualType type; 1230224145Sdim 1231203955Srdivacky // The template argument itself might be an expression, in which 1232203955Srdivacky // case we just return that expression. 1233224145Sdim if (arg.getKind() == TemplateArgument::Expression) { 1234224145Sdim Expr *argExpr = arg.getAsExpr(); 1235224145Sdim result = SemaRef.Owned(argExpr); 1236224145Sdim type = argExpr->getType(); 1237193326Sed 1238243830Sdim } else if (arg.getKind() == TemplateArgument::Declaration || 1239243830Sdim arg.getKind() == TemplateArgument::NullPtr) { 1240234353Sdim ValueDecl *VD; 1241243830Sdim if (arg.getKind() == TemplateArgument::Declaration) { 1242243830Sdim VD = cast<ValueDecl>(arg.getAsDecl()); 1243193326Sed 1244234353Sdim // Find the instantiation of the template argument. This is 1245234353Sdim // required for nested templates. 1246234353Sdim VD = cast_or_null<ValueDecl>( 1247234353Sdim getSema().FindInstantiatedDecl(loc, VD, TemplateArgs)); 1248234353Sdim if (!VD) 1249234353Sdim return ExprError(); 1250234353Sdim } else { 1251234353Sdim // Propagate NULL template argument. 1252234353Sdim VD = 0; 1253234353Sdim } 1254234353Sdim 1255203955Srdivacky // Derive the type we want the substituted decl to have. This had 1256203955Srdivacky // better be non-dependent, or these checks will have serious problems. 1257224145Sdim if (parm->isExpandedParameterPack()) { 1258224145Sdim type = parm->getExpansionType(SemaRef.ArgumentPackSubstitutionIndex); 1259224145Sdim } else if (parm->isParameterPack() && 1260224145Sdim isa<PackExpansionType>(parm->getType())) { 1261224145Sdim type = SemaRef.SubstType( 1262224145Sdim cast<PackExpansionType>(parm->getType())->getPattern(), 1263224145Sdim TemplateArgs, loc, parm->getDeclName()); 1264224145Sdim } else { 1265224145Sdim type = SemaRef.SubstType(parm->getType(), TemplateArgs, 1266224145Sdim loc, parm->getDeclName()); 1267224145Sdim } 1268224145Sdim assert(!type.isNull() && "type substitution failed for param type"); 1269224145Sdim assert(!type->isDependentType() && "param type still dependent"); 1270224145Sdim result = SemaRef.BuildExpressionFromDeclTemplateArgument(arg, type, loc); 1271224145Sdim 1272224145Sdim if (!result.isInvalid()) type = result.get()->getType(); 1273224145Sdim } else { 1274224145Sdim result = SemaRef.BuildExpressionFromIntegralTemplateArgument(arg, loc); 1275224145Sdim 1276224145Sdim // Note that this type can be different from the type of 'result', 1277224145Sdim // e.g. if it's an enum type. 1278224145Sdim type = arg.getIntegralType(); 1279203955Srdivacky } 1280224145Sdim if (result.isInvalid()) return ExprError(); 1281203955Srdivacky 1282224145Sdim Expr *resultExpr = result.take(); 1283224145Sdim return SemaRef.Owned(new (SemaRef.Context) 1284224145Sdim SubstNonTypeTemplateParmExpr(type, 1285224145Sdim resultExpr->getValueKind(), 1286224145Sdim loc, parm, resultExpr)); 1287203955Srdivacky} 1288203955Srdivacky 1289218893SdimExprResult 1290218893SdimTemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr( 1291218893Sdim SubstNonTypeTemplateParmPackExpr *E) { 1292218893Sdim if (getSema().ArgumentPackSubstitutionIndex == -1) { 1293218893Sdim // We aren't expanding the parameter pack, so just return ourselves. 1294218893Sdim return getSema().Owned(E); 1295218893Sdim } 1296263508Sdim 1297263508Sdim TemplateArgument Arg = E->getArgumentPack(); 1298263508Sdim Arg = getPackSubstitutedTemplateArgument(getSema(), Arg); 1299224145Sdim return transformNonTypeTemplateParmRef(E->getParameterPack(), 1300224145Sdim E->getParameterPackLocation(), 1301224145Sdim Arg); 1302218893Sdim} 1303218893Sdim 1304212904SdimExprResult 1305243830SdimTemplateInstantiator::RebuildParmVarDeclRefExpr(ParmVarDecl *PD, 1306243830Sdim SourceLocation Loc) { 1307243830Sdim DeclarationNameInfo NameInfo(PD->getDeclName(), Loc); 1308243830Sdim return getSema().BuildDeclarationNameExpr(CXXScopeSpec(), NameInfo, PD); 1309243830Sdim} 1310243830Sdim 1311243830SdimExprResult 1312243830SdimTemplateInstantiator::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) { 1313243830Sdim if (getSema().ArgumentPackSubstitutionIndex != -1) { 1314243830Sdim // We can expand this parameter pack now. 1315243830Sdim ParmVarDecl *D = E->getExpansion(getSema().ArgumentPackSubstitutionIndex); 1316243830Sdim ValueDecl *VD = cast_or_null<ValueDecl>(TransformDecl(E->getExprLoc(), D)); 1317243830Sdim if (!VD) 1318243830Sdim return ExprError(); 1319243830Sdim return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(VD), E->getExprLoc()); 1320243830Sdim } 1321243830Sdim 1322243830Sdim QualType T = TransformType(E->getType()); 1323243830Sdim if (T.isNull()) 1324243830Sdim return ExprError(); 1325243830Sdim 1326243830Sdim // Transform each of the parameter expansions into the corresponding 1327243830Sdim // parameters in the instantiation of the function decl. 1328249423Sdim SmallVector<Decl *, 8> Parms; 1329243830Sdim Parms.reserve(E->getNumExpansions()); 1330243830Sdim for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end(); 1331243830Sdim I != End; ++I) { 1332243830Sdim ParmVarDecl *D = 1333243830Sdim cast_or_null<ParmVarDecl>(TransformDecl(E->getExprLoc(), *I)); 1334243830Sdim if (!D) 1335243830Sdim return ExprError(); 1336243830Sdim Parms.push_back(D); 1337243830Sdim } 1338243830Sdim 1339243830Sdim return FunctionParmPackExpr::Create(getSema().Context, T, 1340243830Sdim E->getParameterPack(), 1341243830Sdim E->getParameterPackLocation(), Parms); 1342243830Sdim} 1343243830Sdim 1344243830SdimExprResult 1345243830SdimTemplateInstantiator::TransformFunctionParmPackRefExpr(DeclRefExpr *E, 1346243830Sdim ParmVarDecl *PD) { 1347243830Sdim typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack; 1348243830Sdim llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found 1349243830Sdim = getSema().CurrentInstantiationScope->findInstantiationOf(PD); 1350243830Sdim assert(Found && "no instantiation for parameter pack"); 1351243830Sdim 1352243830Sdim Decl *TransformedDecl; 1353243830Sdim if (DeclArgumentPack *Pack = Found->dyn_cast<DeclArgumentPack *>()) { 1354243830Sdim // If this is a reference to a function parameter pack which we can substitute 1355243830Sdim // but can't yet expand, build a FunctionParmPackExpr for it. 1356243830Sdim if (getSema().ArgumentPackSubstitutionIndex == -1) { 1357243830Sdim QualType T = TransformType(E->getType()); 1358243830Sdim if (T.isNull()) 1359243830Sdim return ExprError(); 1360243830Sdim return FunctionParmPackExpr::Create(getSema().Context, T, PD, 1361243830Sdim E->getExprLoc(), *Pack); 1362243830Sdim } 1363243830Sdim 1364243830Sdim TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex]; 1365243830Sdim } else { 1366243830Sdim TransformedDecl = Found->get<Decl*>(); 1367243830Sdim } 1368243830Sdim 1369243830Sdim // We have either an unexpanded pack or a specific expansion. 1370243830Sdim return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(TransformedDecl), 1371243830Sdim E->getExprLoc()); 1372243830Sdim} 1373243830Sdim 1374243830SdimExprResult 1375203955SrdivackyTemplateInstantiator::TransformDeclRefExpr(DeclRefExpr *E) { 1376203955Srdivacky NamedDecl *D = E->getDecl(); 1377243830Sdim 1378243830Sdim // Handle references to non-type template parameters and non-type template 1379243830Sdim // parameter packs. 1380203955Srdivacky if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) { 1381203955Srdivacky if (NTTP->getDepth() < TemplateArgs.getNumLevels()) 1382203955Srdivacky return TransformTemplateParmRefExpr(E, NTTP); 1383198893Srdivacky 1384198893Srdivacky // We have a non-type template parameter that isn't fully substituted; 1385198893Srdivacky // FindInstantiatedDecl will find it in the local instantiation scope. 1386193326Sed } 1387193326Sed 1388243830Sdim // Handle references to function parameter packs. 1389243830Sdim if (ParmVarDecl *PD = dyn_cast<ParmVarDecl>(D)) 1390243830Sdim if (PD->isParameterPack()) 1391243830Sdim return TransformFunctionParmPackRefExpr(E, PD); 1392243830Sdim 1393200583Srdivacky return TreeTransform<TemplateInstantiator>::TransformDeclRefExpr(E); 1394193326Sed} 1395193326Sed 1396212904SdimExprResult TemplateInstantiator::TransformCXXDefaultArgExpr( 1397200583Srdivacky CXXDefaultArgExpr *E) { 1398199482Srdivacky assert(!cast<FunctionDecl>(E->getParam()->getDeclContext())-> 1399199482Srdivacky getDescribedFunctionTemplate() && 1400199482Srdivacky "Default arg expressions are never formed in dependent cases."); 1401201361Srdivacky return SemaRef.BuildCXXDefaultArgExpr(E->getUsedLocation(), 1402201361Srdivacky cast<FunctionDecl>(E->getParam()->getDeclContext()), 1403201361Srdivacky E->getParam()); 1404199482Srdivacky} 1405199482Srdivacky 1406207619SrdivackyQualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB, 1407218893Sdim FunctionProtoTypeLoc TL) { 1408207619Srdivacky // We need a local instantiation scope for this function prototype. 1409212904Sdim LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true); 1410218893Sdim return inherited::TransformFunctionProtoType(TLB, TL); 1411205219Srdivacky} 1412205219Srdivacky 1413234982SdimQualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB, 1414234982Sdim FunctionProtoTypeLoc TL, 1415234982Sdim CXXRecordDecl *ThisContext, 1416234982Sdim unsigned ThisTypeQuals) { 1417234982Sdim // We need a local instantiation scope for this function prototype. 1418234982Sdim LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true); 1419234982Sdim return inherited::TransformFunctionProtoType(TLB, TL, ThisContext, 1420234982Sdim ThisTypeQuals); 1421234982Sdim} 1422234982Sdim 1423205219SrdivackyParmVarDecl * 1424218893SdimTemplateInstantiator::TransformFunctionTypeParam(ParmVarDecl *OldParm, 1425221345Sdim int indexAdjustment, 1426249423Sdim Optional<unsigned> NumExpansions, 1427234353Sdim bool ExpectParameterPack) { 1428221345Sdim return SemaRef.SubstParmVarDecl(OldParm, TemplateArgs, indexAdjustment, 1429234353Sdim NumExpansions, ExpectParameterPack); 1430205219Srdivacky} 1431205219Srdivacky 1432194613SedQualType 1433198398SrdivackyTemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB, 1434218893Sdim TemplateTypeParmTypeLoc TL) { 1435218893Sdim const TemplateTypeParmType *T = TL.getTypePtr(); 1436198092Srdivacky if (T->getDepth() < TemplateArgs.getNumLevels()) { 1437198092Srdivacky // Replace the template type parameter with its corresponding 1438198092Srdivacky // template argument. 1439193326Sed 1440198092Srdivacky // If the corresponding template argument is NULL or doesn't exist, it's 1441198092Srdivacky // because we are performing instantiation from explicitly-specified 1442198092Srdivacky // template arguments in a function template class, but there were some 1443198092Srdivacky // arguments left unspecified. 1444198398Srdivacky if (!TemplateArgs.hasTemplateArgument(T->getDepth(), T->getIndex())) { 1445198398Srdivacky TemplateTypeParmTypeLoc NewTL 1446198398Srdivacky = TLB.push<TemplateTypeParmTypeLoc>(TL.getType()); 1447198398Srdivacky NewTL.setNameLoc(TL.getNameLoc()); 1448198398Srdivacky return TL.getType(); 1449198398Srdivacky } 1450193326Sed 1451218893Sdim TemplateArgument Arg = TemplateArgs(T->getDepth(), T->getIndex()); 1452218893Sdim 1453218893Sdim if (T->isParameterPack()) { 1454218893Sdim assert(Arg.getKind() == TemplateArgument::Pack && 1455218893Sdim "Missing argument pack"); 1456218893Sdim 1457218893Sdim if (getSema().ArgumentPackSubstitutionIndex == -1) { 1458218893Sdim // We have the template argument pack, but we're not expanding the 1459218893Sdim // enclosing pack expansion yet. Just save the template argument 1460218893Sdim // pack for later substitution. 1461218893Sdim QualType Result 1462218893Sdim = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg); 1463218893Sdim SubstTemplateTypeParmPackTypeLoc NewTL 1464218893Sdim = TLB.push<SubstTemplateTypeParmPackTypeLoc>(Result); 1465218893Sdim NewTL.setNameLoc(TL.getNameLoc()); 1466218893Sdim return Result; 1467218893Sdim } 1468218893Sdim 1469263508Sdim Arg = getPackSubstitutedTemplateArgument(getSema(), Arg); 1470218893Sdim } 1471218893Sdim 1472218893Sdim assert(Arg.getKind() == TemplateArgument::Type && 1473198092Srdivacky "Template argument kind mismatch"); 1474193326Sed 1475218893Sdim QualType Replacement = Arg.getAsType(); 1476198398Srdivacky 1477198398Srdivacky // TODO: only do this uniquing once, at the start of instantiation. 1478198398Srdivacky QualType Result 1479198398Srdivacky = getSema().Context.getSubstTemplateTypeParmType(T, Replacement); 1480198398Srdivacky SubstTemplateTypeParmTypeLoc NewTL 1481198398Srdivacky = TLB.push<SubstTemplateTypeParmTypeLoc>(Result); 1482198398Srdivacky NewTL.setNameLoc(TL.getNameLoc()); 1483198398Srdivacky return Result; 1484193326Sed } 1485195099Sed 1486198092Srdivacky // The template type parameter comes from an inner template (e.g., 1487198092Srdivacky // the template parameter list of a member template inside the 1488198092Srdivacky // template we are instantiating). Create a new template type 1489198092Srdivacky // parameter with the template "level" reduced by one. 1490221345Sdim TemplateTypeParmDecl *NewTTPDecl = 0; 1491221345Sdim if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl()) 1492221345Sdim NewTTPDecl = cast_or_null<TemplateTypeParmDecl>( 1493221345Sdim TransformDecl(TL.getNameLoc(), OldTTPDecl)); 1494221345Sdim 1495198398Srdivacky QualType Result 1496198398Srdivacky = getSema().Context.getTemplateTypeParmType(T->getDepth() 1497198398Srdivacky - TemplateArgs.getNumLevels(), 1498198398Srdivacky T->getIndex(), 1499198398Srdivacky T->isParameterPack(), 1500221345Sdim NewTTPDecl); 1501198398Srdivacky TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result); 1502198398Srdivacky NewTL.setNameLoc(TL.getNameLoc()); 1503198398Srdivacky return Result; 1504193326Sed} 1505193326Sed 1506218893SdimQualType 1507218893SdimTemplateInstantiator::TransformSubstTemplateTypeParmPackType( 1508218893Sdim TypeLocBuilder &TLB, 1509218893Sdim SubstTemplateTypeParmPackTypeLoc TL) { 1510218893Sdim if (getSema().ArgumentPackSubstitutionIndex == -1) { 1511218893Sdim // We aren't expanding the parameter pack, so just return ourselves. 1512218893Sdim SubstTemplateTypeParmPackTypeLoc NewTL 1513218893Sdim = TLB.push<SubstTemplateTypeParmPackTypeLoc>(TL.getType()); 1514218893Sdim NewTL.setNameLoc(TL.getNameLoc()); 1515218893Sdim return TL.getType(); 1516218893Sdim } 1517263508Sdim 1518263508Sdim TemplateArgument Arg = TL.getTypePtr()->getArgumentPack(); 1519263508Sdim Arg = getPackSubstitutedTemplateArgument(getSema(), Arg); 1520263508Sdim QualType Result = Arg.getAsType(); 1521263508Sdim 1522218893Sdim Result = getSema().Context.getSubstTemplateTypeParmType( 1523218893Sdim TL.getTypePtr()->getReplacedParameter(), 1524218893Sdim Result); 1525218893Sdim SubstTemplateTypeParmTypeLoc NewTL 1526218893Sdim = TLB.push<SubstTemplateTypeParmTypeLoc>(Result); 1527218893Sdim NewTL.setNameLoc(TL.getNameLoc()); 1528218893Sdim return Result; 1529218893Sdim} 1530218893Sdim 1531198092Srdivacky/// \brief Perform substitution on the type T with a given set of template 1532198092Srdivacky/// arguments. 1533193326Sed/// 1534193326Sed/// This routine substitutes the given template arguments into the 1535193326Sed/// type T and produces the instantiated type. 1536193326Sed/// 1537193326Sed/// \param T the type into which the template arguments will be 1538193326Sed/// substituted. If this type is not dependent, it will be returned 1539193326Sed/// immediately. 1540193326Sed/// 1541239462Sdim/// \param Args the template arguments that will be 1542193326Sed/// substituted for the top-level template parameters within T. 1543193326Sed/// 1544193326Sed/// \param Loc the location in the source code where this substitution 1545193326Sed/// is being performed. It will typically be the location of the 1546193326Sed/// declarator (if we're instantiating the type of some declaration) 1547193326Sed/// or the location of the type in the source code (if, e.g., we're 1548193326Sed/// instantiating the type of a cast expression). 1549193326Sed/// 1550193326Sed/// \param Entity the name of the entity associated with a declaration 1551193326Sed/// being instantiated (if any). May be empty to indicate that there 1552193326Sed/// is no such entity (if, e.g., this is a type that occurs as part of 1553193326Sed/// a cast expression) or that the entity has no name (e.g., an 1554193326Sed/// unnamed function parameter). 1555193326Sed/// 1556193326Sed/// \returns If the instantiation succeeds, the instantiated 1557193326Sed/// type. Otherwise, produces diagnostics and returns a NULL type. 1558200583SrdivackyTypeSourceInfo *Sema::SubstType(TypeSourceInfo *T, 1559198398Srdivacky const MultiLevelTemplateArgumentList &Args, 1560198398Srdivacky SourceLocation Loc, 1561198398Srdivacky DeclarationName Entity) { 1562198398Srdivacky assert(!ActiveTemplateInstantiations.empty() && 1563198398Srdivacky "Cannot perform an instantiation without some context on the " 1564198398Srdivacky "instantiation stack"); 1565198398Srdivacky 1566224145Sdim if (!T->getType()->isInstantiationDependentType() && 1567208600Srdivacky !T->getType()->isVariablyModifiedType()) 1568198398Srdivacky return T; 1569198398Srdivacky 1570198398Srdivacky TemplateInstantiator Instantiator(*this, Args, Loc, Entity); 1571198398Srdivacky return Instantiator.TransformType(T); 1572198398Srdivacky} 1573198398Srdivacky 1574218893SdimTypeSourceInfo *Sema::SubstType(TypeLoc TL, 1575218893Sdim const MultiLevelTemplateArgumentList &Args, 1576218893Sdim SourceLocation Loc, 1577218893Sdim DeclarationName Entity) { 1578218893Sdim assert(!ActiveTemplateInstantiations.empty() && 1579218893Sdim "Cannot perform an instantiation without some context on the " 1580218893Sdim "instantiation stack"); 1581218893Sdim 1582218893Sdim if (TL.getType().isNull()) 1583218893Sdim return 0; 1584218893Sdim 1585224145Sdim if (!TL.getType()->isInstantiationDependentType() && 1586218893Sdim !TL.getType()->isVariablyModifiedType()) { 1587218893Sdim // FIXME: Make a copy of the TypeLoc data here, so that we can 1588218893Sdim // return a new TypeSourceInfo. Inefficient! 1589218893Sdim TypeLocBuilder TLB; 1590218893Sdim TLB.pushFullCopy(TL); 1591218893Sdim return TLB.getTypeSourceInfo(Context, TL.getType()); 1592218893Sdim } 1593218893Sdim 1594218893Sdim TemplateInstantiator Instantiator(*this, Args, Loc, Entity); 1595218893Sdim TypeLocBuilder TLB; 1596218893Sdim TLB.reserve(TL.getFullDataSize()); 1597218893Sdim QualType Result = Instantiator.TransformType(TLB, TL); 1598218893Sdim if (Result.isNull()) 1599218893Sdim return 0; 1600218893Sdim 1601218893Sdim return TLB.getTypeSourceInfo(Context, Result); 1602218893Sdim} 1603218893Sdim 1604198398Srdivacky/// Deprecated form of the above. 1605198092SrdivackyQualType Sema::SubstType(QualType T, 1606198092Srdivacky const MultiLevelTemplateArgumentList &TemplateArgs, 1607198092Srdivacky SourceLocation Loc, DeclarationName Entity) { 1608193326Sed assert(!ActiveTemplateInstantiations.empty() && 1609193326Sed "Cannot perform an instantiation without some context on the " 1610193326Sed "instantiation stack"); 1611193326Sed 1612208600Srdivacky // If T is not a dependent type or a variably-modified type, there 1613208600Srdivacky // is nothing to do. 1614224145Sdim if (!T->isInstantiationDependentType() && !T->isVariablyModifiedType()) 1615193326Sed return T; 1616193326Sed 1617198092Srdivacky TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, Entity); 1618198092Srdivacky return Instantiator.TransformType(T); 1619193326Sed} 1620193326Sed 1621207619Srdivackystatic bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T) { 1622224145Sdim if (T->getType()->isInstantiationDependentType() || 1623224145Sdim T->getType()->isVariablyModifiedType()) 1624207619Srdivacky return true; 1625207619Srdivacky 1626218893Sdim TypeLoc TL = T->getTypeLoc().IgnoreParens(); 1627249423Sdim if (!TL.getAs<FunctionProtoTypeLoc>()) 1628207619Srdivacky return false; 1629207619Srdivacky 1630249423Sdim FunctionProtoTypeLoc FP = TL.castAs<FunctionProtoTypeLoc>(); 1631207619Srdivacky for (unsigned I = 0, E = FP.getNumArgs(); I != E; ++I) { 1632207619Srdivacky ParmVarDecl *P = FP.getArg(I); 1633207619Srdivacky 1634263508Sdim // This must be synthesized from a typedef. 1635263508Sdim if (!P) continue; 1636263508Sdim 1637223017Sdim // The parameter's type as written might be dependent even if the 1638223017Sdim // decayed type was not dependent. 1639223017Sdim if (TypeSourceInfo *TSInfo = P->getTypeSourceInfo()) 1640224145Sdim if (TSInfo->getType()->isInstantiationDependentType()) 1641223017Sdim return true; 1642223017Sdim 1643207619Srdivacky // TODO: currently we always rebuild expressions. When we 1644207619Srdivacky // properly get lazier about this, we should use the same 1645207619Srdivacky // logic to avoid rebuilding prototypes here. 1646218893Sdim if (P->hasDefaultArg()) 1647207619Srdivacky return true; 1648207619Srdivacky } 1649207619Srdivacky 1650207619Srdivacky return false; 1651207619Srdivacky} 1652207619Srdivacky 1653207619Srdivacky/// A form of SubstType intended specifically for instantiating the 1654207619Srdivacky/// type of a FunctionDecl. Its purpose is solely to force the 1655207619Srdivacky/// instantiation of default-argument expressions. 1656207619SrdivackyTypeSourceInfo *Sema::SubstFunctionDeclType(TypeSourceInfo *T, 1657207619Srdivacky const MultiLevelTemplateArgumentList &Args, 1658207619Srdivacky SourceLocation Loc, 1659234982Sdim DeclarationName Entity, 1660234982Sdim CXXRecordDecl *ThisContext, 1661234982Sdim unsigned ThisTypeQuals) { 1662207619Srdivacky assert(!ActiveTemplateInstantiations.empty() && 1663207619Srdivacky "Cannot perform an instantiation without some context on the " 1664207619Srdivacky "instantiation stack"); 1665207619Srdivacky 1666207619Srdivacky if (!NeedsInstantiationAsFunctionType(T)) 1667207619Srdivacky return T; 1668207619Srdivacky 1669207619Srdivacky TemplateInstantiator Instantiator(*this, Args, Loc, Entity); 1670207619Srdivacky 1671207619Srdivacky TypeLocBuilder TLB; 1672207619Srdivacky 1673207619Srdivacky TypeLoc TL = T->getTypeLoc(); 1674207619Srdivacky TLB.reserve(TL.getFullDataSize()); 1675207619Srdivacky 1676234982Sdim QualType Result; 1677249423Sdim 1678249423Sdim if (FunctionProtoTypeLoc Proto = TL.getAs<FunctionProtoTypeLoc>()) { 1679249423Sdim Result = Instantiator.TransformFunctionProtoType(TLB, Proto, ThisContext, 1680234982Sdim ThisTypeQuals); 1681234982Sdim } else { 1682234982Sdim Result = Instantiator.TransformType(TLB, TL); 1683234982Sdim } 1684207619Srdivacky if (Result.isNull()) 1685207619Srdivacky return 0; 1686207619Srdivacky 1687207619Srdivacky return TLB.getTypeSourceInfo(Context, Result); 1688207619Srdivacky} 1689207619Srdivacky 1690207619SrdivackyParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm, 1691218893Sdim const MultiLevelTemplateArgumentList &TemplateArgs, 1692221345Sdim int indexAdjustment, 1693249423Sdim Optional<unsigned> NumExpansions, 1694234353Sdim bool ExpectParameterPack) { 1695207619Srdivacky TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); 1696218893Sdim TypeSourceInfo *NewDI = 0; 1697218893Sdim 1698218893Sdim TypeLoc OldTL = OldDI->getTypeLoc(); 1699249423Sdim if (PackExpansionTypeLoc ExpansionTL = OldTL.getAs<PackExpansionTypeLoc>()) { 1700249423Sdim 1701218893Sdim // We have a function parameter pack. Substitute into the pattern of the 1702218893Sdim // expansion. 1703218893Sdim NewDI = SubstType(ExpansionTL.getPatternLoc(), TemplateArgs, 1704218893Sdim OldParm->getLocation(), OldParm->getDeclName()); 1705218893Sdim if (!NewDI) 1706218893Sdim return 0; 1707218893Sdim 1708218893Sdim if (NewDI->getType()->containsUnexpandedParameterPack()) { 1709218893Sdim // We still have unexpanded parameter packs, which means that 1710218893Sdim // our function parameter is still a function parameter pack. 1711218893Sdim // Therefore, make its type a pack expansion type. 1712218893Sdim NewDI = CheckPackExpansion(NewDI, ExpansionTL.getEllipsisLoc(), 1713218893Sdim NumExpansions); 1714234353Sdim } else if (ExpectParameterPack) { 1715234353Sdim // We expected to get a parameter pack but didn't (because the type 1716234353Sdim // itself is not a pack expansion type), so complain. This can occur when 1717234353Sdim // the substitution goes through an alias template that "loses" the 1718234353Sdim // pack expansion. 1719234353Sdim Diag(OldParm->getLocation(), 1720234353Sdim diag::err_function_parameter_pack_without_parameter_packs) 1721234353Sdim << NewDI->getType(); 1722234353Sdim return 0; 1723234353Sdim } 1724218893Sdim } else { 1725218893Sdim NewDI = SubstType(OldDI, TemplateArgs, OldParm->getLocation(), 1726218893Sdim OldParm->getDeclName()); 1727218893Sdim } 1728218893Sdim 1729207619Srdivacky if (!NewDI) 1730207619Srdivacky return 0; 1731207619Srdivacky 1732207619Srdivacky if (NewDI->getType()->isVoidType()) { 1733207619Srdivacky Diag(OldParm->getLocation(), diag::err_param_with_void_type); 1734207619Srdivacky return 0; 1735207619Srdivacky } 1736207619Srdivacky 1737207619Srdivacky ParmVarDecl *NewParm = CheckParameter(Context.getTranslationUnitDecl(), 1738221345Sdim OldParm->getInnerLocStart(), 1739221345Sdim OldParm->getLocation(), 1740207619Srdivacky OldParm->getIdentifier(), 1741221345Sdim NewDI->getType(), NewDI, 1742249423Sdim OldParm->getStorageClass()); 1743207619Srdivacky if (!NewParm) 1744207619Srdivacky return 0; 1745207619Srdivacky 1746207619Srdivacky // Mark the (new) default argument as uninstantiated (if any). 1747207619Srdivacky if (OldParm->hasUninstantiatedDefaultArg()) { 1748207619Srdivacky Expr *Arg = OldParm->getUninstantiatedDefaultArg(); 1749207619Srdivacky NewParm->setUninstantiatedDefaultArg(Arg); 1750218893Sdim } else if (OldParm->hasUnparsedDefaultArg()) { 1751218893Sdim NewParm->setUnparsedDefaultArg(); 1752218893Sdim UnparsedDefaultArgInstantiations[OldParm].push_back(NewParm); 1753207619Srdivacky } else if (Expr *Arg = OldParm->getDefaultArg()) 1754239462Sdim // FIXME: if we non-lazily instantiated non-dependent default args for 1755239462Sdim // non-dependent parameter types we could remove a bunch of duplicate 1756239462Sdim // conversion warnings for such arguments. 1757207619Srdivacky NewParm->setUninstantiatedDefaultArg(Arg); 1758207619Srdivacky 1759207619Srdivacky NewParm->setHasInheritedDefaultArg(OldParm->hasInheritedDefaultArg()); 1760234353Sdim 1761218893Sdim if (OldParm->isParameterPack() && !NewParm->isParameterPack()) { 1762234353Sdim // Add the new parameter to the instantiated parameter pack. 1763218893Sdim CurrentInstantiationScope->InstantiatedLocalPackArg(OldParm, NewParm); 1764218893Sdim } else { 1765218893Sdim // Introduce an Old -> New mapping 1766218893Sdim CurrentInstantiationScope->InstantiatedLocal(OldParm, NewParm); 1767218893Sdim } 1768218893Sdim 1769212904Sdim // FIXME: OldParm may come from a FunctionProtoType, in which case CurContext 1770212904Sdim // can be anything, is this right ? 1771210299Sed NewParm->setDeclContext(CurContext); 1772221345Sdim 1773221345Sdim NewParm->setScopeInfo(OldParm->getFunctionScopeDepth(), 1774221345Sdim OldParm->getFunctionScopeIndex() + indexAdjustment); 1775249423Sdim 1776249423Sdim InstantiateAttrs(TemplateArgs, OldParm, NewParm); 1777249423Sdim 1778207619Srdivacky return NewParm; 1779207619Srdivacky} 1780207619Srdivacky 1781218893Sdim/// \brief Substitute the given template arguments into the given set of 1782218893Sdim/// parameters, producing the set of parameter types that would be generated 1783218893Sdim/// from such a substitution. 1784218893Sdimbool Sema::SubstParmTypes(SourceLocation Loc, 1785218893Sdim ParmVarDecl **Params, unsigned NumParams, 1786218893Sdim const MultiLevelTemplateArgumentList &TemplateArgs, 1787226633Sdim SmallVectorImpl<QualType> &ParamTypes, 1788226633Sdim SmallVectorImpl<ParmVarDecl *> *OutParams) { 1789218893Sdim assert(!ActiveTemplateInstantiations.empty() && 1790218893Sdim "Cannot perform an instantiation without some context on the " 1791218893Sdim "instantiation stack"); 1792218893Sdim 1793218893Sdim TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, 1794218893Sdim DeclarationName()); 1795218893Sdim return Instantiator.TransformFunctionTypeParams(Loc, Params, NumParams, 0, 1796218893Sdim ParamTypes, OutParams); 1797218893Sdim} 1798218893Sdim 1799198092Srdivacky/// \brief Perform substitution on the base class specifiers of the 1800198092Srdivacky/// given class template specialization. 1801193326Sed/// 1802193326Sed/// Produces a diagnostic and returns true on error, returns false and 1803193326Sed/// attaches the instantiated base classes to the class template 1804193326Sed/// specialization if successful. 1805198092Srdivackybool 1806198092SrdivackySema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation, 1807198092Srdivacky CXXRecordDecl *Pattern, 1808198092Srdivacky const MultiLevelTemplateArgumentList &TemplateArgs) { 1809193326Sed bool Invalid = false; 1810226633Sdim SmallVector<CXXBaseSpecifier*, 4> InstantiatedBases; 1811198092Srdivacky for (ClassTemplateSpecializationDecl::base_class_iterator 1812193326Sed Base = Pattern->bases_begin(), BaseEnd = Pattern->bases_end(); 1813193326Sed Base != BaseEnd; ++Base) { 1814193326Sed if (!Base->getType()->isDependentType()) { 1815263508Sdim if (const CXXRecordDecl *RD = Base->getType()->getAsCXXRecordDecl()) { 1816263508Sdim if (RD->isInvalidDecl()) 1817263508Sdim Instantiation->setInvalidDecl(); 1818263508Sdim } 1819198092Srdivacky InstantiatedBases.push_back(new (Context) CXXBaseSpecifier(*Base)); 1820193326Sed continue; 1821193326Sed } 1822193326Sed 1823218893Sdim SourceLocation EllipsisLoc; 1824221345Sdim TypeSourceInfo *BaseTypeLoc; 1825218893Sdim if (Base->isPackExpansion()) { 1826218893Sdim // This is a pack expansion. See whether we should expand it now, or 1827218893Sdim // wait until later. 1828226633Sdim SmallVector<UnexpandedParameterPack, 2> Unexpanded; 1829218893Sdim collectUnexpandedParameterPacks(Base->getTypeSourceInfo()->getTypeLoc(), 1830218893Sdim Unexpanded); 1831218893Sdim bool ShouldExpand = false; 1832218893Sdim bool RetainExpansion = false; 1833249423Sdim Optional<unsigned> NumExpansions; 1834218893Sdim if (CheckParameterPacksForExpansion(Base->getEllipsisLoc(), 1835218893Sdim Base->getSourceRange(), 1836226633Sdim Unexpanded, 1837218893Sdim TemplateArgs, ShouldExpand, 1838218893Sdim RetainExpansion, 1839218893Sdim NumExpansions)) { 1840218893Sdim Invalid = true; 1841218893Sdim continue; 1842218893Sdim } 1843218893Sdim 1844218893Sdim // If we should expand this pack expansion now, do so. 1845218893Sdim if (ShouldExpand) { 1846218893Sdim for (unsigned I = 0; I != *NumExpansions; ++I) { 1847218893Sdim Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I); 1848218893Sdim 1849218893Sdim TypeSourceInfo *BaseTypeLoc = SubstType(Base->getTypeSourceInfo(), 1850218893Sdim TemplateArgs, 1851218893Sdim Base->getSourceRange().getBegin(), 1852218893Sdim DeclarationName()); 1853218893Sdim if (!BaseTypeLoc) { 1854218893Sdim Invalid = true; 1855218893Sdim continue; 1856218893Sdim } 1857218893Sdim 1858218893Sdim if (CXXBaseSpecifier *InstantiatedBase 1859218893Sdim = CheckBaseSpecifier(Instantiation, 1860218893Sdim Base->getSourceRange(), 1861218893Sdim Base->isVirtual(), 1862218893Sdim Base->getAccessSpecifierAsWritten(), 1863218893Sdim BaseTypeLoc, 1864218893Sdim SourceLocation())) 1865218893Sdim InstantiatedBases.push_back(InstantiatedBase); 1866218893Sdim else 1867218893Sdim Invalid = true; 1868218893Sdim } 1869218893Sdim 1870218893Sdim continue; 1871218893Sdim } 1872218893Sdim 1873218893Sdim // The resulting base specifier will (still) be a pack expansion. 1874218893Sdim EllipsisLoc = Base->getEllipsisLoc(); 1875221345Sdim Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1); 1876221345Sdim BaseTypeLoc = SubstType(Base->getTypeSourceInfo(), 1877221345Sdim TemplateArgs, 1878221345Sdim Base->getSourceRange().getBegin(), 1879221345Sdim DeclarationName()); 1880221345Sdim } else { 1881221345Sdim BaseTypeLoc = SubstType(Base->getTypeSourceInfo(), 1882221345Sdim TemplateArgs, 1883221345Sdim Base->getSourceRange().getBegin(), 1884221345Sdim DeclarationName()); 1885218893Sdim } 1886218893Sdim 1887212904Sdim if (!BaseTypeLoc) { 1888193326Sed Invalid = true; 1889193326Sed continue; 1890193326Sed } 1891193326Sed 1892193326Sed if (CXXBaseSpecifier *InstantiatedBase 1893193326Sed = CheckBaseSpecifier(Instantiation, 1894193326Sed Base->getSourceRange(), 1895193326Sed Base->isVirtual(), 1896193326Sed Base->getAccessSpecifierAsWritten(), 1897218893Sdim BaseTypeLoc, 1898218893Sdim EllipsisLoc)) 1899193326Sed InstantiatedBases.push_back(InstantiatedBase); 1900193326Sed else 1901193326Sed Invalid = true; 1902193326Sed } 1903193326Sed 1904193326Sed if (!Invalid && 1905193326Sed AttachBaseSpecifiers(Instantiation, InstantiatedBases.data(), 1906193326Sed InstantiatedBases.size())) 1907193326Sed Invalid = true; 1908193326Sed 1909193326Sed return Invalid; 1910193326Sed} 1911193326Sed 1912234353Sdim// Defined via #include from SemaTemplateInstantiateDecl.cpp 1913234353Sdimnamespace clang { 1914234353Sdim namespace sema { 1915234353Sdim Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S, 1916234353Sdim const MultiLevelTemplateArgumentList &TemplateArgs); 1917234353Sdim } 1918234353Sdim} 1919234353Sdim 1920234353Sdim/// Determine whether we would be unable to instantiate this template (because 1921234353Sdim/// it either has no definition, or is in the process of being instantiated). 1922234353Sdimstatic bool DiagnoseUninstantiableTemplate(Sema &S, 1923234353Sdim SourceLocation PointOfInstantiation, 1924234353Sdim TagDecl *Instantiation, 1925234353Sdim bool InstantiatedFromMember, 1926234353Sdim TagDecl *Pattern, 1927234353Sdim TagDecl *PatternDef, 1928234353Sdim TemplateSpecializationKind TSK, 1929234353Sdim bool Complain = true) { 1930234353Sdim if (PatternDef && !PatternDef->isBeingDefined()) 1931234353Sdim return false; 1932234353Sdim 1933234353Sdim if (!Complain || (PatternDef && PatternDef->isInvalidDecl())) { 1934234353Sdim // Say nothing 1935234353Sdim } else if (PatternDef) { 1936234353Sdim assert(PatternDef->isBeingDefined()); 1937234353Sdim S.Diag(PointOfInstantiation, 1938234353Sdim diag::err_template_instantiate_within_definition) 1939234353Sdim << (TSK != TSK_ImplicitInstantiation) 1940234353Sdim << S.Context.getTypeDeclType(Instantiation); 1941234353Sdim // Not much point in noting the template declaration here, since 1942234353Sdim // we're lexically inside it. 1943234353Sdim Instantiation->setInvalidDecl(); 1944234353Sdim } else if (InstantiatedFromMember) { 1945234353Sdim S.Diag(PointOfInstantiation, 1946234353Sdim diag::err_implicit_instantiate_member_undefined) 1947234353Sdim << S.Context.getTypeDeclType(Instantiation); 1948234353Sdim S.Diag(Pattern->getLocation(), diag::note_member_of_template_here); 1949234353Sdim } else { 1950234353Sdim S.Diag(PointOfInstantiation, diag::err_template_instantiate_undefined) 1951234353Sdim << (TSK != TSK_ImplicitInstantiation) 1952234353Sdim << S.Context.getTypeDeclType(Instantiation); 1953234353Sdim S.Diag(Pattern->getLocation(), diag::note_template_decl_here); 1954234353Sdim } 1955234353Sdim 1956234353Sdim // In general, Instantiation isn't marked invalid to get more than one 1957234353Sdim // error for multiple undefined instantiations. But the code that does 1958234353Sdim // explicit declaration -> explicit definition conversion can't handle 1959234353Sdim // invalid declarations, so mark as invalid in that case. 1960234353Sdim if (TSK == TSK_ExplicitInstantiationDeclaration) 1961234353Sdim Instantiation->setInvalidDecl(); 1962234353Sdim return true; 1963234353Sdim} 1964234353Sdim 1965193326Sed/// \brief Instantiate the definition of a class from a given pattern. 1966193326Sed/// 1967193326Sed/// \param PointOfInstantiation The point of instantiation within the 1968193326Sed/// source code. 1969193326Sed/// 1970193326Sed/// \param Instantiation is the declaration whose definition is being 1971193326Sed/// instantiated. This will be either a class template specialization 1972193326Sed/// or a member class of a class template specialization. 1973193326Sed/// 1974193326Sed/// \param Pattern is the pattern from which the instantiation 1975193326Sed/// occurs. This will be either the declaration of a class template or 1976193326Sed/// the declaration of a member class of a class template. 1977193326Sed/// 1978193326Sed/// \param TemplateArgs The template arguments to be substituted into 1979193326Sed/// the pattern. 1980193326Sed/// 1981198092Srdivacky/// \param TSK the kind of implicit or explicit instantiation to perform. 1982198092Srdivacky/// 1983198092Srdivacky/// \param Complain whether to complain if the class cannot be instantiated due 1984198092Srdivacky/// to the lack of a definition. 1985198092Srdivacky/// 1986193326Sed/// \returns true if an error occurred, false otherwise. 1987193326Sedbool 1988193326SedSema::InstantiateClass(SourceLocation PointOfInstantiation, 1989193326Sed CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, 1990198092Srdivacky const MultiLevelTemplateArgumentList &TemplateArgs, 1991198092Srdivacky TemplateSpecializationKind TSK, 1992198092Srdivacky bool Complain) { 1993198092Srdivacky CXXRecordDecl *PatternDef 1994203955Srdivacky = cast_or_null<CXXRecordDecl>(Pattern->getDefinition()); 1995234353Sdim if (DiagnoseUninstantiableTemplate(*this, PointOfInstantiation, Instantiation, 1996234353Sdim Instantiation->getInstantiatedFromMemberClass(), 1997234353Sdim Pattern, PatternDef, TSK, Complain)) 1998193326Sed return true; 1999193326Sed Pattern = PatternDef; 2000193326Sed 2001198398Srdivacky // \brief Record the point of instantiation. 2002198398Srdivacky if (MemberSpecializationInfo *MSInfo 2003198398Srdivacky = Instantiation->getMemberSpecializationInfo()) { 2004198398Srdivacky MSInfo->setTemplateSpecializationKind(TSK); 2005198398Srdivacky MSInfo->setPointOfInstantiation(PointOfInstantiation); 2006198893Srdivacky } else if (ClassTemplateSpecializationDecl *Spec 2007234353Sdim = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) { 2008198893Srdivacky Spec->setTemplateSpecializationKind(TSK); 2009198893Srdivacky Spec->setPointOfInstantiation(PointOfInstantiation); 2010198398Srdivacky } 2011198398Srdivacky 2012193326Sed InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation); 2013263508Sdim if (Inst.isInvalid()) 2014193326Sed return true; 2015193326Sed 2016193326Sed // Enter the scope of this instantiation. We don't use 2017193326Sed // PushDeclContext because we don't have a scope. 2018207619Srdivacky ContextRAII SavedContext(*this, Instantiation); 2019208600Srdivacky EnterExpressionEvaluationContext EvalContext(*this, 2020212904Sdim Sema::PotentiallyEvaluated); 2021193326Sed 2022206084Srdivacky // If this is an instantiation of a local class, merge this local 2023206084Srdivacky // instantiation scope with the enclosing scope. Otherwise, every 2024206084Srdivacky // instantiation of a class has its own local instantiation scope. 2025206084Srdivacky bool MergeWithParentScope = !Instantiation->isDefinedOutsideFunctionOrMethod(); 2026212904Sdim LocalInstantiationScope Scope(*this, MergeWithParentScope); 2027206084Srdivacky 2028212904Sdim // Pull attributes from the pattern onto the instantiation. 2029212904Sdim InstantiateAttrs(TemplateArgs, Pattern, Instantiation); 2030212904Sdim 2031193326Sed // Start the definition of this instantiation. 2032193326Sed Instantiation->startDefinition(); 2033208600Srdivacky 2034208600Srdivacky Instantiation->setTagKind(Pattern->getTagKind()); 2035193326Sed 2036198092Srdivacky // Do substitution on the base class specifiers. 2037198092Srdivacky if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs)) 2038239462Sdim Instantiation->setInvalidDecl(); 2039193326Sed 2040218893Sdim TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs); 2041226633Sdim SmallVector<Decl*, 4> Fields; 2042226633Sdim SmallVector<std::pair<FieldDecl*, FieldDecl*>, 4> 2043223017Sdim FieldsWithMemberInitializers; 2044234353Sdim // Delay instantiation of late parsed attributes. 2045234353Sdim LateInstantiatedAttrVec LateAttrs; 2046234353Sdim Instantiator.enableLateAttributeInstantiation(&LateAttrs); 2047234353Sdim 2048195341Sed for (RecordDecl::decl_iterator Member = Pattern->decls_begin(), 2049198092Srdivacky MemberEnd = Pattern->decls_end(); 2050193326Sed Member != MemberEnd; ++Member) { 2051218893Sdim // Don't instantiate members not belonging in this semantic context. 2052218893Sdim // e.g. for: 2053218893Sdim // @code 2054218893Sdim // template <int i> class A { 2055218893Sdim // class B *g; 2056218893Sdim // }; 2057218893Sdim // @endcode 2058218893Sdim // 'class B' has the template as lexical context but semantically it is 2059218893Sdim // introduced in namespace scope. 2060218893Sdim if ((*Member)->getDeclContext() != Pattern) 2061218893Sdim continue; 2062218893Sdim 2063218893Sdim if ((*Member)->isInvalidDecl()) { 2064239462Sdim Instantiation->setInvalidDecl(); 2065218893Sdim continue; 2066218893Sdim } 2067218893Sdim 2068218893Sdim Decl *NewMember = Instantiator.Visit(*Member); 2069193326Sed if (NewMember) { 2070223017Sdim if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) { 2071212904Sdim Fields.push_back(Field); 2072223017Sdim FieldDecl *OldField = cast<FieldDecl>(*Member); 2073223017Sdim if (OldField->getInClassInitializer()) 2074223017Sdim FieldsWithMemberInitializers.push_back(std::make_pair(OldField, 2075223017Sdim Field)); 2076234353Sdim } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) { 2077234353Sdim // C++11 [temp.inst]p1: The implicit instantiation of a class template 2078234353Sdim // specialization causes the implicit instantiation of the definitions 2079234353Sdim // of unscoped member enumerations. 2080234353Sdim // Record a point of instantiation for this implicit instantiation. 2081234353Sdim if (TSK == TSK_ImplicitInstantiation && !Enum->isScoped() && 2082234353Sdim Enum->isCompleteDefinition()) { 2083234353Sdim MemberSpecializationInfo *MSInfo =Enum->getMemberSpecializationInfo(); 2084234353Sdim assert(MSInfo && "no spec info for member enum specialization"); 2085234353Sdim MSInfo->setTemplateSpecializationKind(TSK_ImplicitInstantiation); 2086234353Sdim MSInfo->setPointOfInstantiation(PointOfInstantiation); 2087234353Sdim } 2088239462Sdim } else if (StaticAssertDecl *SA = dyn_cast<StaticAssertDecl>(NewMember)) { 2089239462Sdim if (SA->isFailed()) { 2090239462Sdim // A static_assert failed. Bail out; instantiating this 2091239462Sdim // class is probably not meaningful. 2092239462Sdim Instantiation->setInvalidDecl(); 2093239462Sdim break; 2094239462Sdim } 2095234353Sdim } 2096234353Sdim 2097234353Sdim if (NewMember->isInvalidDecl()) 2098239462Sdim Instantiation->setInvalidDecl(); 2099193326Sed } else { 2100193326Sed // FIXME: Eventually, a NULL return will mean that one of the 2101239462Sdim // instantiations was a semantic disaster, and we'll want to mark the 2102239462Sdim // declaration invalid. 2103239462Sdim // For now, we expect to skip some members that we can't yet handle. 2104193326Sed } 2105193326Sed } 2106193326Sed 2107193326Sed // Finish checking fields. 2108226633Sdim ActOnFields(0, Instantiation->getLocation(), Instantiation, Fields, 2109226633Sdim SourceLocation(), SourceLocation(), 0); 2110210299Sed CheckCompletedCXXClass(Instantiation); 2111223017Sdim 2112223017Sdim // Attach any in-class member initializers now the class is complete. 2113249423Sdim // FIXME: We are supposed to defer instantiating these until they are needed. 2114239462Sdim if (!FieldsWithMemberInitializers.empty()) { 2115234982Sdim // C++11 [expr.prim.general]p4: 2116234982Sdim // Otherwise, if a member-declarator declares a non-static data member 2117234982Sdim // (9.2) of a class X, the expression this is a prvalue of type "pointer 2118234982Sdim // to X" within the optional brace-or-equal-initializer. It shall not 2119234982Sdim // appear elsewhere in the member-declarator. 2120234982Sdim CXXThisScopeRAII ThisScope(*this, Instantiation, (unsigned)0); 2121234982Sdim 2122234982Sdim for (unsigned I = 0, N = FieldsWithMemberInitializers.size(); I != N; ++I) { 2123234982Sdim FieldDecl *OldField = FieldsWithMemberInitializers[I].first; 2124234982Sdim FieldDecl *NewField = FieldsWithMemberInitializers[I].second; 2125234982Sdim Expr *OldInit = OldField->getInClassInitializer(); 2126223017Sdim 2127234982Sdim ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs, 2128234982Sdim /*CXXDirectInit=*/false); 2129234982Sdim if (NewInit.isInvalid()) 2130234982Sdim NewField->setInvalidDecl(); 2131234982Sdim else { 2132234982Sdim Expr *Init = NewInit.take(); 2133234982Sdim assert(Init && "no-argument initializer in class"); 2134234982Sdim assert(!isa<ParenListExpr>(Init) && "call-style init in class"); 2135239462Sdim ActOnCXXInClassMemberInitializer(NewField, Init->getLocStart(), Init); 2136234982Sdim } 2137223017Sdim } 2138223017Sdim } 2139234353Sdim // Instantiate late parsed attributes, and attach them to their decls. 2140234353Sdim // See Sema::InstantiateAttrs 2141234353Sdim for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(), 2142234353Sdim E = LateAttrs.end(); I != E; ++I) { 2143234353Sdim assert(CurrentInstantiationScope == Instantiator.getStartingScope()); 2144234353Sdim CurrentInstantiationScope = I->Scope; 2145263508Sdim 2146263508Sdim // Allow 'this' within late-parsed attributes. 2147263508Sdim NamedDecl *ND = dyn_cast<NamedDecl>(I->NewDecl); 2148263508Sdim CXXRecordDecl *ThisContext = 2149263508Sdim dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()); 2150263508Sdim CXXThisScopeRAII ThisScope(*this, ThisContext, /*TypeQuals*/0, 2151263508Sdim ND && ND->isCXXInstanceMember()); 2152263508Sdim 2153234353Sdim Attr *NewAttr = 2154234353Sdim instantiateTemplateAttribute(I->TmplAttr, Context, *this, TemplateArgs); 2155234353Sdim I->NewDecl->addAttr(NewAttr); 2156234353Sdim LocalInstantiationScope::deleteScopes(I->Scope, 2157234353Sdim Instantiator.getStartingScope()); 2158234353Sdim } 2159234353Sdim Instantiator.disableLateAttributeInstantiation(); 2160234353Sdim LateAttrs.clear(); 2161234353Sdim 2162239462Sdim ActOnFinishDelayedMemberInitializers(Instantiation); 2163223017Sdim 2164234353Sdim if (TSK == TSK_ImplicitInstantiation) { 2165234353Sdim Instantiation->setLocation(Pattern->getLocation()); 2166234353Sdim Instantiation->setLocStart(Pattern->getInnerLocStart()); 2167226633Sdim Instantiation->setRBraceLoc(Pattern->getRBraceLoc()); 2168234353Sdim } 2169226633Sdim 2170239462Sdim if (!Instantiation->isInvalidDecl()) { 2171239462Sdim // Perform any dependent diagnostics from the pattern. 2172239462Sdim PerformDependentDiagnostics(Pattern, TemplateArgs); 2173239462Sdim 2174218893Sdim // Instantiate any out-of-line class template partial 2175218893Sdim // specializations now. 2176263508Sdim for (TemplateDeclInstantiator::delayed_partial_spec_iterator 2177218893Sdim P = Instantiator.delayed_partial_spec_begin(), 2178218893Sdim PEnd = Instantiator.delayed_partial_spec_end(); 2179218893Sdim P != PEnd; ++P) { 2180218893Sdim if (!Instantiator.InstantiateClassTemplatePartialSpecialization( 2181263508Sdim P->first, P->second)) { 2182239462Sdim Instantiation->setInvalidDecl(); 2183218893Sdim break; 2184218893Sdim } 2185218893Sdim } 2186263508Sdim 2187263508Sdim // Instantiate any out-of-line variable template partial 2188263508Sdim // specializations now. 2189263508Sdim for (TemplateDeclInstantiator::delayed_var_partial_spec_iterator 2190263508Sdim P = Instantiator.delayed_var_partial_spec_begin(), 2191263508Sdim PEnd = Instantiator.delayed_var_partial_spec_end(); 2192263508Sdim P != PEnd; ++P) { 2193263508Sdim if (!Instantiator.InstantiateVarTemplatePartialSpecialization( 2194263508Sdim P->first, P->second)) { 2195263508Sdim Instantiation->setInvalidDecl(); 2196263508Sdim break; 2197263508Sdim } 2198263508Sdim } 2199218893Sdim } 2200218893Sdim 2201193326Sed // Exit the scope of this instantiation. 2202207619Srdivacky SavedContext.pop(); 2203193326Sed 2204239462Sdim if (!Instantiation->isInvalidDecl()) { 2205208600Srdivacky Consumer.HandleTagDeclDefinition(Instantiation); 2206208600Srdivacky 2207208600Srdivacky // Always emit the vtable for an explicit instantiation definition 2208208600Srdivacky // of a polymorphic class template specialization. 2209208600Srdivacky if (TSK == TSK_ExplicitInstantiationDefinition) 2210208600Srdivacky MarkVTableUsed(PointOfInstantiation, Instantiation, true); 2211203955Srdivacky } 2212202379Srdivacky 2213239462Sdim return Instantiation->isInvalidDecl(); 2214193326Sed} 2215193326Sed 2216234353Sdim/// \brief Instantiate the definition of an enum from a given pattern. 2217234353Sdim/// 2218234353Sdim/// \param PointOfInstantiation The point of instantiation within the 2219234353Sdim/// source code. 2220234353Sdim/// \param Instantiation is the declaration whose definition is being 2221234353Sdim/// instantiated. This will be a member enumeration of a class 2222234353Sdim/// temploid specialization, or a local enumeration within a 2223234353Sdim/// function temploid specialization. 2224234353Sdim/// \param Pattern The templated declaration from which the instantiation 2225234353Sdim/// occurs. 2226234353Sdim/// \param TemplateArgs The template arguments to be substituted into 2227234353Sdim/// the pattern. 2228234353Sdim/// \param TSK The kind of implicit or explicit instantiation to perform. 2229234353Sdim/// 2230234353Sdim/// \return \c true if an error occurred, \c false otherwise. 2231234353Sdimbool Sema::InstantiateEnum(SourceLocation PointOfInstantiation, 2232234353Sdim EnumDecl *Instantiation, EnumDecl *Pattern, 2233234353Sdim const MultiLevelTemplateArgumentList &TemplateArgs, 2234234353Sdim TemplateSpecializationKind TSK) { 2235234353Sdim EnumDecl *PatternDef = Pattern->getDefinition(); 2236234353Sdim if (DiagnoseUninstantiableTemplate(*this, PointOfInstantiation, Instantiation, 2237234353Sdim Instantiation->getInstantiatedFromMemberEnum(), 2238234353Sdim Pattern, PatternDef, TSK,/*Complain*/true)) 2239234353Sdim return true; 2240234353Sdim Pattern = PatternDef; 2241234353Sdim 2242234353Sdim // Record the point of instantiation. 2243234353Sdim if (MemberSpecializationInfo *MSInfo 2244234353Sdim = Instantiation->getMemberSpecializationInfo()) { 2245234353Sdim MSInfo->setTemplateSpecializationKind(TSK); 2246234353Sdim MSInfo->setPointOfInstantiation(PointOfInstantiation); 2247234353Sdim } 2248234353Sdim 2249234353Sdim InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation); 2250263508Sdim if (Inst.isInvalid()) 2251234353Sdim return true; 2252234353Sdim 2253234353Sdim // Enter the scope of this instantiation. We don't use 2254234353Sdim // PushDeclContext because we don't have a scope. 2255234353Sdim ContextRAII SavedContext(*this, Instantiation); 2256234353Sdim EnterExpressionEvaluationContext EvalContext(*this, 2257234353Sdim Sema::PotentiallyEvaluated); 2258234353Sdim 2259234353Sdim LocalInstantiationScope Scope(*this, /*MergeWithParentScope*/true); 2260234353Sdim 2261234353Sdim // Pull attributes from the pattern onto the instantiation. 2262234353Sdim InstantiateAttrs(TemplateArgs, Pattern, Instantiation); 2263234353Sdim 2264234353Sdim TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs); 2265234353Sdim Instantiator.InstantiateEnumDefinition(Instantiation, Pattern); 2266234353Sdim 2267234353Sdim // Exit the scope of this instantiation. 2268234353Sdim SavedContext.pop(); 2269234353Sdim 2270234353Sdim return Instantiation->isInvalidDecl(); 2271234353Sdim} 2272234353Sdim 2273218893Sdimnamespace { 2274218893Sdim /// \brief A partial specialization whose template arguments have matched 2275218893Sdim /// a given template-id. 2276218893Sdim struct PartialSpecMatchResult { 2277218893Sdim ClassTemplatePartialSpecializationDecl *Partial; 2278218893Sdim TemplateArgumentList *Args; 2279218893Sdim }; 2280218893Sdim} 2281218893Sdim 2282263508Sdimbool Sema::InstantiateClassTemplateSpecialization( 2283263508Sdim SourceLocation PointOfInstantiation, 2284263508Sdim ClassTemplateSpecializationDecl *ClassTemplateSpec, 2285263508Sdim TemplateSpecializationKind TSK, bool Complain) { 2286193326Sed // Perform the actual instantiation on the canonical declaration. 2287193326Sed ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>( 2288198092Srdivacky ClassTemplateSpec->getCanonicalDecl()); 2289193326Sed 2290198092Srdivacky // Check whether we have already instantiated or specialized this class 2291198092Srdivacky // template specialization. 2292198092Srdivacky if (ClassTemplateSpec->getSpecializationKind() != TSK_Undeclared) { 2293198092Srdivacky if (ClassTemplateSpec->getSpecializationKind() == 2294198092Srdivacky TSK_ExplicitInstantiationDeclaration && 2295198092Srdivacky TSK == TSK_ExplicitInstantiationDefinition) { 2296198092Srdivacky // An explicit instantiation definition follows an explicit instantiation 2297198092Srdivacky // declaration (C++0x [temp.explicit]p10); go ahead and perform the 2298198092Srdivacky // explicit instantiation. 2299198092Srdivacky ClassTemplateSpec->setSpecializationKind(TSK); 2300208600Srdivacky 2301208600Srdivacky // If this is an explicit instantiation definition, mark the 2302208600Srdivacky // vtable as used. 2303234353Sdim if (TSK == TSK_ExplicitInstantiationDefinition && 2304234353Sdim !ClassTemplateSpec->isInvalidDecl()) 2305208600Srdivacky MarkVTableUsed(PointOfInstantiation, ClassTemplateSpec, true); 2306208600Srdivacky 2307198092Srdivacky return false; 2308198092Srdivacky } 2309198092Srdivacky 2310198092Srdivacky // We can only instantiate something that hasn't already been 2311198092Srdivacky // instantiated or specialized. Fail without any diagnostics: our 2312198092Srdivacky // caller will provide an error message. 2313193326Sed return true; 2314198092Srdivacky } 2315193326Sed 2316198092Srdivacky if (ClassTemplateSpec->isInvalidDecl()) 2317198092Srdivacky return true; 2318198092Srdivacky 2319193326Sed ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate(); 2320198092Srdivacky CXXRecordDecl *Pattern = 0; 2321193326Sed 2322194179Sed // C++ [temp.class.spec.match]p1: 2323194179Sed // When a class template is used in a context that requires an 2324194179Sed // instantiation of the class, it is necessary to determine 2325194179Sed // whether the instantiation is to be generated using the primary 2326194179Sed // template or one of the partial specializations. This is done by 2327194179Sed // matching the template arguments of the class template 2328194179Sed // specialization with the template argument lists of the partial 2329194179Sed // specializations. 2330218893Sdim typedef PartialSpecMatchResult MatchResult; 2331226633Sdim SmallVector<MatchResult, 4> Matched; 2332226633Sdim SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs; 2333207619Srdivacky Template->getPartialSpecializations(PartialSpecs); 2334263508Sdim TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation); 2335207619Srdivacky for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) { 2336207619Srdivacky ClassTemplatePartialSpecializationDecl *Partial = PartialSpecs[I]; 2337263508Sdim TemplateDeductionInfo Info(FailedCandidates.getLocation()); 2338194179Sed if (TemplateDeductionResult Result 2339207619Srdivacky = DeduceTemplateArguments(Partial, 2340194179Sed ClassTemplateSpec->getTemplateArgs(), 2341194179Sed Info)) { 2342263508Sdim // Store the failed-deduction information for use in diagnostics, later. 2343263508Sdim // TODO: Actually use the failed-deduction info? 2344263508Sdim FailedCandidates.addCandidate() 2345263508Sdim .set(Partial, MakeDeductionFailureInfo(Context, Result, Info)); 2346194179Sed (void)Result; 2347194179Sed } else { 2348218893Sdim Matched.push_back(PartialSpecMatchResult()); 2349218893Sdim Matched.back().Partial = Partial; 2350218893Sdim Matched.back().Args = Info.take(); 2351194179Sed } 2352193326Sed } 2353193326Sed 2354218893Sdim // If we're dealing with a member template where the template parameters 2355218893Sdim // have been instantiated, this provides the original template parameters 2356218893Sdim // from which the member template's parameters were instantiated. 2357226633Sdim SmallVector<const NamedDecl *, 4> InstantiatedTemplateParameters; 2358218893Sdim 2359198893Srdivacky if (Matched.size() >= 1) { 2360263508Sdim SmallVectorImpl<MatchResult>::iterator Best = Matched.begin(); 2361198893Srdivacky if (Matched.size() == 1) { 2362198893Srdivacky // -- If exactly one matching specialization is found, the 2363198893Srdivacky // instantiation is generated from that specialization. 2364198893Srdivacky // We don't need to do anything for this. 2365198893Srdivacky } else { 2366198893Srdivacky // -- If more than one matching specialization is found, the 2367198893Srdivacky // partial order rules (14.5.4.2) are used to determine 2368198893Srdivacky // whether one of the specializations is more specialized 2369198893Srdivacky // than the others. If none of the specializations is more 2370198893Srdivacky // specialized than all of the other matching 2371198893Srdivacky // specializations, then the use of the class template is 2372198893Srdivacky // ambiguous and the program is ill-formed. 2373263508Sdim for (SmallVectorImpl<MatchResult>::iterator P = Best + 1, 2374263508Sdim PEnd = Matched.end(); 2375198893Srdivacky P != PEnd; ++P) { 2376218893Sdim if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial, 2377203955Srdivacky PointOfInstantiation) 2378218893Sdim == P->Partial) 2379198893Srdivacky Best = P; 2380198092Srdivacky } 2381198092Srdivacky 2382198893Srdivacky // Determine if the best partial specialization is more specialized than 2383198893Srdivacky // the others. 2384198893Srdivacky bool Ambiguous = false; 2385263508Sdim for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(), 2386263508Sdim PEnd = Matched.end(); 2387198893Srdivacky P != PEnd; ++P) { 2388198893Srdivacky if (P != Best && 2389218893Sdim getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial, 2390203955Srdivacky PointOfInstantiation) 2391218893Sdim != Best->Partial) { 2392198893Srdivacky Ambiguous = true; 2393198893Srdivacky break; 2394198893Srdivacky } 2395198893Srdivacky } 2396198893Srdivacky 2397198893Srdivacky if (Ambiguous) { 2398198893Srdivacky // Partial ordering did not produce a clear winner. Complain. 2399198893Srdivacky ClassTemplateSpec->setInvalidDecl(); 2400198893Srdivacky Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous) 2401198893Srdivacky << ClassTemplateSpec; 2402198893Srdivacky 2403198893Srdivacky // Print the matching partial specializations. 2404263508Sdim for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(), 2405263508Sdim PEnd = Matched.end(); 2406198893Srdivacky P != PEnd; ++P) 2407218893Sdim Diag(P->Partial->getLocation(), diag::note_partial_spec_match) 2408218893Sdim << getTemplateArgumentBindingsText( 2409218893Sdim P->Partial->getTemplateParameters(), 2410218893Sdim *P->Args); 2411198092Srdivacky 2412198893Srdivacky return true; 2413198893Srdivacky } 2414198092Srdivacky } 2415198092Srdivacky 2416198092Srdivacky // Instantiate using the best class template partial specialization. 2417218893Sdim ClassTemplatePartialSpecializationDecl *OrigPartialSpec = Best->Partial; 2418198893Srdivacky while (OrigPartialSpec->getInstantiatedFromMember()) { 2419198893Srdivacky // If we've found an explicit specialization of this class template, 2420198893Srdivacky // stop here and use that as the pattern. 2421198893Srdivacky if (OrigPartialSpec->isMemberSpecialization()) 2422198893Srdivacky break; 2423198893Srdivacky 2424198893Srdivacky OrigPartialSpec = OrigPartialSpec->getInstantiatedFromMember(); 2425198893Srdivacky } 2426198893Srdivacky 2427198893Srdivacky Pattern = OrigPartialSpec; 2428218893Sdim ClassTemplateSpec->setInstantiationOf(Best->Partial, Best->Args); 2429194179Sed } else { 2430194179Sed // -- If no matches are found, the instantiation is generated 2431194179Sed // from the primary template. 2432198092Srdivacky ClassTemplateDecl *OrigTemplate = Template; 2433198092Srdivacky while (OrigTemplate->getInstantiatedFromMemberTemplate()) { 2434198092Srdivacky // If we've found an explicit specialization of this class template, 2435198092Srdivacky // stop here and use that as the pattern. 2436198092Srdivacky if (OrigTemplate->isMemberSpecialization()) 2437198092Srdivacky break; 2438198092Srdivacky 2439198092Srdivacky OrigTemplate = OrigTemplate->getInstantiatedFromMemberTemplate(); 2440198092Srdivacky } 2441198092Srdivacky 2442198092Srdivacky Pattern = OrigTemplate->getTemplatedDecl(); 2443193326Sed } 2444193326Sed 2445198893Srdivacky bool Result = InstantiateClass(PointOfInstantiation, ClassTemplateSpec, 2446198893Srdivacky Pattern, 2447198893Srdivacky getTemplateInstantiationArgs(ClassTemplateSpec), 2448198092Srdivacky TSK, 2449198092Srdivacky Complain); 2450198092Srdivacky 2451193576Sed return Result; 2452193326Sed} 2453193326Sed 2454198092Srdivacky/// \brief Instantiates the definitions of all of the member 2455198092Srdivacky/// of the given class, which is an instantiation of a class template 2456198092Srdivacky/// or a member class of a template. 2457193326Sedvoid 2458193326SedSema::InstantiateClassMembers(SourceLocation PointOfInstantiation, 2459193326Sed CXXRecordDecl *Instantiation, 2460198092Srdivacky const MultiLevelTemplateArgumentList &TemplateArgs, 2461198092Srdivacky TemplateSpecializationKind TSK) { 2462263508Sdim assert( 2463263508Sdim (TSK == TSK_ExplicitInstantiationDefinition || 2464263508Sdim TSK == TSK_ExplicitInstantiationDeclaration || 2465263508Sdim (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && 2466263508Sdim "Unexpected template specialization kind!"); 2467195341Sed for (DeclContext::decl_iterator D = Instantiation->decls_begin(), 2468195341Sed DEnd = Instantiation->decls_end(); 2469193326Sed D != DEnd; ++D) { 2470198893Srdivacky bool SuppressNew = false; 2471193326Sed if (FunctionDecl *Function = dyn_cast<FunctionDecl>(*D)) { 2472198893Srdivacky if (FunctionDecl *Pattern 2473198893Srdivacky = Function->getInstantiatedFromMemberFunction()) { 2474198893Srdivacky MemberSpecializationInfo *MSInfo 2475198893Srdivacky = Function->getMemberSpecializationInfo(); 2476198893Srdivacky assert(MSInfo && "No member specialization information?"); 2477207619Srdivacky if (MSInfo->getTemplateSpecializationKind() 2478207619Srdivacky == TSK_ExplicitSpecialization) 2479207619Srdivacky continue; 2480207619Srdivacky 2481198893Srdivacky if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK, 2482198893Srdivacky Function, 2483198893Srdivacky MSInfo->getTemplateSpecializationKind(), 2484218893Sdim MSInfo->getPointOfInstantiation(), 2485198893Srdivacky SuppressNew) || 2486198893Srdivacky SuppressNew) 2487198092Srdivacky continue; 2488198092Srdivacky 2489223017Sdim if (Function->isDefined()) 2490198893Srdivacky continue; 2491198893Srdivacky 2492198893Srdivacky if (TSK == TSK_ExplicitInstantiationDefinition) { 2493198893Srdivacky // C++0x [temp.explicit]p8: 2494198893Srdivacky // An explicit instantiation definition that names a class template 2495198893Srdivacky // specialization explicitly instantiates the class template 2496198893Srdivacky // specialization and is only an explicit instantiation definition 2497198893Srdivacky // of members whose definition is visible at the point of 2498198893Srdivacky // instantiation. 2499223017Sdim if (!Pattern->isDefined()) 2500198893Srdivacky continue; 2501198893Srdivacky 2502198893Srdivacky Function->setTemplateSpecializationKind(TSK, PointOfInstantiation); 2503198893Srdivacky 2504198893Srdivacky InstantiateFunctionDefinition(PointOfInstantiation, Function); 2505198893Srdivacky } else { 2506198893Srdivacky Function->setTemplateSpecializationKind(TSK, PointOfInstantiation); 2507263508Sdim if (TSK == TSK_ImplicitInstantiation) 2508263508Sdim PendingLocalImplicitInstantiations.push_back( 2509263508Sdim std::make_pair(Function, PointOfInstantiation)); 2510198893Srdivacky } 2511198092Srdivacky } 2512193326Sed } else if (VarDecl *Var = dyn_cast<VarDecl>(*D)) { 2513263508Sdim if (isa<VarTemplateSpecializationDecl>(Var)) 2514263508Sdim continue; 2515263508Sdim 2516198092Srdivacky if (Var->isStaticDataMember()) { 2517198893Srdivacky MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo(); 2518198893Srdivacky assert(MSInfo && "No member specialization information?"); 2519207619Srdivacky if (MSInfo->getTemplateSpecializationKind() 2520207619Srdivacky == TSK_ExplicitSpecialization) 2521207619Srdivacky continue; 2522207619Srdivacky 2523198893Srdivacky if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK, 2524198893Srdivacky Var, 2525198893Srdivacky MSInfo->getTemplateSpecializationKind(), 2526218893Sdim MSInfo->getPointOfInstantiation(), 2527198893Srdivacky SuppressNew) || 2528198893Srdivacky SuppressNew) 2529198092Srdivacky continue; 2530198092Srdivacky 2531198893Srdivacky if (TSK == TSK_ExplicitInstantiationDefinition) { 2532198893Srdivacky // C++0x [temp.explicit]p8: 2533198893Srdivacky // An explicit instantiation definition that names a class template 2534198893Srdivacky // specialization explicitly instantiates the class template 2535198893Srdivacky // specialization and is only an explicit instantiation definition 2536198893Srdivacky // of members whose definition is visible at the point of 2537198893Srdivacky // instantiation. 2538198893Srdivacky if (!Var->getInstantiatedFromStaticDataMember() 2539198893Srdivacky ->getOutOfLineDefinition()) 2540198893Srdivacky continue; 2541198893Srdivacky 2542198893Srdivacky Var->setTemplateSpecializationKind(TSK, PointOfInstantiation); 2543198092Srdivacky InstantiateStaticDataMemberDefinition(PointOfInstantiation, Var); 2544198893Srdivacky } else { 2545198893Srdivacky Var->setTemplateSpecializationKind(TSK, PointOfInstantiation); 2546198893Srdivacky } 2547198893Srdivacky } 2548193326Sed } else if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(*D)) { 2549207619Srdivacky // Always skip the injected-class-name, along with any 2550207619Srdivacky // redeclarations of nested classes, since both would cause us 2551207619Srdivacky // to try to instantiate the members of a class twice. 2552234353Sdim if (Record->isInjectedClassName() || Record->getPreviousDecl()) 2553198092Srdivacky continue; 2554198092Srdivacky 2555198893Srdivacky MemberSpecializationInfo *MSInfo = Record->getMemberSpecializationInfo(); 2556198893Srdivacky assert(MSInfo && "No member specialization information?"); 2557207619Srdivacky 2558207619Srdivacky if (MSInfo->getTemplateSpecializationKind() 2559207619Srdivacky == TSK_ExplicitSpecialization) 2560207619Srdivacky continue; 2561218893Sdim 2562198893Srdivacky if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK, 2563198893Srdivacky Record, 2564198893Srdivacky MSInfo->getTemplateSpecializationKind(), 2565218893Sdim MSInfo->getPointOfInstantiation(), 2566198893Srdivacky SuppressNew) || 2567198893Srdivacky SuppressNew) 2568198092Srdivacky continue; 2569198092Srdivacky 2570198893Srdivacky CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass(); 2571198893Srdivacky assert(Pattern && "Missing instantiated-from-template information"); 2572198893Srdivacky 2573203955Srdivacky if (!Record->getDefinition()) { 2574203955Srdivacky if (!Pattern->getDefinition()) { 2575198893Srdivacky // C++0x [temp.explicit]p8: 2576198893Srdivacky // An explicit instantiation definition that names a class template 2577198893Srdivacky // specialization explicitly instantiates the class template 2578198893Srdivacky // specialization and is only an explicit instantiation definition 2579198893Srdivacky // of members whose definition is visible at the point of 2580198893Srdivacky // instantiation. 2581198893Srdivacky if (TSK == TSK_ExplicitInstantiationDeclaration) { 2582198893Srdivacky MSInfo->setTemplateSpecializationKind(TSK); 2583198893Srdivacky MSInfo->setPointOfInstantiation(PointOfInstantiation); 2584198893Srdivacky } 2585198893Srdivacky 2586198893Srdivacky continue; 2587198893Srdivacky } 2588198893Srdivacky 2589198893Srdivacky InstantiateClass(PointOfInstantiation, Record, Pattern, 2590198092Srdivacky TemplateArgs, 2591198092Srdivacky TSK); 2592218893Sdim } else { 2593218893Sdim if (TSK == TSK_ExplicitInstantiationDefinition && 2594218893Sdim Record->getTemplateSpecializationKind() == 2595218893Sdim TSK_ExplicitInstantiationDeclaration) { 2596218893Sdim Record->setTemplateSpecializationKind(TSK); 2597218893Sdim MarkVTableUsed(PointOfInstantiation, Record, true); 2598218893Sdim } 2599198893Srdivacky } 2600198092Srdivacky 2601203955Srdivacky Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition()); 2602198893Srdivacky if (Pattern) 2603198893Srdivacky InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs, 2604198893Srdivacky TSK); 2605234353Sdim } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(*D)) { 2606234353Sdim MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo(); 2607234353Sdim assert(MSInfo && "No member specialization information?"); 2608234353Sdim 2609234353Sdim if (MSInfo->getTemplateSpecializationKind() 2610234353Sdim == TSK_ExplicitSpecialization) 2611234353Sdim continue; 2612234353Sdim 2613234353Sdim if (CheckSpecializationInstantiationRedecl( 2614234353Sdim PointOfInstantiation, TSK, Enum, 2615234353Sdim MSInfo->getTemplateSpecializationKind(), 2616234353Sdim MSInfo->getPointOfInstantiation(), SuppressNew) || 2617234353Sdim SuppressNew) 2618234353Sdim continue; 2619234353Sdim 2620234353Sdim if (Enum->getDefinition()) 2621234353Sdim continue; 2622234353Sdim 2623234353Sdim EnumDecl *Pattern = Enum->getInstantiatedFromMemberEnum(); 2624234353Sdim assert(Pattern && "Missing instantiated-from-template information"); 2625234353Sdim 2626234353Sdim if (TSK == TSK_ExplicitInstantiationDefinition) { 2627234353Sdim if (!Pattern->getDefinition()) 2628234353Sdim continue; 2629234353Sdim 2630234353Sdim InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK); 2631234353Sdim } else { 2632234353Sdim MSInfo->setTemplateSpecializationKind(TSK); 2633234353Sdim MSInfo->setPointOfInstantiation(PointOfInstantiation); 2634234353Sdim } 2635193326Sed } 2636193326Sed } 2637193326Sed} 2638193326Sed 2639193326Sed/// \brief Instantiate the definitions of all of the members of the 2640193326Sed/// given class template specialization, which was named as part of an 2641193326Sed/// explicit instantiation. 2642198092Srdivackyvoid 2643198092SrdivackySema::InstantiateClassTemplateSpecializationMembers( 2644193326Sed SourceLocation PointOfInstantiation, 2645198092Srdivacky ClassTemplateSpecializationDecl *ClassTemplateSpec, 2646198092Srdivacky TemplateSpecializationKind TSK) { 2647193326Sed // C++0x [temp.explicit]p7: 2648193326Sed // An explicit instantiation that names a class template 2649193326Sed // specialization is an explicit instantion of the same kind 2650193326Sed // (declaration or definition) of each of its members (not 2651193326Sed // including members inherited from base classes) that has not 2652193326Sed // been previously explicitly specialized in the translation unit 2653193326Sed // containing the explicit instantiation, except as described 2654193326Sed // below. 2655193326Sed InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec, 2656198092Srdivacky getTemplateInstantiationArgs(ClassTemplateSpec), 2657198092Srdivacky TSK); 2658193326Sed} 2659193326Sed 2660212904SdimStmtResult 2661198092SrdivackySema::SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs) { 2662198092Srdivacky if (!S) 2663198092Srdivacky return Owned(S); 2664193326Sed 2665198092Srdivacky TemplateInstantiator Instantiator(*this, TemplateArgs, 2666198092Srdivacky SourceLocation(), 2667198092Srdivacky DeclarationName()); 2668198092Srdivacky return Instantiator.TransformStmt(S); 2669198092Srdivacky} 2670193326Sed 2671212904SdimExprResult 2672198092SrdivackySema::SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs) { 2673198092Srdivacky if (!E) 2674198092Srdivacky return Owned(E); 2675193326Sed 2676198092Srdivacky TemplateInstantiator Instantiator(*this, TemplateArgs, 2677198092Srdivacky SourceLocation(), 2678198092Srdivacky DeclarationName()); 2679198092Srdivacky return Instantiator.TransformExpr(E); 2680198092Srdivacky} 2681193326Sed 2682249423SdimExprResult Sema::SubstInitializer(Expr *Init, 2683249423Sdim const MultiLevelTemplateArgumentList &TemplateArgs, 2684249423Sdim bool CXXDirectInit) { 2685249423Sdim TemplateInstantiator Instantiator(*this, TemplateArgs, 2686249423Sdim SourceLocation(), 2687249423Sdim DeclarationName()); 2688249423Sdim return Instantiator.TransformInitializer(Init, CXXDirectInit); 2689249423Sdim} 2690249423Sdim 2691218893Sdimbool Sema::SubstExprs(Expr **Exprs, unsigned NumExprs, bool IsCall, 2692218893Sdim const MultiLevelTemplateArgumentList &TemplateArgs, 2693226633Sdim SmallVectorImpl<Expr *> &Outputs) { 2694218893Sdim if (NumExprs == 0) 2695218893Sdim return false; 2696249423Sdim 2697218893Sdim TemplateInstantiator Instantiator(*this, TemplateArgs, 2698218893Sdim SourceLocation(), 2699218893Sdim DeclarationName()); 2700218893Sdim return Instantiator.TransformExprs(Exprs, NumExprs, IsCall, Outputs); 2701218893Sdim} 2702218893Sdim 2703219077SdimNestedNameSpecifierLoc 2704219077SdimSema::SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, 2705219077Sdim const MultiLevelTemplateArgumentList &TemplateArgs) { 2706219077Sdim if (!NNS) 2707219077Sdim return NestedNameSpecifierLoc(); 2708219077Sdim 2709219077Sdim TemplateInstantiator Instantiator(*this, TemplateArgs, NNS.getBeginLoc(), 2710219077Sdim DeclarationName()); 2711219077Sdim return Instantiator.TransformNestedNameSpecifierLoc(NNS); 2712219077Sdim} 2713219077Sdim 2714212904Sdim/// \brief Do template substitution on declaration name info. 2715212904SdimDeclarationNameInfo 2716212904SdimSema::SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, 2717212904Sdim const MultiLevelTemplateArgumentList &TemplateArgs) { 2718212904Sdim TemplateInstantiator Instantiator(*this, TemplateArgs, NameInfo.getLoc(), 2719212904Sdim NameInfo.getName()); 2720212904Sdim return Instantiator.TransformDeclarationNameInfo(NameInfo); 2721212904Sdim} 2722212904Sdim 2723193326SedTemplateName 2724221345SdimSema::SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, 2725221345Sdim TemplateName Name, SourceLocation Loc, 2726198092Srdivacky const MultiLevelTemplateArgumentList &TemplateArgs) { 2727198092Srdivacky TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, 2728198092Srdivacky DeclarationName()); 2729221345Sdim CXXScopeSpec SS; 2730221345Sdim SS.Adopt(QualifierLoc); 2731221345Sdim return Instantiator.TransformTemplateName(SS, Name, Loc); 2732193326Sed} 2733194179Sed 2734218893Sdimbool Sema::Subst(const TemplateArgumentLoc *Args, unsigned NumArgs, 2735218893Sdim TemplateArgumentListInfo &Result, 2736198893Srdivacky const MultiLevelTemplateArgumentList &TemplateArgs) { 2737198092Srdivacky TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(), 2738198092Srdivacky DeclarationName()); 2739218893Sdim 2740218893Sdim return Instantiator.TransformTemplateArguments(Args, NumArgs, Result); 2741194179Sed} 2742207619Srdivacky 2743243830Sdim 2744243830Sdimstatic const Decl* getCanonicalParmVarDecl(const Decl *D) { 2745243830Sdim // When storing ParmVarDecls in the local instantiation scope, we always 2746243830Sdim // want to use the ParmVarDecl from the canonical function declaration, 2747243830Sdim // since the map is then valid for any redeclaration or definition of that 2748243830Sdim // function. 2749243830Sdim if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) { 2750243830Sdim if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) { 2751243830Sdim unsigned i = PV->getFunctionScopeIndex(); 2752243830Sdim return FD->getCanonicalDecl()->getParamDecl(i); 2753243830Sdim } 2754243830Sdim } 2755243830Sdim return D; 2756243830Sdim} 2757243830Sdim 2758243830Sdim 2759218893Sdimllvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> * 2760218893SdimLocalInstantiationScope::findInstantiationOf(const Decl *D) { 2761243830Sdim D = getCanonicalParmVarDecl(D); 2762218893Sdim for (LocalInstantiationScope *Current = this; Current; 2763207619Srdivacky Current = Current->Outer) { 2764218893Sdim 2765207619Srdivacky // Check if we found something within this scope. 2766218893Sdim const Decl *CheckD = D; 2767218893Sdim do { 2768218893Sdim LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD); 2769218893Sdim if (Found != Current->LocalDecls.end()) 2770218893Sdim return &Found->second; 2771218893Sdim 2772218893Sdim // If this is a tag declaration, it's possible that we need to look for 2773218893Sdim // a previous declaration. 2774218893Sdim if (const TagDecl *Tag = dyn_cast<TagDecl>(CheckD)) 2775234353Sdim CheckD = Tag->getPreviousDecl(); 2776218893Sdim else 2777218893Sdim CheckD = 0; 2778218893Sdim } while (CheckD); 2779218893Sdim 2780207619Srdivacky // If we aren't combined with our outer scope, we're done. 2781207619Srdivacky if (!Current->CombineWithOuterScope) 2782207619Srdivacky break; 2783207619Srdivacky } 2784218893Sdim 2785263508Sdim // If we're performing a partial substitution during template argument 2786263508Sdim // deduction, we may not have values for template parameters yet. 2787263508Sdim if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) || 2788263508Sdim isa<TemplateTemplateParmDecl>(D)) 2789263508Sdim return 0; 2790263508Sdim 2791218893Sdim // If we didn't find the decl, then we either have a sema bug, or we have a 2792218893Sdim // forward reference to a label declaration. Return null to indicate that 2793218893Sdim // we have an uninstantiated label. 2794218893Sdim assert(isa<LabelDecl>(D) && "declaration not instantiated in this scope"); 2795207619Srdivacky return 0; 2796207619Srdivacky} 2797207619Srdivacky 2798212904Sdimvoid LocalInstantiationScope::InstantiatedLocal(const Decl *D, Decl *Inst) { 2799243830Sdim D = getCanonicalParmVarDecl(D); 2800218893Sdim llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D]; 2801218893Sdim if (Stored.isNull()) 2802218893Sdim Stored = Inst; 2803251662Sdim else if (DeclArgumentPack *Pack = Stored.dyn_cast<DeclArgumentPack *>()) 2804251662Sdim Pack->push_back(Inst); 2805251662Sdim else 2806218893Sdim assert(Stored.get<Decl *>() == Inst && "Already instantiated this local"); 2807207619Srdivacky} 2808218893Sdim 2809218893Sdimvoid LocalInstantiationScope::InstantiatedLocalPackArg(const Decl *D, 2810218893Sdim Decl *Inst) { 2811243830Sdim D = getCanonicalParmVarDecl(D); 2812218893Sdim DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>(); 2813218893Sdim Pack->push_back(Inst); 2814218893Sdim} 2815218893Sdim 2816218893Sdimvoid LocalInstantiationScope::MakeInstantiatedLocalArgPack(const Decl *D) { 2817243830Sdim D = getCanonicalParmVarDecl(D); 2818218893Sdim llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D]; 2819218893Sdim assert(Stored.isNull() && "Already instantiated this local"); 2820218893Sdim DeclArgumentPack *Pack = new DeclArgumentPack; 2821218893Sdim Stored = Pack; 2822218893Sdim ArgumentPacks.push_back(Pack); 2823218893Sdim} 2824218893Sdim 2825218893Sdimvoid LocalInstantiationScope::SetPartiallySubstitutedPack(NamedDecl *Pack, 2826218893Sdim const TemplateArgument *ExplicitArgs, 2827218893Sdim unsigned NumExplicitArgs) { 2828218893Sdim assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && 2829218893Sdim "Already have a partially-substituted pack"); 2830218893Sdim assert((!PartiallySubstitutedPack 2831218893Sdim || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && 2832218893Sdim "Wrong number of arguments in partially-substituted pack"); 2833218893Sdim PartiallySubstitutedPack = Pack; 2834218893Sdim ArgsInPartiallySubstitutedPack = ExplicitArgs; 2835218893Sdim NumArgsInPartiallySubstitutedPack = NumExplicitArgs; 2836218893Sdim} 2837218893Sdim 2838218893SdimNamedDecl *LocalInstantiationScope::getPartiallySubstitutedPack( 2839218893Sdim const TemplateArgument **ExplicitArgs, 2840218893Sdim unsigned *NumExplicitArgs) const { 2841218893Sdim if (ExplicitArgs) 2842218893Sdim *ExplicitArgs = 0; 2843218893Sdim if (NumExplicitArgs) 2844218893Sdim *NumExplicitArgs = 0; 2845218893Sdim 2846218893Sdim for (const LocalInstantiationScope *Current = this; Current; 2847218893Sdim Current = Current->Outer) { 2848218893Sdim if (Current->PartiallySubstitutedPack) { 2849218893Sdim if (ExplicitArgs) 2850218893Sdim *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack; 2851218893Sdim if (NumExplicitArgs) 2852218893Sdim *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack; 2853218893Sdim 2854218893Sdim return Current->PartiallySubstitutedPack; 2855218893Sdim } 2856218893Sdim 2857218893Sdim if (!Current->CombineWithOuterScope) 2858218893Sdim break; 2859218893Sdim } 2860218893Sdim 2861218893Sdim return 0; 2862218893Sdim} 2863