SemaTemplateInstantiate.cpp revision dd13e8468462e60971487bcd5915419762dab814 
1//===------- SemaTemplateInstantiate.cpp - C++ Template Instantiation ------===/
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//  This file implements C++ template instantiation.
10//
11//===----------------------------------------------------------------------===/
12
13#include "Sema.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/Expr.h"
16#include "clang/AST/DeclTemplate.h"
17#include "clang/Parse/DeclSpec.h"
18#include "clang/Basic/LangOptions.h"
19#include "llvm/Support/Compiler.h"
20
21using namespace clang;
22
23//===----------------------------------------------------------------------===/
24// Template Instantiation Support
25//===----------------------------------------------------------------------===/
26
27Sema::InstantiatingTemplate::
28InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
29                      CXXRecordDecl *Entity,
30                      SourceRange InstantiationRange)
31  :  SemaRef(SemaRef) {
32
33  Invalid = CheckInstantiationDepth(PointOfInstantiation,
34                                    InstantiationRange);
35  if (!Invalid) {
36    ActiveTemplateInstantiation Inst;
37    Inst.Kind = ActiveTemplateInstantiation::TemplateInstantiation;
38    Inst.PointOfInstantiation = PointOfInstantiation;
39    Inst.Entity = reinterpret_cast<uintptr_t>(Entity);
40    Inst.TemplateArgs = 0;
41    Inst.NumTemplateArgs = 0;
42    Inst.InstantiationRange = InstantiationRange;
43    SemaRef.ActiveTemplateInstantiations.push_back(Inst);
44    Invalid = false;
45  }
46}
47
48Sema::InstantiatingTemplate::InstantiatingTemplate(Sema &SemaRef,
49                                         SourceLocation PointOfInstantiation,
50                                         TemplateDecl *Template,
51                                         const TemplateArgument *TemplateArgs,
52                                         unsigned NumTemplateArgs,
53                                         SourceRange InstantiationRange)
54  : SemaRef(SemaRef) {
55
56  Invalid = CheckInstantiationDepth(PointOfInstantiation,
57                                    InstantiationRange);
58  if (!Invalid) {
59    ActiveTemplateInstantiation Inst;
60    Inst.Kind
61      = ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation;
62    Inst.PointOfInstantiation = PointOfInstantiation;
63    Inst.Entity = reinterpret_cast<uintptr_t>(Template);
64    Inst.TemplateArgs = TemplateArgs;
65    Inst.NumTemplateArgs = NumTemplateArgs;
66    Inst.InstantiationRange = InstantiationRange;
67    SemaRef.ActiveTemplateInstantiations.push_back(Inst);
68    Invalid = false;
69  }
70}
71
72Sema::InstantiatingTemplate::~InstantiatingTemplate() {
73  if (!Invalid)
74    SemaRef.ActiveTemplateInstantiations.pop_back();
75}
76
77bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
78                                        SourceLocation PointOfInstantiation,
79                                           SourceRange InstantiationRange) {
80  if (SemaRef.ActiveTemplateInstantiations.size()
81       <= SemaRef.getLangOptions().InstantiationDepth)
82    return false;
83
84  SemaRef.Diag(PointOfInstantiation,
85               diag::err_template_recursion_depth_exceeded)
86    << SemaRef.getLangOptions().InstantiationDepth
87    << InstantiationRange;
88  SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth)
89    << SemaRef.getLangOptions().InstantiationDepth;
90  return true;
91}
92
93/// \brief Prints the current instantiation stack through a series of
94/// notes.
95void Sema::PrintInstantiationStack() {
96  for (llvm::SmallVector<ActiveTemplateInstantiation, 16>::reverse_iterator
97         Active = ActiveTemplateInstantiations.rbegin(),
98         ActiveEnd = ActiveTemplateInstantiations.rend();
99       Active != ActiveEnd;
100       ++Active) {
101    switch (Active->Kind) {
102    case ActiveTemplateInstantiation::TemplateInstantiation: {
103      unsigned DiagID = diag::note_template_member_class_here;
104      CXXRecordDecl *Record = (CXXRecordDecl *)Active->Entity;
105      if (isa<ClassTemplateSpecializationDecl>(Record))
106        DiagID = diag::note_template_class_instantiation_here;
107      Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr),
108                   DiagID)
109        << Context.getTypeDeclType(Record)
110        << Active->InstantiationRange;
111      break;
112    }
113
114    case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation: {
115      TemplateDecl *Template = cast<TemplateDecl>((Decl *)Active->Entity);
116      std::string TemplateArgsStr
117        = TemplateSpecializationType::PrintTemplateArgumentList(
118                                                      Active->TemplateArgs,
119                                                      Active->NumTemplateArgs);
120      Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr),
121                   diag::note_default_arg_instantiation_here)
122        << (Template->getNameAsString() + TemplateArgsStr)
123        << Active->InstantiationRange;
124      break;
125    }
126    }
127  }
128}
129
130//===----------------------------------------------------------------------===/
131// Template Instantiation for Types
132//===----------------------------------------------------------------------===/
133namespace {
134  class VISIBILITY_HIDDEN TemplateTypeInstantiator {
135    Sema &SemaRef;
136    const TemplateArgument *TemplateArgs;
137    unsigned NumTemplateArgs;
138    SourceLocation Loc;
139    DeclarationName Entity;
140
141  public:
142    TemplateTypeInstantiator(Sema &SemaRef,
143                             const TemplateArgument *TemplateArgs,
144                             unsigned NumTemplateArgs,
145                             SourceLocation Loc,
146                             DeclarationName Entity)
147      : SemaRef(SemaRef), TemplateArgs(TemplateArgs),
148        NumTemplateArgs(NumTemplateArgs), Loc(Loc), Entity(Entity) { }
149
150    QualType operator()(QualType T) const { return Instantiate(T); }
151
152    QualType Instantiate(QualType T) const;
153
154    // Declare instantiate functions for each type.
155#define TYPE(Class, Base)                                       \
156    QualType Instantiate##Class##Type(const Class##Type *T,     \
157                                      unsigned Quals) const;
158#define ABSTRACT_TYPE(Class, Base)
159#include "clang/AST/TypeNodes.def"
160  };
161}
162
163QualType
164TemplateTypeInstantiator::InstantiateExtQualType(const ExtQualType *T,
165                                                 unsigned Quals) const {
166  // FIXME: Implement this
167  assert(false && "Cannot instantiate ExtQualType yet");
168  return QualType();
169}
170
171QualType
172TemplateTypeInstantiator::InstantiateBuiltinType(const BuiltinType *T,
173                                                 unsigned Quals) const {
174  assert(false && "Builtin types are not dependent and cannot be instantiated");
175  return QualType(T, Quals);
176}
177
178QualType
179TemplateTypeInstantiator::
180InstantiateFixedWidthIntType(const FixedWidthIntType *T, unsigned Quals) const {
181  // FIXME: Implement this
182  assert(false && "Cannot instantiate FixedWidthIntType yet");
183  return QualType();
184}
185
186QualType
187TemplateTypeInstantiator::InstantiateComplexType(const ComplexType *T,
188                                                 unsigned Quals) const {
189  // FIXME: Implement this
190  assert(false && "Cannot instantiate ComplexType yet");
191  return QualType();
192}
193
194QualType
195TemplateTypeInstantiator::InstantiatePointerType(const PointerType *T,
196                                                 unsigned Quals) const {
197  QualType PointeeType = Instantiate(T->getPointeeType());
198  if (PointeeType.isNull())
199    return QualType();
200
201  return SemaRef.BuildPointerType(PointeeType, Quals, Loc, Entity);
202}
203
204QualType
205TemplateTypeInstantiator::InstantiateBlockPointerType(const BlockPointerType *T,
206                                                      unsigned Quals) const {
207  // FIXME: Implement this
208  assert(false && "Cannot instantiate BlockPointerType yet");
209  return QualType();
210}
211
212QualType
213TemplateTypeInstantiator::InstantiateLValueReferenceType(
214    const LValueReferenceType *T, unsigned Quals) const {
215  QualType ReferentType = Instantiate(T->getPointeeType());
216  if (ReferentType.isNull())
217    return QualType();
218
219  return SemaRef.BuildReferenceType(ReferentType, true, Quals, Loc, Entity);
220}
221
222QualType
223TemplateTypeInstantiator::InstantiateRValueReferenceType(
224    const RValueReferenceType *T, unsigned Quals) const {
225  QualType ReferentType = Instantiate(T->getPointeeType());
226  if (ReferentType.isNull())
227    return QualType();
228
229  return SemaRef.BuildReferenceType(ReferentType, false, Quals, Loc, Entity);
230}
231
232QualType
233TemplateTypeInstantiator::
234InstantiateMemberPointerType(const MemberPointerType *T,
235                             unsigned Quals) const {
236  // FIXME: Implement this
237  assert(false && "Cannot instantiate MemberPointerType yet");
238  return QualType();
239}
240
241QualType
242TemplateTypeInstantiator::
243InstantiateConstantArrayType(const ConstantArrayType *T,
244                             unsigned Quals) const {
245  QualType ElementType = Instantiate(T->getElementType());
246  if (ElementType.isNull())
247    return ElementType;
248
249  // Build a temporary integer literal to specify the size for
250  // BuildArrayType. Since we have already checked the size as part of
251  // creating the dependent array type in the first place, we know
252  // there aren't any errors.
253  // FIXME: Is IntTy big enough? Maybe not, but LongLongTy causes
254  // problems that I have yet to investigate.
255  IntegerLiteral ArraySize(T->getSize(), SemaRef.Context.IntTy, Loc);
256  return SemaRef.BuildArrayType(ElementType, T->getSizeModifier(),
257                                &ArraySize, T->getIndexTypeQualifier(),
258                                Loc, Entity);
259}
260
261QualType
262TemplateTypeInstantiator::
263InstantiateIncompleteArrayType(const IncompleteArrayType *T,
264                               unsigned Quals) const {
265  QualType ElementType = Instantiate(T->getElementType());
266  if (ElementType.isNull())
267    return ElementType;
268
269  return SemaRef.BuildArrayType(ElementType, T->getSizeModifier(),
270                                0, T->getIndexTypeQualifier(),
271                                Loc, Entity);
272}
273
274QualType
275TemplateTypeInstantiator::
276InstantiateVariableArrayType(const VariableArrayType *T,
277                             unsigned Quals) const {
278  // FIXME: Implement this
279  assert(false && "Cannot instantiate VariableArrayType yet");
280  return QualType();
281}
282
283QualType
284TemplateTypeInstantiator::
285InstantiateDependentSizedArrayType(const DependentSizedArrayType *T,
286                                   unsigned Quals) const {
287  Expr *ArraySize = T->getSizeExpr();
288  assert(ArraySize->isValueDependent() &&
289         "dependent sized array types must have value dependent size expr");
290
291  // Instantiate the element type if needed
292  QualType ElementType = T->getElementType();
293  if (ElementType->isDependentType()) {
294    ElementType = Instantiate(ElementType);
295    if (ElementType.isNull())
296      return QualType();
297  }
298
299  // Instantiate the size expression
300  Sema::OwningExprResult InstantiatedArraySize =
301    SemaRef.InstantiateExpr(ArraySize, TemplateArgs, NumTemplateArgs);
302  if (InstantiatedArraySize.isInvalid())
303    return QualType();
304
305  return SemaRef.BuildArrayType(ElementType, T->getSizeModifier(),
306                                (Expr *)InstantiatedArraySize.release(),
307                                T->getIndexTypeQualifier(), Loc, Entity);
308}
309
310QualType
311TemplateTypeInstantiator::InstantiateVectorType(const VectorType *T,
312                                             unsigned Quals) const {
313  // FIXME: Implement this
314  assert(false && "Cannot instantiate VectorType yet");
315  return QualType();
316}
317
318QualType
319TemplateTypeInstantiator::InstantiateExtVectorType(const ExtVectorType *T,
320                                                   unsigned Quals) const {
321  // FIXME: Implement this
322  assert(false && "Cannot instantiate ExtVectorType yet");
323  return QualType();
324}
325
326QualType
327TemplateTypeInstantiator::
328InstantiateFunctionProtoType(const FunctionProtoType *T,
329                             unsigned Quals) const {
330  QualType ResultType = Instantiate(T->getResultType());
331  if (ResultType.isNull())
332    return ResultType;
333
334  llvm::SmallVector<QualType, 16> ParamTypes;
335  for (FunctionProtoType::arg_type_iterator Param = T->arg_type_begin(),
336                                         ParamEnd = T->arg_type_end();
337       Param != ParamEnd; ++Param) {
338    QualType P = Instantiate(*Param);
339    if (P.isNull())
340      return P;
341
342    ParamTypes.push_back(P);
343  }
344
345  return SemaRef.BuildFunctionType(ResultType, &ParamTypes[0],
346                                   ParamTypes.size(),
347                                   T->isVariadic(), T->getTypeQuals(),
348                                   Loc, Entity);
349}
350
351QualType
352TemplateTypeInstantiator::
353InstantiateFunctionNoProtoType(const FunctionNoProtoType *T,
354                               unsigned Quals) const {
355  assert(false && "Functions without prototypes cannot be dependent.");
356  return QualType();
357}
358
359QualType
360TemplateTypeInstantiator::InstantiateTypedefType(const TypedefType *T,
361                                                 unsigned Quals) const {
362  // FIXME: Implement this
363  assert(false && "Cannot instantiate TypedefType yet");
364  return QualType();
365}
366
367QualType
368TemplateTypeInstantiator::InstantiateTypeOfExprType(const TypeOfExprType *T,
369                                                    unsigned Quals) const {
370  // FIXME: Implement this
371  assert(false && "Cannot instantiate TypeOfExprType yet");
372  return QualType();
373}
374
375QualType
376TemplateTypeInstantiator::InstantiateTypeOfType(const TypeOfType *T,
377                                                unsigned Quals) const {
378  // FIXME: Implement this
379  assert(false && "Cannot instantiate TypeOfType yet");
380  return QualType();
381}
382
383QualType
384TemplateTypeInstantiator::InstantiateRecordType(const RecordType *T,
385                                                unsigned Quals) const {
386  // FIXME: Implement this
387  assert(false && "Cannot instantiate RecordType yet");
388  return QualType();
389}
390
391QualType
392TemplateTypeInstantiator::InstantiateEnumType(const EnumType *T,
393                                              unsigned Quals) const {
394  // FIXME: Implement this
395  assert(false && "Cannot instantiate EnumType yet");
396  return QualType();
397}
398
399QualType
400TemplateTypeInstantiator::
401InstantiateTemplateTypeParmType(const TemplateTypeParmType *T,
402                                unsigned Quals) const {
403  if (T->getDepth() == 0) {
404    // Replace the template type parameter with its corresponding
405    // template argument.
406    assert(T->getIndex() < NumTemplateArgs && "Wrong # of template args");
407    assert(TemplateArgs[T->getIndex()].getKind() == TemplateArgument::Type &&
408           "Template argument kind mismatch");
409    QualType Result = TemplateArgs[T->getIndex()].getAsType();
410    if (Result.isNull() || !Quals)
411      return Result;
412
413    // C++ [dcl.ref]p1:
414    //   [...] Cv-qualified references are ill-formed except when
415    //   the cv-qualifiers are introduced through the use of a
416    //   typedef (7.1.3) or of a template type argument (14.3), in
417    //   which case the cv-qualifiers are ignored.
418    if (Quals && Result->isReferenceType())
419      Quals = 0;
420
421    return QualType(Result.getTypePtr(), Quals | Result.getCVRQualifiers());
422  }
423
424  // The template type parameter comes from an inner template (e.g.,
425  // the template parameter list of a member template inside the
426  // template we are instantiating). Create a new template type
427  // parameter with the template "level" reduced by one.
428  return SemaRef.Context.getTemplateTypeParmType(T->getDepth() - 1,
429                                                 T->getIndex(),
430                                                 T->getName())
431    .getQualifiedType(Quals);
432}
433
434QualType
435TemplateTypeInstantiator::
436InstantiateTemplateSpecializationType(
437                                  const TemplateSpecializationType *T,
438                                  unsigned Quals) const {
439  llvm::SmallVector<TemplateArgument, 16> InstantiatedTemplateArgs;
440  InstantiatedTemplateArgs.reserve(T->getNumArgs());
441  for (TemplateSpecializationType::iterator Arg = T->begin(), ArgEnd = T->end();
442       Arg != ArgEnd; ++Arg) {
443    switch (Arg->getKind()) {
444    case TemplateArgument::Type: {
445      QualType T = SemaRef.InstantiateType(Arg->getAsType(),
446                                           TemplateArgs, NumTemplateArgs,
447                                           Arg->getLocation(),
448                                           DeclarationName());
449      if (T.isNull())
450        return QualType();
451
452      InstantiatedTemplateArgs.push_back(
453                                TemplateArgument(Arg->getLocation(), T));
454      break;
455    }
456
457    case TemplateArgument::Declaration:
458    case TemplateArgument::Integral:
459      InstantiatedTemplateArgs.push_back(*Arg);
460      break;
461
462    case TemplateArgument::Expression:
463      Sema::OwningExprResult E
464        = SemaRef.InstantiateExpr(Arg->getAsExpr(), TemplateArgs,
465                                  NumTemplateArgs);
466      if (E.isInvalid())
467        return QualType();
468      InstantiatedTemplateArgs.push_back((Expr *)E.release());
469      break;
470    }
471  }
472
473  // FIXME: We're missing the locations of the template name, '<', and
474  // '>'.
475  // FIXME: Need to instantiate into the template name.
476  return SemaRef.CheckTemplateIdType(T->getTemplateName(),
477                                     Loc,
478                                     SourceLocation(),
479                                     &InstantiatedTemplateArgs[0],
480                                     InstantiatedTemplateArgs.size(),
481                                     SourceLocation());
482}
483
484QualType
485TemplateTypeInstantiator::
486InstantiateQualifiedNameType(const QualifiedNameType *T,
487                             unsigned Quals) const {
488  // When we instantiated a qualified name type, there's no point in
489  // keeping the qualification around in the instantiated result. So,
490  // just instantiate the named type.
491  return (*this)(T->getNamedType());
492}
493
494QualType
495TemplateTypeInstantiator::
496InstantiateTypenameType(const TypenameType *T, unsigned Quals) const {
497  NestedNameSpecifier *NNS
498    = SemaRef.InstantiateNestedNameSpecifier(T->getQualifier(),
499                                             SourceRange(Loc),
500                                             TemplateArgs, NumTemplateArgs);
501  if (!NNS)
502    return QualType();
503
504  return SemaRef.CheckTypenameType(NNS, *T->getName(), SourceRange(Loc));
505}
506
507QualType
508TemplateTypeInstantiator::
509InstantiateObjCInterfaceType(const ObjCInterfaceType *T,
510                             unsigned Quals) const {
511  assert(false && "Objective-C types cannot be dependent");
512  return QualType();
513}
514
515QualType
516TemplateTypeInstantiator::
517InstantiateObjCQualifiedInterfaceType(const ObjCQualifiedInterfaceType *T,
518                                      unsigned Quals) const {
519  assert(false && "Objective-C types cannot be dependent");
520  return QualType();
521}
522
523QualType
524TemplateTypeInstantiator::
525InstantiateObjCQualifiedIdType(const ObjCQualifiedIdType *T,
526                               unsigned Quals) const {
527  assert(false && "Objective-C types cannot be dependent");
528  return QualType();
529}
530
531QualType
532TemplateTypeInstantiator::
533InstantiateObjCQualifiedClassType(const ObjCQualifiedClassType *T,
534                                  unsigned Quals) const {
535  assert(false && "Objective-C types cannot be dependent");
536  return QualType();
537}
538
539/// \brief The actual implementation of Sema::InstantiateType().
540QualType TemplateTypeInstantiator::Instantiate(QualType T) const {
541  // If T is not a dependent type, there is nothing to do.
542  if (!T->isDependentType())
543    return T;
544
545  switch (T->getTypeClass()) {
546#define TYPE(Class, Base)                                               \
547  case Type::Class:                                                     \
548    return Instantiate##Class##Type(cast<Class##Type>(T.getTypePtr()),  \
549                                    T.getCVRQualifiers());
550#define ABSTRACT_TYPE(Class, Base)
551#include "clang/AST/TypeNodes.def"
552  }
553
554  assert(false && "Not all types have been decoded for instantiation");
555  return QualType();
556}
557
558/// \brief Instantiate the type T with a given set of template arguments.
559///
560/// This routine substitutes the given template arguments into the
561/// type T and produces the instantiated type.
562///
563/// \param T the type into which the template arguments will be
564/// substituted. If this type is not dependent, it will be returned
565/// immediately.
566///
567/// \param TemplateArgs the template arguments that will be
568/// substituted for the top-level template parameters within T.
569///
570/// \param NumTemplateArgs the number of template arguments provided
571/// by TemplateArgs.
572///
573/// \param Loc the location in the source code where this substitution
574/// is being performed. It will typically be the location of the
575/// declarator (if we're instantiating the type of some declaration)
576/// or the location of the type in the source code (if, e.g., we're
577/// instantiating the type of a cast expression).
578///
579/// \param Entity the name of the entity associated with a declaration
580/// being instantiated (if any). May be empty to indicate that there
581/// is no such entity (if, e.g., this is a type that occurs as part of
582/// a cast expression) or that the entity has no name (e.g., an
583/// unnamed function parameter).
584///
585/// \returns If the instantiation succeeds, the instantiated
586/// type. Otherwise, produces diagnostics and returns a NULL type.
587QualType Sema::InstantiateType(QualType T,
588                               const TemplateArgument *TemplateArgs,
589                               unsigned NumTemplateArgs,
590                               SourceLocation Loc, DeclarationName Entity) {
591  assert(!ActiveTemplateInstantiations.empty() &&
592         "Cannot perform an instantiation without some context on the "
593         "instantiation stack");
594
595  // If T is not a dependent type, there is nothing to do.
596  if (!T->isDependentType())
597    return T;
598
599  TemplateTypeInstantiator Instantiator(*this, TemplateArgs, NumTemplateArgs,
600                                        Loc, Entity);
601  return Instantiator(T);
602}
603
604/// \brief Instantiate the base class specifiers of the given class
605/// template specialization.
606///
607/// Produces a diagnostic and returns true on error, returns false and
608/// attaches the instantiated base classes to the class template
609/// specialization if successful.
610bool
611Sema::InstantiateBaseSpecifiers(CXXRecordDecl *Instantiation,
612                                CXXRecordDecl *Pattern,
613                                const TemplateArgument *TemplateArgs,
614                                unsigned NumTemplateArgs) {
615  bool Invalid = false;
616  llvm::SmallVector<CXXBaseSpecifier*, 8> InstantiatedBases;
617  for (ClassTemplateSpecializationDecl::base_class_iterator
618         Base = Pattern->bases_begin(), BaseEnd = Pattern->bases_end();
619       Base != BaseEnd; ++Base) {
620    if (!Base->getType()->isDependentType()) {
621      // FIXME: Allocate via ASTContext
622      InstantiatedBases.push_back(new CXXBaseSpecifier(*Base));
623      continue;
624    }
625
626    QualType BaseType = InstantiateType(Base->getType(),
627                                        TemplateArgs, NumTemplateArgs,
628                                        Base->getSourceRange().getBegin(),
629                                        DeclarationName());
630    if (BaseType.isNull()) {
631      Invalid = true;
632      continue;
633    }
634
635    if (CXXBaseSpecifier *InstantiatedBase
636          = CheckBaseSpecifier(Instantiation,
637                               Base->getSourceRange(),
638                               Base->isVirtual(),
639                               Base->getAccessSpecifierAsWritten(),
640                               BaseType,
641                               /*FIXME: Not totally accurate */
642                               Base->getSourceRange().getBegin()))
643      InstantiatedBases.push_back(InstantiatedBase);
644    else
645      Invalid = true;
646  }
647
648  if (!Invalid &&
649      AttachBaseSpecifiers(Instantiation, &InstantiatedBases[0],
650                           InstantiatedBases.size()))
651    Invalid = true;
652
653  return Invalid;
654}
655
656/// \brief Instantiate the definition of a class from a given pattern.
657///
658/// \param PointOfInstantiation The point of instantiation within the
659/// source code.
660///
661/// \param Instantiation is the declaration whose definition is being
662/// instantiated. This will be either a class template specialization
663/// or a member class of a class template specialization.
664///
665/// \param Pattern is the pattern from which the instantiation
666/// occurs. This will be either the declaration of a class template or
667/// the declaration of a member class of a class template.
668///
669/// \param TemplateArgs The template arguments to be substituted into
670/// the pattern.
671///
672/// \param NumTemplateArgs The number of templates arguments in
673/// TemplateArgs.
674///
675/// \returns true if an error occurred, false otherwise.
676bool
677Sema::InstantiateClass(SourceLocation PointOfInstantiation,
678                       CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
679                       const TemplateArgument *TemplateArgs,
680                       unsigned NumTemplateArgs) {
681  bool Invalid = false;
682
683  CXXRecordDecl *PatternDef
684    = cast_or_null<CXXRecordDecl>(Pattern->getDefinition(Context));
685  if (!PatternDef) {
686    if (Pattern == Instantiation->getInstantiatedFromMemberClass()) {
687      Diag(PointOfInstantiation,
688           diag::err_implicit_instantiate_member_undefined)
689        << Context.getTypeDeclType(Instantiation);
690      Diag(Pattern->getLocation(), diag::note_member_of_template_here);
691    } else {
692      Diag(PointOfInstantiation,
693           diag::err_template_implicit_instantiate_undefined)
694        << Context.getTypeDeclType(Instantiation);
695      Diag(Pattern->getLocation(), diag::note_template_decl_here);
696    }
697    return true;
698  }
699  Pattern = PatternDef;
700
701  InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
702  if (Inst)
703    return true;
704
705  // Enter the scope of this instantiation. We don't use
706  // PushDeclContext because we don't have a scope.
707  DeclContext *PreviousContext = CurContext;
708  CurContext = Instantiation;
709
710  // Start the definition of this instantiation.
711  Instantiation->startDefinition();
712
713  // Instantiate the base class specifiers.
714  if (InstantiateBaseSpecifiers(Instantiation, Pattern, TemplateArgs,
715                                NumTemplateArgs))
716    Invalid = true;
717
718  llvm::SmallVector<DeclPtrTy, 32> Fields;
719  for (RecordDecl::decl_iterator Member = Pattern->decls_begin(),
720       MemberEnd = Pattern->decls_end(); Member != MemberEnd; ++Member) {
721    Decl *NewMember = InstantiateDecl(*Member, Instantiation,
722                                      TemplateArgs, NumTemplateArgs);
723    if (NewMember) {
724      if (NewMember->isInvalidDecl())
725        Invalid = true;
726      else if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember))
727        Fields.push_back(DeclPtrTy::make(Field));
728    } else {
729      // FIXME: Eventually, a NULL return will mean that one of the
730      // instantiations was a semantic disaster, and we'll want to set
731      // Invalid = true. For now, we expect to skip some members that
732      // we can't yet handle.
733    }
734  }
735
736  // Finish checking fields.
737  ActOnFields(0, Instantiation->getLocation(), DeclPtrTy::make(Instantiation),
738              &Fields[0], Fields.size(), SourceLocation(), SourceLocation(),
739              0);
740
741  // Add any implicitly-declared members that we might need.
742  AddImplicitlyDeclaredMembersToClass(Instantiation);
743
744  // Exit the scope of this instantiation.
745  CurContext = PreviousContext;
746
747  return Invalid;
748}
749
750bool
751Sema::InstantiateClassTemplateSpecialization(
752                           ClassTemplateSpecializationDecl *ClassTemplateSpec,
753                           bool ExplicitInstantiation) {
754  // Perform the actual instantiation on the canonical declaration.
755  ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
756                               Context.getCanonicalDecl(ClassTemplateSpec));
757
758  // We can only instantiate something that hasn't already been
759  // instantiated or specialized. Fail without any diagnostics: our
760  // caller will provide an error message.
761  if (ClassTemplateSpec->getSpecializationKind() != TSK_Undeclared)
762    return true;
763
764  // FIXME: Push this class template instantiation onto the
765  // instantiation stack, checking for recursion that exceeds a
766  // certain depth.
767
768  // FIXME: Perform class template partial specialization to select
769  // the best template.
770  ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
771
772  CXXRecordDecl *Pattern = Template->getTemplatedDecl();
773
774  // Note that this is an instantiation.
775  ClassTemplateSpec->setSpecializationKind(
776                        ExplicitInstantiation? TSK_ExplicitInstantiation
777                                             : TSK_ImplicitInstantiation);
778
779  return InstantiateClass(ClassTemplateSpec->getLocation(),
780                          ClassTemplateSpec, Pattern,
781                          ClassTemplateSpec->getTemplateArgs(),
782                          ClassTemplateSpec->getNumTemplateArgs());
783}
784
785/// \brief Instantiate a nested-name-specifier.
786NestedNameSpecifier *
787Sema::InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS,
788                                     SourceRange Range,
789                                     const TemplateArgument *TemplateArgs,
790                                     unsigned NumTemplateArgs) {
791  // Instantiate the prefix of this nested name specifier.
792  NestedNameSpecifier *Prefix = NNS->getPrefix();
793  if (Prefix) {
794    Prefix = InstantiateNestedNameSpecifier(Prefix, Range, TemplateArgs,
795                                            NumTemplateArgs);
796    if (!Prefix)
797      return 0;
798  }
799
800  switch (NNS->getKind()) {
801  case NestedNameSpecifier::Identifier:
802    // FIXME: Implement this lookup!
803    assert(false && "Cannot instantiate this nested-name-specifier");
804    break;
805
806  case NestedNameSpecifier::Namespace:
807  case NestedNameSpecifier::Global:
808    return NNS;
809
810  case NestedNameSpecifier::TypeSpecWithTemplate:
811  case NestedNameSpecifier::TypeSpec: {
812    QualType T = QualType(NNS->getAsType(), 0);
813    if (!T->isDependentType())
814      return NNS;
815
816    // FIXME: We won't be able to perform the instantiation here when
817    // the template-name is dependent, e.g., we have something like
818    // "T::template apply<U>::type".
819    T = InstantiateType(T, TemplateArgs, NumTemplateArgs, Range.getBegin(),
820                        DeclarationName());
821    if (T.isNull())
822      return 0;
823
824    if (T->isRecordType() ||
825        (getLangOptions().CPlusPlus0x && T->isEnumeralType())) {
826      // Note that T.getTypePtr(), below, strips cv-qualifiers. This is
827      // perfectly reasonable, since cv-qualified types in
828      // nested-name-specifiers don't matter.
829      return NestedNameSpecifier::Create(Context, Prefix,
830                 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate,
831                                         T.getTypePtr());
832    }
833
834    Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T;
835    return 0;
836  }
837  }
838
839  // Required to silence a GCC warning
840  return 0;
841}
842