1 //===------- SemaTemplateDeduction.cpp - Template Argument Deduction ------===/
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //===----------------------------------------------------------------------===/
9 // This file implements C++ template argument deduction.
11 //===----------------------------------------------------------------------===/
13 #include "clang/Sema/TemplateDeduction.h"
14 #include "TreeTransform.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/ASTLambda.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/DeclTemplate.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/ExprCXX.h"
21 #include "clang/AST/StmtVisitor.h"
22 #include "clang/Sema/DeclSpec.h"
23 #include "clang/Sema/Sema.h"
24 #include "clang/Sema/Template.h"
25 #include "llvm/ADT/SmallBitVector.h"
30 /// \brief Various flags that control template argument deduction.
32 /// These flags can be bitwise-OR'd together.
33 enum TemplateDeductionFlags {
34 /// \brief No template argument deduction flags, which indicates the
35 /// strictest results for template argument deduction (as used for, e.g.,
36 /// matching class template partial specializations).
38 /// \brief Within template argument deduction from a function call, we are
39 /// matching with a parameter type for which the original parameter was
41 TDF_ParamWithReferenceType = 0x1,
42 /// \brief Within template argument deduction from a function call, we
43 /// are matching in a case where we ignore cv-qualifiers.
44 TDF_IgnoreQualifiers = 0x02,
45 /// \brief Within template argument deduction from a function call,
46 /// we are matching in a case where we can perform template argument
47 /// deduction from a template-id of a derived class of the argument type.
48 TDF_DerivedClass = 0x04,
49 /// \brief Allow non-dependent types to differ, e.g., when performing
50 /// template argument deduction from a function call where conversions
52 TDF_SkipNonDependent = 0x08,
53 /// \brief Whether we are performing template argument deduction for
54 /// parameters and arguments in a top-level template argument
55 TDF_TopLevelParameterTypeList = 0x10,
56 /// \brief Within template argument deduction from overload resolution per
57 /// C++ [over.over] allow matching function types that are compatible in
58 /// terms of noreturn and default calling convention adjustments.
59 TDF_InOverloadResolution = 0x20
63 using namespace clang;
65 /// \brief Compare two APSInts, extending and switching the sign as
66 /// necessary to compare their values regardless of underlying type.
67 static bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) {
68 if (Y.getBitWidth() > X.getBitWidth())
69 X = X.extend(Y.getBitWidth());
70 else if (Y.getBitWidth() < X.getBitWidth())
71 Y = Y.extend(X.getBitWidth());
73 // If there is a signedness mismatch, correct it.
74 if (X.isSigned() != Y.isSigned()) {
75 // If the signed value is negative, then the values cannot be the same.
76 if ((Y.isSigned() && Y.isNegative()) || (X.isSigned() && X.isNegative()))
86 static Sema::TemplateDeductionResult
87 DeduceTemplateArguments(Sema &S,
88 TemplateParameterList *TemplateParams,
89 const TemplateArgument &Param,
91 TemplateDeductionInfo &Info,
92 SmallVectorImpl<DeducedTemplateArgument> &Deduced);
94 /// \brief Whether template argument deduction for two reference parameters
95 /// resulted in the argument type, parameter type, or neither type being more
96 /// qualified than the other.
97 enum DeductionQualifierComparison {
98 NeitherMoreQualified = 0,
103 /// \brief Stores the result of comparing two reference parameters while
104 /// performing template argument deduction for partial ordering of function
106 struct RefParamPartialOrderingComparison {
107 /// \brief Whether the parameter type is an rvalue reference type.
108 bool ParamIsRvalueRef;
109 /// \brief Whether the argument type is an rvalue reference type.
112 /// \brief Whether the parameter or argument (or neither) is more qualified.
113 DeductionQualifierComparison Qualifiers;
118 static Sema::TemplateDeductionResult
119 DeduceTemplateArgumentsByTypeMatch(Sema &S,
120 TemplateParameterList *TemplateParams,
123 TemplateDeductionInfo &Info,
124 SmallVectorImpl<DeducedTemplateArgument> &
127 bool PartialOrdering = false,
128 SmallVectorImpl<RefParamPartialOrderingComparison> *
129 RefParamComparisons = 0);
131 static Sema::TemplateDeductionResult
132 DeduceTemplateArguments(Sema &S,
133 TemplateParameterList *TemplateParams,
134 const TemplateArgument *Params, unsigned NumParams,
135 const TemplateArgument *Args, unsigned NumArgs,
136 TemplateDeductionInfo &Info,
137 SmallVectorImpl<DeducedTemplateArgument> &Deduced);
139 /// \brief If the given expression is of a form that permits the deduction
140 /// of a non-type template parameter, return the declaration of that
141 /// non-type template parameter.
142 static NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) {
143 // If we are within an alias template, the expression may have undergone
144 // any number of parameter substitutions already.
146 if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E))
147 E = IC->getSubExpr();
148 else if (SubstNonTypeTemplateParmExpr *Subst =
149 dyn_cast<SubstNonTypeTemplateParmExpr>(E))
150 E = Subst->getReplacement();
155 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
156 return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
161 /// \brief Determine whether two declaration pointers refer to the same
163 static bool isSameDeclaration(Decl *X, Decl *Y) {
164 if (NamedDecl *NX = dyn_cast<NamedDecl>(X))
165 X = NX->getUnderlyingDecl();
166 if (NamedDecl *NY = dyn_cast<NamedDecl>(Y))
167 Y = NY->getUnderlyingDecl();
169 return X->getCanonicalDecl() == Y->getCanonicalDecl();
172 /// \brief Verify that the given, deduced template arguments are compatible.
174 /// \returns The deduced template argument, or a NULL template argument if
175 /// the deduced template arguments were incompatible.
176 static DeducedTemplateArgument
177 checkDeducedTemplateArguments(ASTContext &Context,
178 const DeducedTemplateArgument &X,
179 const DeducedTemplateArgument &Y) {
180 // We have no deduction for one or both of the arguments; they're compatible.
186 switch (X.getKind()) {
187 case TemplateArgument::Null:
188 llvm_unreachable("Non-deduced template arguments handled above");
190 case TemplateArgument::Type:
191 // If two template type arguments have the same type, they're compatible.
192 if (Y.getKind() == TemplateArgument::Type &&
193 Context.hasSameType(X.getAsType(), Y.getAsType()))
196 return DeducedTemplateArgument();
198 case TemplateArgument::Integral:
199 // If we deduced a constant in one case and either a dependent expression or
200 // declaration in another case, keep the integral constant.
201 // If both are integral constants with the same value, keep that value.
202 if (Y.getKind() == TemplateArgument::Expression ||
203 Y.getKind() == TemplateArgument::Declaration ||
204 (Y.getKind() == TemplateArgument::Integral &&
205 hasSameExtendedValue(X.getAsIntegral(), Y.getAsIntegral())))
206 return DeducedTemplateArgument(X,
207 X.wasDeducedFromArrayBound() &&
208 Y.wasDeducedFromArrayBound());
210 // All other combinations are incompatible.
211 return DeducedTemplateArgument();
213 case TemplateArgument::Template:
214 if (Y.getKind() == TemplateArgument::Template &&
215 Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate()))
218 // All other combinations are incompatible.
219 return DeducedTemplateArgument();
221 case TemplateArgument::TemplateExpansion:
222 if (Y.getKind() == TemplateArgument::TemplateExpansion &&
223 Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(),
224 Y.getAsTemplateOrTemplatePattern()))
227 // All other combinations are incompatible.
228 return DeducedTemplateArgument();
230 case TemplateArgument::Expression:
231 // If we deduced a dependent expression in one case and either an integral
232 // constant or a declaration in another case, keep the integral constant
234 if (Y.getKind() == TemplateArgument::Integral ||
235 Y.getKind() == TemplateArgument::Declaration)
236 return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() &&
237 Y.wasDeducedFromArrayBound());
239 if (Y.getKind() == TemplateArgument::Expression) {
240 // Compare the expressions for equality
241 llvm::FoldingSetNodeID ID1, ID2;
242 X.getAsExpr()->Profile(ID1, Context, true);
243 Y.getAsExpr()->Profile(ID2, Context, true);
248 // All other combinations are incompatible.
249 return DeducedTemplateArgument();
251 case TemplateArgument::Declaration:
252 // If we deduced a declaration and a dependent expression, keep the
254 if (Y.getKind() == TemplateArgument::Expression)
257 // If we deduced a declaration and an integral constant, keep the
258 // integral constant.
259 if (Y.getKind() == TemplateArgument::Integral)
262 // If we deduced two declarations, make sure they they refer to the
264 if (Y.getKind() == TemplateArgument::Declaration &&
265 isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) &&
266 X.isDeclForReferenceParam() == Y.isDeclForReferenceParam())
269 // All other combinations are incompatible.
270 return DeducedTemplateArgument();
272 case TemplateArgument::NullPtr:
273 // If we deduced a null pointer and a dependent expression, keep the
275 if (Y.getKind() == TemplateArgument::Expression)
278 // If we deduced a null pointer and an integral constant, keep the
279 // integral constant.
280 if (Y.getKind() == TemplateArgument::Integral)
283 // If we deduced two null pointers, make sure they have the same type.
284 if (Y.getKind() == TemplateArgument::NullPtr &&
285 Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType()))
288 // All other combinations are incompatible.
289 return DeducedTemplateArgument();
291 case TemplateArgument::Pack:
292 if (Y.getKind() != TemplateArgument::Pack ||
293 X.pack_size() != Y.pack_size())
294 return DeducedTemplateArgument();
296 for (TemplateArgument::pack_iterator XA = X.pack_begin(),
297 XAEnd = X.pack_end(),
299 XA != XAEnd; ++XA, ++YA) {
300 if (checkDeducedTemplateArguments(Context,
301 DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()),
302 DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound()))
304 return DeducedTemplateArgument();
310 llvm_unreachable("Invalid TemplateArgument Kind!");
313 /// \brief Deduce the value of the given non-type template parameter
314 /// from the given constant.
315 static Sema::TemplateDeductionResult
316 DeduceNonTypeTemplateArgument(Sema &S,
317 NonTypeTemplateParmDecl *NTTP,
318 llvm::APSInt Value, QualType ValueType,
319 bool DeducedFromArrayBound,
320 TemplateDeductionInfo &Info,
321 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
322 assert(NTTP->getDepth() == 0 &&
323 "Cannot deduce non-type template argument with depth > 0");
325 DeducedTemplateArgument NewDeduced(S.Context, Value, ValueType,
326 DeducedFromArrayBound);
327 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
328 Deduced[NTTP->getIndex()],
330 if (Result.isNull()) {
332 Info.FirstArg = Deduced[NTTP->getIndex()];
333 Info.SecondArg = NewDeduced;
334 return Sema::TDK_Inconsistent;
337 Deduced[NTTP->getIndex()] = Result;
338 return Sema::TDK_Success;
341 /// \brief Deduce the value of the given non-type template parameter
342 /// from the given type- or value-dependent expression.
344 /// \returns true if deduction succeeded, false otherwise.
345 static Sema::TemplateDeductionResult
346 DeduceNonTypeTemplateArgument(Sema &S,
347 NonTypeTemplateParmDecl *NTTP,
349 TemplateDeductionInfo &Info,
350 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
351 assert(NTTP->getDepth() == 0 &&
352 "Cannot deduce non-type template argument with depth > 0");
353 assert((Value->isTypeDependent() || Value->isValueDependent()) &&
354 "Expression template argument must be type- or value-dependent.");
356 DeducedTemplateArgument NewDeduced(Value);
357 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
358 Deduced[NTTP->getIndex()],
361 if (Result.isNull()) {
363 Info.FirstArg = Deduced[NTTP->getIndex()];
364 Info.SecondArg = NewDeduced;
365 return Sema::TDK_Inconsistent;
368 Deduced[NTTP->getIndex()] = Result;
369 return Sema::TDK_Success;
372 /// \brief Deduce the value of the given non-type template parameter
373 /// from the given declaration.
375 /// \returns true if deduction succeeded, false otherwise.
376 static Sema::TemplateDeductionResult
377 DeduceNonTypeTemplateArgument(Sema &S,
378 NonTypeTemplateParmDecl *NTTP,
380 TemplateDeductionInfo &Info,
381 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
382 assert(NTTP->getDepth() == 0 &&
383 "Cannot deduce non-type template argument with depth > 0");
385 D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : 0;
386 TemplateArgument New(D, NTTP->getType()->isReferenceType());
387 DeducedTemplateArgument NewDeduced(New);
388 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
389 Deduced[NTTP->getIndex()],
391 if (Result.isNull()) {
393 Info.FirstArg = Deduced[NTTP->getIndex()];
394 Info.SecondArg = NewDeduced;
395 return Sema::TDK_Inconsistent;
398 Deduced[NTTP->getIndex()] = Result;
399 return Sema::TDK_Success;
402 static Sema::TemplateDeductionResult
403 DeduceTemplateArguments(Sema &S,
404 TemplateParameterList *TemplateParams,
407 TemplateDeductionInfo &Info,
408 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
409 TemplateDecl *ParamDecl = Param.getAsTemplateDecl();
411 // The parameter type is dependent and is not a template template parameter,
412 // so there is nothing that we can deduce.
413 return Sema::TDK_Success;
416 if (TemplateTemplateParmDecl *TempParam
417 = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) {
418 DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg));
419 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
420 Deduced[TempParam->getIndex()],
422 if (Result.isNull()) {
423 Info.Param = TempParam;
424 Info.FirstArg = Deduced[TempParam->getIndex()];
425 Info.SecondArg = NewDeduced;
426 return Sema::TDK_Inconsistent;
429 Deduced[TempParam->getIndex()] = Result;
430 return Sema::TDK_Success;
433 // Verify that the two template names are equivalent.
434 if (S.Context.hasSameTemplateName(Param, Arg))
435 return Sema::TDK_Success;
437 // Mismatch of non-dependent template parameter to argument.
438 Info.FirstArg = TemplateArgument(Param);
439 Info.SecondArg = TemplateArgument(Arg);
440 return Sema::TDK_NonDeducedMismatch;
443 /// \brief Deduce the template arguments by comparing the template parameter
444 /// type (which is a template-id) with the template argument type.
446 /// \param S the Sema
448 /// \param TemplateParams the template parameters that we are deducing
450 /// \param Param the parameter type
452 /// \param Arg the argument type
454 /// \param Info information about the template argument deduction itself
456 /// \param Deduced the deduced template arguments
458 /// \returns the result of template argument deduction so far. Note that a
459 /// "success" result means that template argument deduction has not yet failed,
460 /// but it may still fail, later, for other reasons.
461 static Sema::TemplateDeductionResult
462 DeduceTemplateArguments(Sema &S,
463 TemplateParameterList *TemplateParams,
464 const TemplateSpecializationType *Param,
466 TemplateDeductionInfo &Info,
467 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
468 assert(Arg.isCanonical() && "Argument type must be canonical");
470 // Check whether the template argument is a dependent template-id.
471 if (const TemplateSpecializationType *SpecArg
472 = dyn_cast<TemplateSpecializationType>(Arg)) {
473 // Perform template argument deduction for the template name.
474 if (Sema::TemplateDeductionResult Result
475 = DeduceTemplateArguments(S, TemplateParams,
476 Param->getTemplateName(),
477 SpecArg->getTemplateName(),
482 // Perform template argument deduction on each template
483 // argument. Ignore any missing/extra arguments, since they could be
484 // filled in by default arguments.
485 return DeduceTemplateArguments(S, TemplateParams,
486 Param->getArgs(), Param->getNumArgs(),
487 SpecArg->getArgs(), SpecArg->getNumArgs(),
491 // If the argument type is a class template specialization, we
492 // perform template argument deduction using its template
494 const RecordType *RecordArg = dyn_cast<RecordType>(Arg);
496 Info.FirstArg = TemplateArgument(QualType(Param, 0));
497 Info.SecondArg = TemplateArgument(Arg);
498 return Sema::TDK_NonDeducedMismatch;
501 ClassTemplateSpecializationDecl *SpecArg
502 = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl());
504 Info.FirstArg = TemplateArgument(QualType(Param, 0));
505 Info.SecondArg = TemplateArgument(Arg);
506 return Sema::TDK_NonDeducedMismatch;
509 // Perform template argument deduction for the template name.
510 if (Sema::TemplateDeductionResult Result
511 = DeduceTemplateArguments(S,
513 Param->getTemplateName(),
514 TemplateName(SpecArg->getSpecializedTemplate()),
518 // Perform template argument deduction for the template arguments.
519 return DeduceTemplateArguments(S, TemplateParams,
520 Param->getArgs(), Param->getNumArgs(),
521 SpecArg->getTemplateArgs().data(),
522 SpecArg->getTemplateArgs().size(),
526 /// \brief Determines whether the given type is an opaque type that
527 /// might be more qualified when instantiated.
528 static bool IsPossiblyOpaquelyQualifiedType(QualType T) {
529 switch (T->getTypeClass()) {
530 case Type::TypeOfExpr:
532 case Type::DependentName:
534 case Type::UnresolvedUsing:
535 case Type::TemplateTypeParm:
538 case Type::ConstantArray:
539 case Type::IncompleteArray:
540 case Type::VariableArray:
541 case Type::DependentSizedArray:
542 return IsPossiblyOpaquelyQualifiedType(
543 cast<ArrayType>(T)->getElementType());
550 /// \brief Retrieve the depth and index of a template parameter.
551 static std::pair<unsigned, unsigned>
552 getDepthAndIndex(NamedDecl *ND) {
553 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
554 return std::make_pair(TTP->getDepth(), TTP->getIndex());
556 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
557 return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
559 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
560 return std::make_pair(TTP->getDepth(), TTP->getIndex());
563 /// \brief Retrieve the depth and index of an unexpanded parameter pack.
564 static std::pair<unsigned, unsigned>
565 getDepthAndIndex(UnexpandedParameterPack UPP) {
566 if (const TemplateTypeParmType *TTP
567 = UPP.first.dyn_cast<const TemplateTypeParmType *>())
568 return std::make_pair(TTP->getDepth(), TTP->getIndex());
570 return getDepthAndIndex(UPP.first.get<NamedDecl *>());
573 /// \brief Helper function to build a TemplateParameter when we don't
574 /// know its type statically.
575 static TemplateParameter makeTemplateParameter(Decl *D) {
576 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D))
577 return TemplateParameter(TTP);
578 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
579 return TemplateParameter(NTTP);
581 return TemplateParameter(cast<TemplateTemplateParmDecl>(D));
584 typedef SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2>
585 NewlyDeducedPacksType;
587 /// \brief Prepare to perform template argument deduction for all of the
588 /// arguments in a set of argument packs.
590 PrepareArgumentPackDeduction(Sema &S,
591 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
592 ArrayRef<unsigned> PackIndices,
593 SmallVectorImpl<DeducedTemplateArgument> &SavedPacks,
594 NewlyDeducedPacksType &NewlyDeducedPacks) {
595 // Save the deduced template arguments for each parameter pack expanded
596 // by this pack expansion, then clear out the deduction.
597 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
598 // Save the previously-deduced argument pack, then clear it out so that we
599 // can deduce a new argument pack.
600 SavedPacks[I] = Deduced[PackIndices[I]];
601 Deduced[PackIndices[I]] = TemplateArgument();
603 if (!S.CurrentInstantiationScope)
606 // If the template argument pack was explicitly specified, add that to
607 // the set of deduced arguments.
608 const TemplateArgument *ExplicitArgs;
609 unsigned NumExplicitArgs;
610 if (NamedDecl *PartiallySubstitutedPack
611 = S.CurrentInstantiationScope->getPartiallySubstitutedPack(
614 if (getDepthAndIndex(PartiallySubstitutedPack).second == PackIndices[I])
615 NewlyDeducedPacks[I].append(ExplicitArgs,
616 ExplicitArgs + NumExplicitArgs);
621 /// \brief Finish template argument deduction for a set of argument packs,
622 /// producing the argument packs and checking for consistency with prior
624 static Sema::TemplateDeductionResult
625 FinishArgumentPackDeduction(Sema &S,
626 TemplateParameterList *TemplateParams,
627 bool HasAnyArguments,
628 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
629 ArrayRef<unsigned> PackIndices,
630 SmallVectorImpl<DeducedTemplateArgument> &SavedPacks,
631 NewlyDeducedPacksType &NewlyDeducedPacks,
632 TemplateDeductionInfo &Info) {
633 // Build argument packs for each of the parameter packs expanded by this
635 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
636 if (HasAnyArguments && NewlyDeducedPacks[I].empty()) {
637 // We were not able to deduce anything for this parameter pack,
638 // so just restore the saved argument pack.
639 Deduced[PackIndices[I]] = SavedPacks[I];
643 DeducedTemplateArgument NewPack;
645 if (NewlyDeducedPacks[I].empty()) {
646 // If we deduced an empty argument pack, create it now.
647 NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack());
649 TemplateArgument *ArgumentPack
650 = new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()];
651 std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(),
654 = DeducedTemplateArgument(TemplateArgument(ArgumentPack,
655 NewlyDeducedPacks[I].size()),
656 NewlyDeducedPacks[I][0].wasDeducedFromArrayBound());
659 DeducedTemplateArgument Result
660 = checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack);
661 if (Result.isNull()) {
663 = makeTemplateParameter(TemplateParams->getParam(PackIndices[I]));
664 Info.FirstArg = SavedPacks[I];
665 Info.SecondArg = NewPack;
666 return Sema::TDK_Inconsistent;
669 Deduced[PackIndices[I]] = Result;
672 return Sema::TDK_Success;
675 /// \brief Deduce the template arguments by comparing the list of parameter
676 /// types to the list of argument types, as in the parameter-type-lists of
677 /// function types (C++ [temp.deduct.type]p10).
679 /// \param S The semantic analysis object within which we are deducing
681 /// \param TemplateParams The template parameters that we are deducing
683 /// \param Params The list of parameter types
685 /// \param NumParams The number of types in \c Params
687 /// \param Args The list of argument types
689 /// \param NumArgs The number of types in \c Args
691 /// \param Info information about the template argument deduction itself
693 /// \param Deduced the deduced template arguments
695 /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
696 /// how template argument deduction is performed.
698 /// \param PartialOrdering If true, we are performing template argument
699 /// deduction for during partial ordering for a call
700 /// (C++0x [temp.deduct.partial]).
702 /// \param RefParamComparisons If we're performing template argument deduction
703 /// in the context of partial ordering, the set of qualifier comparisons.
705 /// \returns the result of template argument deduction so far. Note that a
706 /// "success" result means that template argument deduction has not yet failed,
707 /// but it may still fail, later, for other reasons.
708 static Sema::TemplateDeductionResult
709 DeduceTemplateArguments(Sema &S,
710 TemplateParameterList *TemplateParams,
711 const QualType *Params, unsigned NumParams,
712 const QualType *Args, unsigned NumArgs,
713 TemplateDeductionInfo &Info,
714 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
716 bool PartialOrdering = false,
717 SmallVectorImpl<RefParamPartialOrderingComparison> *
718 RefParamComparisons = 0) {
719 // Fast-path check to see if we have too many/too few arguments.
720 if (NumParams != NumArgs &&
721 !(NumParams && isa<PackExpansionType>(Params[NumParams - 1])) &&
722 !(NumArgs && isa<PackExpansionType>(Args[NumArgs - 1])))
723 return Sema::TDK_MiscellaneousDeductionFailure;
725 // C++0x [temp.deduct.type]p10:
726 // Similarly, if P has a form that contains (T), then each parameter type
727 // Pi of the respective parameter-type- list of P is compared with the
728 // corresponding parameter type Ai of the corresponding parameter-type-list
730 unsigned ArgIdx = 0, ParamIdx = 0;
731 for (; ParamIdx != NumParams; ++ParamIdx) {
732 // Check argument types.
733 const PackExpansionType *Expansion
734 = dyn_cast<PackExpansionType>(Params[ParamIdx]);
736 // Simple case: compare the parameter and argument types at this point.
738 // Make sure we have an argument.
739 if (ArgIdx >= NumArgs)
740 return Sema::TDK_MiscellaneousDeductionFailure;
742 if (isa<PackExpansionType>(Args[ArgIdx])) {
743 // C++0x [temp.deduct.type]p22:
744 // If the original function parameter associated with A is a function
745 // parameter pack and the function parameter associated with P is not
746 // a function parameter pack, then template argument deduction fails.
747 return Sema::TDK_MiscellaneousDeductionFailure;
750 if (Sema::TemplateDeductionResult Result
751 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
752 Params[ParamIdx], Args[ArgIdx],
755 RefParamComparisons))
762 // C++0x [temp.deduct.type]p5:
763 // The non-deduced contexts are:
764 // - A function parameter pack that does not occur at the end of the
765 // parameter-declaration-clause.
766 if (ParamIdx + 1 < NumParams)
767 return Sema::TDK_Success;
769 // C++0x [temp.deduct.type]p10:
770 // If the parameter-declaration corresponding to Pi is a function
771 // parameter pack, then the type of its declarator- id is compared with
772 // each remaining parameter type in the parameter-type-list of A. Each
773 // comparison deduces template arguments for subsequent positions in the
774 // template parameter packs expanded by the function parameter pack.
776 // Compute the set of template parameter indices that correspond to
777 // parameter packs expanded by the pack expansion.
778 SmallVector<unsigned, 2> PackIndices;
779 QualType Pattern = Expansion->getPattern();
781 llvm::SmallBitVector SawIndices(TemplateParams->size());
782 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
783 S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
784 for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
785 unsigned Depth, Index;
786 llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
787 if (Depth == 0 && !SawIndices[Index]) {
788 SawIndices[Index] = true;
789 PackIndices.push_back(Index);
793 assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
795 // Keep track of the deduced template arguments for each parameter pack
796 // expanded by this pack expansion (the outer index) and for each
797 // template argument (the inner SmallVectors).
798 NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size());
799 SmallVector<DeducedTemplateArgument, 2>
800 SavedPacks(PackIndices.size());
801 PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
804 bool HasAnyArguments = false;
805 for (; ArgIdx < NumArgs; ++ArgIdx) {
806 HasAnyArguments = true;
808 // Deduce template arguments from the pattern.
809 if (Sema::TemplateDeductionResult Result
810 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern,
811 Args[ArgIdx], Info, Deduced,
812 TDF, PartialOrdering,
813 RefParamComparisons))
816 // Capture the deduced template arguments for each parameter pack expanded
817 // by this pack expansion, add them to the list of arguments we've deduced
818 // for that pack, then clear out the deduced argument.
819 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
820 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
821 if (!DeducedArg.isNull()) {
822 NewlyDeducedPacks[I].push_back(DeducedArg);
823 DeducedArg = DeducedTemplateArgument();
828 // Build argument packs for each of the parameter packs expanded by this
830 if (Sema::TemplateDeductionResult Result
831 = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments,
832 Deduced, PackIndices, SavedPacks,
833 NewlyDeducedPacks, Info))
837 // Make sure we don't have any extra arguments.
838 if (ArgIdx < NumArgs)
839 return Sema::TDK_MiscellaneousDeductionFailure;
841 return Sema::TDK_Success;
844 /// \brief Determine whether the parameter has qualifiers that are either
845 /// inconsistent with or a superset of the argument's qualifiers.
846 static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType,
848 Qualifiers ParamQs = ParamType.getQualifiers();
849 Qualifiers ArgQs = ArgType.getQualifiers();
851 if (ParamQs == ArgQs)
854 // Mismatched (but not missing) Objective-C GC attributes.
855 if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() &&
856 ParamQs.hasObjCGCAttr())
859 // Mismatched (but not missing) address spaces.
860 if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() &&
861 ParamQs.hasAddressSpace())
864 // Mismatched (but not missing) Objective-C lifetime qualifiers.
865 if (ParamQs.getObjCLifetime() != ArgQs.getObjCLifetime() &&
866 ParamQs.hasObjCLifetime())
869 // CVR qualifier superset.
870 return (ParamQs.getCVRQualifiers() != ArgQs.getCVRQualifiers()) &&
871 ((ParamQs.getCVRQualifiers() | ArgQs.getCVRQualifiers())
872 == ParamQs.getCVRQualifiers());
875 /// \brief Compare types for equality with respect to possibly compatible
876 /// function types (noreturn adjustment, implicit calling conventions). If any
877 /// of parameter and argument is not a function, just perform type comparison.
879 /// \param Param the template parameter type.
881 /// \param Arg the argument type.
882 bool Sema::isSameOrCompatibleFunctionType(CanQualType Param,
884 const FunctionType *ParamFunction = Param->getAs<FunctionType>(),
885 *ArgFunction = Arg->getAs<FunctionType>();
887 // Just compare if not functions.
888 if (!ParamFunction || !ArgFunction)
891 // Noreturn adjustment.
892 QualType AdjustedParam;
893 if (IsNoReturnConversion(Param, Arg, AdjustedParam))
894 return Arg == Context.getCanonicalType(AdjustedParam);
896 // FIXME: Compatible calling conventions.
901 /// \brief Deduce the template arguments by comparing the parameter type and
902 /// the argument type (C++ [temp.deduct.type]).
904 /// \param S the semantic analysis object within which we are deducing
906 /// \param TemplateParams the template parameters that we are deducing
908 /// \param ParamIn the parameter type
910 /// \param ArgIn the argument type
912 /// \param Info information about the template argument deduction itself
914 /// \param Deduced the deduced template arguments
916 /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
917 /// how template argument deduction is performed.
919 /// \param PartialOrdering Whether we're performing template argument deduction
920 /// in the context of partial ordering (C++0x [temp.deduct.partial]).
922 /// \param RefParamComparisons If we're performing template argument deduction
923 /// in the context of partial ordering, the set of qualifier comparisons.
925 /// \returns the result of template argument deduction so far. Note that a
926 /// "success" result means that template argument deduction has not yet failed,
927 /// but it may still fail, later, for other reasons.
928 static Sema::TemplateDeductionResult
929 DeduceTemplateArgumentsByTypeMatch(Sema &S,
930 TemplateParameterList *TemplateParams,
931 QualType ParamIn, QualType ArgIn,
932 TemplateDeductionInfo &Info,
933 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
935 bool PartialOrdering,
936 SmallVectorImpl<RefParamPartialOrderingComparison> *
937 RefParamComparisons) {
938 // We only want to look at the canonical types, since typedefs and
939 // sugar are not part of template argument deduction.
940 QualType Param = S.Context.getCanonicalType(ParamIn);
941 QualType Arg = S.Context.getCanonicalType(ArgIn);
943 // If the argument type is a pack expansion, look at its pattern.
944 // This isn't explicitly called out
945 if (const PackExpansionType *ArgExpansion
946 = dyn_cast<PackExpansionType>(Arg))
947 Arg = ArgExpansion->getPattern();
949 if (PartialOrdering) {
950 // C++0x [temp.deduct.partial]p5:
951 // Before the partial ordering is done, certain transformations are
952 // performed on the types used for partial ordering:
953 // - If P is a reference type, P is replaced by the type referred to.
954 const ReferenceType *ParamRef = Param->getAs<ReferenceType>();
956 Param = ParamRef->getPointeeType();
958 // - If A is a reference type, A is replaced by the type referred to.
959 const ReferenceType *ArgRef = Arg->getAs<ReferenceType>();
961 Arg = ArgRef->getPointeeType();
963 if (RefParamComparisons && ParamRef && ArgRef) {
964 // C++0x [temp.deduct.partial]p6:
965 // If both P and A were reference types (before being replaced with the
966 // type referred to above), determine which of the two types (if any) is
967 // more cv-qualified than the other; otherwise the types are considered
968 // to be equally cv-qualified for partial ordering purposes. The result
969 // of this determination will be used below.
971 // We save this information for later, using it only when deduction
972 // succeeds in both directions.
973 RefParamPartialOrderingComparison Comparison;
974 Comparison.ParamIsRvalueRef = ParamRef->getAs<RValueReferenceType>();
975 Comparison.ArgIsRvalueRef = ArgRef->getAs<RValueReferenceType>();
976 Comparison.Qualifiers = NeitherMoreQualified;
978 Qualifiers ParamQuals = Param.getQualifiers();
979 Qualifiers ArgQuals = Arg.getQualifiers();
980 if (ParamQuals.isStrictSupersetOf(ArgQuals))
981 Comparison.Qualifiers = ParamMoreQualified;
982 else if (ArgQuals.isStrictSupersetOf(ParamQuals))
983 Comparison.Qualifiers = ArgMoreQualified;
984 RefParamComparisons->push_back(Comparison);
987 // C++0x [temp.deduct.partial]p7:
988 // Remove any top-level cv-qualifiers:
989 // - If P is a cv-qualified type, P is replaced by the cv-unqualified
991 Param = Param.getUnqualifiedType();
992 // - If A is a cv-qualified type, A is replaced by the cv-unqualified
994 Arg = Arg.getUnqualifiedType();
996 // C++0x [temp.deduct.call]p4 bullet 1:
997 // - If the original P is a reference type, the deduced A (i.e., the type
998 // referred to by the reference) can be more cv-qualified than the
1000 if (TDF & TDF_ParamWithReferenceType) {
1002 QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals);
1003 Quals.setCVRQualifiers(Quals.getCVRQualifiers() &
1004 Arg.getCVRQualifiers());
1005 Param = S.Context.getQualifiedType(UnqualParam, Quals);
1008 if ((TDF & TDF_TopLevelParameterTypeList) && !Param->isFunctionType()) {
1009 // C++0x [temp.deduct.type]p10:
1010 // If P and A are function types that originated from deduction when
1011 // taking the address of a function template (14.8.2.2) or when deducing
1012 // template arguments from a function declaration (14.8.2.6) and Pi and
1013 // Ai are parameters of the top-level parameter-type-list of P and A,
1014 // respectively, Pi is adjusted if it is an rvalue reference to a
1015 // cv-unqualified template parameter and Ai is an lvalue reference, in
1016 // which case the type of Pi is changed to be the template parameter
1017 // type (i.e., T&& is changed to simply T). [ Note: As a result, when
1018 // Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be
1019 // deduced as X&. - end note ]
1020 TDF &= ~TDF_TopLevelParameterTypeList;
1022 if (const RValueReferenceType *ParamRef
1023 = Param->getAs<RValueReferenceType>()) {
1024 if (isa<TemplateTypeParmType>(ParamRef->getPointeeType()) &&
1025 !ParamRef->getPointeeType().getQualifiers())
1026 if (Arg->isLValueReferenceType())
1027 Param = ParamRef->getPointeeType();
1032 // C++ [temp.deduct.type]p9:
1033 // A template type argument T, a template template argument TT or a
1034 // template non-type argument i can be deduced if P and A have one of
1035 // the following forms:
1039 if (const TemplateTypeParmType *TemplateTypeParm
1040 = Param->getAs<TemplateTypeParmType>()) {
1041 // Just skip any attempts to deduce from a placeholder type.
1042 if (Arg->isPlaceholderType())
1043 return Sema::TDK_Success;
1045 unsigned Index = TemplateTypeParm->getIndex();
1046 bool RecanonicalizeArg = false;
1048 // If the argument type is an array type, move the qualifiers up to the
1049 // top level, so they can be matched with the qualifiers on the parameter.
1050 if (isa<ArrayType>(Arg)) {
1052 Arg = S.Context.getUnqualifiedArrayType(Arg, Quals);
1054 Arg = S.Context.getQualifiedType(Arg, Quals);
1055 RecanonicalizeArg = true;
1059 // The argument type can not be less qualified than the parameter
1061 if (!(TDF & TDF_IgnoreQualifiers) &&
1062 hasInconsistentOrSupersetQualifiersOf(Param, Arg)) {
1063 Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
1064 Info.FirstArg = TemplateArgument(Param);
1065 Info.SecondArg = TemplateArgument(Arg);
1066 return Sema::TDK_Underqualified;
1069 assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0");
1070 assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function");
1071 QualType DeducedType = Arg;
1073 // Remove any qualifiers on the parameter from the deduced type.
1074 // We checked the qualifiers for consistency above.
1075 Qualifiers DeducedQs = DeducedType.getQualifiers();
1076 Qualifiers ParamQs = Param.getQualifiers();
1077 DeducedQs.removeCVRQualifiers(ParamQs.getCVRQualifiers());
1078 if (ParamQs.hasObjCGCAttr())
1079 DeducedQs.removeObjCGCAttr();
1080 if (ParamQs.hasAddressSpace())
1081 DeducedQs.removeAddressSpace();
1082 if (ParamQs.hasObjCLifetime())
1083 DeducedQs.removeObjCLifetime();
1086 // If template deduction would produce a lifetime qualifier on a type
1087 // that is not a lifetime type, template argument deduction fails.
1088 if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() &&
1089 !DeducedType->isDependentType()) {
1090 Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
1091 Info.FirstArg = TemplateArgument(Param);
1092 Info.SecondArg = TemplateArgument(Arg);
1093 return Sema::TDK_Underqualified;
1097 // If template deduction would produce an argument type with lifetime type
1098 // but no lifetime qualifier, the __strong lifetime qualifier is inferred.
1099 if (S.getLangOpts().ObjCAutoRefCount &&
1100 DeducedType->isObjCLifetimeType() &&
1101 !DeducedQs.hasObjCLifetime())
1102 DeducedQs.setObjCLifetime(Qualifiers::OCL_Strong);
1104 DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(),
1107 if (RecanonicalizeArg)
1108 DeducedType = S.Context.getCanonicalType(DeducedType);
1110 DeducedTemplateArgument NewDeduced(DeducedType);
1111 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
1114 if (Result.isNull()) {
1115 Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
1116 Info.FirstArg = Deduced[Index];
1117 Info.SecondArg = NewDeduced;
1118 return Sema::TDK_Inconsistent;
1121 Deduced[Index] = Result;
1122 return Sema::TDK_Success;
1125 // Set up the template argument deduction information for a failure.
1126 Info.FirstArg = TemplateArgument(ParamIn);
1127 Info.SecondArg = TemplateArgument(ArgIn);
1129 // If the parameter is an already-substituted template parameter
1130 // pack, do nothing: we don't know which of its arguments to look
1131 // at, so we have to wait until all of the parameter packs in this
1132 // expansion have arguments.
1133 if (isa<SubstTemplateTypeParmPackType>(Param))
1134 return Sema::TDK_Success;
1136 // Check the cv-qualifiers on the parameter and argument types.
1137 CanQualType CanParam = S.Context.getCanonicalType(Param);
1138 CanQualType CanArg = S.Context.getCanonicalType(Arg);
1139 if (!(TDF & TDF_IgnoreQualifiers)) {
1140 if (TDF & TDF_ParamWithReferenceType) {
1141 if (hasInconsistentOrSupersetQualifiersOf(Param, Arg))
1142 return Sema::TDK_NonDeducedMismatch;
1143 } else if (!IsPossiblyOpaquelyQualifiedType(Param)) {
1144 if (Param.getCVRQualifiers() != Arg.getCVRQualifiers())
1145 return Sema::TDK_NonDeducedMismatch;
1148 // If the parameter type is not dependent, there is nothing to deduce.
1149 if (!Param->isDependentType()) {
1150 if (!(TDF & TDF_SkipNonDependent)) {
1151 bool NonDeduced = (TDF & TDF_InOverloadResolution)?
1152 !S.isSameOrCompatibleFunctionType(CanParam, CanArg) :
1155 return Sema::TDK_NonDeducedMismatch;
1158 return Sema::TDK_Success;
1160 } else if (!Param->isDependentType()) {
1161 CanQualType ParamUnqualType = CanParam.getUnqualifiedType(),
1162 ArgUnqualType = CanArg.getUnqualifiedType();
1163 bool Success = (TDF & TDF_InOverloadResolution)?
1164 S.isSameOrCompatibleFunctionType(ParamUnqualType,
1166 ParamUnqualType == ArgUnqualType;
1168 return Sema::TDK_Success;
1171 switch (Param->getTypeClass()) {
1172 // Non-canonical types cannot appear here.
1173 #define NON_CANONICAL_TYPE(Class, Base) \
1174 case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class);
1175 #define TYPE(Class, Base)
1176 #include "clang/AST/TypeNodes.def"
1178 case Type::TemplateTypeParm:
1179 case Type::SubstTemplateTypeParmPack:
1180 llvm_unreachable("Type nodes handled above");
1182 // These types cannot be dependent, so simply check whether the types are
1185 case Type::VariableArray:
1187 case Type::FunctionNoProto:
1190 case Type::ObjCObject:
1191 case Type::ObjCInterface:
1192 case Type::ObjCObjectPointer: {
1193 if (TDF & TDF_SkipNonDependent)
1194 return Sema::TDK_Success;
1196 if (TDF & TDF_IgnoreQualifiers) {
1197 Param = Param.getUnqualifiedType();
1198 Arg = Arg.getUnqualifiedType();
1201 return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch;
1204 // _Complex T [placeholder extension]
1206 if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>())
1207 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1208 cast<ComplexType>(Param)->getElementType(),
1209 ComplexArg->getElementType(),
1210 Info, Deduced, TDF);
1212 return Sema::TDK_NonDeducedMismatch;
1214 // _Atomic T [extension]
1216 if (const AtomicType *AtomicArg = Arg->getAs<AtomicType>())
1217 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1218 cast<AtomicType>(Param)->getValueType(),
1219 AtomicArg->getValueType(),
1220 Info, Deduced, TDF);
1222 return Sema::TDK_NonDeducedMismatch;
1225 case Type::Pointer: {
1226 QualType PointeeType;
1227 if (const PointerType *PointerArg = Arg->getAs<PointerType>()) {
1228 PointeeType = PointerArg->getPointeeType();
1229 } else if (const ObjCObjectPointerType *PointerArg
1230 = Arg->getAs<ObjCObjectPointerType>()) {
1231 PointeeType = PointerArg->getPointeeType();
1233 return Sema::TDK_NonDeducedMismatch;
1236 unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass);
1237 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1238 cast<PointerType>(Param)->getPointeeType(),
1240 Info, Deduced, SubTDF);
1244 case Type::LValueReference: {
1245 const LValueReferenceType *ReferenceArg = Arg->getAs<LValueReferenceType>();
1247 return Sema::TDK_NonDeducedMismatch;
1249 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1250 cast<LValueReferenceType>(Param)->getPointeeType(),
1251 ReferenceArg->getPointeeType(), Info, Deduced, 0);
1255 case Type::RValueReference: {
1256 const RValueReferenceType *ReferenceArg = Arg->getAs<RValueReferenceType>();
1258 return Sema::TDK_NonDeducedMismatch;
1260 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1261 cast<RValueReferenceType>(Param)->getPointeeType(),
1262 ReferenceArg->getPointeeType(),
1266 // T [] (implied, but not stated explicitly)
1267 case Type::IncompleteArray: {
1268 const IncompleteArrayType *IncompleteArrayArg =
1269 S.Context.getAsIncompleteArrayType(Arg);
1270 if (!IncompleteArrayArg)
1271 return Sema::TDK_NonDeducedMismatch;
1273 unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
1274 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1275 S.Context.getAsIncompleteArrayType(Param)->getElementType(),
1276 IncompleteArrayArg->getElementType(),
1277 Info, Deduced, SubTDF);
1280 // T [integer-constant]
1281 case Type::ConstantArray: {
1282 const ConstantArrayType *ConstantArrayArg =
1283 S.Context.getAsConstantArrayType(Arg);
1284 if (!ConstantArrayArg)
1285 return Sema::TDK_NonDeducedMismatch;
1287 const ConstantArrayType *ConstantArrayParm =
1288 S.Context.getAsConstantArrayType(Param);
1289 if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize())
1290 return Sema::TDK_NonDeducedMismatch;
1292 unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
1293 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1294 ConstantArrayParm->getElementType(),
1295 ConstantArrayArg->getElementType(),
1296 Info, Deduced, SubTDF);
1300 case Type::DependentSizedArray: {
1301 const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg);
1303 return Sema::TDK_NonDeducedMismatch;
1305 unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
1307 // Check the element type of the arrays
1308 const DependentSizedArrayType *DependentArrayParm
1309 = S.Context.getAsDependentSizedArrayType(Param);
1310 if (Sema::TemplateDeductionResult Result
1311 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1312 DependentArrayParm->getElementType(),
1313 ArrayArg->getElementType(),
1314 Info, Deduced, SubTDF))
1317 // Determine the array bound is something we can deduce.
1318 NonTypeTemplateParmDecl *NTTP
1319 = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr());
1321 return Sema::TDK_Success;
1323 // We can perform template argument deduction for the given non-type
1324 // template parameter.
1325 assert(NTTP->getDepth() == 0 &&
1326 "Cannot deduce non-type template argument at depth > 0");
1327 if (const ConstantArrayType *ConstantArrayArg
1328 = dyn_cast<ConstantArrayType>(ArrayArg)) {
1329 llvm::APSInt Size(ConstantArrayArg->getSize());
1330 return DeduceNonTypeTemplateArgument(S, NTTP, Size,
1331 S.Context.getSizeType(),
1332 /*ArrayBound=*/true,
1335 if (const DependentSizedArrayType *DependentArrayArg
1336 = dyn_cast<DependentSizedArrayType>(ArrayArg))
1337 if (DependentArrayArg->getSizeExpr())
1338 return DeduceNonTypeTemplateArgument(S, NTTP,
1339 DependentArrayArg->getSizeExpr(),
1342 // Incomplete type does not match a dependently-sized array type
1343 return Sema::TDK_NonDeducedMismatch;
1349 case Type::FunctionProto: {
1350 unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList;
1351 const FunctionProtoType *FunctionProtoArg =
1352 dyn_cast<FunctionProtoType>(Arg);
1353 if (!FunctionProtoArg)
1354 return Sema::TDK_NonDeducedMismatch;
1356 const FunctionProtoType *FunctionProtoParam =
1357 cast<FunctionProtoType>(Param);
1359 if (FunctionProtoParam->getTypeQuals()
1360 != FunctionProtoArg->getTypeQuals() ||
1361 FunctionProtoParam->getRefQualifier()
1362 != FunctionProtoArg->getRefQualifier() ||
1363 FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic())
1364 return Sema::TDK_NonDeducedMismatch;
1366 // Check return types.
1367 if (Sema::TemplateDeductionResult Result
1368 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1369 FunctionProtoParam->getResultType(),
1370 FunctionProtoArg->getResultType(),
1374 return DeduceTemplateArguments(S, TemplateParams,
1375 FunctionProtoParam->arg_type_begin(),
1376 FunctionProtoParam->getNumArgs(),
1377 FunctionProtoArg->arg_type_begin(),
1378 FunctionProtoArg->getNumArgs(),
1379 Info, Deduced, SubTDF);
1382 case Type::InjectedClassName: {
1383 // Treat a template's injected-class-name as if the template
1384 // specialization type had been used.
1385 Param = cast<InjectedClassNameType>(Param)
1386 ->getInjectedSpecializationType();
1387 assert(isa<TemplateSpecializationType>(Param) &&
1388 "injected class name is not a template specialization type");
1392 // template-name<T> (where template-name refers to a class template)
1397 case Type::TemplateSpecialization: {
1398 const TemplateSpecializationType *SpecParam
1399 = cast<TemplateSpecializationType>(Param);
1401 // Try to deduce template arguments from the template-id.
1402 Sema::TemplateDeductionResult Result
1403 = DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg,
1406 if (Result && (TDF & TDF_DerivedClass)) {
1407 // C++ [temp.deduct.call]p3b3:
1408 // If P is a class, and P has the form template-id, then A can be a
1409 // derived class of the deduced A. Likewise, if P is a pointer to a
1410 // class of the form template-id, A can be a pointer to a derived
1411 // class pointed to by the deduced A.
1413 // More importantly:
1414 // These alternatives are considered only if type deduction would
1416 if (const RecordType *RecordT = Arg->getAs<RecordType>()) {
1417 // We cannot inspect base classes as part of deduction when the type
1418 // is incomplete, so either instantiate any templates necessary to
1419 // complete the type, or skip over it if it cannot be completed.
1420 if (S.RequireCompleteType(Info.getLocation(), Arg, 0))
1423 // Use data recursion to crawl through the list of base classes.
1424 // Visited contains the set of nodes we have already visited, while
1425 // ToVisit is our stack of records that we still need to visit.
1426 llvm::SmallPtrSet<const RecordType *, 8> Visited;
1427 SmallVector<const RecordType *, 8> ToVisit;
1428 ToVisit.push_back(RecordT);
1429 bool Successful = false;
1430 SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(),
1432 while (!ToVisit.empty()) {
1433 // Retrieve the next class in the inheritance hierarchy.
1434 const RecordType *NextT = ToVisit.pop_back_val();
1436 // If we have already seen this type, skip it.
1437 if (!Visited.insert(NextT))
1440 // If this is a base class, try to perform template argument
1441 // deduction from it.
1442 if (NextT != RecordT) {
1443 TemplateDeductionInfo BaseInfo(Info.getLocation());
1444 Sema::TemplateDeductionResult BaseResult
1445 = DeduceTemplateArguments(S, TemplateParams, SpecParam,
1446 QualType(NextT, 0), BaseInfo,
1449 // If template argument deduction for this base was successful,
1450 // note that we had some success. Otherwise, ignore any deductions
1451 // from this base class.
1452 if (BaseResult == Sema::TDK_Success) {
1454 DeducedOrig.clear();
1455 DeducedOrig.append(Deduced.begin(), Deduced.end());
1456 Info.Param = BaseInfo.Param;
1457 Info.FirstArg = BaseInfo.FirstArg;
1458 Info.SecondArg = BaseInfo.SecondArg;
1461 Deduced = DeducedOrig;
1464 // Visit base classes
1465 CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl());
1466 for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(),
1467 BaseEnd = Next->bases_end();
1468 Base != BaseEnd; ++Base) {
1469 assert(Base->getType()->isRecordType() &&
1470 "Base class that isn't a record?");
1471 ToVisit.push_back(Base->getType()->getAs<RecordType>());
1476 return Sema::TDK_Success;
1488 // type (type::*)(T)
1493 case Type::MemberPointer: {
1494 const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param);
1495 const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg);
1497 return Sema::TDK_NonDeducedMismatch;
1499 if (Sema::TemplateDeductionResult Result
1500 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1501 MemPtrParam->getPointeeType(),
1502 MemPtrArg->getPointeeType(),
1504 TDF & TDF_IgnoreQualifiers))
1507 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1508 QualType(MemPtrParam->getClass(), 0),
1509 QualType(MemPtrArg->getClass(), 0),
1511 TDF & TDF_IgnoreQualifiers);
1514 // (clang extension)
1519 case Type::BlockPointer: {
1520 const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param);
1521 const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg);
1524 return Sema::TDK_NonDeducedMismatch;
1526 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1527 BlockPtrParam->getPointeeType(),
1528 BlockPtrArg->getPointeeType(),
1532 // (clang extension)
1534 // T __attribute__(((ext_vector_type(<integral constant>))))
1535 case Type::ExtVector: {
1536 const ExtVectorType *VectorParam = cast<ExtVectorType>(Param);
1537 if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
1538 // Make sure that the vectors have the same number of elements.
1539 if (VectorParam->getNumElements() != VectorArg->getNumElements())
1540 return Sema::TDK_NonDeducedMismatch;
1542 // Perform deduction on the element types.
1543 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1544 VectorParam->getElementType(),
1545 VectorArg->getElementType(),
1546 Info, Deduced, TDF);
1549 if (const DependentSizedExtVectorType *VectorArg
1550 = dyn_cast<DependentSizedExtVectorType>(Arg)) {
1551 // We can't check the number of elements, since the argument has a
1552 // dependent number of elements. This can only occur during partial
1555 // Perform deduction on the element types.
1556 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1557 VectorParam->getElementType(),
1558 VectorArg->getElementType(),
1559 Info, Deduced, TDF);
1562 return Sema::TDK_NonDeducedMismatch;
1565 // (clang extension)
1567 // T __attribute__(((ext_vector_type(N))))
1568 case Type::DependentSizedExtVector: {
1569 const DependentSizedExtVectorType *VectorParam
1570 = cast<DependentSizedExtVectorType>(Param);
1572 if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
1573 // Perform deduction on the element types.
1574 if (Sema::TemplateDeductionResult Result
1575 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1576 VectorParam->getElementType(),
1577 VectorArg->getElementType(),
1578 Info, Deduced, TDF))
1581 // Perform deduction on the vector size, if we can.
1582 NonTypeTemplateParmDecl *NTTP
1583 = getDeducedParameterFromExpr(VectorParam->getSizeExpr());
1585 return Sema::TDK_Success;
1587 llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false);
1588 ArgSize = VectorArg->getNumElements();
1589 return DeduceNonTypeTemplateArgument(S, NTTP, ArgSize, S.Context.IntTy,
1590 false, Info, Deduced);
1593 if (const DependentSizedExtVectorType *VectorArg
1594 = dyn_cast<DependentSizedExtVectorType>(Arg)) {
1595 // Perform deduction on the element types.
1596 if (Sema::TemplateDeductionResult Result
1597 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1598 VectorParam->getElementType(),
1599 VectorArg->getElementType(),
1600 Info, Deduced, TDF))
1603 // Perform deduction on the vector size, if we can.
1604 NonTypeTemplateParmDecl *NTTP
1605 = getDeducedParameterFromExpr(VectorParam->getSizeExpr());
1607 return Sema::TDK_Success;
1609 return DeduceNonTypeTemplateArgument(S, NTTP, VectorArg->getSizeExpr(),
1613 return Sema::TDK_NonDeducedMismatch;
1616 case Type::TypeOfExpr:
1618 case Type::DependentName:
1619 case Type::UnresolvedUsing:
1620 case Type::Decltype:
1621 case Type::UnaryTransform:
1623 case Type::DependentTemplateSpecialization:
1624 case Type::PackExpansion:
1625 // No template argument deduction for these types
1626 return Sema::TDK_Success;
1629 llvm_unreachable("Invalid Type Class!");
1632 static Sema::TemplateDeductionResult
1633 DeduceTemplateArguments(Sema &S,
1634 TemplateParameterList *TemplateParams,
1635 const TemplateArgument &Param,
1636 TemplateArgument Arg,
1637 TemplateDeductionInfo &Info,
1638 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
1639 // If the template argument is a pack expansion, perform template argument
1640 // deduction against the pattern of that expansion. This only occurs during
1641 // partial ordering.
1642 if (Arg.isPackExpansion())
1643 Arg = Arg.getPackExpansionPattern();
1645 switch (Param.getKind()) {
1646 case TemplateArgument::Null:
1647 llvm_unreachable("Null template argument in parameter list");
1649 case TemplateArgument::Type:
1650 if (Arg.getKind() == TemplateArgument::Type)
1651 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1655 Info.FirstArg = Param;
1656 Info.SecondArg = Arg;
1657 return Sema::TDK_NonDeducedMismatch;
1659 case TemplateArgument::Template:
1660 if (Arg.getKind() == TemplateArgument::Template)
1661 return DeduceTemplateArguments(S, TemplateParams,
1662 Param.getAsTemplate(),
1663 Arg.getAsTemplate(), Info, Deduced);
1664 Info.FirstArg = Param;
1665 Info.SecondArg = Arg;
1666 return Sema::TDK_NonDeducedMismatch;
1668 case TemplateArgument::TemplateExpansion:
1669 llvm_unreachable("caller should handle pack expansions");
1671 case TemplateArgument::Declaration:
1672 if (Arg.getKind() == TemplateArgument::Declaration &&
1673 isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl()) &&
1674 Param.isDeclForReferenceParam() == Arg.isDeclForReferenceParam())
1675 return Sema::TDK_Success;
1677 Info.FirstArg = Param;
1678 Info.SecondArg = Arg;
1679 return Sema::TDK_NonDeducedMismatch;
1681 case TemplateArgument::NullPtr:
1682 if (Arg.getKind() == TemplateArgument::NullPtr &&
1683 S.Context.hasSameType(Param.getNullPtrType(), Arg.getNullPtrType()))
1684 return Sema::TDK_Success;
1686 Info.FirstArg = Param;
1687 Info.SecondArg = Arg;
1688 return Sema::TDK_NonDeducedMismatch;
1690 case TemplateArgument::Integral:
1691 if (Arg.getKind() == TemplateArgument::Integral) {
1692 if (hasSameExtendedValue(Param.getAsIntegral(), Arg.getAsIntegral()))
1693 return Sema::TDK_Success;
1695 Info.FirstArg = Param;
1696 Info.SecondArg = Arg;
1697 return Sema::TDK_NonDeducedMismatch;
1700 if (Arg.getKind() == TemplateArgument::Expression) {
1701 Info.FirstArg = Param;
1702 Info.SecondArg = Arg;
1703 return Sema::TDK_NonDeducedMismatch;
1706 Info.FirstArg = Param;
1707 Info.SecondArg = Arg;
1708 return Sema::TDK_NonDeducedMismatch;
1710 case TemplateArgument::Expression: {
1711 if (NonTypeTemplateParmDecl *NTTP
1712 = getDeducedParameterFromExpr(Param.getAsExpr())) {
1713 if (Arg.getKind() == TemplateArgument::Integral)
1714 return DeduceNonTypeTemplateArgument(S, NTTP,
1715 Arg.getAsIntegral(),
1716 Arg.getIntegralType(),
1717 /*ArrayBound=*/false,
1719 if (Arg.getKind() == TemplateArgument::Expression)
1720 return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(),
1722 if (Arg.getKind() == TemplateArgument::Declaration)
1723 return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(),
1726 Info.FirstArg = Param;
1727 Info.SecondArg = Arg;
1728 return Sema::TDK_NonDeducedMismatch;
1731 // Can't deduce anything, but that's okay.
1732 return Sema::TDK_Success;
1734 case TemplateArgument::Pack:
1735 llvm_unreachable("Argument packs should be expanded by the caller!");
1738 llvm_unreachable("Invalid TemplateArgument Kind!");
1741 /// \brief Determine whether there is a template argument to be used for
1744 /// This routine "expands" argument packs in-place, overriding its input
1745 /// parameters so that \c Args[ArgIdx] will be the available template argument.
1747 /// \returns true if there is another template argument (which will be at
1748 /// \c Args[ArgIdx]), false otherwise.
1749 static bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args,
1751 unsigned &NumArgs) {
1752 if (ArgIdx == NumArgs)
1755 const TemplateArgument &Arg = Args[ArgIdx];
1756 if (Arg.getKind() != TemplateArgument::Pack)
1759 assert(ArgIdx == NumArgs - 1 && "Pack not at the end of argument list?");
1760 Args = Arg.pack_begin();
1761 NumArgs = Arg.pack_size();
1763 return ArgIdx < NumArgs;
1766 /// \brief Determine whether the given set of template arguments has a pack
1767 /// expansion that is not the last template argument.
1768 static bool hasPackExpansionBeforeEnd(const TemplateArgument *Args,
1770 unsigned ArgIdx = 0;
1771 while (ArgIdx < NumArgs) {
1772 const TemplateArgument &Arg = Args[ArgIdx];
1774 // Unwrap argument packs.
1775 if (Args[ArgIdx].getKind() == TemplateArgument::Pack) {
1776 Args = Arg.pack_begin();
1777 NumArgs = Arg.pack_size();
1783 if (ArgIdx == NumArgs)
1786 if (Arg.isPackExpansion())
1793 static Sema::TemplateDeductionResult
1794 DeduceTemplateArguments(Sema &S,
1795 TemplateParameterList *TemplateParams,
1796 const TemplateArgument *Params, unsigned NumParams,
1797 const TemplateArgument *Args, unsigned NumArgs,
1798 TemplateDeductionInfo &Info,
1799 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
1800 // C++0x [temp.deduct.type]p9:
1801 // If the template argument list of P contains a pack expansion that is not
1802 // the last template argument, the entire template argument list is a
1803 // non-deduced context.
1804 if (hasPackExpansionBeforeEnd(Params, NumParams))
1805 return Sema::TDK_Success;
1807 // C++0x [temp.deduct.type]p9:
1808 // If P has a form that contains <T> or <i>, then each argument Pi of the
1809 // respective template argument list P is compared with the corresponding
1810 // argument Ai of the corresponding template argument list of A.
1811 unsigned ArgIdx = 0, ParamIdx = 0;
1812 for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams);
1814 if (!Params[ParamIdx].isPackExpansion()) {
1815 // The simple case: deduce template arguments by matching Pi and Ai.
1817 // Check whether we have enough arguments.
1818 if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs))
1819 return Sema::TDK_Success;
1821 if (Args[ArgIdx].isPackExpansion()) {
1822 // FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here,
1823 // but applied to pack expansions that are template arguments.
1824 return Sema::TDK_MiscellaneousDeductionFailure;
1827 // Perform deduction for this Pi/Ai pair.
1828 if (Sema::TemplateDeductionResult Result
1829 = DeduceTemplateArguments(S, TemplateParams,
1830 Params[ParamIdx], Args[ArgIdx],
1834 // Move to the next argument.
1839 // The parameter is a pack expansion.
1841 // C++0x [temp.deduct.type]p9:
1842 // If Pi is a pack expansion, then the pattern of Pi is compared with
1843 // each remaining argument in the template argument list of A. Each
1844 // comparison deduces template arguments for subsequent positions in the
1845 // template parameter packs expanded by Pi.
1846 TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern();
1848 // Compute the set of template parameter indices that correspond to
1849 // parameter packs expanded by the pack expansion.
1850 SmallVector<unsigned, 2> PackIndices;
1852 llvm::SmallBitVector SawIndices(TemplateParams->size());
1853 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
1854 S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
1855 for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
1856 unsigned Depth, Index;
1857 llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
1858 if (Depth == 0 && !SawIndices[Index]) {
1859 SawIndices[Index] = true;
1860 PackIndices.push_back(Index);
1864 assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
1866 // FIXME: If there are no remaining arguments, we can bail out early
1867 // and set any deduced parameter packs to an empty argument pack.
1868 // The latter part of this is a (minor) correctness issue.
1870 // Save the deduced template arguments for each parameter pack expanded
1871 // by this pack expansion, then clear out the deduction.
1872 SmallVector<DeducedTemplateArgument, 2>
1873 SavedPacks(PackIndices.size());
1874 NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size());
1875 PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
1878 // Keep track of the deduced template arguments for each parameter pack
1879 // expanded by this pack expansion (the outer index) and for each
1880 // template argument (the inner SmallVectors).
1881 bool HasAnyArguments = false;
1882 while (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) {
1883 HasAnyArguments = true;
1885 // Deduce template arguments from the pattern.
1886 if (Sema::TemplateDeductionResult Result
1887 = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx],
1891 // Capture the deduced template arguments for each parameter pack expanded
1892 // by this pack expansion, add them to the list of arguments we've deduced
1893 // for that pack, then clear out the deduced argument.
1894 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
1895 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
1896 if (!DeducedArg.isNull()) {
1897 NewlyDeducedPacks[I].push_back(DeducedArg);
1898 DeducedArg = DeducedTemplateArgument();
1905 // Build argument packs for each of the parameter packs expanded by this
1907 if (Sema::TemplateDeductionResult Result
1908 = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments,
1909 Deduced, PackIndices, SavedPacks,
1910 NewlyDeducedPacks, Info))
1914 return Sema::TDK_Success;
1917 static Sema::TemplateDeductionResult
1918 DeduceTemplateArguments(Sema &S,
1919 TemplateParameterList *TemplateParams,
1920 const TemplateArgumentList &ParamList,
1921 const TemplateArgumentList &ArgList,
1922 TemplateDeductionInfo &Info,
1923 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
1924 return DeduceTemplateArguments(S, TemplateParams,
1925 ParamList.data(), ParamList.size(),
1926 ArgList.data(), ArgList.size(),
1930 /// \brief Determine whether two template arguments are the same.
1931 static bool isSameTemplateArg(ASTContext &Context,
1932 const TemplateArgument &X,
1933 const TemplateArgument &Y) {
1934 if (X.getKind() != Y.getKind())
1937 switch (X.getKind()) {
1938 case TemplateArgument::Null:
1939 llvm_unreachable("Comparing NULL template argument");
1941 case TemplateArgument::Type:
1942 return Context.getCanonicalType(X.getAsType()) ==
1943 Context.getCanonicalType(Y.getAsType());
1945 case TemplateArgument::Declaration:
1946 return isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) &&
1947 X.isDeclForReferenceParam() == Y.isDeclForReferenceParam();
1949 case TemplateArgument::NullPtr:
1950 return Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType());
1952 case TemplateArgument::Template:
1953 case TemplateArgument::TemplateExpansion:
1954 return Context.getCanonicalTemplateName(
1955 X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() ==
1956 Context.getCanonicalTemplateName(
1957 Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer();
1959 case TemplateArgument::Integral:
1960 return X.getAsIntegral() == Y.getAsIntegral();
1962 case TemplateArgument::Expression: {
1963 llvm::FoldingSetNodeID XID, YID;
1964 X.getAsExpr()->Profile(XID, Context, true);
1965 Y.getAsExpr()->Profile(YID, Context, true);
1969 case TemplateArgument::Pack:
1970 if (X.pack_size() != Y.pack_size())
1973 for (TemplateArgument::pack_iterator XP = X.pack_begin(),
1974 XPEnd = X.pack_end(),
1975 YP = Y.pack_begin();
1976 XP != XPEnd; ++XP, ++YP)
1977 if (!isSameTemplateArg(Context, *XP, *YP))
1983 llvm_unreachable("Invalid TemplateArgument Kind!");
1986 /// \brief Allocate a TemplateArgumentLoc where all locations have
1987 /// been initialized to the given location.
1989 /// \param S The semantic analysis object.
1991 /// \param Arg The template argument we are producing template argument
1992 /// location information for.
1994 /// \param NTTPType For a declaration template argument, the type of
1995 /// the non-type template parameter that corresponds to this template
1998 /// \param Loc The source location to use for the resulting template
2000 static TemplateArgumentLoc
2001 getTrivialTemplateArgumentLoc(Sema &S,
2002 const TemplateArgument &Arg,
2004 SourceLocation Loc) {
2005 switch (Arg.getKind()) {
2006 case TemplateArgument::Null:
2007 llvm_unreachable("Can't get a NULL template argument here");
2009 case TemplateArgument::Type:
2010 return TemplateArgumentLoc(Arg,
2011 S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
2013 case TemplateArgument::Declaration: {
2015 = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
2017 return TemplateArgumentLoc(TemplateArgument(E), E);
2020 case TemplateArgument::NullPtr: {
2022 = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
2024 return TemplateArgumentLoc(TemplateArgument(NTTPType, /*isNullPtr*/true),
2028 case TemplateArgument::Integral: {
2030 = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs<Expr>();
2031 return TemplateArgumentLoc(TemplateArgument(E), E);
2034 case TemplateArgument::Template:
2035 case TemplateArgument::TemplateExpansion: {
2036 NestedNameSpecifierLocBuilder Builder;
2037 TemplateName Template = Arg.getAsTemplate();
2038 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
2039 Builder.MakeTrivial(S.Context, DTN->getQualifier(), Loc);
2040 else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
2041 Builder.MakeTrivial(S.Context, QTN->getQualifier(), Loc);
2043 if (Arg.getKind() == TemplateArgument::Template)
2044 return TemplateArgumentLoc(Arg,
2045 Builder.getWithLocInContext(S.Context),
2049 return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context),
2053 case TemplateArgument::Expression:
2054 return TemplateArgumentLoc(Arg, Arg.getAsExpr());
2056 case TemplateArgument::Pack:
2057 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
2060 llvm_unreachable("Invalid TemplateArgument Kind!");
2064 /// \brief Convert the given deduced template argument and add it to the set of
2065 /// fully-converted template arguments.
2067 ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param,
2068 DeducedTemplateArgument Arg,
2069 NamedDecl *Template,
2071 unsigned ArgumentPackIndex,
2072 TemplateDeductionInfo &Info,
2073 bool InFunctionTemplate,
2074 SmallVectorImpl<TemplateArgument> &Output) {
2075 if (Arg.getKind() == TemplateArgument::Pack) {
2076 // This is a template argument pack, so check each of its arguments against
2077 // the template parameter.
2078 SmallVector<TemplateArgument, 2> PackedArgsBuilder;
2079 for (TemplateArgument::pack_iterator PA = Arg.pack_begin(),
2080 PAEnd = Arg.pack_end();
2081 PA != PAEnd; ++PA) {
2082 // When converting the deduced template argument, append it to the
2083 // general output list. We need to do this so that the template argument
2084 // checking logic has all of the prior template arguments available.
2085 DeducedTemplateArgument InnerArg(*PA);
2086 InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound());
2087 if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template,
2088 NTTPType, PackedArgsBuilder.size(),
2089 Info, InFunctionTemplate, Output))
2092 // Move the converted template argument into our argument pack.
2093 PackedArgsBuilder.push_back(Output.pop_back_val());
2096 // Create the resulting argument pack.
2097 Output.push_back(TemplateArgument::CreatePackCopy(S.Context,
2098 PackedArgsBuilder.data(),
2099 PackedArgsBuilder.size()));
2103 // Convert the deduced template argument into a template
2104 // argument that we can check, almost as if the user had written
2105 // the template argument explicitly.
2106 TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType,
2107 Info.getLocation());
2109 // Check the template argument, converting it as necessary.
2110 return S.CheckTemplateArgument(Param, ArgLoc,
2112 Template->getLocation(),
2113 Template->getSourceRange().getEnd(),
2117 ? (Arg.wasDeducedFromArrayBound()
2118 ? Sema::CTAK_DeducedFromArrayBound
2119 : Sema::CTAK_Deduced)
2120 : Sema::CTAK_Specified);
2123 /// Complete template argument deduction for a class template partial
2125 static Sema::TemplateDeductionResult
2126 FinishTemplateArgumentDeduction(Sema &S,
2127 ClassTemplatePartialSpecializationDecl *Partial,
2128 const TemplateArgumentList &TemplateArgs,
2129 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2130 TemplateDeductionInfo &Info) {
2131 // Unevaluated SFINAE context.
2132 EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated);
2133 Sema::SFINAETrap Trap(S);
2135 Sema::ContextRAII SavedContext(S, Partial);
2137 // C++ [temp.deduct.type]p2:
2138 // [...] or if any template argument remains neither deduced nor
2139 // explicitly specified, template argument deduction fails.
2140 SmallVector<TemplateArgument, 4> Builder;
2141 TemplateParameterList *PartialParams = Partial->getTemplateParameters();
2142 for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) {
2143 NamedDecl *Param = PartialParams->getParam(I);
2144 if (Deduced[I].isNull()) {
2145 Info.Param = makeTemplateParameter(Param);
2146 return Sema::TDK_Incomplete;
2149 // We have deduced this argument, so it still needs to be
2150 // checked and converted.
2152 // First, for a non-type template parameter type that is
2153 // initialized by a declaration, we need the type of the
2154 // corresponding non-type template parameter.
2156 if (NonTypeTemplateParmDecl *NTTP
2157 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
2158 NTTPType = NTTP->getType();
2159 if (NTTPType->isDependentType()) {
2160 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
2161 Builder.data(), Builder.size());
2162 NTTPType = S.SubstType(NTTPType,
2163 MultiLevelTemplateArgumentList(TemplateArgs),
2164 NTTP->getLocation(),
2165 NTTP->getDeclName());
2166 if (NTTPType.isNull()) {
2167 Info.Param = makeTemplateParameter(Param);
2168 // FIXME: These template arguments are temporary. Free them!
2169 Info.reset(TemplateArgumentList::CreateCopy(S.Context,
2172 return Sema::TDK_SubstitutionFailure;
2177 if (ConvertDeducedTemplateArgument(S, Param, Deduced[I],
2178 Partial, NTTPType, 0, Info, false,
2180 Info.Param = makeTemplateParameter(Param);
2181 // FIXME: These template arguments are temporary. Free them!
2182 Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
2184 return Sema::TDK_SubstitutionFailure;
2188 // Form the template argument list from the deduced template arguments.
2189 TemplateArgumentList *DeducedArgumentList
2190 = TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
2193 Info.reset(DeducedArgumentList);
2195 // Substitute the deduced template arguments into the template
2196 // arguments of the class template partial specialization, and
2197 // verify that the instantiated template arguments are both valid
2198 // and are equivalent to the template arguments originally provided
2199 // to the class template.
2200 LocalInstantiationScope InstScope(S);
2201 ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate();
2202 const ASTTemplateArgumentListInfo *PartialTemplArgInfo
2203 = Partial->getTemplateArgsAsWritten();
2204 const TemplateArgumentLoc *PartialTemplateArgs
2205 = PartialTemplArgInfo->getTemplateArgs();
2207 TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc,
2208 PartialTemplArgInfo->RAngleLoc);
2210 if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs,
2211 InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) {
2212 unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx;
2213 if (ParamIdx >= Partial->getTemplateParameters()->size())
2214 ParamIdx = Partial->getTemplateParameters()->size() - 1;
2217 = const_cast<NamedDecl *>(
2218 Partial->getTemplateParameters()->getParam(ParamIdx));
2219 Info.Param = makeTemplateParameter(Param);
2220 Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument();
2221 return Sema::TDK_SubstitutionFailure;
2224 SmallVector<TemplateArgument, 4> ConvertedInstArgs;
2225 if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(),
2226 InstArgs, false, ConvertedInstArgs))
2227 return Sema::TDK_SubstitutionFailure;
2229 TemplateParameterList *TemplateParams
2230 = ClassTemplate->getTemplateParameters();
2231 for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
2232 TemplateArgument InstArg = ConvertedInstArgs.data()[I];
2233 if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) {
2234 Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
2235 Info.FirstArg = TemplateArgs[I];
2236 Info.SecondArg = InstArg;
2237 return Sema::TDK_NonDeducedMismatch;
2241 if (Trap.hasErrorOccurred())
2242 return Sema::TDK_SubstitutionFailure;
2244 return Sema::TDK_Success;
2247 /// \brief Perform template argument deduction to determine whether
2248 /// the given template arguments match the given class template
2249 /// partial specialization per C++ [temp.class.spec.match].
2250 Sema::TemplateDeductionResult
2251 Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
2252 const TemplateArgumentList &TemplateArgs,
2253 TemplateDeductionInfo &Info) {
2254 if (Partial->isInvalidDecl())
2257 // C++ [temp.class.spec.match]p2:
2258 // A partial specialization matches a given actual template
2259 // argument list if the template arguments of the partial
2260 // specialization can be deduced from the actual template argument
2263 // Unevaluated SFINAE context.
2264 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
2265 SFINAETrap Trap(*this);
2267 SmallVector<DeducedTemplateArgument, 4> Deduced;
2268 Deduced.resize(Partial->getTemplateParameters()->size());
2269 if (TemplateDeductionResult Result
2270 = ::DeduceTemplateArguments(*this,
2271 Partial->getTemplateParameters(),
2272 Partial->getTemplateArgs(),
2273 TemplateArgs, Info, Deduced))
2276 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
2277 InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial,
2279 if (Inst.isInvalid())
2280 return TDK_InstantiationDepth;
2282 if (Trap.hasErrorOccurred())
2283 return Sema::TDK_SubstitutionFailure;
2285 return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs,
2289 /// Complete template argument deduction for a variable template partial
2291 /// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
2292 /// May require unifying ClassTemplate(Partial)SpecializationDecl and
2293 /// VarTemplate(Partial)SpecializationDecl with a new data
2294 /// structure Template(Partial)SpecializationDecl, and
2295 /// using Template(Partial)SpecializationDecl as input type.
2296 static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction(
2297 Sema &S, VarTemplatePartialSpecializationDecl *Partial,
2298 const TemplateArgumentList &TemplateArgs,
2299 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2300 TemplateDeductionInfo &Info) {
2301 // Unevaluated SFINAE context.
2302 EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated);
2303 Sema::SFINAETrap Trap(S);
2305 // C++ [temp.deduct.type]p2:
2306 // [...] or if any template argument remains neither deduced nor
2307 // explicitly specified, template argument deduction fails.
2308 SmallVector<TemplateArgument, 4> Builder;
2309 TemplateParameterList *PartialParams = Partial->getTemplateParameters();
2310 for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) {
2311 NamedDecl *Param = PartialParams->getParam(I);
2312 if (Deduced[I].isNull()) {
2313 Info.Param = makeTemplateParameter(Param);
2314 return Sema::TDK_Incomplete;
2317 // We have deduced this argument, so it still needs to be
2318 // checked and converted.
2320 // First, for a non-type template parameter type that is
2321 // initialized by a declaration, we need the type of the
2322 // corresponding non-type template parameter.
2324 if (NonTypeTemplateParmDecl *NTTP =
2325 dyn_cast<NonTypeTemplateParmDecl>(Param)) {
2326 NTTPType = NTTP->getType();
2327 if (NTTPType->isDependentType()) {
2328 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
2329 Builder.data(), Builder.size());
2331 S.SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs),
2332 NTTP->getLocation(), NTTP->getDeclName());
2333 if (NTTPType.isNull()) {
2334 Info.Param = makeTemplateParameter(Param);
2335 // FIXME: These template arguments are temporary. Free them!
2336 Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
2338 return Sema::TDK_SubstitutionFailure;
2343 if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Partial, NTTPType,
2344 0, Info, false, Builder)) {
2345 Info.Param = makeTemplateParameter(Param);
2346 // FIXME: These template arguments are temporary. Free them!
2347 Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
2349 return Sema::TDK_SubstitutionFailure;
2353 // Form the template argument list from the deduced template arguments.
2354 TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy(
2355 S.Context, Builder.data(), Builder.size());
2357 Info.reset(DeducedArgumentList);
2359 // Substitute the deduced template arguments into the template
2360 // arguments of the class template partial specialization, and
2361 // verify that the instantiated template arguments are both valid
2362 // and are equivalent to the template arguments originally provided
2363 // to the class template.
2364 LocalInstantiationScope InstScope(S);
2365 VarTemplateDecl *VarTemplate = Partial->getSpecializedTemplate();
2366 const ASTTemplateArgumentListInfo *PartialTemplArgInfo
2367 = Partial->getTemplateArgsAsWritten();
2368 const TemplateArgumentLoc *PartialTemplateArgs
2369 = PartialTemplArgInfo->getTemplateArgs();
2371 TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc,
2372 PartialTemplArgInfo->RAngleLoc);
2374 if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs,
2375 InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) {
2376 unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx;
2377 if (ParamIdx >= Partial->getTemplateParameters()->size())
2378 ParamIdx = Partial->getTemplateParameters()->size() - 1;
2380 Decl *Param = const_cast<NamedDecl *>(
2381 Partial->getTemplateParameters()->getParam(ParamIdx));
2382 Info.Param = makeTemplateParameter(Param);
2383 Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument();
2384 return Sema::TDK_SubstitutionFailure;
2386 SmallVector<TemplateArgument, 4> ConvertedInstArgs;
2387 if (S.CheckTemplateArgumentList(VarTemplate, Partial->getLocation(), InstArgs,
2388 false, ConvertedInstArgs))
2389 return Sema::TDK_SubstitutionFailure;
2391 TemplateParameterList *TemplateParams = VarTemplate->getTemplateParameters();
2392 for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
2393 TemplateArgument InstArg = ConvertedInstArgs.data()[I];
2394 if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) {
2395 Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
2396 Info.FirstArg = TemplateArgs[I];
2397 Info.SecondArg = InstArg;
2398 return Sema::TDK_NonDeducedMismatch;
2402 if (Trap.hasErrorOccurred())
2403 return Sema::TDK_SubstitutionFailure;
2405 return Sema::TDK_Success;
2408 /// \brief Perform template argument deduction to determine whether
2409 /// the given template arguments match the given variable template
2410 /// partial specialization per C++ [temp.class.spec.match].
2411 /// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
2412 /// May require unifying ClassTemplate(Partial)SpecializationDecl and
2413 /// VarTemplate(Partial)SpecializationDecl with a new data
2414 /// structure Template(Partial)SpecializationDecl, and
2415 /// using Template(Partial)SpecializationDecl as input type.
2416 Sema::TemplateDeductionResult
2417 Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
2418 const TemplateArgumentList &TemplateArgs,
2419 TemplateDeductionInfo &Info) {
2420 if (Partial->isInvalidDecl())
2423 // C++ [temp.class.spec.match]p2:
2424 // A partial specialization matches a given actual template
2425 // argument list if the template arguments of the partial
2426 // specialization can be deduced from the actual template argument
2429 // Unevaluated SFINAE context.
2430 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
2431 SFINAETrap Trap(*this);
2433 SmallVector<DeducedTemplateArgument, 4> Deduced;
2434 Deduced.resize(Partial->getTemplateParameters()->size());
2435 if (TemplateDeductionResult Result = ::DeduceTemplateArguments(
2436 *this, Partial->getTemplateParameters(), Partial->getTemplateArgs(),
2437 TemplateArgs, Info, Deduced))
2440 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
2441 InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial,
2443 if (Inst.isInvalid())
2444 return TDK_InstantiationDepth;
2446 if (Trap.hasErrorOccurred())
2447 return Sema::TDK_SubstitutionFailure;
2449 return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs,
2453 /// \brief Determine whether the given type T is a simple-template-id type.
2454 static bool isSimpleTemplateIdType(QualType T) {
2455 if (const TemplateSpecializationType *Spec
2456 = T->getAs<TemplateSpecializationType>())
2457 return Spec->getTemplateName().getAsTemplateDecl() != 0;
2462 /// \brief Substitute the explicitly-provided template arguments into the
2463 /// given function template according to C++ [temp.arg.explicit].
2465 /// \param FunctionTemplate the function template into which the explicit
2466 /// template arguments will be substituted.
2468 /// \param ExplicitTemplateArgs the explicitly-specified template
2471 /// \param Deduced the deduced template arguments, which will be populated
2472 /// with the converted and checked explicit template arguments.
2474 /// \param ParamTypes will be populated with the instantiated function
2477 /// \param FunctionType if non-NULL, the result type of the function template
2478 /// will also be instantiated and the pointed-to value will be updated with
2479 /// the instantiated function type.
2481 /// \param Info if substitution fails for any reason, this object will be
2482 /// populated with more information about the failure.
2484 /// \returns TDK_Success if substitution was successful, or some failure
2486 Sema::TemplateDeductionResult
2487 Sema::SubstituteExplicitTemplateArguments(
2488 FunctionTemplateDecl *FunctionTemplate,
2489 TemplateArgumentListInfo &ExplicitTemplateArgs,
2490 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2491 SmallVectorImpl<QualType> &ParamTypes,
2492 QualType *FunctionType,
2493 TemplateDeductionInfo &Info) {
2494 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
2495 TemplateParameterList *TemplateParams
2496 = FunctionTemplate->getTemplateParameters();
2498 if (ExplicitTemplateArgs.size() == 0) {
2499 // No arguments to substitute; just copy over the parameter types and
2500 // fill in the function type.
2501 for (FunctionDecl::param_iterator P = Function->param_begin(),
2502 PEnd = Function->param_end();
2505 ParamTypes.push_back((*P)->getType());
2508 *FunctionType = Function->getType();
2512 // Unevaluated SFINAE context.
2513 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
2514 SFINAETrap Trap(*this);
2516 // C++ [temp.arg.explicit]p3:
2517 // Template arguments that are present shall be specified in the
2518 // declaration order of their corresponding template-parameters. The
2519 // template argument list shall not specify more template-arguments than
2520 // there are corresponding template-parameters.
2521 SmallVector<TemplateArgument, 4> Builder;
2523 // Enter a new template instantiation context where we check the
2524 // explicitly-specified template arguments against this function template,
2525 // and then substitute them into the function parameter types.
2526 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
2527 InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(),
2528 FunctionTemplate, DeducedArgs,
2529 ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution,
2531 if (Inst.isInvalid())
2532 return TDK_InstantiationDepth;
2534 if (CheckTemplateArgumentList(FunctionTemplate,
2536 ExplicitTemplateArgs,
2538 Builder) || Trap.hasErrorOccurred()) {
2539 unsigned Index = Builder.size();
2540 if (Index >= TemplateParams->size())
2541 Index = TemplateParams->size() - 1;
2542 Info.Param = makeTemplateParameter(TemplateParams->getParam(Index));
2543 return TDK_InvalidExplicitArguments;
2546 // Form the template argument list from the explicitly-specified
2547 // template arguments.
2548 TemplateArgumentList *ExplicitArgumentList
2549 = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size());
2550 Info.reset(ExplicitArgumentList);
2552 // Template argument deduction and the final substitution should be
2553 // done in the context of the templated declaration. Explicit
2554 // argument substitution, on the other hand, needs to happen in the
2556 ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl());
2558 // If we deduced template arguments for a template parameter pack,
2559 // note that the template argument pack is partially substituted and record
2560 // the explicit template arguments. They'll be used as part of deduction
2561 // for this template parameter pack.
2562 for (unsigned I = 0, N = Builder.size(); I != N; ++I) {
2563 const TemplateArgument &Arg = Builder[I];
2564 if (Arg.getKind() == TemplateArgument::Pack) {
2565 CurrentInstantiationScope->SetPartiallySubstitutedPack(
2566 TemplateParams->getParam(I),
2573 const FunctionProtoType *Proto
2574 = Function->getType()->getAs<FunctionProtoType>();
2575 assert(Proto && "Function template does not have a prototype?");
2577 // Instantiate the types of each of the function parameters given the
2578 // explicitly-specified template arguments. If the function has a trailing
2579 // return type, substitute it after the arguments to ensure we substitute
2580 // in lexical order.
2581 if (Proto->hasTrailingReturn()) {
2582 if (SubstParmTypes(Function->getLocation(),
2583 Function->param_begin(), Function->getNumParams(),
2584 MultiLevelTemplateArgumentList(*ExplicitArgumentList),
2586 return TDK_SubstitutionFailure;
2589 // Instantiate the return type.
2590 QualType ResultType;
2592 // C++11 [expr.prim.general]p3:
2593 // If a declaration declares a member function or member function
2594 // template of a class X, the expression this is a prvalue of type
2595 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
2596 // and the end of the function-definition, member-declarator, or
2598 unsigned ThisTypeQuals = 0;
2599 CXXRecordDecl *ThisContext = 0;
2600 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
2601 ThisContext = Method->getParent();
2602 ThisTypeQuals = Method->getTypeQualifiers();
2605 CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals,
2606 getLangOpts().CPlusPlus11);
2608 ResultType = SubstType(Proto->getResultType(),
2609 MultiLevelTemplateArgumentList(*ExplicitArgumentList),
2610 Function->getTypeSpecStartLoc(),
2611 Function->getDeclName());
2612 if (ResultType.isNull() || Trap.hasErrorOccurred())
2613 return TDK_SubstitutionFailure;
2616 // Instantiate the types of each of the function parameters given the
2617 // explicitly-specified template arguments if we didn't do so earlier.
2618 if (!Proto->hasTrailingReturn() &&
2619 SubstParmTypes(Function->getLocation(),
2620 Function->param_begin(), Function->getNumParams(),
2621 MultiLevelTemplateArgumentList(*ExplicitArgumentList),
2623 return TDK_SubstitutionFailure;
2626 *FunctionType = BuildFunctionType(ResultType, ParamTypes,
2627 Function->getLocation(),
2628 Function->getDeclName(),
2629 Proto->getExtProtoInfo());
2630 if (FunctionType->isNull() || Trap.hasErrorOccurred())
2631 return TDK_SubstitutionFailure;
2634 // C++ [temp.arg.explicit]p2:
2635 // Trailing template arguments that can be deduced (14.8.2) may be
2636 // omitted from the list of explicit template-arguments. If all of the
2637 // template arguments can be deduced, they may all be omitted; in this
2638 // case, the empty template argument list <> itself may also be omitted.
2640 // Take all of the explicitly-specified arguments and put them into
2641 // the set of deduced template arguments. Explicitly-specified
2642 // parameter packs, however, will be set to NULL since the deduction
2643 // mechanisms handle explicitly-specified argument packs directly.
2644 Deduced.reserve(TemplateParams->size());
2645 for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) {
2646 const TemplateArgument &Arg = ExplicitArgumentList->get(I);
2647 if (Arg.getKind() == TemplateArgument::Pack)
2648 Deduced.push_back(DeducedTemplateArgument());
2650 Deduced.push_back(Arg);
2656 /// \brief Check whether the deduced argument type for a call to a function
2657 /// template matches the actual argument type per C++ [temp.deduct.call]p4.
2659 CheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg,
2660 QualType DeducedA) {
2661 ASTContext &Context = S.Context;
2663 QualType A = OriginalArg.OriginalArgType;
2664 QualType OriginalParamType = OriginalArg.OriginalParamType;
2666 // Check for type equality (top-level cv-qualifiers are ignored).
2667 if (Context.hasSameUnqualifiedType(A, DeducedA))
2670 // Strip off references on the argument types; they aren't needed for
2671 // the following checks.
2672 if (const ReferenceType *DeducedARef = DeducedA->getAs<ReferenceType>())
2673 DeducedA = DeducedARef->getPointeeType();
2674 if (const ReferenceType *ARef = A->getAs<ReferenceType>())
2675 A = ARef->getPointeeType();
2677 // C++ [temp.deduct.call]p4:
2678 // [...] However, there are three cases that allow a difference:
2679 // - If the original P is a reference type, the deduced A (i.e., the
2680 // type referred to by the reference) can be more cv-qualified than
2681 // the transformed A.
2682 if (const ReferenceType *OriginalParamRef
2683 = OriginalParamType->getAs<ReferenceType>()) {
2684 // We don't want to keep the reference around any more.
2685 OriginalParamType = OriginalParamRef->getPointeeType();
2687 Qualifiers AQuals = A.getQualifiers();
2688 Qualifiers DeducedAQuals = DeducedA.getQualifiers();
2690 // Under Objective-C++ ARC, the deduced type may have implicitly
2691 // been given strong or (when dealing with a const reference)
2692 // unsafe_unretained lifetime. If so, update the original
2693 // qualifiers to include this lifetime.
2694 if (S.getLangOpts().ObjCAutoRefCount &&
2695 ((DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_Strong &&
2696 AQuals.getObjCLifetime() == Qualifiers::OCL_None) ||
2697 (DeducedAQuals.hasConst() &&
2698 DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone))) {
2699 AQuals.setObjCLifetime(DeducedAQuals.getObjCLifetime());
2702 if (AQuals == DeducedAQuals) {
2703 // Qualifiers match; there's nothing to do.
2704 } else if (!DeducedAQuals.compatiblyIncludes(AQuals)) {
2707 // Qualifiers are compatible, so have the argument type adopt the
2708 // deduced argument type's qualifiers as if we had performed the
2709 // qualification conversion.
2710 A = Context.getQualifiedType(A.getUnqualifiedType(), DeducedAQuals);
2714 // - The transformed A can be another pointer or pointer to member
2715 // type that can be converted to the deduced A via a qualification
2718 // Also allow conversions which merely strip [[noreturn]] from function types
2719 // (recursively) as an extension.
2720 // FIXME: Currently, this doesn't play nicely with qualification conversions.
2721 bool ObjCLifetimeConversion = false;
2723 if ((A->isAnyPointerType() || A->isMemberPointerType()) &&
2724 (S.IsQualificationConversion(A, DeducedA, false,
2725 ObjCLifetimeConversion) ||
2726 S.IsNoReturnConversion(A, DeducedA, ResultTy)))
2730 // - If P is a class and P has the form simple-template-id, then the
2731 // transformed A can be a derived class of the deduced A. [...]
2732 // [...] Likewise, if P is a pointer to a class of the form
2733 // simple-template-id, the transformed A can be a pointer to a
2734 // derived class pointed to by the deduced A.
2735 if (const PointerType *OriginalParamPtr
2736 = OriginalParamType->getAs<PointerType>()) {
2737 if (const PointerType *DeducedAPtr = DeducedA->getAs<PointerType>()) {
2738 if (const PointerType *APtr = A->getAs<PointerType>()) {
2739 if (A->getPointeeType()->isRecordType()) {
2740 OriginalParamType = OriginalParamPtr->getPointeeType();
2741 DeducedA = DeducedAPtr->getPointeeType();
2742 A = APtr->getPointeeType();
2748 if (Context.hasSameUnqualifiedType(A, DeducedA))
2751 if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) &&
2752 S.IsDerivedFrom(A, DeducedA))
2758 /// \brief Finish template argument deduction for a function template,
2759 /// checking the deduced template arguments for completeness and forming
2760 /// the function template specialization.
2762 /// \param OriginalCallArgs If non-NULL, the original call arguments against
2763 /// which the deduced argument types should be compared.
2764 Sema::TemplateDeductionResult
2765 Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate,
2766 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2767 unsigned NumExplicitlySpecified,
2768 FunctionDecl *&Specialization,
2769 TemplateDeductionInfo &Info,
2770 SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs) {
2771 TemplateParameterList *TemplateParams
2772 = FunctionTemplate->getTemplateParameters();
2774 // Unevaluated SFINAE context.
2775 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
2776 SFINAETrap Trap(*this);
2778 // Enter a new template instantiation context while we instantiate the
2779 // actual function declaration.
2780 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
2781 InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(),
2782 FunctionTemplate, DeducedArgs,
2783 ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution,
2785 if (Inst.isInvalid())
2786 return TDK_InstantiationDepth;
2788 ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl());
2790 // C++ [temp.deduct.type]p2:
2791 // [...] or if any template argument remains neither deduced nor
2792 // explicitly specified, template argument deduction fails.
2793 SmallVector<TemplateArgument, 4> Builder;
2794 for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
2795 NamedDecl *Param = TemplateParams->getParam(I);
2797 if (!Deduced[I].isNull()) {
2798 if (I < NumExplicitlySpecified) {
2799 // We have already fully type-checked and converted this
2800 // argument, because it was explicitly-specified. Just record the
2801 // presence of this argument.
2802 Builder.push_back(Deduced[I]);
2806 // We have deduced this argument, so it still needs to be
2807 // checked and converted.
2809 // First, for a non-type template parameter type that is
2810 // initialized by a declaration, we need the type of the
2811 // corresponding non-type template parameter.
2813 if (NonTypeTemplateParmDecl *NTTP
2814 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
2815 NTTPType = NTTP->getType();
2816 if (NTTPType->isDependentType()) {
2817 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
2818 Builder.data(), Builder.size());
2819 NTTPType = SubstType(NTTPType,
2820 MultiLevelTemplateArgumentList(TemplateArgs),
2821 NTTP->getLocation(),
2822 NTTP->getDeclName());
2823 if (NTTPType.isNull()) {
2824 Info.Param = makeTemplateParameter(Param);
2825 // FIXME: These template arguments are temporary. Free them!
2826 Info.reset(TemplateArgumentList::CreateCopy(Context,
2829 return TDK_SubstitutionFailure;
2834 if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I],
2835 FunctionTemplate, NTTPType, 0, Info,
2837 Info.Param = makeTemplateParameter(Param);
2838 // FIXME: These template arguments are temporary. Free them!
2839 Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(),
2841 return TDK_SubstitutionFailure;
2847 // C++0x [temp.arg.explicit]p3:
2848 // A trailing template parameter pack (14.5.3) not otherwise deduced will
2849 // be deduced to an empty sequence of template arguments.
2850 // FIXME: Where did the word "trailing" come from?
2851 if (Param->isTemplateParameterPack()) {
2852 // We may have had explicitly-specified template arguments for this
2853 // template parameter pack. If so, our empty deduction extends the
2854 // explicitly-specified set (C++0x [temp.arg.explicit]p9).
2855 const TemplateArgument *ExplicitArgs;
2856 unsigned NumExplicitArgs;
2857 if (CurrentInstantiationScope &&
2858 CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs,
2861 Builder.push_back(TemplateArgument(ExplicitArgs, NumExplicitArgs));
2863 // Forget the partially-substituted pack; it's substitution is now
2865 CurrentInstantiationScope->ResetPartiallySubstitutedPack();
2867 Builder.push_back(TemplateArgument::getEmptyPack());
2872 // Substitute into the default template argument, if available.
2873 bool HasDefaultArg = false;
2874 TemplateArgumentLoc DefArg
2875 = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate,
2876 FunctionTemplate->getLocation(),
2877 FunctionTemplate->getSourceRange().getEnd(),
2879 Builder, HasDefaultArg);
2881 // If there was no default argument, deduction is incomplete.
2882 if (DefArg.getArgument().isNull()) {
2883 Info.Param = makeTemplateParameter(
2884 const_cast<NamedDecl *>(TemplateParams->getParam(I)));
2885 Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(),
2887 return HasDefaultArg ? TDK_SubstitutionFailure : TDK_Incomplete;
2890 // Check whether we can actually use the default argument.
2891 if (CheckTemplateArgument(Param, DefArg,
2893 FunctionTemplate->getLocation(),
2894 FunctionTemplate->getSourceRange().getEnd(),
2897 Info.Param = makeTemplateParameter(
2898 const_cast<NamedDecl *>(TemplateParams->getParam(I)));
2899 // FIXME: These template arguments are temporary. Free them!
2900 Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(),
2902 return TDK_SubstitutionFailure;
2905 // If we get here, we successfully used the default template argument.
2908 // Form the template argument list from the deduced template arguments.
2909 TemplateArgumentList *DeducedArgumentList
2910 = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size());
2911 Info.reset(DeducedArgumentList);
2913 // Substitute the deduced template arguments into the function template
2914 // declaration to produce the function template specialization.
2915 DeclContext *Owner = FunctionTemplate->getDeclContext();
2916 if (FunctionTemplate->getFriendObjectKind())
2917 Owner = FunctionTemplate->getLexicalDeclContext();
2918 Specialization = cast_or_null<FunctionDecl>(
2919 SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner,
2920 MultiLevelTemplateArgumentList(*DeducedArgumentList)));
2921 if (!Specialization || Specialization->isInvalidDecl())
2922 return TDK_SubstitutionFailure;
2924 assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
2925 FunctionTemplate->getCanonicalDecl());
2927 // If the template argument list is owned by the function template
2928 // specialization, release it.
2929 if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList &&
2930 !Trap.hasErrorOccurred())
2933 // There may have been an error that did not prevent us from constructing a
2934 // declaration. Mark the declaration invalid and return with a substitution
2936 if (Trap.hasErrorOccurred()) {
2937 Specialization->setInvalidDecl(true);
2938 return TDK_SubstitutionFailure;
2941 if (OriginalCallArgs) {
2942 // C++ [temp.deduct.call]p4:
2943 // In general, the deduction process attempts to find template argument
2944 // values that will make the deduced A identical to A (after the type A
2945 // is transformed as described above). [...]
2946 for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
2947 OriginalCallArg OriginalArg = (*OriginalCallArgs)[I];
2948 unsigned ParamIdx = OriginalArg.ArgIdx;
2950 if (ParamIdx >= Specialization->getNumParams())
2953 QualType DeducedA = Specialization->getParamDecl(ParamIdx)->getType();
2954 if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA))
2955 return Sema::TDK_SubstitutionFailure;
2959 // If we suppressed any diagnostics while performing template argument
2960 // deduction, and if we haven't already instantiated this declaration,
2961 // keep track of these diagnostics. They'll be emitted if this specialization
2962 // is actually used.
2963 if (Info.diag_begin() != Info.diag_end()) {
2964 SuppressedDiagnosticsMap::iterator
2965 Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl());
2966 if (Pos == SuppressedDiagnostics.end())
2967 SuppressedDiagnostics[Specialization->getCanonicalDecl()]
2968 .append(Info.diag_begin(), Info.diag_end());
2974 /// Gets the type of a function for template-argument-deducton
2975 /// purposes when it's considered as part of an overload set.
2976 static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R,
2978 // We may need to deduce the return type of the function now.
2979 if (S.getLangOpts().CPlusPlus1y && Fn->getResultType()->isUndeducedType() &&
2980 S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/false))
2983 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
2984 if (Method->isInstance()) {
2985 // An instance method that's referenced in a form that doesn't
2986 // look like a member pointer is just invalid.
2987 if (!R.HasFormOfMemberPointer) return QualType();
2989 return S.Context.getMemberPointerType(Fn->getType(),
2990 S.Context.getTypeDeclType(Method->getParent()).getTypePtr());
2993 if (!R.IsAddressOfOperand) return Fn->getType();
2994 return S.Context.getPointerType(Fn->getType());
2997 /// Apply the deduction rules for overload sets.
2999 /// \return the null type if this argument should be treated as an
3000 /// undeduced context
3002 ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams,
3003 Expr *Arg, QualType ParamType,
3004 bool ParamWasReference) {
3006 OverloadExpr::FindResult R = OverloadExpr::find(Arg);
3008 OverloadExpr *Ovl = R.Expression;
3010 // C++0x [temp.deduct.call]p4
3012 if (ParamWasReference)
3013 TDF |= TDF_ParamWithReferenceType;
3014 if (R.IsAddressOfOperand)
3015 TDF |= TDF_IgnoreQualifiers;
3017 // C++0x [temp.deduct.call]p6:
3018 // When P is a function type, pointer to function type, or pointer
3019 // to member function type:
3021 if (!ParamType->isFunctionType() &&
3022 !ParamType->isFunctionPointerType() &&
3023 !ParamType->isMemberFunctionPointerType()) {
3024 if (Ovl->hasExplicitTemplateArgs()) {
3025 // But we can still look for an explicit specialization.
3026 if (FunctionDecl *ExplicitSpec
3027 = S.ResolveSingleFunctionTemplateSpecialization(Ovl))
3028 return GetTypeOfFunction(S, R, ExplicitSpec);
3034 // Gather the explicit template arguments, if any.
3035 TemplateArgumentListInfo ExplicitTemplateArgs;
3036 if (Ovl->hasExplicitTemplateArgs())
3037 Ovl->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs);
3039 for (UnresolvedSetIterator I = Ovl->decls_begin(),
3040 E = Ovl->decls_end(); I != E; ++I) {
3041 NamedDecl *D = (*I)->getUnderlyingDecl();
3043 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) {
3044 // - If the argument is an overload set containing one or more
3045 // function templates, the parameter is treated as a
3046 // non-deduced context.
3047 if (!Ovl->hasExplicitTemplateArgs())
3050 // Otherwise, see if we can resolve a function type
3051 FunctionDecl *Specialization = 0;
3052 TemplateDeductionInfo Info(Ovl->getNameLoc());
3053 if (S.DeduceTemplateArguments(FunTmpl, &ExplicitTemplateArgs,
3054 Specialization, Info))
3060 FunctionDecl *Fn = cast<FunctionDecl>(D);
3061 QualType ArgType = GetTypeOfFunction(S, R, Fn);
3062 if (ArgType.isNull()) continue;
3064 // Function-to-pointer conversion.
3065 if (!ParamWasReference && ParamType->isPointerType() &&
3066 ArgType->isFunctionType())
3067 ArgType = S.Context.getPointerType(ArgType);
3069 // - If the argument is an overload set (not containing function
3070 // templates), trial argument deduction is attempted using each
3071 // of the members of the set. If deduction succeeds for only one
3072 // of the overload set members, that member is used as the
3073 // argument value for the deduction. If deduction succeeds for
3074 // more than one member of the overload set the parameter is
3075 // treated as a non-deduced context.
3077 // We do all of this in a fresh context per C++0x [temp.deduct.type]p2:
3078 // Type deduction is done independently for each P/A pair, and
3079 // the deduced template argument values are then combined.
3080 // So we do not reject deductions which were made elsewhere.
3081 SmallVector<DeducedTemplateArgument, 8>
3082 Deduced(TemplateParams->size());
3083 TemplateDeductionInfo Info(Ovl->getNameLoc());
3084 Sema::TemplateDeductionResult Result
3085 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
3086 ArgType, Info, Deduced, TDF);
3087 if (Result) continue;
3088 if (!Match.isNull()) return QualType();
3095 /// \brief Perform the adjustments to the parameter and argument types
3096 /// described in C++ [temp.deduct.call].
3098 /// \returns true if the caller should not attempt to perform any template
3099 /// argument deduction based on this P/A pair because the argument is an
3100 /// overloaded function set that could not be resolved.
3101 static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S,
3102 TemplateParameterList *TemplateParams,
3103 QualType &ParamType,
3107 // C++0x [temp.deduct.call]p3:
3108 // If P is a cv-qualified type, the top level cv-qualifiers of P's type
3109 // are ignored for type deduction.
3110 if (ParamType.hasQualifiers())
3111 ParamType = ParamType.getUnqualifiedType();
3112 const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>();
3114 QualType PointeeType = ParamRefType->getPointeeType();
3116 // If the argument has incomplete array type, try to complete its type.
3117 if (ArgType->isIncompleteArrayType() && !S.RequireCompleteExprType(Arg, 0))
3118 ArgType = Arg->getType();
3120 // [C++0x] If P is an rvalue reference to a cv-unqualified
3121 // template parameter and the argument is an lvalue, the type
3122 // "lvalue reference to A" is used in place of A for type
3124 if (isa<RValueReferenceType>(ParamType)) {
3125 if (!PointeeType.getQualifiers() &&
3126 isa<TemplateTypeParmType>(PointeeType) &&
3127 Arg->Classify(S.Context).isLValue() &&
3128 Arg->getType() != S.Context.OverloadTy &&
3129 Arg->getType() != S.Context.BoundMemberTy)
3130 ArgType = S.Context.getLValueReferenceType(ArgType);
3133 // [...] If P is a reference type, the type referred to by P is used
3134 // for type deduction.
3135 ParamType = PointeeType;
3138 // Overload sets usually make this parameter an undeduced
3139 // context, but there are sometimes special circumstances.
3140 if (ArgType == S.Context.OverloadTy) {
3141 ArgType = ResolveOverloadForDeduction(S, TemplateParams,
3144 if (ArgType.isNull())
3149 // C++0x [temp.deduct.call]p3:
3150 // [...] If P is of the form T&&, where T is a template parameter, and
3151 // the argument is an lvalue, the type A& is used in place of A for
3153 if (ParamRefType->isRValueReferenceType() &&
3154 ParamRefType->getAs<TemplateTypeParmType>() &&
3156 ArgType = S.Context.getLValueReferenceType(ArgType);
3158 // C++ [temp.deduct.call]p2:
3159 // If P is not a reference type:
3160 // - If A is an array type, the pointer type produced by the
3161 // array-to-pointer standard conversion (4.2) is used in place of
3162 // A for type deduction; otherwise,
3163 if (ArgType->isArrayType())
3164 ArgType = S.Context.getArrayDecayedType(ArgType);
3165 // - If A is a function type, the pointer type produced by the
3166 // function-to-pointer standard conversion (4.3) is used in place
3167 // of A for type deduction; otherwise,
3168 else if (ArgType->isFunctionType())
3169 ArgType = S.Context.getPointerType(ArgType);
3171 // - If A is a cv-qualified type, the top level cv-qualifiers of A's
3172 // type are ignored for type deduction.
3173 ArgType = ArgType.getUnqualifiedType();
3177 // C++0x [temp.deduct.call]p4:
3178 // In general, the deduction process attempts to find template argument
3179 // values that will make the deduced A identical to A (after the type A
3180 // is transformed as described above). [...]
3181 TDF = TDF_SkipNonDependent;
3183 // - If the original P is a reference type, the deduced A (i.e., the
3184 // type referred to by the reference) can be more cv-qualified than
3185 // the transformed A.
3187 TDF |= TDF_ParamWithReferenceType;
3188 // - The transformed A can be another pointer or pointer to member
3189 // type that can be converted to the deduced A via a qualification
3190 // conversion (4.4).
3191 if (ArgType->isPointerType() || ArgType->isMemberPointerType() ||
3192 ArgType->isObjCObjectPointerType())
3193 TDF |= TDF_IgnoreQualifiers;
3194 // - If P is a class and P has the form simple-template-id, then the
3195 // transformed A can be a derived class of the deduced A. Likewise,
3196 // if P is a pointer to a class of the form simple-template-id, the
3197 // transformed A can be a pointer to a derived class pointed to by
3199 if (isSimpleTemplateIdType(ParamType) ||
3200 (isa<PointerType>(ParamType) &&
3201 isSimpleTemplateIdType(
3202 ParamType->getAs<PointerType>()->getPointeeType())))
3203 TDF |= TDF_DerivedClass;
3208 static bool hasDeducibleTemplateParameters(Sema &S,
3209 FunctionTemplateDecl *FunctionTemplate,
3212 /// \brief Perform template argument deduction by matching a parameter type
3213 /// against a single expression, where the expression is an element of
3214 /// an initializer list that was originally matched against a parameter
3215 /// of type \c initializer_list\<ParamType\>.
3216 static Sema::TemplateDeductionResult
3217 DeduceTemplateArgumentByListElement(Sema &S,
3218 TemplateParameterList *TemplateParams,
3219 QualType ParamType, Expr *Arg,
3220 TemplateDeductionInfo &Info,
3221 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
3223 // Handle the case where an init list contains another init list as the
3225 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
3227 if (!S.isStdInitializerList(ParamType.getNonReferenceType(), &X))
3228 return Sema::TDK_Success; // Just ignore this expression.
3230 // Recurse down into the init list.
3231 for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) {
3232 if (Sema::TemplateDeductionResult Result =
3233 DeduceTemplateArgumentByListElement(S, TemplateParams, X,
3235 Info, Deduced, TDF))
3238 return Sema::TDK_Success;
3241 // For all other cases, just match by type.
3242 QualType ArgType = Arg->getType();
3243 if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType,
3244 ArgType, Arg, TDF)) {
3245 Info.Expression = Arg;
3246 return Sema::TDK_FailedOverloadResolution;
3248 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
3249 ArgType, Info, Deduced, TDF);
3252 /// \brief Perform template argument deduction from a function call
3253 /// (C++ [temp.deduct.call]).
3255 /// \param FunctionTemplate the function template for which we are performing
3256 /// template argument deduction.
3258 /// \param ExplicitTemplateArgs the explicit template arguments provided
3261 /// \param Args the function call arguments
3263 /// \param Specialization if template argument deduction was successful,
3264 /// this will be set to the function template specialization produced by
3265 /// template argument deduction.
3267 /// \param Info the argument will be updated to provide additional information
3268 /// about template argument deduction.
3270 /// \returns the result of template argument deduction.
3271 Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(
3272 FunctionTemplateDecl *FunctionTemplate,
3273 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
3274 FunctionDecl *&Specialization, TemplateDeductionInfo &Info) {
3275 if (FunctionTemplate->isInvalidDecl())
3278 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
3280 // C++ [temp.deduct.call]p1:
3281 // Template argument deduction is done by comparing each function template
3282 // parameter type (call it P) with the type of the corresponding argument
3283 // of the call (call it A) as described below.
3284 unsigned CheckArgs = Args.size();
3285 if (Args.size() < Function->getMinRequiredArguments())
3286 return TDK_TooFewArguments;
3287 else if (Args.size() > Function->getNumParams()) {
3288 const FunctionProtoType *Proto
3289 = Function->getType()->getAs<FunctionProtoType>();
3290 if (Proto->isTemplateVariadic())
3292 else if (Proto->isVariadic())
3293 CheckArgs = Function->getNumParams();
3295 return TDK_TooManyArguments;
3298 // The types of the parameters from which we will perform template argument
3300 LocalInstantiationScope InstScope(*this);
3301 TemplateParameterList *TemplateParams
3302 = FunctionTemplate->getTemplateParameters();
3303 SmallVector<DeducedTemplateArgument, 4> Deduced;
3304 SmallVector<QualType, 4> ParamTypes;
3305 unsigned NumExplicitlySpecified = 0;
3306 if (ExplicitTemplateArgs) {
3307 TemplateDeductionResult Result =
3308 SubstituteExplicitTemplateArguments(FunctionTemplate,
3309 *ExplicitTemplateArgs,
3317 NumExplicitlySpecified = Deduced.size();
3319 // Just fill in the parameter types from the function declaration.
3320 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I)
3321 ParamTypes.push_back(Function->getParamDecl(I)->getType());
3324 // Deduce template arguments from the function parameters.
3325 Deduced.resize(TemplateParams->size());
3326 unsigned ArgIdx = 0;
3327 SmallVector<OriginalCallArg, 4> OriginalCallArgs;
3328 for (unsigned ParamIdx = 0, NumParams = ParamTypes.size();
3329 ParamIdx != NumParams; ++ParamIdx) {
3330 QualType OrigParamType = ParamTypes[ParamIdx];
3331 QualType ParamType = OrigParamType;
3333 const PackExpansionType *ParamExpansion
3334 = dyn_cast<PackExpansionType>(ParamType);
3335 if (!ParamExpansion) {
3336 // Simple case: matching a function parameter to a function argument.
3337 if (ArgIdx >= CheckArgs)
3340 Expr *Arg = Args[ArgIdx++];
3341 QualType ArgType = Arg->getType();
3344 if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams,
3345 ParamType, ArgType, Arg,
3349 // If we have nothing to deduce, we're done.
3350 if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
3353 // If the argument is an initializer list ...
3354 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
3355 // ... then the parameter is an undeduced context, unless the parameter
3356 // type is (reference to cv) std::initializer_list<P'>, in which case
3357 // deduction is done for each element of the initializer list, and the
3358 // result is the deduced type if it's the same for all elements.
3360 // Removing references was already done.
3361 if (!isStdInitializerList(ParamType, &X))
3364 for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) {
3365 if (TemplateDeductionResult Result =
3366 DeduceTemplateArgumentByListElement(*this, TemplateParams, X,
3368 Info, Deduced, TDF))
3371 // Don't track the argument type, since an initializer list has none.
3375 // Keep track of the argument type and corresponding parameter index,
3376 // so we can check for compatibility between the deduced A and A.
3377 OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1,
3380 if (TemplateDeductionResult Result
3381 = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
3383 Info, Deduced, TDF))
3389 // C++0x [temp.deduct.call]p1:
3390 // For a function parameter pack that occurs at the end of the
3391 // parameter-declaration-list, the type A of each remaining argument of
3392 // the call is compared with the type P of the declarator-id of the
3393 // function parameter pack. Each comparison deduces template arguments
3394 // for subsequent positions in the template parameter packs expanded by
3395 // the function parameter pack. For a function parameter pack that does
3396 // not occur at the end of the parameter-declaration-list, the type of
3397 // the parameter pack is a non-deduced context.
3398 if (ParamIdx + 1 < NumParams)
3401 QualType ParamPattern = ParamExpansion->getPattern();
3402 SmallVector<unsigned, 2> PackIndices;
3404 llvm::SmallBitVector SawIndices(TemplateParams->size());
3405 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
3406 collectUnexpandedParameterPacks(ParamPattern, Unexpanded);
3407 for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
3408 unsigned Depth, Index;
3409 llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
3410 if (Depth == 0 && !SawIndices[Index]) {
3411 SawIndices[Index] = true;
3412 PackIndices.push_back(Index);
3416 assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
3418 // Keep track of the deduced template arguments for each parameter pack
3419 // expanded by this pack expansion (the outer index) and for each
3420 // template argument (the inner SmallVectors).
3421 NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size());
3422 SmallVector<DeducedTemplateArgument, 2>
3423 SavedPacks(PackIndices.size());
3424 PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks,
3426 bool HasAnyArguments = false;
3427 for (; ArgIdx < Args.size(); ++ArgIdx) {
3428 HasAnyArguments = true;
3430 QualType OrigParamType = ParamPattern;
3431 ParamType = OrigParamType;
3432 Expr *Arg = Args[ArgIdx];
3433 QualType ArgType = Arg->getType();
3436 if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams,
3437 ParamType, ArgType, Arg,
3439 // We can't actually perform any deduction for this argument, so stop
3440 // deduction at this point.
3445 // As above, initializer lists need special handling.
3446 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
3448 if (!isStdInitializerList(ParamType, &X)) {
3453 for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) {
3454 if (TemplateDeductionResult Result =
3455 DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, X,
3456 ILE->getInit(i)->getType(),
3457 Info, Deduced, TDF))
3462 // Keep track of the argument type and corresponding argument index,
3463 // so we can check for compatibility between the deduced A and A.
3464 if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
3465 OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx,
3468 if (TemplateDeductionResult Result
3469 = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
3470 ParamType, ArgType, Info,
3475 // Capture the deduced template arguments for each parameter pack expanded
3476 // by this pack expansion, add them to the list of arguments we've deduced
3477 // for that pack, then clear out the deduced argument.
3478 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
3479 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
3480 if (!DeducedArg.isNull()) {
3481 NewlyDeducedPacks[I].push_back(DeducedArg);
3482 DeducedArg = DeducedTemplateArgument();
3487 // Build argument packs for each of the parameter packs expanded by this
3489 if (Sema::TemplateDeductionResult Result
3490 = FinishArgumentPackDeduction(*this, TemplateParams, HasAnyArguments,
3491 Deduced, PackIndices, SavedPacks,
3492 NewlyDeducedPacks, Info))
3495 // After we've matching against a parameter pack, we're done.
3499 return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
3500 NumExplicitlySpecified,
3501 Specialization, Info, &OriginalCallArgs);
3504 QualType Sema::adjustCCAndNoReturn(QualType ArgFunctionType,
3505 QualType FunctionType) {
3506 if (ArgFunctionType.isNull())
3507 return ArgFunctionType;
3509 const FunctionProtoType *FunctionTypeP =
3510 FunctionType->castAs<FunctionProtoType>();
3511 CallingConv CC = FunctionTypeP->getCallConv();
3512 bool NoReturn = FunctionTypeP->getNoReturnAttr();
3513 const FunctionProtoType *ArgFunctionTypeP =
3514 ArgFunctionType->getAs<FunctionProtoType>();
3515 if (ArgFunctionTypeP->getCallConv() == CC &&
3516 ArgFunctionTypeP->getNoReturnAttr() == NoReturn)
3517 return ArgFunctionType;
3519 FunctionType::ExtInfo EI = ArgFunctionTypeP->getExtInfo().withCallingConv(CC);
3520 EI = EI.withNoReturn(NoReturn);
3522 cast<FunctionProtoType>(Context.adjustFunctionType(ArgFunctionTypeP, EI));
3523 return QualType(ArgFunctionTypeP, 0);
3526 /// \brief Deduce template arguments when taking the address of a function
3527 /// template (C++ [temp.deduct.funcaddr]) or matching a specialization to
3530 /// \param FunctionTemplate the function template for which we are performing
3531 /// template argument deduction.
3533 /// \param ExplicitTemplateArgs the explicitly-specified template
3536 /// \param ArgFunctionType the function type that will be used as the
3537 /// "argument" type (A) when performing template argument deduction from the
3538 /// function template's function type. This type may be NULL, if there is no
3539 /// argument type to compare against, in C++0x [temp.arg.explicit]p3.
3541 /// \param Specialization if template argument deduction was successful,
3542 /// this will be set to the function template specialization produced by
3543 /// template argument deduction.
3545 /// \param Info the argument will be updated to provide additional information
3546 /// about template argument deduction.
3548 /// \returns the result of template argument deduction.
3549 Sema::TemplateDeductionResult
3550 Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
3551 TemplateArgumentListInfo *ExplicitTemplateArgs,
3552 QualType ArgFunctionType,
3553 FunctionDecl *&Specialization,
3554 TemplateDeductionInfo &Info,
3555 bool InOverloadResolution) {
3556 if (FunctionTemplate->isInvalidDecl())
3559 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
3560 TemplateParameterList *TemplateParams
3561 = FunctionTemplate->getTemplateParameters();
3562 QualType FunctionType = Function->getType();
3563 if (!InOverloadResolution)
3564 ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, FunctionType);
3566 // Substitute any explicit template arguments.
3567 LocalInstantiationScope InstScope(*this);
3568 SmallVector<DeducedTemplateArgument, 4> Deduced;
3569 unsigned NumExplicitlySpecified = 0;
3570 SmallVector<QualType, 4> ParamTypes;
3571 if (ExplicitTemplateArgs) {
3572 if (TemplateDeductionResult Result
3573 = SubstituteExplicitTemplateArguments(FunctionTemplate,
3574 *ExplicitTemplateArgs,
3575 Deduced, ParamTypes,
3576 &FunctionType, Info))
3579 NumExplicitlySpecified = Deduced.size();
3582 // Unevaluated SFINAE context.
3583 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
3584 SFINAETrap Trap(*this);
3586 Deduced.resize(TemplateParams->size());
3588 // If the function has a deduced return type, substitute it for a dependent
3589 // type so that we treat it as a non-deduced context in what follows.
3590 bool HasDeducedReturnType = false;
3591 if (getLangOpts().CPlusPlus1y && InOverloadResolution &&
3592 Function->getResultType()->getContainedAutoType()) {
3593 FunctionType = SubstAutoType(FunctionType, Context.DependentTy);
3594 HasDeducedReturnType = true;
3597 if (!ArgFunctionType.isNull()) {
3598 unsigned TDF = TDF_TopLevelParameterTypeList;
3599 if (InOverloadResolution) TDF |= TDF_InOverloadResolution;
3600 // Deduce template arguments from the function type.
3601 if (TemplateDeductionResult Result
3602 = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
3603 FunctionType, ArgFunctionType,
3604 Info, Deduced, TDF))
3608 if (TemplateDeductionResult Result
3609 = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
3610 NumExplicitlySpecified,
3611 Specialization, Info))
3614 // If the function has a deduced return type, deduce it now, so we can check
3615 // that the deduced function type matches the requested type.
3616 if (HasDeducedReturnType &&
3617 Specialization->getResultType()->isUndeducedType() &&
3618 DeduceReturnType(Specialization, Info.getLocation(), false))
3619 return TDK_MiscellaneousDeductionFailure;
3621 // If the requested function type does not match the actual type of the
3622 // specialization with respect to arguments of compatible pointer to function
3623 // types, template argument deduction fails.
3624 if (!ArgFunctionType.isNull()) {
3625 if (InOverloadResolution && !isSameOrCompatibleFunctionType(
3626 Context.getCanonicalType(Specialization->getType()),
3627 Context.getCanonicalType(ArgFunctionType)))
3628 return TDK_MiscellaneousDeductionFailure;
3629 else if(!InOverloadResolution &&
3630 !Context.hasSameType(Specialization->getType(), ArgFunctionType))
3631 return TDK_MiscellaneousDeductionFailure;
3637 /// \brief Given a function declaration (e.g. a generic lambda conversion
3638 /// function) that contains an 'auto' in its result type, substitute it
3639 /// with TypeToReplaceAutoWith. Be careful to pass in the type you want
3640 /// to replace 'auto' with and not the actual result type you want
3641 /// to set the function to.
3643 SubstAutoWithinFunctionReturnType(FunctionDecl *F,
3644 QualType TypeToReplaceAutoWith, Sema &S) {
3645 assert(!TypeToReplaceAutoWith->getContainedAutoType());
3646 QualType AutoResultType = F->getResultType();
3647 assert(AutoResultType->getContainedAutoType());
3648 QualType DeducedResultType = S.SubstAutoType(AutoResultType,
3649 TypeToReplaceAutoWith);
3650 S.Context.adjustDeducedFunctionResultType(F, DeducedResultType);
3653 /// \brief Given a specialized conversion operator of a generic lambda
3654 /// create the corresponding specializations of the call operator and
3655 /// the static-invoker. If the return type of the call operator is auto,
3656 /// deduce its return type and check if that matches the
3657 /// return type of the destination function ptr.
3659 static inline Sema::TemplateDeductionResult
3660 SpecializeCorrespondingLambdaCallOperatorAndInvoker(
3661 CXXConversionDecl *ConversionSpecialized,
3662 SmallVectorImpl<DeducedTemplateArgument> &DeducedArguments,
3663 QualType ReturnTypeOfDestFunctionPtr,
3664 TemplateDeductionInfo &TDInfo,
3667 CXXRecordDecl *LambdaClass = ConversionSpecialized->getParent();
3668 assert(LambdaClass && LambdaClass->isGenericLambda());
3670 CXXMethodDecl *CallOpGeneric = LambdaClass->getLambdaCallOperator();
3671 QualType CallOpResultType = CallOpGeneric->getResultType();
3672 const bool GenericLambdaCallOperatorHasDeducedReturnType =
3673 CallOpResultType->getContainedAutoType();
3675 FunctionTemplateDecl *CallOpTemplate =
3676 CallOpGeneric->getDescribedFunctionTemplate();
3678 FunctionDecl *CallOpSpecialized = 0;
3679 // Use the deduced arguments of the conversion function, to specialize our
3680 // generic lambda's call operator.
3681 if (Sema::TemplateDeductionResult Result
3682 = S.FinishTemplateArgumentDeduction(CallOpTemplate,
3684 0, CallOpSpecialized, TDInfo))
3687 // If we need to deduce the return type, do so (instantiates the callop).
3688 if (GenericLambdaCallOperatorHasDeducedReturnType &&
3689 CallOpSpecialized->getResultType()->isUndeducedType())
3690 S.DeduceReturnType(CallOpSpecialized,
3691 CallOpSpecialized->getPointOfInstantiation(),
3694 // Check to see if the return type of the destination ptr-to-function
3695 // matches the return type of the call operator.
3696 if (!S.Context.hasSameType(CallOpSpecialized->getResultType(),
3697 ReturnTypeOfDestFunctionPtr))
3698 return Sema::TDK_NonDeducedMismatch;
3699 // Since we have succeeded in matching the source and destination
3700 // ptr-to-functions (now including return type), and have successfully
3701 // specialized our corresponding call operator, we are ready to
3702 // specialize the static invoker with the deduced arguments of our
3704 FunctionDecl *InvokerSpecialized = 0;
3705 FunctionTemplateDecl *InvokerTemplate = LambdaClass->
3706 getLambdaStaticInvoker()->getDescribedFunctionTemplate();
3708 Sema::TemplateDeductionResult LLVM_ATTRIBUTE_UNUSED Result
3709 = S.FinishTemplateArgumentDeduction(InvokerTemplate, DeducedArguments, 0,
3710 InvokerSpecialized, TDInfo);
3711 assert(Result == Sema::TDK_Success &&
3712 "If the call operator succeeded so should the invoker!");
3713 // Set the result type to match the corresponding call operator
3714 // specialization's result type.
3715 if (GenericLambdaCallOperatorHasDeducedReturnType &&
3716 InvokerSpecialized->getResultType()->isUndeducedType()) {
3717 // Be sure to get the type to replace 'auto' with and not
3718 // the full result type of the call op specialization
3719 // to substitute into the 'auto' of the invoker and conversion
3722 // int* (*fp)(int*) = [](auto* a) -> auto* { return a; };
3723 // We don't want to subst 'int*' into 'auto' to get int**.
3725 QualType TypeToReplaceAutoWith =
3726 CallOpSpecialized->getResultType()->
3727 getContainedAutoType()->getDeducedType();
3728 SubstAutoWithinFunctionReturnType(InvokerSpecialized,
3729 TypeToReplaceAutoWith, S);
3730 SubstAutoWithinFunctionReturnType(ConversionSpecialized,
3731 TypeToReplaceAutoWith, S);
3734 // Ensure that static invoker doesn't have a const qualifier.
3735 // FIXME: When creating the InvokerTemplate in SemaLambda.cpp
3736 // do not use the CallOperator's TypeSourceInfo which allows
3737 // the const qualifier to leak through.
3738 const FunctionProtoType *InvokerFPT = InvokerSpecialized->
3739 getType().getTypePtr()->castAs<FunctionProtoType>();
3740 FunctionProtoType::ExtProtoInfo EPI = InvokerFPT->getExtProtoInfo();
3742 InvokerSpecialized->setType(S.Context.getFunctionType(
3743 InvokerFPT->getResultType(), InvokerFPT->getArgTypes(),EPI));
3744 return Sema::TDK_Success;
3746 /// \brief Deduce template arguments for a templated conversion
3747 /// function (C++ [temp.deduct.conv]) and, if successful, produce a
3748 /// conversion function template specialization.
3749 Sema::TemplateDeductionResult
3750 Sema::DeduceTemplateArguments(FunctionTemplateDecl *ConversionTemplate,
3752 CXXConversionDecl *&Specialization,
3753 TemplateDeductionInfo &Info) {
3754 if (ConversionTemplate->isInvalidDecl())
3757 CXXConversionDecl *ConversionGeneric
3758 = cast<CXXConversionDecl>(ConversionTemplate->getTemplatedDecl());
3760 QualType FromType = ConversionGeneric->getConversionType();
3762 // Canonicalize the types for deduction.
3763 QualType P = Context.getCanonicalType(FromType);
3764 QualType A = Context.getCanonicalType(ToType);
3766 // C++0x [temp.deduct.conv]p2:
3767 // If P is a reference type, the type referred to by P is used for
3769 if (const ReferenceType *PRef = P->getAs<ReferenceType>())
3770 P = PRef->getPointeeType();
3772 // C++0x [temp.deduct.conv]p4:
3773 // [...] If A is a reference type, the type referred to by A is used
3774 // for type deduction.
3775 if (const ReferenceType *ARef = A->getAs<ReferenceType>())
3776 A = ARef->getPointeeType().getUnqualifiedType();
3777 // C++ [temp.deduct.conv]p3:
3779 // If A is not a reference type:
3781 assert(!A->isReferenceType() && "Reference types were handled above");
3783 // - If P is an array type, the pointer type produced by the
3784 // array-to-pointer standard conversion (4.2) is used in place
3785 // of P for type deduction; otherwise,
3786 if (P->isArrayType())
3787 P = Context.getArrayDecayedType(P);
3788 // - If P is a function type, the pointer type produced by the
3789 // function-to-pointer standard conversion (4.3) is used in
3790 // place of P for type deduction; otherwise,
3791 else if (P->isFunctionType())
3792 P = Context.getPointerType(P);
3793 // - If P is a cv-qualified type, the top level cv-qualifiers of
3794 // P's type are ignored for type deduction.
3796 P = P.getUnqualifiedType();
3798 // C++0x [temp.deduct.conv]p4:
3799 // If A is a cv-qualified type, the top level cv-qualifiers of A's
3800 // type are ignored for type deduction. If A is a reference type, the type
3801 // referred to by A is used for type deduction.
3802 A = A.getUnqualifiedType();
3805 // Unevaluated SFINAE context.
3806 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
3807 SFINAETrap Trap(*this);
3809 // C++ [temp.deduct.conv]p1:
3810 // Template argument deduction is done by comparing the return
3811 // type of the template conversion function (call it P) with the
3812 // type that is required as the result of the conversion (call it
3813 // A) as described in 14.8.2.4.
3814 TemplateParameterList *TemplateParams
3815 = ConversionTemplate->getTemplateParameters();
3816 SmallVector<DeducedTemplateArgument, 4> Deduced;
3817 Deduced.resize(TemplateParams->size());
3819 // C++0x [temp.deduct.conv]p4:
3820 // In general, the deduction process attempts to find template
3821 // argument values that will make the deduced A identical to
3822 // A. However, there are two cases that allow a difference:
3824 // - If the original A is a reference type, A can be more
3825 // cv-qualified than the deduced A (i.e., the type referred to
3826 // by the reference)
3827 if (ToType->isReferenceType())
3828 TDF |= TDF_ParamWithReferenceType;
3829 // - The deduced A can be another pointer or pointer to member
3830 // type that can be converted to A via a qualification
3833 // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when
3834 // both P and A are pointers or member pointers. In this case, we
3835 // just ignore cv-qualifiers completely).
3836 if ((P->isPointerType() && A->isPointerType()) ||
3837 (P->isMemberPointerType() && A->isMemberPointerType()))
3838 TDF |= TDF_IgnoreQualifiers;
3839 if (TemplateDeductionResult Result
3840 = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
3841 P, A, Info, Deduced, TDF))
3844 // Create an Instantiation Scope for finalizing the operator.
3845 LocalInstantiationScope InstScope(*this);
3846 // Finish template argument deduction.
3847 FunctionDecl *ConversionSpecialized = 0;
3848 TemplateDeductionResult Result
3849 = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0,
3850 ConversionSpecialized, Info);
3851 Specialization = cast_or_null<CXXConversionDecl>(ConversionSpecialized);
3853 // If the conversion operator is being invoked on a lambda closure to convert
3854 // to a ptr-to-function, use the deduced arguments from the conversion function
3855 // to specialize the corresponding call operator.
3856 // e.g., int (*fp)(int) = [](auto a) { return a; };
3857 if (Result == TDK_Success && isLambdaConversionOperator(ConversionGeneric)) {
3859 // Get the return type of the destination ptr-to-function we are converting
3860 // to. This is necessary for matching the lambda call operator's return
3861 // type to that of the destination ptr-to-function's return type.
3862 assert(A->isPointerType() &&
3863 "Can only convert from lambda to ptr-to-function");
3864 const FunctionType *ToFunType =
3865 A->getPointeeType().getTypePtr()->getAs<FunctionType>();
3866 const QualType DestFunctionPtrReturnType = ToFunType->getResultType();
3868 // Create the corresponding specializations of the call operator and
3869 // the static-invoker; and if the return type is auto,
3870 // deduce the return type and check if it matches the
3871 // DestFunctionPtrReturnType.
3873 // auto L = [](auto a) { return f(a); };
3874 // int (*fp)(int) = L;
3875 // char (*fp2)(int) = L; <-- Not OK.
3877 Result = SpecializeCorrespondingLambdaCallOperatorAndInvoker(
3878 Specialization, Deduced, DestFunctionPtrReturnType,
3884 /// \brief Deduce template arguments for a function template when there is
3885 /// nothing to deduce against (C++0x [temp.arg.explicit]p3).
3887 /// \param FunctionTemplate the function template for which we are performing
3888 /// template argument deduction.
3890 /// \param ExplicitTemplateArgs the explicitly-specified template
3893 /// \param Specialization if template argument deduction was successful,
3894 /// this will be set to the function template specialization produced by
3895 /// template argument deduction.
3897 /// \param Info the argument will be updated to provide additional information
3898 /// about template argument deduction.
3900 /// \returns the result of template argument deduction.
3901 Sema::TemplateDeductionResult
3902 Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
3903 TemplateArgumentListInfo *ExplicitTemplateArgs,
3904 FunctionDecl *&Specialization,
3905 TemplateDeductionInfo &Info,
3906 bool InOverloadResolution) {
3907 return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs,
3908 QualType(), Specialization, Info,
3909 InOverloadResolution);
3913 /// Substitute the 'auto' type specifier within a type for a given replacement
3915 class SubstituteAutoTransform :
3916 public TreeTransform<SubstituteAutoTransform> {
3917 QualType Replacement;
3919 SubstituteAutoTransform(Sema &SemaRef, QualType Replacement) :
3920 TreeTransform<SubstituteAutoTransform>(SemaRef), Replacement(Replacement) {
3922 QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) {
3923 // If we're building the type pattern to deduce against, don't wrap the
3924 // substituted type in an AutoType. Certain template deduction rules
3925 // apply only when a template type parameter appears directly (and not if
3926 // the parameter is found through desugaring). For instance:
3927 // auto &&lref = lvalue;
3928 // must transform into "rvalue reference to T" not "rvalue reference to
3929 // auto type deduced as T" in order for [temp.deduct.call]p3 to apply.
3930 if (!Replacement.isNull() && isa<TemplateTypeParmType>(Replacement)) {
3931 QualType Result = Replacement;
3932 TemplateTypeParmTypeLoc NewTL =
3933 TLB.push<TemplateTypeParmTypeLoc>(Result);
3934 NewTL.setNameLoc(TL.getNameLoc());
3938 !Replacement.isNull() && Replacement->isDependentType();
3940 SemaRef.Context.getAutoType(Dependent ? QualType() : Replacement,
3941 TL.getTypePtr()->isDecltypeAuto(),
3943 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
3944 NewTL.setNameLoc(TL.getNameLoc());
3949 ExprResult TransformLambdaExpr(LambdaExpr *E) {
3950 // Lambdas never need to be transformed.
3954 QualType Apply(TypeLoc TL) {
3955 // Create some scratch storage for the transformed type locations.
3956 // FIXME: We're just going to throw this information away. Don't build it.
3958 TLB.reserve(TL.getFullDataSize());
3959 return TransformType(TLB, TL);
3964 Sema::DeduceAutoResult
3965 Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result) {
3966 return DeduceAutoType(Type->getTypeLoc(), Init, Result);
3969 /// \brief Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
3971 /// \param Type the type pattern using the auto type-specifier.
3972 /// \param Init the initializer for the variable whose type is to be deduced.
3973 /// \param Result if type deduction was successful, this will be set to the
3975 Sema::DeduceAutoResult
3976 Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result) {
3977 if (Init->getType()->isNonOverloadPlaceholderType()) {
3978 ExprResult NonPlaceholder = CheckPlaceholderExpr(Init);
3979 if (NonPlaceholder.isInvalid())
3980 return DAR_FailedAlreadyDiagnosed;
3981 Init = NonPlaceholder.take();
3984 if (Init->isTypeDependent() || Type.getType()->isDependentType()) {
3985 Result = SubstituteAutoTransform(*this, Context.DependentTy).Apply(Type);
3986 assert(!Result.isNull() && "substituting DependentTy can't fail");
3987 return DAR_Succeeded;
3990 // If this is a 'decltype(auto)' specifier, do the decltype dance.
3991 // Since 'decltype(auto)' can only occur at the top of the type, we
3992 // don't need to go digging for it.
3993 if (const AutoType *AT = Type.getType()->getAs<AutoType>()) {
3994 if (AT->isDecltypeAuto()) {
3995 if (isa<InitListExpr>(Init)) {
3996 Diag(Init->getLocStart(), diag::err_decltype_auto_initializer_list);
3997 return DAR_FailedAlreadyDiagnosed;
4000 QualType Deduced = BuildDecltypeType(Init, Init->getLocStart());
4001 // FIXME: Support a non-canonical deduced type for 'auto'.
4002 Deduced = Context.getCanonicalType(Deduced);
4003 Result = SubstituteAutoTransform(*this, Deduced).Apply(Type);
4004 if (Result.isNull())
4005 return DAR_FailedAlreadyDiagnosed;
4006 return DAR_Succeeded;
4010 SourceLocation Loc = Init->getExprLoc();
4012 LocalInstantiationScope InstScope(*this);
4014 // Build template<class TemplParam> void Func(FuncParam);
4015 TemplateTypeParmDecl *TemplParam =
4016 TemplateTypeParmDecl::Create(Context, 0, SourceLocation(), Loc, 0, 0, 0,
4018 QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0);
4019 NamedDecl *TemplParamPtr = TemplParam;
4020 FixedSizeTemplateParameterList<1> TemplateParams(Loc, Loc, &TemplParamPtr,
4023 QualType FuncParam = SubstituteAutoTransform(*this, TemplArg).Apply(Type);
4024 assert(!FuncParam.isNull() &&
4025 "substituting template parameter for 'auto' failed");
4027 // Deduce type of TemplParam in Func(Init)
4028 SmallVector<DeducedTemplateArgument, 1> Deduced;
4030 QualType InitType = Init->getType();
4033 TemplateDeductionInfo Info(Loc);
4035 InitListExpr *InitList = dyn_cast<InitListExpr>(Init);
4037 for (unsigned i = 0, e = InitList->getNumInits(); i < e; ++i) {
4038 if (DeduceTemplateArgumentByListElement(*this, &TemplateParams,
4040 InitList->getInit(i),
4041 Info, Deduced, TDF))
4045 if (AdjustFunctionParmAndArgTypesForDeduction(*this, &TemplateParams,
4046 FuncParam, InitType, Init,
4050 if (DeduceTemplateArgumentsByTypeMatch(*this, &TemplateParams, FuncParam,
4051 InitType, Info, Deduced, TDF))
4055 if (Deduced[0].getKind() != TemplateArgument::Type)
4058 QualType DeducedType = Deduced[0].getAsType();
4061 DeducedType = BuildStdInitializerList(DeducedType, Loc);
4062 if (DeducedType.isNull())
4063 return DAR_FailedAlreadyDiagnosed;
4066 Result = SubstituteAutoTransform(*this, DeducedType).Apply(Type);
4067 if (Result.isNull())
4068 return DAR_FailedAlreadyDiagnosed;
4070 // Check that the deduced argument type is compatible with the original
4071 // argument type per C++ [temp.deduct.call]p4.
4072 if (!InitList && !Result.isNull() &&
4073 CheckOriginalCallArgDeduction(*this,
4074 Sema::OriginalCallArg(FuncParam,0,InitType),
4076 Result = QualType();
4080 return DAR_Succeeded;
4083 QualType Sema::SubstAutoType(QualType TypeWithAuto,
4084 QualType TypeToReplaceAuto) {
4085 return SubstituteAutoTransform(*this, TypeToReplaceAuto).
4086 TransformType(TypeWithAuto);
4089 TypeSourceInfo* Sema::SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
4090 QualType TypeToReplaceAuto) {
4091 return SubstituteAutoTransform(*this, TypeToReplaceAuto).
4092 TransformType(TypeWithAuto);
4095 void Sema::DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init) {
4096 if (isa<InitListExpr>(Init))
4097 Diag(VDecl->getLocation(),
4098 VDecl->isInitCapture()
4099 ? diag::err_init_capture_deduction_failure_from_init_list
4100 : diag::err_auto_var_deduction_failure_from_init_list)
4101 << VDecl->getDeclName() << VDecl->getType() << Init->getSourceRange();
4103 Diag(VDecl->getLocation(),
4104 VDecl->isInitCapture() ? diag::err_init_capture_deduction_failure
4105 : diag::err_auto_var_deduction_failure)
4106 << VDecl->getDeclName() << VDecl->getType() << Init->getType()
4107 << Init->getSourceRange();
4110 bool Sema::DeduceReturnType(FunctionDecl *FD, SourceLocation Loc,
4112 assert(FD->getResultType()->isUndeducedType());
4114 if (FD->getTemplateInstantiationPattern())
4115 InstantiateFunctionDefinition(Loc, FD);
4117 bool StillUndeduced = FD->getResultType()->isUndeducedType();
4118 if (StillUndeduced && Diagnose && !FD->isInvalidDecl()) {
4119 Diag(Loc, diag::err_auto_fn_used_before_defined) << FD;
4120 Diag(FD->getLocation(), diag::note_callee_decl) << FD;
4123 return StillUndeduced;
4127 MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
4130 llvm::SmallBitVector &Deduced);
4132 /// \brief If this is a non-static member function,
4134 AddImplicitObjectParameterType(ASTContext &Context,
4135 CXXMethodDecl *Method,
4136 SmallVectorImpl<QualType> &ArgTypes) {
4137 // C++11 [temp.func.order]p3:
4138 // [...] The new parameter is of type "reference to cv A," where cv are
4139 // the cv-qualifiers of the function template (if any) and A is
4140 // the class of which the function template is a member.
4142 // The standard doesn't say explicitly, but we pick the appropriate kind of
4143 // reference type based on [over.match.funcs]p4.
4144 QualType ArgTy = Context.getTypeDeclType(Method->getParent());
4145 ArgTy = Context.getQualifiedType(ArgTy,
4146 Qualifiers::fromCVRMask(Method->getTypeQualifiers()));
4147 if (Method->getRefQualifier() == RQ_RValue)
4148 ArgTy = Context.getRValueReferenceType(ArgTy);
4150 ArgTy = Context.getLValueReferenceType(ArgTy);
4151 ArgTypes.push_back(ArgTy);
4154 /// \brief Determine whether the function template \p FT1 is at least as
4155 /// specialized as \p FT2.
4156 static bool isAtLeastAsSpecializedAs(Sema &S,
4158 FunctionTemplateDecl *FT1,
4159 FunctionTemplateDecl *FT2,
4160 TemplatePartialOrderingContext TPOC,
4161 unsigned NumCallArguments1,
4162 SmallVectorImpl<RefParamPartialOrderingComparison> *RefParamComparisons) {
4163 FunctionDecl *FD1 = FT1->getTemplatedDecl();
4164 FunctionDecl *FD2 = FT2->getTemplatedDecl();
4165 const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>();
4166 const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>();
4168 assert(Proto1 && Proto2 && "Function templates must have prototypes");
4169 TemplateParameterList *TemplateParams = FT2->getTemplateParameters();
4170 SmallVector<DeducedTemplateArgument, 4> Deduced;
4171 Deduced.resize(TemplateParams->size());
4173 // C++0x [temp.deduct.partial]p3:
4174 // The types used to determine the ordering depend on the context in which
4175 // the partial ordering is done:
4176 TemplateDeductionInfo Info(Loc);
4177 SmallVector<QualType, 4> Args2;
4180 // - In the context of a function call, the function parameter types are
4182 CXXMethodDecl *Method1 = dyn_cast<CXXMethodDecl>(FD1);
4183 CXXMethodDecl *Method2 = dyn_cast<CXXMethodDecl>(FD2);
4185 // C++11 [temp.func.order]p3:
4186 // [...] If only one of the function templates is a non-static
4187 // member, that function template is considered to have a new
4188 // first parameter inserted in its function parameter list. The
4189 // new parameter is of type "reference to cv A," where cv are
4190 // the cv-qualifiers of the function template (if any) and A is
4191 // the class of which the function template is a member.
4193 // Note that we interpret this to mean "if one of the function
4194 // templates is a non-static member and the other is a non-member";
4195 // otherwise, the ordering rules for static functions against non-static
4196 // functions don't make any sense.
4198 // C++98/03 doesn't have this provision, so instead we drop the
4199 // first argument of the free function, which seems to match
4200 // existing practice.
4201 SmallVector<QualType, 4> Args1;
4203 unsigned Skip1 = 0, Skip2 = 0;
4204 unsigned NumComparedArguments = NumCallArguments1;
4206 if (!Method2 && Method1 && !Method1->isStatic()) {
4207 if (S.getLangOpts().CPlusPlus11) {
4208 // Compare 'this' from Method1 against first parameter from Method2.
4209 AddImplicitObjectParameterType(S.Context, Method1, Args1);
4210 ++NumComparedArguments;
4212 // Ignore first parameter from Method2.
4214 } else if (!Method1 && Method2 && !Method2->isStatic()) {
4215 if (S.getLangOpts().CPlusPlus11)
4216 // Compare 'this' from Method2 against first parameter from Method1.
4217 AddImplicitObjectParameterType(S.Context, Method2, Args2);
4219 // Ignore first parameter from Method1.
4223 Args1.insert(Args1.end(),
4224 Proto1->arg_type_begin() + Skip1, Proto1->arg_type_end());
4225 Args2.insert(Args2.end(),
4226 Proto2->arg_type_begin() + Skip2, Proto2->arg_type_end());
4228 // C++ [temp.func.order]p5:
4229 // The presence of unused ellipsis and default arguments has no effect on
4230 // the partial ordering of function templates.
4231 if (Args1.size() > NumComparedArguments)
4232 Args1.resize(NumComparedArguments);
4233 if (Args2.size() > NumComparedArguments)
4234 Args2.resize(NumComparedArguments);
4235 if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(),
4236 Args1.data(), Args1.size(), Info, Deduced,
4237 TDF_None, /*PartialOrdering=*/true,
4238 RefParamComparisons))
4244 case TPOC_Conversion:
4245 // - In the context of a call to a conversion operator, the return types
4246 // of the conversion function templates are used.
4247 if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
4248 Proto2->getResultType(),
4249 Proto1->getResultType(),
4250 Info, Deduced, TDF_None,
4251 /*PartialOrdering=*/true,
4252 RefParamComparisons))
4257 // - In other contexts (14.6.6.2) the function template's function type
4259 if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
4260 FD2->getType(), FD1->getType(),
4261 Info, Deduced, TDF_None,
4262 /*PartialOrdering=*/true,
4263 RefParamComparisons))
4268 // C++0x [temp.deduct.partial]p11:
4269 // In most cases, all template parameters must have values in order for
4270 // deduction to succeed, but for partial ordering purposes a template
4271 // parameter may remain without a value provided it is not used in the
4272 // types being used for partial ordering. [ Note: a template parameter used
4273 // in a non-deduced context is considered used. -end note]
4274 unsigned ArgIdx = 0, NumArgs = Deduced.size();
4275 for (; ArgIdx != NumArgs; ++ArgIdx)
4276 if (Deduced[ArgIdx].isNull())
4279 if (ArgIdx == NumArgs) {
4280 // All template arguments were deduced. FT1 is at least as specialized
4285 // Figure out which template parameters were used.
4286 llvm::SmallBitVector UsedParameters(TemplateParams->size());
4289 for (unsigned I = 0, N = Args2.size(); I != N; ++I)
4290 ::MarkUsedTemplateParameters(S.Context, Args2[I], false,
4291 TemplateParams->getDepth(),
4295 case TPOC_Conversion:
4296 ::MarkUsedTemplateParameters(S.Context, Proto2->getResultType(), false,
4297 TemplateParams->getDepth(),
4302 ::MarkUsedTemplateParameters(S.Context, FD2->getType(), false,
4303 TemplateParams->getDepth(),
4308 for (; ArgIdx != NumArgs; ++ArgIdx)
4309 // If this argument had no value deduced but was used in one of the types
4310 // used for partial ordering, then deduction fails.
4311 if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx])
4317 /// \brief Determine whether this a function template whose parameter-type-list
4318 /// ends with a function parameter pack.
4319 static bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) {
4320 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
4321 unsigned NumParams = Function->getNumParams();
4325 ParmVarDecl *Last = Function->getParamDecl(NumParams - 1);
4326 if (!Last->isParameterPack())
4329 // Make sure that no previous parameter is a parameter pack.
4330 while (--NumParams > 0) {
4331 if (Function->getParamDecl(NumParams - 1)->isParameterPack())
4338 /// \brief Returns the more specialized function template according
4339 /// to the rules of function template partial ordering (C++ [temp.func.order]).
4341 /// \param FT1 the first function template
4343 /// \param FT2 the second function template
4345 /// \param TPOC the context in which we are performing partial ordering of
4346 /// function templates.
4348 /// \param NumCallArguments1 The number of arguments in the call to FT1, used
4349 /// only when \c TPOC is \c TPOC_Call.
4351 /// \param NumCallArguments2 The number of arguments in the call to FT2, used
4352 /// only when \c TPOC is \c TPOC_Call.
4354 /// \returns the more specialized function template. If neither
4355 /// template is more specialized, returns NULL.
4356 FunctionTemplateDecl *
4357 Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,
4358 FunctionTemplateDecl *FT2,
4360 TemplatePartialOrderingContext TPOC,
4361 unsigned NumCallArguments1,
4362 unsigned NumCallArguments2) {
4363 SmallVector<RefParamPartialOrderingComparison, 4> RefParamComparisons;
4364 bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC,
4365 NumCallArguments1, 0);
4366 bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC,
4368 &RefParamComparisons);
4370 if (Better1 != Better2) // We have a clear winner
4371 return Better1? FT1 : FT2;
4373 if (!Better1 && !Better2) // Neither is better than the other
4376 // C++0x [temp.deduct.partial]p10:
4377 // If for each type being considered a given template is at least as
4378 // specialized for all types and more specialized for some set of types and
4379 // the other template is not more specialized for any types or is not at
4380 // least as specialized for any types, then the given template is more
4381 // specialized than the other template. Otherwise, neither template is more
4382 // specialized than the other.
4385 for (unsigned I = 0, N = RefParamComparisons.size(); I != N; ++I) {
4386 // C++0x [temp.deduct.partial]p9:
4387 // If, for a given type, deduction succeeds in both directions (i.e., the
4388 // types are identical after the transformations above) and both P and A
4389 // were reference types (before being replaced with the type referred to
4392 // -- if the type from the argument template was an lvalue reference
4393 // and the type from the parameter template was not, the argument
4394 // type is considered to be more specialized than the other;
4396 if (!RefParamComparisons[I].ArgIsRvalueRef &&
4397 RefParamComparisons[I].ParamIsRvalueRef) {
4402 } else if (!RefParamComparisons[I].ParamIsRvalueRef &&
4403 RefParamComparisons[I].ArgIsRvalueRef) {
4410 // -- if the type from the argument template is more cv-qualified than
4411 // the type from the parameter template (as described above), the
4412 // argument type is considered to be more specialized than the
4413 // other; otherwise,
4414 switch (RefParamComparisons[I].Qualifiers) {
4415 case NeitherMoreQualified:
4418 case ParamMoreQualified:
4424 case ArgMoreQualified:
4431 // -- neither type is more specialized than the other.
4434 assert(!(Better1 && Better2) && "Should have broken out in the loop above");
4440 // FIXME: This mimics what GCC implements, but doesn't match up with the
4441 // proposed resolution for core issue 692. This area needs to be sorted out,
4442 // but for now we attempt to maintain compatibility.
4443 bool Variadic1 = isVariadicFunctionTemplate(FT1);
4444 bool Variadic2 = isVariadicFunctionTemplate(FT2);
4445 if (Variadic1 != Variadic2)
4446 return Variadic1? FT2 : FT1;
4451 /// \brief Determine if the two templates are equivalent.
4452 static bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) {
4459 return T1->getCanonicalDecl() == T2->getCanonicalDecl();
4462 /// \brief Retrieve the most specialized of the given function template
4463 /// specializations.
4465 /// \param SpecBegin the start iterator of the function template
4466 /// specializations that we will be comparing.
4468 /// \param SpecEnd the end iterator of the function template
4469 /// specializations, paired with \p SpecBegin.
4471 /// \param Loc the location where the ambiguity or no-specializations
4472 /// diagnostic should occur.
4474 /// \param NoneDiag partial diagnostic used to diagnose cases where there are
4475 /// no matching candidates.
4477 /// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one
4480 /// \param CandidateDiag partial diagnostic used for each function template
4481 /// specialization that is a candidate in the ambiguous ordering. One parameter
4482 /// in this diagnostic should be unbound, which will correspond to the string
4483 /// describing the template arguments for the function template specialization.
4485 /// \returns the most specialized function template specialization, if
4486 /// found. Otherwise, returns SpecEnd.
4487 UnresolvedSetIterator Sema::getMostSpecialized(
4488 UnresolvedSetIterator SpecBegin, UnresolvedSetIterator SpecEnd,
4489 TemplateSpecCandidateSet &FailedCandidates,
4490 SourceLocation Loc, const PartialDiagnostic &NoneDiag,
4491 const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag,
4492 bool Complain, QualType TargetType) {
4493 if (SpecBegin == SpecEnd) {
4495 Diag(Loc, NoneDiag);
4496 FailedCandidates.NoteCandidates(*this, Loc);
4501 if (SpecBegin + 1 == SpecEnd)
4504 // Find the function template that is better than all of the templates it
4505 // has been compared to.
4506 UnresolvedSetIterator Best = SpecBegin;
4507 FunctionTemplateDecl *BestTemplate
4508 = cast<FunctionDecl>(*Best)->getPrimaryTemplate();
4509 assert(BestTemplate && "Not a function template specialization?");
4510 for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) {
4511 FunctionTemplateDecl *Challenger
4512 = cast<FunctionDecl>(*I)->getPrimaryTemplate();
4513 assert(Challenger && "Not a function template specialization?");
4514 if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
4515 Loc, TPOC_Other, 0, 0),
4518 BestTemplate = Challenger;
4522 // Make sure that the "best" function template is more specialized than all
4524 bool Ambiguous = false;
4525 for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
4526 FunctionTemplateDecl *Challenger
4527 = cast<FunctionDecl>(*I)->getPrimaryTemplate();
4529 !isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
4530 Loc, TPOC_Other, 0, 0),
4538 // We found an answer. Return it.
4542 // Diagnose the ambiguity.
4544 Diag(Loc, AmbigDiag);
4546 // FIXME: Can we order the candidates in some sane way?
4547 for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
4548 PartialDiagnostic PD = CandidateDiag;
4549 PD << getTemplateArgumentBindingsText(
4550 cast<FunctionDecl>(*I)->getPrimaryTemplate()->getTemplateParameters(),
4551 *cast<FunctionDecl>(*I)->getTemplateSpecializationArgs());
4552 if (!TargetType.isNull())
4553 HandleFunctionTypeMismatch(PD, cast<FunctionDecl>(*I)->getType(),
4555 Diag((*I)->getLocation(), PD);
4562 /// \brief Returns the more specialized class template partial specialization
4563 /// according to the rules of partial ordering of class template partial
4564 /// specializations (C++ [temp.class.order]).
4566 /// \param PS1 the first class template partial specialization
4568 /// \param PS2 the second class template partial specialization
4570 /// \returns the more specialized class template partial specialization. If
4571 /// neither partial specialization is more specialized, returns NULL.
4572 ClassTemplatePartialSpecializationDecl *
4573 Sema::getMoreSpecializedPartialSpecialization(
4574 ClassTemplatePartialSpecializationDecl *PS1,
4575 ClassTemplatePartialSpecializationDecl *PS2,
4576 SourceLocation Loc) {
4577 // C++ [temp.class.order]p1:
4578 // For two class template partial specializations, the first is at least as
4579 // specialized as the second if, given the following rewrite to two
4580 // function templates, the first function template is at least as
4581 // specialized as the second according to the ordering rules for function
4582 // templates (14.6.6.2):
4583 // - the first function template has the same template parameters as the
4584 // first partial specialization and has a single function parameter
4585 // whose type is a class template specialization with the template
4586 // arguments of the first partial specialization, and
4587 // - the second function template has the same template parameters as the
4588 // second partial specialization and has a single function parameter
4589 // whose type is a class template specialization with the template
4590 // arguments of the second partial specialization.
4592 // Rather than synthesize function templates, we merely perform the
4593 // equivalent partial ordering by performing deduction directly on
4594 // the template arguments of the class template partial
4595 // specializations. This computation is slightly simpler than the
4596 // general problem of function template partial ordering, because
4597 // class template partial specializations are more constrained. We
4598 // know that every template parameter is deducible from the class
4599 // template partial specialization's template arguments, for
4601 SmallVector<DeducedTemplateArgument, 4> Deduced;
4602 TemplateDeductionInfo Info(Loc);
4604 QualType PT1 = PS1->getInjectedSpecializationType();
4605 QualType PT2 = PS2->getInjectedSpecializationType();
4607 // Determine whether PS1 is at least as specialized as PS2
4608 Deduced.resize(PS2->getTemplateParameters()->size());
4609 bool Better1 = !DeduceTemplateArgumentsByTypeMatch(*this,
4610 PS2->getTemplateParameters(),
4611 PT2, PT1, Info, Deduced, TDF_None,
4612 /*PartialOrdering=*/true,
4613 /*RefParamComparisons=*/0);
4615 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
4616 InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2, DeducedArgs,
4618 Better1 = !::FinishTemplateArgumentDeduction(
4619 *this, PS2, PS1->getTemplateArgs(), Deduced, Info);
4622 // Determine whether PS2 is at least as specialized as PS1
4624 Deduced.resize(PS1->getTemplateParameters()->size());
4625 bool Better2 = !DeduceTemplateArgumentsByTypeMatch(
4626 *this, PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None,
4627 /*PartialOrdering=*/true,
4628 /*RefParamComparisons=*/0);
4630 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
4632 InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1, DeducedArgs,
4634 Better2 = !::FinishTemplateArgumentDeduction(
4635 *this, PS1, PS2->getTemplateArgs(), Deduced, Info);
4638 if (Better1 == Better2)
4641 return Better1 ? PS1 : PS2;
4644 /// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
4645 /// May require unifying ClassTemplate(Partial)SpecializationDecl and
4646 /// VarTemplate(Partial)SpecializationDecl with a new data
4647 /// structure Template(Partial)SpecializationDecl, and
4648 /// using Template(Partial)SpecializationDecl as input type.
4649 VarTemplatePartialSpecializationDecl *
4650 Sema::getMoreSpecializedPartialSpecialization(
4651 VarTemplatePartialSpecializationDecl *PS1,
4652 VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) {
4653 SmallVector<DeducedTemplateArgument, 4> Deduced;
4654 TemplateDeductionInfo Info(Loc);
4656 assert(PS1->getSpecializedTemplate() == PS1->getSpecializedTemplate() &&
4657 "the partial specializations being compared should specialize"
4658 " the same template.");
4659 TemplateName Name(PS1->getSpecializedTemplate());
4660 TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
4661 QualType PT1 = Context.getTemplateSpecializationType(
4662 CanonTemplate, PS1->getTemplateArgs().data(),
4663 PS1->getTemplateArgs().size());
4664 QualType PT2 = Context.getTemplateSpecializationType(
4665 CanonTemplate, PS2->getTemplateArgs().data(),
4666 PS2->getTemplateArgs().size());
4668 // Determine whether PS1 is at least as specialized as PS2
4669 Deduced.resize(PS2->getTemplateParameters()->size());
4670 bool Better1 = !DeduceTemplateArgumentsByTypeMatch(
4671 *this, PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None,
4672 /*PartialOrdering=*/true,
4673 /*RefParamComparisons=*/0);
4675 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
4677 InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2,
4679 Better1 = !::FinishTemplateArgumentDeduction(*this, PS2,
4680 PS1->getTemplateArgs(),
4684 // Determine whether PS2 is at least as specialized as PS1
4686 Deduced.resize(PS1->getTemplateParameters()->size());
4687 bool Better2 = !DeduceTemplateArgumentsByTypeMatch(*this,
4688 PS1->getTemplateParameters(),
4689 PT1, PT2, Info, Deduced, TDF_None,
4690 /*PartialOrdering=*/true,
4691 /*RefParamComparisons=*/0);
4693 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
4694 InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1,
4696 Better2 = !::FinishTemplateArgumentDeduction(*this, PS1,
4697 PS2->getTemplateArgs(),
4701 if (Better1 == Better2)
4704 return Better1? PS1 : PS2;
4708 MarkUsedTemplateParameters(ASTContext &Ctx,
4709 const TemplateArgument &TemplateArg,
4712 llvm::SmallBitVector &Used);
4714 /// \brief Mark the template parameters that are used by the given
4717 MarkUsedTemplateParameters(ASTContext &Ctx,
4721 llvm::SmallBitVector &Used) {
4722 // We can deduce from a pack expansion.
4723 if (const PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(E))
4724 E = Expansion->getPattern();
4726 // Skip through any implicit casts we added while type-checking, and any
4727 // substitutions performed by template alias expansion.
4729 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
4730 E = ICE->getSubExpr();
4731 else if (const SubstNonTypeTemplateParmExpr *Subst =
4732 dyn_cast<SubstNonTypeTemplateParmExpr>(E))
4733 E = Subst->getReplacement();
4738 // FIXME: if !OnlyDeduced, we have to walk the whole subexpression to
4739 // find other occurrences of template parameters.
4740 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
4744 const NonTypeTemplateParmDecl *NTTP
4745 = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
4749 if (NTTP->getDepth() == Depth)
4750 Used[NTTP->getIndex()] = true;
4753 /// \brief Mark the template parameters that are used by the given
4754 /// nested name specifier.
4756 MarkUsedTemplateParameters(ASTContext &Ctx,
4757 NestedNameSpecifier *NNS,
4760 llvm::SmallBitVector &Used) {
4764 MarkUsedTemplateParameters(Ctx, NNS->getPrefix(), OnlyDeduced, Depth,
4766 MarkUsedTemplateParameters(Ctx, QualType(NNS->getAsType(), 0),
4767 OnlyDeduced, Depth, Used);
4770 /// \brief Mark the template parameters that are used by the given
4773 MarkUsedTemplateParameters(ASTContext &Ctx,
4777 llvm::SmallBitVector &Used) {
4778 if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
4779 if (TemplateTemplateParmDecl *TTP
4780 = dyn_cast<TemplateTemplateParmDecl>(Template)) {
4781 if (TTP->getDepth() == Depth)
4782 Used[TTP->getIndex()] = true;
4787 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName())
4788 MarkUsedTemplateParameters(Ctx, QTN->getQualifier(), OnlyDeduced,
4790 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName())
4791 MarkUsedTemplateParameters(Ctx, DTN->getQualifier(), OnlyDeduced,
4795 /// \brief Mark the template parameters that are used by the given
4798 MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
4801 llvm::SmallBitVector &Used) {
4805 // Non-dependent types have nothing deducible
4806 if (!T->isDependentType())
4809 T = Ctx.getCanonicalType(T);
4810 switch (T->getTypeClass()) {
4812 MarkUsedTemplateParameters(Ctx,
4813 cast<PointerType>(T)->getPointeeType(),
4819 case Type::BlockPointer:
4820 MarkUsedTemplateParameters(Ctx,
4821 cast<BlockPointerType>(T)->getPointeeType(),
4827 case Type::LValueReference:
4828 case Type::RValueReference:
4829 MarkUsedTemplateParameters(Ctx,
4830 cast<ReferenceType>(T)->getPointeeType(),
4836 case Type::MemberPointer: {
4837 const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr());
4838 MarkUsedTemplateParameters(Ctx, MemPtr->getPointeeType(), OnlyDeduced,
4840 MarkUsedTemplateParameters(Ctx, QualType(MemPtr->getClass(), 0),
4841 OnlyDeduced, Depth, Used);
4845 case Type::DependentSizedArray:
4846 MarkUsedTemplateParameters(Ctx,
4847 cast<DependentSizedArrayType>(T)->getSizeExpr(),
4848 OnlyDeduced, Depth, Used);
4849 // Fall through to check the element type
4851 case Type::ConstantArray:
4852 case Type::IncompleteArray:
4853 MarkUsedTemplateParameters(Ctx,
4854 cast<ArrayType>(T)->getElementType(),
4855 OnlyDeduced, Depth, Used);
4859 case Type::ExtVector:
4860 MarkUsedTemplateParameters(Ctx,
4861 cast<VectorType>(T)->getElementType(),
4862 OnlyDeduced, Depth, Used);
4865 case Type::DependentSizedExtVector: {
4866 const DependentSizedExtVectorType *VecType
4867 = cast<DependentSizedExtVectorType>(T);
4868 MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced,
4870 MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced,
4875 case Type::FunctionProto: {
4876 const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
4877 MarkUsedTemplateParameters(Ctx, Proto->getResultType(), OnlyDeduced,
4879 for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I)
4880 MarkUsedTemplateParameters(Ctx, Proto->getArgType(I), OnlyDeduced,
4885 case Type::TemplateTypeParm: {
4886 const TemplateTypeParmType *TTP = cast<TemplateTypeParmType>(T);
4887 if (TTP->getDepth() == Depth)
4888 Used[TTP->getIndex()] = true;
4892 case Type::SubstTemplateTypeParmPack: {
4893 const SubstTemplateTypeParmPackType *Subst
4894 = cast<SubstTemplateTypeParmPackType>(T);
4895 MarkUsedTemplateParameters(Ctx,
4896 QualType(Subst->getReplacedParameter(), 0),
4897 OnlyDeduced, Depth, Used);
4898 MarkUsedTemplateParameters(Ctx, Subst->getArgumentPack(),
4899 OnlyDeduced, Depth, Used);
4903 case Type::InjectedClassName:
4904 T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType();
4907 case Type::TemplateSpecialization: {
4908 const TemplateSpecializationType *Spec
4909 = cast<TemplateSpecializationType>(T);
4910 MarkUsedTemplateParameters(Ctx, Spec->getTemplateName(), OnlyDeduced,
4913 // C++0x [temp.deduct.type]p9:
4914 // If the template argument list of P contains a pack expansion that is not
4915 // the last template argument, the entire template argument list is a
4916 // non-deduced context.
4918 hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs()))
4921 for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
4922 MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth,
4929 MarkUsedTemplateParameters(Ctx,
4930 cast<ComplexType>(T)->getElementType(),
4931 OnlyDeduced, Depth, Used);
4936 MarkUsedTemplateParameters(Ctx,
4937 cast<AtomicType>(T)->getValueType(),
4938 OnlyDeduced, Depth, Used);
4941 case Type::DependentName:
4943 MarkUsedTemplateParameters(Ctx,
4944 cast<DependentNameType>(T)->getQualifier(),
4945 OnlyDeduced, Depth, Used);
4948 case Type::DependentTemplateSpecialization: {
4949 const DependentTemplateSpecializationType *Spec
4950 = cast<DependentTemplateSpecializationType>(T);
4952 MarkUsedTemplateParameters(Ctx, Spec->getQualifier(),
4953 OnlyDeduced, Depth, Used);
4955 // C++0x [temp.deduct.type]p9:
4956 // If the template argument list of P contains a pack expansion that is not
4957 // the last template argument, the entire template argument list is a
4958 // non-deduced context.
4960 hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs()))
4963 for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
4964 MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth,
4971 MarkUsedTemplateParameters(Ctx,
4972 cast<TypeOfType>(T)->getUnderlyingType(),
4973 OnlyDeduced, Depth, Used);
4976 case Type::TypeOfExpr:
4978 MarkUsedTemplateParameters(Ctx,
4979 cast<TypeOfExprType>(T)->getUnderlyingExpr(),
4980 OnlyDeduced, Depth, Used);
4983 case Type::Decltype:
4985 MarkUsedTemplateParameters(Ctx,
4986 cast<DecltypeType>(T)->getUnderlyingExpr(),
4987 OnlyDeduced, Depth, Used);
4990 case Type::UnaryTransform:
4992 MarkUsedTemplateParameters(Ctx,
4993 cast<UnaryTransformType>(T)->getUnderlyingType(),
4994 OnlyDeduced, Depth, Used);
4997 case Type::PackExpansion:
4998 MarkUsedTemplateParameters(Ctx,
4999 cast<PackExpansionType>(T)->getPattern(),
5000 OnlyDeduced, Depth, Used);
5004 MarkUsedTemplateParameters(Ctx,
5005 cast<AutoType>(T)->getDeducedType(),
5006 OnlyDeduced, Depth, Used);
5008 // None of these types have any template parameters in them.
5010 case Type::VariableArray:
5011 case Type::FunctionNoProto:
5014 case Type::ObjCInterface:
5015 case Type::ObjCObject:
5016 case Type::ObjCObjectPointer:
5017 case Type::UnresolvedUsing:
5018 #define TYPE(Class, Base)
5019 #define ABSTRACT_TYPE(Class, Base)
5020 #define DEPENDENT_TYPE(Class, Base)
5021 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
5022 #include "clang/AST/TypeNodes.def"
5027 /// \brief Mark the template parameters that are used by this
5028 /// template argument.
5030 MarkUsedTemplateParameters(ASTContext &Ctx,
5031 const TemplateArgument &TemplateArg,
5034 llvm::SmallBitVector &Used) {
5035 switch (TemplateArg.getKind()) {
5036 case TemplateArgument::Null:
5037 case TemplateArgument::Integral:
5038 case TemplateArgument::Declaration:
5041 case TemplateArgument::NullPtr:
5042 MarkUsedTemplateParameters(Ctx, TemplateArg.getNullPtrType(), OnlyDeduced,
5046 case TemplateArgument::Type:
5047 MarkUsedTemplateParameters(Ctx, TemplateArg.getAsType(), OnlyDeduced,
5051 case TemplateArgument::Template:
5052 case TemplateArgument::TemplateExpansion:
5053 MarkUsedTemplateParameters(Ctx,
5054 TemplateArg.getAsTemplateOrTemplatePattern(),
5055 OnlyDeduced, Depth, Used);
5058 case TemplateArgument::Expression:
5059 MarkUsedTemplateParameters(Ctx, TemplateArg.getAsExpr(), OnlyDeduced,
5063 case TemplateArgument::Pack:
5064 for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(),
5065 PEnd = TemplateArg.pack_end();
5067 MarkUsedTemplateParameters(Ctx, *P, OnlyDeduced, Depth, Used);
5072 /// \brief Mark which template parameters can be deduced from a given
5073 /// template argument list.
5075 /// \param TemplateArgs the template argument list from which template
5076 /// parameters will be deduced.
5078 /// \param Used a bit vector whose elements will be set to \c true
5079 /// to indicate when the corresponding template parameter will be
5082 Sema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
5083 bool OnlyDeduced, unsigned Depth,
5084 llvm::SmallBitVector &Used) {
5085 // C++0x [temp.deduct.type]p9:
5086 // If the template argument list of P contains a pack expansion that is not
5087 // the last template argument, the entire template argument list is a
5088 // non-deduced context.
5090 hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size()))
5093 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
5094 ::MarkUsedTemplateParameters(Context, TemplateArgs[I], OnlyDeduced,
5098 /// \brief Marks all of the template parameters that will be deduced by a
5099 /// call to the given function template.
5101 Sema::MarkDeducedTemplateParameters(ASTContext &Ctx,
5102 const FunctionTemplateDecl *FunctionTemplate,
5103 llvm::SmallBitVector &Deduced) {
5104 TemplateParameterList *TemplateParams
5105 = FunctionTemplate->getTemplateParameters();
5107 Deduced.resize(TemplateParams->size());
5109 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
5110 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I)
5111 ::MarkUsedTemplateParameters(Ctx, Function->getParamDecl(I)->getType(),
5112 true, TemplateParams->getDepth(), Deduced);
5115 bool hasDeducibleTemplateParameters(Sema &S,
5116 FunctionTemplateDecl *FunctionTemplate,
5118 if (!T->isDependentType())
5121 TemplateParameterList *TemplateParams
5122 = FunctionTemplate->getTemplateParameters();
5123 llvm::SmallBitVector Deduced(TemplateParams->size());
5124 ::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(),
5127 return Deduced.any();