SemaTemplateDeduction.cpp revision 62c28c831bbf207cc36e683e7c321fc33bf8928c
10b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor//===------- SemaTemplateDeduction.cpp - Template Argument Deduction ------===/ 20b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// 30b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// The LLVM Compiler Infrastructure 40b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// 50b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// This file is distributed under the University of Illinois Open Source 60b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// License. See LICENSE.TXT for details. 70b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor//===----------------------------------------------------------------------===/ 80b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// 90b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// This file implements C++ template argument deduction. 100b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor// 110b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor//===----------------------------------------------------------------------===/ 120b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 13e737f5041a36d0befb39ffeed8d50ba15916d3daDouglas Gregor#include "clang/Sema/Sema.h" 1419510856727e0e14a3696b2a72c35163bff2a71fJohn McCall#include "clang/Sema/DeclSpec.h" 1520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor#include "clang/Sema/SemaDiagnostic.h" // FIXME: temporary! 167cd088e519d7e6caa4c4c12db52e0e4ae35d25c2John McCall#include "clang/Sema/Template.h" 172a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall#include "clang/Sema/TemplateDeduction.h" 180b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/ASTContext.h" 197cd088e519d7e6caa4c4c12db52e0e4ae35d25c2John McCall#include "clang/AST/DeclObjC.h" 200b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/DeclTemplate.h" 210b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/StmtVisitor.h" 220b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/Expr.h" 230b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/ExprCXX.h" 24e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor#include "llvm/ADT/BitVector.h" 258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor#include <algorithm> 26508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor 27508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregornamespace clang { 282a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall using namespace sema; 292a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall 30508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Various flags that control template argument deduction. 31508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// 32508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// These flags can be bitwise-OR'd together. 33508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor enum TemplateDeductionFlags { 34508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief No template argument deduction flags, which indicates the 35508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// strictest results for template argument deduction (as used for, e.g., 36508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// matching class template partial specializations). 37508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF_None = 0, 38508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Within template argument deduction from a function call, we are 39508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// matching with a parameter type for which the original parameter was 40508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// a reference. 41508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF_ParamWithReferenceType = 0x1, 42508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Within template argument deduction from a function call, we 43508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// are matching in a case where we ignore cv-qualifiers. 44508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF_IgnoreQualifiers = 0x02, 45508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// \brief Within template argument deduction from a function call, 46508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor /// we are matching in a case where we can perform template argument 474112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor /// deduction from a template-id of a derived class of the argument type. 481282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor TDF_DerivedClass = 0x04, 491282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor /// \brief Allow non-dependent types to differ, e.g., when performing 501282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor /// template argument deduction from a function call where conversions 511282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor /// may apply. 521282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor TDF_SkipNonDependent = 0x08 53508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor }; 54508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor} 55508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor 560b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregorusing namespace clang; 570b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 589d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor/// \brief Compare two APSInts, extending and switching the sign as 599d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor/// necessary to compare their values regardless of underlying type. 609d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregorstatic bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) { 619d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if (Y.getBitWidth() > X.getBitWidth()) 629f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad X = X.extend(Y.getBitWidth()); 639d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor else if (Y.getBitWidth() < X.getBitWidth()) 649f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad Y = Y.extend(X.getBitWidth()); 659d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 669d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor // If there is a signedness mismatch, correct it. 679d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if (X.isSigned() != Y.isSigned()) { 689d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor // If the signed value is negative, then the values cannot be the same. 699d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if ((Y.isSigned() && Y.isNegative()) || (X.isSigned() && X.isNegative())) 709d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor return false; 719d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 729d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor Y.setIsSigned(true); 739d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor X.setIsSigned(true); 749d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor } 759d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 769d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor return X == Y; 779d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor} 789d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 79f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 80a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 81f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 82f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor const TemplateArgument &Param, 8377d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor TemplateArgument Arg, 842a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 850972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced); 86d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 875c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \brief Stores the result of comparing the qualifiers of two types, used 885c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// when 895c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregorenum DeductionQualifierComparison { 905c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor NeitherMoreQualified = 0, 915c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor ParamMoreQualified, 925c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor ArgMoreQualified 935c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor}; 945c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 955c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 9620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregorstatic Sema::TemplateDeductionResult 9720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas GregorDeduceTemplateArguments(Sema &S, 9820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateParameterList *TemplateParams, 99603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor QualType Param, 100603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor QualType Arg, 101603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateDeductionInfo &Info, 102603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 1035c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned TDF, 1045c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor bool PartialOrdering = false, 1055c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor llvm::SmallVectorImpl<DeductionQualifierComparison> * 1065c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor QualifierComparisons = 0); 107603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 108603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic Sema::TemplateDeductionResult 109603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas GregorDeduceTemplateArguments(Sema &S, 110603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateParameterList *TemplateParams, 11120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Params, unsigned NumParams, 11220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Args, unsigned NumArgs, 11320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateDeductionInfo &Info, 1140972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 1150972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor bool NumberOfArgumentsMustMatch = true); 11620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 117199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \brief If the given expression is of a form that permits the deduction 118199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// of a non-type template parameter, return the declaration of that 119199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// non-type template parameter. 120199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregorstatic NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) { 121199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E)) 122199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor E = IC->getSubExpr(); 1231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 124199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 125199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()); 1261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 127199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return 0; 128199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 129199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1300d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \brief Determine whether two declaration pointers refer to the same 1310d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// declaration. 1320d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregorstatic bool isSameDeclaration(Decl *X, Decl *Y) { 1330d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (!X || !Y) 1340d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return !X && !Y; 1350d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1360d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (NamedDecl *NX = dyn_cast<NamedDecl>(X)) 1370d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X = NX->getUnderlyingDecl(); 1380d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (NamedDecl *NY = dyn_cast<NamedDecl>(Y)) 1390d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y = NY->getUnderlyingDecl(); 1400d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1410d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X->getCanonicalDecl() == Y->getCanonicalDecl(); 1420d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor} 1430d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1440d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \brief Verify that the given, deduced template arguments are compatible. 1450d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// 1460d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \returns The deduced template argument, or a NULL template argument if 1470d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// the deduced template arguments were incompatible. 1480d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregorstatic DeducedTemplateArgument 1490d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas GregorcheckDeducedTemplateArguments(ASTContext &Context, 1500d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor const DeducedTemplateArgument &X, 1510d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor const DeducedTemplateArgument &Y) { 1520d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // We have no deduction for one or both of the arguments; they're compatible. 1530d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (X.isNull()) 1540d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Y; 1550d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.isNull()) 1560d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 1570d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1580d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor switch (X.getKind()) { 1590d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Null: 1600d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor llvm_unreachable("Non-deduced template arguments handled above"); 1610d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1620d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Type: 1630d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If two template type arguments have the same type, they're compatible. 1640d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Type && 1650d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Context.hasSameType(X.getAsType(), Y.getAsType())) 1660d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 1670d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1680d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 1690d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1700d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Integral: 1710d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a constant in one case and either a dependent expression or 1720d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // declaration in another case, keep the integral constant. 1730d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If both are integral constants with the same value, keep that value. 1740d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression || 1750d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getKind() == TemplateArgument::Declaration || 1760d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor (Y.getKind() == TemplateArgument::Integral && 1770d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor hasSameExtendedValue(*X.getAsIntegral(), *Y.getAsIntegral()))) 1780d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(X, 1790d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.wasDeducedFromArrayBound() && 1800d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.wasDeducedFromArrayBound()); 1810d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1820d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 1830d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 1840d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1850d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Template: 1860d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Template && 1870d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate())) 1880d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 1890d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1900d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 1910d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 192a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 193a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 194a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor if (Y.getKind() == TemplateArgument::TemplateExpansion && 195a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(), 196a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Y.getAsTemplateOrTemplatePattern())) 197a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return X; 198a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 199a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor // All other combinations are incompatible. 200a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return DeducedTemplateArgument(); 201a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 2020d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Expression: 2030d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a dependent expression in one case and either an integral 2040d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // constant or a declaration in another case, keep the integral constant 2050d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // or declaration. 2060d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Integral || 2070d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getKind() == TemplateArgument::Declaration) 2080d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() && 2090d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.wasDeducedFromArrayBound()); 2100d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2110d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression) { 2120d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // Compare the expressions for equality 2130d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor llvm::FoldingSetNodeID ID1, ID2; 2140d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.getAsExpr()->Profile(ID1, Context, true); 2150d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getAsExpr()->Profile(ID2, Context, true); 2160d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (ID1 == ID2) 2170d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 2180d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 2190d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2200d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 2210d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 2220d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2230d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Declaration: 2240d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a declaration and a dependent expression, keep the 2250d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // declaration. 2260d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression) 2270d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 2280d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2290d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a declaration and an integral constant, keep the 2300d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // integral constant. 2310d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Integral) 2320d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Y; 2330d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2340d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced two declarations, make sure they they refer to the 2350d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // same declaration. 2360d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Declaration && 2370d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor isSameDeclaration(X.getAsDecl(), Y.getAsDecl())) 2380d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 2390d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2400d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 2410d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 2420d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2430d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Pack: 2440d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() != TemplateArgument::Pack || 2450d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.pack_size() != Y.pack_size()) 2460d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 2470d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2480d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor for (TemplateArgument::pack_iterator XA = X.pack_begin(), 2490d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor XAEnd = X.pack_end(), 2500d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor YA = Y.pack_begin(); 2510d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor XA != XAEnd; ++XA, ++YA) { 252135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor if (checkDeducedTemplateArguments(Context, 253135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()), 254135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound())) 255135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor .isNull()) 2560d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 2570d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 2580d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2590d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 2600d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 2610d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2620d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 2630d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor} 2640d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the value of the given non-type template parameter 266199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// from the given constant. 267f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 268a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 2691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NonTypeTemplateParmDecl *NTTP, 2709d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor llvm::APSInt Value, QualType ValueType, 27102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor bool DeducedFromArrayBound, 2722a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 27302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 2741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 275199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument with depth > 0"); 2761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2770d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(Value, ValueType, DeducedFromArrayBound); 2780d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 2790d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()], 2800d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 2810d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 282f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = NTTP; 283f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 2840d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 2850d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Inconsistent; 286f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 2870d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2880d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 289f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 290199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 291199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 2921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the value of the given non-type template parameter 293199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// from the given type- or value-dependent expression. 294199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// 295199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \returns true if deduction succeeded, false otherwise. 296f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 297a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 298f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor NonTypeTemplateParmDecl *NTTP, 299f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Expr *Value, 3002a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 30102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 3021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 303199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument with depth > 0"); 304199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert((Value->isTypeDependent() || Value->isValueDependent()) && 305199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Expression template argument must be type- or value-dependent."); 3061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3070d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(Value); 3080d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 3090d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()], 3100d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 3110d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 3120d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 3130d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = NTTP; 3140d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 3150d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 3160d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Inconsistent; 3179eea08ba72f8b1e7faf38e43376b9157fc4a2af2Douglas Gregor } 3180d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 3190d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 320f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 321199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 322199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 32315755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// \brief Deduce the value of the given non-type template parameter 32415755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// from the given declaration. 32515755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// 32615755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// \returns true if deduction succeeded, false otherwise. 32715755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregorstatic Sema::TemplateDeductionResult 328a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 32915755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor NonTypeTemplateParmDecl *NTTP, 33015755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor Decl *D, 3312a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 33202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 33315755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor assert(NTTP->getDepth() == 0 && 33415755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor "Cannot deduce non-type template argument with depth > 0"); 33515755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor 3360d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(D? D->getCanonicalDecl() : 0); 3370d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 3380d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()], 3390d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 3400d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 3410d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = NTTP; 3420d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 3430d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 3440d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Inconsistent; 34515755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor } 34615755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor 3470d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 34815755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor return Sema::TDK_Success; 34915755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor} 35015755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor 351f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 352a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 353db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor TemplateParameterList *TemplateParams, 354f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateName Param, 355f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateName Arg, 3562a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 35702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 358d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor TemplateDecl *ParamDecl = Param.getAsTemplateDecl(); 359db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (!ParamDecl) { 360db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // The parameter type is dependent and is not a template template parameter, 361db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // so there is nothing that we can deduce. 362db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_Success; 363f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 364db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor 365db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (TemplateTemplateParmDecl *TempParam 366db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) { 3670d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg)); 3680d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 3690d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[TempParam->getIndex()], 3700d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 3710d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 3720d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = TempParam; 3730d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[TempParam->getIndex()]; 3740d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 3750d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Inconsistent; 376db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor } 377db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor 3780d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[TempParam->getIndex()] = Result; 3790d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Success; 380f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 381db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor 382db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // Verify that the two template names are equivalent. 383a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth if (S.Context.hasSameTemplateName(Param, Arg)) 384db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_Success; 385db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor 386db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // Mismatch of non-dependent template parameter to argument. 387db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Info.FirstArg = TemplateArgument(Param); 388db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Info.SecondArg = TemplateArgument(Arg); 389db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_NonDeducedMismatch; 390d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor} 391d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 3921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the template arguments by comparing the template parameter 393de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// type (which is a template-id) with the template argument type. 394de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 395a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth/// \param S the Sema 396de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 397de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param TemplateParams the template parameters that we are deducing 398de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 399de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Param the parameter type 400de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 401de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Arg the argument type 402de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 403de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Info information about the template argument deduction itself 404de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 405de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Deduced the deduced template arguments 406de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 407de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \returns the result of template argument deduction so far. Note that a 408de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// "success" result means that template argument deduction has not yet failed, 409de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// but it may still fail, later, for other reasons. 410de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregorstatic Sema::TemplateDeductionResult 411a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 412de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor TemplateParameterList *TemplateParams, 413de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const TemplateSpecializationType *Param, 414de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor QualType Arg, 4152a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 41602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 417467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(Arg.isCanonical() && "Argument type must be canonical"); 4181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 419de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Check whether the template argument is a dependent template-id. 4201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateSpecializationType *SpecArg 421de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = dyn_cast<TemplateSpecializationType>(Arg)) { 422de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction for the template name. 423de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 424a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 425de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getTemplateName(), 426de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor SpecArg->getTemplateName(), 427de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 428de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 4291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 431de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction on each template 4320972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor // argument. Ignore any missing/extra arguments, since they could be 4330972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor // filled in by default arguments. 43420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return DeduceTemplateArguments(S, TemplateParams, 4350972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor Param->getArgs(), Param->getNumArgs(), 4360972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor SpecArg->getArgs(), SpecArg->getNumArgs(), 4370972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor Info, Deduced, 4380972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor /*NumberOfArgumentsMustMatch=*/false); 439de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 4401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 441de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If the argument type is a class template specialization, we 442de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // perform template argument deduction using its template 443de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // arguments. 444de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const RecordType *RecordArg = dyn_cast<RecordType>(Arg); 445de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!RecordArg) 446de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 4471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ClassTemplateSpecializationDecl *SpecArg 449de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl()); 450de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!SpecArg) 451de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 4521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 453de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction for the template name. 454de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 455a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, 456db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor TemplateParams, 457de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getTemplateName(), 458de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor TemplateName(SpecArg->getSpecializedTemplate()), 459de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 460de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 4611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 46220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Perform template argument deduction for the template arguments. 46320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return DeduceTemplateArguments(S, TemplateParams, 46420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Param->getArgs(), Param->getNumArgs(), 46520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor SpecArg->getTemplateArgs().data(), 46620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor SpecArg->getTemplateArgs().size(), 46720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Info, Deduced); 468de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor} 469de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 470cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall/// \brief Determines whether the given type is an opaque type that 471cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall/// might be more qualified when instantiated. 472cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCallstatic bool IsPossiblyOpaquelyQualifiedType(QualType T) { 473cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall switch (T->getTypeClass()) { 474cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::TypeOfExpr: 475cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::TypeOf: 476cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::DependentName: 477cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::Decltype: 478cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::UnresolvedUsing: 47962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall case Type::TemplateTypeParm: 480cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return true; 481cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 482cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::ConstantArray: 483cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::IncompleteArray: 484cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::VariableArray: 485cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::DependentSizedArray: 486cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return IsPossiblyOpaquelyQualifiedType( 487cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall cast<ArrayType>(T)->getElementType()); 488cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 489cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall default: 490cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return false; 491cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall } 492cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall} 493cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 494d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor/// \brief Retrieve the depth and index of a template parameter. 495603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic std::pair<unsigned, unsigned> 496d3731198193eee92796ddeb493973b7a598b003eDouglas GregorgetDepthAndIndex(NamedDecl *ND) { 497603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND)) 498603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 499603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 500603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND)) 501603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(NTTP->getDepth(), NTTP->getIndex()); 502603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 503603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND); 504603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 505603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 506603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 507d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor/// \brief Retrieve the depth and index of an unexpanded parameter pack. 508d3731198193eee92796ddeb493973b7a598b003eDouglas Gregorstatic std::pair<unsigned, unsigned> 509d3731198193eee92796ddeb493973b7a598b003eDouglas GregorgetDepthAndIndex(UnexpandedParameterPack UPP) { 510d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (const TemplateTypeParmType *TTP 511d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor = UPP.first.dyn_cast<const TemplateTypeParmType *>()) 512d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 513d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor 514d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor return getDepthAndIndex(UPP.first.get<NamedDecl *>()); 515d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor} 516d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor 517603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \brief Helper function to build a TemplateParameter when we don't 518603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// know its type statically. 519603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic TemplateParameter makeTemplateParameter(Decl *D) { 520603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D)) 521603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(TTP); 522603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) 523603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(NTTP); 524603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 525603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(cast<TemplateTemplateParmDecl>(D)); 526603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 527603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 5285429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor/// \brief Prepare to perform template argument deduction for all of the 5295429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor/// arguments in a set of argument packs. 5305429385919a2b6fb3708635b967221705f4b1dafDouglas Gregorstatic void PrepareArgumentPackDeduction(Sema &S, 5315429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 5325429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor const llvm::SmallVectorImpl<unsigned> &PackIndices, 5335429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &SavedPacks, 5345429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor llvm::SmallVectorImpl< 5355429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> > &NewlyDeducedPacks) { 5365429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // Save the deduced template arguments for each parameter pack expanded 5375429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // by this pack expansion, then clear out the deduction. 5385429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 5395429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // Save the previously-deduced argument pack, then clear it out so that we 5405429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // can deduce a new argument pack. 5415429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor SavedPacks[I] = Deduced[PackIndices[I]]; 5425429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor Deduced[PackIndices[I]] = TemplateArgument(); 5435429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor 5445429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // If the template arugment pack was explicitly specified, add that to 5455429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // the set of deduced arguments. 5465429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor const TemplateArgument *ExplicitArgs; 5475429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor unsigned NumExplicitArgs; 5485429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor if (NamedDecl *PartiallySubstitutedPack 5495429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor = S.CurrentInstantiationScope->getPartiallySubstitutedPack( 5505429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor &ExplicitArgs, 5515429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor &NumExplicitArgs)) { 5525429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor if (getDepthAndIndex(PartiallySubstitutedPack).second == PackIndices[I]) 5535429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor NewlyDeducedPacks[I].append(ExplicitArgs, 5545429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor ExplicitArgs + NumExplicitArgs); 5555429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor } 5565429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor } 5575429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor} 5585429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor 5590216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor/// \brief Finish template argument deduction for a set of argument packs, 5600216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor/// producing the argument packs and checking for consistency with prior 5610216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor/// deductions. 5620216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregorstatic Sema::TemplateDeductionResult 5630216f8121df32b320cab659d5b703fee50cdfda5Douglas GregorFinishArgumentPackDeduction(Sema &S, 5640216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor TemplateParameterList *TemplateParams, 5650216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor bool HasAnyArguments, 5660216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 5670216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor const llvm::SmallVectorImpl<unsigned> &PackIndices, 5680216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &SavedPacks, 5690216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor llvm::SmallVectorImpl< 5700216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> > &NewlyDeducedPacks, 5710216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor TemplateDeductionInfo &Info) { 5720216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 5730216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // pack expansion. 5740216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 5750216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (HasAnyArguments && NewlyDeducedPacks[I].empty()) { 5760216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // We were not able to deduce anything for this parameter pack, 5770216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // so just restore the saved argument pack. 5780216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced[PackIndices[I]] = SavedPacks[I]; 5790216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor continue; 5800216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 5810216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor 5820216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor DeducedTemplateArgument NewPack; 5830216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor 5840216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (NewlyDeducedPacks[I].empty()) { 5850216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // If we deduced an empty argument pack, create it now. 5860216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewPack = DeducedTemplateArgument(TemplateArgument(0, 0)); 5870216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } else { 5880216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor TemplateArgument *ArgumentPack 589203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor = new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()]; 5900216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(), 5910216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor ArgumentPack); 5920216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewPack 593203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor = DeducedTemplateArgument(TemplateArgument(ArgumentPack, 594203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor NewlyDeducedPacks[I].size()), 595203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor NewlyDeducedPacks[I][0].wasDeducedFromArrayBound()); 5960216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 5970216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor 5980216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor DeducedTemplateArgument Result 5990216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor = checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack); 6000216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Result.isNull()) { 6010216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Info.Param 6020216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor = makeTemplateParameter(TemplateParams->getParam(PackIndices[I])); 6030216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Info.FirstArg = SavedPacks[I]; 6040216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Info.SecondArg = NewPack; 6050216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor return Sema::TDK_Inconsistent; 6060216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 6070216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor 6080216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced[PackIndices[I]] = Result; 6090216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 6100216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor 6110216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor return Sema::TDK_Success; 6120216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor} 6130216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor 614603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \brief Deduce the template arguments by comparing the list of parameter 615603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// types to the list of argument types, as in the parameter-type-lists of 616603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// function types (C++ [temp.deduct.type]p10). 617603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 618603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param S The semantic analysis object within which we are deducing 619603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 620603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param TemplateParams The template parameters that we are deducing 621603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 622603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Params The list of parameter types 623603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 624603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param NumParams The number of types in \c Params 625603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 626603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Args The list of argument types 627603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 628603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param NumArgs The number of types in \c Args 629603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 630603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Info information about the template argument deduction itself 631603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 632603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Deduced the deduced template arguments 633603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 634603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe 635603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// how template argument deduction is performed. 636603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 6375c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param PartialOrdering If true, we are performing template argument 6385c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// deduction for during partial ordering for a call 6395c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// (C++0x [temp.deduct.partial]). 6405c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 6415c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param QualifierComparisons If we're performing template argument deduction 6425c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// in the context of partial ordering, the set of qualifier comparisons. 6435c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 644603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \returns the result of template argument deduction so far. Note that a 645603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// "success" result means that template argument deduction has not yet failed, 646603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// but it may still fail, later, for other reasons. 647603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic Sema::TemplateDeductionResult 648603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas GregorDeduceTemplateArguments(Sema &S, 649603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateParameterList *TemplateParams, 650603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor const QualType *Params, unsigned NumParams, 651603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor const QualType *Args, unsigned NumArgs, 652603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateDeductionInfo &Info, 653603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 6545c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned TDF, 6555c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor bool PartialOrdering = false, 6565c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor llvm::SmallVectorImpl<DeductionQualifierComparison> * 6575c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor QualifierComparisons = 0) { 6580bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor // Fast-path check to see if we have too many/too few arguments. 6590bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor if (NumParams != NumArgs && 6600bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor !(NumParams && isa<PackExpansionType>(Params[NumParams - 1])) && 6610bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor !(NumArgs && isa<PackExpansionType>(Args[NumArgs - 1]))) 6623cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor return Sema::TDK_NonDeducedMismatch; 663603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 664603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // C++0x [temp.deduct.type]p10: 665603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Similarly, if P has a form that contains (T), then each parameter type 666603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Pi of the respective parameter-type- list of P is compared with the 667603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // corresponding parameter type Ai of the corresponding parameter-type-list 668603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // of A. [...] 669603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor unsigned ArgIdx = 0, ParamIdx = 0; 670603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (; ParamIdx != NumParams; ++ParamIdx) { 671603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Check argument types. 672603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor const PackExpansionType *Expansion 673603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor = dyn_cast<PackExpansionType>(Params[ParamIdx]); 674603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (!Expansion) { 675603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Simple case: compare the parameter and argument types at this point. 676603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 677603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Make sure we have an argument. 678603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (ArgIdx >= NumArgs) 6793cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor return Sema::TDK_NonDeducedMismatch; 680603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 68177d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (isa<PackExpansionType>(Args[ArgIdx])) { 68277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // C++0x [temp.deduct.type]p22: 68377d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // If the original function parameter associated with A is a function 68477d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // parameter pack and the function parameter associated with P is not 68577d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // a function parameter pack, then template argument deduction fails. 68677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor return Sema::TDK_NonDeducedMismatch; 68777d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor } 6885c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 689603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (Sema::TemplateDeductionResult Result 6905c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor = DeduceTemplateArguments(S, TemplateParams, 6915c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Params[ParamIdx], 6925c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Args[ArgIdx], 6935c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Info, Deduced, TDF, 6945c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor PartialOrdering, 6955c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor QualifierComparisons)) 696603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Result; 697603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 698603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor ++ArgIdx; 699603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor continue; 700603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 701603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 7027d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // C++0x [temp.deduct.type]p5: 7037d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // The non-deduced contexts are: 7047d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // - A function parameter pack that does not occur at the end of the 7057d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // parameter-declaration-clause. 7067d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor if (ParamIdx + 1 < NumParams) 7077d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor return Sema::TDK_Success; 7087d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor 709603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // C++0x [temp.deduct.type]p10: 710603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // If the parameter-declaration corresponding to Pi is a function 711603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // parameter pack, then the type of its declarator- id is compared with 712603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // each remaining parameter type in the parameter-type-list of A. Each 713603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // comparison deduces template arguments for subsequent positions in the 714603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // template parameter packs expanded by the function parameter pack. 715603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 716603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Compute the set of template parameter indices that correspond to 717603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // parameter packs expanded by the pack expansion. 718603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::SmallVector<unsigned, 2> PackIndices; 719603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor QualType Pattern = Expansion->getPattern(); 720603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor { 721603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::BitVector SawIndices(TemplateParams->size()); 722603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded; 723603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor S.collectUnexpandedParameterPacks(Pattern, Unexpanded); 724603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 725603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor unsigned Depth, Index; 726603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 727603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 728603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor SawIndices[Index] = true; 729603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor PackIndices.push_back(Index); 730603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 731603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 732603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 733603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 734603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 735d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // Keep track of the deduced template arguments for each parameter pack 736d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // expanded by this pack expansion (the outer index) and for each 737d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // template argument (the inner SmallVectors). 738d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor llvm::SmallVector<llvm::SmallVector<DeducedTemplateArgument, 4>, 2> 739d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor NewlyDeducedPacks(PackIndices.size()); 740603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 2> 7415429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor SavedPacks(PackIndices.size()); 7425429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, 7435429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor NewlyDeducedPacks); 744603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 745603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor bool HasAnyArguments = false; 746603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (; ArgIdx < NumArgs; ++ArgIdx) { 747603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor HasAnyArguments = true; 748603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 749603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Deduce template arguments from the pattern. 750603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (Sema::TemplateDeductionResult Result 751603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx], 7525c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Info, Deduced, PartialOrdering, 7535c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor QualifierComparisons)) 754603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Result; 755603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 756603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 757603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 758603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // for that pack, then clear out the deduced argument. 759603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 760603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 761603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (!DeducedArg.isNull()) { 762603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 763603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor DeducedArg = DeducedTemplateArgument(); 764603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 765603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 766603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 767603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 768603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 769603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // pack expansion. 7700216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Sema::TemplateDeductionResult Result 7710216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, 7720216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced, PackIndices, SavedPacks, 7730216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewlyDeducedPacks, Info)) 7740216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor return Result; 775603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 776603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 777603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Make sure we don't have any extra arguments. 778603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (ArgIdx < NumArgs) 7793cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor return Sema::TDK_NonDeducedMismatch; 780603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 781603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Sema::TDK_Success; 782603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 783603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 784500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \brief Deduce the template arguments by comparing the parameter type and 785500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// the argument type (C++ [temp.deduct.type]). 786500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 787a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth/// \param S the semantic analysis object within which we are deducing 788500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 789500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param TemplateParams the template parameters that we are deducing 790500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 791500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param ParamIn the parameter type 792500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 793500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param ArgIn the argument type 794500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 795500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param Info information about the template argument deduction itself 796500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 797500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param Deduced the deduced template arguments 798500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 799508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe 8001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// how template argument deduction is performed. 801500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 8025c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param PartialOrdering Whether we're performing template argument deduction 8035c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// in the context of partial ordering (C++0x [temp.deduct.partial]). 8045c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 8055c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param QualifierComparisons If we're performing template argument deduction 8065c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// in the context of partial ordering, the set of qualifier comparisons. 8075c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 808500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \returns the result of template argument deduction so far. Note that a 809500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// "success" result means that template argument deduction has not yet failed, 810500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// but it may still fail, later, for other reasons. 811f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 812a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 813f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 814f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor QualType ParamIn, QualType ArgIn, 8152a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 81602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 8175c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned TDF, 8185c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor bool PartialOrdering, 8195c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor llvm::SmallVectorImpl<DeductionQualifierComparison> *QualifierComparisons) { 8200b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // We only want to look at the canonical types, since typedefs and 8210b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // sugar are not part of template argument deduction. 822a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth QualType Param = S.Context.getCanonicalType(ParamIn); 823a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth QualType Arg = S.Context.getCanonicalType(ArgIn); 8240b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 82577d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // If the argument type is a pack expansion, look at its pattern. 82677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // This isn't explicitly called out 82777d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (const PackExpansionType *ArgExpansion 82877d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor = dyn_cast<PackExpansionType>(Arg)) 82977d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Arg = ArgExpansion->getPattern(); 83077d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor 8315c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (PartialOrdering) { 8325c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.partial]p5: 8335c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // Before the partial ordering is done, certain transformations are 8345c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // performed on the types used for partial ordering: 8355c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // - If P is a reference type, P is replaced by the type referred to. 8365c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor const ReferenceType *ParamRef = Param->getAs<ReferenceType>(); 8375c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (ParamRef) 8385c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Param = ParamRef->getPointeeType(); 8395c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 8405c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // - If A is a reference type, A is replaced by the type referred to. 8415c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor const ReferenceType *ArgRef = Arg->getAs<ReferenceType>(); 8425c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (ArgRef) 8435c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Arg = ArgRef->getPointeeType(); 8445c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 8455c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (QualifierComparisons && ParamRef && ArgRef) { 8465c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.partial]p6: 8475c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // If both P and A were reference types (before being replaced with the 8485c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // type referred to above), determine which of the two types (if any) is 8495c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // more cv-qualified than the other; otherwise the types are considered 8505c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // to be equally cv-qualified for partial ordering purposes. The result 8515c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // of this determination will be used below. 8525c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // 8535c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // We save this information for later, using it only when deduction 8545c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // succeeds in both directions. 8555c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor DeductionQualifierComparison QualifierResult = NeitherMoreQualified; 8565c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (Param.isMoreQualifiedThan(Arg)) 8575c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor QualifierResult = ParamMoreQualified; 8585c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor else if (Arg.isMoreQualifiedThan(Param)) 8595c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor QualifierResult = ArgMoreQualified; 8605c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor QualifierComparisons->push_back(QualifierResult); 8615c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor } 8625c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 8635c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.partial]p7: 8645c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // Remove any top-level cv-qualifiers: 8655c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // - If P is a cv-qualified type, P is replaced by the cv-unqualified 8665c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // version of P. 8675c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Param = Param.getUnqualifiedType(); 8685c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // - If A is a cv-qualified type, A is replaced by the cv-unqualified 8695c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // version of A. 8705c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Arg = Arg.getUnqualifiedType(); 8715c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor } else { 8725c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.call]p4 bullet 1: 8735c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // - If the original P is a reference type, the deduced A (i.e., the type 8745c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // referred to by the reference) can be more cv-qualified than the 8755c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // transformed A. 8765c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (TDF & TDF_ParamWithReferenceType) { 8775c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Qualifiers Quals; 8785c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals); 8795c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Quals.setCVRQualifiers(Quals.getCVRQualifiers() & 88062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall Arg.getCVRQualifiers()); 8815c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Param = S.Context.getQualifiedType(UnqualParam, Quals); 8825c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor } 883500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor } 8845c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 885f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // If the parameter type is not dependent, there is nothing to deduce. 8861282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor if (!Param->isDependentType()) { 8873cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor if (!(TDF & TDF_SkipNonDependent) && Param != Arg) 8881282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor return Sema::TDK_NonDeducedMismatch; 8891282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor 890f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return Sema::TDK_Success; 8911282029f3d37f482bbba3c38ea9da17a78d11d40Douglas Gregor } 8920b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 893199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // C++ [temp.deduct.type]p9: 8941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // A template type argument T, a template template argument TT or a 8951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // template non-type argument i can be deduced if P and A have one of 896199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // the following forms: 897199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // 898199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T 899199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // cv-list T 9001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateTypeParmType *TemplateTypeParm 901183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = Param->getAs<TemplateTypeParmType>()) { 902f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor unsigned Index = TemplateTypeParm->getIndex(); 903f290e0db835a619014538c41ed552696efc0e977Douglas Gregor bool RecanonicalizeArg = false; 9041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 9059e9fae4b8af47c15696da4ea3c30102e3a035179Douglas Gregor // If the argument type is an array type, move the qualifiers up to the 9069e9fae4b8af47c15696da4ea3c30102e3a035179Douglas Gregor // top level, so they can be matched with the qualifiers on the parameter. 9079e9fae4b8af47c15696da4ea3c30102e3a035179Douglas Gregor // FIXME: address spaces, ObjC GC qualifiers 908f290e0db835a619014538c41ed552696efc0e977Douglas Gregor if (isa<ArrayType>(Arg)) { 9090953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers Quals; 910a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth Arg = S.Context.getUnqualifiedArrayType(Arg, Quals); 9110953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (Quals) { 912a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth Arg = S.Context.getQualifiedType(Arg, Quals); 913f290e0db835a619014538c41ed552696efc0e977Douglas Gregor RecanonicalizeArg = true; 914f290e0db835a619014538c41ed552696efc0e977Douglas Gregor } 915f290e0db835a619014538c41ed552696efc0e977Douglas Gregor } 9161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 9170b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // The argument type can not be less qualified than the parameter 9180b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // type. 919508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (Param.isMoreQualifiedThan(Arg) && !(TDF & TDF_IgnoreQualifiers)) { 920f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 92157e97786433e70197a089360228d8f0d82e3ad4cJohn McCall Info.FirstArg = TemplateArgument(Param); 922833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.SecondArg = TemplateArgument(Arg); 92357e97786433e70197a089360228d8f0d82e3ad4cJohn McCall return Sema::TDK_Underqualified; 924f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 9250b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 9260b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0"); 927a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function"); 9280953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualType DeducedType = Arg; 92949f4e1cbd839da27ff4814b4ea6d85a79f786cbdJohn McCall 93049f4e1cbd839da27ff4814b4ea6d85a79f786cbdJohn McCall // local manipulation is okay because it's canonical 93149f4e1cbd839da27ff4814b4ea6d85a79f786cbdJohn McCall DeducedType.removeLocalCVRQualifiers(Param.getCVRQualifiers()); 932f290e0db835a619014538c41ed552696efc0e977Douglas Gregor if (RecanonicalizeArg) 933a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth DeducedType = S.Context.getCanonicalType(DeducedType); 9341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 9350d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(DeducedType); 9360d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 9370d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[Index], 9380d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 9390d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 9400d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 9410d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[Index]; 9420d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 9430d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Inconsistent; 9440b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 9450d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 9460d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[Index] = Result; 9470d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Sema::TDK_Success; 9480b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 9490b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 950f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor // Set up the template argument deduction information for a failure. 951833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.FirstArg = TemplateArgument(ParamIn); 952833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.SecondArg = TemplateArgument(ArgIn); 953f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 9540bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // If the parameter is an already-substituted template parameter 9550bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // pack, do nothing: we don't know which of its arguments to look 9560bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // at, so we have to wait until all of the parameter packs in this 9570bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // expansion have arguments. 9580bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor if (isa<SubstTemplateTypeParmPackType>(Param)) 9590bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor return Sema::TDK_Success; 9600bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor 961508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor // Check the cv-qualifiers on the parameter and argument types. 962508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (!(TDF & TDF_IgnoreQualifiers)) { 963508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (TDF & TDF_ParamWithReferenceType) { 964508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (Param.isMoreQualifiedThan(Arg)) 965508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor return Sema::TDK_NonDeducedMismatch; 966cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall } else if (!IsPossiblyOpaquelyQualifiedType(Param)) { 967508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (Param.getCVRQualifiers() != Arg.getCVRQualifiers()) 9681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Sema::TDK_NonDeducedMismatch; 969508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor } 970508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor } 9710b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 972d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor switch (Param->getTypeClass()) { 973199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // No deduction possible for these types 974199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case Type::Builtin: 975f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 9761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 977199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T * 978d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::Pointer: { 979c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall QualType PointeeType; 980c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall if (const PointerType *PointerArg = Arg->getAs<PointerType>()) { 981c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType = PointerArg->getPointeeType(); 982c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } else if (const ObjCObjectPointerType *PointerArg 983c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall = Arg->getAs<ObjCObjectPointerType>()) { 984c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType = PointerArg->getPointeeType(); 985c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } else { 986f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 987c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } 9881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 9894112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass); 990a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 991d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor cast<PointerType>(Param)->getPointeeType(), 992c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType, 9934112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor Info, Deduced, SubTDF); 994d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 9951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 996199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T & 997d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::LValueReference: { 9986217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const LValueReferenceType *ReferenceArg = Arg->getAs<LValueReferenceType>(); 999d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor if (!ReferenceArg) 1000f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 10011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1002a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 1003d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor cast<LValueReferenceType>(Param)->getPointeeType(), 1004d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor ReferenceArg->getPointeeType(), 1005508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0); 1006d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 10070b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1008199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T && [C++0x] 1009d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::RValueReference: { 10106217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const RValueReferenceType *ReferenceArg = Arg->getAs<RValueReferenceType>(); 1011d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor if (!ReferenceArg) 1012f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 10131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1014a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 1015d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor cast<RValueReferenceType>(Param)->getPointeeType(), 1016d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor ReferenceArg->getPointeeType(), 1017508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0); 1018d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 10191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1020199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T [] (implied, but not stated explicitly) 10214d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson case Type::IncompleteArray: { 10221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const IncompleteArrayType *IncompleteArrayArg = 1023a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsIncompleteArrayType(Arg); 10244d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (!IncompleteArrayArg) 1025f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 10261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1027e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 1028a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 1029a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsIncompleteArrayType(Param)->getElementType(), 10304d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson IncompleteArrayArg->getElementType(), 1031e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall Info, Deduced, SubTDF); 10324d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson } 1033199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1034199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T [integer-constant] 10354d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson case Type::ConstantArray: { 10361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const ConstantArrayType *ConstantArrayArg = 1037a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsConstantArrayType(Arg); 10384d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (!ConstantArrayArg) 1039f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 10401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const ConstantArrayType *ConstantArrayParm = 1042a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsConstantArrayType(Param); 10434d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize()) 1044f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 10451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1046e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 1047a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 10484d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson ConstantArrayParm->getElementType(), 10494d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson ConstantArrayArg->getElementType(), 1050e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall Info, Deduced, SubTDF); 10514d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson } 10524d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson 1053199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // type [i] 1054199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case Type::DependentSizedArray: { 1055a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg); 1056199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (!ArrayArg) 1057f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 10581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1059e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 1060e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall 1061199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Check the element type of the arrays 1062199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor const DependentSizedArrayType *DependentArrayParm 1063a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = S.Context.getAsDependentSizedArrayType(Param); 1064f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 1065a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 1066f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor DependentArrayParm->getElementType(), 1067f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor ArrayArg->getElementType(), 1068e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall Info, Deduced, SubTDF)) 1069f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 10701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1071199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Determine the array bound is something we can deduce. 10721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NonTypeTemplateParmDecl *NTTP 1073199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr()); 1074199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (!NTTP) 1075f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 10761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // We can perform template argument deduction for the given non-type 1078199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // template parameter. 10791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 1080199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument at depth > 0"); 10811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ConstantArrayType *ConstantArrayArg 1082335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson = dyn_cast<ConstantArrayType>(ArrayArg)) { 1083335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson llvm::APSInt Size(ConstantArrayArg->getSize()); 10849d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor return DeduceNonTypeTemplateArgument(S, NTTP, Size, 10859d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor S.Context.getSizeType(), 108602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor /*ArrayBound=*/true, 1087f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 1088335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson } 1089199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (const DependentSizedArrayType *DependentArrayArg 1090199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = dyn_cast<DependentSizedArrayType>(ArrayArg)) 109134c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor if (DependentArrayArg->getSizeExpr()) 109234c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor return DeduceNonTypeTemplateArgument(S, NTTP, 109334c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor DependentArrayArg->getSizeExpr(), 109434c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor Info, Deduced); 10951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1096199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Incomplete type does not match a dependently-sized array type 1097f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1098199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 10991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // type(*)(T) 11011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(*)() 11021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(*)(T) 1103a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson case Type::FunctionProto: { 11041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *FunctionProtoArg = 1105a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson dyn_cast<FunctionProtoType>(Arg); 1106a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson if (!FunctionProtoArg) 1107f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 11081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *FunctionProtoParam = 1110a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson cast<FunctionProtoType>(Param); 1111994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson 11121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (FunctionProtoParam->getTypeQuals() != 1113994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson FunctionProtoArg->getTypeQuals()) 1114f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 11151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1116994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson if (FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic()) 1117f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1118994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson 1119a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson // Check return types. 1120f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 1121a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 1122f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor FunctionProtoParam->getResultType(), 1123f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor FunctionProtoArg->getResultType(), 1124508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0)) 1125f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 11261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1127603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return DeduceTemplateArguments(S, TemplateParams, 1128603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoParam->arg_type_begin(), 1129603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoParam->getNumArgs(), 1130603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoArg->arg_type_begin(), 1131603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoArg->getNumArgs(), 1132603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor Info, Deduced, 0); 1133a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson } 11341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11353cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall case Type::InjectedClassName: { 11363cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // Treat a template's injected-class-name as if the template 11373cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // specialization type had been used. 113831f17ecbef57b5679c017c375db330546b7b5145John McCall Param = cast<InjectedClassNameType>(Param) 113931f17ecbef57b5679c017c375db330546b7b5145John McCall ->getInjectedSpecializationType(); 11403cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<TemplateSpecializationType>(Param) && 11413cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall "injected class name is not a template specialization type"); 11423cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // fall through 11433cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 11443cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 1145f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // template-name<T> (where template-name refers to a class template) 1146d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor // template-name<i> 1147db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<T> 1148db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<i> 1149db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<> 1150d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor case Type::TemplateSpecialization: { 1151d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor const TemplateSpecializationType *SpecParam 1152d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor = cast<TemplateSpecializationType>(Param); 11531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1154de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Try to deduce template arguments from the template-id. 1155de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Sema::TemplateDeductionResult Result 1156a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, 1157de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced); 11581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11594a5c15f75f76b95e1c2ceb6fa2737dcadd5f4be1Douglas Gregor if (Result && (TDF & TDF_DerivedClass)) { 1160de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // C++ [temp.deduct.call]p3b3: 1161de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If P is a class, and P has the form template-id, then A can be a 1162de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // derived class of the deduced A. Likewise, if P is a pointer to a 11631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // class of the form template-id, A can be a pointer to a derived 1164de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // class pointed to by the deduced A. 1165de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // 1166de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // More importantly: 11671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // These alternatives are considered only if type deduction would 1168de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // otherwise fail. 1169a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth if (const RecordType *RecordT = Arg->getAs<RecordType>()) { 1170a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // We cannot inspect base classes as part of deduction when the type 1171a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // is incomplete, so either instantiate any templates necessary to 1172a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // complete the type, or skip over it if it cannot be completed. 11735769d6195087229770d7ac90449443e026c47103John McCall if (S.RequireCompleteType(Info.getLocation(), Arg, 0)) 1174a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return Result; 1175a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth 1176de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Use data recursion to crawl through the list of base classes. 11771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Visited contains the set of nodes we have already visited, while 1178de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // ToVisit is our stack of records that we still need to visit. 1179de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor llvm::SmallPtrSet<const RecordType *, 8> Visited; 1180de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor llvm::SmallVector<const RecordType *, 8> ToVisit; 1181de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ToVisit.push_back(RecordT); 1182de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor bool Successful = false; 1183053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> DeducedOrig(0); 1184053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor DeducedOrig = Deduced; 1185de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor while (!ToVisit.empty()) { 1186de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Retrieve the next class in the inheritance hierarchy. 1187de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const RecordType *NextT = ToVisit.back(); 1188de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ToVisit.pop_back(); 11891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1190de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If we have already seen this type, skip it. 1191de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!Visited.insert(NextT)) 1192de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor continue; 11931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1194de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If this is a base class, try to perform template argument 1195de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // deduction from it. 1196de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (NextT != RecordT) { 1197de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Sema::TemplateDeductionResult BaseResult 1198a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, SpecParam, 1199de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor QualType(NextT, 0), Info, Deduced); 12001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1201de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If template argument deduction for this base was successful, 1202053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor // note that we had some success. Otherwise, ignore any deductions 1203053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor // from this base class. 1204053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor if (BaseResult == Sema::TDK_Success) { 1205de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Successful = true; 1206053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor DeducedOrig = Deduced; 1207053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor } 1208053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor else 1209053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor Deduced = DeducedOrig; 1210de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 12111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1212de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Visit base classes 1213de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl()); 1214de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(), 1215de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor BaseEnd = Next->bases_end(); 12169994a34f6cf842721ba7723edc0b9036229fe387Sebastian Redl Base != BaseEnd; ++Base) { 12171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(Base->getType()->isRecordType() && 1218de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor "Base class that isn't a record?"); 12196217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek ToVisit.push_back(Base->getType()->getAs<RecordType>()); 1220de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 1221de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 12221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1223de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Successful) 1224de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_Success; 1225de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 12261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1227de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 12281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1229de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 1230d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor } 1231d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 1232637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T type::* 1233637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T T::* 1234637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (type::*)() 1235637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (T::*)() 1236637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (type::*)(T) 1237637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (T::*)(T) 1238637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (type::*)(T) 1239637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (T::*)() 1240637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (T::*)(T) 1241637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::MemberPointer: { 1242637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param); 1243637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg); 1244637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor if (!MemPtrArg) 1245f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1246f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1247f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 1248a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 1249f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor MemPtrParam->getPointeeType(), 1250f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor MemPtrArg->getPointeeType(), 1251508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 1252508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor TDF & TDF_IgnoreQualifiers)) 1253f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 1254f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1255a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 1256f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor QualType(MemPtrParam->getClass(), 0), 1257f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor QualType(MemPtrArg->getClass(), 0), 1258508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Info, Deduced, 0); 1259637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor } 1260637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor 12619a917e4fac79aba20fbd25983c78396475078918Anders Carlsson // (clang extension) 12629a917e4fac79aba20fbd25983c78396475078918Anders Carlsson // 12631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // type(^)(T) 12641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(^)() 12651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(^)(T) 1266859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson case Type::BlockPointer: { 1267859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param); 1268859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg); 12691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1270859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson if (!BlockPtrArg) 1271f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1273a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 1274859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson BlockPtrParam->getPointeeType(), 1275f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor BlockPtrArg->getPointeeType(), Info, 1276508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor Deduced, 0); 1277859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson } 1278859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson 1279637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::TypeOfExpr: 1280637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::TypeOf: 12814714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor case Type::DependentName: 1282637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // No template argument deduction for these types 1283f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 1284637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor 1285d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor default: 1286d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor break; 12870b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 12880b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 12890b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // FIXME: Many more cases to go (to go). 1290f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return Sema::TDK_Success; 12910b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 12920b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1293f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 1294a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 1295f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 1296f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor const TemplateArgument &Param, 129777d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor TemplateArgument Arg, 12982a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 129902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 130077d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // If the template argument is a pack expansion, perform template argument 130177d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // deduction against the pattern of that expansion. This only occurs during 130277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // partial ordering. 130377d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (Arg.isPackExpansion()) 130477d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Arg = Arg.getPackExpansionPattern(); 130577d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor 13060b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor switch (Param.getKind()) { 1307199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Null: 1308199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert(false && "Null template argument in parameter list"); 1309199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor break; 13101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 13111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case TemplateArgument::Type: 1312788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (Arg.getKind() == TemplateArgument::Type) 1313a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, Param.getAsType(), 1314788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Arg.getAsType(), Info, Deduced, 0); 1315788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.FirstArg = Param; 1316788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.SecondArg = Arg; 1317788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1318a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 1319788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 1320db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (Arg.getKind() == TemplateArgument::Template) 1321a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceTemplateArguments(S, TemplateParams, 1322788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Param.getAsTemplate(), 1323db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Arg.getAsTemplate(), Info, Deduced); 1324788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.FirstArg = Param; 1325788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.SecondArg = Arg; 1326788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1327a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 1328a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 1329a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor llvm_unreachable("caller should handle pack expansions"); 1330a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor break; 1331788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor 1332199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Declaration: 1333788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (Arg.getKind() == TemplateArgument::Declaration && 1334788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Param.getAsDecl()->getCanonicalDecl() == 1335788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Arg.getAsDecl()->getCanonicalDecl()) 1336788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_Success; 1337788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor 1338f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1339f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1340f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 13411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1342199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Integral: 1343199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Integral) { 13449d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if (hasSameExtendedValue(*Param.getAsIntegral(), *Arg.getAsIntegral())) 1345f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 1346f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1347f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1348f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1349f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1350f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 1351f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1352f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Arg.getKind() == TemplateArgument::Expression) { 1353f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1354f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1355f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1356199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 1357199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1358f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1359f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1360f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 13611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1362199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Expression: { 13631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (NonTypeTemplateParmDecl *NTTP 1364199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = getDeducedParameterFromExpr(Param.getAsExpr())) { 1365199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Integral) 1366a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, 13671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump *Arg.getAsIntegral(), 13689d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor Arg.getIntegralType(), 136902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor /*ArrayBound=*/false, 1370f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 1371199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Expression) 1372a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(), 1373f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 137415755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor if (Arg.getKind() == TemplateArgument::Declaration) 1375a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(), 137615755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor Info, Deduced); 137715755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor 1378f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1379f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1380f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1381199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 13821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1383199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Can't deduce anything, but that's okay. 1384f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 1385199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 1386d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson case TemplateArgument::Pack: 138720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor llvm_unreachable("Argument packs should be expanded by the caller!"); 13880b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 13891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1390f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 13910b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 13920b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 139320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \brief Determine whether there is a template argument to be used for 139420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// deduction. 139520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// 139620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// This routine "expands" argument packs in-place, overriding its input 139720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// parameters so that \c Args[ArgIdx] will be the available template argument. 139820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// 139920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \returns true if there is another template argument (which will be at 140020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \c Args[ArgIdx]), false otherwise. 140120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregorstatic bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args, 140220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned &ArgIdx, 140320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned &NumArgs) { 140420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (ArgIdx == NumArgs) 140520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return false; 140620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 140720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument &Arg = Args[ArgIdx]; 140820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (Arg.getKind() != TemplateArgument::Pack) 140920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return true; 141020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 141120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor assert(ArgIdx == NumArgs - 1 && "Pack not at the end of argument list?"); 141220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Args = Arg.pack_begin(); 141320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor NumArgs = Arg.pack_size(); 141420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ArgIdx = 0; 141520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return ArgIdx < NumArgs; 141620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor} 141720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 14187b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor/// \brief Determine whether the given set of template arguments has a pack 14197b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor/// expansion that is not the last template argument. 14207b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregorstatic bool hasPackExpansionBeforeEnd(const TemplateArgument *Args, 14217b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor unsigned NumArgs) { 14227b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor unsigned ArgIdx = 0; 14237b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor while (ArgIdx < NumArgs) { 14247b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor const TemplateArgument &Arg = Args[ArgIdx]; 14257b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 14267b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // Unwrap argument packs. 14277b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (Args[ArgIdx].getKind() == TemplateArgument::Pack) { 14287b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor Args = Arg.pack_begin(); 14297b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor NumArgs = Arg.pack_size(); 14307b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor ArgIdx = 0; 14317b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor continue; 14327b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor } 14337b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 14347b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor ++ArgIdx; 14357b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (ArgIdx == NumArgs) 14367b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return false; 14377b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 14387b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (Arg.isPackExpansion()) 14397b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return true; 14407b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor } 14417b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 14427b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return false; 14437b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor} 14447b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 14451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic Sema::TemplateDeductionResult 1446a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 1447f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 144820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Params, unsigned NumParams, 144920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Args, unsigned NumArgs, 14502a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 14510972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 14520972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor bool NumberOfArgumentsMustMatch) { 1453e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1454e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // If the template argument list of P contains a pack expansion that is not 1455e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // the last template argument, the entire template argument list is a 1456e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // non-deduced context. 14577b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (hasPackExpansionBeforeEnd(Params, NumParams)) 14587b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return Sema::TDK_Success; 14597b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 1460e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1461e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // If P has a form that contains <T> or <i>, then each argument Pi of the 1462e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // respective template argument list P is compared with the corresponding 1463e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // argument Ai of the corresponding template argument list of A. 146420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned ArgIdx = 0, ParamIdx = 0; 146520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams); 146620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ++ParamIdx) { 146720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (!Params[ParamIdx].isPackExpansion()) { 1468e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The simple case: deduce template arguments by matching Pi and Ai. 146920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 147020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Check whether we have enough arguments. 147120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) 14723cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor return NumberOfArgumentsMustMatch? Sema::TDK_NonDeducedMismatch 14730972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor : Sema::TDK_Success; 147420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 147577d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (Args[ArgIdx].isPackExpansion()) { 147677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here, 147777d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // but applied to pack expansions that are template arguments. 147877d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor return Sema::TDK_NonDeducedMismatch; 147977d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor } 148077d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor 1481e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Perform deduction for this Pi/Ai pair. 148220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (Sema::TemplateDeductionResult Result 148377d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor = DeduceTemplateArguments(S, TemplateParams, 148477d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Params[ParamIdx], Args[ArgIdx], 148577d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Info, Deduced)) 148620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return Result; 148720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 148820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Move to the next argument. 148920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ++ArgIdx; 149020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor continue; 149120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor } 149220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 1493e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The parameter is a pack expansion. 1494e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1495e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1496e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // If Pi is a pack expansion, then the pattern of Pi is compared with 1497e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // each remaining argument in the template argument list of A. Each 1498e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // comparison deduces template arguments for subsequent positions in the 1499e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // template parameter packs expanded by Pi. 1500e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern(); 1501e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1502e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Compute the set of template parameter indices that correspond to 1503e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // parameter packs expanded by the pack expansion. 1504e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::SmallVector<unsigned, 2> PackIndices; 1505e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor { 1506e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::BitVector SawIndices(TemplateParams->size()); 1507e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded; 1508e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor S.collectUnexpandedParameterPacks(Pattern, Unexpanded); 1509e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 1510e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor unsigned Depth, Index; 1511e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 1512e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 1513e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor SawIndices[Index] = true; 1514e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor PackIndices.push_back(Index); 1515e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1516e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1517e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1518e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 1519e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1520e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // FIXME: If there are no remaining arguments, we can bail out early 1521e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // and set any deduced parameter packs to an empty argument pack. 1522e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The latter part of this is a (minor) correctness issue. 1523e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1524e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Save the deduced template arguments for each parameter pack expanded 1525e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // by this pack expansion, then clear out the deduction. 1526e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 2> 1527e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor SavedPacks(PackIndices.size()); 15285429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor llvm::SmallVector<llvm::SmallVector<DeducedTemplateArgument, 4>, 2> 15295429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor NewlyDeducedPacks(PackIndices.size()); 15305429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, 15315429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor NewlyDeducedPacks); 1532e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1533e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Keep track of the deduced template arguments for each parameter pack 1534e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // expanded by this pack expansion (the outer index) and for each 1535e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // template argument (the inner SmallVectors). 1536e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor bool HasAnyArguments = false; 1537e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor while (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) { 1538e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor HasAnyArguments = true; 1539e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1540e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Deduce template arguments from the pattern. 1541e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (Sema::TemplateDeductionResult Result 1542e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx], 1543e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info, Deduced)) 1544e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor return Result; 1545e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1546e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 1547e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 1548e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // for that pack, then clear out the deduced argument. 1549e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 1550e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 1551e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (!DeducedArg.isNull()) { 1552e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 1553e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor DeducedArg = DeducedTemplateArgument(); 1554e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1555e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1556e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1557e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor ++ArgIdx; 1558e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1559e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1560e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 1561e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // pack expansion. 15620216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Sema::TemplateDeductionResult Result 15630216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, 15640216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced, PackIndices, SavedPacks, 15650216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewlyDeducedPacks, Info)) 15660216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor return Result; 15670b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 156820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 156920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // If there is an argument remaining, then we had too many arguments. 15700972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor if (NumberOfArgumentsMustMatch && 15710972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) 15723cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor return Sema::TDK_NonDeducedMismatch; 157320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 1574f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 15750b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 15760b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 157720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregorstatic Sema::TemplateDeductionResult 157820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas GregorDeduceTemplateArguments(Sema &S, 157920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateParameterList *TemplateParams, 158020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgumentList &ParamList, 158120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgumentList &ArgList, 158220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateDeductionInfo &Info, 158320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 158420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return DeduceTemplateArguments(S, TemplateParams, 158520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ParamList.data(), ParamList.size(), 158620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ArgList.data(), ArgList.size(), 158720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Info, Deduced); 158820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor} 158920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 1590f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor/// \brief Determine whether two template arguments are the same. 15911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic bool isSameTemplateArg(ASTContext &Context, 1592f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor const TemplateArgument &X, 1593f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor const TemplateArgument &Y) { 1594f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (X.getKind() != Y.getKind()) 1595f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 15961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1597f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor switch (X.getKind()) { 1598f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Null: 1599f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor assert(false && "Comparing NULL template argument"); 1600f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor break; 16011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1602f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Type: 1603f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return Context.getCanonicalType(X.getAsType()) == 1604f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Context.getCanonicalType(Y.getAsType()); 16051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1606f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Declaration: 160797fbaa2a38804268a024f1a104b43fcf8b4411b0Argyrios Kyrtzidis return X.getAsDecl()->getCanonicalDecl() == 160897fbaa2a38804268a024f1a104b43fcf8b4411b0Argyrios Kyrtzidis Y.getAsDecl()->getCanonicalDecl(); 16091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1610788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 1611a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 1612a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return Context.getCanonicalTemplateName( 1613a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() == 1614a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Context.getCanonicalTemplateName( 1615a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer(); 1616788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor 1617f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Integral: 1618f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return *X.getAsIntegral() == *Y.getAsIntegral(); 16191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1620788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Expression: { 1621788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor llvm::FoldingSetNodeID XID, YID; 1622788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor X.getAsExpr()->Profile(XID, Context, true); 1623788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Y.getAsExpr()->Profile(YID, Context, true); 1624788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return XID == YID; 1625788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor } 16261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1627f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Pack: 1628f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (X.pack_size() != Y.pack_size()) 1629f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 16301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (TemplateArgument::pack_iterator XP = X.pack_begin(), 16321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump XPEnd = X.pack_end(), 1633f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor YP = Y.pack_begin(); 16341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump XP != XPEnd; ++XP, ++YP) 1635f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (!isSameTemplateArg(Context, *XP, *YP)) 1636f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 1637f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 1638f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return true; 1639f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 1640f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 1641f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 1642f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor} 1643f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 164454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \brief Allocate a TemplateArgumentLoc where all locations have 164554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// been initialized to the given location. 164654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 164754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param S The semantic analysis object. 164854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 164954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param The template argument we are producing template argument 165054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// location information for. 165154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 165254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param NTTPType For a declaration template argument, the type of 165354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// the non-type template parameter that corresponds to this template 165454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// argument. 165554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 165654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param Loc The source location to use for the resulting template 165754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// argument. 165854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregorstatic TemplateArgumentLoc 165954c53cca105ed595e12fecf04e415c3712bda936Douglas GregorgetTrivialTemplateArgumentLoc(Sema &S, 166054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor const TemplateArgument &Arg, 166154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor QualType NTTPType, 166254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor SourceLocation Loc) { 166354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor switch (Arg.getKind()) { 166454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Null: 166554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor llvm_unreachable("Can't get a NULL template argument here"); 166654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor break; 166754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 166854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Type: 166954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(Arg, 167054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); 167154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 167254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Declaration: { 167354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Expr *E 1674ba68eca7582a62e3e2ff4b0eba1b2b73a6b80895Douglas Gregor = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) 167554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor .takeAs<Expr>(); 167654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(TemplateArgument(E), E); 167754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 167854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 167954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Integral: { 168054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Expr *E 1681ba68eca7582a62e3e2ff4b0eba1b2b73a6b80895Douglas Gregor = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs<Expr>(); 168254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(TemplateArgument(E), E); 168354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 168454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 168554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Template: 1686a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return TemplateArgumentLoc(Arg, SourceRange(), Loc); 1687a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 1688a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 1689a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return TemplateArgumentLoc(Arg, SourceRange(), Loc, Loc); 1690a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 169154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Expression: 169254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(Arg, Arg.getAsExpr()); 169354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 169454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Pack: 169554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); 169654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 169754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 169854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(); 169954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor} 170054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 170154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 170254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \brief Convert the given deduced template argument and add it to the set of 170354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// fully-converted template arguments. 170454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregorstatic bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, 170554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor DeducedTemplateArgument Arg, 170654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NamedDecl *Template, 170754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor QualType NTTPType, 170854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateDeductionInfo &Info, 170954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor bool InFunctionTemplate, 171054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor llvm::SmallVectorImpl<TemplateArgument> &Output) { 171154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (Arg.getKind() == TemplateArgument::Pack) { 171254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // This is a template argument pack, so check each of its arguments against 171354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // the template parameter. 171454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor llvm::SmallVector<TemplateArgument, 2> PackedArgsBuilder; 171554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor for (TemplateArgument::pack_iterator PA = Arg.pack_begin(), 1716135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor PAEnd = Arg.pack_end(); 171754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor PA != PAEnd; ++PA) { 1718d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // When converting the deduced template argument, append it to the 1719d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // general output list. We need to do this so that the template argument 1720d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // checking logic has all of the prior template arguments available. 172154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor DeducedTemplateArgument InnerArg(*PA); 172254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound()); 172354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template, 172454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NTTPType, Info, 1725d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor InFunctionTemplate, Output)) 172654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return true; 1727d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor 1728d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // Move the converted template argument into our argument pack. 1729d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor PackedArgsBuilder.push_back(Output.back()); 1730d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Output.pop_back(); 173154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 173254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 173354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Create the resulting argument pack. 1734203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor Output.push_back(TemplateArgument::CreatePackCopy(S.Context, 1735203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor PackedArgsBuilder.data(), 1736203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor PackedArgsBuilder.size())); 173754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return false; 173854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 173954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 174054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Convert the deduced template argument into a template 174154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // argument that we can check, almost as if the user had written 174254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // the template argument explicitly. 174354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType, 174454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.getLocation()); 174554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 174654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Check the template argument, converting it as necessary. 174754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return S.CheckTemplateArgument(Param, ArgLoc, 174854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template, 174954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template->getLocation(), 175054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template->getSourceRange().getEnd(), 175154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Output, 175254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InFunctionTemplate 175354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor ? (Arg.wasDeducedFromArrayBound() 175454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor ? Sema::CTAK_DeducedFromArrayBound 175554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor : Sema::CTAK_Deduced) 175654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor : Sema::CTAK_Specified); 175754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor} 175854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 175931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// Complete template argument deduction for a class template partial 176031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// specialization. 176131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregorstatic Sema::TemplateDeductionResult 176231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas GregorFinishTemplateArgumentDeduction(Sema &S, 176331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor ClassTemplatePartialSpecializationDecl *Partial, 176431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor const TemplateArgumentList &TemplateArgs, 176531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 17662a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info) { 176731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // Trap errors. 176831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Sema::SFINAETrap Trap(S); 176931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 177031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Sema::ContextRAII SavedContext(S, Partial); 1771f5813826802c2e76cdc13cae834ebfd4518d74a6John McCall 177202cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // C++ [temp.deduct.type]p2: 177302cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // [...] or if any template argument remains neither deduced nor 177402cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // explicitly specified, template argument deduction fails. 1775910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor llvm::SmallVector<TemplateArgument, 4> Builder; 1776033a3cad525e5b221ba035ffc3e0abfa1241d90eDouglas Gregor TemplateParameterList *PartialParams = Partial->getTemplateParameters(); 1777033a3cad525e5b221ba035ffc3e0abfa1241d90eDouglas Gregor for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) { 177854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NamedDecl *Param = PartialParams->getParam(I); 1779f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Deduced[I].isNull()) { 178054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.Param = makeTemplateParameter(Param); 178131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_Incomplete; 1782f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 178331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 178454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // We have deduced this argument, so it still needs to be 178554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // checked and converted. 178654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 178754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // First, for a non-type template parameter type that is 178854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // initialized by a declaration, we need the type of the 178954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // corresponding non-type template parameter. 179054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor QualType NTTPType; 179154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (NonTypeTemplateParmDecl *NTTP 1792d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 179354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NTTPType = NTTP->getType(); 1794d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor if (NTTPType->isDependentType()) { 1795d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 1796d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Builder.data(), Builder.size()); 1797d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTPType = S.SubstType(NTTPType, 1798d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor MultiLevelTemplateArgumentList(TemplateArgs), 1799d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTP->getLocation(), 1800d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTP->getDeclName()); 1801d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor if (NTTPType.isNull()) { 1802d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Info.Param = makeTemplateParameter(Param); 1803d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // FIXME: These template arguments are temporary. Free them! 1804d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Info.reset(TemplateArgumentList::CreateCopy(S.Context, 1805d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Builder.data(), 1806d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Builder.size())); 1807d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor return Sema::TDK_SubstitutionFailure; 1808d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 1809d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 1810d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 1811d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor 181254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], 181354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Partial, NTTPType, Info, false, 181454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Builder)) { 181554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.Param = makeTemplateParameter(Param); 181654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // FIXME: These template arguments are temporary. Free them! 181754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), 181854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Builder.size())); 181954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return Sema::TDK_SubstitutionFailure; 182054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 182102cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor } 182277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor 182302cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // Form the template argument list from the deduced template arguments. 18241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *DeducedArgumentList 1825910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = TemplateArgumentList::CreateCopy(S.Context, Builder.data(), 1826910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.size()); 1827910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor 1828f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.reset(DeducedArgumentList); 182902cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 183002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // Substitute the deduced template arguments into the template 183102cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // arguments of the class template partial specialization, and 183202cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // verify that the instantiated template arguments are both valid 183302cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // and are equivalent to the template arguments originally provided 18341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // to the class template. 18352a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(S); 183602cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate(); 1837833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall const TemplateArgumentLoc *PartialTemplateArgs 1838833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall = Partial->getTemplateArgsAsWritten(); 1839d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 1840d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall // Note that we don't provide the langle and rangle locations. 1841d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall TemplateArgumentListInfo InstArgs; 1842d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 1843e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (S.Subst(PartialTemplateArgs, 1844e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Partial->getNumTemplateArgsAsWritten(), 1845e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) { 1846e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx; 1847e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (ParamIdx >= Partial->getTemplateParameters()->size()) 1848e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor ParamIdx = Partial->getTemplateParameters()->size() - 1; 1849e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1850e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Decl *Param 1851e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor = const_cast<NamedDecl *>( 1852e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Partial->getTemplateParameters()->getParam(ParamIdx)); 1853e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info.Param = makeTemplateParameter(Param); 1854e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument(); 1855e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor return Sema::TDK_SubstitutionFailure; 1856833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall } 1857833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 1858910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor llvm::SmallVector<TemplateArgument, 4> ConvertedInstArgs; 185931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(), 186054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InstArgs, false, ConvertedInstArgs)) 186131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 1862833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 186354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateParameterList *TemplateParams 186454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor = ClassTemplate->getTemplateParameters(); 186554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { 1866910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgument InstArg = ConvertedInstArgs.data()[I]; 186731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) { 18682fdc5e8199e1e239620f2faae88997153703e16fDouglas Gregor Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); 1869f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.FirstArg = TemplateArgs[I]; 1870f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.SecondArg = InstArg; 187131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1872f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 187302cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor } 187402cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 1875bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor if (Trap.hasErrorOccurred()) 187631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 1877bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor 187831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_Success; 187931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor} 188031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 188131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// \brief Perform template argument deduction to determine whether 188231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// the given template arguments match the given class template 188331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// partial specialization per C++ [temp.class.spec.match]. 188431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas GregorSema::TemplateDeductionResult 188531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas GregorSema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, 188631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor const TemplateArgumentList &TemplateArgs, 188731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor TemplateDeductionInfo &Info) { 188831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // C++ [temp.class.spec.match]p2: 188931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // A partial specialization matches a given actual template 189031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // argument list if the template arguments of the partial 189131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // specialization can be deduced from the actual template argument 189231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // list (14.8.2). 189331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor SFINAETrap Trap(*this); 189431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> Deduced; 189531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Deduced.resize(Partial->getTemplateParameters()->size()); 189631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (TemplateDeductionResult Result 189731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor = ::DeduceTemplateArguments(*this, 189831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Partial->getTemplateParameters(), 189931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Partial->getTemplateArgs(), 190031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor TemplateArgs, Info, Deduced)) 190131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Result; 190231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 190331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial, 19049b623639378d53a675921ddfa7316034d571881eDouglas Gregor Deduced.data(), Deduced.size(), Info); 190531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (Inst) 190631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return TDK_InstantiationDepth; 190731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 190831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (Trap.hasErrorOccurred()) 190931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 191031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 191131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs, 191231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Deduced, Info); 19130b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 1914031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 19154112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor/// \brief Determine whether the given type T is a simple-template-id type. 19164112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregorstatic bool isSimpleTemplateIdType(QualType T) { 19171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateSpecializationType *Spec 1918183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = T->getAs<TemplateSpecializationType>()) 19194112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor return Spec->getTemplateName().getAsTemplateDecl() != 0; 19201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19214112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor return false; 19224112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor} 192383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 192483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \brief Substitute the explicitly-provided template arguments into the 192583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// given function template according to C++ [temp.arg.explicit]. 192683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 192783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionTemplate the function template into which the explicit 192883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template arguments will be substituted. 192983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 19301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param ExplicitTemplateArguments the explicitly-specified template 193183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// arguments. 193283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 19331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param Deduced the deduced template arguments, which will be populated 193483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// with the converted and checked explicit template arguments. 193583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 19361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param ParamTypes will be populated with the instantiated function 193783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// parameters. 193883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 193983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionType if non-NULL, the result type of the function template 194083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// will also be instantiated and the pointed-to value will be updated with 194183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the instantiated function type. 194283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 194383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Info if substitution fails for any reason, this object will be 194483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// populated with more information about the failure. 194583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 194683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \returns TDK_Success if substitution was successful, or some failure 194783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// condition. 194883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::TemplateDeductionResult 194983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::SubstituteExplicitTemplateArguments( 195083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionTemplateDecl *FunctionTemplate, 1951d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall const TemplateArgumentListInfo &ExplicitTemplateArgs, 195202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 195383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor llvm::SmallVectorImpl<QualType> &ParamTypes, 195483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType *FunctionType, 195583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 195683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 195783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 195883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 195983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 1960d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs.size() == 0) { 196183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // No arguments to substitute; just copy over the parameter types and 196283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // fill in the function type. 196383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor for (FunctionDecl::param_iterator P = Function->param_begin(), 196483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor PEnd = Function->param_end(); 196583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor P != PEnd; 196683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ++P) 196783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes.push_back((*P)->getType()); 19681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 196983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType) 197083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor *FunctionType = Function->getType(); 197183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Success; 197283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 19731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 197483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Substitution of the explicit template arguments into a function template 197583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor /// is a SFINAE context. Trap any errors that might occur. 19761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 19771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 197883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.arg.explicit]p3: 19791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Template arguments that are present shall be specified in the 19801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // declaration order of their corresponding template-parameters. The 198183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template argument list shall not specify more template-arguments than 19821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // there are corresponding template-parameters. 1983910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor llvm::SmallVector<TemplateArgument, 4> Builder; 19841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Enter a new template instantiation context where we check the 198683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly-specified template arguments against this function template, 198783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // and then substitute them into the function parameter types. 19881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), 198983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionTemplate, Deduced.data(), Deduced.size(), 19909b623639378d53a675921ddfa7316034d571881eDouglas Gregor ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution, 19919b623639378d53a675921ddfa7316034d571881eDouglas Gregor Info); 199283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Inst) 199383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_InstantiationDepth; 19941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 199583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (CheckTemplateArgumentList(FunctionTemplate, 199683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SourceLocation(), 1997d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall ExplicitTemplateArgs, 199883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor true, 1999f1a8445036a2d047c7165d4170e3058cdeaba6ebDouglas Gregor Builder) || Trap.hasErrorOccurred()) { 2000910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor unsigned Index = Builder.size(); 2001fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor if (Index >= TemplateParams->size()) 2002fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor Index = TemplateParams->size() - 1; 2003fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor Info.Param = makeTemplateParameter(TemplateParams->getParam(Index)); 200483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_InvalidExplicitArguments; 2005f1a8445036a2d047c7165d4170e3058cdeaba6ebDouglas Gregor } 20061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 200783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Form the template argument list from the explicitly-specified 200883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template arguments. 20091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *ExplicitArgumentList 2010910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); 201183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.reset(ExplicitArgumentList); 2012d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor 2013df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // Template argument deduction and the final substitution should be 2014df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // done in the context of the templated declaration. Explicit 2015df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // argument substitution, on the other hand, needs to happen in the 2016df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // calling context. 2017df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); 2018df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall 2019d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // If we deduced template arguments for a template parameter pack, 2020d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // note that the template argument pack is partially substituted and record 2021d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // the explicit template arguments. They'll be used as part of deduction 2022d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // for this template parameter pack. 2023d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor for (unsigned I = 0, N = Builder.size(); I != N; ++I) { 2024d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor const TemplateArgument &Arg = Builder[I]; 2025d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (Arg.getKind() == TemplateArgument::Pack) { 2026d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor CurrentInstantiationScope->SetPartiallySubstitutedPack( 2027d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor TemplateParams->getParam(I), 2028d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Arg.pack_begin(), 2029d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Arg.pack_size()); 2030d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor break; 2031d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor } 2032d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor } 2033d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor 203483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Instantiate the types of each of the function parameters given the 203583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly-specified template arguments. 2036a009b59fc2c550a229b9146aabda8e33fe3a7771Douglas Gregor if (SubstParmTypes(Function->getLocation(), 2037a009b59fc2c550a229b9146aabda8e33fe3a7771Douglas Gregor Function->param_begin(), Function->getNumParams(), 2038a009b59fc2c550a229b9146aabda8e33fe3a7771Douglas Gregor MultiLevelTemplateArgumentList(*ExplicitArgumentList), 2039a009b59fc2c550a229b9146aabda8e33fe3a7771Douglas Gregor ParamTypes)) 2040a009b59fc2c550a229b9146aabda8e33fe3a7771Douglas Gregor return TDK_SubstitutionFailure; 204183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 204283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // If the caller wants a full function type back, instantiate the return 204383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // type and form that function type. 204483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType) { 204583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // FIXME: exception-specifications? 20461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *Proto 2047183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = Function->getType()->getAs<FunctionProtoType>(); 204883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor assert(Proto && "Function template does not have a prototype?"); 20491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType ResultType 2051357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor = SubstType(Proto->getResultType(), 2052357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor MultiLevelTemplateArgumentList(*ExplicitArgumentList), 2053357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor Function->getTypeSpecStartLoc(), 2054357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor Function->getDeclName()); 205583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (ResultType.isNull() || Trap.hasErrorOccurred()) 205683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 20571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump *FunctionType = BuildFunctionType(ResultType, 205983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes.data(), ParamTypes.size(), 206083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Proto->isVariadic(), 206183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Proto->getTypeQuals(), 206283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Function->getLocation(), 2063fa869547eb1cab12d7e0c0dfa8ba594e336b9b32Eli Friedman Function->getDeclName(), 2064fa869547eb1cab12d7e0c0dfa8ba594e336b9b32Eli Friedman Proto->getExtInfo()); 206583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType->isNull() || Trap.hasErrorOccurred()) 206683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 206783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 20681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 206983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.arg.explicit]p2: 20701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Trailing template arguments that can be deduced (14.8.2) may be 20711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // omitted from the list of explicit template-arguments. If all of the 207283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template arguments can be deduced, they may all be omitted; in this 207383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // case, the empty template argument list <> itself may also be omitted. 207483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // 2075d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // Take all of the explicitly-specified arguments and put them into 2076d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // the set of deduced template arguments. Explicitly-specified 2077d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // parameter packs, however, will be set to NULL since the deduction 2078d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // mechanisms handle explicitly-specified argument packs directly. 207983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced.reserve(TemplateParams->size()); 2080d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) { 2081d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor const TemplateArgument &Arg = ExplicitArgumentList->get(I); 2082d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (Arg.getKind() == TemplateArgument::Pack) 2083d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Deduced.push_back(DeducedTemplateArgument()); 2084d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor else 2085d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Deduced.push_back(Arg); 2086d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor } 20871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 208883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Success; 208983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 209083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 20911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Finish template argument deduction for a function template, 209283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// checking the deduced template arguments for completeness and forming 209383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the function template specialization. 20941eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpSema::TemplateDeductionResult 209583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, 209602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced, 209702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified, 209883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *&Specialization, 209983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 210083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 210183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 21021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 210351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Template argument deduction for function templates in a SFINAE context. 210451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Trap any errors that might occur. 210551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor SFINAETrap Trap(*this); 210651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 210751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Enter a new template instantiation context while we instantiate the 210851ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // actual function declaration. 210951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), 211051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate, Deduced.data(), Deduced.size(), 21119b623639378d53a675921ddfa7316034d571881eDouglas Gregor ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution, 21129b623639378d53a675921ddfa7316034d571881eDouglas Gregor Info); 211351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (Inst) 211451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor return TDK_InstantiationDepth; 211551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 211696db310ab7ca59e1890ddef25a3701bc2909d20fJohn McCall ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); 2117f5813826802c2e76cdc13cae834ebfd4518d74a6John McCall 211883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.deduct.type]p2: 211983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // [...] or if any template argument remains neither deduced nor 212083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly specified, template argument deduction fails. 2121910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor llvm::SmallVector<TemplateArgument, 4> Builder; 2122b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { 2123b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NamedDecl *Param = TemplateParams->getParam(I); 2124ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor 212551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (!Deduced[I].isNull()) { 21263273b0cea879c7af345d6bf98502bbf73fc4fde1Douglas Gregor if (I < NumExplicitlySpecified) { 212702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // We have already fully type-checked and converted this 21283273b0cea879c7af345d6bf98502bbf73fc4fde1Douglas Gregor // argument, because it was explicitly-specified. Just record the 21293273b0cea879c7af345d6bf98502bbf73fc4fde1Douglas Gregor // presence of this argument. 2130910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.push_back(Deduced[I]); 213102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor continue; 213202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 213302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 213402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // We have deduced this argument, so it still needs to be 213502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // checked and converted. 213602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 213702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // First, for a non-type template parameter type that is 213802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // initialized by a declaration, we need the type of the 213902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // corresponding non-type template parameter. 214002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor QualType NTTPType; 214102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor if (NonTypeTemplateParmDecl *NTTP 214202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 2143b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTPType = NTTP->getType(); 2144b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (NTTPType->isDependentType()) { 2145b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2146b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.data(), Builder.size()); 2147b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTPType = SubstType(NTTPType, 2148b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor MultiLevelTemplateArgumentList(TemplateArgs), 2149b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTP->getLocation(), 2150b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTP->getDeclName()); 2151b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (NTTPType.isNull()) { 2152b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Info.Param = makeTemplateParameter(Param); 2153b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2154b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Info.reset(TemplateArgumentList::CreateCopy(Context, 2155b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.data(), 2156b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.size())); 2157b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor return TDK_SubstitutionFailure; 215802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 215902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 216002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 216102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 2162b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I], 2163b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor FunctionTemplate, NTTPType, Info, 216454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor true, Builder)) { 2165b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Info.Param = makeTemplateParameter(Param); 2166910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2167910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), 2168b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.size())); 216902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor return TDK_SubstitutionFailure; 217002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 217102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 217251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor continue; 217351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor } 2174ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor 2175ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // C++0x [temp.arg.explicit]p3: 2176ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // A trailing template parameter pack (14.5.3) not otherwise deduced will 2177ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // be deduced to an empty sequence of template arguments. 2178ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // FIXME: Where did the word "trailing" come from? 2179ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor if (Param->isTemplateParameterPack()) { 2180d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // We may have had explicitly-specified template arguments for this 2181d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // template parameter pack. If so, our empty deduction extends the 2182d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // explicitly-specified set (C++0x [temp.arg.explicit]p9). 2183d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor const TemplateArgument *ExplicitArgs; 2184d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor unsigned NumExplicitArgs; 2185d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs, 2186d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor &NumExplicitArgs) 2187d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor == Param) 2188d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Builder.push_back(TemplateArgument(ExplicitArgs, NumExplicitArgs)); 2189d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor else 2190d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Builder.push_back(TemplateArgument(0, 0)); 2191d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor 2192ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor continue; 2193ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor } 219451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 219551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Substitute into the default template argument, if available. 219651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor TemplateArgumentLoc DefArg 219751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate, 219851ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getLocation(), 219951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getSourceRange().getEnd(), 220051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Param, 220151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Builder); 220251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 220351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // If there was no default argument, deduction is incomplete. 220451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (DefArg.getArgument().isNull()) { 220583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.Param = makeTemplateParameter( 220651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor const_cast<NamedDecl *>(TemplateParams->getParam(I))); 220783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Incomplete; 220883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 220951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 221051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Check whether we can actually use the default argument. 221151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (CheckTemplateArgument(Param, DefArg, 221251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate, 221351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getLocation(), 221451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getSourceRange().getEnd(), 221502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor Builder, 221602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor CTAK_Deduced)) { 221751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Info.Param = makeTemplateParameter( 221851ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor const_cast<NamedDecl *>(TemplateParams->getParam(I))); 2219910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2220910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), 2221910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.size())); 222251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor return TDK_SubstitutionFailure; 222351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor } 22241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 222551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // If we get here, we successfully used the default template argument. 222683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 22271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 222883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Form the template argument list from the deduced template arguments. 22291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *DeducedArgumentList 2230910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); 223183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.reset(DeducedArgumentList); 22321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 22331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Substitute the deduced template arguments into the function template 223483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // declaration to produce the function template specialization. 2235d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor DeclContext *Owner = FunctionTemplate->getDeclContext(); 2236d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor if (FunctionTemplate->getFriendObjectKind()) 2237d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor Owner = FunctionTemplate->getLexicalDeclContext(); 223883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Specialization = cast_or_null<FunctionDecl>( 2239d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, 2240357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor MultiLevelTemplateArgumentList(*DeducedArgumentList))); 224183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (!Specialization) 224283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 22431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2244f882574cf640d5c8355965e1c486f9d8d8ffcf47Douglas Gregor assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() == 2245f882574cf640d5c8355965e1c486f9d8d8ffcf47Douglas Gregor FunctionTemplate->getCanonicalDecl()); 2246f882574cf640d5c8355965e1c486f9d8d8ffcf47Douglas Gregor 22471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the template argument list is owned by the function template 224883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // specialization, release it. 2249ec20f46740a59758b12c22108002395bcf5b6f9bDouglas Gregor if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList && 2250ec20f46740a59758b12c22108002395bcf5b6f9bDouglas Gregor !Trap.hasErrorOccurred()) 225183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.take(); 22521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 225383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // There may have been an error that did not prevent us from constructing a 225483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // declaration. Mark the declaration invalid and return with a substitution 225583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // failure. 225683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Trap.hasErrorOccurred()) { 225783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Specialization->setInvalidDecl(true); 225883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 225983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 22601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 22619b623639378d53a675921ddfa7316034d571881eDouglas Gregor // If we suppressed any diagnostics while performing template argument 22629b623639378d53a675921ddfa7316034d571881eDouglas Gregor // deduction, and if we haven't already instantiated this declaration, 22639b623639378d53a675921ddfa7316034d571881eDouglas Gregor // keep track of these diagnostics. They'll be emitted if this specialization 22649b623639378d53a675921ddfa7316034d571881eDouglas Gregor // is actually used. 22659b623639378d53a675921ddfa7316034d571881eDouglas Gregor if (Info.diag_begin() != Info.diag_end()) { 22669b623639378d53a675921ddfa7316034d571881eDouglas Gregor llvm::DenseMap<Decl *, llvm::SmallVector<PartialDiagnosticAt, 1> >::iterator 22679b623639378d53a675921ddfa7316034d571881eDouglas Gregor Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl()); 22689b623639378d53a675921ddfa7316034d571881eDouglas Gregor if (Pos == SuppressedDiagnostics.end()) 22699b623639378d53a675921ddfa7316034d571881eDouglas Gregor SuppressedDiagnostics[Specialization->getCanonicalDecl()] 22709b623639378d53a675921ddfa7316034d571881eDouglas Gregor .append(Info.diag_begin(), Info.diag_end()); 22719b623639378d53a675921ddfa7316034d571881eDouglas Gregor } 22729b623639378d53a675921ddfa7316034d571881eDouglas Gregor 22731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return TDK_Success; 227483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 227583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 22769c72c6088d591ace8503b842d39448c2040f3033John McCall/// Gets the type of a function for template-argument-deducton 22779c72c6088d591ace8503b842d39448c2040f3033John McCall/// purposes when it's considered as part of an overload set. 2278eff92135d32039c9874dc356f3e93143af6069c1John McCallstatic QualType GetTypeOfFunction(ASTContext &Context, 22799c72c6088d591ace8503b842d39448c2040f3033John McCall const OverloadExpr::FindResult &R, 2280eff92135d32039c9874dc356f3e93143af6069c1John McCall FunctionDecl *Fn) { 2281eff92135d32039c9874dc356f3e93143af6069c1John McCall if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) 22829c72c6088d591ace8503b842d39448c2040f3033John McCall if (Method->isInstance()) { 22839c72c6088d591ace8503b842d39448c2040f3033John McCall // An instance method that's referenced in a form that doesn't 22849c72c6088d591ace8503b842d39448c2040f3033John McCall // look like a member pointer is just invalid. 22859c72c6088d591ace8503b842d39448c2040f3033John McCall if (!R.HasFormOfMemberPointer) return QualType(); 22869c72c6088d591ace8503b842d39448c2040f3033John McCall 2287eff92135d32039c9874dc356f3e93143af6069c1John McCall return Context.getMemberPointerType(Fn->getType(), 2288eff92135d32039c9874dc356f3e93143af6069c1John McCall Context.getTypeDeclType(Method->getParent()).getTypePtr()); 22899c72c6088d591ace8503b842d39448c2040f3033John McCall } 22909c72c6088d591ace8503b842d39448c2040f3033John McCall 22919c72c6088d591ace8503b842d39448c2040f3033John McCall if (!R.IsAddressOfOperand) return Fn->getType(); 2292eff92135d32039c9874dc356f3e93143af6069c1John McCall return Context.getPointerType(Fn->getType()); 2293eff92135d32039c9874dc356f3e93143af6069c1John McCall} 2294eff92135d32039c9874dc356f3e93143af6069c1John McCall 2295eff92135d32039c9874dc356f3e93143af6069c1John McCall/// Apply the deduction rules for overload sets. 2296eff92135d32039c9874dc356f3e93143af6069c1John McCall/// 2297eff92135d32039c9874dc356f3e93143af6069c1John McCall/// \return the null type if this argument should be treated as an 2298eff92135d32039c9874dc356f3e93143af6069c1John McCall/// undeduced context 2299eff92135d32039c9874dc356f3e93143af6069c1John McCallstatic QualType 2300eff92135d32039c9874dc356f3e93143af6069c1John McCallResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, 230175f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor Expr *Arg, QualType ParamType, 230275f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor bool ParamWasReference) { 23039c72c6088d591ace8503b842d39448c2040f3033John McCall 23049c72c6088d591ace8503b842d39448c2040f3033John McCall OverloadExpr::FindResult R = OverloadExpr::find(Arg); 2305eff92135d32039c9874dc356f3e93143af6069c1John McCall 23069c72c6088d591ace8503b842d39448c2040f3033John McCall OverloadExpr *Ovl = R.Expression; 2307eff92135d32039c9874dc356f3e93143af6069c1John McCall 230875f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor // C++0x [temp.deduct.call]p4 230975f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor unsigned TDF = 0; 231075f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor if (ParamWasReference) 231175f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor TDF |= TDF_ParamWithReferenceType; 231275f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor if (R.IsAddressOfOperand) 231375f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor TDF |= TDF_IgnoreQualifiers; 231475f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor 2315eff92135d32039c9874dc356f3e93143af6069c1John McCall // If there were explicit template arguments, we can only find 2316eff92135d32039c9874dc356f3e93143af6069c1John McCall // something via C++ [temp.arg.explicit]p3, i.e. if the arguments 2317eff92135d32039c9874dc356f3e93143af6069c1John McCall // unambiguously name a full specialization. 23187bb12da2b0749eeebb21854c77877736969e59f2John McCall if (Ovl->hasExplicitTemplateArgs()) { 2319eff92135d32039c9874dc356f3e93143af6069c1John McCall // But we can still look for an explicit specialization. 2320eff92135d32039c9874dc356f3e93143af6069c1John McCall if (FunctionDecl *ExplicitSpec 23217bb12da2b0749eeebb21854c77877736969e59f2John McCall = S.ResolveSingleFunctionTemplateSpecialization(Ovl)) 23229c72c6088d591ace8503b842d39448c2040f3033John McCall return GetTypeOfFunction(S.Context, R, ExplicitSpec); 2323eff92135d32039c9874dc356f3e93143af6069c1John McCall return QualType(); 2324eff92135d32039c9874dc356f3e93143af6069c1John McCall } 2325eff92135d32039c9874dc356f3e93143af6069c1John McCall 2326eff92135d32039c9874dc356f3e93143af6069c1John McCall // C++0x [temp.deduct.call]p6: 2327eff92135d32039c9874dc356f3e93143af6069c1John McCall // When P is a function type, pointer to function type, or pointer 2328eff92135d32039c9874dc356f3e93143af6069c1John McCall // to member function type: 2329eff92135d32039c9874dc356f3e93143af6069c1John McCall 2330eff92135d32039c9874dc356f3e93143af6069c1John McCall if (!ParamType->isFunctionType() && 2331eff92135d32039c9874dc356f3e93143af6069c1John McCall !ParamType->isFunctionPointerType() && 2332eff92135d32039c9874dc356f3e93143af6069c1John McCall !ParamType->isMemberFunctionPointerType()) 2333eff92135d32039c9874dc356f3e93143af6069c1John McCall return QualType(); 2334eff92135d32039c9874dc356f3e93143af6069c1John McCall 2335eff92135d32039c9874dc356f3e93143af6069c1John McCall QualType Match; 23367bb12da2b0749eeebb21854c77877736969e59f2John McCall for (UnresolvedSetIterator I = Ovl->decls_begin(), 23377bb12da2b0749eeebb21854c77877736969e59f2John McCall E = Ovl->decls_end(); I != E; ++I) { 2338eff92135d32039c9874dc356f3e93143af6069c1John McCall NamedDecl *D = (*I)->getUnderlyingDecl(); 2339eff92135d32039c9874dc356f3e93143af6069c1John McCall 2340eff92135d32039c9874dc356f3e93143af6069c1John McCall // - If the argument is an overload set containing one or more 2341eff92135d32039c9874dc356f3e93143af6069c1John McCall // function templates, the parameter is treated as a 2342eff92135d32039c9874dc356f3e93143af6069c1John McCall // non-deduced context. 2343eff92135d32039c9874dc356f3e93143af6069c1John McCall if (isa<FunctionTemplateDecl>(D)) 2344eff92135d32039c9874dc356f3e93143af6069c1John McCall return QualType(); 2345eff92135d32039c9874dc356f3e93143af6069c1John McCall 2346eff92135d32039c9874dc356f3e93143af6069c1John McCall FunctionDecl *Fn = cast<FunctionDecl>(D); 23479c72c6088d591ace8503b842d39448c2040f3033John McCall QualType ArgType = GetTypeOfFunction(S.Context, R, Fn); 23489c72c6088d591ace8503b842d39448c2040f3033John McCall if (ArgType.isNull()) continue; 2349eff92135d32039c9874dc356f3e93143af6069c1John McCall 235075f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor // Function-to-pointer conversion. 235175f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor if (!ParamWasReference && ParamType->isPointerType() && 235275f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor ArgType->isFunctionType()) 235375f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor ArgType = S.Context.getPointerType(ArgType); 235475f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor 2355eff92135d32039c9874dc356f3e93143af6069c1John McCall // - If the argument is an overload set (not containing function 2356eff92135d32039c9874dc356f3e93143af6069c1John McCall // templates), trial argument deduction is attempted using each 2357eff92135d32039c9874dc356f3e93143af6069c1John McCall // of the members of the set. If deduction succeeds for only one 2358eff92135d32039c9874dc356f3e93143af6069c1John McCall // of the overload set members, that member is used as the 2359eff92135d32039c9874dc356f3e93143af6069c1John McCall // argument value for the deduction. If deduction succeeds for 2360eff92135d32039c9874dc356f3e93143af6069c1John McCall // more than one member of the overload set the parameter is 2361eff92135d32039c9874dc356f3e93143af6069c1John McCall // treated as a non-deduced context. 2362eff92135d32039c9874dc356f3e93143af6069c1John McCall 2363eff92135d32039c9874dc356f3e93143af6069c1John McCall // We do all of this in a fresh context per C++0x [temp.deduct.type]p2: 2364eff92135d32039c9874dc356f3e93143af6069c1John McCall // Type deduction is done independently for each P/A pair, and 2365eff92135d32039c9874dc356f3e93143af6069c1John McCall // the deduced template argument values are then combined. 2366eff92135d32039c9874dc356f3e93143af6069c1John McCall // So we do not reject deductions which were made elsewhere. 236702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 8> 236802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor Deduced(TemplateParams->size()); 23692a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo Info(S.Context, Ovl->getNameLoc()); 2370eff92135d32039c9874dc356f3e93143af6069c1John McCall Sema::TemplateDeductionResult Result 2371a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 2372eff92135d32039c9874dc356f3e93143af6069c1John McCall ParamType, ArgType, 2373eff92135d32039c9874dc356f3e93143af6069c1John McCall Info, Deduced, TDF); 2374eff92135d32039c9874dc356f3e93143af6069c1John McCall if (Result) continue; 2375eff92135d32039c9874dc356f3e93143af6069c1John McCall if (!Match.isNull()) return QualType(); 2376eff92135d32039c9874dc356f3e93143af6069c1John McCall Match = ArgType; 2377eff92135d32039c9874dc356f3e93143af6069c1John McCall } 2378eff92135d32039c9874dc356f3e93143af6069c1John McCall 2379eff92135d32039c9874dc356f3e93143af6069c1John McCall return Match; 2380eff92135d32039c9874dc356f3e93143af6069c1John McCall} 2381eff92135d32039c9874dc356f3e93143af6069c1John McCall 2382f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// \brief Perform the adjustments to the parameter and argument types 2383f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// described in C++ [temp.deduct.call]. 2384f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// 2385f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// \returns true if the caller should not attempt to perform any template 2386f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// argument deduction based on this P/A pair. 2387f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregorstatic bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S, 2388f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TemplateParameterList *TemplateParams, 2389f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType &ParamType, 2390f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType &ArgType, 2391f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg, 2392f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned &TDF) { 2393f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p3: 2394f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // If P is a cv-qualified type, the top level cv-qualifiers of P’s type 2395f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // are ignored for type deduction. 2396f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamType.getCVRQualifiers()) 2397f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType = ParamType.getLocalUnqualifiedType(); 2398f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>(); 2399f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) { 2400f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // [...] If P is a reference type, the type referred to by P is used 2401f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // for type deduction. 2402f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType = ParamRefType->getPointeeType(); 2403f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 24045c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 2405f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Overload sets usually make this parameter an undeduced 2406f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // context, but there are sometimes special circumstances. 2407f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType == S.Context.OverloadTy) { 2408f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = ResolveOverloadForDeduction(S, TemplateParams, 2409f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Arg, ParamType, 2410f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamRefType != 0); 2411f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType.isNull()) 2412f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return true; 2413f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2414f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2415f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) { 2416f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p3: 2417f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // [...] If P is of the form T&&, where T is a template parameter, and 2418f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the argument is an lvalue, the type A& is used in place of A for 2419f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type deduction. 2420f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType->isRValueReferenceType() && 2421f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamRefType->getAs<TemplateTypeParmType>() && 2422f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Arg->isLValue()) 2423f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getLValueReferenceType(ArgType); 2424f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } else { 2425f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++ [temp.deduct.call]p2: 2426f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // If P is not a reference type: 2427f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If A is an array type, the pointer type produced by the 2428f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // array-to-pointer standard conversion (4.2) is used in place of 2429f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // A for type deduction; otherwise, 2430f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType->isArrayType()) 2431f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getArrayDecayedType(ArgType); 2432f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If A is a function type, the pointer type produced by the 2433f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // function-to-pointer standard conversion (4.3) is used in place 2434f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // of A for type deduction; otherwise, 2435f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else if (ArgType->isFunctionType()) 2436f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getPointerType(ArgType); 2437f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else { 2438f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If A is a cv-qualified type, the top level cv-qualifiers of A’s 2439f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type are ignored for type deduction. 2440f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType.getCVRQualifiers()) 2441f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = ArgType.getUnqualifiedType(); 2442f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2443f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2444f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2445f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p4: 2446f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // In general, the deduction process attempts to find template argument 2447f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // values that will make the deduced A identical to A (after the type A 2448f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // is transformed as described above). [...] 2449f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF = TDF_SkipNonDependent; 2450f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2451f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If the original P is a reference type, the deduced A (i.e., the 2452f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type referred to by the reference) can be more cv-qualified than 2453f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the transformed A. 2454f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) 2455f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_ParamWithReferenceType; 2456f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - The transformed A can be another pointer or pointer to member 2457f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type that can be converted to the deduced A via a qualification 2458f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // conversion (4.4). 2459f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType->isPointerType() || ArgType->isMemberPointerType() || 2460f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType->isObjCObjectPointerType()) 2461f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_IgnoreQualifiers; 2462f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If P is a class and P has the form simple-template-id, then the 2463f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // transformed A can be a derived class of the deduced A. Likewise, 2464f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // if P is a pointer to a class of the form simple-template-id, the 2465f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // transformed A can be a pointer to a derived class pointed to by 2466f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the deduced A. 2467f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (isSimpleTemplateIdType(ParamType) || 2468f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor (isa<PointerType>(ParamType) && 2469f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor isSimpleTemplateIdType( 2470f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType->getAs<PointerType>()->getPointeeType()))) 2471f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_DerivedClass; 2472f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2473f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return false; 2474f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor} 2475f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2476e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \brief Perform template argument deduction from a function call 2477e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// (C++ [temp.deduct.call]). 2478e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 2479e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param FunctionTemplate the function template for which we are performing 2480e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// template argument deduction. 2481e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 248248026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// \param ExplicitTemplateArguments the explicit template arguments provided 248348026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// for this call. 24846db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// 2485e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Args the function call arguments 2486e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 2487e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param NumArgs the number of arguments in Args 2488e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 248948026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// \param Name the name of the function being called. This is only significant 249048026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// when the function template is a conversion function template, in which 249148026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// case this routine will also perform template argument deduction based on 249248026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// the function to which 249348026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// 2494e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Specialization if template argument deduction was successful, 24951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// this will be set to the function template specialization produced by 2496e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// template argument deduction. 2497e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 2498e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Info the argument will be updated to provide additional information 2499e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// about template argument deduction. 2500e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 2501e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \returns the result of template argument deduction. 2502e53060fa78ad7e98352049f72787bdb7543e2a48Douglas GregorSema::TemplateDeductionResult 2503e53060fa78ad7e98352049f72787bdb7543e2a48Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 250448026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor const TemplateArgumentListInfo *ExplicitTemplateArgs, 2505e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor Expr **Args, unsigned NumArgs, 2506e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor FunctionDecl *&Specialization, 2507e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor TemplateDeductionInfo &Info) { 2508e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 25096db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor 2510e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // C++ [temp.deduct.call]p1: 2511e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // Template argument deduction is done by comparing each function template 2512e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // parameter type (call it P) with the type of the corresponding argument 2513e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // of the call (call it A) as described below. 2514e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor unsigned CheckArgs = NumArgs; 25156db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor if (NumArgs < Function->getMinRequiredArguments()) 2516e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor return TDK_TooFewArguments; 2517e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor else if (NumArgs > Function->getNumParams()) { 25181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *Proto 2519183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = Function->getType()->getAs<FunctionProtoType>(); 2520f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (Proto->isTemplateVariadic()) 2521f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor /* Do nothing */; 2522f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else if (Proto->isVariadic()) 2523f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor CheckArgs = Function->getNumParams(); 2524f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else 2525e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor return TDK_TooManyArguments; 2526e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 25271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 25286db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // The types of the parameters from which we will perform template argument 25296db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // deduction. 25302a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 2531e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor TemplateParameterList *TemplateParams 2532e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor = FunctionTemplate->getTemplateParameters(); 253302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> Deduced; 25346db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor llvm::SmallVector<QualType, 4> ParamTypes; 253502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified = 0; 2536d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs) { 253783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionResult Result = 253883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SubstituteExplicitTemplateArguments(FunctionTemplate, 2539d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall *ExplicitTemplateArgs, 254083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced, 254183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes, 254283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 0, 254383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info); 254483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Result) 254583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return Result; 254602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 254702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified = Deduced.size(); 25486db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor } else { 25496db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // Just fill in the parameter types from the function declaration. 2550f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) 25516db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor ParamTypes.push_back(Function->getParamDecl(I)->getType()); 25526db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor } 25531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 25546db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // Deduce template arguments from the function parameters. 25551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced.resize(TemplateParams->size()); 2556f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned ArgIdx = 0; 2557f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned ParamIdx = 0, NumParams = ParamTypes.size(); 2558f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamIdx != NumParams; ++ParamIdx) { 2559f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ParamType = ParamTypes[ParamIdx]; 2560f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2561f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor const PackExpansionType *ParamExpansion 2562f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor = dyn_cast<PackExpansionType>(ParamType); 2563f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (!ParamExpansion) { 2564f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Simple case: matching a function parameter to a function argument. 2565f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgIdx >= CheckArgs) 2566f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 2567f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2568f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg = Args[ArgIdx++]; 2569f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ArgType = Arg->getType(); 2570f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned TDF = 0; 2571f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, 2572f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Arg, 2573f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) 2574f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor continue; 2575f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2576f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (TemplateDeductionResult Result 2577f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor = ::DeduceTemplateArguments(*this, TemplateParams, 2578f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Info, Deduced, 2579f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) 2580f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return Result; 25811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2582f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // FIXME: we need to check that the deduced A is the same as A, 2583f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // modulo the various allowed differences. 2584f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor continue; 258575f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor } 258675f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor 2587f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p1: 2588f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // For a function parameter pack that occurs at the end of the 2589f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // parameter-declaration-list, the type A of each remaining argument of 2590f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the call is compared with the type P of the declarator-id of the 2591f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // function parameter pack. Each comparison deduces template arguments 2592f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // for subsequent positions in the template parameter packs expanded by 25937d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // the function parameter pack. For a function parameter pack that does 25947d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // not occur at the end of the parameter-declaration-list, the type of 25957d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // the parameter pack is a non-deduced context. 25967d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor if (ParamIdx + 1 < NumParams) 25977d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor break; 25987d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor 2599f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ParamPattern = ParamExpansion->getPattern(); 2600f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::SmallVector<unsigned, 2> PackIndices; 2601f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor { 2602f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::BitVector SawIndices(TemplateParams->size()); 2603f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded; 2604f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor collectUnexpandedParameterPacks(ParamPattern, Unexpanded); 2605f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 2606f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned Depth, Index; 2607f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 2608f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 2609f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor SawIndices[Index] = true; 2610f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor PackIndices.push_back(Index); 2611f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2612f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2613f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2614f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 2615f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2616d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // Keep track of the deduced template arguments for each parameter pack 2617d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // expanded by this pack expansion (the outer index) and for each 2618d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // template argument (the inner SmallVectors). 2619d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor llvm::SmallVector<llvm::SmallVector<DeducedTemplateArgument, 4>, 2> 2620d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor NewlyDeducedPacks(PackIndices.size()); 2621f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 2> 2622d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor SavedPacks(PackIndices.size()); 26235429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks, 26245429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor NewlyDeducedPacks); 2625f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor bool HasAnyArguments = false; 2626f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (; ArgIdx < NumArgs; ++ArgIdx) { 2627f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor HasAnyArguments = true; 2628f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2629f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType = ParamPattern; 2630f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg = Args[ArgIdx]; 2631f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ArgType = Arg->getType(); 2632f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned TDF = 0; 2633f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, 2634f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Arg, 2635f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) { 2636f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // We can't actually perform any deduction for this argument, so stop 2637f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // deduction at this point. 2638f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ++ArgIdx; 2639f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 2640f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2641f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2642f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (TemplateDeductionResult Result 2643f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor = ::DeduceTemplateArguments(*this, TemplateParams, 2644f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Info, Deduced, 2645f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) 2646f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return Result; 2647eff92135d32039c9874dc356f3e93143af6069c1John McCall 2648f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 2649f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 2650f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // for that pack, then clear out the deduced argument. 2651f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 2652f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 2653f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (!DeducedArg.isNull()) { 2654f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 2655f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor DeducedArg = DeducedTemplateArgument(); 2656f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2657e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 2658e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 2659f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2660f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 2661f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // pack expansion. 26620216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Sema::TemplateDeductionResult Result 26630216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor = FinishArgumentPackDeduction(*this, TemplateParams, HasAnyArguments, 26640216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced, PackIndices, SavedPacks, 26650216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewlyDeducedPacks, Info)) 26660216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor return Result; 26671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2668f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // After we've matching against a parameter pack, we're done. 2669f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 2670e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 267165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 26721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 267302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified, 267483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Specialization, Info); 267583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 2676127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor 267783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \brief Deduce template arguments when taking the address of a function 26784b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template (C++ [temp.deduct.funcaddr]) or matching a specialization to 26794b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// a template. 268083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 268183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionTemplate the function template for which we are performing 268283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template argument deduction. 268383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 26844b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param ExplicitTemplateArguments the explicitly-specified template 26854b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// arguments. 268683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 268783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param ArgFunctionType the function type that will be used as the 268883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// "argument" type (A) when performing template argument deduction from the 26894b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// function template's function type. This type may be NULL, if there is no 26904b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// argument type to compare against, in C++0x [temp.arg.explicit]p3. 269183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 269283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Specialization if template argument deduction was successful, 26931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// this will be set to the function template specialization produced by 269483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template argument deduction. 269583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 269683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Info the argument will be updated to provide additional information 269783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// about template argument deduction. 269883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 269983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \returns the result of template argument deduction. 270083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::TemplateDeductionResult 270183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 2702d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall const TemplateArgumentListInfo *ExplicitTemplateArgs, 270383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType ArgFunctionType, 270483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *&Specialization, 270583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 270683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 270783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 270883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 270983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType FunctionType = Function->getType(); 27101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 271183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Substitute any explicit template arguments. 27122a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 271302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> Deduced; 271402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified = 0; 271583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor llvm::SmallVector<QualType, 4> ParamTypes; 2716d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs) { 27171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (TemplateDeductionResult Result 27181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump = SubstituteExplicitTemplateArguments(FunctionTemplate, 2719d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall *ExplicitTemplateArgs, 27201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced, ParamTypes, 272183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor &FunctionType, Info)) 272283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return Result; 272302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 272402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified = Deduced.size(); 2725127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor } 272683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 272783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Template argument deduction for function templates in a SFINAE context. 272883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Trap any errors that might occur. 27291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 27301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2731eff92135d32039c9874dc356f3e93143af6069c1John McCall Deduced.resize(TemplateParams->size()); 2732eff92135d32039c9874dc356f3e93143af6069c1John McCall 27334b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (!ArgFunctionType.isNull()) { 27344b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor // Deduce template arguments from the function type. 27354b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (TemplateDeductionResult Result 2736a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = ::DeduceTemplateArguments(*this, TemplateParams, 27374b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor FunctionType, ArgFunctionType, Info, 27384b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor Deduced, 0)) 27394b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return Result; 27404b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor } 2741fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 2742fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor if (TemplateDeductionResult Result 2743fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 2744fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor NumExplicitlySpecified, 2745fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor Specialization, Info)) 2746fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return Result; 2747fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 2748fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor // If the requested function type does not match the actual type of the 2749fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor // specialization, template argument deduction fails. 2750fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor if (!ArgFunctionType.isNull() && 2751fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor !Context.hasSameType(ArgFunctionType, Specialization->getType())) 2752fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return TDK_NonDeducedMismatch; 2753fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 2754fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return TDK_Success; 2755e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor} 2756e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor 275765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \brief Deduce template arguments for a templated conversion 275865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// function (C++ [temp.deduct.conv]) and, if successful, produce a 275965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// conversion function template specialization. 276065ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::TemplateDeductionResult 276165ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 276265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType ToType, 276365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor CXXConversionDecl *&Specialization, 276465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateDeductionInfo &Info) { 27651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CXXConversionDecl *Conv 276665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor = cast<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()); 276765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType FromType = Conv->getConversionType(); 276865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 276965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Canonicalize the types for deduction. 277065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType P = Context.getCanonicalType(FromType); 277165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType A = Context.getCanonicalType(ToType); 277265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 277365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++0x [temp.deduct.conv]p3: 277465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // If P is a reference type, the type referred to by P is used for 277565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type deduction. 277665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (const ReferenceType *PRef = P->getAs<ReferenceType>()) 277765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = PRef->getPointeeType(); 277865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 277965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++0x [temp.deduct.conv]p3: 278065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // If A is a reference type, the type referred to by A is used 278165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // for type deduction. 278265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (const ReferenceType *ARef = A->getAs<ReferenceType>()) 278365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor A = ARef->getPointeeType(); 278465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++ [temp.deduct.conv]p2: 278565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // 27861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If A is not a reference type: 278765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else { 278865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor assert(!A->isReferenceType() && "Reference types were handled above"); 278965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 279065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is an array type, the pointer type produced by the 27911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // array-to-pointer standard conversion (4.2) is used in place 279265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // of P for type deduction; otherwise, 279365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (P->isArrayType()) 279465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = Context.getArrayDecayedType(P); 279565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is a function type, the pointer type produced by the 279665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // function-to-pointer standard conversion (4.3) is used in 279765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // place of P for type deduction; otherwise, 279865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else if (P->isFunctionType()) 279965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = Context.getPointerType(P); 280065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is a cv-qualified type, the top level cv-qualifiers of 280165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // P’s type are ignored for type deduction. 280265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else 280365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = P.getUnqualifiedType(); 280465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 280565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++0x [temp.deduct.conv]p3: 280665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // If A is a cv-qualified type, the top level cv-qualifiers of A’s 280765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type are ignored for type deduction. 280865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor A = A.getUnqualifiedType(); 280965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor } 281065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 281165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Template argument deduction for function templates in a SFINAE context. 281265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Trap any errors that might occur. 28131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 281465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 281565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++ [temp.deduct.conv]p1: 281665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Template argument deduction is done by comparing the return 281765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type of the template conversion function (call it P) with the 281865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type that is required as the result of the conversion (call it 281965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // A) as described in 14.8.2.4. 282065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateParameterList *TemplateParams 282165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor = FunctionTemplate->getTemplateParameters(); 282202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> Deduced; 28231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced.resize(TemplateParams->size()); 282465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 282565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++0x [temp.deduct.conv]p4: 282665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // In general, the deduction process attempts to find template 282765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // argument values that will make the deduced A identical to 282865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // A. However, there are two cases that allow a difference: 282965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor unsigned TDF = 0; 283065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If the original A is a reference type, A can be more 283165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // cv-qualified than the deduced A (i.e., the type referred to 283265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // by the reference) 283365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (ToType->isReferenceType()) 283465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TDF |= TDF_ParamWithReferenceType; 283565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - The deduced A can be another pointer or pointer to member 283665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type that can be converted to A via a qualification 283765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // conversion. 283865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // 283965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when 284065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // both P and A are pointers or member pointers. In this case, we 284165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // just ignore cv-qualifiers completely). 284265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if ((P->isPointerType() && A->isPointerType()) || 284365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor (P->isMemberPointerType() && P->isMemberPointerType())) 284465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TDF |= TDF_IgnoreQualifiers; 284565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (TemplateDeductionResult Result 2846a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = ::DeduceTemplateArguments(*this, TemplateParams, 284765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P, A, Info, Deduced, TDF)) 284865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return Result; 284965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 285065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // FIXME: we need to check that the deduced A is the same as A, 285165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // modulo the various allowed differences. 28521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 285365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Finish template argument deduction. 28542a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 285565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor FunctionDecl *Spec = 0; 285665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateDeductionResult Result 285702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 0, Spec, 285802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor Info); 285965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor Specialization = cast_or_null<CXXConversionDecl>(Spec); 286065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return Result; 286165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor} 286265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 28634b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \brief Deduce template arguments for a function template when there is 28644b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// nothing to deduce against (C++0x [temp.arg.explicit]p3). 28654b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 28664b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param FunctionTemplate the function template for which we are performing 28674b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template argument deduction. 28684b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 28694b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param ExplicitTemplateArguments the explicitly-specified template 28704b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// arguments. 28714b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 28724b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param Specialization if template argument deduction was successful, 28734b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// this will be set to the function template specialization produced by 28744b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template argument deduction. 28754b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 28764b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param Info the argument will be updated to provide additional information 28774b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// about template argument deduction. 28784b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 28794b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \returns the result of template argument deduction. 28804b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas GregorSema::TemplateDeductionResult 28814b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 28824b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor const TemplateArgumentListInfo *ExplicitTemplateArgs, 28834b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor FunctionDecl *&Specialization, 28844b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor TemplateDeductionInfo &Info) { 28854b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, 28864b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor QualType(), Specialization, Info); 28874b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor} 28884b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor 28898a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregorstatic void 2890e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, QualType T, 2891e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 2892ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Level, 2893e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Deduced); 289477bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 289577bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor/// \brief If this is a non-static member function, 289677bc572138543ef97ebec137522b763d6a6ee909Douglas Gregorstatic void MaybeAddImplicitObjectParameterType(ASTContext &Context, 289777bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor CXXMethodDecl *Method, 289877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor llvm::SmallVectorImpl<QualType> &ArgTypes) { 289977bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor if (Method->isStatic()) 290077bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor return; 290177bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 290277bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // C++ [over.match.funcs]p4: 290377bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // 290477bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // For non-static member functions, the type of the implicit 290577bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // object parameter is 290677bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // — "lvalue reference to cv X" for functions declared without a 290777bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // ref-qualifier or with the & ref-qualifier 290877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // - "rvalue reference to cv X" for functions declared with the 290977bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // && ref-qualifier 291077bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // 291177bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // FIXME: We don't have ref-qualifiers yet, so we don't do that part. 291277bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor QualType ArgTy = Context.getTypeDeclType(Method->getParent()); 291377bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor ArgTy = Context.getQualifiedType(ArgTy, 291477bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor Qualifiers::fromCVRMask(Method->getTypeQualifiers())); 291577bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor ArgTy = Context.getLValueReferenceType(ArgTy); 291677bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor ArgTypes.push_back(ArgTy); 291777bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor} 291877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 29198a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \brief Determine whether the function template \p FT1 is at least as 29208a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// specialized as \p FT2. 29218a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregorstatic bool isAtLeastAsSpecializedAs(Sema &S, 29225769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc, 29238a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionTemplateDecl *FT1, 29248a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionTemplateDecl *FT2, 29258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplatePartialOrderingContext TPOC, 29265c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned NumCallArguments, 29278a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor llvm::SmallVectorImpl<DeductionQualifierComparison> *QualifierComparisons) { 29288a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionDecl *FD1 = FT1->getTemplatedDecl(); 29298a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionDecl *FD2 = FT2->getTemplatedDecl(); 29308a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>(); 29318a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>(); 29328a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 29338a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor assert(Proto1 && Proto2 && "Function templates must have prototypes"); 29348a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplateParameterList *TemplateParams = FT2->getTemplateParameters(); 293502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> Deduced; 29368a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Deduced.resize(TemplateParams->size()); 29378a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 29388a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p3: 29398a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // The types used to determine the ordering depend on the context in which 29408a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // the partial ordering is done: 29412a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo Info(S.Context, Loc); 29428d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor CXXMethodDecl *Method1 = 0; 29438d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor CXXMethodDecl *Method2 = 0; 29448d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor bool IsNonStatic2 = false; 29458d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor bool IsNonStatic1 = false; 29468d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor unsigned Skip2 = 0; 29478a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor switch (TPOC) { 29488a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Call: { 29498a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - In the context of a function call, the function parameter types are 29508a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // used. 29518d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Method1 = dyn_cast<CXXMethodDecl>(FD1); 29528d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Method2 = dyn_cast<CXXMethodDecl>(FD2); 29538d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic1 = Method1 && !Method1->isStatic(); 29548d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic2 = Method2 && !Method2->isStatic(); 29558d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor 29568d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // C++0x [temp.func.order]p3: 29578d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // [...] If only one of the function templates is a non-static 29588d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // member, that function template is considered to have a new 29598d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // first parameter inserted in its function parameter list. The 29608d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // new parameter is of type "reference to cv A," where cv are 29618d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // the cv-qualifiers of the function template (if any) and A is 29628d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // the class of which the function template is a member. 29638d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // 29648d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // C++98/03 doesn't have this provision, so instead we drop the 29658d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // first argument of the free function or static member, which 29668d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // seems to match existing practice. 296777bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor llvm::SmallVector<QualType, 4> Args1; 29688d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor unsigned Skip1 = !S.getLangOptions().CPlusPlus0x && 29698d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic2 && !IsNonStatic1; 29708d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor if (S.getLangOptions().CPlusPlus0x && IsNonStatic1 && !IsNonStatic2) 29715c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor MaybeAddImplicitObjectParameterType(S.Context, Method1, Args1); 297277bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor Args1.insert(Args1.end(), 29738d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Proto1->arg_type_begin() + Skip1, Proto1->arg_type_end()); 297477bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 297577bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor llvm::SmallVector<QualType, 4> Args2; 29768d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Skip2 = !S.getLangOptions().CPlusPlus0x && 29778d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic1 && !IsNonStatic2; 29788d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor if (S.getLangOptions().CPlusPlus0x && IsNonStatic2 && !IsNonStatic1) 297977bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor MaybeAddImplicitObjectParameterType(S.Context, Method2, Args2); 298077bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor Args2.insert(Args2.end(), 29818d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Proto2->arg_type_begin() + Skip2, Proto2->arg_type_end()); 29825c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 29835c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++ [temp.func.order]p5: 29845c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // The presence of unused ellipsis and default arguments has no effect on 29855c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // the partial ordering of function templates. 29865c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (Args1.size() > NumCallArguments) 29875c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Args1.resize(NumCallArguments); 29885c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (Args2.size() > NumCallArguments) 29895c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Args2.resize(NumCallArguments); 29905c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(), 29915c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Args1.data(), Args1.size(), Info, Deduced, 29925c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor TDF_None, /*PartialOrdering=*/true, 29935c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor QualifierComparisons)) 29948a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 29958a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 29968a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 29978a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 29988a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 29998a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Conversion: 30008a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - In the context of a call to a conversion operator, the return types 30018a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // of the conversion function templates are used. 30025c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (DeduceTemplateArguments(S, TemplateParams, Proto2->getResultType(), 30035c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Proto1->getResultType(), Info, Deduced, 30045c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor TDF_None, /*PartialOrdering=*/true, 30055c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor QualifierComparisons)) 30068a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 30078a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 30088a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30098a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Other: 30108a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - In other contexts (14.6.6.2) the function template’s function type 30118a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // is used. 30125c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // FIXME: Don't we actually want to perform the adjustments on the parameter 30135c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // types? 30145c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (DeduceTemplateArguments(S, TemplateParams, FD2->getType(), 30155c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor FD1->getType(), Info, Deduced, TDF_None, 30165c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor /*PartialOrdering=*/true, QualifierComparisons)) 30178a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 30188a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 30198a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 30208a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30218a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p11: 30228a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // In most cases, all template parameters must have values in order for 30238a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // deduction to succeed, but for partial ordering purposes a template 30248a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // parameter may remain without a value provided it is not used in the 30258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // types being used for partial ordering. [ Note: a template parameter used 30268a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // in a non-deduced context is considered used. -end note] 30278a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor unsigned ArgIdx = 0, NumArgs = Deduced.size(); 30288a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor for (; ArgIdx != NumArgs; ++ArgIdx) 30298a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Deduced[ArgIdx].isNull()) 30308a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 30318a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30328a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (ArgIdx == NumArgs) { 30338a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // All template arguments were deduced. FT1 is at least as specialized 30348a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // as FT2. 30358a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return true; 30368a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 30378a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 3038e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // Figure out which template parameters were used. 30398a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor llvm::SmallVector<bool, 4> UsedParameters; 30408a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor UsedParameters.resize(TemplateParams->size()); 30418a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor switch (TPOC) { 30428a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Call: { 30435c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned NumParams = std::min(NumCallArguments, 30445c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor std::min(Proto1->getNumArgs(), 30455c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Proto2->getNumArgs())); 30468d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor if (S.getLangOptions().CPlusPlus0x && IsNonStatic2 && !IsNonStatic1) 30478d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor ::MarkUsedTemplateParameters(S, Method2->getThisType(S.Context), false, 30488d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor TemplateParams->getDepth(), UsedParameters); 30498d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor for (unsigned I = Skip2; I < NumParams; ++I) 3050ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor ::MarkUsedTemplateParameters(S, Proto2->getArgType(I), false, 3051ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 3052e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor UsedParameters); 30538a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 30548a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 30558a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30568a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Conversion: 3057ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor ::MarkUsedTemplateParameters(S, Proto2->getResultType(), false, 3058ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 3059e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor UsedParameters); 30608a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 30618a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30628a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Other: 3063ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor ::MarkUsedTemplateParameters(S, FD2->getType(), false, 3064ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 3065ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor UsedParameters); 30668a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 30678a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 30688a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30698a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor for (; ArgIdx != NumArgs; ++ArgIdx) 30708a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // If this argument had no value deduced but was used in one of the types 30718a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // used for partial ordering, then deduction fails. 30728a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx]) 30738a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 30748a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30758a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return true; 30768a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor} 30778a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 30789da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor/// \brief Determine whether this a function template whose parameter-type-list 30799da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor/// ends with a function parameter pack. 30809da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregorstatic bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) { 30819da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor FunctionDecl *Function = FunTmpl->getTemplatedDecl(); 30829da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor unsigned NumParams = Function->getNumParams(); 30839da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (NumParams == 0) 30849da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return false; 30859da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor 30869da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor ParmVarDecl *Last = Function->getParamDecl(NumParams - 1); 30879da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (!Last->isParameterPack()) 30889da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return false; 30899da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor 30909da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // Make sure that no previous parameter is a parameter pack. 30919da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor while (--NumParams > 0) { 30929da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (Function->getParamDecl(NumParams - 1)->isParameterPack()) 30939da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return false; 30949da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor } 30959da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor 30969da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return true; 30979da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor} 30988a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 3099bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \brief Returns the more specialized function template according 310065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// to the rules of function template partial ordering (C++ [temp.func.order]). 310165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 310265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \param FT1 the first function template 310365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 310465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \param FT2 the second function template 310565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 31068a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \param TPOC the context in which we are performing partial ordering of 31078a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// function templates. 31081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// 31095c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param NumCallArguments The number of arguments in a call, used only 31105c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// when \c TPOC is \c TPOC_Call. 31115c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 3112bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \returns the more specialized function template. If neither 311365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// template is more specialized, returns NULL. 311465ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorFunctionTemplateDecl * 311565ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, 311665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor FunctionTemplateDecl *FT2, 31175769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc, 31185c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor TemplatePartialOrderingContext TPOC, 31195c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned NumCallArguments) { 31208a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor llvm::SmallVector<DeductionQualifierComparison, 4> QualifierComparisons; 31215c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC, 31225c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor NumCallArguments, 0); 31235769d6195087229770d7ac90449443e026c47103John McCall bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC, 31245c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor NumCallArguments, 31258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor &QualifierComparisons); 31268a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 31278a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Better1 != Better2) // We have a clear winner 31288a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return Better1? FT1 : FT2; 31298a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 31308a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (!Better1 && !Better2) // Neither is better than the other 313165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return 0; 31328a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 31338a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 31348a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p10: 31358a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // If for each type being considered a given template is at least as 31368a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized for all types and more specialized for some set of types and 31378a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // the other template is not more specialized for any types or is not at 31388a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // least as specialized for any types, then the given template is more 31398a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized than the other template. Otherwise, neither template is more 31408a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized than the other. 31418a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better1 = false; 31428a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better2 = false; 31438a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor for (unsigned I = 0, N = QualifierComparisons.size(); I != N; ++I) { 31448a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p9: 31458a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // If, for a given type, deduction succeeds in both directions (i.e., the 31468a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // types are identical after the transformations above) and if the type 31478a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // from the argument template is more cv-qualified than the type from the 31488a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // parameter template (as described above) that type is considered to be 31498a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // more specialized than the other. If neither type is more cv-qualified 31508a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // than the other then neither type is more specialized than the other. 31518a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor switch (QualifierComparisons[I]) { 31528a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case NeitherMoreQualified: 31538a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 31548a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 31558a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case ParamMoreQualified: 31568a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better1 = true; 31578a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Better2) 31588a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return 0; 31598a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 31608a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 31618a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case ArgMoreQualified: 31628a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better2 = true; 31638a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Better1) 31648a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return 0; 31658a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 31668a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 31678a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 31688a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 31698a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor assert(!(Better1 && Better2) && "Should have broken out in the loop above"); 317065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (Better1) 317165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return FT1; 31728a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor else if (Better2) 31738a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return FT2; 31749da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor 31759da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // FIXME: This mimics what GCC implements, but doesn't match up with the 31769da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // proposed resolution for core issue 692. This area needs to be sorted out, 31779da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // but for now we attempt to maintain compatibility. 31789da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor bool Variadic1 = isVariadicFunctionTemplate(FT1); 31799da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor bool Variadic2 = isVariadicFunctionTemplate(FT2); 31809da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (Variadic1 != Variadic2) 31819da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return Variadic1? FT2 : FT1; 31829da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor 31839da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return 0; 318465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor} 318583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 3186d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \brief Determine if the two templates are equivalent. 3187d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregorstatic bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) { 3188d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (T1 == T2) 3189d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return true; 3190d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3191d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (!T1 || !T2) 3192d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return false; 3193d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3194d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return T1->getCanonicalDecl() == T2->getCanonicalDecl(); 3195d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor} 3196d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3197d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \brief Retrieve the most specialized of the given function template 3198d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// specializations. 3199d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3200c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// \param SpecBegin the start iterator of the function template 3201c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// specializations that we will be comparing. 3202d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3203c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// \param SpecEnd the end iterator of the function template 3204c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// specializations, paired with \p SpecBegin. 3205d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3206d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param TPOC the partial ordering context to use to compare the function 3207d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// template specializations. 3208d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 32095c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param NumCallArguments The number of arguments in a call, used only 32105c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// when \c TPOC is \c TPOC_Call. 32115c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 3212d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param Loc the location where the ambiguity or no-specializations 3213d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// diagnostic should occur. 3214d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3215d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param NoneDiag partial diagnostic used to diagnose cases where there are 3216d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// no matching candidates. 3217d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3218d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one 3219d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// occurs. 3220d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3221d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param CandidateDiag partial diagnostic used for each function template 3222d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// specialization that is a candidate in the ambiguous ordering. One parameter 3223d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// in this diagnostic should be unbound, which will correspond to the string 3224d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// describing the template arguments for the function template specialization. 3225d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3226d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param Index if non-NULL and the result of this function is non-nULL, 3227d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// receives the index corresponding to the resulting function template 3228d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// specialization. 3229d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3230d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \returns the most specialized function template specialization, if 3231c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// found. Otherwise, returns SpecEnd. 3232d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 3233d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \todo FIXME: Consider passing in the "also-ran" candidates that failed 3234d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// template argument deduction. 3235c373d48502ca7683ab55385f5bd624d778eb288dJohn McCallUnresolvedSetIterator 3236c373d48502ca7683ab55385f5bd624d778eb288dJohn McCallSema::getMostSpecialized(UnresolvedSetIterator SpecBegin, 32375c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor UnresolvedSetIterator SpecEnd, 3238c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall TemplatePartialOrderingContext TPOC, 32395c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned NumCallArguments, 3240c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall SourceLocation Loc, 3241c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall const PartialDiagnostic &NoneDiag, 3242c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall const PartialDiagnostic &AmbigDiag, 3243c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall const PartialDiagnostic &CandidateDiag) { 3244c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall if (SpecBegin == SpecEnd) { 3245d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Diag(Loc, NoneDiag); 3246c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecEnd; 3247d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3248d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3249c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall if (SpecBegin + 1 == SpecEnd) 3250c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecBegin; 3251d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3252d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Find the function template that is better than all of the templates it 3253d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // has been compared to. 3254c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall UnresolvedSetIterator Best = SpecBegin; 3255d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor FunctionTemplateDecl *BestTemplate 3256c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*Best)->getPrimaryTemplate(); 3257d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor assert(BestTemplate && "Not a function template specialization?"); 3258c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) { 3259c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall FunctionTemplateDecl *Challenger 3260c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*I)->getPrimaryTemplate(); 3261d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor assert(Challenger && "Not a function template specialization?"); 3262c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, 32635c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Loc, TPOC, NumCallArguments), 3264d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Challenger)) { 3265d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Best = I; 3266d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor BestTemplate = Challenger; 3267d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3268d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3269d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3270d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Make sure that the "best" function template is more specialized than all 3271d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // of the others. 3272d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor bool Ambiguous = false; 3273c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { 3274c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall FunctionTemplateDecl *Challenger 3275c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*I)->getPrimaryTemplate(); 3276d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (I != Best && 3277d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor !isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, 32785c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Loc, TPOC, NumCallArguments), 3279d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor BestTemplate)) { 3280d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Ambiguous = true; 3281d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor break; 3282d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3283d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3284d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3285d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (!Ambiguous) { 3286d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // We found an answer. Return it. 3287c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return Best; 3288d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 3289d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3290d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Diagnose the ambiguity. 3291d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Diag(Loc, AmbigDiag); 3292d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3293d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // FIXME: Can we order the candidates in some sane way? 3294c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) 3295c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall Diag((*I)->getLocation(), CandidateDiag) 3296d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor << getTemplateArgumentBindingsText( 3297c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall cast<FunctionDecl>(*I)->getPrimaryTemplate()->getTemplateParameters(), 3298c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall *cast<FunctionDecl>(*I)->getTemplateSpecializationArgs()); 3299d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3300c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecEnd; 3301d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor} 3302d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 3303bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \brief Returns the more specialized class template partial specialization 3304bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// according to the rules of partial ordering of class template partial 3305bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// specializations (C++ [temp.class.order]). 3306bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 3307bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \param PS1 the first class template partial specialization 3308bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 3309bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \param PS2 the second class template partial specialization 3310bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 3311bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \returns the more specialized class template partial specialization. If 3312bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// neither partial specialization is more specialized, returns NULL. 3313bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas GregorClassTemplatePartialSpecializationDecl * 3314bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas GregorSema::getMoreSpecializedPartialSpecialization( 3315bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor ClassTemplatePartialSpecializationDecl *PS1, 33165769d6195087229770d7ac90449443e026c47103John McCall ClassTemplatePartialSpecializationDecl *PS2, 33175769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc) { 3318bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // C++ [temp.class.order]p1: 3319bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // For two class template partial specializations, the first is at least as 3320bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // specialized as the second if, given the following rewrite to two 3321bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // function templates, the first function template is at least as 3322bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // specialized as the second according to the ordering rules for function 3323bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // templates (14.6.6.2): 3324bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // - the first function template has the same template parameters as the 3325bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // first partial specialization and has a single function parameter 3326bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // whose type is a class template specialization with the template 3327bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // arguments of the first partial specialization, and 3328bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // - the second function template has the same template parameters as the 3329bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // second partial specialization and has a single function parameter 3330bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // whose type is a class template specialization with the template 3331bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // arguments of the second partial specialization. 3332bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // 333331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // Rather than synthesize function templates, we merely perform the 333431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // equivalent partial ordering by performing deduction directly on 333531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // the template arguments of the class template partial 333631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // specializations. This computation is slightly simpler than the 333731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // general problem of function template partial ordering, because 333831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // class template partial specializations are more constrained. We 333931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // know that every template parameter is deducible from the class 334031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // template partial specialization's template arguments, for 334131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // example. 334202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVector<DeducedTemplateArgument, 4> Deduced; 33432a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo Info(Context, Loc); 334431f17ecbef57b5679c017c375db330546b7b5145John McCall 334531f17ecbef57b5679c017c375db330546b7b5145John McCall QualType PT1 = PS1->getInjectedSpecializationType(); 334631f17ecbef57b5679c017c375db330546b7b5145John McCall QualType PT2 = PS2->getInjectedSpecializationType(); 3347bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor 3348bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // Determine whether PS1 is at least as specialized as PS2 3349bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Deduced.resize(PS2->getTemplateParameters()->size()); 33505c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor bool Better1 = !::DeduceTemplateArguments(*this, PS2->getTemplateParameters(), 33515c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor PT2, PT1, Info, Deduced, TDF_None, 33525c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor /*PartialOrdering=*/true, 33535c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor /*QualifierComparisons=*/0); 33542c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis if (Better1) { 33552c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2, 33562c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis Deduced.data(), Deduced.size(), Info); 3357516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Better1 = !::FinishTemplateArgumentDeduction(*this, PS2, 3358516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor PS1->getTemplateArgs(), 3359516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Deduced, Info); 33602c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis } 3361516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor 3362bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // Determine whether PS2 is at least as specialized as PS1 3363db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Deduced.clear(); 3364bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Deduced.resize(PS1->getTemplateParameters()->size()); 33655c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor bool Better2 = !::DeduceTemplateArguments(*this, PS1->getTemplateParameters(), 33665c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor PT1, PT2, Info, Deduced, TDF_None, 33675c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor /*PartialOrdering=*/true, 33685c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor /*QualifierComparisons=*/0); 33692c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis if (Better2) { 33702c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1, 33712c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis Deduced.data(), Deduced.size(), Info); 3372516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Better2 = !::FinishTemplateArgumentDeduction(*this, PS1, 3373516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor PS2->getTemplateArgs(), 3374516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Deduced, Info); 33752c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis } 3376bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor 3377bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor if (Better1 == Better2) 3378bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor return 0; 3379bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor 3380bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor return Better1? PS1 : PS2; 3381bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor} 3382bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor 33831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 3384e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, 3385e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const TemplateArgument &TemplateArg, 3386e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3387ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 3388e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used); 3389031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3390e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 3391031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// expression. 33921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 3393e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, 3394e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const Expr *E, 3395e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3396ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 3397e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used) { 3398be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor // We can deduce from a pack expansion. 3399be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor if (const PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(E)) 3400be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor E = Expansion->getPattern(); 3401be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor 340254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Skip through any implicit casts we added while type-checking. 340354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 340454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor E = ICE->getSubExpr(); 340554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 3406e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // FIXME: if !OnlyDeduced, we have to walk the whole subexpression to 3407e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // find other occurrences of template parameters. 3408f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 3409c781f9cd854f3d5d1c826f4a13382c6abca4cff7Douglas Gregor if (!DRE) 3410031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 3411031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 34121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const NonTypeTemplateParmDecl *NTTP 3413031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()); 3414031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (!NTTP) 3415031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 3416031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3417ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (NTTP->getDepth() == Depth) 3418ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[NTTP->getIndex()] = true; 3419031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 3420031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3421e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 3422e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// nested name specifier. 3423e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregorstatic void 3424e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, 3425e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor NestedNameSpecifier *NNS, 3426e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3427ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 3428e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used) { 3429e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!NNS) 3430e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 3431e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 3432ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor MarkUsedTemplateParameters(SemaRef, NNS->getPrefix(), OnlyDeduced, Depth, 3433ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used); 3434e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, QualType(NNS->getAsType(), 0), 3435ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3436e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor} 3437e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 3438e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 3439e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// template name. 3440e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregorstatic void 3441e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, 3442e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor TemplateName Name, 3443e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3444ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 3445e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used) { 3446e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 3447e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (TemplateTemplateParmDecl *TTP 3448ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor = dyn_cast<TemplateTemplateParmDecl>(Template)) { 3449ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (TTP->getDepth() == Depth) 3450ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[TTP->getIndex()] = true; 3451ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor } 3452e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 3453e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor } 3454e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 3455788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) 3456788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor MarkUsedTemplateParameters(SemaRef, QTN->getQualifier(), OnlyDeduced, 3457788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Depth, Used); 3458e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) 3459ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor MarkUsedTemplateParameters(SemaRef, DTN->getQualifier(), OnlyDeduced, 3460ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3461e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor} 3462e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 3463e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 3464031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// type. 34651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 3466e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, QualType T, 3467e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3468ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 3469e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used) { 3470e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (T.isNull()) 3471e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 3472e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 3473031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor // Non-dependent types have nothing deducible 3474031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (!T->isDependentType()) 3475031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 3476031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3477031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor T = SemaRef.Context.getCanonicalType(T); 3478031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor switch (T->getTypeClass()) { 3479031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Pointer: 3480e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3481e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<PointerType>(T)->getPointeeType(), 3482e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 3483ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 3484e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 3485031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3486031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3487031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::BlockPointer: 3488e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3489e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<BlockPointerType>(T)->getPointeeType(), 3490e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 3491ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 3492e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 3493031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3494031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3495031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::LValueReference: 3496031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::RValueReference: 3497e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3498e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ReferenceType>(T)->getPointeeType(), 3499e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 3500ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 3501e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 3502031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3503031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3504031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::MemberPointer: { 3505031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr()); 3506e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, MemPtr->getPointeeType(), OnlyDeduced, 3507ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3508e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, QualType(MemPtr->getClass(), 0), 3509ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3510031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3511031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 3512031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3513031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::DependentSizedArray: 3514e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3515e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<DependentSizedArrayType>(T)->getSizeExpr(), 3516ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3517031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor // Fall through to check the element type 3518031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3519031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ConstantArray: 3520031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::IncompleteArray: 3521e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3522e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ArrayType>(T)->getElementType(), 3523ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3524031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3525031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3526031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Vector: 3527031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ExtVector: 3528e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3529e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<VectorType>(T)->getElementType(), 3530ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3531031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3532031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 35339cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor case Type::DependentSizedExtVector: { 35349cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor const DependentSizedExtVectorType *VecType 3535f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor = cast<DependentSizedExtVectorType>(T); 3536e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, VecType->getElementType(), OnlyDeduced, 3537ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3538e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, VecType->getSizeExpr(), OnlyDeduced, 3539ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 35409cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor break; 35419cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor } 35429cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 3543031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::FunctionProto: { 3544f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor const FunctionProtoType *Proto = cast<FunctionProtoType>(T); 3545e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, Proto->getResultType(), OnlyDeduced, 3546ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3547031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I) 3548e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, Proto->getArgType(I), OnlyDeduced, 3549ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3550031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3551031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 3552031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3553ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor case Type::TemplateTypeParm: { 3554ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor const TemplateTypeParmType *TTP = cast<TemplateTypeParmType>(T); 3555ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (TTP->getDepth() == Depth) 3556ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[TTP->getIndex()] = true; 3557031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3558ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor } 3559031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 35600bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor case Type::SubstTemplateTypeParmPack: { 35610bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor const SubstTemplateTypeParmPackType *Subst 35620bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor = cast<SubstTemplateTypeParmPackType>(T); 35630bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor MarkUsedTemplateParameters(SemaRef, 35640bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor QualType(Subst->getReplacedParameter(), 0), 35650bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor OnlyDeduced, Depth, Used); 35660bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor MarkUsedTemplateParameters(SemaRef, Subst->getArgumentPack(), 35670bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor OnlyDeduced, Depth, Used); 35680bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor break; 35690bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor } 35700bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor 357131f17ecbef57b5679c017c375db330546b7b5145John McCall case Type::InjectedClassName: 357231f17ecbef57b5679c017c375db330546b7b5145John McCall T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType(); 357331f17ecbef57b5679c017c375db330546b7b5145John McCall // fall through 357431f17ecbef57b5679c017c375db330546b7b5145John McCall 3575031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::TemplateSpecialization: { 35761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const TemplateSpecializationType *Spec 3577f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor = cast<TemplateSpecializationType>(T); 3578e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, Spec->getTemplateName(), OnlyDeduced, 3579ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 35807b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 35817b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 35827b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // If the template argument list of P contains a pack expansion that is not 35837b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // the last template argument, the entire template argument list is a 35847b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 35857b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (OnlyDeduced && 35867b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) 35877b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor break; 35887b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 3589e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) 3590ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor MarkUsedTemplateParameters(SemaRef, Spec->getArg(I), OnlyDeduced, Depth, 3591ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used); 3592e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor break; 3593e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor } 35941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3595e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor case Type::Complex: 3596e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!OnlyDeduced) 3597e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3598e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ComplexType>(T)->getElementType(), 3599ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3600e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor break; 3601031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 36024714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor case Type::DependentName: 3603e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!OnlyDeduced) 3604e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, 36054714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor cast<DependentNameType>(T)->getQualifier(), 3606ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 3607031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3608031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 360933500955d731c73717af52088b7fc0e7a85681e7John McCall case Type::DependentTemplateSpecialization: { 361033500955d731c73717af52088b7fc0e7a85681e7John McCall const DependentTemplateSpecializationType *Spec 361133500955d731c73717af52088b7fc0e7a85681e7John McCall = cast<DependentTemplateSpecializationType>(T); 361233500955d731c73717af52088b7fc0e7a85681e7John McCall if (!OnlyDeduced) 361333500955d731c73717af52088b7fc0e7a85681e7John McCall MarkUsedTemplateParameters(SemaRef, Spec->getQualifier(), 361433500955d731c73717af52088b7fc0e7a85681e7John McCall OnlyDeduced, Depth, Used); 36157b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 36167b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 36177b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // If the template argument list of P contains a pack expansion that is not 36187b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // the last template argument, the entire template argument list is a 36197b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 36207b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (OnlyDeduced && 36217b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) 36227b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor break; 36237b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 362433500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) 362533500955d731c73717af52088b7fc0e7a85681e7John McCall MarkUsedTemplateParameters(SemaRef, Spec->getArg(I), OnlyDeduced, Depth, 362633500955d731c73717af52088b7fc0e7a85681e7John McCall Used); 362733500955d731c73717af52088b7fc0e7a85681e7John McCall break; 362833500955d731c73717af52088b7fc0e7a85681e7John McCall } 362933500955d731c73717af52088b7fc0e7a85681e7John McCall 3630ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::TypeOf: 3631ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 3632ad5e73887052193afda72db8efcb812bd083a4a8John McCall MarkUsedTemplateParameters(SemaRef, 3633ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<TypeOfType>(T)->getUnderlyingType(), 3634ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 3635ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 3636ad5e73887052193afda72db8efcb812bd083a4a8John McCall 3637ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::TypeOfExpr: 3638ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 3639ad5e73887052193afda72db8efcb812bd083a4a8John McCall MarkUsedTemplateParameters(SemaRef, 3640ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<TypeOfExprType>(T)->getUnderlyingExpr(), 3641ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 3642ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 3643ad5e73887052193afda72db8efcb812bd083a4a8John McCall 3644ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::Decltype: 3645ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 3646ad5e73887052193afda72db8efcb812bd083a4a8John McCall MarkUsedTemplateParameters(SemaRef, 3647ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<DecltypeType>(T)->getUnderlyingExpr(), 3648ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 3649ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 3650ad5e73887052193afda72db8efcb812bd083a4a8John McCall 36517536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor case Type::PackExpansion: 36527536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor MarkUsedTemplateParameters(SemaRef, 36537536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor cast<PackExpansionType>(T)->getPattern(), 36547536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor OnlyDeduced, Depth, Used); 36557536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor break; 36567536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 3657e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // None of these types have any template parameters in them. 3658031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Builtin: 3659031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::VariableArray: 3660031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::FunctionNoProto: 3661031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Record: 3662031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Enum: 3663031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ObjCInterface: 3664c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: 3665d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff case Type::ObjCObjectPointer: 3666ed97649e9574b9d854fa4d6109c9333ae0993554John McCall case Type::UnresolvedUsing: 3667031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define TYPE(Class, Base) 3668031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 3669031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define DEPENDENT_TYPE(Class, Base) 3670031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 3671031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#include "clang/AST/TypeNodes.def" 3672031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3673031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 3674031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 3675031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3676e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by this 3677031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// template argument. 36781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 3679e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorMarkUsedTemplateParameters(Sema &SemaRef, 3680e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const TemplateArgument &TemplateArg, 3681e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3682ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 3683e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used) { 3684031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor switch (TemplateArg.getKind()) { 3685031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Null: 3686031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Integral: 3687788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Declaration: 3688031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 36891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3690031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Type: 3691e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, TemplateArg.getAsType(), OnlyDeduced, 3692ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3693031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3694031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3695788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 3696a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 3697a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor MarkUsedTemplateParameters(SemaRef, 3698a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor TemplateArg.getAsTemplateOrTemplatePattern(), 3699788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor OnlyDeduced, Depth, Used); 3700031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3701031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3702031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Expression: 3703e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor MarkUsedTemplateParameters(SemaRef, TemplateArg.getAsExpr(), OnlyDeduced, 3704ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3705031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 3706e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 3707d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson case TemplateArgument::Pack: 3708e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(), 3709e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor PEnd = TemplateArg.pack_end(); 3710e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor P != PEnd; ++P) 3711ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor MarkUsedTemplateParameters(SemaRef, *P, OnlyDeduced, Depth, Used); 3712d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson break; 3713031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 3714031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 3715031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 3716031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \brief Mark the template parameters can be deduced by the given 3717031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// template argument list. 3718031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// 3719031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \param TemplateArgs the template argument list from which template 3720031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// parameters will be deduced. 3721031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// 3722031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \param Deduced a bit vector whose elements will be set to \c true 3723031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// to indicate when the corresponding template parameter will be 3724031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// deduced. 37251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid 3726e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorSema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs, 3727ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor bool OnlyDeduced, unsigned Depth, 3728e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor llvm::SmallVectorImpl<bool> &Used) { 37297b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 37307b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // If the template argument list of P contains a pack expansion that is not 37317b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // the last template argument, the entire template argument list is a 37327b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 37337b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (OnlyDeduced && 37347b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size())) 37357b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return; 37367b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 3737031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) 3738ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor ::MarkUsedTemplateParameters(*this, TemplateArgs[I], OnlyDeduced, 3739ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 3740031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 374163f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor 374263f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor/// \brief Marks all of the template parameters that will be deduced by a 374363f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor/// call to the given function template. 374402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregorvoid 374502024a9f0d8e6c898de276193af604c42ee41269Douglas GregorSema::MarkDeducedTemplateParameters(FunctionTemplateDecl *FunctionTemplate, 374602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor llvm::SmallVectorImpl<bool> &Deduced) { 374763f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor TemplateParameterList *TemplateParams 374863f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor = FunctionTemplate->getTemplateParameters(); 374963f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor Deduced.clear(); 375063f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor Deduced.resize(TemplateParams->size()); 375163f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor 375263f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 375363f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) 375463f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor ::MarkUsedTemplateParameters(*this, Function->getParamDecl(I)->getType(), 3755ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor true, TemplateParams->getDepth(), Deduced); 375663f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor} 3757