DeclTemplate.cpp revision 194711 
1//===--- DeclCXX.cpp - C++ Declaration AST Node Implementation ------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the C++ related Decl classes for templates.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/DeclCXX.h"
15#include "clang/AST/DeclTemplate.h"
16#include "clang/AST/Expr.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/Basic/IdentifierTable.h"
19#include "llvm/ADT/STLExtras.h"
20using namespace clang;
21
22//===----------------------------------------------------------------------===//
23// TemplateParameterList Implementation
24//===----------------------------------------------------------------------===//
25
26TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc,
27                                             SourceLocation LAngleLoc,
28                                             Decl **Params, unsigned NumParams,
29                                             SourceLocation RAngleLoc)
30  : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
31    NumParams(NumParams) {
32  for (unsigned Idx = 0; Idx < NumParams; ++Idx)
33    begin()[Idx] = Params[Idx];
34}
35
36TemplateParameterList *
37TemplateParameterList::Create(ASTContext &C, SourceLocation TemplateLoc,
38                              SourceLocation LAngleLoc, Decl **Params,
39                              unsigned NumParams, SourceLocation RAngleLoc) {
40  unsigned Size = sizeof(TemplateParameterList) + sizeof(Decl *) * NumParams;
41  unsigned Align = llvm::AlignOf<TemplateParameterList>::Alignment;
42  void *Mem = C.Allocate(Size, Align);
43  return new (Mem) TemplateParameterList(TemplateLoc, LAngleLoc, Params,
44                                         NumParams, RAngleLoc);
45}
46
47unsigned TemplateParameterList::getMinRequiredArguments() const {
48  unsigned NumRequiredArgs = size();
49  iterator Param = const_cast<TemplateParameterList *>(this)->end(),
50      ParamBegin = const_cast<TemplateParameterList *>(this)->begin();
51  while (Param != ParamBegin) {
52    --Param;
53
54    if (!(*Param)->isTemplateParameterPack() &&
55        !(isa<TemplateTypeParmDecl>(*Param) &&
56          cast<TemplateTypeParmDecl>(*Param)->hasDefaultArgument()) &&
57        !(isa<NonTypeTemplateParmDecl>(*Param) &&
58          cast<NonTypeTemplateParmDecl>(*Param)->hasDefaultArgument()) &&
59        !(isa<TemplateTemplateParmDecl>(*Param) &&
60          cast<TemplateTemplateParmDecl>(*Param)->hasDefaultArgument()))
61      break;
62
63    --NumRequiredArgs;
64  }
65
66  return NumRequiredArgs;
67}
68
69//===----------------------------------------------------------------------===//
70// TemplateDecl Implementation
71//===----------------------------------------------------------------------===//
72
73TemplateDecl::~TemplateDecl() {
74}
75
76//===----------------------------------------------------------------------===//
77// FunctionTemplateDecl Implementation
78//===----------------------------------------------------------------------===//
79
80FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C,
81                                                   DeclContext *DC,
82                                                   SourceLocation L,
83                                                   DeclarationName Name,
84                                                   TemplateParameterList *Params,
85                                                   NamedDecl *Decl) {
86  return new (C) FunctionTemplateDecl(DC, L, Name, Params, Decl);
87}
88
89//===----------------------------------------------------------------------===//
90// ClassTemplateDecl Implementation
91//===----------------------------------------------------------------------===//
92
93ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
94                                             DeclContext *DC,
95                                             SourceLocation L,
96                                             DeclarationName Name,
97                                             TemplateParameterList *Params,
98                                             NamedDecl *Decl,
99                                             ClassTemplateDecl *PrevDecl) {
100  Common *CommonPtr;
101  if (PrevDecl)
102    CommonPtr = PrevDecl->CommonPtr;
103  else
104    CommonPtr = new (C) Common;
105
106  return new (C) ClassTemplateDecl(DC, L, Name, Params, Decl, PrevDecl,
107                                   CommonPtr);
108}
109
110ClassTemplateDecl::~ClassTemplateDecl() {
111  assert(CommonPtr == 0 && "ClassTemplateDecl must be explicitly destroyed");
112}
113
114void ClassTemplateDecl::Destroy(ASTContext& C) {
115  if (!PreviousDeclaration) {
116    CommonPtr->~Common();
117    C.Deallocate((void*)CommonPtr);
118  }
119  CommonPtr = 0;
120
121  this->~ClassTemplateDecl();
122  C.Deallocate((void*)this);
123}
124
125QualType ClassTemplateDecl::getInjectedClassNameType(ASTContext &Context) {
126  if (!CommonPtr->InjectedClassNameType.isNull())
127    return CommonPtr->InjectedClassNameType;
128
129  // FIXME: n2800 14.6.1p1 should say how the template arguments
130  // corresponding to template parameter packs should be pack
131  // expansions. We already say that in 14.6.2.1p2, so it would be
132  // better to fix that redundancy.
133
134  TemplateParameterList *Params = getTemplateParameters();
135
136  llvm::SmallVector<TemplateArgument, 16> TemplateArgs;
137  llvm::SmallVector<TemplateArgument, 16> CanonTemplateArgs;
138  TemplateArgs.reserve(Params->size());
139  CanonTemplateArgs.reserve(Params->size());
140
141  for (TemplateParameterList::iterator
142         Param = Params->begin(), ParamEnd = Params->end();
143       Param != ParamEnd; ++Param) {
144    if (isa<TemplateTypeParmDecl>(*Param)) {
145      QualType ParamType = Context.getTypeDeclType(cast<TypeDecl>(*Param));
146      TemplateArgs.push_back(TemplateArgument((*Param)->getLocation(),
147                                              ParamType));
148      CanonTemplateArgs.push_back(
149                         TemplateArgument((*Param)->getLocation(),
150                                          Context.getCanonicalType(ParamType)));
151    } else if (NonTypeTemplateParmDecl *NTTP =
152                 dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
153      // FIXME: Build canonical expression, too!
154      Expr *E = new (Context) DeclRefExpr(NTTP, NTTP->getType(),
155                                          NTTP->getLocation(),
156                                          NTTP->getType()->isDependentType(),
157                                          /*Value-dependent=*/true);
158      TemplateArgs.push_back(TemplateArgument(E));
159      CanonTemplateArgs.push_back(TemplateArgument(E));
160    } else {
161      TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*Param);
162      TemplateArgs.push_back(TemplateArgument(TTP->getLocation(), TTP));
163      CanonTemplateArgs.push_back(TemplateArgument(TTP->getLocation(),
164                                              Context.getCanonicalDecl(TTP)));
165    }
166  }
167
168  // FIXME: I should really move the "build-the-canonical-type" logic
169  // into ASTContext::getTemplateSpecializationType.
170  TemplateName Name = TemplateName(this);
171  QualType CanonType = Context.getTemplateSpecializationType(
172                                       Context.getCanonicalTemplateName(Name),
173                                             &CanonTemplateArgs[0],
174                                             CanonTemplateArgs.size());
175
176  CommonPtr->InjectedClassNameType
177    = Context.getTemplateSpecializationType(Name,
178                                            &TemplateArgs[0],
179                                            TemplateArgs.size(),
180                                            CanonType);
181  return CommonPtr->InjectedClassNameType;
182}
183
184//===----------------------------------------------------------------------===//
185// TemplateTypeParm Allocation/Deallocation Method Implementations
186//===----------------------------------------------------------------------===//
187
188TemplateTypeParmDecl *
189TemplateTypeParmDecl::Create(ASTContext &C, DeclContext *DC,
190                             SourceLocation L, unsigned D, unsigned P,
191                             IdentifierInfo *Id, bool Typename,
192                             bool ParameterPack) {
193  QualType Type = C.getTemplateTypeParmType(D, P, ParameterPack, Id);
194  return new (C) TemplateTypeParmDecl(DC, L, Id, Typename, Type, ParameterPack);
195}
196
197//===----------------------------------------------------------------------===//
198// NonTypeTemplateParmDecl Method Implementations
199//===----------------------------------------------------------------------===//
200
201NonTypeTemplateParmDecl *
202NonTypeTemplateParmDecl::Create(ASTContext &C, DeclContext *DC,
203                                SourceLocation L, unsigned D, unsigned P,
204                                IdentifierInfo *Id, QualType T,
205                                SourceLocation TypeSpecStartLoc) {
206  return new (C) NonTypeTemplateParmDecl(DC, L, D, P, Id, T,
207                                         TypeSpecStartLoc);
208}
209
210SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
211  return DefaultArgument? DefaultArgument->getSourceRange().getBegin()
212                        : SourceLocation();
213}
214
215//===----------------------------------------------------------------------===//
216// TemplateTemplateParmDecl Method Implementations
217//===----------------------------------------------------------------------===//
218
219TemplateTemplateParmDecl *
220TemplateTemplateParmDecl::Create(ASTContext &C, DeclContext *DC,
221                                 SourceLocation L, unsigned D, unsigned P,
222                                 IdentifierInfo *Id,
223                                 TemplateParameterList *Params) {
224  return new (C) TemplateTemplateParmDecl(DC, L, D, P, Id, Params);
225}
226
227SourceLocation TemplateTemplateParmDecl::getDefaultArgumentLoc() const {
228  return DefaultArgument? DefaultArgument->getSourceRange().getBegin()
229                        : SourceLocation();
230}
231
232//===----------------------------------------------------------------------===//
233// TemplateArgument Implementation
234//===----------------------------------------------------------------------===//
235
236TemplateArgument::TemplateArgument(Expr *E) : Kind(Expression) {
237  TypeOrValue = reinterpret_cast<uintptr_t>(E);
238  StartLoc = E->getSourceRange().getBegin();
239}
240
241/// \brief Construct a template argument pack.
242void TemplateArgument::setArgumentPack(TemplateArgument *args, unsigned NumArgs,
243                                       bool CopyArgs) {
244  assert(isNull() && "Must call setArgumentPack on a null argument");
245
246  Kind = Pack;
247  Args.NumArgs = NumArgs;
248  Args.CopyArgs = CopyArgs;
249  if (!Args.CopyArgs) {
250    Args.Args = args;
251    return;
252  }
253
254  Args.Args = new TemplateArgument[NumArgs];
255  for (unsigned I = 0; I != Args.NumArgs; ++I)
256    Args.Args[I] = args[I];
257}
258
259//===----------------------------------------------------------------------===//
260// TemplateArgumentListBuilder Implementation
261//===----------------------------------------------------------------------===//
262
263void TemplateArgumentListBuilder::Append(const TemplateArgument& Arg) {
264  switch (Arg.getKind()) {
265    default: break;
266    case TemplateArgument::Type:
267      assert(Arg.getAsType()->isCanonical() && "Type must be canonical!");
268      break;
269  }
270
271  assert(NumFlatArgs < MaxFlatArgs && "Argument list builder is full!");
272  assert(!StructuredArgs &&
273         "Can't append arguments when an argument pack has been added!");
274
275  if (!FlatArgs)
276    FlatArgs = new TemplateArgument[MaxFlatArgs];
277
278  FlatArgs[NumFlatArgs++] = Arg;
279}
280
281void TemplateArgumentListBuilder::BeginPack() {
282  assert(!AddingToPack && "Already adding to pack!");
283  assert(!StructuredArgs && "Argument list already contains a pack!");
284
285  AddingToPack = true;
286  PackBeginIndex = NumFlatArgs;
287}
288
289void TemplateArgumentListBuilder::EndPack() {
290  assert(AddingToPack && "Not adding to pack!");
291  assert(!StructuredArgs && "Argument list already contains a pack!");
292
293  AddingToPack = false;
294
295  StructuredArgs = new TemplateArgument[MaxStructuredArgs];
296
297  // First copy the flat entries over to the list  (if any)
298  for (unsigned I = 0; I != PackBeginIndex; ++I) {
299    NumStructuredArgs++;
300    StructuredArgs[I] = FlatArgs[I];
301  }
302
303  // Next, set the pack.
304  TemplateArgument *PackArgs = 0;
305  unsigned NumPackArgs = NumFlatArgs - PackBeginIndex;
306  if (NumPackArgs)
307    PackArgs = &FlatArgs[PackBeginIndex];
308
309  StructuredArgs[NumStructuredArgs++].setArgumentPack(PackArgs, NumPackArgs,
310                                                      /*CopyArgs=*/false);
311}
312
313void TemplateArgumentListBuilder::ReleaseArgs() {
314  FlatArgs = 0;
315  NumFlatArgs = 0;
316  MaxFlatArgs = 0;
317  StructuredArgs = 0;
318  NumStructuredArgs = 0;
319  MaxStructuredArgs = 0;
320}
321
322//===----------------------------------------------------------------------===//
323// TemplateArgumentList Implementation
324//===----------------------------------------------------------------------===//
325TemplateArgumentList::TemplateArgumentList(ASTContext &Context,
326                                           TemplateArgumentListBuilder &Builder,
327                                           bool TakeArgs)
328  : FlatArguments(Builder.getFlatArguments(), TakeArgs),
329    NumFlatArguments(Builder.flatSize()),
330    StructuredArguments(Builder.getStructuredArguments(), TakeArgs),
331    NumStructuredArguments(Builder.structuredSize()) {
332
333  if (!TakeArgs)
334    return;
335
336  if (Builder.getStructuredArguments() == Builder.getFlatArguments())
337    StructuredArguments.setInt(0);
338  Builder.ReleaseArgs();
339}
340
341TemplateArgumentList::~TemplateArgumentList() {
342  // FIXME: Deallocate template arguments
343}
344
345//===----------------------------------------------------------------------===//
346// ClassTemplateSpecializationDecl Implementation
347//===----------------------------------------------------------------------===//
348ClassTemplateSpecializationDecl::
349ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK,
350                                DeclContext *DC, SourceLocation L,
351                                ClassTemplateDecl *SpecializedTemplate,
352                                TemplateArgumentListBuilder &Builder)
353  : CXXRecordDecl(DK,
354                  SpecializedTemplate->getTemplatedDecl()->getTagKind(),
355                  DC, L,
356                  // FIXME: Should we use DeclarationName for the name of
357                  // class template specializations?
358                  SpecializedTemplate->getIdentifier()),
359    SpecializedTemplate(SpecializedTemplate),
360    TemplateArgs(Context, Builder, /*TakeArgs=*/true),
361    SpecializationKind(TSK_Undeclared) {
362}
363
364ClassTemplateSpecializationDecl *
365ClassTemplateSpecializationDecl::Create(ASTContext &Context,
366                                        DeclContext *DC, SourceLocation L,
367                                        ClassTemplateDecl *SpecializedTemplate,
368                                        TemplateArgumentListBuilder &Builder,
369                                   ClassTemplateSpecializationDecl *PrevDecl) {
370  ClassTemplateSpecializationDecl *Result
371    = new (Context)ClassTemplateSpecializationDecl(Context,
372                                                   ClassTemplateSpecialization,
373                                                   DC, L,
374                                                   SpecializedTemplate,
375                                                   Builder);
376  Context.getTypeDeclType(Result, PrevDecl);
377  return Result;
378}
379
380//===----------------------------------------------------------------------===//
381// ClassTemplatePartialSpecializationDecl Implementation
382//===----------------------------------------------------------------------===//
383ClassTemplatePartialSpecializationDecl *
384ClassTemplatePartialSpecializationDecl::
385Create(ASTContext &Context, DeclContext *DC, SourceLocation L,
386       TemplateParameterList *Params,
387       ClassTemplateDecl *SpecializedTemplate,
388       TemplateArgumentListBuilder &Builder,
389       ClassTemplatePartialSpecializationDecl *PrevDecl) {
390  ClassTemplatePartialSpecializationDecl *Result
391    = new (Context)ClassTemplatePartialSpecializationDecl(Context,
392                                                          DC, L, Params,
393                                                          SpecializedTemplate,
394                                                          Builder);
395  Result->setSpecializationKind(TSK_ExplicitSpecialization);
396  Context.getTypeDeclType(Result, PrevDecl);
397  return Result;
398}
399