Remove broken support for variadic templates, along with the various

abstractions (e.g., TemplateArgumentListBuilder) that were designed to
support variadic templates. Only a few remnants of variadic templates
remain, in the parser (parsing template type parameter packs), AST
(template type parameter pack bits and TemplateArgument::Pack), and
Sema; these are expected to be used in a future implementation of
variadic templates.

But don't get too excited about that happening now.


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

1 files changed, 24 insertions, 120 deletions

diff --git a/lib/AST/DeclTemplate.cpp b/lib/AST/DeclTemplate.cpp
index c07d832073..cce434364f 100644
--- a/lib/AST/DeclTemplate.cpp
+++ b/lib/AST/DeclTemplate.cpp
@@ -19,6 +19,7 @@
 #include "clang/AST/ASTMutationListener.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "llvm/ADT/STLExtras.h"
+#include <memory>
 using namespace clang;
 
 //===----------------------------------------------------------------------===//
@@ -394,120 +395,20 @@ TemplateTemplateParmDecl::Create(ASTContext &C, DeclContext *DC,
 }
 
 //===----------------------------------------------------------------------===//
-// TemplateArgumentListBuilder Implementation
-//===----------------------------------------------------------------------===//
-
-void TemplateArgumentListBuilder::Append(const TemplateArgument &Arg) {
-  assert((Arg.getKind() != TemplateArgument::Type ||
-          Arg.getAsType().isCanonical()) && "Type must be canonical!");
-  assert(FlatArgs.size() < MaxFlatArgs && "Argument list builder is full!");
-  assert(!StructuredArgs &&
-         "Can't append arguments when an argument pack has been added!");
-
-  FlatArgs.push_back(Arg);
-}
-
-void TemplateArgumentListBuilder::BeginPack() {
-  assert(!AddingToPack && "Already adding to pack!");
-  assert(!StructuredArgs && "Argument list already contains a pack!");
-
-  AddingToPack = true;
-  PackBeginIndex = FlatArgs.size();
-}
-
-void TemplateArgumentListBuilder::EndPack() {
-  assert(AddingToPack && "Not adding to pack!");
-  assert(!StructuredArgs && "Argument list already contains a pack!");
-
-  AddingToPack = false;
-
-  // FIXME: This is a memory leak!
-  StructuredArgs = new TemplateArgument[MaxStructuredArgs];
-
-  // First copy the flat entries over to the list  (if any)
-  for (unsigned I = 0; I != PackBeginIndex; ++I) {
-    NumStructuredArgs++;
-    StructuredArgs[I] = FlatArgs[I];
-  }
-
-  // Next, set the pack.
-  TemplateArgument *PackArgs = 0;
-  unsigned NumPackArgs = NumFlatArgs - PackBeginIndex;
-  // FIXME: NumPackArgs shouldn't be negative here???
-  if (NumPackArgs)
-    PackArgs = FlatArgs.data()+PackBeginIndex;
-
-  StructuredArgs[NumStructuredArgs++].setArgumentPack(PackArgs, NumPackArgs,
-                                                      /*CopyArgs=*/false);
-}
-
-//===----------------------------------------------------------------------===//
 // TemplateArgumentList Implementation
 //===----------------------------------------------------------------------===//
-TemplateArgumentList::TemplateArgumentList(ASTContext &Context,
-                                           TemplateArgumentListBuilder &Builder,
-                                           bool TakeArgs)
-  : FlatArguments(Builder.getFlatArguments(), TakeArgs),
-    NumFlatArguments(Builder.flatSize()),
-    StructuredArguments(Builder.getStructuredArguments(), TakeArgs),
-    NumStructuredArguments(Builder.structuredSize()) {
-
-  if (!TakeArgs)
-    return;
-
-  // If this does take ownership of the arguments, then we have to new them
-  // and copy over.
-  TemplateArgument *NewArgs =
-    new (Context) TemplateArgument[Builder.flatSize()];
-  std::copy(Builder.getFlatArguments(),
-            Builder.getFlatArguments()+Builder.flatSize(), NewArgs);
-  FlatArguments.setPointer(NewArgs);
-      
-  // Just reuse the structured and flat arguments array if possible.
-  if (Builder.getStructuredArguments() == Builder.getFlatArguments()) {
-    StructuredArguments.setPointer(NewArgs);    
-    StructuredArguments.setInt(0);
-  } else {
-    TemplateArgument *NewSArgs =
-      new (Context) TemplateArgument[Builder.flatSize()];
-    std::copy(Builder.getFlatArguments(),
-              Builder.getFlatArguments()+Builder.flatSize(), NewSArgs);
-    StructuredArguments.setPointer(NewSArgs);
-  }
-}
-
-TemplateArgumentList::TemplateArgumentList(ASTContext &Context,
-                                           const TemplateArgument *Args,
-                                           unsigned NumArgs)
-  : NumFlatArguments(0), NumStructuredArguments(0) {
-  init(Context, Args, NumArgs);
-}
-
-/// Produces a shallow copy of the given template argument list.  This
-/// assumes that the input argument list outlives it.  This takes the list as
-/// a pointer to avoid looking like a copy constructor, since this really
-/// really isn't safe to use that way.
-TemplateArgumentList::TemplateArgumentList(const TemplateArgumentList *Other)
-  : FlatArguments(Other->FlatArguments.getPointer(), false),
-    NumFlatArguments(Other->flat_size()),
-    StructuredArguments(Other->StructuredArguments.getPointer(), false),
-    NumStructuredArguments(Other->NumStructuredArguments) { }
-
-void TemplateArgumentList::init(ASTContext &Context,
-                           const TemplateArgument *Args,
-                           unsigned NumArgs) {
-assert(NumFlatArguments == 0 && NumStructuredArguments == 0 &&
-       "Already initialized!");
-
-NumFlatArguments = NumStructuredArguments = NumArgs;
-TemplateArgument *NewArgs = new (Context) TemplateArgument[NumArgs];
-std::copy(Args, Args+NumArgs, NewArgs);
-FlatArguments.setPointer(NewArgs);
-FlatArguments.setInt(1); // Owns the pointer.
-
-// Just reuse the flat arguments array.
-StructuredArguments.setPointer(NewArgs);    
-StructuredArguments.setInt(0); // Doesn't own the pointer.
+TemplateArgumentList *
+TemplateArgumentList::CreateCopy(ASTContext &Context,
+                                 const TemplateArgument *Args,
+                                 unsigned NumArgs) {
+  std::size_t Size = sizeof(TemplateArgumentList)
+                   + NumArgs * sizeof(TemplateArgument);
+  void *Mem = Context.Allocate(Size);
+  TemplateArgument *StoredArgs 
+    = reinterpret_cast<TemplateArgument *>(
+                                static_cast<TemplateArgumentList *>(Mem) + 1);
+  std::uninitialized_copy(Args, Args + NumArgs, StoredArgs);
+  return new (Mem) TemplateArgumentList(StoredArgs, NumArgs, true);
 }
 
 //===----------------------------------------------------------------------===//
@@ -517,14 +418,15 @@ ClassTemplateSpecializationDecl::
 ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
                                 DeclContext *DC, SourceLocation L,
                                 ClassTemplateDecl *SpecializedTemplate,
-                                TemplateArgumentListBuilder &Builder,
+                                const TemplateArgument *Args,
+                                unsigned NumArgs,
                                 ClassTemplateSpecializationDecl *PrevDecl)
   : CXXRecordDecl(DK, TK, DC, L,
                   SpecializedTemplate->getIdentifier(),
                   PrevDecl),
     SpecializedTemplate(SpecializedTemplate),
     ExplicitInfo(0),
-    TemplateArgs(Context, Builder, /*TakeArgs=*/true),
+    TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args, NumArgs)),
     SpecializationKind(TSK_Undeclared) {
 }
 
@@ -538,14 +440,15 @@ ClassTemplateSpecializationDecl *
 ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK,
                                         DeclContext *DC, SourceLocation L,
                                         ClassTemplateDecl *SpecializedTemplate,
-                                        TemplateArgumentListBuilder &Builder,
+                                        const TemplateArgument *Args,
+                                        unsigned NumArgs,
                                    ClassTemplateSpecializationDecl *PrevDecl) {
   ClassTemplateSpecializationDecl *Result
     = new (Context)ClassTemplateSpecializationDecl(Context,
                                                    ClassTemplateSpecialization,
                                                    TK, DC, L,
                                                    SpecializedTemplate,
-                                                   Builder,
+                                                   Args, NumArgs,
                                                    PrevDecl);
   Context.getTypeDeclType(Result, PrevDecl);
   return Result;
@@ -565,8 +468,8 @@ ClassTemplateSpecializationDecl::getNameForDiagnostic(std::string &S,
 
   const TemplateArgumentList &TemplateArgs = getTemplateArgs();
   S += TemplateSpecializationType::PrintTemplateArgumentList(
-                                       TemplateArgs.getFlatArgumentList(),
-                                       TemplateArgs.flat_size(),
+                                                          TemplateArgs.data(),
+                                                          TemplateArgs.size(),
                                                              Policy);
 }
 
@@ -586,7 +489,8 @@ ClassTemplatePartialSpecializationDecl::
 Create(ASTContext &Context, TagKind TK,DeclContext *DC, SourceLocation L,
        TemplateParameterList *Params,
        ClassTemplateDecl *SpecializedTemplate,
-       TemplateArgumentListBuilder &Builder,
+       const TemplateArgument *Args,
+       unsigned NumArgs,
        const TemplateArgumentListInfo &ArgInfos,
        QualType CanonInjectedType,
        ClassTemplatePartialSpecializationDecl *PrevDecl,
@@ -600,7 +504,7 @@ Create(ASTContext &Context, TagKind TK,DeclContext *DC, SourceLocation L,
     = new (Context)ClassTemplatePartialSpecializationDecl(Context, TK,
                                                           DC, L, Params,
                                                           SpecializedTemplate,
-                                                          Builder,
+                                                          Args, NumArgs,
                                                           ClonedArgs, N,
                                                           PrevDecl,
                                                           SequenceNumber);