Add TemplateArgument::CreatePackCopy() to create a new parameter pack

in ASTContext-allocated memory, copying the provided template
arguments. Use this new routine where we can. No functionality change.

llvm-svn: 123289

clang/include/clang/AST/TemplateBase.h

@@ -191,6 +191,12 @@ public:
       getAsIntegral()->~APSInt();
   }
 
+  /// \brief Create a new template argument pack by copying the given set of
+  /// template arguments.
+  static TemplateArgument CreatePackCopy(ASTContext &Context,
+                                         const TemplateArgument *Args,
+                                         unsigned NumArgs);
+  
   /// \brief Return the kind of stored template argument.
   ArgKind getKind() const { return (ArgKind)Kind; }
 

clang/lib/AST/DeclTemplate.cpp

@@ -338,11 +338,8 @@ ClassTemplateDecl::getInjectedClassNameSpecialization() {
       Arg = TemplateArgument(TemplateName(TTP), TTP->isParameterPack());
     }
     
-    if ((*Param)->isTemplateParameterPack()) {
-      TemplateArgument *Pack = new (Context) TemplateArgument [1];
-      *Pack = Arg;
-      Arg = TemplateArgument(Pack, 1);
-    }
+    if ((*Param)->isTemplateParameterPack())
+      Arg = TemplateArgument::CreatePackCopy(Context, &Arg, 1);
     
     TemplateArgs.push_back(Arg);
   }

clang/lib/AST/TemplateBase.cpp

@@ -21,6 +21,7 @@
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/Diagnostic.h"
 #include "llvm/ADT/FoldingSet.h"
+#include <algorithm>
 
 using namespace clang;
 
@@ -28,6 +29,17 @@ using namespace clang;
 // TemplateArgument Implementation
 //===----------------------------------------------------------------------===//
 
+TemplateArgument TemplateArgument::CreatePackCopy(ASTContext &Context,
+                                                  const TemplateArgument *Args,
+                                                  unsigned NumArgs) {
+  if (NumArgs == 0)
+    return TemplateArgument(0, 0);
+  
+  TemplateArgument *Storage = new (Context) TemplateArgument [NumArgs];
+  std::copy(Args, Args + NumArgs, Storage);
+  return TemplateArgument(Storage, NumArgs);
+}
+
 bool TemplateArgument::isDependent() const {
   switch (getKind()) {
   case Null:

clang/lib/Sema/SemaTemplate.cpp

@@ -2556,13 +2556,12 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
     if ((*Param)->isTemplateParameterPack()) {     
       if (PartialTemplateArgs && ArgumentPack.empty()) {
         Converted.push_back(TemplateArgument());
-      } else if (ArgumentPack.empty()) {
+      } else if (ArgumentPack.empty())
         Converted.push_back(TemplateArgument(0, 0));
-      } else {
-        TemplateArgument *PackedArgs
-          = new (Context) TemplateArgument [ArgumentPack.size()];
-        std::copy(ArgumentPack.begin(), ArgumentPack.end(), PackedArgs);
-        Converted.push_back(TemplateArgument(PackedArgs, ArgumentPack.size()));
+      else {
+        Converted.push_back(TemplateArgument::CreatePackCopy(Context, 
+                                                          ArgumentPack.data(), 
+                                                         ArgumentPack.size()));
         ArgumentPack.clear();
       }
     }

clang/lib/Sema/SemaTemplateDeduction.cpp

@@ -1726,12 +1726,9 @@ static bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param,
     }
     
     // Create the resulting argument pack.
-    TemplateArgument *PackedArgs = 0;
-    if (!PackedArgsBuilder.empty()) {
-      PackedArgs = new (S.Context) TemplateArgument[PackedArgsBuilder.size()];
-      std::copy(PackedArgsBuilder.begin(), PackedArgsBuilder.end(), PackedArgs);
-    }
-    Output.push_back(TemplateArgument(PackedArgs, PackedArgsBuilder.size()));
+    Output.push_back(TemplateArgument::CreatePackCopy(S.Context, 
+                                                      PackedArgsBuilder.data(),
+                                                     PackedArgsBuilder.size()));
     return false;
   }