SemaTemplateInstantiateDecl.cpp revision 06a54a38be5054c910ffc92db60edab23f9ea105
172a454cd3513ac24fbdd0e0cb9ad70b86a99b801Kristian Monsen//===--- SemaTemplateInstantiateDecl.cpp - C++ Template Decl Instantiation ===/ 2c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 3c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// The LLVM Compiler Infrastructure 4c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 5c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// This file is distributed under the University of Illinois Open Source 6c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// License. See LICENSE.TXT for details. 73345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick//===----------------------------------------------------------------------===/ 8c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 9c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// This file implements C++ template instantiation for declarations. 10c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 11c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch//===----------------------------------------------------------------------===/ 12ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen#include "Sema.h" 133345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick#include "Lookup.h" 14c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include "clang/AST/ASTConsumer.h" 15731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "clang/AST/ASTContext.h" 16c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include "clang/AST/DeclTemplate.h" 173345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick#include "clang/AST/DeclVisitor.h" 18513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch#include "clang/AST/DependentDiagnostic.h" 19731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "clang/AST/Expr.h" 20c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include "clang/AST/ExprCXX.h" 21731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "clang/AST/TypeLoc.h" 22c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include "clang/Basic/PrettyStackTrace.h" 23c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include "clang/Lex/Preprocessor.h" 24731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 253345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrickusing namespace clang; 26c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 27c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochnamespace { 28c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch class TemplateDeclInstantiator 29c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch : public DeclVisitor<TemplateDeclInstantiator, Decl *> { 30731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Sema &SemaRef; 31c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclContext *Owner; 32c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const MultiLevelTemplateArgumentList &TemplateArgs; 33c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 34c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch void InstantiateAttrs(Decl *Tmpl, Decl *New); 35c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 36c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 37c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch typedef Sema::OwningExprResult OwningExprResult; 38c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 39c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateDeclInstantiator(Sema &SemaRef, DeclContext *Owner, 40c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const MultiLevelTemplateArgumentList &TemplateArgs) 41c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch : SemaRef(SemaRef), Owner(Owner), TemplateArgs(TemplateArgs) { } 42c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 43c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: Once we get closer to completion, replace these manually-written 44c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // declarations with automatically-generated ones from 45c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // clang/AST/DeclNodes.inc. 46c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D); 47c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitNamespaceDecl(NamespaceDecl *D); 48c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitNamespaceAliasDecl(NamespaceAliasDecl *D); 49c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitTypedefDecl(TypedefDecl *D); 50c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitVarDecl(VarDecl *D); 51c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitAccessSpecDecl(AccessSpecDecl *D); 52c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitFieldDecl(FieldDecl *D); 53c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitStaticAssertDecl(StaticAssertDecl *D); 54731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Decl *VisitEnumDecl(EnumDecl *D); 55731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Decl *VisitEnumConstantDecl(EnumConstantDecl *D); 56513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Decl *VisitFriendDecl(FriendDecl *D); 57513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Decl *VisitFunctionDecl(FunctionDecl *D, 583345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick TemplateParameterList *TemplateParams = 0); 59c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitCXXRecordDecl(CXXRecordDecl *D); 60c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitCXXMethodDecl(CXXMethodDecl *D, 61c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParameterList *TemplateParams = 0); 62c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D); 63c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D); 64c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitCXXConversionDecl(CXXConversionDecl *D); 65c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ParmVarDecl *VisitParmVarDecl(ParmVarDecl *D); 66c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitClassTemplateDecl(ClassTemplateDecl *D); 67c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitClassTemplatePartialSpecializationDecl( 68c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplatePartialSpecializationDecl *D); 69c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitFunctionTemplateDecl(FunctionTemplateDecl *D); 70c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); 71c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); 72c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); 73c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitUsingDirectiveDecl(UsingDirectiveDecl *D); 74c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitUsingDecl(UsingDecl *D); 75c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitUsingShadowDecl(UsingShadowDecl *D); 76c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); 77c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); 78c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 79c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Base case. FIXME: Remove once we can instantiate everything. 80c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *VisitDecl(Decl *D) { 81c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch unsigned DiagID = SemaRef.getDiagnostics().getCustomDiagID( 82c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Diagnostic::Error, 83c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "cannot instantiate %0 yet"); 84c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.Diag(D->getLocation(), DiagID) 85c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << D->getDeclKindName(); 86c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 87c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 88c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 89c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 90c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const LangOptions &getLangOptions() { 91c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return SemaRef.getLangOptions(); 92731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 93513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 943345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // Helper functions for instantiating methods. 95c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeSourceInfo *SubstFunctionType(FunctionDecl *D, 96c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch llvm::SmallVectorImpl<ParmVarDecl *> &Params); 97c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool InitFunctionInstantiation(FunctionDecl *New, FunctionDecl *Tmpl); 98c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool InitMethodInstantiation(CXXMethodDecl *New, CXXMethodDecl *Tmpl); 99c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 100c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParameterList * 101c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SubstTemplateParams(TemplateParameterList *List); 102c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 103c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool SubstQualifier(const DeclaratorDecl *OldDecl, 104c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclaratorDecl *NewDecl); 105731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick bool SubstQualifier(const TagDecl *OldDecl, 106513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch TagDecl *NewDecl); 1073345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 108c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool InstantiateClassTemplatePartialSpecialization( 109c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplateDecl *ClassTemplate, 110c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplatePartialSpecializationDecl *PartialSpec); 111c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }; 112c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 113c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 114c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochbool TemplateDeclInstantiator::SubstQualifier(const DeclaratorDecl *OldDecl, 115c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclaratorDecl *NewDecl) { 116c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NestedNameSpecifier *OldQual = OldDecl->getQualifier(); 117c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!OldQual) return false; 118731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 119513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch SourceRange QualRange = OldDecl->getQualifierRange(); 1203345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 121c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NestedNameSpecifier *NewQual 122c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = SemaRef.SubstNestedNameSpecifier(OldQual, QualRange, TemplateArgs); 123c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!NewQual) 124c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return true; 125c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 126c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NewDecl->setQualifierInfo(NewQual, QualRange); 127c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 128c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 129c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 130c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochbool TemplateDeclInstantiator::SubstQualifier(const TagDecl *OldDecl, 131731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick TagDecl *NewDecl) { 132513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch NestedNameSpecifier *OldQual = OldDecl->getQualifier(); 1333345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick if (!OldQual) return false; 134c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 135c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SourceRange QualRange = OldDecl->getQualifierRange(); 136c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 137c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NestedNameSpecifier *NewQual 138c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = SemaRef.SubstNestedNameSpecifier(OldQual, QualRange, TemplateArgs); 139c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!NewQual) 140c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return true; 141c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 142c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NewDecl->setQualifierInfo(NewQual, QualRange); 143c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 144731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 145513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 146513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch// FIXME: Is this still too simple? 147c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochvoid TemplateDeclInstantiator::InstantiateAttrs(Decl *Tmpl, Decl *New) { 148c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (const Attr *TmplAttr = Tmpl->getAttrs(); TmplAttr; 149c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TmplAttr = TmplAttr->getNext()) { 150c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: This should be generalized to more than just the AlignedAttr. 151c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr)) { 152c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Aligned->isDependent()) { 153c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The alignment expression is not potentially evaluated. 154c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EnterExpressionEvaluationContext Unevaluated(SemaRef, 155c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Action::Unevaluated); 156c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 157731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick OwningExprResult Result = SemaRef.SubstExpr(Aligned->getAlignmentExpr(), 158513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch TemplateArgs); 159513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch if (!Result.isInvalid()) 160c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: Is this the correct source location? 161c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.AddAlignedAttr(Aligned->getAlignmentExpr()->getExprLoc(), 162c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch New, Result.takeAs<Expr>()); 163c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch continue; 164c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 165c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 166c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 167c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: Is cloning correct for all attributes? 168c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Attr *NewAttr = TmplAttr->clone(SemaRef.Context); 169c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch New->addAttr(NewAttr); 170731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 171513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch} 1723345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 173c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl * 174c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 175c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(false && "Translation units cannot be instantiated"); 176c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return D; 177c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 178c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 179c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl * 180c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) { 181c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(false && "Namespaces cannot be instantiated"); 182c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return D; 183731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 184513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 1853345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickDecl * 186c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 187c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NamespaceAliasDecl *Inst 188c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = NamespaceAliasDecl::Create(SemaRef.Context, Owner, 189c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getNamespaceLoc(), 190c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getAliasLoc(), 191c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getNamespace()->getIdentifier(), 192c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getQualifierRange(), 193c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getQualifier(), 194c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getTargetNameLoc(), 195c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getNamespace()); 196731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Owner->addDecl(Inst); 197513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch return Inst; 1983345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 199c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 200c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) { 201c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool Invalid = false; 202c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeSourceInfo *DI = D->getTypeSourceInfo(); 203c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (DI->getType()->isDependentType() || 204c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DI->getType()->isVariablyModifiedType()) { 205c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DI = SemaRef.SubstType(DI, TemplateArgs, 206c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getLocation(), D->getDeclName()); 207c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!DI) { 208c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Invalid = true; 209731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy); 210513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch } 2113345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } else { 212c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType()); 213c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 214c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 215c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Create the new typedef 216c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypedefDecl *Typedef 217c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = TypedefDecl::Create(SemaRef.Context, Owner, D->getLocation(), 218c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getIdentifier(), DI); 219c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Invalid) 220c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Typedef->setInvalidDecl(); 221c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 222731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (const TagType *TT = DI->getType()->getAs<TagType>()) { 223513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch TagDecl *TD = TT->getDecl(); 2243345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 225c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If the TagDecl that the TypedefDecl points to is an anonymous decl 226c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // keep track of the TypedefDecl. 227c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!TD->getIdentifier() && !TD->getTypedefForAnonDecl()) 228c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TD->setTypedefForAnonDecl(Typedef); 229c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 230c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 231c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (TypedefDecl *Prev = D->getPreviousDeclaration()) { 232c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev, 233c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs); 234c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Typedef->setPreviousDeclaration(cast<TypedefDecl>(InstPrev)); 235731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 236513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 2373345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick InstantiateAttrs(D, Typedef); 238c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 239c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Typedef->setAccess(D->getAccess()); 240c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Owner->addDecl(Typedef); 241c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 242c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Typedef; 243c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 244c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 245c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \brief Instantiate the arguments provided as part of initialization. 246c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 247c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \returns true if an error occurred, false otherwise. 248731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic bool InstantiateInitializationArguments(Sema &SemaRef, 249513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Expr **Args, unsigned NumArgs, 250513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch const MultiLevelTemplateArgumentList &TemplateArgs, 251c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch llvm::SmallVectorImpl<SourceLocation> &FakeCommaLocs, 252c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASTOwningVector<&ActionBase::DeleteExpr> &InitArgs) { 253c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (unsigned I = 0; I != NumArgs; ++I) { 254c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // When we hit the first defaulted argument, break out of the loop: 255c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // we don't pass those default arguments on. 256c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Args[I]->isDefaultArgument()) 257c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch break; 258c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 259c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Sema::OwningExprResult Arg = SemaRef.SubstExpr(Args[I], TemplateArgs); 260c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Arg.isInvalid()) 261731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick return true; 262513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 263513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Expr *ArgExpr = (Expr *)Arg.get(); 264c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InitArgs.push_back(Arg.release()); 265c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 266c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: We're faking all of the comma locations. Do we need them? 267c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FakeCommaLocs.push_back( 268c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.PP.getLocForEndOfToken(ArgExpr->getLocEnd())); 269c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 270c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 271c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 272c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 273c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 274731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick/// \brief Instantiate an initializer, breaking it into separate 275513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch/// initialization arguments. 2763345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick/// 277c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \param S The semantic analysis object. 278c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 279c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \param Init The initializer to instantiate. 280c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 281c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \param TemplateArgs Template arguments to be substituted into the 282c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// initializer. 283c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 284c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \param NewArgs Will be filled in with the instantiation arguments. 285c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 286c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \returns true if an error occurred, false otherwise 287731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic bool InstantiateInitializer(Sema &S, Expr *Init, 288513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch const MultiLevelTemplateArgumentList &TemplateArgs, 2893345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick SourceLocation &LParenLoc, 290c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch llvm::SmallVector<SourceLocation, 4> &CommaLocs, 291c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASTOwningVector<&ActionBase::DeleteExpr> &NewArgs, 292c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SourceLocation &RParenLoc) { 293c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NewArgs.clear(); 294c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch LParenLoc = SourceLocation(); 295c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch RParenLoc = SourceLocation(); 296c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 297c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Init) 298c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 299c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 300731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (CXXExprWithTemporaries *ExprTemp = dyn_cast<CXXExprWithTemporaries>(Init)) 301513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Init = ExprTemp->getSubExpr(); 3023345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 303c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init)) 304c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Init = Binder->getSubExpr(); 305c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 306c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init)) 307c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Init = ICE->getSubExprAsWritten(); 308c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 309c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) { 310c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch LParenLoc = ParenList->getLParenLoc(); 311c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch RParenLoc = ParenList->getRParenLoc(); 312c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return InstantiateInitializationArguments(S, ParenList->getExprs(), 313c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ParenList->getNumExprs(), 314731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick TemplateArgs, CommaLocs, 315513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch NewArgs); 3163345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } 317c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 318c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init)) { 319c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!isa<CXXTemporaryObjectExpr>(Construct)) { 320c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (InstantiateInitializationArguments(S, 321c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Construct->getArgs(), 322c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Construct->getNumArgs(), 323c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs, 324c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CommaLocs, NewArgs)) 325c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return true; 326c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 327731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // FIXME: Fake locations! 328513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch LParenLoc = S.PP.getLocForEndOfToken(Init->getLocStart()); 3293345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick RParenLoc = CommaLocs.empty()? LParenLoc : CommaLocs.back(); 330c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 331c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 332c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 333c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 334c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Sema::OwningExprResult Result = S.SubstExpr(Init, TemplateArgs); 335c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Result.isInvalid()) 336c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return true; 337c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 338c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NewArgs.push_back(Result.takeAs<Expr>()); 339c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 340731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 341513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 3423345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickDecl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) { 343c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If this is the variable for an anonymous struct or union, 344c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // instantiate the anonymous struct/union type first. 345c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (const RecordType *RecordTy = D->getType()->getAs<RecordType>()) 346c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (RecordTy->getDecl()->isAnonymousStructOrUnion()) 347c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!VisitCXXRecordDecl(cast<CXXRecordDecl>(RecordTy->getDecl()))) 348c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 349c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 350c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Do substitution on the type of the declaration 351c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeSourceInfo *DI = SemaRef.SubstType(D->getTypeSourceInfo(), 352c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs, 353731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick D->getTypeSpecStartLoc(), 354513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch D->getDeclName()); 3553345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick if (!DI) 356c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 357c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 358c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Build the instantiated declaration 359c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch VarDecl *Var = VarDecl::Create(SemaRef.Context, Owner, 360c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getLocation(), D->getIdentifier(), 361c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DI->getType(), DI, 362c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getStorageClass(), 363c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getStorageClassAsWritten()); 364c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Var->setThreadSpecified(D->isThreadSpecified()); 365c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Var->setCXXDirectInitializer(D->hasCXXDirectInitializer()); 366731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Var->setDeclaredInCondition(D->isDeclaredInCondition()); 367513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 3683345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // Substitute the nested name specifier, if any. 369c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (SubstQualifier(D, Var)) 370c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 371c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 372c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If we are instantiating a static data member defined 373c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // out-of-line, the instantiation will have the same lexical 374c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // context (which will be a namespace scope) as the template. 375c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (D->isOutOfLine()) 376c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Var->setLexicalDeclContext(D->getLexicalDeclContext()); 377c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 378c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Var->setAccess(D->getAccess()); 379731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 380513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch if (!D->isStaticDataMember()) 3813345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Var->setUsed(D->isUsed(false)); 382c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 383c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: In theory, we could have a previous declaration for variables that 384c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // are not static data members. 385c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool Redeclaration = false; 386c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: having to fake up a LookupResult is dumb. 387c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch LookupResult Previous(SemaRef, Var->getDeclName(), Var->getLocation(), 388c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Sema::LookupOrdinaryName, Sema::ForRedeclaration); 389c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (D->isStaticDataMember()) 390c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.LookupQualifiedName(Previous, Owner, false); 391c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CheckVariableDeclaration(Var, Previous, Redeclaration); 392731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 393513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch if (D->isOutOfLine()) { 3943345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick if (!D->isStaticDataMember()) 395c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getLexicalDeclContext()->addDecl(Var); 396c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Owner->makeDeclVisibleInContext(Var); 397c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 398c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Owner->addDecl(Var); 399c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 400c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Owner->isFunctionOrMethod()) 401c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Var); 402c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 403c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 404c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Link instantiations of static data members back to the template from 405731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // which they were instantiated. 406513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch if (Var->isStaticDataMember()) 4073345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick SemaRef.Context.setInstantiatedFromStaticDataMember(Var, D, 408c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TSK_ImplicitInstantiation); 409c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 410c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Var->getAnyInitializer()) { 411c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We already have an initializer in the class. 412c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else if (D->getInit()) { 413c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Var->isStaticDataMember() && !D->isOutOfLine()) 414c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.PushExpressionEvaluationContext(Sema::Unevaluated); 415c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch else 416c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.PushExpressionEvaluationContext(Sema::PotentiallyEvaluated); 417c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 418731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Instantiate the initializer. 419513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch SourceLocation LParenLoc, RParenLoc; 4203345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick llvm::SmallVector<SourceLocation, 4> CommaLocs; 421c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASTOwningVector<&ActionBase::DeleteExpr> InitArgs(SemaRef); 422c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!InstantiateInitializer(SemaRef, D->getInit(), TemplateArgs, LParenLoc, 423c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CommaLocs, InitArgs, RParenLoc)) { 424c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Attach the initializer to the declaration. 425c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (D->hasCXXDirectInitializer()) { 426c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Add the direct initializer to the declaration. 427c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.AddCXXDirectInitializerToDecl(Sema::DeclPtrTy::make(Var), 428c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch LParenLoc, 429c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch move_arg(InitArgs), 430c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CommaLocs.data(), 431731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick RParenLoc); 432513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch } else if (InitArgs.size() == 1) { 4333345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Expr *Init = (Expr*)(InitArgs.take()[0]); 434c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.AddInitializerToDecl(Sema::DeclPtrTy::make(Var), 435c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.Owned(Init), 436c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch false); 437c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 438c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(InitArgs.size() == 0); 439c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.ActOnUninitializedDecl(Sema::DeclPtrTy::make(Var), false); 440c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 441c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 442c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: Not too happy about invalidating the declaration 443c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // because of a bogus initializer. 444731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Var->setInvalidDecl(); 445513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch } 4463345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 447c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.PopExpressionEvaluationContext(); 448c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else if (!Var->isStaticDataMember() || Var->isOutOfLine()) 449c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.ActOnUninitializedDecl(Sema::DeclPtrTy::make(Var), false); 450c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 451c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Diagnose unused local variables. 452c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Var->isInvalidDecl() && Owner->isFunctionOrMethod() && !Var->isUsed()) 453c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.DiagnoseUnusedDecl(Var); 454c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 455c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Var; 456c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 457731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 458513209b27ff55e2841eac0e4120199c23acce758Ben MurdochDecl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) { 4593345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick AccessSpecDecl* AD 460c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner, 461c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getAccessSpecifierLoc(), D->getColonLoc()); 462c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Owner->addHiddenDecl(AD); 463c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return AD; 464c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 465c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 466c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) { 467c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool Invalid = false; 468c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeSourceInfo *DI = D->getTypeSourceInfo(); 469c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (DI->getType()->isDependentType() || 470731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick DI->getType()->isVariablyModifiedType()) { 471513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch DI = SemaRef.SubstType(DI, TemplateArgs, 4723345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick D->getLocation(), D->getDeclName()); 473c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!DI) { 474c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DI = D->getTypeSourceInfo(); 475c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Invalid = true; 476c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else if (DI->getType()->isFunctionType()) { 477c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // C++ [temp.arg.type]p3: 478c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If a declaration acquires a function type through a type 479c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // dependent on a template-parameter and this causes a 480c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // declaration that does not use the syntactic form of a 481c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // function declarator to have function type, the program is 482c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // ill-formed. 483731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function) 484513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch << DI->getType(); 4853345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Invalid = true; 486c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 487c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 488c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType()); 489c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 490c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 491c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Expr *BitWidth = D->getBitWidth(); 492c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Invalid) 493c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch BitWidth = 0; 494c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch else if (BitWidth) { 495c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The bit-width expression is not potentially evaluated. 496731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 497513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 4983345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick OwningExprResult InstantiatedBitWidth 499c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = SemaRef.SubstExpr(BitWidth, TemplateArgs); 500c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (InstantiatedBitWidth.isInvalid()) { 501c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Invalid = true; 502c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch BitWidth = 0; 503c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else 504c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch BitWidth = InstantiatedBitWidth.takeAs<Expr>(); 505c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 506c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 507c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(), 508c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DI->getType(), DI, 509731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick cast<RecordDecl>(Owner), 510513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch D->getLocation(), 5113345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick D->isMutable(), 512c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch BitWidth, 513c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getTypeSpecStartLoc(), 514c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getAccess(), 515c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 0); 516c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Field) { 517c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch cast<Decl>(Owner)->setInvalidDecl(); 518c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 519c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 520c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 521c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstantiateAttrs(D, Field); 522731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 523513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch if (Invalid) 5243345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Field->setInvalidDecl(); 525c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 526c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Field->getDeclName()) { 527c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Keep track of where this decl came from. 528c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.Context.setInstantiatedFromUnnamedFieldDecl(Field, D); 529c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 530c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) { 531c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Parent->isAnonymousStructOrUnion() && 532c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Parent->getLookupContext()->isFunctionOrMethod()) 533c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field); 534c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 535731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 536513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Field->setImplicit(D->isImplicit()); 5373345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Field->setAccess(D->getAccess()); 538c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Owner->addDecl(Field); 539c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 540c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Field; 541c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 542c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 543c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) { 544c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Handle friend type expressions by simply substituting template 545c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // parameters into the pattern type and checking the result. 546c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (TypeSourceInfo *Ty = D->getFriendType()) { 547c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeSourceInfo *InstTy = 548731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick SemaRef.SubstType(Ty, TemplateArgs, 549513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch D->getLocation(), DeclarationName()); 5503345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick if (!InstTy) 551c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 552c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 553c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getFriendLoc(), InstTy); 554c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!FD) 555c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 556c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 557c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FD->setAccess(AS_public); 558c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Owner->addDecl(FD); 559c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return FD; 560c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 561731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 562513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch NamedDecl *ND = D->getFriendDecl(); 5633345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick assert(ND && "friend decl must be a decl or a type!"); 564c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 565c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // All of the Visit implementations for the various potential friend 566c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // declarations have to be carefully written to work for friend 567c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // objects, with the most important detail being that the target 568c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // decl should almost certainly not be placed in Owner. 569c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *NewND = Visit(ND); 570c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!NewND) return 0; 571c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 572c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FriendDecl *FD = 573c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(), 574731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick cast<NamedDecl>(NewND), D->getFriendLoc()); 575513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch FD->setAccess(AS_public); 5763345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Owner->addDecl(FD); 577c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return FD; 578c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 579c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 580c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) { 581c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Expr *AssertExpr = D->getAssertExpr(); 582c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 583c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The expression in a static assertion is not potentially evaluated. 584c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 585c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 586c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch OwningExprResult InstantiatedAssertExpr 587731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick = SemaRef.SubstExpr(AssertExpr, TemplateArgs); 588513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch if (InstantiatedAssertExpr.isInvalid()) 5893345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick return 0; 590c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 591c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch OwningExprResult Message(SemaRef, D->getMessage()); 592c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getMessage()->Retain(); 593c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *StaticAssert 594c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = SemaRef.ActOnStaticAssertDeclaration(D->getLocation(), 595c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch move(InstantiatedAssertExpr), 596c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch move(Message)).getAs<Decl>(); 597c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return StaticAssert; 598c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 599c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 600731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickDecl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) { 601513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch EnumDecl *Enum = EnumDecl::Create(SemaRef.Context, Owner, 6023345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick D->getLocation(), D->getIdentifier(), 603c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getTagKeywordLoc(), 604c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch /*PrevDecl=*/0); 605c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Enum->setInstantiationOfMemberEnum(D); 606c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Enum->setAccess(D->getAccess()); 607c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (SubstQualifier(D, Enum)) return 0; 608c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Owner->addDecl(Enum); 609c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Enum->startDefinition(); 610c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 611c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (D->getDeclContext()->isFunctionOrMethod()) 612c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Enum); 613731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 614513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch llvm::SmallVector<Sema::DeclPtrTy, 4> Enumerators; 6153345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 616c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EnumConstantDecl *LastEnumConst = 0; 617c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (EnumDecl::enumerator_iterator EC = D->enumerator_begin(), 618c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ECEnd = D->enumerator_end(); 619c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EC != ECEnd; ++EC) { 620c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The specified value for the enumerator. 621c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch OwningExprResult Value = SemaRef.Owned((Expr *)0); 622c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Expr *UninstValue = EC->getInitExpr()) { 623c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The enumerator's value expression is not potentially evaluated. 624c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EnterExpressionEvaluationContext Unevaluated(SemaRef, 625c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Action::Unevaluated); 626731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 627513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Value = SemaRef.SubstExpr(UninstValue, TemplateArgs); 6283345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } 629c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 630c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Drop the initial value and continue. 631c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool isInvalid = false; 632c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Value.isInvalid()) { 633c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Value = SemaRef.Owned((Expr *)0); 634c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch isInvalid = true; 635c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 636c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 637c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EnumConstantDecl *EnumConst 638c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = SemaRef.CheckEnumConstant(Enum, LastEnumConst, 639731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EC->getLocation(), EC->getIdentifier(), 640513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch move(Value)); 6413345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 642c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isInvalid) { 643c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (EnumConst) 644c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EnumConst->setInvalidDecl(); 645c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Enum->setInvalidDecl(); 646c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 647c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 648c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (EnumConst) { 649c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EnumConst->setAccess(Enum->getAccess()); 650c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Enum->addDecl(EnumConst); 651c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Enumerators.push_back(Sema::DeclPtrTy::make(EnumConst)); 652731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick LastEnumConst = EnumConst; 653513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 6543345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick if (D->getDeclContext()->isFunctionOrMethod()) { 655c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If the enumeration is within a function or method, record the enum 656c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // constant as a local. 657c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CurrentInstantiationScope->InstantiatedLocal(*EC, EnumConst); 658c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 659c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 660c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 661c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 662c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: Fixup LBraceLoc and RBraceLoc 663c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: Empty Scope and AttributeList (required to handle attribute packed). 664c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.ActOnEnumBody(Enum->getLocation(), SourceLocation(), SourceLocation(), 665731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Sema::DeclPtrTy::make(Enum), 666513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch &Enumerators[0], Enumerators.size(), 6673345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 0, 0); 668c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 669c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Enum; 670c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 671c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 672c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) { 673c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(false && "EnumConstantDecls can only occur within EnumDecls."); 674c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 675c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 676c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 677c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) { 678731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None); 679513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 6803345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // Create a local instantiation scope for this class template, which 681c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // will contain the instantiations of the template parameters. 682c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Sema::LocalInstantiationScope Scope(SemaRef); 683c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParameterList *TempParams = D->getTemplateParameters(); 684c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParameterList *InstParams = SubstTemplateParams(TempParams); 685c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!InstParams) 686c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return NULL; 687c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 688c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CXXRecordDecl *Pattern = D->getTemplatedDecl(); 689c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 690c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Instantiate the qualifier. We have to do this first in case 691731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // we're a friend declaration, because if we are then we need to put 692513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // the new declaration in the appropriate context. 6933345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick NestedNameSpecifier *Qualifier = Pattern->getQualifier(); 694c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Qualifier) { 695c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Qualifier = SemaRef.SubstNestedNameSpecifier(Qualifier, 696c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Pattern->getQualifierRange(), 697c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs); 698c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Qualifier) return 0; 699c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 700c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 701c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CXXRecordDecl *PrevDecl = 0; 702c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplateDecl *PrevClassTemplate = 0; 703c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 704731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // If this isn't a friend, then it's a member template, in which 705513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // case we just want to build the instantiation in the 7063345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // specialization. If it is a friend, we want to build it in 707c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // the appropriate context. 708c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclContext *DC = Owner; 709c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isFriend) { 710c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Qualifier) { 711c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CXXScopeSpec SS; 712c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SS.setScopeRep(Qualifier); 713c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SS.setRange(Pattern->getQualifierRange()); 714c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DC = SemaRef.computeDeclContext(SS); 715c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!DC) return 0; 716c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 717731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(), 718513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Pattern->getDeclContext(), 7193345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick TemplateArgs); 720c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 721c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 722c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Look for a previous declaration of the template in the owning 723c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // context. 724c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(), 725c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Sema::LookupOrdinaryName, Sema::ForRedeclaration); 726c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.LookupQualifiedName(R, DC); 727c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 728c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (R.isSingleResult()) { 729c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>(); 730731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (PrevClassTemplate) 731513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch PrevDecl = PrevClassTemplate->getTemplatedDecl(); 7323345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } 733c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 734c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!PrevClassTemplate && Qualifier) { 735c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope) 736c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC 737c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << Pattern->getQualifierRange(); 738c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 739c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 740c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 741c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool AdoptedPreviousTemplateParams = false; 742c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (PrevClassTemplate) { 743731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick bool Complain = true; 744513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 7453345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // HACK: libstdc++ 4.2.1 contains an ill-formed friend class 746c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // template for struct std::tr1::__detail::_Map_base, where the 747c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // template parameters of the friend declaration don't match the 748c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // template parameters of the original declaration. In this one 749c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // case, we don't complain about the ill-formed friend 750c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // declaration. 751c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isFriend && Pattern->getIdentifier() && 752c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Pattern->getIdentifier()->isStr("_Map_base") && 753c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DC->isNamespace() && 754c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch cast<NamespaceDecl>(DC)->getIdentifier() && 755c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__detail")) { 756731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick DeclContext *DCParent = DC->getParent(); 757513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch if (DCParent->isNamespace() && 7583345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick cast<NamespaceDecl>(DCParent)->getIdentifier() && 759c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch cast<NamespaceDecl>(DCParent)->getIdentifier()->isStr("tr1")) { 760c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclContext *DCParent2 = DCParent->getParent(); 761c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (DCParent2->isNamespace() && 762c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch cast<NamespaceDecl>(DCParent2)->getIdentifier() && 763c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch cast<NamespaceDecl>(DCParent2)->getIdentifier()->isStr("std") && 764c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DCParent2->getParent()->isTranslationUnit()) 765c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Complain = false; 766c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 767c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 768c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 769731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick TemplateParameterList *PrevParams 770513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch = PrevClassTemplate->getTemplateParameters(); 7713345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 772c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Make sure the parameter lists match. 773c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams, 774c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Complain, 775c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Sema::TPL_TemplateMatch)) { 776c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Complain) 777c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 778c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 779c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AdoptedPreviousTemplateParams = true; 780c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstParams = PrevParams; 781c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 782731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 783513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // Do some additional validation, then merge default arguments 7843345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // from the existing declarations. 785c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!AdoptedPreviousTemplateParams && 786c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CheckTemplateParameterList(InstParams, PrevParams, 787c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Sema::TPC_ClassTemplate)) 788c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 789c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 790c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 791c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 792c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CXXRecordDecl *RecordInst 793c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = CXXRecordDecl::Create(SemaRef.Context, Pattern->getTagKind(), DC, 794c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Pattern->getLocation(), Pattern->getIdentifier(), 795731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Pattern->getTagKeywordLoc(), PrevDecl, 796513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch /*DelayTypeCreation=*/true); 7973345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 798c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Qualifier) 799c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch RecordInst->setQualifierInfo(Qualifier, Pattern->getQualifierRange()); 800c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 801c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplateDecl *Inst 802c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(), 803c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getIdentifier(), InstParams, RecordInst, 804c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PrevClassTemplate); 805c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch RecordInst->setDescribedClassTemplate(Inst); 806c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 807c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isFriend) { 808731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (PrevClassTemplate) 809513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Inst->setAccess(PrevClassTemplate->getAccess()); 8103345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick else 811c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Inst->setAccess(D->getAccess()); 812c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 813c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Inst->setObjectOfFriendDecl(PrevClassTemplate != 0); 814c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // TODO: do we want to track the instantiation progeny of this 815c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // friend target decl? 816c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 817c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Inst->setAccess(D->getAccess()); 818c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Inst->setInstantiatedFromMemberTemplate(D); 819c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 820c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 821731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Trigger creation of the type for the instantiation. 822513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch SemaRef.Context.getInjectedClassNameType(RecordInst, 8233345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Inst->getInjectedClassNameSpecialization(SemaRef.Context)); 824c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 825c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Finish handling of friends. 826c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isFriend) { 827c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DC->makeDeclVisibleInContext(Inst, /*Recoverable*/ false); 828c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Inst; 829c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 830c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 831c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Owner->addDecl(Inst); 832c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 833c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Instantiate all of the partial specializations of this member class 834731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // template. 835513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch llvm::SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs; 8363345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick D->getPartialSpecializations(PartialSpecs); 837c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) 838c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstantiateClassTemplatePartialSpecialization(Inst, PartialSpecs[I]); 839c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 840c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Inst; 841c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 842c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 843c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl * 844c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl( 845c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplatePartialSpecializationDecl *D) { 846c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate(); 847731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 848513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // Lookup the already-instantiated declaration in the instantiation 8493345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // of the class template and return that. 850c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclContext::lookup_result Found 851c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = Owner->lookup(ClassTemplate->getDeclName()); 852c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Found.first == Found.second) 853c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 854c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 855c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplateDecl *InstClassTemplate 856c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = dyn_cast<ClassTemplateDecl>(*Found.first); 857c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!InstClassTemplate) 858c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 859c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 860731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Decl *DCanon = D->getCanonicalDecl(); 861513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch for (llvm::FoldingSet<ClassTemplatePartialSpecializationDecl>::iterator 8623345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick P = InstClassTemplate->getPartialSpecializations().begin(), 863c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PEnd = InstClassTemplate->getPartialSpecializations().end(); 864c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch P != PEnd; ++P) { 865c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (P->getInstantiatedFromMember()->getCanonicalDecl() == DCanon) 866c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return &*P; 867c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 868c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 869c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 870c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 871c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 872c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl * 873731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 874513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // Create a local instantiation scope for this function template, which 8753345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // will contain the instantiations of the template parameters and then get 876c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // merged with the local instantiation scope for the function template 877c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // itself. 878c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Sema::LocalInstantiationScope Scope(SemaRef); 879c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 880c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParameterList *TempParams = D->getTemplateParameters(); 881c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParameterList *InstParams = SubstTemplateParams(TempParams); 882c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!InstParams) 883c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return NULL; 884c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 885c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionDecl *Instantiated = 0; 886731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl())) 887513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod, 8883345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick InstParams)); 889c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch else 890c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl( 891c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getTemplatedDecl(), 892c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstParams)); 893c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 894c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Instantiated) 895c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 896c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 897c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instantiated->setAccess(D->getAccess()); 898c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 899731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Link the instantiated function template declaration to the function 900513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // template from which it was instantiated. 9013345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick FunctionTemplateDecl *InstTemplate 902c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = Instantiated->getDescribedFunctionTemplate(); 903c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstTemplate->setAccess(D->getAccess()); 904c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(InstTemplate && 905c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "VisitFunctionDecl/CXXMethodDecl didn't create a template!"); 906c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 907c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None); 908c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 909c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Link the instantiation back to the pattern *unless* this is a 910c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // non-definition friend declaration. 911c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!InstTemplate->getInstantiatedFromMemberTemplate() && 912731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition())) 913513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch InstTemplate->setInstantiatedFromMemberTemplate(D); 9143345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 915c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Make declarations visible in the appropriate context. 916c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!isFriend) 917c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Owner->addDecl(InstTemplate); 918c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 919c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return InstTemplate; 920c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 921c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 922c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) { 923c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CXXRecordDecl *PrevDecl = 0; 924c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (D->isInjectedClassName()) 925731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick PrevDecl = cast<CXXRecordDecl>(Owner); 926513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch else if (D->getPreviousDeclaration()) { 9273345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(), 928c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getPreviousDeclaration(), 929c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs); 930c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Prev) return 0; 931c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PrevDecl = cast<CXXRecordDecl>(Prev); 932c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 933c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 934c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CXXRecordDecl *Record 935c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner, 936c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getLocation(), D->getIdentifier(), 937c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getTagKeywordLoc(), PrevDecl); 938731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 939513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // Substitute the nested name specifier, if any. 9403345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick if (SubstQualifier(D, Record)) 941c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 942c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 943c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Record->setImplicit(D->isImplicit()); 944c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: Check against AS_none is an ugly hack to work around the issue that 945c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // the tag decls introduced by friend class declarations don't have an access 946c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // specifier. Remove once this area of the code gets sorted out. 947c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (D->getAccess() != AS_none) 948c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Record->setAccess(D->getAccess()); 949c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!D->isInjectedClassName()) 950c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation); 951731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 952513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // If the original function was part of a friend declaration, 9533345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // inherit its namespace state. 954c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Decl::FriendObjectKind FOK = D->getFriendObjectKind()) 955c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Record->setObjectOfFriendDecl(FOK == Decl::FOK_Declared); 956c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 957c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Make sure that anonymous structs and unions are recorded. 958c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (D->isAnonymousStructOrUnion()) { 959c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Record->setAnonymousStructOrUnion(true); 960c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Record->getDeclContext()->getLookupContext()->isFunctionOrMethod()) 961c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record); 962c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 963c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 964731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Owner->addDecl(Record); 965513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch return Record; 9663345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 967c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 968c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// Normal class members are of more specific types and therefore 969c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// don't make it here. This function serves two purposes: 970c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 1) instantiating function templates 971c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 2) substituting friend declarations 972c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// FIXME: preserve function definitions in case #2 973c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D, 974c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParameterList *TemplateParams) { 975c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Check whether there is already a function template specialization for 976c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // this declaration. 977731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate(); 978513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch void *InsertPos = 0; 9793345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick if (FunctionTemplate && !TemplateParams) { 980c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch llvm::FoldingSetNodeID ID; 981c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionTemplateSpecializationInfo::Profile(ID, 982c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs.getInnermost().getFlatArgumentList(), 983c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs.getInnermost().flat_size(), 984c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.Context); 985c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 986c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionTemplateSpecializationInfo *Info 987c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = FunctionTemplate->getSpecializations().FindNodeOrInsertPos(ID, 988c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InsertPos); 989c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 990731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // If we already have a function template specialization, return it. 991513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch if (Info) 9923345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick return Info->Function; 993c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 994c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 995c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool isFriend; 996c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (FunctionTemplate) 997c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None); 998c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch else 999c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch isFriend = (D->getFriendObjectKind() != Decl::FOK_None); 1000c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1001c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool MergeWithParentScope = (TemplateParams != 0) || 1002c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Owner->isFunctionOrMethod() || 1003731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick !(isa<Decl>(Owner) && 1004513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod()); 10053345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Sema::LocalInstantiationScope Scope(SemaRef, MergeWithParentScope); 1006c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1007c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch llvm::SmallVector<ParmVarDecl *, 4> Params; 1008c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeSourceInfo *TInfo = D->getTypeSourceInfo(); 1009c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TInfo = SubstFunctionType(D, Params); 1010c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!TInfo) 1011c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 1012c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch QualType T = TInfo->getType(); 1013c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1014c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NestedNameSpecifier *Qualifier = D->getQualifier(); 1015c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Qualifier) { 1016731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Qualifier = SemaRef.SubstNestedNameSpecifier(Qualifier, 1017513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch D->getQualifierRange(), 10183345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick TemplateArgs); 1019c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Qualifier) return 0; 1020c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1021c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1022c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If we're instantiating a local function declaration, put the result 1023c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // in the owner; otherwise we need to find the instantiated context. 1024c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclContext *DC; 1025c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (D->getDeclContext()->isFunctionOrMethod()) 1026c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DC = Owner; 1027c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch else if (isFriend && Qualifier) { 1028c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CXXScopeSpec SS; 1029731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick SS.setScopeRep(Qualifier); 1030513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch SS.setRange(D->getQualifierRange()); 10313345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick DC = SemaRef.computeDeclContext(SS); 1032c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!DC) return 0; 1033c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 1034c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(), 1035c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs); 1036c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1037c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1038c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionDecl *Function = 1039c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionDecl::Create(SemaRef.Context, DC, D->getLocation(), 1040c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getDeclName(), T, TInfo, 1041c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getStorageClass(), D->getStorageClassAsWritten(), 1042731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick D->isInlineSpecified(), D->hasWrittenPrototype()); 1043513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 10443345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick if (Qualifier) 1045c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Function->setQualifierInfo(Qualifier, D->getQualifierRange()); 1046c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1047c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclContext *LexicalDC = Owner; 1048c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!isFriend && D->isOutOfLine()) { 1049c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(D->getDeclContext()->isFileContext()); 1050c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch LexicalDC = D->getDeclContext(); 1051c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1052c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1053c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Function->setLexicalDeclContext(LexicalDC); 1054c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1055731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Attach the parameters 1056513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch for (unsigned P = 0; P < Params.size(); ++P) 10573345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Params[P]->setOwningFunction(Function); 1058c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Function->setParams(Params.data(), Params.size()); 1059c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1060c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SourceLocation InstantiateAtPOI; 1061c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (TemplateParams) { 1062c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Our resulting instantiation is actually a function template, since we 1063c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // are substituting only the outer template parameters. For example, given 1064c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 1065c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // template<typename T> 1066c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // struct X { 10673345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // template<typename U> friend void f(T, U); 1068731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // }; 1069513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // 10703345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // X<int> x; 1071c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 1072c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We are instantiating the friend function template "f" within X<int>, 1073c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // which means substituting int for T, but leaving "f" as a friend function 1074c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // template. 1075c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Build the function template itself. 1076c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC, 1077c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Function->getLocation(), 1078c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Function->getDeclName(), 1079c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParams, Function); 1080c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Function->setDescribedFunctionTemplate(FunctionTemplate); 1081731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1082513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch FunctionTemplate->setLexicalDeclContext(LexicalDC); 10833345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 1084c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isFriend && D->isThisDeclarationADefinition()) { 1085c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // TODO: should we remember this connection regardless of whether 1086c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // the friend declaration provided a body? 1087c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionTemplate->setInstantiatedFromMemberTemplate( 1088c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getDescribedFunctionTemplate()); 1089c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1090c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else if (FunctionTemplate) { 1091c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Record this function template specialization. 1092c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Function->setFunctionTemplateSpecialization(FunctionTemplate, 1093c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch &TemplateArgs.getInnermost(), 1094731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick InsertPos); 1095513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch } else if (isFriend && D->isThisDeclarationADefinition()) { 10963345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // TODO: should we remember this connection regardless of whether 1097c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // the friend declaration provided a body? 1098c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation); 1099c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1100c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1101c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (InitFunctionInstantiation(Function, D)) 1102c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Function->setInvalidDecl(); 1103c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1104c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool Redeclaration = false; 1105c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool OverloadableAttrRequired = false; 1106c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool isExplicitSpecialization = false; 1107731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1108513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch LookupResult Previous(SemaRef, Function->getDeclName(), SourceLocation(), 11093345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Sema::LookupOrdinaryName, Sema::ForRedeclaration); 1110c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1111c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (DependentFunctionTemplateSpecializationInfo *Info 1112c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = D->getDependentSpecializationInfo()) { 1113c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(isFriend && "non-friend has dependent specialization info?"); 1114c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1115c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // This needs to be set now for future sanity. 1116c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Function->setObjectOfFriendDecl(/*HasPrevious*/ true); 1117c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1118c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Instantiate the explicit template arguments. 1119c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(), 1120731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Info->getRAngleLoc()); 1121513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch for (unsigned I = 0, E = Info->getNumTemplateArgs(); I != E; ++I) { 1122513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch TemplateArgumentLoc Loc; 1123c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (SemaRef.Subst(Info->getTemplateArg(I), Loc, TemplateArgs)) 1124c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 1125c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1126c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ExplicitArgs.addArgument(Loc); 1127c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1128c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1129c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Map the candidate templates to their instantiations. 1130c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) { 1131c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(), 1132c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Info->getTemplate(I), 1133731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick TemplateArgs); 1134513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch if (!Temp) return 0; 1135513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 1136c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Previous.addDecl(cast<FunctionTemplateDecl>(Temp)); 1137c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1138c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1139c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (SemaRef.CheckFunctionTemplateSpecialization(Function, 1140c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch &ExplicitArgs, 1141c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Previous)) 1142c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Function->setInvalidDecl(); 1143c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1144c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch isExplicitSpecialization = true; 1145c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1146731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } else if (TemplateParams || !FunctionTemplate) { 1147513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // Look only into the namespace where the friend would be declared to 1148513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // find a previous declaration. This is the innermost enclosing namespace, 1149c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // as described in ActOnFriendFunctionDecl. 1150c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.LookupQualifiedName(Previous, DC); 1151c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1152c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // In C++, the previous declaration we find might be a tag type 1153c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // (class or enum). In this case, the new declaration will hide the 1154c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // tag type. Note that this does does not apply if we're declaring a 1155c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // typedef (C++ [dcl.typedef]p4). 1156c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Previous.isSingleTagDecl()) 1157c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Previous.clear(); 1158c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1159c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1160731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick SemaRef.CheckFunctionDeclaration(/*Scope*/ 0, Function, Previous, 1161513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch isExplicitSpecialization, Redeclaration, 1162513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch /*FIXME:*/OverloadableAttrRequired); 1163c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1164c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NamedDecl *PrincipalDecl = (TemplateParams 1165c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ? cast<NamedDecl>(FunctionTemplate) 1166c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch : Function); 1167c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1168c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If the original function was part of a friend declaration, 1169c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // inherit its namespace state and add it to the owner. 1170c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isFriend) { 1171c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NamedDecl *PrevDecl; 1172c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (TemplateParams) 1173731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick PrevDecl = FunctionTemplate->getPreviousDeclaration(); 1174513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch else 11753345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick PrevDecl = Function->getPreviousDeclaration(); 1176c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1177c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PrincipalDecl->setObjectOfFriendDecl(PrevDecl != 0); 1178c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DC->makeDeclVisibleInContext(PrincipalDecl, /*Recoverable=*/ false); 1179c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1180c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!SemaRef.getLangOptions().CPlusPlus0x && 1181c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->isThisDeclarationADefinition()) { 1182c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Check for a function body. 1183c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const FunctionDecl *Definition = 0; 1184c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Function->hasBody(Definition) && 1185c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Definition->getTemplateSpecializationKind() == TSK_Undeclared) { 1186c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.Diag(Function->getLocation(), diag::err_redefinition) 1187c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << Function->getDeclName(); 1188513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch SemaRef.Diag(Definition->getLocation(), diag::note_previous_definition); 118972a454cd3513ac24fbdd0e0cb9ad70b86a99b801Kristian Monsen Function->setInvalidDecl(); 1190513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch } 11913345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // Check for redefinitions due to other instantiations of this or 1192c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // a similar friend function. 1193c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch else for (FunctionDecl::redecl_iterator R = Function->redecls_begin(), 1194c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch REnd = Function->redecls_end(); 1195c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch R != REnd; ++R) { 1196c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (*R != Function && 1197c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ((*R)->getFriendObjectKind() != Decl::FOK_None)) { 1198c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (const FunctionDecl *RPattern 1199c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = (*R)->getTemplateInstantiationPattern()) 1200c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (RPattern->hasBody(RPattern)) { 1201c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.Diag(Function->getLocation(), diag::err_redefinition) 1202731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick << Function->getDeclName(); 1203513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch SemaRef.Diag((*R)->getLocation(), diag::note_previous_definition); 1204513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Function->setInvalidDecl(); 1205c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch break; 1206c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1207c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1208c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1209c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1210c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1211c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1212c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1213c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Function->isOverloadedOperator() && !DC->isRecord() && 1214c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 1215731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick PrincipalDecl->setNonMemberOperator(); 1216513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 1217513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch return Function; 1218c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1219c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1220c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl * 1221c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D, 1222c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParameterList *TemplateParams) { 1223c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate(); 1224c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch void *InsertPos = 0; 12253345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick if (FunctionTemplate && !TemplateParams) { 1226c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We are creating a function template specialization from a function 1227c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // template. Check whether there is already a function template 1228731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // specialization for this particular set of template arguments. 1229513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch llvm::FoldingSetNodeID ID; 12303345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick FunctionTemplateSpecializationInfo::Profile(ID, 1231c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs.getInnermost().getFlatArgumentList(), 1232c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs.getInnermost().flat_size(), 1233c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.Context); 1234c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1235c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionTemplateSpecializationInfo *Info 1236c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = FunctionTemplate->getSpecializations().FindNodeOrInsertPos(ID, 1237c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InsertPos); 1238c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1239c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If we already have a function template specialization, return it. 1240c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Info) 1241731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick return Info->Function; 1242513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch } 1243513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 1244c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool isFriend; 1245c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (FunctionTemplate) 1246c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None); 1247c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch else 1248c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch isFriend = (D->getFriendObjectKind() != Decl::FOK_None); 1249c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1250c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool MergeWithParentScope = (TemplateParams != 0) || 1251c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch !(isa<Decl>(Owner) && 1252c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod()); 1253c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Sema::LocalInstantiationScope Scope(SemaRef, MergeWithParentScope); 1254731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1255513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch llvm::SmallVector<ParmVarDecl *, 4> Params; 1256513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch TypeSourceInfo *TInfo = D->getTypeSourceInfo(); 1257c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TInfo = SubstFunctionType(D, Params); 1258c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!TInfo) 1259c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 1260c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch QualType T = TInfo->getType(); 1261c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1262c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // \brief If the type of this function is not *directly* a function 1263c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // type, then we're instantiating the a function that was declared 1264c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // via a typedef, e.g., 1265c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 1266c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // typedef int functype(int, int); 1267731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // functype func; 1268513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // 1269513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // In this case, we'll just go instantiate the ParmVarDecls that we 1270c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // synthesized in the method declaration. 1271c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!isa<FunctionProtoType>(T)) { 1272c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(!Params.size() && "Instantiating type could not yield parameters"); 1273c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (unsigned I = 0, N = D->getNumParams(); I != N; ++I) { 1274c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ParmVarDecl *P = SemaRef.SubstParmVarDecl(D->getParamDecl(I), 1275c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs); 1276c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!P) 1277c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 1278c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1279c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Params.push_back(P); 1280731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 1281513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch } 1282513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 1283c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NestedNameSpecifier *Qualifier = D->getQualifier(); 1284c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Qualifier) { 1285c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Qualifier = SemaRef.SubstNestedNameSpecifier(Qualifier, 1286c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getQualifierRange(), 1287c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs); 1288c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Qualifier) return 0; 1289c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1290c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1291c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclContext *DC = Owner; 1292c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isFriend) { 1293731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (Qualifier) { 1294513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch CXXScopeSpec SS; 1295513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch SS.setScopeRep(Qualifier); 1296c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SS.setRange(D->getQualifierRange()); 1297c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DC = SemaRef.computeDeclContext(SS); 1298c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 1299c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DC = SemaRef.FindInstantiatedContext(D->getLocation(), 1300c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getDeclContext(), 1301c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs); 1302c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1303c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!DC) return 0; 1304c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1305c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1306731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Build the instantiated method declaration. 1307513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch CXXRecordDecl *Record = cast<CXXRecordDecl>(DC); 1308513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch CXXMethodDecl *Method = 0; 1309c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1310c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclarationName Name = D->getDeclName(); 1311c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) { 1312c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch QualType ClassTy = SemaRef.Context.getTypeDeclType(Record); 1313c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Name = SemaRef.Context.DeclarationNames.getCXXConstructorName( 1314c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.Context.getCanonicalType(ClassTy)); 1315c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method = CXXConstructorDecl::Create(SemaRef.Context, Record, 1316c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Constructor->getLocation(), 1317c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Name, T, TInfo, 1318c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Constructor->isExplicit(), 1319731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Constructor->isInlineSpecified(), 1320513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch false); 13213345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) { 1322c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch QualType ClassTy = SemaRef.Context.getTypeDeclType(Record); 1323c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Name = SemaRef.Context.DeclarationNames.getCXXDestructorName( 1324c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.Context.getCanonicalType(ClassTy)); 1325c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method = CXXDestructorDecl::Create(SemaRef.Context, Record, 1326c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Destructor->getLocation(), Name, 1327c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch T, Destructor->isInlineSpecified(), 1328c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch false); 1329c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) { 1330c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CanQualType ConvTy 1331c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = SemaRef.Context.getCanonicalType( 1332731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick T->getAs<FunctionType>()->getResultType()); 1333513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Name = SemaRef.Context.DeclarationNames.getCXXConversionFunctionName( 1334513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch ConvTy); 1335c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method = CXXConversionDecl::Create(SemaRef.Context, Record, 1336c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Conversion->getLocation(), Name, 1337c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch T, TInfo, 1338c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Conversion->isInlineSpecified(), 1339c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Conversion->isExplicit()); 1340c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 1341c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method = CXXMethodDecl::Create(SemaRef.Context, Record, D->getLocation(), 1342c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getDeclName(), T, TInfo, 1343c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->isStatic(), 1344c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getStorageClassAsWritten(), 1345731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick D->isInlineSpecified()); 1346513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch } 1347513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 1348c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Qualifier) 1349c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method->setQualifierInfo(Qualifier, D->getQualifierRange()); 1350c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1351c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (TemplateParams) { 1352c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Our resulting instantiation is actually a function template, since we 1353c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // are substituting only the outer template parameters. For example, given 1354c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 1355c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // template<typename T> 1356c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // struct X { 1357c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // template<typename U> void f(T, U); 1358731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // }; 1359513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // 1360513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // X<int> x; 1361c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 1362c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We are instantiating the member template "f" within X<int>, which means 1363c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // substituting int for T, but leaving "f" as a member function template. 1364c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Build the function template itself. 1365c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record, 1366c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method->getLocation(), 1367c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method->getDeclName(), 1368c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParams, Method); 1369c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isFriend) { 1370c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionTemplate->setLexicalDeclContext(Owner); 1371731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick FunctionTemplate->setObjectOfFriendDecl(true); 1372513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch } else if (D->isOutOfLine()) 13733345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext()); 1374c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method->setDescribedFunctionTemplate(FunctionTemplate); 1375c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else if (FunctionTemplate) { 1376c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Record this function template specialization. 1377c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method->setFunctionTemplateSpecialization(FunctionTemplate, 1378c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch &TemplateArgs.getInnermost(), 1379c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InsertPos); 1380c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else if (!isFriend) { 1381c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Record that this is an instantiation of a member function. 1382c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation); 1383c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1384731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1385513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // If we are instantiating a member function defined 1386513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // out-of-line, the instantiation will have the same lexical 1387c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // context (which will be a namespace scope) as the template. 1388c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isFriend) { 1389c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method->setLexicalDeclContext(Owner); 1390c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method->setObjectOfFriendDecl(true); 1391c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else if (D->isOutOfLine()) 1392c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method->setLexicalDeclContext(D->getLexicalDeclContext()); 1393c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1394c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Attach the parameters 1395c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (unsigned P = 0; P < Params.size(); ++P) 1396c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Params[P]->setOwningFunction(Method); 1397c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method->setParams(Params.data(), Params.size()); 1398c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1399731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (InitMethodInstantiation(Method, D)) 1400513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Method->setInvalidDecl(); 14013345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 1402c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch LookupResult Previous(SemaRef, Name, SourceLocation(), 1403c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Sema::LookupOrdinaryName, Sema::ForRedeclaration); 1404c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1405c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!FunctionTemplate || TemplateParams || isFriend) { 1406c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.LookupQualifiedName(Previous, Record); 1407c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1408c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // In C++, the previous declaration we find might be a tag type 1409c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // (class or enum). In this case, the new declaration will hide the 1410c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // tag type. Note that this does does not apply if we're declaring a 1411c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // typedef (C++ [dcl.typedef]p4). 1412731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (Previous.isSingleTagDecl()) 1413513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Previous.clear(); 14143345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } 1415c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1416c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool Redeclaration = false; 1417c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool OverloadableAttrRequired = false; 1418c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CheckFunctionDeclaration(0, Method, Previous, false, Redeclaration, 1419c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch /*FIXME:*/OverloadableAttrRequired); 1420c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1421c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (D->isPure()) 1422c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CheckPureMethod(Method, SourceRange()); 1423c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1424c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Method->setAccess(D->getAccess()); 1425731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1426513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch if (FunctionTemplate) { 14273345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // If there's a function template, let our caller handle it. 1428c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else if (Method->isInvalidDecl() && !Previous.empty()) { 1429c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Don't hide a (potentially) valid declaration with an invalid one. 1430c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 1431c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NamedDecl *DeclToAdd = (TemplateParams 1432c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ? cast<NamedDecl>(FunctionTemplate) 1433c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch : Method); 1434c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isFriend) 1435c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Record->makeDeclVisibleInContext(DeclToAdd); 1436c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch else 1437c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Owner->addDecl(DeclToAdd); 1438731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 1439513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 1440513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch return Method; 1441c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1442c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1443c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 1444c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return VisitCXXMethodDecl(D); 1445c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1446c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1447c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 1448c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return VisitCXXMethodDecl(D); 1449c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1450c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1451731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickDecl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) { 1452513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch return VisitCXXMethodDecl(D); 14533345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 1454c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1455c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochParmVarDecl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) { 1456c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return SemaRef.SubstParmVarDecl(D, TemplateArgs); 1457c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1458c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1459c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl( 1460c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateTypeParmDecl *D) { 1461c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // TODO: don't always clone when decls are refcounted. 1462c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Type* T = D->getTypeForDecl(); 1463c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(T->isTemplateTypeParmType()); 1464731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const TemplateTypeParmType *TTPT = T->getAs<TemplateTypeParmType>(); 1465513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 1466513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch TemplateTypeParmDecl *Inst = 1467c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateTypeParmDecl::Create(SemaRef.Context, Owner, D->getLocation(), 1468c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TTPT->getDepth() - 1, TTPT->getIndex(), 1469c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TTPT->getName(), 1470c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->wasDeclaredWithTypename(), 1471c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->isParameterPack()); 1472c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1473c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (D->hasDefaultArgument()) 1474c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Inst->setDefaultArgument(D->getDefaultArgumentInfo(), false); 1475c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1476c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Introduce this template parameter's instantiation into the instantiation 1477731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // scope. 1478513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst); 14793345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 1480c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Inst; 1481c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1482c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1483c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl( 1484c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NonTypeTemplateParmDecl *D) { 1485c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Substitute into the type of the non-type template parameter. 1486c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch QualType T; 1487c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeSourceInfo *DI = D->getTypeSourceInfo(); 1488c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (DI) { 1489c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DI = SemaRef.SubstType(DI, TemplateArgs, D->getLocation(), 1490731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick D->getDeclName()); 1491513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch if (DI) T = DI->getType(); 14923345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } else { 1493c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch T = SemaRef.SubstType(D->getType(), TemplateArgs, D->getLocation(), 1494c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getDeclName()); 1495c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DI = 0; 1496c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1497c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (T.isNull()) 1498c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 1499c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1500c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Check that this type is acceptable for a non-type template parameter. 1501c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool Invalid = false; 1502c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch T = SemaRef.CheckNonTypeTemplateParameterType(T, D->getLocation()); 1503731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (T.isNull()) { 1504513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch T = SemaRef.Context.IntTy; 15053345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Invalid = true; 1506c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1507c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1508c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NonTypeTemplateParmDecl *Param 1509c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner, D->getLocation(), 1510c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getDepth() - 1, D->getPosition(), 1511c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getIdentifier(), T, DI); 1512c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Invalid) 1513c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Param->setInvalidDecl(); 1514c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1515c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Param->setDefaultArgument(D->getDefaultArgument(), false); 1516731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1517513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // Introduce this template parameter's instantiation into the instantiation 15183345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // scope. 1519c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param); 1520c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Param; 1521c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1522c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1523c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl * 1524c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTemplateDeclInstantiator::VisitTemplateTemplateParmDecl( 1525c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateTemplateParmDecl *D) { 1526c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Instantiate the template parameter list of the template template parameter. 1527c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParameterList *TempParams = D->getTemplateParameters(); 1528c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParameterList *InstParams; 1529731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick { 1530513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // Perform the actual substitution of template parameters within a new, 15313345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // local instantiation scope. 1532c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Sema::LocalInstantiationScope Scope(SemaRef); 1533c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstParams = SubstTemplateParams(TempParams); 1534c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!InstParams) 1535c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return NULL; 1536c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1537c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1538c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Build the template template parameter. 1539c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateTemplateParmDecl *Param 1540c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = TemplateTemplateParmDecl::Create(SemaRef.Context, Owner, D->getLocation(), 1541c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getDepth() - 1, D->getPosition(), 1542731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick D->getIdentifier(), InstParams); 1543513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Param->setDefaultArgument(D->getDefaultArgument(), false); 1544513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 1545c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Introduce this template parameter's instantiation into the instantiation 1546c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // scope. 1547c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param); 1548c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1549c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Param; 1550c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1551c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1552c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 1553c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Using directives are never dependent, so they require no explicit 1554c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1555731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick UsingDirectiveDecl *Inst 1556513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(), 1557513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch D->getNamespaceKeyLocation(), 1558c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getQualifierRange(), D->getQualifier(), 1559c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getIdentLocation(), 1560c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getNominatedNamespace(), 1561c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getCommonAncestor()); 1562c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Owner->addDecl(Inst); 1563c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Inst; 1564c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1565c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1566c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) { 1567c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The nested name specifier is non-dependent, so no transformation 1568731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // is required. 1569513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 15703345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // We only need to do redeclaration lookups if we're in a class 1571c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // scope (in fact, it's not really even possible in non-class 1572c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // scopes). 1573c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool CheckRedeclaration = Owner->isRecord(); 1574c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1575c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch LookupResult Prev(SemaRef, D->getDeclName(), D->getLocation(), 1576c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Sema::LookupUsingDeclName, Sema::ForRedeclaration); 1577c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1578c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner, 1579c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getLocation(), 1580c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getNestedNameRange(), 1581731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick D->getUsingLocation(), 1582513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch D->getTargetNestedNameDecl(), 15833345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick D->getDeclName(), 1584c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->isTypeName()); 1585c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1586c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CXXScopeSpec SS; 1587c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SS.setScopeRep(D->getTargetNestedNameDecl()); 1588c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SS.setRange(D->getNestedNameRange()); 1589c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1590c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (CheckRedeclaration) { 1591c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Prev.setHideTags(false); 1592c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.LookupQualifiedName(Prev, Owner); 1593c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1594731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Check for invalid redeclarations. 1595513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLocation(), 1596513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch D->isTypeName(), SS, 1597c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getLocation(), Prev)) 1598c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NewUD->setInvalidDecl(); 1599c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1600c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1601c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1602c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!NewUD->isInvalidDecl() && 1603c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CheckUsingDeclQualifier(D->getUsingLocation(), SS, 1604c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getLocation())) 1605c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NewUD->setInvalidDecl(); 1606c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1607731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D); 1608513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch NewUD->setAccess(D->getAccess()); 1609513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Owner->addDecl(NewUD); 1610c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1611c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Don't process the shadow decls for an invalid decl. 1612c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (NewUD->isInvalidDecl()) 1613c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return NewUD; 1614c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1615c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool isFunctionScope = Owner->isFunctionOrMethod(); 1616c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1617c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Process the shadow decls. 1618c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (UsingDecl::shadow_iterator I = D->shadow_begin(), E = D->shadow_end(); 1619c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch I != E; ++I) { 1620c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch UsingShadowDecl *Shadow = *I; 1621731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick NamedDecl *InstTarget = 1622513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch cast<NamedDecl>(SemaRef.FindInstantiatedDecl(Shadow->getLocation(), 16233345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Shadow->getTargetDecl(), 1624c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs)); 1625c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1626c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (CheckRedeclaration && 1627c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev)) 1628c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch continue; 1629c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1630c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch UsingShadowDecl *InstShadow 1631c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = SemaRef.BuildUsingShadowDecl(/*Scope*/ 0, NewUD, InstTarget); 1632c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow); 1633c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1634731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (isFunctionScope) 1635513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow); 1636513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch } 1637c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1638c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return NewUD; 1639c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1640c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1641c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) { 1642c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Ignore these; we handle them in bulk when processing the UsingDecl. 1643c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 1644c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1645c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1646c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl * TemplateDeclInstantiator 1647731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ::VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) { 1648513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch NestedNameSpecifier *NNS = 1649513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch SemaRef.SubstNestedNameSpecifier(D->getTargetNestedNameSpecifier(), 1650c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getTargetNestedNameRange(), 1651c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs); 1652c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!NNS) 1653c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 1654c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1655c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CXXScopeSpec SS; 1656c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SS.setRange(D->getTargetNestedNameRange()); 1657c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SS.setScopeRep(NNS); 1658c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1659c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NamedDecl *UD = 1660731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick SemaRef.BuildUsingDeclaration(/*Scope*/ 0, D->getAccess(), 1661513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch D->getUsingLoc(), SS, D->getLocation(), 1662513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch D->getDeclName(), 0, 1663c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch /*instantiation*/ true, 1664c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch /*typename*/ true, D->getTypenameLoc()); 1665c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (UD) 1666c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.Context.setInstantiatedFromUsingDecl(cast<UsingDecl>(UD), D); 1667c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1668c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return UD; 1669c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1670c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1671c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl * TemplateDeclInstantiator 1672c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { 1673731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick NestedNameSpecifier *NNS = 1674513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch SemaRef.SubstNestedNameSpecifier(D->getTargetNestedNameSpecifier(), 16753345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick D->getTargetNestedNameRange(), 1676c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs); 1677c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!NNS) 1678c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 1679c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1680c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CXXScopeSpec SS; 1681c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SS.setRange(D->getTargetNestedNameRange()); 1682c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SS.setScopeRep(NNS); 1683c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1684c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NamedDecl *UD = 1685c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.BuildUsingDeclaration(/*Scope*/ 0, D->getAccess(), 1686731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick D->getUsingLoc(), SS, D->getLocation(), 1687513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch D->getDeclName(), 0, 1688513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch /*instantiation*/ true, 1689c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch /*typename*/ false, SourceLocation()); 1690c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (UD) 1691c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.Context.setInstantiatedFromUsingDecl(cast<UsingDecl>(UD), D); 1692c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1693c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return UD; 1694c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1695c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1696c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDecl *Sema::SubstDecl(Decl *D, DeclContext *Owner, 1697c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const MultiLevelTemplateArgumentList &TemplateArgs) { 1698c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs); 1699731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (D->isInvalidDecl()) 1700513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch return 0; 17013345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 1702c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Instantiator.Visit(D); 1703c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1704c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1705c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \brief Instantiates a nested template parameter list in the current 1706c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// instantiation context. 1707c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 1708c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \param L The parameter list to instantiate 1709c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 1710c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \returns NULL if there was an error 1711c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTemplateParameterList * 1712731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTemplateDeclInstantiator::SubstTemplateParams(TemplateParameterList *L) { 1713513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // Get errors for all the parameters before bailing out. 17143345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick bool Invalid = false; 1715c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1716c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch unsigned N = L->size(); 1717c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch typedef llvm::SmallVector<NamedDecl *, 8> ParamVector; 1718c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ParamVector Params; 1719c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Params.reserve(N); 1720c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (TemplateParameterList::iterator PI = L->begin(), PE = L->end(); 1721c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PI != PE; ++PI) { 1722c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NamedDecl *D = cast_or_null<NamedDecl>(Visit(*PI)); 1723c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Params.push_back(D); 1724c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Invalid = Invalid || !D || D->isInvalidDecl(); 1725731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 1726513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 1727513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // Clean up if we had an error. 1728c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Invalid) { 1729c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (ParamVector::iterator PI = Params.begin(), PE = Params.end(); 1730c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PI != PE; ++PI) 1731c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (*PI) 1732c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch (*PI)->Destroy(SemaRef.Context); 1733c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return NULL; 1734c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1735c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1736c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParameterList *InstL 1737c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(), 1738731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick L->getLAngleLoc(), &Params.front(), N, 1739513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch L->getRAngleLoc()); 17403345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick return InstL; 1741c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1742c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1743c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \brief Instantiate the declaration of a class template partial 1744c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// specialization. 1745c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 1746c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \param ClassTemplate the (instantiated) class template that is partially 1747c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// specialized by the instantiation of \p PartialSpec. 1748c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 1749c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \param PartialSpec the (uninstantiated) class template partial 1750c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// specialization that we are instantiating. 1751c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 1752c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \returns true if there was an error, false otherwise. 1753c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochbool 1754c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization( 1755c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplateDecl *ClassTemplate, 1756731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ClassTemplatePartialSpecializationDecl *PartialSpec) { 1757513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // Create a local instantiation scope for this class template partial 17583345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // specialization, which will contain the instantiations of the template 1759c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // parameters. 1760c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Sema::LocalInstantiationScope Scope(SemaRef); 1761c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1762c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Substitute into the template parameters of the class template partial 1763c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // specialization. 1764c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParameterList *TempParams = PartialSpec->getTemplateParameters(); 1765c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateParameterList *InstParams = SubstTemplateParams(TempParams); 1766c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!InstParams) 1767c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return true; 1768c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1769c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Substitute into the template arguments of the class template partial 1770731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // specialization. 1771513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch const TemplateArgumentLoc *PartialSpecTemplateArgs 17723345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick = PartialSpec->getTemplateArgsAsWritten(); 1773c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch unsigned N = PartialSpec->getNumTemplateArgsAsWritten(); 1774c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1775c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgumentListInfo InstTemplateArgs; // no angle locations 1776c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (unsigned I = 0; I != N; ++I) { 1777c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgumentLoc Loc; 1778c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (SemaRef.Subst(PartialSpecTemplateArgs[I], Loc, TemplateArgs)) 1779c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return true; 1780c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstTemplateArgs.addArgument(Loc); 1781c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1782c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1783c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1784c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Check that the template argument list is well-formed for this 1785731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // class template. 1786513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch TemplateArgumentListBuilder Converted(ClassTemplate->getTemplateParameters(), 17873345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick InstTemplateArgs.size()); 1788c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (SemaRef.CheckTemplateArgumentList(ClassTemplate, 1789c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PartialSpec->getLocation(), 1790c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstTemplateArgs, 1791c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch false, 1792c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Converted)) 1793c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return true; 1794c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1795c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Figure out where to insert this class template partial specialization 1796c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // in the member template's set of class template partial specializations. 1797c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch llvm::FoldingSetNodeID ID; 1798c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplatePartialSpecializationDecl::Profile(ID, 1799c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Converted.getFlatArguments(), 1800731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Converted.flatSize(), 1801513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch SemaRef.Context); 18023345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick void *InsertPos = 0; 1803c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplateSpecializationDecl *PrevDecl 1804c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = ClassTemplate->getPartialSpecializations().FindNodeOrInsertPos(ID, 1805c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InsertPos); 1806c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1807c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Build the canonical type that describes the converted template 1808c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // arguments of the class template partial specialization. 1809c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch QualType CanonType 1810c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate), 1811c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Converted.getFlatArguments(), 1812c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Converted.flatSize()); 1813c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1814c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Build the fully-sugared type for this class template 1815731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // specialization as the user wrote in the specialization 1816513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // itself. This means that we'll pretty-print the type retrieved 18173345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // from the specialization's declaration the way that the user 1818c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // actually wrote the specialization, rather than formatting the 1819c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // name based on the "canonical" representation used to store the 1820c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // template arguments in the specialization. 1821c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeSourceInfo *WrittenTy 1822c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = SemaRef.Context.getTemplateSpecializationTypeInfo( 1823c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateName(ClassTemplate), 1824c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PartialSpec->getLocation(), 1825c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstTemplateArgs, 1826c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CanonType); 1827c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1828c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (PrevDecl) { 1829731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // We've already seen a partial specialization with the same template 1830513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // parameters and template arguments. This can happen, for example, when 18313345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // substituting the outer template arguments ends up causing two 1832c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // class template partial specializations of a member class template 1833c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // to have identical forms, e.g., 1834c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 1835c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // template<typename T, typename U> 1836c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // struct Outer { 1837c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // template<typename X, typename Y> struct Inner; 1838c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // template<typename Y> struct Inner<T, Y>; 1839c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // template<typename Y> struct Inner<U, Y>; 1840c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // }; 1841c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 1842c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Outer<int, int> outer; // error: the partial specializations of Inner 1843c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // // have the same signature. 1844731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared) 1845513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch << WrittenTy; 18463345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here) 1847c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << SemaRef.Context.getTypeDeclType(PrevDecl); 1848c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return true; 1849c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1850c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1851c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1852c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Create the class template partial specialization declaration. 1853c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplatePartialSpecializationDecl *InstPartialSpec 1854c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = ClassTemplatePartialSpecializationDecl::Create(SemaRef.Context, 1855c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PartialSpec->getTagKind(), 1856c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Owner, 1857c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PartialSpec->getLocation(), 1858c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstParams, 1859c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplate, 1860731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Converted, 1861513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch InstTemplateArgs, 18623345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick CanonType, 1863c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 0, 1864c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplate->getPartialSpecializations().size()); 1865c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Substitute the nested name specifier, if any. 1866c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (SubstQualifier(PartialSpec, InstPartialSpec)) 1867c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 1868c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1869c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstPartialSpec->setInstantiatedFromMember(PartialSpec); 1870c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstPartialSpec->setTypeAsWritten(WrittenTy); 1871c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1872c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Add this partial specialization to the set of class template partial 1873c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // specializations. 1874c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplate->getPartialSpecializations().InsertNode(InstPartialSpec, 1875731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick InsertPos); 1876513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch return false; 18773345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 1878c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1879c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTypeSourceInfo* 1880c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D, 1881c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch llvm::SmallVectorImpl<ParmVarDecl *> &Params) { 1882c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeSourceInfo *OldTInfo = D->getTypeSourceInfo(); 1883c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(OldTInfo && "substituting function without type source info"); 1884c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(Params.empty() && "parameter vector is non-empty at start"); 1885c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeSourceInfo *NewTInfo 1886c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs, 1887c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getTypeSpecStartLoc(), 1888c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getDeclName()); 1889c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!NewTInfo) 1890731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick return 0; 1891513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 18923345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick if (NewTInfo != OldTInfo) { 1893c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Get parameters from the new type info. 1894c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeLoc OldTL = OldTInfo->getTypeLoc(); 1895c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (FunctionProtoTypeLoc *OldProtoLoc 1896c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = dyn_cast<FunctionProtoTypeLoc>(&OldTL)) { 1897c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeLoc NewTL = NewTInfo->getTypeLoc(); 1898c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionProtoTypeLoc *NewProtoLoc = cast<FunctionProtoTypeLoc>(&NewTL); 1899c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(NewProtoLoc && "Missing prototype?"); 1900c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (unsigned i = 0, i_end = NewProtoLoc->getNumArgs(); i != i_end; ++i) { 1901c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: Variadic templates will break this. 1902c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Params.push_back(NewProtoLoc->getArg(i)); 1903c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CurrentInstantiationScope->InstantiatedLocal( 1904731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick OldProtoLoc->getArg(i), 1905513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch NewProtoLoc->getArg(i)); 19063345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } 1907c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1908c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 1909c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The function type itself was not dependent and therefore no 1910c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // substitution occurred. However, we still need to instantiate 1911c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // the function parameters themselves. 1912c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeLoc OldTL = OldTInfo->getTypeLoc(); 1913c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (FunctionProtoTypeLoc *OldProtoLoc 1914c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = dyn_cast<FunctionProtoTypeLoc>(&OldTL)) { 1915c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (unsigned i = 0, i_end = OldProtoLoc->getNumArgs(); i != i_end; ++i) { 1916c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ParmVarDecl *Parm = VisitParmVarDecl(OldProtoLoc->getArg(i)); 1917c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Parm) 1918c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 1919731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Params.push_back(Parm); 1920513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch } 19213345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } 1922c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1923c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return NewTInfo; 1924c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1925c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1926c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \brief Initializes the common fields of an instantiation function 1927c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// declaration (New) from the corresponding fields of its template (Tmpl). 1928c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 1929c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \returns true if there was an error 1930c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochbool 1931c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New, 1932c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionDecl *Tmpl) { 1933731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (Tmpl->isDeleted()) 1934513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch New->setDeleted(); 19353345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 1936c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If we are performing substituting explicitly-specified template arguments 1937c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // or deduced template arguments into a function template and we reach this 1938c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // point, we are now past the point where SFINAE applies and have committed 1939c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // to keeping the new function template specialization. We therefore 1940c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // convert the active template instantiation for the function template 1941c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // into a template instantiation for this specific function template 1942c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // specialization, which is not a SFINAE context, so that we diagnose any 1943c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // further errors in the declaration itself. 1944c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch typedef Sema::ActiveTemplateInstantiation ActiveInstType; 1945c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ActiveInstType &ActiveInst = SemaRef.ActiveTemplateInstantiations.back(); 1946c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution || 1947c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) { 1948731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (FunctionTemplateDecl *FunTmpl 1949513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch = dyn_cast<FunctionTemplateDecl>((Decl *)ActiveInst.Entity)) { 19503345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick assert(FunTmpl->getTemplatedDecl() == Tmpl && 1951c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Deduction from the wrong function template?"); 1952c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch (void) FunTmpl; 1953c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ActiveInst.Kind = ActiveInstType::TemplateInstantiation; 1954c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ActiveInst.Entity = reinterpret_cast<uintptr_t>(New); 1955c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch --SemaRef.NonInstantiationEntries; 1956c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1957c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1958c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1959c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>(); 1960c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(Proto && "Function template without prototype?"); 1961c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1962c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Proto->hasExceptionSpec() || Proto->hasAnyExceptionSpec() || 1963c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Proto->getNoReturnAttr()) { 1964c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The function has an exception specification or a "noreturn" 1965731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // attribute. Substitute into each of the exception types. 1966513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch llvm::SmallVector<QualType, 4> Exceptions; 19673345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick for (unsigned I = 0, N = Proto->getNumExceptions(); I != N; ++I) { 1968c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: Poor location information! 1969c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch QualType T 1970c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = SemaRef.SubstType(Proto->getExceptionType(I), TemplateArgs, 1971c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch New->getLocation(), New->getDeclName()); 1972c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (T.isNull() || 1973c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SemaRef.CheckSpecifiedExceptionType(T, New->getLocation())) 1974c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch continue; 1975c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1976c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Exceptions.push_back(T); 1977c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1978c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1979c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Rebuild the function type 1980731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1981513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch const FunctionProtoType *NewProto 19823345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick = New->getType()->getAs<FunctionProtoType>(); 1983c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(NewProto && "Template instantiation without function prototype?"); 1984c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch New->setType(SemaRef.Context.getFunctionType(NewProto->getResultType(), 1985c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NewProto->arg_type_begin(), 1986c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NewProto->getNumArgs(), 1987c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NewProto->isVariadic(), 1988c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NewProto->getTypeQuals(), 1989c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Proto->hasExceptionSpec(), 1990c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Proto->hasAnyExceptionSpec(), 1991c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Exceptions.size(), 1992c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Exceptions.data(), 1993c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Proto->getExtInfo())); 1994c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1995731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1996513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch InstantiateAttrs(Tmpl, New); 19973345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 1998c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 1999c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2000c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2001c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \brief Initializes common fields of an instantiated method 2002c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// declaration (New) from the corresponding fields of its template 2003c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// (Tmpl). 2004c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 2005c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \returns true if there was an error 2006c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochbool 2007c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New, 2008c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CXXMethodDecl *Tmpl) { 2009c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (InitFunctionInstantiation(New, Tmpl)) 2010731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick return true; 2011513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 20123345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick CXXRecordDecl *Record = cast<CXXRecordDecl>(Owner); 2013c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch New->setAccess(Tmpl->getAccess()); 2014c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Tmpl->isVirtualAsWritten()) 2015c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Record->setMethodAsVirtual(New); 2016c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2017c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: attributes 2018c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: New needs a pointer to Tmpl 2019c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 2020c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2021c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2022c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \brief Instantiate the definition of the given function from its 2023c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// template. 2024731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick/// 2025513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch/// \param PointOfInstantiation the point at which the instantiation was 20263345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick/// required. Note that this is not precisely a "point of instantiation" 2027c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// for the function, but it's close. 2028c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 2029c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \param Function the already-instantiated declaration of a 2030c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// function template specialization or member function of a class template 2031c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// specialization. 2032c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 2033c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \param Recursive if true, recursively instantiates any functions that 2034c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// are required by this instantiation. 2035c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 2036c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \param DefinitionRequired if true, then we are performing an explicit 2037c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// instantiation where the body of the function is required. Complain if 2038c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// there is no such body. 2039731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, 2040513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch FunctionDecl *Function, 20413345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick bool Recursive, 2042c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool DefinitionRequired) { 2043c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Function->isInvalidDecl() || Function->hasBody()) 2044c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return; 2045c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2046c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Never instantiate an explicit specialization. 2047c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Function->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) 2048c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return; 2049c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2050c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Find the function body that we'll be substituting. 2051c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern(); 2052c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Stmt *Pattern = 0; 2053c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (PatternDecl) 2054731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Pattern = PatternDecl->getBody(PatternDecl); 2055513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 20563345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick if (!Pattern) { 2057c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (DefinitionRequired) { 2058c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Function->getPrimaryTemplate()) 2059c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Diag(PointOfInstantiation, 2060c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch diag::err_explicit_instantiation_undefined_func_template) 2061c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << Function->getPrimaryTemplate(); 2062c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch else 2063c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Diag(PointOfInstantiation, 2064c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch diag::err_explicit_instantiation_undefined_member) 2065c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << 1 << Function->getDeclName() << Function->getDeclContext(); 2066c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2067c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (PatternDecl) 2068c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Diag(PatternDecl->getLocation(), 2069731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick diag::note_explicit_instantiation_here); 2070513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Function->setInvalidDecl(); 20713345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } 2072c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2073c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return; 2074c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2075c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2076c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // C++0x [temp.explicit]p9: 2077c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Except for inline functions, other explicit instantiation declarations 2078c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // have the effect of suppressing the implicit instantiation of the entity 2079c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // to which they refer. 2080c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Function->getTemplateSpecializationKind() 2081c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch == TSK_ExplicitInstantiationDeclaration && 2082c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch !PatternDecl->isInlined()) 2083731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick return; 2084513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 20853345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick InstantiatingTemplate Inst(*this, PointOfInstantiation, Function); 2086c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Inst) 2087c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return; 2088c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2089c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If we're performing recursive template instantiation, create our own 2090c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // queue of pending implicit instantiations that we will instantiate later, 2091c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // while we're still within our own instantiation context. 2092c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch std::deque<PendingImplicitInstantiation> SavedPendingImplicitInstantiations; 2093c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Recursive) 2094c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PendingImplicitInstantiations.swap(SavedPendingImplicitInstantiations); 2095c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2096c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EnterExpressionEvaluationContext EvalContext(*this, 2097731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Action::PotentiallyEvaluated); 2098513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch ActOnStartOfFunctionDef(0, DeclPtrTy::make(Function)); 20993345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 2100c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Introduce a new scope where local variable instantiations will be 2101c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // recorded, unless we're actually a member function within a local 2102c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // class, in which case we need to merge our results with the parent 2103c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // scope (of the enclosing function). 2104c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool MergeWithParentScope = false; 2105c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext())) 2106c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch MergeWithParentScope = Rec->isLocalClass(); 2107c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2108c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch LocalInstantiationScope Scope(*this, MergeWithParentScope); 2109c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2110c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Introduce the instantiated function parameters into the local 2111c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // instantiation scope. 2112731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) 2113513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Scope.InstantiatedLocal(PatternDecl->getParamDecl(I), 21143345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Function->getParamDecl(I)); 2115c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2116c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Enter the scope of this instantiation. We don't use 2117c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // PushDeclContext because we don't have a scope. 2118c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclContext *PreviousContext = CurContext; 2119c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CurContext = Function; 2120c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2121c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch MultiLevelTemplateArgumentList TemplateArgs = 2122c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch getTemplateInstantiationArgs(Function, 0, false, PatternDecl); 2123c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2124c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If this is a constructor, instantiate the member initializers. 2125c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (const CXXConstructorDecl *Ctor = 2126c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch dyn_cast<CXXConstructorDecl>(PatternDecl)) { 2127731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick InstantiateMemInitializers(cast<CXXConstructorDecl>(Function), Ctor, 2128513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch TemplateArgs); 21293345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } 2130c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2131c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Instantiate the function body. 2132c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch OwningStmtResult Body = SubstStmt(Pattern, TemplateArgs); 2133c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2134c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Body.isInvalid()) 2135c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Function->setInvalidDecl(); 2136c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2137c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ActOnFinishFunctionBody(DeclPtrTy::make(Function), move(Body), 2138c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch /*IsInstantiation=*/true); 2139c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2140c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PerformDependentDiagnostics(PatternDecl, TemplateArgs); 2141c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2142731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CurContext = PreviousContext; 2143513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 21443345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick DeclGroupRef DG(Function); 2145c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Consumer.HandleTopLevelDecl(DG); 2146c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2147c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // This class may have local implicit instantiations that need to be 2148c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // instantiation within this scope. 2149c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PerformPendingImplicitInstantiations(/*LocalOnly=*/true); 2150c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Scope.Exit(); 2151c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2152c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Recursive) { 2153c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Instantiate any pending implicit instantiations found during the 2154c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // instantiation of this template. 2155c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PerformPendingImplicitInstantiations(); 2156731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 2157513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // Restore the set of pending implicit instantiations. 21583345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick PendingImplicitInstantiations.swap(SavedPendingImplicitInstantiations); 2159c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2160c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2161c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2162c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \brief Instantiate the definition of the given variable from its 2163c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// template. 2164c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 2165c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \param PointOfInstantiation the point at which the instantiation was 2166c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// required. Note that this is not precisely a "point of instantiation" 2167c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// for the function, but it's close. 2168c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 2169c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \param Var the already-instantiated declaration of a static member 2170731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick/// variable of a class template specialization. 2171513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch/// 21723345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick/// \param Recursive if true, recursively instantiates any functions that 2173c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// are required by this instantiation. 2174c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 2175c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \param DefinitionRequired if true, then we are performing an explicit 2176c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// instantiation where an out-of-line definition of the member variable 2177c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// is required. Complain if there is no such definition. 2178c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochvoid Sema::InstantiateStaticDataMemberDefinition( 2179c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SourceLocation PointOfInstantiation, 2180c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch VarDecl *Var, 2181c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool Recursive, 2182c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool DefinitionRequired) { 2183c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Var->isInvalidDecl()) 2184731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick return; 2185513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 21863345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // Find the out-of-line definition of this static data member. 2187c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch VarDecl *Def = Var->getInstantiatedFromStaticDataMember(); 2188c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(Def && "This data member was not instantiated from a template?"); 2189c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(Def->isStaticDataMember() && "Not a static data member?"); 2190c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Def = Def->getOutOfLineDefinition(); 2191c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2192c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Def) { 2193c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We did not find an out-of-line definition of this static data member, 2194c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // so we won't perform any instantiation. Rather, we rely on the user to 2195c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // instantiate this definition (or provide a specialization for it) in 2196c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // another translation unit. 2197c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (DefinitionRequired) { 2198c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Def = Var->getInstantiatedFromStaticDataMember(); 2199731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Diag(PointOfInstantiation, 2200513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch diag::err_explicit_instantiation_undefined_member) 22013345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick << 2 << Var->getDeclName() << Var->getDeclContext(); 2202c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Diag(Def->getLocation(), diag::note_explicit_instantiation_here); 2203c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2204c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2205c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return; 2206c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2207c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2208c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Never instantiate an explicit specialization. 2209c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Var->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) 2210c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return; 2211c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2212c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // C++0x [temp.explicit]p9: 22133345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // Except for inline functions, other explicit instantiation declarations 2214731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // have the effect of suppressing the implicit instantiation of the entity 2215513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // to which they refer. 22163345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick if (Var->getTemplateSpecializationKind() 2217c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch == TSK_ExplicitInstantiationDeclaration) 2218c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return; 2219c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2220c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstantiatingTemplate Inst(*this, PointOfInstantiation, Var); 2221c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Inst) 2222c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return; 2223c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2224c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If we're performing recursive template instantiation, create our own 2225c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // queue of pending implicit instantiations that we will instantiate later, 2226c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // while we're still within our own instantiation context. 2227c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch std::deque<PendingImplicitInstantiation> SavedPendingImplicitInstantiations; 2228c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Recursive) 2229c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PendingImplicitInstantiations.swap(SavedPendingImplicitInstantiations); 2230731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 2231513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch // Enter the scope of this instantiation. We don't use 22323345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // PushDeclContext because we don't have a scope. 2233c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclContext *PreviousContext = CurContext; 2234c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CurContext = Var->getDeclContext(); 2235c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2236c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch VarDecl *OldVar = Var; 2237c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(), 2238c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch getTemplateInstantiationArgs(Var))); 2239c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CurContext = PreviousContext; 2240c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2241c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Var) { 2242c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch MemberSpecializationInfo *MSInfo = OldVar->getMemberSpecializationInfo(); 2243c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(MSInfo && "Missing member specialization information?"); 2244c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Var->setTemplateSpecializationKind(MSInfo->getTemplateSpecializationKind(), 2245731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MSInfo->getPointOfInstantiation()); 2246513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch DeclGroupRef DG(Var); 22473345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Consumer.HandleTopLevelDecl(DG); 2248c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2249c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2250c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Recursive) { 2251c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Instantiate any pending implicit instantiations found during the 2252c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // instantiation of this template. 2253c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PerformPendingImplicitInstantiations(); 2254c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2255c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Restore the set of pending implicit instantiations. 2256c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PendingImplicitInstantiations.swap(SavedPendingImplicitInstantiations); 2257c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2258c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2259c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2260731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid 2261513209b27ff55e2841eac0e4120199c23acce758Ben MurdochSema::InstantiateMemInitializers(CXXConstructorDecl *New, 22623345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const CXXConstructorDecl *Tmpl, 2263c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const MultiLevelTemplateArgumentList &TemplateArgs) { 2264c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2265c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch llvm::SmallVector<MemInitTy*, 4> NewInits; 2266c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool AnyErrors = false; 2267c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2268c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Instantiate all the initializers. 2269c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (CXXConstructorDecl::init_const_iterator Inits = Tmpl->init_begin(), 2270c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InitsEnd = Tmpl->init_end(); 2271c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Inits != InitsEnd; ++Inits) { 2272c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CXXBaseOrMemberInitializer *Init = *Inits; 2273c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2274c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SourceLocation LParenLoc, RParenLoc; 2275731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASTOwningVector<&ActionBase::DeleteExpr> NewArgs(*this); 2276513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch llvm::SmallVector<SourceLocation, 4> CommaLocs; 22773345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 2278c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Instantiate the initializer. 2279c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (InstantiateInitializer(*this, Init->getInit(), TemplateArgs, 2280c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch LParenLoc, CommaLocs, NewArgs, RParenLoc)) { 2281c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AnyErrors = true; 2282c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch continue; 2283c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2284c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2285c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch MemInitResult NewInit; 2286c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Init->isBaseInitializer()) { 2287c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeSourceInfo *BaseTInfo = SubstType(Init->getBaseClassInfo(), 2288731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick TemplateArgs, 2289513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch Init->getSourceLocation(), 2290513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch New->getDeclName()); 2291c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!BaseTInfo) { 2292c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AnyErrors = true; 2293c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch New->setInvalidDecl(); 2294c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch continue; 2295c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2296c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2297c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NewInit = BuildBaseInitializer(BaseTInfo->getType(), BaseTInfo, 2298c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch (Expr **)NewArgs.data(), 2299c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NewArgs.size(), 2300c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Init->getLParenLoc(), 2301731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Init->getRParenLoc(), 2302513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch New->getParent()); 23033345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } else if (Init->isMemberInitializer()) { 2304c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FieldDecl *Member; 2305c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2306c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Is this an anonymous union? 2307c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (FieldDecl *UnionInit = Init->getAnonUnionMember()) 2308c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Member = cast<FieldDecl>(FindInstantiatedDecl(Init->getMemberLocation(), 2309c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch UnionInit, TemplateArgs)); 2310c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch else 2311c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Member = cast<FieldDecl>(FindInstantiatedDecl(Init->getMemberLocation(), 2312c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Init->getMember(), 2313c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TemplateArgs)); 2314731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 2315513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch NewInit = BuildMemberInitializer(Member, (Expr **)NewArgs.data(), 23163345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick NewArgs.size(), 2317c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Init->getSourceLocation(), 2318c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Init->getLParenLoc(), 2319c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Init->getRParenLoc()); 2320c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2321c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2322c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (NewInit.isInvalid()) { 2323c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AnyErrors = true; 2324c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch New->setInvalidDecl(); 2325c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 2326c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: It would be nice if ASTOwningVector had a release function. 2327731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick NewArgs.take(); 2328513209b27ff55e2841eac0e4120199c23acce758Ben Murdoch 23293345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick NewInits.push_back((MemInitTy *)NewInit.get()); 2330c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2331c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2332c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2333c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Assign all the initializers to the new constructor. 2334c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ActOnMemInitializers(DeclPtrTy::make(New), 2335c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch /*FIXME: ColonLoc */ 2336c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SourceLocation(), 2337c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NewInits.data(), NewInits.size(), 2338c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AnyErrors); 2339c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2340c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2341c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// TODO: this could be templated if the various decl types used the 2342c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// same method name. 2343c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic bool isInstantiationOf(ClassTemplateDecl *Pattern, 2344c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplateDecl *Instance) { 2345c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Pattern = Pattern->getCanonicalDecl(); 2346c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2347c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch do { 2348c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = Instance->getCanonicalDecl(); 2349c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Pattern == Instance) return true; 2350c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = Instance->getInstantiatedFromMemberTemplate(); 2351c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } while (Instance); 2352c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2353c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 2354c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2355c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2356c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic bool isInstantiationOf(FunctionTemplateDecl *Pattern, 2357c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionTemplateDecl *Instance) { 2358c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Pattern = Pattern->getCanonicalDecl(); 2359c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2360c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch do { 2361c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = Instance->getCanonicalDecl(); 2362c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Pattern == Instance) return true; 2363c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = Instance->getInstantiatedFromMemberTemplate(); 2364c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } while (Instance); 2365c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2366c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 2367c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 23683345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 2369c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic bool 2370c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochisInstantiationOf(ClassTemplatePartialSpecializationDecl *Pattern, 2371c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplatePartialSpecializationDecl *Instance) { 2372c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Pattern 2373c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl()); 2374c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch do { 2375c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = cast<ClassTemplatePartialSpecializationDecl>( 2376c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance->getCanonicalDecl()); 2377c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Pattern == Instance) 2378c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return true; 2379c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = Instance->getInstantiatedFromMember(); 2380c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } while (Instance); 2381c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2382c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 2383c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2384c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2385c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic bool isInstantiationOf(CXXRecordDecl *Pattern, 2386c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CXXRecordDecl *Instance) { 2387c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Pattern = Pattern->getCanonicalDecl(); 2388c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2389c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch do { 2390c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = Instance->getCanonicalDecl(); 2391c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Pattern == Instance) return true; 2392c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = Instance->getInstantiatedFromMemberClass(); 2393c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } while (Instance); 2394c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2395c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 2396c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2397c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2398c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic bool isInstantiationOf(FunctionDecl *Pattern, 2399c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FunctionDecl *Instance) { 2400c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Pattern = Pattern->getCanonicalDecl(); 2401c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2402c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch do { 2403c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = Instance->getCanonicalDecl(); 2404c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Pattern == Instance) return true; 2405c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = Instance->getInstantiatedFromMemberFunction(); 2406c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } while (Instance); 2407c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2408c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 2409c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2410c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2411c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic bool isInstantiationOf(EnumDecl *Pattern, 2412c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EnumDecl *Instance) { 2413c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Pattern = Pattern->getCanonicalDecl(); 2414c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2415c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch do { 2416c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = Instance->getCanonicalDecl(); 2417c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Pattern == Instance) return true; 2418c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = Instance->getInstantiatedFromMemberEnum(); 2419c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } while (Instance); 2420c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2421c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 2422c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2423c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2424c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic bool isInstantiationOf(UsingShadowDecl *Pattern, 2425c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch UsingShadowDecl *Instance, 2426c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASTContext &C) { 2427c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return C.getInstantiatedFromUsingShadowDecl(Instance) == Pattern; 2428c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2429c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2430c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic bool isInstantiationOf(UsingDecl *Pattern, 2431c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch UsingDecl *Instance, 2432c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASTContext &C) { 2433c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return C.getInstantiatedFromUsingDecl(Instance) == Pattern; 2434c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2435c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2436c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic bool isInstantiationOf(UnresolvedUsingValueDecl *Pattern, 2437c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch UsingDecl *Instance, 2438c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASTContext &C) { 2439c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return C.getInstantiatedFromUsingDecl(Instance) == Pattern; 2440c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2441c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2442c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic bool isInstantiationOf(UnresolvedUsingTypenameDecl *Pattern, 2443c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch UsingDecl *Instance, 2444c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASTContext &C) { 24453345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick return C.getInstantiatedFromUsingDecl(Instance) == Pattern; 2446c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2447c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2448c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic bool isInstantiationOfStaticDataMember(VarDecl *Pattern, 2449c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch VarDecl *Instance) { 2450c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(Instance->isStaticDataMember()); 2451c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2452c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Pattern = Pattern->getCanonicalDecl(); 2453c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2454c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch do { 2455c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = Instance->getCanonicalDecl(); 2456c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Pattern == Instance) return true; 2457c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Instance = Instance->getInstantiatedFromStaticDataMember(); 2458c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } while (Instance); 2459c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2460c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 2461c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2462c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2463c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Other is the prospective instantiation 2464c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// D is the prospective pattern 2465c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) { 2466c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (D->getKind() != Other->getKind()) { 2467c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (UnresolvedUsingTypenameDecl *UUD 2468c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = dyn_cast<UnresolvedUsingTypenameDecl>(D)) { 2469c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (UsingDecl *UD = dyn_cast<UsingDecl>(Other)) { 2470c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return isInstantiationOf(UUD, UD, Ctx); 2471c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2472c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2473c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2474c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (UnresolvedUsingValueDecl *UUD 2475c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = dyn_cast<UnresolvedUsingValueDecl>(D)) { 2476c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (UsingDecl *UD = dyn_cast<UsingDecl>(Other)) { 2477c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return isInstantiationOf(UUD, UD, Ctx); 2478c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2479c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2480c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2481c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 2482c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2483c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2484c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Other)) 2485c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return isInstantiationOf(cast<CXXRecordDecl>(D), Record); 2486c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2487c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Other)) 2488c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return isInstantiationOf(cast<FunctionDecl>(D), Function); 2489c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2490c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (EnumDecl *Enum = dyn_cast<EnumDecl>(Other)) 2491c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return isInstantiationOf(cast<EnumDecl>(D), Enum); 2492c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2493c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (VarDecl *Var = dyn_cast<VarDecl>(Other)) 2494c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Var->isStaticDataMember()) 2495c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var); 2496c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2497c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (ClassTemplateDecl *Temp = dyn_cast<ClassTemplateDecl>(Other)) 2498c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp); 2499c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2500c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (FunctionTemplateDecl *Temp = dyn_cast<FunctionTemplateDecl>(Other)) 2501c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp); 2502c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2503c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (ClassTemplatePartialSpecializationDecl *PartialSpec 2504c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = dyn_cast<ClassTemplatePartialSpecializationDecl>(Other)) 2505c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D), 2506c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PartialSpec); 2507c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2508c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (FieldDecl *Field = dyn_cast<FieldDecl>(Other)) { 2509c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Field->getDeclName()) { 2510c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // This is an unnamed field. 2511c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Ctx.getInstantiatedFromUnnamedFieldDecl(Field) == 2512c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch cast<FieldDecl>(D); 2513c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2514c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2515c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2516c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (UsingDecl *Using = dyn_cast<UsingDecl>(Other)) 2517c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx); 2518c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2519c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(Other)) 2520c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx); 2521c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2522c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return D->getDeclName() && isa<NamedDecl>(Other) && 2523c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D->getDeclName() == cast<NamedDecl>(Other)->getDeclName(); 2524c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2525c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2526c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate<typename ForwardIterator> 2527c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic NamedDecl *findInstantiationOf(ASTContext &Ctx, 2528c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NamedDecl *D, 2529c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ForwardIterator first, 2530c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ForwardIterator last) { 2531c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (; first != last; ++first) 2532c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isInstantiationOf(Ctx, D, *first)) 2533c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return cast<NamedDecl>(*first); 2534c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2535c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 2536c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2537c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2538c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \brief Finds the instantiation of the given declaration context 2539c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// within the current instantiation. 2540c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 2541c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \returns NULL if there was an error 2542c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochDeclContext *Sema::FindInstantiatedContext(SourceLocation Loc, DeclContext* DC, 2543c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const MultiLevelTemplateArgumentList &TemplateArgs) { 2544c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) { 2545c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs); 2546c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return cast_or_null<DeclContext>(ID); 2547c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else return DC; 2548c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2549c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2550c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \brief Find the instantiation of the given declaration within the 2551c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// current instantiation. 2552c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 25533345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick/// This routine is intended to be used when \p D is a declaration 2554c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// referenced from within a template, that needs to mapped into the 2555c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// corresponding declaration within an instantiation. For example, 2556c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// given: 2557c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 2558c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \code 2559c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// template<typename T> 2560c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// struct X { 2561c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// enum Kind { 2562c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// KnownValue = sizeof(T) 2563c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// }; 2564c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 2565c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// bool getKind() const { return KnownValue; } 2566c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// }; 2567c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 2568c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// template struct X<int>; 2569c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \endcode 2570c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// 2571c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// In the instantiation of X<int>::getKind(), we need to map the 2572c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// EnumConstantDecl for KnownValue (which refers to 2573c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// X<T>::<Kind>::KnownValue) to its instantiation 2574c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// (X<int>::<Kind>::KnownValue). InstantiateCurrentDeclRef() performs 2575c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// this mapping from within the instantiation of X<int>. 2576c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochNamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, 2577c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const MultiLevelTemplateArgumentList &TemplateArgs) { 2578c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclContext *ParentDC = D->getDeclContext(); 2579c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) || 2580c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) || 2581c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ParentDC->isFunctionOrMethod()) { 2582c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // D is a local of some kind. Look into the map of local 2583c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // declarations to their instantiations. 2584c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return cast<NamedDecl>(CurrentInstantiationScope->getInstantiationOf(D)); 2585c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2586c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2587c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) { 2588c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Record->isDependentContext()) 25893345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick return D; 2590c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2591c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If the RecordDecl is actually the injected-class-name or a 2592c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // "templated" declaration for a class template, class template 2593c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // partial specialization, or a member class of a class template, 2594c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // substitute into the injected-class-name of the class template 2595c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // or partial specialization to find the new DeclContext. 2596c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch QualType T; 2597c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate(); 2598c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2599c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (ClassTemplate) { 2600c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch T = ClassTemplate->getInjectedClassNameSpecialization(Context); 2601c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else if (ClassTemplatePartialSpecializationDecl *PartialSpec 2602c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) { 2603c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ClassTemplate = PartialSpec->getSpecializedTemplate(); 2604c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2605c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If we call SubstType with an InjectedClassNameType here we 2606c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // can end up in an infinite loop. 2607c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch T = Context.getTypeDeclType(Record); 2608c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(isa<InjectedClassNameType>(T) && 2609c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "type of partial specialization is not an InjectedClassNameType"); 2610c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType(); 2611c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2612c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2613c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!T.isNull()) { 2614c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Substitute into the injected-class-name to get the type 2615c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // corresponding to the instantiation we want, which may also be 2616c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // the current instantiation (if we're in a template 2617c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // definition). This substitution should never fail, since we 2618c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // know we can instantiate the injected-class-name or we 2619c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // wouldn't have gotten to the injected-class-name! 2620c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2621c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: Can we use the CurrentInstantiationScope to avoid this 2622c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // extra instantiation in the common case? 2623c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch T = SubstType(T, TemplateArgs, SourceLocation(), DeclarationName()); 2624c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(!T.isNull() && "Instantiation of injected-class-name cannot fail."); 2625c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2626c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!T->isDependentType()) { 2627c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(T->isRecordType() && "Instantiation must produce a record type"); 2628c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return T->getAs<RecordType>()->getDecl(); 2629c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2630c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2631c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We are performing "partial" template instantiation to create 2632c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // the member declarations for the members of a class template 2633c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // specialization. Therefore, D is actually referring to something 2634c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // in the current instantiation. Look through the current 2635c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // context, which contains actual instantiations, to find the 2636c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // instantiation of the "current instantiation" that D refers 2637c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // to. 2638c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool SawNonDependentContext = false; 2639c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (DeclContext *DC = CurContext; !DC->isFileContext(); 2640c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DC = DC->getParent()) { 2641c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (ClassTemplateSpecializationDecl *Spec 2642c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch = dyn_cast<ClassTemplateSpecializationDecl>(DC)) 2643c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (isInstantiationOf(ClassTemplate, 2644c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Spec->getSpecializedTemplate())) 2645c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Spec; 2646c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2647c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!DC->isDependentContext()) 2648c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SawNonDependentContext = true; 2649c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2650c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2651c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We're performing "instantiation" of a member of the current 2652c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // instantiation while we are type-checking the 2653c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // definition. Compute the declaration context and return that. 2654c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(!SawNonDependentContext && 2655c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "No dependent context while instantiating record"); 2656c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclContext *DC = computeDeclContext(T); 2657c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(DC && 2658c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Unable to find declaration for the current instantiation"); 2659c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return cast<CXXRecordDecl>(DC); 2660c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2661c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2662c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Fall through to deal with other dependent record types (e.g., 2663c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // anonymous unions in class templates). 2664c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2665c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2666c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!ParentDC->isDependentContext()) 2667c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return D; 2668c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2669c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs); 2670c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!ParentDC) 2671c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 2672c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2673c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (ParentDC != D->getDeclContext()) { 2674c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We performed some kind of instantiation in the parent context, 2675c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // so now we need to look into the instantiated parent context to 2676c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // find the instantiation of the declaration D. 2677c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2678c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If our context used to be dependent, we may need to instantiate 2679c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // it before performing lookup into that context. 2680c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) { 2681c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Spec->isDependentContext()) { 2682c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch QualType T = Context.getTypeDeclType(Spec); 2683c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const RecordType *Tag = T->getAs<RecordType>(); 2684c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(Tag && "type of non-dependent record is not a RecordType"); 2685c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (!Tag->isBeingDefined() && 2686c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch RequireCompleteType(Loc, T, diag::err_incomplete_type)) 2687c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return 0; 2688c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2689c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2690c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2691c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NamedDecl *Result = 0; 2692c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (D->getDeclName()) { 2693c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DeclContext::lookup_result Found = ParentDC->lookup(D->getDeclName()); 2694c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Result = findInstantiationOf(Context, D, Found.first, Found.second); 2695c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 2696c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Since we don't have a name for the entity we're looking for, 2697c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // our only option is to walk through all of the declarations to 2698c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // find that name. This will occur in a few cases: 2699c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 2700c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // - anonymous struct/union within a template 2701c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // - unnamed class/struct/union/enum within a template 2702c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 2703c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FIXME: Find a better way to find these instantiations! 2704c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Result = findInstantiationOf(Context, D, 2705c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ParentDC->decls_begin(), 2706c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ParentDC->decls_end()); 2707c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2708c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2709c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // UsingShadowDecls can instantiate to nothing because of using hiding. 2710c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert((Result || isa<UsingShadowDecl>(D) || D->isInvalidDecl() || 2711c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch cast<Decl>(ParentDC)->isInvalidDecl()) 2712c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch && "Unable to find instantiation of declaration!"); 27133345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 2714c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch D = Result; 2715c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2716c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2717c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return D; 2718c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2719c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2720c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch/// \brief Performs template instantiation for all implicit template 27213345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick/// instantiations we have seen until this point. 2722c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochvoid Sema::PerformPendingImplicitInstantiations(bool LocalOnly) { 2723c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch while (!PendingLocalImplicitInstantiations.empty() || 2724c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch (!LocalOnly && !PendingImplicitInstantiations.empty())) { 2725c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PendingImplicitInstantiation Inst; 2726c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2727c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (PendingLocalImplicitInstantiations.empty()) { 2728c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Inst = PendingImplicitInstantiations.front(); 2729c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PendingImplicitInstantiations.pop_front(); 2730c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 2731c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Inst = PendingLocalImplicitInstantiations.front(); 2732c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PendingLocalImplicitInstantiations.pop_front(); 2733c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2734c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2735c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Instantiate function definitions 2736c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) { 2737c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PrettyStackTraceActionsDecl CrashInfo(DeclPtrTy::make(Function), 2738c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Function->getLocation(), *this, 2739c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Context.getSourceManager(), 2740c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "instantiating function definition"); 2741c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2742c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true); 2743c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch continue; 2744c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2745c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2746c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Instantiate static data member definitions. 2747c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch VarDecl *Var = cast<VarDecl>(Inst.first); 2748c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(Var->isStaticDataMember() && "Not a static data member?"); 2749c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2750c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Don't try to instantiate declarations if the most recent redeclaration 2751c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // is invalid. 2752c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (Var->getMostRecentDeclaration()->isInvalidDecl()) 2753c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch continue; 2754c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2755c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Check if the most recent declaration has changed the specialization kind 2756c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // and removed the need for implicit instantiation. 2757c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch switch (Var->getMostRecentDeclaration()->getTemplateSpecializationKind()) { 2758c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch case TSK_Undeclared: 2759c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch assert(false && "Cannot instantitiate an undeclared specialization."); 2760c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch case TSK_ExplicitInstantiationDeclaration: 2761c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch case TSK_ExplicitInstantiationDefinition: 2762c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch case TSK_ExplicitSpecialization: 2763c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch continue; // No longer need implicit instantiation. 2764c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch case TSK_ImplicitInstantiation: 2765c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch break; 2766c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2767c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2768c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PrettyStackTraceActionsDecl CrashInfo(DeclPtrTy::make(Var), 2769c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Var->getLocation(), *this, 2770c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Context.getSourceManager(), 2771731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "instantiating static data member " 2772731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "definition"); 2773731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 2774731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick InstantiateStaticDataMemberDefinition(/*FIXME:*/Inst.second, Var, true); 2775731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 2776731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 2777731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 2778731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid Sema::PerformDependentDiagnostics(const DeclContext *Pattern, 2779731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const MultiLevelTemplateArgumentList &TemplateArgs) { 2780731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick for (DeclContext::ddiag_iterator I = Pattern->ddiag_begin(), 2781731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick E = Pattern->ddiag_end(); I != E; ++I) { 2782731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick DependentDiagnostic *DD = *I; 2783731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 2784731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick switch (DD->getKind()) { 2785731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick case DependentDiagnostic::Access: 2786731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick HandleDependentAccessCheck(*DD, TemplateArgs); 2787731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick break; 2788731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 2789731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 2790731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 2791731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick