From: Douglas Gregor Date: Wed, 13 May 2009 20:28:22 +0000 (+0000) Subject: Explicit instantiations of templates now instantiate the definitions X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=a58861f6490780baec50689e06ca65f7438b85dc;p=clang Explicit instantiations of templates now instantiate the definitions of class members (recursively). Only member classes are actually instantiated; the instantiation logic for member functions and variables are just stubs. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@71713 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h index 46120bcb38..9d5afbbb9c 100644 --- a/lib/Sema/Sema.h +++ b/lib/Sema/Sema.h @@ -2116,6 +2116,14 @@ public: ClassTemplateSpecializationDecl *ClassTemplateSpec, bool ExplicitInstantiation); + void InstantiateClassMembers(SourceLocation PointOfInstantiation, + CXXRecordDecl *Instantiation, + const TemplateArgumentList &TemplateArgs); + + void InstantiateClassTemplateSpecializationMembers( + SourceLocation PointOfInstantiation, + ClassTemplateSpecializationDecl *ClassTemplateSpec); + NestedNameSpecifier * InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS, SourceRange Range, @@ -2125,6 +2133,9 @@ public: InstantiateTemplateName(TemplateName Name, SourceLocation Loc, const TemplateArgumentList &TemplateArgs); + void InstantiateFunctionDefinition(FunctionDecl *Function); + void InstantiateVariableDefinition(VarDecl *Var); + // Simple function for cloning expressions. template OwningExprResult Clone(T *E) { diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp index adf9ea4941..22f2bef0e9 100644 --- a/lib/Sema/SemaTemplate.cpp +++ b/lib/Sema/SemaTemplate.cpp @@ -2335,9 +2335,10 @@ Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc, InstantiateClassTemplateSpecialization(Specialization, true)) return true; - // FIXME: Instantiate all of the members of the template (that - // haven't already been instantiated!). - + // Instantiate the members of this class template specialization. + InstantiatingTemplate Inst(*this, TemplateLoc, Specialization); + InstantiateClassTemplateSpecializationMembers(TemplateLoc, Specialization); + return DeclPtrTy::make(Specialization); } diff --git a/lib/Sema/SemaTemplateInstantiate.cpp b/lib/Sema/SemaTemplateInstantiate.cpp index 3a2f677755..9c2c4230f9 100644 --- a/lib/Sema/SemaTemplateInstantiate.cpp +++ b/lib/Sema/SemaTemplateInstantiate.cpp @@ -749,6 +749,10 @@ Sema::InstantiateClass(SourceLocation PointOfInstantiation, // Exit the scope of this instantiation. CurContext = PreviousContext; + // If this is an explicit instantiation, instantiate our members, too. + if (!Invalid && ExplicitInstantiation) + InstantiateClassMembers(PointOfInstantiation, Instantiation, TemplateArgs); + return Invalid; } @@ -787,6 +791,53 @@ Sema::InstantiateClassTemplateSpecialization( ExplicitInstantiation); } +/// \brief Instantiate the definitions of all of the member of the +/// given class, which is an instantiation of a class template or a +/// member class of a template. +void +Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation, + CXXRecordDecl *Instantiation, + const TemplateArgumentList &TemplateArgs) { + for (DeclContext::decl_iterator D = Instantiation->decls_begin(Context), + DEnd = Instantiation->decls_end(Context); + D != DEnd; ++D) { + if (FunctionDecl *Function = dyn_cast(*D)) { + if (!Function->getBody(Context)) + InstantiateFunctionDefinition(Function); + } else if (VarDecl *Var = dyn_cast(*D)) { + const VarDecl *Def = 0; + if (!Var->getDefinition(Def)) + InstantiateVariableDefinition(Var); + } else if (CXXRecordDecl *Record = dyn_cast(*D)) { + if (!Record->isInjectedClassName() && !Record->getDefinition(Context)) { + assert(Record->getInstantiatedFromMemberClass() && + "Missing instantiated-from-template information"); + InstantiateClass(Record->getLocation(), Record, + Record->getInstantiatedFromMemberClass(), + TemplateArgs, true); + } + } + } +} + +/// \brief Instantiate the definitions of all of the members of the +/// given class template specialization, which was named as part of an +/// explicit instantiation. +void Sema::InstantiateClassTemplateSpecializationMembers( + SourceLocation PointOfInstantiation, + ClassTemplateSpecializationDecl *ClassTemplateSpec) { + // C++0x [temp.explicit]p7: + // An explicit instantiation that names a class template + // specialization is an explicit instantion of the same kind + // (declaration or definition) of each of its members (not + // including members inherited from base classes) that has not + // been previously explicitly specialized in the translation unit + // containing the explicit instantiation, except as described + // below. + InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec, + ClassTemplateSpec->getTemplateArgs()); +} + /// \brief Instantiate a nested-name-specifier. NestedNameSpecifier * Sema::InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS, diff --git a/lib/Sema/SemaTemplateInstantiateDecl.cpp b/lib/Sema/SemaTemplateInstantiateDecl.cpp index b254a40da7..92d253d3ba 100644 --- a/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -550,3 +550,20 @@ TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New, // FIXME: New needs a pointer to Tmpl return false; } + +/// \brief Instantiate the definition of the given function from its +/// template. +/// +/// \param Function the already-instantiated declaration of a +/// function. +void Sema::InstantiateFunctionDefinition(FunctionDecl *Function) { + // FIXME: Implement this! +} + +/// \brief Instantiate the definition of the given variable from its +/// template. +/// +/// \param Var the already-instantiated declaration of a variable. +void Sema::InstantiateVariableDefinition(VarDecl *Var) { + // FIXME: Implement this! +} diff --git a/test/SemaTemplate/temp_explicit.cpp b/test/SemaTemplate/temp_explicit.cpp index b6009bd9c1..0b96c73c1f 100644 --- a/test/SemaTemplate/temp_explicit.cpp +++ b/test/SemaTemplate/temp_explicit.cpp @@ -1,4 +1,4 @@ -// RUN: clang-cc -fsyntax-only -verify -pedantic %s +// RUN: clang-cc -fsyntax-only -pedantic -verify %s // // Tests explicit instantiation of templates. template class X0 { }; @@ -46,3 +46,28 @@ struct X2 { template struct X2; // okay template struct X2; // expected-note{{in instantiation of}} + +// Check that explicit instantiations instantiate member classes. +template struct X3 { + struct Inner { // expected-note{{here}} + void f(T*); // expected-error{{pointer to a reference}} + }; +}; + +void f1(X3); // okay, Inner, not instantiated + +template struct X3; // expected-note{{instantiation}} + +template struct X4 { + struct Inner { // expected-note 2{{here}} + struct VeryInner { // expected-note 2{{here}} + void f(T*); // expected-error 2{{pointer to a reference}} + }; + }; +}; + +void f2(X4); // okay, Inner, not instantiated +void f3(X4::Inner); // okay, Inner::VeryInner, not instantiated + +template struct X4; // expected-note{{instantiation}} +template struct X4; // expected-note{{instantiation}}