SemaTemplateInstantiate.cpp revision ab452ba8323d1985e08bade2bced588cddf2cc28 
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  assert(false && "Cannot have dependent qualified name types (yet)");
489  return QualType();
490}
491
492QualType
493TemplateTypeInstantiator::
494InstantiateObjCInterfaceType(const ObjCInterfaceType *T,
495                             unsigned Quals) const {
496  assert(false && "Objective-C types cannot be dependent");
497  return QualType();
498}
499
500QualType
501TemplateTypeInstantiator::
502InstantiateObjCQualifiedInterfaceType(const ObjCQualifiedInterfaceType *T,
503                                      unsigned Quals) const {
504  assert(false && "Objective-C types cannot be dependent");
505  return QualType();
506}
507
508QualType
509TemplateTypeInstantiator::
510InstantiateObjCQualifiedIdType(const ObjCQualifiedIdType *T,
511                               unsigned Quals) const {
512  assert(false && "Objective-C types cannot be dependent");
513  return QualType();
514}
515
516QualType
517TemplateTypeInstantiator::
518InstantiateObjCQualifiedClassType(const ObjCQualifiedClassType *T,
519                                  unsigned Quals) const {
520  assert(false && "Objective-C types cannot be dependent");
521  return QualType();
522}
523
524/// \brief The actual implementation of Sema::InstantiateType().
525QualType TemplateTypeInstantiator::Instantiate(QualType T) const {
526  // If T is not a dependent type, there is nothing to do.
527  if (!T->isDependentType())
528    return T;
529
530  switch (T->getTypeClass()) {
531#define TYPE(Class, Base)                                               \
532  case Type::Class:                                                     \
533    return Instantiate##Class##Type(cast<Class##Type>(T.getTypePtr()),  \
534                                    T.getCVRQualifiers());
535#define ABSTRACT_TYPE(Class, Base)
536#include "clang/AST/TypeNodes.def"
537  }
538
539  assert(false && "Not all types have been decoded for instantiation");
540  return QualType();
541}
542
543/// \brief Instantiate the type T with a given set of template arguments.
544///
545/// This routine substitutes the given template arguments into the
546/// type T and produces the instantiated type.
547///
548/// \param T the type into which the template arguments will be
549/// substituted. If this type is not dependent, it will be returned
550/// immediately.
551///
552/// \param TemplateArgs the template arguments that will be
553/// substituted for the top-level template parameters within T.
554///
555/// \param NumTemplateArgs the number of template arguments provided
556/// by TemplateArgs.
557///
558/// \param Loc the location in the source code where this substitution
559/// is being performed. It will typically be the location of the
560/// declarator (if we're instantiating the type of some declaration)
561/// or the location of the type in the source code (if, e.g., we're
562/// instantiating the type of a cast expression).
563///
564/// \param Entity the name of the entity associated with a declaration
565/// being instantiated (if any). May be empty to indicate that there
566/// is no such entity (if, e.g., this is a type that occurs as part of
567/// a cast expression) or that the entity has no name (e.g., an
568/// unnamed function parameter).
569///
570/// \returns If the instantiation succeeds, the instantiated
571/// type. Otherwise, produces diagnostics and returns a NULL type.
572QualType Sema::InstantiateType(QualType T,
573                               const TemplateArgument *TemplateArgs,
574                               unsigned NumTemplateArgs,
575                               SourceLocation Loc, DeclarationName Entity) {
576  assert(!ActiveTemplateInstantiations.empty() &&
577         "Cannot perform an instantiation without some context on the "
578         "instantiation stack");
579
580  // If T is not a dependent type, there is nothing to do.
581  if (!T->isDependentType())
582    return T;
583
584  TemplateTypeInstantiator Instantiator(*this, TemplateArgs, NumTemplateArgs,
585                                        Loc, Entity);
586  return Instantiator(T);
587}
588
589/// \brief Instantiate the base class specifiers of the given class
590/// template specialization.
591///
592/// Produces a diagnostic and returns true on error, returns false and
593/// attaches the instantiated base classes to the class template
594/// specialization if successful.
595bool
596Sema::InstantiateBaseSpecifiers(CXXRecordDecl *Instantiation,
597                                CXXRecordDecl *Pattern,
598                                const TemplateArgument *TemplateArgs,
599                                unsigned NumTemplateArgs) {
600  bool Invalid = false;
601  llvm::SmallVector<CXXBaseSpecifier*, 8> InstantiatedBases;
602  for (ClassTemplateSpecializationDecl::base_class_iterator
603         Base = Pattern->bases_begin(), BaseEnd = Pattern->bases_end();
604       Base != BaseEnd; ++Base) {
605    if (!Base->getType()->isDependentType()) {
606      // FIXME: Allocate via ASTContext
607      InstantiatedBases.push_back(new CXXBaseSpecifier(*Base));
608      continue;
609    }
610
611    QualType BaseType = InstantiateType(Base->getType(),
612                                        TemplateArgs, NumTemplateArgs,
613                                        Base->getSourceRange().getBegin(),
614                                        DeclarationName());
615    if (BaseType.isNull()) {
616      Invalid = true;
617      continue;
618    }
619
620    if (CXXBaseSpecifier *InstantiatedBase
621          = CheckBaseSpecifier(Instantiation,
622                               Base->getSourceRange(),
623                               Base->isVirtual(),
624                               Base->getAccessSpecifierAsWritten(),
625                               BaseType,
626                               /*FIXME: Not totally accurate */
627                               Base->getSourceRange().getBegin()))
628      InstantiatedBases.push_back(InstantiatedBase);
629    else
630      Invalid = true;
631  }
632
633  if (!Invalid &&
634      AttachBaseSpecifiers(Instantiation, &InstantiatedBases[0],
635                           InstantiatedBases.size()))
636    Invalid = true;
637
638  return Invalid;
639}
640
641/// \brief Instantiate the definition of a class from a given pattern.
642///
643/// \param PointOfInstantiation The point of instantiation within the
644/// source code.
645///
646/// \param Instantiation is the declaration whose definition is being
647/// instantiated. This will be either a class template specialization
648/// or a member class of a class template specialization.
649///
650/// \param Pattern is the pattern from which the instantiation
651/// occurs. This will be either the declaration of a class template or
652/// the declaration of a member class of a class template.
653///
654/// \param TemplateArgs The template arguments to be substituted into
655/// the pattern.
656///
657/// \param NumTemplateArgs The number of templates arguments in
658/// TemplateArgs.
659///
660/// \returns true if an error occurred, false otherwise.
661bool
662Sema::InstantiateClass(SourceLocation PointOfInstantiation,
663                       CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
664                       const TemplateArgument *TemplateArgs,
665                       unsigned NumTemplateArgs) {
666  bool Invalid = false;
667
668  CXXRecordDecl *PatternDef
669    = cast_or_null<CXXRecordDecl>(Pattern->getDefinition(Context));
670  if (!PatternDef) {
671    if (Pattern == Instantiation->getInstantiatedFromMemberClass()) {
672      Diag(PointOfInstantiation,
673           diag::err_implicit_instantiate_member_undefined)
674        << Context.getTypeDeclType(Instantiation);
675      Diag(Pattern->getLocation(), diag::note_member_of_template_here);
676    } else {
677      Diag(PointOfInstantiation,
678           diag::err_template_implicit_instantiate_undefined)
679        << Context.getTypeDeclType(Instantiation);
680      Diag(Pattern->getLocation(), diag::note_template_decl_here);
681    }
682    return true;
683  }
684  Pattern = PatternDef;
685
686  InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
687  if (Inst)
688    return true;
689
690  // Enter the scope of this instantiation. We don't use
691  // PushDeclContext because we don't have a scope.
692  DeclContext *PreviousContext = CurContext;
693  CurContext = Instantiation;
694
695  // Start the definition of this instantiation.
696  Instantiation->startDefinition();
697
698  // Instantiate the base class specifiers.
699  if (InstantiateBaseSpecifiers(Instantiation, Pattern, TemplateArgs,
700                                NumTemplateArgs))
701    Invalid = true;
702
703  llvm::SmallVector<DeclTy *, 32> Fields;
704  for (RecordDecl::decl_iterator Member = Pattern->decls_begin(),
705                              MemberEnd = Pattern->decls_end();
706       Member != MemberEnd; ++Member) {
707    Decl *NewMember = InstantiateDecl(*Member, Instantiation,
708                                      TemplateArgs, NumTemplateArgs);
709    if (NewMember) {
710      if (NewMember->isInvalidDecl())
711        Invalid = true;
712      else if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember))
713        Fields.push_back(Field);
714    } else {
715      // FIXME: Eventually, a NULL return will mean that one of the
716      // instantiations was a semantic disaster, and we'll want to set
717      // Invalid = true. For now, we expect to skip some members that
718      // we can't yet handle.
719    }
720  }
721
722  // Finish checking fields.
723  ActOnFields(0, Instantiation->getLocation(), Instantiation,
724              &Fields[0], Fields.size(), SourceLocation(), SourceLocation(),
725              0);
726
727  // Add any implicitly-declared members that we might need.
728  AddImplicitlyDeclaredMembersToClass(Instantiation);
729
730  // Exit the scope of this instantiation.
731  CurContext = PreviousContext;
732
733  return Invalid;
734}
735
736bool
737Sema::InstantiateClassTemplateSpecialization(
738                           ClassTemplateSpecializationDecl *ClassTemplateSpec,
739                           bool ExplicitInstantiation) {
740  // Perform the actual instantiation on the canonical declaration.
741  ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
742                               Context.getCanonicalDecl(ClassTemplateSpec));
743
744  // We can only instantiate something that hasn't already been
745  // instantiated or specialized. Fail without any diagnostics: our
746  // caller will provide an error message.
747  if (ClassTemplateSpec->getSpecializationKind() != TSK_Undeclared)
748    return true;
749
750  // FIXME: Push this class template instantiation onto the
751  // instantiation stack, checking for recursion that exceeds a
752  // certain depth.
753
754  // FIXME: Perform class template partial specialization to select
755  // the best template.
756  ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
757
758  CXXRecordDecl *Pattern = Template->getTemplatedDecl();
759
760  // Note that this is an instantiation.
761  ClassTemplateSpec->setSpecializationKind(
762                        ExplicitInstantiation? TSK_ExplicitInstantiation
763                                             : TSK_ImplicitInstantiation);
764
765  return InstantiateClass(ClassTemplateSpec->getLocation(),
766                          ClassTemplateSpec, Pattern,
767                          ClassTemplateSpec->getTemplateArgs(),
768                          ClassTemplateSpec->getNumTemplateArgs());
769}
770
771/// \brief Instantiate a nested-name-specifier.
772NestedNameSpecifier *
773Sema::InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS,
774                                     SourceRange Range,
775                                     const TemplateArgument *TemplateArgs,
776                                     unsigned NumTemplateArgs) {
777  // Instantiate the prefix of this nested name specifier.
778  NestedNameSpecifier *Prefix = NNS->getPrefix();
779  if (Prefix) {
780    Prefix = InstantiateNestedNameSpecifier(Prefix, Range, TemplateArgs,
781                                            NumTemplateArgs);
782    if (!Prefix)
783      return 0;
784  }
785
786  switch (NNS->getKind()) {
787  case NestedNameSpecifier::Identifier:
788    // FIXME: Implement this lookup!
789    assert(false && "Cannot instantiate this nested-name-specifier");
790    break;
791
792  case NestedNameSpecifier::Namespace:
793  case NestedNameSpecifier::Global:
794    return NNS;
795
796  case NestedNameSpecifier::TypeSpecWithTemplate:
797  case NestedNameSpecifier::TypeSpec: {
798    QualType T = QualType(NNS->getAsType(), 0);
799    if (!T->isDependentType())
800      return NNS;
801
802    T = InstantiateType(T, TemplateArgs, NumTemplateArgs, Range.getBegin(),
803                        DeclarationName());
804    if (T.isNull())
805      return 0;
806
807    // Note that T.getTypePtr(), below, strips cv-qualifiers. This is
808    // perfectly reasonable, since cv-qualified types in
809    // nested-name-specifiers don't matter.
810    // FIXME: we need to perform more checking on this type.
811    return NestedNameSpecifier::Create(Context, Prefix,
812                 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate,
813                                       T.getTypePtr());
814  }
815  }
816
817  // Required to silence GCC warning.
818  return 0;
819}
820