commit 357bbd022c1d340c8e255aea7a684ddb34bc76e5
author Douglas Gregor <dgregor@apple.com> Fri Aug 28 20:50:45 2009 +0000
committer Douglas Gregor <dgregor@apple.com> Fri Aug 28 20:50:45 2009 +0000
tree 668efdbda10cd6080ad5057c6922ecb3f0278fce
parent c18faf67c366f79035e364944d7df7f281ddf5a4

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.



git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@80391 91177308-0d34-0410-b5e6-96231b3b80d8

lib/Sema/SemaTemplate.cpp

diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp
index 4fa09d8..d72cea0 100644
--- a/lib/Sema/SemaTemplate.cpp
+++ b/lib/Sema/SemaTemplate.cpp
@@ -1319,7 +1319,8 @@
 
         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

lib/Sema/SemaTemplate.h

diff --git a/lib/Sema/SemaTemplate.h b/lib/Sema/SemaTemplate.h
index b400cb3..59bb542 100644
--- a/lib/Sema/SemaTemplate.h
+++ b/lib/Sema/SemaTemplate.h
@@ -38,7 +38,7 @@
   /// 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<const TemplateArgumentList *, 4> TemplateArgumentLists;
     
   public:
@@ -46,6 +46,7 @@
     MultiLevelTemplateArgumentList() { }
     
     /// \brief Construct a single-level template argument list.
+    explicit 
     MultiLevelTemplateArgumentList(const TemplateArgumentList &TemplateArgs) {
       TemplateArgumentLists.push_back(&TemplateArgs);
     }

lib/Sema/SemaTemplateDeduction.cpp

diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp
index ec198e0..2253a4e 100644
--- a/lib/Sema/SemaTemplateDeduction.cpp
+++ b/lib/Sema/SemaTemplateDeduction.cpp
@@ -967,8 +967,9 @@
   for (unsigned I = 0, N = PartialTemplateArgs.flat_size(); I != N; ++I) {
     Decl *Param = const_cast<Decl *>(
                     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 @@
                                 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 @@
       = 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 @@
   Specialization = cast_or_null<FunctionDecl>(
                       SubstDecl(FunctionTemplate->getTemplatedDecl(),
                                 FunctionTemplate->getDeclContext(),
-                                *DeducedArgumentList));
+                         MultiLevelTemplateArgumentList(*DeducedArgumentList)));
   if (!Specialization)
     return TDK_SubstitutionFailure;
   

lib/Sema/SemaType.cpp

diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp
index 7837952..284dea2 100644
--- a/lib/Sema/SemaType.cpp
+++ b/lib/Sema/SemaType.cpp
@@ -1787,14 +1787,9 @@
     } else if (CXXRecordDecl *Rec 
                  = dyn_cast<CXXRecordDecl>(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<ClassTemplateSpecializationDecl>(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);
       }