From 39cacdb04b29099084cb7760cc3e823f551ecbaf Mon Sep 17 00:00:00 2001 From: Douglas Gregor Date: Fri, 28 Aug 2009 20:50:45 +0000 Subject: [PATCH] Tighten up the conversion from a single-level template argument list to a multi-level template argument list by making it explicit. The forced auditing of callers found a bug in the instantiation of member classes inside member templates. I *love* static type systems. llvm-svn: 80391 --- clang/lib/Sema/SemaTemplate.cpp | 3 ++- clang/lib/Sema/SemaTemplate.h | 3 ++- clang/lib/Sema/SemaTemplateDeduction.cpp | 24 ++++++++++--------- clang/lib/Sema/SemaType.cpp | 11 +++------ .../instantiate-member-template.cpp | 12 +++++++++- 5 files changed, 31 insertions(+), 22 deletions(-) diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index 4fa09d8fda9b..d72cea090710 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -1319,7 +1319,8 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, TemplateArgumentList TemplateArgs(Context, Converted, /*TakeArgs=*/false); - NTTPType = SubstType(NTTPType, TemplateArgs, + NTTPType = SubstType(NTTPType, + MultiLevelTemplateArgumentList(TemplateArgs), NTTP->getLocation(), NTTP->getDeclName()); // If that worked, check the non-type template parameter type diff --git a/clang/lib/Sema/SemaTemplate.h b/clang/lib/Sema/SemaTemplate.h index b400cb3aba72..59bb54233e4f 100644 --- a/clang/lib/Sema/SemaTemplate.h +++ b/clang/lib/Sema/SemaTemplate.h @@ -38,7 +38,7 @@ namespace clang { /// template argument list (17) at depth 1. struct MultiLevelTemplateArgumentList { /// \brief The template argument lists, stored from the innermost template - /// argument list (first) to the outermost template argument list (last) + /// argument list (first) to the outermost template argument list (last). llvm::SmallVector TemplateArgumentLists; public: @@ -46,6 +46,7 @@ namespace clang { MultiLevelTemplateArgumentList() { } /// \brief Construct a single-level template argument list. + explicit MultiLevelTemplateArgumentList(const TemplateArgumentList &TemplateArgs) { TemplateArgumentLists.push_back(&TemplateArgs); } diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp index ec198e0ffb1e..2253a4e6a7e5 100644 --- a/clang/lib/Sema/SemaTemplateDeduction.cpp +++ b/clang/lib/Sema/SemaTemplateDeduction.cpp @@ -967,8 +967,9 @@ Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, for (unsigned I = 0, N = PartialTemplateArgs.flat_size(); I != N; ++I) { Decl *Param = const_cast( ClassTemplate->getTemplateParameters()->getParam(I)); - TemplateArgument InstArg = Subst(PartialTemplateArgs[I], - *DeducedArgumentList); + TemplateArgument InstArg + = Subst(PartialTemplateArgs[I], + MultiLevelTemplateArgumentList(*DeducedArgumentList)); if (InstArg.isNull()) { Info.Param = makeTemplateParameter(Param); Info.FirstArg = PartialTemplateArgs[I]; @@ -1118,10 +1119,10 @@ Sema::SubstituteExplicitTemplateArguments( PEnd = Function->param_end(); P != PEnd; ++P) { - QualType ParamType = SubstType((*P)->getType(), - *ExplicitArgumentList, - (*P)->getLocation(), - (*P)->getDeclName()); + QualType ParamType + = SubstType((*P)->getType(), + MultiLevelTemplateArgumentList(*ExplicitArgumentList), + (*P)->getLocation(), (*P)->getDeclName()); if (ParamType.isNull() || Trap.hasErrorOccurred()) return TDK_SubstitutionFailure; @@ -1136,10 +1137,11 @@ Sema::SubstituteExplicitTemplateArguments( = Function->getType()->getAsFunctionProtoType(); assert(Proto && "Function template does not have a prototype?"); - QualType ResultType = SubstType(Proto->getResultType(), - *ExplicitArgumentList, - Function->getTypeSpecStartLoc(), - Function->getDeclName()); + QualType ResultType + = SubstType(Proto->getResultType(), + MultiLevelTemplateArgumentList(*ExplicitArgumentList), + Function->getTypeSpecStartLoc(), + Function->getDeclName()); if (ResultType.isNull() || Trap.hasErrorOccurred()) return TDK_SubstitutionFailure; @@ -1215,7 +1217,7 @@ Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, Specialization = cast_or_null( SubstDecl(FunctionTemplate->getTemplatedDecl(), FunctionTemplate->getDeclContext(), - *DeducedArgumentList)); + MultiLevelTemplateArgumentList(*DeducedArgumentList))); if (!Specialization) return TDK_SubstitutionFailure; diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index 783795235349..284dea2b754d 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -1787,14 +1787,9 @@ bool Sema::RequireCompleteType(SourceLocation Loc, QualType T, } else if (CXXRecordDecl *Rec = dyn_cast(Record->getDecl())) { if (CXXRecordDecl *Pattern = Rec->getInstantiatedFromMemberClass()) { - // Find the class template specialization that surrounds this - // member class. - ClassTemplateSpecializationDecl *Spec = 0; - for (DeclContext *Parent = Rec->getDeclContext(); - Parent && !Spec; Parent = Parent->getParent()) - Spec = dyn_cast(Parent); - assert(Spec && "Not a member of a class template specialization?"); - return InstantiateClass(Loc, Rec, Pattern, Spec->getTemplateArgs(), + // This record was instantiated from a class within a template. + return InstantiateClass(Loc, Rec, Pattern, + getTemplateInstantiationArgs(Rec), /*ExplicitInstantiation=*/false, /*Complain=*/diag != 0); } diff --git a/clang/test/SemaTemplate/instantiate-member-template.cpp b/clang/test/SemaTemplate/instantiate-member-template.cpp index eb6a4500306e..be5665b9892f 100644 --- a/clang/test/SemaTemplate/instantiate-member-template.cpp +++ b/clang/test/SemaTemplate/instantiate-member-template.cpp @@ -32,7 +32,14 @@ struct X1 { template struct Inner1 { U x; // expected-error{{void}} - T y; + T y; + }; + + template + struct Inner2 { + struct SuperInner { + U z; // expected-error{{void}} + }; }; }; @@ -42,4 +49,7 @@ void test_X1() { X1::Inner1 *xivp; // okay X1::Inner1 xiv; // expected-note{{instantiation}} + + X1::Inner2::SuperInner *xisivp; // okay + X1::Inner2::SuperInner xisiv; // expected-note{{instantiation}} }