SemaTemplateInstantiate.cpp revision d30226003ea60119b19901b7813821c7ec3d7e55 
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        = ClassTemplateSpecializationType::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::
436InstantiateClassTemplateSpecializationType(
437                                  const ClassTemplateSpecializationType *T,
438                                  unsigned Quals) const {
439  llvm::SmallVector<TemplateArgument, 16> InstantiatedTemplateArgs;
440  InstantiatedTemplateArgs.reserve(T->getNumArgs());
441  for (ClassTemplateSpecializationType::iterator Arg = T->begin(),
442                                              ArgEnd = T->end();
443       Arg != ArgEnd; ++Arg) {
444    switch (Arg->getKind()) {
445    case TemplateArgument::Type: {
446      QualType T = SemaRef.InstantiateType(Arg->getAsType(),
447                                           TemplateArgs, NumTemplateArgs,
448                                           Arg->getLocation(),
449                                           DeclarationName());
450      if (T.isNull())
451        return QualType();
452
453      InstantiatedTemplateArgs.push_back(
454                                TemplateArgument(Arg->getLocation(), T));
455      break;
456    }
457
458    case TemplateArgument::Declaration:
459    case TemplateArgument::Integral:
460      InstantiatedTemplateArgs.push_back(*Arg);
461      break;
462
463    case TemplateArgument::Expression:
464      Sema::OwningExprResult E
465        = SemaRef.InstantiateExpr(Arg->getAsExpr(), TemplateArgs,
466                                  NumTemplateArgs);
467      if (E.isInvalid())
468        return QualType();
469      InstantiatedTemplateArgs.push_back((Expr *)E.release());
470      break;
471    }
472  }
473
474  // FIXME: We're missing the locations of the template name, '<', and
475  // '>'.
476  return SemaRef.CheckClassTemplateId(cast<ClassTemplateDecl>(T->getTemplate()),
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<DeclTy *, 32> Fields;
719  for (RecordDecl::decl_iterator Member = Pattern->decls_begin(),
720                              MemberEnd = Pattern->decls_end();
721       Member != MemberEnd; ++Member) {
722    Decl *NewMember = InstantiateDecl(*Member, Instantiation,
723                                      TemplateArgs, NumTemplateArgs);
724    if (NewMember) {
725      if (NewMember->isInvalidDecl())
726        Invalid = true;
727      else if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember))
728        Fields.push_back(Field);
729    } else {
730      // FIXME: Eventually, a NULL return will mean that one of the
731      // instantiations was a semantic disaster, and we'll want to set
732      // Invalid = true. For now, we expect to skip some members that
733      // we can't yet handle.
734    }
735  }
736
737  // Finish checking fields.
738  ActOnFields(0, Instantiation->getLocation(), Instantiation,
739              &Fields[0], Fields.size(), SourceLocation(), SourceLocation(),
740              0);
741
742  // Add any implicitly-declared members that we might need.
743  AddImplicitlyDeclaredMembersToClass(Instantiation);
744
745  // Exit the scope of this instantiation.
746  CurContext = PreviousContext;
747
748  return Invalid;
749}
750
751bool
752Sema::InstantiateClassTemplateSpecialization(
753                           ClassTemplateSpecializationDecl *ClassTemplateSpec,
754                           bool ExplicitInstantiation) {
755  // Perform the actual instantiation on the canonical declaration.
756  ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
757                               Context.getCanonicalDecl(ClassTemplateSpec));
758
759  // We can only instantiate something that hasn't already been
760  // instantiated or specialized. Fail without any diagnostics: our
761  // caller will provide an error message.
762  if (ClassTemplateSpec->getSpecializationKind() != TSK_Undeclared)
763    return true;
764
765  // FIXME: Push this class template instantiation onto the
766  // instantiation stack, checking for recursion that exceeds a
767  // certain depth.
768
769  // FIXME: Perform class template partial specialization to select
770  // the best template.
771  ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
772
773  CXXRecordDecl *Pattern = Template->getTemplatedDecl();
774
775  // Note that this is an instantiation.
776  ClassTemplateSpec->setSpecializationKind(
777                        ExplicitInstantiation? TSK_ExplicitInstantiation
778                                             : TSK_ImplicitInstantiation);
779
780  return InstantiateClass(ClassTemplateSpec->getLocation(),
781                          ClassTemplateSpec, Pattern,
782                          ClassTemplateSpec->getTemplateArgs(),
783                          ClassTemplateSpec->getNumTemplateArgs());
784}
785
786/// \brief Instantiate a nested-name-specifier.
787NestedNameSpecifier *
788Sema::InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS,
789                                     SourceRange Range,
790                                     const TemplateArgument *TemplateArgs,
791                                     unsigned NumTemplateArgs) {
792  // Instantiate the prefix of this nested name specifier.
793  NestedNameSpecifier *Prefix = NNS->getPrefix();
794  if (Prefix) {
795    Prefix = InstantiateNestedNameSpecifier(Prefix, Range, TemplateArgs,
796                                            NumTemplateArgs);
797    if (!Prefix)
798      return 0;
799  }
800
801  switch (NNS->getKind()) {
802  case NestedNameSpecifier::Identifier:
803    // FIXME: Implement this lookup!
804    assert(false && "Cannot instantiate this nested-name-specifier");
805    break;
806
807  case NestedNameSpecifier::Namespace:
808  case NestedNameSpecifier::Global:
809    return NNS;
810
811  case NestedNameSpecifier::TypeSpecWithTemplate:
812  case NestedNameSpecifier::TypeSpec: {
813    QualType T = QualType(NNS->getAsType(), 0);
814    if (!T->isDependentType())
815      return NNS;
816
817    // FIXME: We won't be able to perform the instantiation here when
818    // the template-name is dependent, e.g., we have something like
819    // "T::template apply<U>::type".
820    T = InstantiateType(T, TemplateArgs, NumTemplateArgs, Range.getBegin(),
821                        DeclarationName());
822    if (T.isNull())
823      return 0;
824
825    if (T->isRecordType() ||
826        (getLangOptions().CPlusPlus0x && T->isEnumeralType())) {
827      // Note that T.getTypePtr(), below, strips cv-qualifiers. This is
828      // perfectly reasonable, since cv-qualified types in
829      // nested-name-specifiers don't matter.
830      return NestedNameSpecifier::Create(Context, Prefix,
831                 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate,
832                                         T.getTypePtr());
833    }
834
835    Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T;
836    return 0;
837  }
838  }
839
840  // Required to silence a GCC warning
841  return 0;
842}
843