SemaTemplateDeduction.cpp revision 80ad52f327b532bded5c5b0ee38779d841c6cd35
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 132a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall#include "clang/Sema/TemplateDeduction.h" 1455fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "TreeTransform.h" 150b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/ASTContext.h" 167cd088e519d7e6caa4c4c12db52e0e4ae35d25c2John McCall#include "clang/AST/DeclObjC.h" 170b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/DeclTemplate.h" 180b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/Expr.h" 190b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor#include "clang/AST/ExprCXX.h" 2055fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "clang/AST/StmtVisitor.h" 2155fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "clang/Sema/DeclSpec.h" 2255fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "clang/Sema/Sema.h" 2355fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "clang/Sema/Template.h" 24013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer#include "llvm/ADT/SmallBitVector.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. 5273b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor TDF_SkipNonDependent = 0x08, 5373b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor /// \brief Whether we are performing template argument deduction for 54dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi /// parameters and arguments in a top-level template argument 5573b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor TDF_TopLevelParameterTypeList = 0x10 56508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor }; 57508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor} 58508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor 590b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregorusing namespace clang; 600b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 619d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor/// \brief Compare two APSInts, extending and switching the sign as 629d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor/// necessary to compare their values regardless of underlying type. 639d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregorstatic bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) { 649d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if (Y.getBitWidth() > X.getBitWidth()) 659f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad X = X.extend(Y.getBitWidth()); 669d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor else if (Y.getBitWidth() < X.getBitWidth()) 679f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad Y = Y.extend(X.getBitWidth()); 689d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 699d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor // If there is a signedness mismatch, correct it. 709d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if (X.isSigned() != Y.isSigned()) { 719d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor // If the signed value is negative, then the values cannot be the same. 729d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor if ((Y.isSigned() && Y.isNegative()) || (X.isSigned() && X.isNegative())) 739d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor return false; 749d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 759d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor Y.setIsSigned(true); 769d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor X.setIsSigned(true); 779d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor } 789d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 799d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor return X == Y; 809d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor} 819d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor 82f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 83a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 84f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 85f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor const TemplateArgument &Param, 8677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor TemplateArgument Arg, 872a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 885f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced); 89d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 90b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// \brief Whether template argument deduction for two reference parameters 91b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// resulted in the argument type, parameter type, or neither type being more 92b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// qualified than the other. 93dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumienum DeductionQualifierComparison { 94dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NeitherMoreQualified = 0, 95dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi ParamMoreQualified, 96dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi ArgMoreQualified 975c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor}; 985c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 99b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// \brief Stores the result of comparing two reference parameters while 100b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// performing template argument deduction for partial ordering of function 101dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// templates. 102b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregorstruct RefParamPartialOrderingComparison { 103b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /// \brief Whether the parameter type is an rvalue reference type. 104b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor bool ParamIsRvalueRef; 105b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /// \brief Whether the argument type is an rvalue reference type. 106b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor bool ArgIsRvalueRef; 107dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 108b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /// \brief Whether the parameter or argument (or neither) is more qualified. 109b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor DeductionQualifierComparison Qualifiers; 110b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor}; 111b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor 112b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor 1135c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor 11420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregorstatic Sema::TemplateDeductionResult 115bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian RedlDeduceTemplateArgumentsByTypeMatch(Sema &S, 116bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TemplateParameterList *TemplateParams, 117bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType Param, 118bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType Arg, 119bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TemplateDeductionInfo &Info, 120bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl SmallVectorImpl<DeducedTemplateArgument> & 121bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Deduced, 122bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl unsigned TDF, 123bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl bool PartialOrdering = false, 124bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl SmallVectorImpl<RefParamPartialOrderingComparison> * 125b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons = 0); 126603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 127603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic Sema::TemplateDeductionResult 128603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas GregorDeduceTemplateArguments(Sema &S, 129603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateParameterList *TemplateParams, 13020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Params, unsigned NumParams, 13120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Args, unsigned NumArgs, 13220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateDeductionInfo &Info, 133030a6644f253818b81b4d8a7fc1770c0a3d35474Richard Smith SmallVectorImpl<DeducedTemplateArgument> &Deduced); 13420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 135199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \brief If the given expression is of a form that permits the deduction 136199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// of a non-type template parameter, return the declaration of that 137199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// non-type template parameter. 138199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregorstatic NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) { 1395a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith // If we are within an alias template, the expression may have undergone 1405a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith // any number of parameter substitutions already. 1415a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith while (1) { 1425a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E)) 1435a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith E = IC->getSubExpr(); 1445a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith else if (SubstNonTypeTemplateParmExpr *Subst = 1455a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith dyn_cast<SubstNonTypeTemplateParmExpr>(E)) 1465a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith E = Subst->getReplacement(); 1475a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith else 1485a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith break; 1495a343d7856e5de04fd92b6192e94becddf541e3eRichard Smith } 1501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 151199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 152199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()); 1531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 154199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor return 0; 155199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 156199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1570d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \brief Determine whether two declaration pointers refer to the same 1580d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// declaration. 1590d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregorstatic bool isSameDeclaration(Decl *X, Decl *Y) { 1600d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (NamedDecl *NX = dyn_cast<NamedDecl>(X)) 1610d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X = NX->getUnderlyingDecl(); 1620d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (NamedDecl *NY = dyn_cast<NamedDecl>(Y)) 1630d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y = NY->getUnderlyingDecl(); 164dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1650d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X->getCanonicalDecl() == Y->getCanonicalDecl(); 1660d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor} 1670d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1680d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \brief Verify that the given, deduced template arguments are compatible. 1690d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// 1700d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// \returns The deduced template argument, or a NULL template argument if 1710d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor/// the deduced template arguments were incompatible. 172dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic DeducedTemplateArgument 1730d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas GregorcheckDeducedTemplateArguments(ASTContext &Context, 1740d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor const DeducedTemplateArgument &X, 1750d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor const DeducedTemplateArgument &Y) { 1760d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // We have no deduction for one or both of the arguments; they're compatible. 1770d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (X.isNull()) 1780d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Y; 1790d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.isNull()) 180dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return X; 1810d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1820d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor switch (X.getKind()) { 1830d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Null: 1840d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor llvm_unreachable("Non-deduced template arguments handled above"); 1850d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 1860d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Type: 1870d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If two template type arguments have the same type, they're compatible. 1880d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Type && 1890d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Context.hasSameType(X.getAsType(), Y.getAsType())) 1900d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 191dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1920d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 193dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1940d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Integral: 1950d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a constant in one case and either a dependent expression or 1960d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // declaration in another case, keep the integral constant. 1970d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If both are integral constants with the same value, keep that value. 1980d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression || 1990d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getKind() == TemplateArgument::Declaration || 2000d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor (Y.getKind() == TemplateArgument::Integral && 201855243789cb44799c03f4c7216d3d6308805f549Benjamin Kramer hasSameExtendedValue(X.getAsIntegral(), Y.getAsIntegral()))) 202dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeducedTemplateArgument(X, 2030d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.wasDeducedFromArrayBound() && 2040d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.wasDeducedFromArrayBound()); 2050d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 2060d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 2070d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 208dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2090d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Template: 2100d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Template && 2110d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate())) 2120d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 213dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2140d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 215dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeducedTemplateArgument(); 216a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 217a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 218a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor if (Y.getKind() == TemplateArgument::TemplateExpansion && 219dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(), 220a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Y.getAsTemplateOrTemplatePattern())) 221a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return X; 222dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 223a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor // All other combinations are incompatible. 224dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeducedTemplateArgument(); 225a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 2260d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Expression: 227dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If we deduced a dependent expression in one case and either an integral 228dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // constant or a declaration in another case, keep the integral constant 2290d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // or declaration. 2300d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Integral || 2310d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getKind() == TemplateArgument::Declaration) 2320d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() && 2330d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.wasDeducedFromArrayBound()); 234dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2350d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression) { 2360d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // Compare the expressions for equality 2370d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor llvm::FoldingSetNodeID ID1, ID2; 2380d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.getAsExpr()->Profile(ID1, Context, true); 2390d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Y.getAsExpr()->Profile(ID2, Context, true); 2400d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (ID1 == ID2) 2410d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 2420d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 243dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2440d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 2450d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 246dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2470d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Declaration: 2480d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a declaration and a dependent expression, keep the 2490d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // declaration. 2500d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Expression) 2510d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 252dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2530d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced a declaration and an integral constant, keep the 2540d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // integral constant. 2550d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Integral) 2560d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return Y; 257dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2580d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // If we deduced two declarations, make sure they they refer to the 2590d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // same declaration. 2600d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() == TemplateArgument::Declaration && 261d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) && 262d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman X.isDeclForReferenceParam() == Y.isDeclForReferenceParam()) 263d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return X; 264d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 265d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman // All other combinations are incompatible. 266d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return DeducedTemplateArgument(); 267d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 268d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman case TemplateArgument::NullPtr: 269d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman // If we deduced a null pointer and a dependent expression, keep the 270d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman // null pointer. 271d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman if (Y.getKind() == TemplateArgument::Expression) 272d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return X; 273d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 274d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman // If we deduced a null pointer and an integral constant, keep the 275d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman // integral constant. 276d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman if (Y.getKind() == TemplateArgument::Integral) 277d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return Y; 278d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 279d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman // If we deduced two null pointers, make sure they have the same type. 280d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman if (Y.getKind() == TemplateArgument::NullPtr && 281d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType())) 2820d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 283dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2840d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor // All other combinations are incompatible. 2850d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 286dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2870d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor case TemplateArgument::Pack: 2880d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Y.getKind() != TemplateArgument::Pack || 2890d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor X.pack_size() != Y.pack_size()) 2900d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 291dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 292dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi for (TemplateArgument::pack_iterator XA = X.pack_begin(), 2930d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor XAEnd = X.pack_end(), 2940d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor YA = Y.pack_begin(); 2950d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor XA != XAEnd; ++XA, ++YA) { 296dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (checkDeducedTemplateArguments(Context, 297dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()), 298135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound())) 299135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor .isNull()) 3000d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return DeducedTemplateArgument(); 3010d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 302dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3030d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor return X; 3040d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor } 305dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3063026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid TemplateArgument Kind!"); 3070d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor} 3080d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor 3091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the value of the given non-type template parameter 310199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// from the given constant. 311f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 312a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 3131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NonTypeTemplateParmDecl *NTTP, 3149d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor llvm::APSInt Value, QualType ValueType, 31502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor bool DeducedFromArrayBound, 3162a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 3175f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 3181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 319199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument with depth > 0"); 3201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 321855243789cb44799c03f4c7216d3d6308805f549Benjamin Kramer DeducedTemplateArgument NewDeduced(S.Context, Value, ValueType, 322855243789cb44799c03f4c7216d3d6308805f549Benjamin Kramer DeducedFromArrayBound); 323dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 3240d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()], 3250d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 3260d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 327f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = NTTP; 328f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 3290d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 330dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 331f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 332dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3330d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 334f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 335199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 336199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 3371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the value of the given non-type template parameter 338199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// from the given type- or value-dependent expression. 339199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// 340199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor/// \returns true if deduction succeeded, false otherwise. 341f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 342a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 343f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor NonTypeTemplateParmDecl *NTTP, 344f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Expr *Value, 3452a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 3465f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 3471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 348199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument with depth > 0"); 349199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor assert((Value->isTypeDependent() || Value->isValueDependent()) && 350199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Expression template argument must be type- or value-dependent."); 3511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3520d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(Value); 353dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 354dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Deduced[NTTP->getIndex()], 3550d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 356dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3570d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 3580d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = NTTP; 3590d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 3600d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 361dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 3629eea08ba72f8b1e7faf38e43376b9157fc4a2af2Douglas Gregor } 363dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3640d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 365f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 366199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor} 367199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 36815755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// \brief Deduce the value of the given non-type template parameter 36915755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// from the given declaration. 37015755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// 37115755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor/// \returns true if deduction succeeded, false otherwise. 37215755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregorstatic Sema::TemplateDeductionResult 373a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceNonTypeTemplateArgument(Sema &S, 37415755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor NonTypeTemplateParmDecl *NTTP, 375d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman ValueDecl *D, 3762a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 3775f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 37815755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor assert(NTTP->getDepth() == 0 && 37915755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor "Cannot deduce non-type template argument with depth > 0"); 380dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 381d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : 0; 382d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman TemplateArgument New(D, NTTP->getType()->isReferenceType()); 383d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman DeducedTemplateArgument NewDeduced(New); 384dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 3850d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()], 3860d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 3870d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 3880d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = NTTP; 3890d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[NTTP->getIndex()]; 3900d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 391dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 39215755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor } 393dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3940d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[NTTP->getIndex()] = Result; 39515755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor return Sema::TDK_Success; 39615755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor} 39715755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor 398f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 399a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 400db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor TemplateParameterList *TemplateParams, 401f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateName Param, 402f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateName Arg, 4032a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 4045f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 405d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor TemplateDecl *ParamDecl = Param.getAsTemplateDecl(); 406db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (!ParamDecl) { 407db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // The parameter type is dependent and is not a template template parameter, 408db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // so there is nothing that we can deduce. 409db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_Success; 410f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 411dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 412db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (TemplateTemplateParmDecl *TempParam 413db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) { 4140d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg)); 415dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 4160d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[TempParam->getIndex()], 4170d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 4180d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 4190d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = TempParam; 4200d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[TempParam->getIndex()]; 4210d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 422dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 423db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor } 424dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4250d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[TempParam->getIndex()] = Result; 426dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Success; 427f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 428dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 429db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // Verify that the two template names are equivalent. 430a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth if (S.Context.hasSameTemplateName(Param, Arg)) 431db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_Success; 432dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 433db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // Mismatch of non-dependent template parameter to argument. 434db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Info.FirstArg = TemplateArgument(Param); 435db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Info.SecondArg = TemplateArgument(Arg); 436db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return Sema::TDK_NonDeducedMismatch; 437d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor} 438d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 4391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Deduce the template arguments by comparing the template parameter 440de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// type (which is a template-id) with the template argument type. 441de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 442a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth/// \param S the Sema 443de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 444de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param TemplateParams the template parameters that we are deducing 445de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 446de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Param the parameter type 447de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 448de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Arg the argument type 449de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 450de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Info information about the template argument deduction itself 451de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 452de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \param Deduced the deduced template arguments 453de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// 454de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// \returns the result of template argument deduction so far. Note that a 455de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// "success" result means that template argument deduction has not yet failed, 456de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor/// but it may still fail, later, for other reasons. 457de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregorstatic Sema::TemplateDeductionResult 458a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 459de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor TemplateParameterList *TemplateParams, 460de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const TemplateSpecializationType *Param, 461de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor QualType Arg, 4622a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 4635f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 464467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(Arg.isCanonical() && "Argument type must be canonical"); 4651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 466de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Check whether the template argument is a dependent template-id. 4671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateSpecializationType *SpecArg 468de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = dyn_cast<TemplateSpecializationType>(Arg)) { 469de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction for the template name. 470de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 471a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, 472de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getTemplateName(), 473de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor SpecArg->getTemplateName(), 474de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 475de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 4761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 478de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction on each template 4790972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor // argument. Ignore any missing/extra arguments, since they could be 4800972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor // filled in by default arguments. 481dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceTemplateArguments(S, TemplateParams, 482dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Param->getArgs(), Param->getNumArgs(), 4830972c867e72171f24052d7b6d307020c065f8a66Douglas Gregor SpecArg->getArgs(), SpecArg->getNumArgs(), 484030a6644f253818b81b4d8a7fc1770c0a3d35474Richard Smith Info, Deduced); 485de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 4861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 487de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If the argument type is a class template specialization, we 488de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // perform template argument deduction using its template 489de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // arguments. 490de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const RecordType *RecordArg = dyn_cast<RecordType>(Arg); 491de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!RecordArg) 492de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 4931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ClassTemplateSpecializationDecl *SpecArg 495de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl()); 496de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!SpecArg) 497de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_NonDeducedMismatch; 4981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 499de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Perform template argument deduction for the template name. 500de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Sema::TemplateDeductionResult Result 501a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, 502db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor TemplateParams, 503de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Param->getTemplateName(), 504de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor TemplateName(SpecArg->getSpecializedTemplate()), 505de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced)) 506de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 5071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 50820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Perform template argument deduction for the template arguments. 509dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceTemplateArguments(S, TemplateParams, 51020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Param->getArgs(), Param->getNumArgs(), 51120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor SpecArg->getTemplateArgs().data(), 51220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor SpecArg->getTemplateArgs().size(), 51320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Info, Deduced); 514de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor} 515de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor 516cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall/// \brief Determines whether the given type is an opaque type that 517cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall/// might be more qualified when instantiated. 518cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCallstatic bool IsPossiblyOpaquelyQualifiedType(QualType T) { 519cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall switch (T->getTypeClass()) { 520cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::TypeOfExpr: 521cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::TypeOf: 522cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::DependentName: 523cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::Decltype: 524cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::UnresolvedUsing: 52562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall case Type::TemplateTypeParm: 526cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return true; 527cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 528cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::ConstantArray: 529cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::IncompleteArray: 530cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::VariableArray: 531cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall case Type::DependentSizedArray: 532cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return IsPossiblyOpaquelyQualifiedType( 533cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall cast<ArrayType>(T)->getElementType()); 534cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 535cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall default: 536cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall return false; 537cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall } 538cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall} 539cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall 540d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor/// \brief Retrieve the depth and index of a template parameter. 541dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic std::pair<unsigned, unsigned> 542d3731198193eee92796ddeb493973b7a598b003eDouglas GregorgetDepthAndIndex(NamedDecl *ND) { 543603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND)) 544603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 545dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 546603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND)) 547603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(NTTP->getDepth(), NTTP->getIndex()); 548dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 549603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND); 550603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 551603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 552603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 553d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor/// \brief Retrieve the depth and index of an unexpanded parameter pack. 554dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic std::pair<unsigned, unsigned> 555d3731198193eee92796ddeb493973b7a598b003eDouglas GregorgetDepthAndIndex(UnexpandedParameterPack UPP) { 556d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (const TemplateTypeParmType *TTP 557d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor = UPP.first.dyn_cast<const TemplateTypeParmType *>()) 558d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor return std::make_pair(TTP->getDepth(), TTP->getIndex()); 559dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 560d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor return getDepthAndIndex(UPP.first.get<NamedDecl *>()); 561d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor} 562d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor 563603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \brief Helper function to build a TemplateParameter when we don't 564603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// know its type statically. 565603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic TemplateParameter makeTemplateParameter(Decl *D) { 566603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D)) 567603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(TTP); 568603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) 569603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(NTTP); 570dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 571603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return TemplateParameter(cast<TemplateTemplateParmDecl>(D)); 572603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 573603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 5745429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor/// \brief Prepare to perform template argument deduction for all of the 5755429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor/// arguments in a set of argument packs. 576dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic void PrepareArgumentPackDeduction(Sema &S, 5775f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 5784fe5be028b723fedc28bb33be96cde1ab2574ee6Bill Wendling ArrayRef<unsigned> PackIndices, 5795f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &SavedPacks, 5805f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl< 5815f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> > &NewlyDeducedPacks) { 5825429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // Save the deduced template arguments for each parameter pack expanded 5835429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // by this pack expansion, then clear out the deduction. 5845429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 5855429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // Save the previously-deduced argument pack, then clear it out so that we 5865429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // can deduce a new argument pack. 5875429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor SavedPacks[I] = Deduced[PackIndices[I]]; 588dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Deduced[PackIndices[I]] = TemplateArgument(); 589dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 590a8eaf008e92759142982f7b40720b2b2674bd663Richard Smith if (!S.CurrentInstantiationScope) 591a8eaf008e92759142982f7b40720b2b2674bd663Richard Smith continue; 592a8eaf008e92759142982f7b40720b2b2674bd663Richard Smith 5936964b3f80ce1ba489e7e25e7cd58062699af9b0cRichard Smith // If the template argument pack was explicitly specified, add that to 5945429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor // the set of deduced arguments. 5955429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor const TemplateArgument *ExplicitArgs; 5965429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor unsigned NumExplicitArgs; 597dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (NamedDecl *PartiallySubstitutedPack 5985429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor = S.CurrentInstantiationScope->getPartiallySubstitutedPack( 5995429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor &ExplicitArgs, 6005429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor &NumExplicitArgs)) { 6015429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor if (getDepthAndIndex(PartiallySubstitutedPack).second == PackIndices[I]) 602dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NewlyDeducedPacks[I].append(ExplicitArgs, 6035429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor ExplicitArgs + NumExplicitArgs); 6045429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor } 6055429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor } 6065429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor} 6075429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor 6080216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor/// \brief Finish template argument deduction for a set of argument packs, 6090216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor/// producing the argument packs and checking for consistency with prior 6100216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor/// deductions. 6110216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregorstatic Sema::TemplateDeductionResult 6120216f8121df32b320cab659d5b703fee50cdfda5Douglas GregorFinishArgumentPackDeduction(Sema &S, 6130216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor TemplateParameterList *TemplateParams, 6140216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor bool HasAnyArguments, 6155f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 616341785ec52f87c0803ba52dc88faac4e136f8593Bill Wendling ArrayRef<unsigned> PackIndices, 6175f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &SavedPacks, 6185f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl< 6195f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> > &NewlyDeducedPacks, 6200216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor TemplateDeductionInfo &Info) { 6210216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 6220216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // pack expansion. 6230216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 6240216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (HasAnyArguments && NewlyDeducedPacks[I].empty()) { 6250216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // We were not able to deduce anything for this parameter pack, 6260216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // so just restore the saved argument pack. 6270216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced[PackIndices[I]] = SavedPacks[I]; 6280216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor continue; 6290216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 630dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6310216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor DeducedTemplateArgument NewPack; 632dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6330216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (NewlyDeducedPacks[I].empty()) { 6340216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor // If we deduced an empty argument pack, create it now. 635d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack()); 6360216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } else { 6370216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor TemplateArgument *ArgumentPack 638203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor = new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()]; 6390216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(), 6400216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor ArgumentPack); 6410216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewPack 642203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor = DeducedTemplateArgument(TemplateArgument(ArgumentPack, 643203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor NewlyDeducedPacks[I].size()), 644dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NewlyDeducedPacks[I][0].wasDeducedFromArrayBound()); 6450216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 646dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6470216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor DeducedTemplateArgument Result 6480216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor = checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack); 6490216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Result.isNull()) { 6500216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Info.Param 6510216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor = makeTemplateParameter(TemplateParams->getParam(PackIndices[I])); 6520216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Info.FirstArg = SavedPacks[I]; 6530216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Info.SecondArg = NewPack; 6540216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor return Sema::TDK_Inconsistent; 6550216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 656dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6570216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced[PackIndices[I]] = Result; 6580216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor } 659dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 6600216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor return Sema::TDK_Success; 6610216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor} 6620216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor 663603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \brief Deduce the template arguments by comparing the list of parameter 664dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// types to the list of argument types, as in the parameter-type-lists of 665dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// function types (C++ [temp.deduct.type]p10). 666603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 667603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param S The semantic analysis object within which we are deducing 668603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 669603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param TemplateParams The template parameters that we are deducing 670603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 671603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Params The list of parameter types 672603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 673603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param NumParams The number of types in \c Params 674603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 675603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Args The list of argument types 676603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 677603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param NumArgs The number of types in \c Args 678603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 679603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Info information about the template argument deduction itself 680603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 681603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param Deduced the deduced template arguments 682603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 683603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe 684603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// how template argument deduction is performed. 685603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// 6865c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param PartialOrdering If true, we are performing template argument 687dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// deduction for during partial ordering for a call 6885c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// (C++0x [temp.deduct.partial]). 6895c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 690b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// \param RefParamComparisons If we're performing template argument deduction 6915c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// in the context of partial ordering, the set of qualifier comparisons. 6925c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 693603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// \returns the result of template argument deduction so far. Note that a 694603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// "success" result means that template argument deduction has not yet failed, 695603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor/// but it may still fail, later, for other reasons. 696603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregorstatic Sema::TemplateDeductionResult 697603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas GregorDeduceTemplateArguments(Sema &S, 698603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateParameterList *TemplateParams, 699603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor const QualType *Params, unsigned NumParams, 700603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor const QualType *Args, unsigned NumArgs, 701603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor TemplateDeductionInfo &Info, 7025f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 7035c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned TDF, 7045c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor bool PartialOrdering = false, 7055f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<RefParamPartialOrderingComparison> * 706b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons = 0) { 7070bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor // Fast-path check to see if we have too many/too few arguments. 7080bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor if (NumParams != NumArgs && 7090bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor !(NumParams && isa<PackExpansionType>(Params[NumParams - 1])) && 7100bbacf8d2b3c7a5f19f292f3201e371836445502Douglas Gregor !(NumArgs && isa<PackExpansionType>(Args[NumArgs - 1]))) 7113cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor return Sema::TDK_NonDeducedMismatch; 712dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 713603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // C++0x [temp.deduct.type]p10: 714dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Similarly, if P has a form that contains (T), then each parameter type 715dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Pi of the respective parameter-type- list of P is compared with the 716dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // corresponding parameter type Ai of the corresponding parameter-type-list 717dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // of A. [...] 718603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor unsigned ArgIdx = 0, ParamIdx = 0; 719603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (; ParamIdx != NumParams; ++ParamIdx) { 720603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Check argument types. 721dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi const PackExpansionType *Expansion 722603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor = dyn_cast<PackExpansionType>(Params[ParamIdx]); 723603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (!Expansion) { 724603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Simple case: compare the parameter and argument types at this point. 725dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 726603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Make sure we have an argument. 727603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (ArgIdx >= NumArgs) 7283cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor return Sema::TDK_NonDeducedMismatch; 729dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 73077d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (isa<PackExpansionType>(Args[ArgIdx])) { 73177d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // C++0x [temp.deduct.type]p22: 73277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // If the original function parameter associated with A is a function 73377d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // parameter pack and the function parameter associated with P is not 73477d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // a function parameter pack, then template argument deduction fails. 73577d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor return Sema::TDK_NonDeducedMismatch; 73677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor } 737dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 738603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (Sema::TemplateDeductionResult Result 739bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 740bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Params[ParamIdx], Args[ArgIdx], 741bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF, 742bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl PartialOrdering, 743bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons)) 744603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Result; 745dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 746603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor ++ArgIdx; 747603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor continue; 748603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 749dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 7507d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // C++0x [temp.deduct.type]p5: 7517d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // The non-deduced contexts are: 752dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // - A function parameter pack that does not occur at the end of the 7537d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // parameter-declaration-clause. 7547d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor if (ParamIdx + 1 < NumParams) 7557d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor return Sema::TDK_Success; 7567d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor 757603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // C++0x [temp.deduct.type]p10: 758dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the parameter-declaration corresponding to Pi is a function 759603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // parameter pack, then the type of its declarator- id is compared with 760dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // each remaining parameter type in the parameter-type-list of A. Each 761603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // comparison deduces template arguments for subsequent positions in the 762603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // template parameter packs expanded by the function parameter pack. 763dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 764603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Compute the set of template parameter indices that correspond to 765603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // parameter packs expanded by the pack expansion. 7665f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<unsigned, 2> PackIndices; 767603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor QualType Pattern = Expansion->getPattern(); 768603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor { 769013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector SawIndices(TemplateParams->size()); 7705f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<UnexpandedParameterPack, 2> Unexpanded; 771603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor S.collectUnexpandedParameterPacks(Pattern, Unexpanded); 772603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 773603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor unsigned Depth, Index; 774603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 775603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 776603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor SawIndices[Index] = true; 777603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor PackIndices.push_back(Index); 778603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 779603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 780603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 781603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 782603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 783d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // Keep track of the deduced template arguments for each parameter pack 784dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // expanded by this pack expansion (the outer index) and for each 785d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // template argument (the inner SmallVectors). 7865f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2> 787d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor NewlyDeducedPacks(PackIndices.size()); 7885f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 2> 7895429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor SavedPacks(PackIndices.size()); 790dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, 7915429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor NewlyDeducedPacks); 792dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 793603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor bool HasAnyArguments = false; 794603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (; ArgIdx < NumArgs; ++ArgIdx) { 795603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor HasAnyArguments = true; 796dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 797603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Deduce template arguments from the pattern. 798dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (Sema::TemplateDeductionResult Result 799bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern, 800bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Args[ArgIdx], Info, Deduced, 801bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TDF, PartialOrdering, 802bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons)) 803603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Result; 804dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 805603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 806603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 807603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // for that pack, then clear out the deduced argument. 808603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 809603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 810603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (!DeducedArg.isNull()) { 811603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 812603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor DeducedArg = DeducedTemplateArgument(); 813603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 814603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 815603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 816dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 817603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 818603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // pack expansion. 8190216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Sema::TemplateDeductionResult Result 820dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, 8210216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced, PackIndices, SavedPacks, 8220216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewlyDeducedPacks, Info)) 823dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Result; 824603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor } 825dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 826603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor // Make sure we don't have any extra arguments. 827603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor if (ArgIdx < NumArgs) 8283cae5c9a79bfd2e27eb44c32b13dfacd2ce5c66fDouglas Gregor return Sema::TDK_NonDeducedMismatch; 829dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 830603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return Sema::TDK_Success; 831603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor} 832603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor 83361d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor/// \brief Determine whether the parameter has qualifiers that are either 83461d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor/// inconsistent with or a superset of the argument's qualifiers. 83561d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregorstatic bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType, 83661d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor QualType ArgType) { 83761d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor Qualifiers ParamQs = ParamType.getQualifiers(); 83861d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor Qualifiers ArgQs = ArgType.getQualifiers(); 83961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 84061d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs == ArgQs) 84161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor return false; 84261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 84361d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // Mismatched (but not missing) Objective-C GC attributes. 84461d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() && 84561d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor ParamQs.hasObjCGCAttr()) 84661d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor return true; 84761d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 84861d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // Mismatched (but not missing) address spaces. 84961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() && 85061d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor ParamQs.hasAddressSpace()) 85161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor return true; 85261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 853f85e193739c953358c865005855253af4f68a497John McCall // Mismatched (but not missing) Objective-C lifetime qualifiers. 854f85e193739c953358c865005855253af4f68a497John McCall if (ParamQs.getObjCLifetime() != ArgQs.getObjCLifetime() && 855f85e193739c953358c865005855253af4f68a497John McCall ParamQs.hasObjCLifetime()) 856f85e193739c953358c865005855253af4f68a497John McCall return true; 857f85e193739c953358c865005855253af4f68a497John McCall 85861d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // CVR qualifier superset. 85961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor return (ParamQs.getCVRQualifiers() != ArgQs.getCVRQualifiers()) && 86061d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor ((ParamQs.getCVRQualifiers() | ArgQs.getCVRQualifiers()) 86161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor == ParamQs.getCVRQualifiers()); 86261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor} 86361d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 864500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \brief Deduce the template arguments by comparing the parameter type and 865500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// the argument type (C++ [temp.deduct.type]). 866500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 867a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth/// \param S the semantic analysis object within which we are deducing 868500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 869500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param TemplateParams the template parameters that we are deducing 870500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 871500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param ParamIn the parameter type 872500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 873500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param ArgIn the argument type 874500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 875500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param Info information about the template argument deduction itself 876500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 877500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \param Deduced the deduced template arguments 878500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 879508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe 8801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// how template argument deduction is performed. 881500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// 8825c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param PartialOrdering Whether we're performing template argument deduction 8835c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// in the context of partial ordering (C++0x [temp.deduct.partial]). 8845c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 885b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor/// \param RefParamComparisons If we're performing template argument deduction 8865c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// in the context of partial ordering, the set of qualifier comparisons. 8875c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 888500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// \returns the result of template argument deduction so far. Note that a 889500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// "success" result means that template argument deduction has not yet failed, 890500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor/// but it may still fail, later, for other reasons. 891f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 892bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian RedlDeduceTemplateArgumentsByTypeMatch(Sema &S, 893bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TemplateParameterList *TemplateParams, 894bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType ParamIn, QualType ArgIn, 895bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TemplateDeductionInfo &Info, 896bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl SmallVectorImpl<DeducedTemplateArgument> &Deduced, 897bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl unsigned TDF, 898bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl bool PartialOrdering, 899bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl SmallVectorImpl<RefParamPartialOrderingComparison> * 900bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons) { 9010b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // We only want to look at the canonical types, since typedefs and 9020b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // sugar are not part of template argument deduction. 903a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth QualType Param = S.Context.getCanonicalType(ParamIn); 904a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth QualType Arg = S.Context.getCanonicalType(ArgIn); 9050b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 90677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // If the argument type is a pack expansion, look at its pattern. 907dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // This isn't explicitly called out 90877d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (const PackExpansionType *ArgExpansion 90977d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor = dyn_cast<PackExpansionType>(Arg)) 91077d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Arg = ArgExpansion->getPattern(); 911dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 9125c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (PartialOrdering) { 9135c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.partial]p5: 914dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Before the partial ordering is done, certain transformations are 915dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // performed on the types used for partial ordering: 916dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // - If P is a reference type, P is replaced by the type referred to. 9175c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor const ReferenceType *ParamRef = Param->getAs<ReferenceType>(); 9185c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (ParamRef) 9195c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Param = ParamRef->getPointeeType(); 920dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 9215c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // - If A is a reference type, A is replaced by the type referred to. 9225c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor const ReferenceType *ArgRef = Arg->getAs<ReferenceType>(); 9235c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (ArgRef) 9245c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Arg = ArgRef->getPointeeType(); 925dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 926b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (RefParamComparisons && ParamRef && ArgRef) { 9275c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.partial]p6: 928dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If both P and A were reference types (before being replaced with the 929dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // type referred to above), determine which of the two types (if any) is 9305c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // more cv-qualified than the other; otherwise the types are considered 931dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // to be equally cv-qualified for partial ordering purposes. The result 9325c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // of this determination will be used below. 9335c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // 934dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // We save this information for later, using it only when deduction 9355c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // succeeds in both directions. 936b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamPartialOrderingComparison Comparison; 937b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.ParamIsRvalueRef = ParamRef->getAs<RValueReferenceType>(); 938b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.ArgIsRvalueRef = ArgRef->getAs<RValueReferenceType>(); 939b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.Qualifiers = NeitherMoreQualified; 940769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor 941769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor Qualifiers ParamQuals = Param.getQualifiers(); 942769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor Qualifiers ArgQuals = Arg.getQualifiers(); 943769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor if (ParamQuals.isStrictSupersetOf(ArgQuals)) 944b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.Qualifiers = ParamMoreQualified; 945769d0cc72b1831785596d0e76f327bdb887823beDouglas Gregor else if (ArgQuals.isStrictSupersetOf(ParamQuals)) 946b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Comparison.Qualifiers = ArgMoreQualified; 947b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons->push_back(Comparison); 9485c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor } 949dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 9505c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.partial]p7: 9515c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // Remove any top-level cv-qualifiers: 952dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // - If P is a cv-qualified type, P is replaced by the cv-unqualified 9535c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // version of P. 9545c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Param = Param.getUnqualifiedType(); 955dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // - If A is a cv-qualified type, A is replaced by the cv-unqualified 9565c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // version of A. 9575c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Arg = Arg.getUnqualifiedType(); 9585c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor } else { 9595c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++0x [temp.deduct.call]p4 bullet 1: 9605c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // - If the original P is a reference type, the deduced A (i.e., the type 9615c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // referred to by the reference) can be more cv-qualified than the 9625c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // transformed A. 9635c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (TDF & TDF_ParamWithReferenceType) { 9645c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Qualifiers Quals; 9655c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals); 9665c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Quals.setCVRQualifiers(Quals.getCVRQualifiers() & 96762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall Arg.getCVRQualifiers()); 9685c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Param = S.Context.getQualifiedType(UnqualParam, Quals); 9695c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor } 970dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 97173b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor if ((TDF & TDF_TopLevelParameterTypeList) && !Param->isFunctionType()) { 97273b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // C++0x [temp.deduct.type]p10: 97373b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // If P and A are function types that originated from deduction when 97473b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // taking the address of a function template (14.8.2.2) or when deducing 97573b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // template arguments from a function declaration (14.8.2.6) and Pi and 976dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Ai are parameters of the top-level parameter-type-list of P and A, 977dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // respectively, Pi is adjusted if it is an rvalue reference to a 978dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // cv-unqualified template parameter and Ai is an lvalue reference, in 979dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // which case the type of Pi is changed to be the template parameter 98073b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // type (i.e., T&& is changed to simply T). [ Note: As a result, when 98173b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor // Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be 9820099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // deduced as X&. - end note ] 98373b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor TDF &= ~TDF_TopLevelParameterTypeList; 984dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 98573b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor if (const RValueReferenceType *ParamRef 98673b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor = Param->getAs<RValueReferenceType>()) { 98773b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor if (isa<TemplateTypeParmType>(ParamRef->getPointeeType()) && 98873b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor !ParamRef->getPointeeType().getQualifiers()) 98973b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor if (Arg->isLValueReferenceType()) 99073b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor Param = ParamRef->getPointeeType(); 99173b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor } 99273b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor } 993500d331eade2f5070b66ba51d777224f9fda6e1dDouglas Gregor } 994dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 995199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // C++ [temp.deduct.type]p9: 9961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // A template type argument T, a template template argument TT or a 9971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // template non-type argument i can be deduced if P and A have one of 998199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // the following forms: 999199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // 1000199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T 1001199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // cv-list T 10021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateTypeParmType *TemplateTypeParm 1003183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = Param->getAs<TemplateTypeParmType>()) { 1004af130823cbac5c02f7fe57a5733ee511f5a3ac98Douglas Gregor // Just skip any attempts to deduce from a placeholder type. 1005af130823cbac5c02f7fe57a5733ee511f5a3ac98Douglas Gregor if (Arg->isPlaceholderType()) 1006af130823cbac5c02f7fe57a5733ee511f5a3ac98Douglas Gregor return Sema::TDK_Success; 1007af130823cbac5c02f7fe57a5733ee511f5a3ac98Douglas Gregor 1008f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor unsigned Index = TemplateTypeParm->getIndex(); 1009f290e0db835a619014538c41ed552696efc0e977Douglas Gregor bool RecanonicalizeArg = false; 10101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10119e9fae4b8af47c15696da4ea3c30102e3a035179Douglas Gregor // If the argument type is an array type, move the qualifiers up to the 10129e9fae4b8af47c15696da4ea3c30102e3a035179Douglas Gregor // top level, so they can be matched with the qualifiers on the parameter. 1013f290e0db835a619014538c41ed552696efc0e977Douglas Gregor if (isa<ArrayType>(Arg)) { 10140953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers Quals; 1015a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth Arg = S.Context.getUnqualifiedArrayType(Arg, Quals); 10160953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (Quals) { 1017a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth Arg = S.Context.getQualifiedType(Arg, Quals); 1018f290e0db835a619014538c41ed552696efc0e977Douglas Gregor RecanonicalizeArg = true; 1019f290e0db835a619014538c41ed552696efc0e977Douglas Gregor } 1020f290e0db835a619014538c41ed552696efc0e977Douglas Gregor } 10211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10220b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // The argument type can not be less qualified than the parameter 10230b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor // type. 102461d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (!(TDF & TDF_IgnoreQualifiers) && 102561d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor hasInconsistentOrSupersetQualifiersOf(Param, Arg)) { 1026f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 102757e97786433e70197a089360228d8f0d82e3ad4cJohn McCall Info.FirstArg = TemplateArgument(Param); 1028833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.SecondArg = TemplateArgument(Arg); 102957e97786433e70197a089360228d8f0d82e3ad4cJohn McCall return Sema::TDK_Underqualified; 1030f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 10310b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 10320b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0"); 1033a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function"); 10340953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualType DeducedType = Arg; 103549f4e1cbd839da27ff4814b4ea6d85a79f786cbdJohn McCall 103661d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // Remove any qualifiers on the parameter from the deduced type. 103761d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor // We checked the qualifiers for consistency above. 103861d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor Qualifiers DeducedQs = DeducedType.getQualifiers(); 103961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor Qualifiers ParamQs = Param.getQualifiers(); 104061d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedQs.removeCVRQualifiers(ParamQs.getCVRQualifiers()); 104161d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs.hasObjCGCAttr()) 104261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedQs.removeObjCGCAttr(); 104361d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (ParamQs.hasAddressSpace()) 104461d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedQs.removeAddressSpace(); 1045f85e193739c953358c865005855253af4f68a497John McCall if (ParamQs.hasObjCLifetime()) 1046f85e193739c953358c865005855253af4f68a497John McCall DeducedQs.removeObjCLifetime(); 1047e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor 1048e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor // Objective-C ARC: 1049da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor // If template deduction would produce a lifetime qualifier on a type 1050da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor // that is not a lifetime type, template argument deduction fails. 1051da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() && 1052da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor !DeducedType->isDependentType()) { 1053da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 1054da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor Info.FirstArg = TemplateArgument(Param); 1055da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor Info.SecondArg = TemplateArgument(Arg); 1056da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor return Sema::TDK_Underqualified; 1057da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor } 1058da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor 1059da8b24961acfbeff47f585109b7559ba60e574cbDouglas Gregor // Objective-C ARC: 1060e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor // If template deduction would produce an argument type with lifetime type 1061e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor // but no lifetime qualifier, the __strong lifetime qualifier is inferred. 10624e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (S.getLangOpts().ObjCAutoRefCount && 1063e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor DeducedType->isObjCLifetimeType() && 1064e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor !DeducedQs.hasObjCLifetime()) 1065e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor DeducedQs.setObjCLifetime(Qualifiers::OCL_Strong); 1066e559ca1672ecef59345a928af0a6809b09282d2cDouglas Gregor 106761d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(), 106861d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor DeducedQs); 106961d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor 1070f290e0db835a619014538c41ed552696efc0e977Douglas Gregor if (RecanonicalizeArg) 1071a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth DeducedType = S.Context.getCanonicalType(DeducedType); 10721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10730d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor DeducedTemplateArgument NewDeduced(DeducedType); 1074dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, 10750d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[Index], 10760d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor NewDeduced); 10770d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor if (Result.isNull()) { 10780d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); 10790d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.FirstArg = Deduced[Index]; 10800d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Info.SecondArg = NewDeduced; 1081dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Inconsistent; 10820b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 1083dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 10840d80abc3b7fb0dca26fb6b272d2c3484f86fb7e7Douglas Gregor Deduced[Index] = Result; 1085dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Sema::TDK_Success; 10860b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 10870b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1088f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor // Set up the template argument deduction information for a failure. 1089833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.FirstArg = TemplateArgument(ParamIn); 1090833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall Info.SecondArg = TemplateArgument(ArgIn); 1091f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 10920bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // If the parameter is an already-substituted template parameter 10930bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // pack, do nothing: we don't know which of its arguments to look 10940bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // at, so we have to wait until all of the parameter packs in this 10950bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor // expansion have arguments. 10960bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor if (isa<SubstTemplateTypeParmPackType>(Param)) 10970bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor return Sema::TDK_Success; 10980bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor 1099508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor // Check the cv-qualifiers on the parameter and argument types. 1100508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (!(TDF & TDF_IgnoreQualifiers)) { 1101508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (TDF & TDF_ParamWithReferenceType) { 110261d0b6baf47cf411f6c0f6ddb4acffcfeec724f1Douglas Gregor if (hasInconsistentOrSupersetQualifiersOf(Param, Arg)) 1103508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1104cd05e81e2e2640a0a0097658c660afc6c8a9f4fdJohn McCall } else if (!IsPossiblyOpaquelyQualifiedType(Param)) { 1105508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor if (Param.getCVRQualifiers() != Arg.getCVRQualifiers()) 11061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Sema::TDK_NonDeducedMismatch; 1107508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor } 1108fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1109fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor // If the parameter type is not dependent, there is nothing to deduce. 1110fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor if (!Param->isDependentType()) { 1111fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor if (!(TDF & TDF_SkipNonDependent) && Param != Arg) 1112fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1113fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1114fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor return Sema::TDK_Success; 1115fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor } 1116fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor } else if (!Param->isDependentType() && 1117fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor Param.getUnqualifiedType() == Arg.getUnqualifiedType()) { 1118fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor return Sema::TDK_Success; 1119508f1c889b9833903ea394034fe0246d3a57a32dDouglas Gregor } 11200b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1121d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor switch (Param->getTypeClass()) { 11224ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Non-canonical types cannot appear here. 11234ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) \ 11244ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class); 11254ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor#define TYPE(Class, Base) 11264ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor#include "clang/AST/TypeNodes.def" 11274ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 11284ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::TemplateTypeParm: 11294ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::SubstTemplateTypeParmPack: 11304ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor llvm_unreachable("Type nodes handled above"); 1131fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1132fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor // These types cannot be dependent, so simply check whether the types are 1133fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor // the same. 1134199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case Type::Builtin: 11354ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::VariableArray: 11364ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Vector: 11374ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::FunctionNoProto: 11384ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Record: 11394ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Enum: 11404ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::ObjCObject: 11414ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::ObjCInterface: 1142fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor case Type::ObjCObjectPointer: { 1143fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor if (TDF & TDF_SkipNonDependent) 1144fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor return Sema::TDK_Success; 1145fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1146fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor if (TDF & TDF_IgnoreQualifiers) { 1147fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor Param = Param.getUnqualifiedType(); 1148fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor Arg = Arg.getUnqualifiedType(); 1149fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor } 1150fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 1151fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch; 1152fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor } 1153fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor 11544ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // _Complex T [placeholder extension] 11554ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Complex: 11564ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>()) 1157bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 11584ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor cast<ComplexType>(Param)->getElementType(), 1159bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ComplexArg->getElementType(), 1160bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF); 11614ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 11624ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1163b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1164b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // _Atomic T [extension] 1165b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: 1166b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (const AtomicType *AtomicArg = Arg->getAs<AtomicType>()) 1167bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1168b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman cast<AtomicType>(Param)->getValueType(), 1169b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicArg->getValueType(), 1170b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Info, Deduced, TDF); 1171b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1172b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return Sema::TDK_NonDeducedMismatch; 1173b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1174199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T * 1175d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::Pointer: { 1176c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall QualType PointeeType; 1177c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall if (const PointerType *PointerArg = Arg->getAs<PointerType>()) { 1178c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType = PointerArg->getPointeeType(); 1179c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } else if (const ObjCObjectPointerType *PointerArg 1180c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall = Arg->getAs<ObjCObjectPointerType>()) { 1181c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType = PointerArg->getPointeeType(); 1182c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } else { 1183f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1184c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall } 11851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11864112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass); 1187bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1188bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl cast<PointerType>(Param)->getPointeeType(), 1189c0008349f233e70e3ffabe7b31eab5d9859bc25fJohn McCall PointeeType, 11904112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor Info, Deduced, SubTDF); 1191d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 11921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1193199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T & 1194d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::LValueReference: { 11956217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const LValueReferenceType *ReferenceArg = Arg->getAs<LValueReferenceType>(); 1196d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor if (!ReferenceArg) 1197f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 11981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1199bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1200d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor cast<LValueReferenceType>(Param)->getPointeeType(), 1201bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ReferenceArg->getPointeeType(), Info, Deduced, 0); 1202d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 12030b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1204199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T && [C++0x] 1205d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor case Type::RValueReference: { 12066217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const RValueReferenceType *ReferenceArg = Arg->getAs<RValueReferenceType>(); 1207d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor if (!ReferenceArg) 1208f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1210bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1211bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl cast<RValueReferenceType>(Param)->getPointeeType(), 1212bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ReferenceArg->getPointeeType(), 1213bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 0); 1214d560d5025a0e5b1942d99d5f39005337b03a64c2Douglas Gregor } 12151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1216199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T [] (implied, but not stated explicitly) 12174d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson case Type::IncompleteArray: { 12181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const IncompleteArrayType *IncompleteArrayArg = 1219a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsIncompleteArrayType(Arg); 12204d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (!IncompleteArrayArg) 1221f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1223e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 1224bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1225bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl S.Context.getAsIncompleteArrayType(Param)->getElementType(), 1226bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl IncompleteArrayArg->getElementType(), 1227bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, SubTDF); 12284d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson } 1229199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1230199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // T [integer-constant] 12314d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson case Type::ConstantArray: { 12321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const ConstantArrayType *ConstantArrayArg = 1233a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsConstantArrayType(Arg); 12344d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (!ConstantArrayArg) 1235f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 12371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const ConstantArrayType *ConstantArrayParm = 1238a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth S.Context.getAsConstantArrayType(Param); 12394d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize()) 1240f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1242e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 1243bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1244bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ConstantArrayParm->getElementType(), 1245bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ConstantArrayArg->getElementType(), 1246bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, SubTDF); 12474d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson } 12484d6fb501ffc0568ca5ca7266005e96a6f1273845Anders Carlsson 1249199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // type [i] 1250199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case Type::DependentSizedArray: { 1251a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg); 1252199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (!ArrayArg) 1253f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 12541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1255e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall unsigned SubTDF = TDF & TDF_IgnoreQualifiers; 1256e4f26e54d81fb1987333132fe34cd927e62c803cJohn McCall 1257199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Check the element type of the arrays 1258199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor const DependentSizedArrayType *DependentArrayParm 1259a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = S.Context.getAsDependentSizedArrayType(Param); 1260f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 1261bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1262bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl DependentArrayParm->getElementType(), 1263bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ArrayArg->getElementType(), 1264bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, SubTDF)) 1265f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 12661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1267199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Determine the array bound is something we can deduce. 12681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NonTypeTemplateParmDecl *NTTP 1269199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr()); 1270199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (!NTTP) 1271f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 12721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 12731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // We can perform template argument deduction for the given non-type 1274199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // template parameter. 12751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(NTTP->getDepth() == 0 && 1276199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor "Cannot deduce non-type template argument at depth > 0"); 12771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ConstantArrayType *ConstantArrayArg 1278335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson = dyn_cast<ConstantArrayType>(ArrayArg)) { 1279335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson llvm::APSInt Size(ConstantArrayArg->getSize()); 1280dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceNonTypeTemplateArgument(S, NTTP, Size, 12819d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor S.Context.getSizeType(), 128202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor /*ArrayBound=*/true, 1283f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 1284335e24a194f2000086d298b800d6169ebc5a7ee6Anders Carlsson } 1285199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (const DependentSizedArrayType *DependentArrayArg 1286199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = dyn_cast<DependentSizedArrayType>(ArrayArg)) 128734c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor if (DependentArrayArg->getSizeExpr()) 128834c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor return DeduceNonTypeTemplateArgument(S, NTTP, 128934c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor DependentArrayArg->getSizeExpr(), 129034c2f8c8a16226f757947bf08c5f799d99c9ac1eDouglas Gregor Info, Deduced); 12911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1292199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Incomplete type does not match a dependently-sized array type 1293f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1294199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 12951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 12961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // type(*)(T) 12971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(*)() 12981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(*)(T) 1299a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson case Type::FunctionProto: { 130073b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList; 13011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *FunctionProtoArg = 1302a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson dyn_cast<FunctionProtoType>(Arg); 1303a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson if (!FunctionProtoArg) 1304f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 13051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 13061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *FunctionProtoParam = 1307a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson cast<FunctionProtoType>(Param); 1308994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson 1309dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (FunctionProtoParam->getTypeQuals() 1310e3c7a7ca66c02567543dbb5ec493818e00e8b177Douglas Gregor != FunctionProtoArg->getTypeQuals() || 1311dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi FunctionProtoParam->getRefQualifier() 1312e3c7a7ca66c02567543dbb5ec493818e00e8b177Douglas Gregor != FunctionProtoArg->getRefQualifier() || 1313e3c7a7ca66c02567543dbb5ec493818e00e8b177Douglas Gregor FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic()) 1314f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1315994b6cb65c9daba2128366bc4c64be6dbf953528Anders Carlsson 1316a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson // Check return types. 1317f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 1318bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1319bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl FunctionProtoParam->getResultType(), 1320bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl FunctionProtoArg->getResultType(), 1321bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 0)) 1322f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 13231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1324603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor return DeduceTemplateArguments(S, TemplateParams, 1325603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoParam->arg_type_begin(), 1326603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoParam->getNumArgs(), 1327603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoArg->arg_type_begin(), 1328603cfb4da2f7ba08a1c3452c2fbf70585b8e7621Douglas Gregor FunctionProtoArg->getNumArgs(), 132973b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor Info, Deduced, SubTDF); 1330a27fad59dc760252af025ef6a86d31bb7d11a44aAnders Carlsson } 13311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 13323cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall case Type::InjectedClassName: { 13333cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // Treat a template's injected-class-name as if the template 13343cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // specialization type had been used. 133531f17ecbef57b5679c017c375db330546b7b5145John McCall Param = cast<InjectedClassNameType>(Param) 133631f17ecbef57b5679c017c375db330546b7b5145John McCall ->getInjectedSpecializationType(); 13373cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<TemplateSpecializationType>(Param) && 13383cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall "injected class name is not a template specialization type"); 13393cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // fall through 13403cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 13413cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 1342f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor // template-name<T> (where template-name refers to a class template) 1343d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor // template-name<i> 1344db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<T> 1345db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<i> 1346db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor // TT<> 1347d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor case Type::TemplateSpecialization: { 1348d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor const TemplateSpecializationType *SpecParam 1349d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor = cast<TemplateSpecializationType>(Param); 13501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1351de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Try to deduce template arguments from the template-id. 1352de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Sema::TemplateDeductionResult Result 1353a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, 1354de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Info, Deduced); 13551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 13564a5c15f75f76b95e1c2ceb6fa2737dcadd5f4be1Douglas Gregor if (Result && (TDF & TDF_DerivedClass)) { 1357de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // C++ [temp.deduct.call]p3b3: 1358de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If P is a class, and P has the form template-id, then A can be a 1359de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // derived class of the deduced A. Likewise, if P is a pointer to a 13601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // class of the form template-id, A can be a pointer to a derived 1361de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // class pointed to by the deduced A. 1362de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // 1363de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // More importantly: 13641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // These alternatives are considered only if type deduction would 1365de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // otherwise fail. 1366a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth if (const RecordType *RecordT = Arg->getAs<RecordType>()) { 1367a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // We cannot inspect base classes as part of deduction when the type 1368a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // is incomplete, so either instantiate any templates necessary to 1369a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth // complete the type, or skip over it if it cannot be completed. 13705769d6195087229770d7ac90449443e026c47103John McCall if (S.RequireCompleteType(Info.getLocation(), Arg, 0)) 1371a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return Result; 1372a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth 1373de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Use data recursion to crawl through the list of base classes. 13741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Visited contains the set of nodes we have already visited, while 1375de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // ToVisit is our stack of records that we still need to visit. 1376de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor llvm::SmallPtrSet<const RecordType *, 8> Visited; 13775f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<const RecordType *, 8> ToVisit; 1378de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ToVisit.push_back(RecordT); 1379de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor bool Successful = false; 138074fe66181db91d45d48f57abe325ea487e32ddbcBenjamin Kramer SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(), 138174fe66181db91d45d48f57abe325ea487e32ddbcBenjamin Kramer Deduced.end()); 1382de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor while (!ToVisit.empty()) { 1383de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Retrieve the next class in the inheritance hierarchy. 1384de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor const RecordType *NextT = ToVisit.back(); 1385de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor ToVisit.pop_back(); 13861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1387de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If we have already seen this type, skip it. 1388de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (!Visited.insert(NextT)) 1389de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor continue; 13901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1391de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If this is a base class, try to perform template argument 1392de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // deduction from it. 1393de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (NextT != RecordT) { 1394910515bc02872bd680e422f75079534d00093bc5Richard Trieu TemplateDeductionInfo BaseInfo(Info.getLocation()); 1395de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Sema::TemplateDeductionResult BaseResult 1396a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth = DeduceTemplateArguments(S, TemplateParams, SpecParam, 1397910515bc02872bd680e422f75079534d00093bc5Richard Trieu QualType(NextT, 0), BaseInfo, 1398910515bc02872bd680e422f75079534d00093bc5Richard Trieu Deduced); 13991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1400de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // If template argument deduction for this base was successful, 1401053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor // note that we had some success. Otherwise, ignore any deductions 1402053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor // from this base class. 1403053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor if (BaseResult == Sema::TDK_Success) { 1404de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor Successful = true; 140574fe66181db91d45d48f57abe325ea487e32ddbcBenjamin Kramer DeducedOrig.clear(); 140674fe66181db91d45d48f57abe325ea487e32ddbcBenjamin Kramer DeducedOrig.append(Deduced.begin(), Deduced.end()); 1407910515bc02872bd680e422f75079534d00093bc5Richard Trieu Info.Param = BaseInfo.Param; 1408910515bc02872bd680e422f75079534d00093bc5Richard Trieu Info.FirstArg = BaseInfo.FirstArg; 1409910515bc02872bd680e422f75079534d00093bc5Richard Trieu Info.SecondArg = BaseInfo.SecondArg; 1410053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor } 1411053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor else 1412053105d58552c600a2e56473592212a9bddafcd4Douglas Gregor Deduced = DeducedOrig; 1413de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 14141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1415de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor // Visit base classes 1416de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl()); 1417de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(), 1418de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor BaseEnd = Next->bases_end(); 14199994a34f6cf842721ba7723edc0b9036229fe387Sebastian Redl Base != BaseEnd; ++Base) { 14201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(Base->getType()->isRecordType() && 1421de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor "Base class that isn't a record?"); 14226217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek ToVisit.push_back(Base->getType()->getAs<RecordType>()); 1423de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 1424de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 14251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1426de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor if (Successful) 1427de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Sema::TDK_Success; 1428de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 14291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1430de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor } 14311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1432de0cb8b6c15c756e14b0716bebd40f4ce48ee717Douglas Gregor return Result; 1433d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor } 1434d708c72e3e5186662fb0045d2bd666bfd93a013dDouglas Gregor 1435637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T type::* 1436637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T T::* 1437637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (type::*)() 1438637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (T::*)() 1439637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (type::*)(T) 1440637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // type (T::*)(T) 1441637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (type::*)(T) 1442637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (T::*)() 1443637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // T (T::*)(T) 1444637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::MemberPointer: { 1445637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param); 1446637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg); 1447637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor if (!MemPtrArg) 1448f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1449f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1450f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Sema::TemplateDeductionResult Result 1451bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1452bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl MemPtrParam->getPointeeType(), 1453bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl MemPtrArg->getPointeeType(), 1454bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 1455bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl TDF & TDF_IgnoreQualifiers)) 1456f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Result; 1457f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1458bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1459bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType(MemPtrParam->getClass(), 0), 1460bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl QualType(MemPtrArg->getClass(), 0), 1461fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor Info, Deduced, 1462fc55a8290a3e81111c0a373e1a04b09dd7da0b98Douglas Gregor TDF & TDF_IgnoreQualifiers); 1463637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor } 1464637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor 14659a917e4fac79aba20fbd25983c78396475078918Anders Carlsson // (clang extension) 14669a917e4fac79aba20fbd25983c78396475078918Anders Carlsson // 14671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // type(^)(T) 14681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(^)() 14691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // T(^)(T) 1470859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson case Type::BlockPointer: { 1471859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param); 1472859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg); 14731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1474859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson if (!BlockPtrArg) 1475f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 14761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1477bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1478bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl BlockPtrParam->getPointeeType(), 1479bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl BlockPtrArg->getPointeeType(), 1480bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 0); 1481859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson } 1482859ba504e754436e1ccf81f50800e5d2ea647447Anders Carlsson 14834ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // (clang extension) 14844ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // 14854ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // T __attribute__(((ext_vector_type(<integral constant>)))) 14864ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::ExtVector: { 14874ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor const ExtVectorType *VectorParam = cast<ExtVectorType>(Param); 14884ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) { 14894ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Make sure that the vectors have the same number of elements. 14904ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (VectorParam->getNumElements() != VectorArg->getNumElements()) 14914ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_NonDeducedMismatch; 14924ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 14934ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the element types. 1494bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1495bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorParam->getElementType(), 1496bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorArg->getElementType(), 1497bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF); 14984ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 14994ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15004ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const DependentSizedExtVectorType *VectorArg 15014ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = dyn_cast<DependentSizedExtVectorType>(Arg)) { 15024ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // We can't check the number of elements, since the argument has a 15034ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // dependent number of elements. This can only occur during partial 15044ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // ordering. 15054ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15064ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the element types. 1507bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1508bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorParam->getElementType(), 1509bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorArg->getElementType(), 1510bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF); 15114ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 15124ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15134ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_NonDeducedMismatch; 15144ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 15154ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15164ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // (clang extension) 15174ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // 15184ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // T __attribute__(((ext_vector_type(N)))) 15194ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::DependentSizedExtVector: { 15204ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor const DependentSizedExtVectorType *VectorParam 15214ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = cast<DependentSizedExtVectorType>(Param); 15224ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15234ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) { 15244ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the element types. 15254ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (Sema::TemplateDeductionResult Result 1526bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1527bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorParam->getElementType(), 1528bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorArg->getElementType(), 1529bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF)) 15304ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Result; 15314ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15324ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the vector size, if we can. 15334ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor NonTypeTemplateParmDecl *NTTP 15344ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = getDeducedParameterFromExpr(VectorParam->getSizeExpr()); 15354ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (!NTTP) 15364ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_Success; 15374ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15384ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false); 15394ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor ArgSize = VectorArg->getNumElements(); 15404ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return DeduceNonTypeTemplateArgument(S, NTTP, ArgSize, S.Context.IntTy, 15414ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor false, Info, Deduced); 15424ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 15434ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15444ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (const DependentSizedExtVectorType *VectorArg 15454ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = dyn_cast<DependentSizedExtVectorType>(Arg)) { 15464ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the element types. 15474ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (Sema::TemplateDeductionResult Result 1548bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1549bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorParam->getElementType(), 1550bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl VectorArg->getElementType(), 1551bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF)) 15524ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Result; 15534ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15544ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor // Perform deduction on the vector size, if we can. 15554ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor NonTypeTemplateParmDecl *NTTP 15564ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor = getDeducedParameterFromExpr(VectorParam->getSizeExpr()); 15574ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor if (!NTTP) 15584ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_Success; 15594ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15604ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return DeduceNonTypeTemplateArgument(S, NTTP, VectorArg->getSizeExpr(), 15614ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor Info, Deduced); 15624ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 15634ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 15644ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor return Sema::TDK_NonDeducedMismatch; 15654ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor } 15664ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor 1567637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::TypeOfExpr: 1568637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor case Type::TypeOf: 15694714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor case Type::DependentName: 15704ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::UnresolvedUsing: 15714ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Decltype: 15724ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::UnaryTransform: 15734ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::Auto: 15744ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::DependentTemplateSpecialization: 15754ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor case Type::PackExpansion: 1576637a4097f61b09d6ccf619298d9d121fafa044e4Douglas Gregor // No template argument deduction for these types 1577f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 15780b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 15790b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 15803026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid Type Class!"); 15810b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 15820b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 1583f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregorstatic Sema::TemplateDeductionResult 1584a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 1585f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 1586f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor const TemplateArgument &Param, 158777d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor TemplateArgument Arg, 15882a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 15895f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 159077d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // If the template argument is a pack expansion, perform template argument 159177d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // deduction against the pattern of that expansion. This only occurs during 159277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // partial ordering. 159377d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (Arg.isPackExpansion()) 159477d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Arg = Arg.getPackExpansionPattern(); 1595dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 15960b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor switch (Param.getKind()) { 1597199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Null: 1598b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Null template argument in parameter list"); 15991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case TemplateArgument::Type: 1601788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (Arg.getKind() == TemplateArgument::Type) 1602bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 1603bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Param.getAsType(), 1604bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Arg.getAsType(), 1605bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, 0); 1606788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.FirstArg = Param; 1607788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.SecondArg = Arg; 1608788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1609a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 1610788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 1611db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor if (Arg.getKind() == TemplateArgument::Template) 1612dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceTemplateArguments(S, TemplateParams, 1613788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Param.getAsTemplate(), 1614db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Arg.getAsTemplate(), Info, Deduced); 1615788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.FirstArg = Param; 1616788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Info.SecondArg = Arg; 1617788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 1618a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 1619a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 1620a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor llvm_unreachable("caller should handle pack expansions"); 1621dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1622199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Declaration: 1623788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (Arg.getKind() == TemplateArgument::Declaration && 1624d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl()) && 1625d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman Param.isDeclForReferenceParam() == Arg.isDeclForReferenceParam()) 1626d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return Sema::TDK_Success; 1627d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 1628d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman Info.FirstArg = Param; 1629d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman Info.SecondArg = Arg; 1630d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return Sema::TDK_NonDeducedMismatch; 1631d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 1632d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman case TemplateArgument::NullPtr: 1633d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman if (Arg.getKind() == TemplateArgument::NullPtr && 1634d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman S.Context.hasSameType(Param.getNullPtrType(), Arg.getNullPtrType())) 1635788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return Sema::TDK_Success; 1636dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1637f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1638f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1639f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 16401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1641199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Integral: 1642199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Integral) { 1643855243789cb44799c03f4c7216d3d6308805f549Benjamin Kramer if (hasSameExtendedValue(Param.getAsIntegral(), Arg.getAsIntegral())) 1644f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 1645f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1646f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1647f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1648f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1649f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 1650f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor 1651f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Arg.getKind() == TemplateArgument::Expression) { 1652f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1653f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1654f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1655199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 1656199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor 1657f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1658f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1659f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 16601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1661199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor case TemplateArgument::Expression: { 16621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (NonTypeTemplateParmDecl *NTTP 1663199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor = getDeducedParameterFromExpr(Param.getAsExpr())) { 1664199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Integral) 1665a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, 1666855243789cb44799c03f4c7216d3d6308805f549Benjamin Kramer Arg.getAsIntegral(), 16679d0e441036de0faa59d8039ce0c9967bda112c7fDouglas Gregor Arg.getIntegralType(), 166802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor /*ArrayBound=*/false, 1669f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 1670199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor if (Arg.getKind() == TemplateArgument::Expression) 1671a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(), 1672f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info, Deduced); 167315755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor if (Arg.getKind() == TemplateArgument::Declaration) 1674a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler Carruth return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(), 167515755cb8399afa702575a21915daf2f6e56b5ac1Douglas Gregor Info, Deduced); 1676dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1677f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.FirstArg = Param; 1678f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.SecondArg = Arg; 1679f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_NonDeducedMismatch; 1680199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 16811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1682199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor // Can't deduce anything, but that's okay. 1683f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 1684199d99192fbcca9f043596c40ead4afab4999dbaDouglas Gregor } 1685d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson case TemplateArgument::Pack: 168620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor llvm_unreachable("Argument packs should be expanded by the caller!"); 16870b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 16881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16893026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid TemplateArgument Kind!"); 16900b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 16910b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 169220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \brief Determine whether there is a template argument to be used for 169320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// deduction. 169420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// 169520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// This routine "expands" argument packs in-place, overriding its input 169620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// parameters so that \c Args[ArgIdx] will be the available template argument. 169720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// 169820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \returns true if there is another template argument (which will be at 169920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor/// \c Args[ArgIdx]), false otherwise. 1700dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args, 170120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned &ArgIdx, 170220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned &NumArgs) { 170320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (ArgIdx == NumArgs) 170420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return false; 1705dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 170620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument &Arg = Args[ArgIdx]; 170720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (Arg.getKind() != TemplateArgument::Pack) 170820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return true; 170920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 171020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor assert(ArgIdx == NumArgs - 1 && "Pack not at the end of argument list?"); 171120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Args = Arg.pack_begin(); 171220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor NumArgs = Arg.pack_size(); 171320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ArgIdx = 0; 171420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor return ArgIdx < NumArgs; 171520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor} 171620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 17177b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor/// \brief Determine whether the given set of template arguments has a pack 17187b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor/// expansion that is not the last template argument. 17197b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregorstatic bool hasPackExpansionBeforeEnd(const TemplateArgument *Args, 17207b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor unsigned NumArgs) { 17217b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor unsigned ArgIdx = 0; 17227b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor while (ArgIdx < NumArgs) { 17237b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor const TemplateArgument &Arg = Args[ArgIdx]; 1724dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 17257b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // Unwrap argument packs. 17267b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (Args[ArgIdx].getKind() == TemplateArgument::Pack) { 17277b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor Args = Arg.pack_begin(); 17287b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor NumArgs = Arg.pack_size(); 17297b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor ArgIdx = 0; 17307b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor continue; 17317b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor } 1732dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 17337b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor ++ArgIdx; 17347b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (ArgIdx == NumArgs) 17357b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return false; 1736dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 17377b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (Arg.isPackExpansion()) 17387b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return true; 17397b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor } 1740dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 17417b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return false; 17427b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor} 17437b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 17441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic Sema::TemplateDeductionResult 1745a7ef13024e4cc3dfb75e3bc1695371b39d9a5240Chandler CarruthDeduceTemplateArguments(Sema &S, 1746f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor TemplateParameterList *TemplateParams, 174720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Params, unsigned NumParams, 174820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgument *Args, unsigned NumArgs, 17492a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info, 1750030a6644f253818b81b4d8a7fc1770c0a3d35474Richard Smith SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 1751e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1752dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the template argument list of P contains a pack expansion that is not 1753dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the last template argument, the entire template argument list is a 1754e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // non-deduced context. 17557b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor if (hasPackExpansionBeforeEnd(Params, NumParams)) 17567b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return Sema::TDK_Success; 1757dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1758e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1759dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If P has a form that contains <T> or <i>, then each argument Pi of the 1760dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // respective template argument list P is compared with the corresponding 1761e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // argument Ai of the corresponding template argument list of A. 176220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor unsigned ArgIdx = 0, ParamIdx = 0; 1763dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams); 176420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ++ParamIdx) { 176520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (!Params[ParamIdx].isPackExpansion()) { 1766e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The simple case: deduce template arguments by matching Pi and Ai. 1767dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 176820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Check whether we have enough arguments. 176920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) 1770030a6644f253818b81b4d8a7fc1770c0a3d35474Richard Smith return Sema::TDK_Success; 1771dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 177277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor if (Args[ArgIdx].isPackExpansion()) { 177377d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here, 177477d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor // but applied to pack expansions that are template arguments. 177577d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor return Sema::TDK_NonDeducedMismatch; 177677d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor } 1777dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1778e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Perform deduction for this Pi/Ai pair. 177920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor if (Sema::TemplateDeductionResult Result 178077d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor = DeduceTemplateArguments(S, TemplateParams, 178177d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Params[ParamIdx], Args[ArgIdx], 178277d6bb9e223496aa5288294f34e7225d1f65dddcDouglas Gregor Info, Deduced)) 1783dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Result; 1784dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 178520a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor // Move to the next argument. 178620a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ++ArgIdx; 178720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor continue; 178820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor } 1789dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1790e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The parameter is a pack expansion. 1791dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1792e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // C++0x [temp.deduct.type]p9: 1793dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If Pi is a pack expansion, then the pattern of Pi is compared with 1794dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // each remaining argument in the template argument list of A. Each 1795dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // comparison deduces template arguments for subsequent positions in the 1796e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // template parameter packs expanded by Pi. 1797e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern(); 1798dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1799e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Compute the set of template parameter indices that correspond to 1800e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // parameter packs expanded by the pack expansion. 18015f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<unsigned, 2> PackIndices; 1802e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor { 1803013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector SawIndices(TemplateParams->size()); 18045f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<UnexpandedParameterPack, 2> Unexpanded; 1805e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor S.collectUnexpandedParameterPacks(Pattern, Unexpanded); 1806e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 1807e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor unsigned Depth, Index; 1808e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 1809e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 1810e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor SawIndices[Index] = true; 1811e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor PackIndices.push_back(Index); 1812e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1813e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1814e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1815e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 1816dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1817e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // FIXME: If there are no remaining arguments, we can bail out early 1818e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // and set any deduced parameter packs to an empty argument pack. 1819e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // The latter part of this is a (minor) correctness issue. 1820dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1821e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Save the deduced template arguments for each parameter pack expanded 1822e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // by this pack expansion, then clear out the deduction. 18235f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 2> 1824e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor SavedPacks(PackIndices.size()); 18255f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2> 18265429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor NewlyDeducedPacks(PackIndices.size()); 1827dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, 18285429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor NewlyDeducedPacks); 1829e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 1830e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Keep track of the deduced template arguments for each parameter pack 1831dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // expanded by this pack expansion (the outer index) and for each 1832e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // template argument (the inner SmallVectors). 1833e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor bool HasAnyArguments = false; 1834e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor while (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) { 1835e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor HasAnyArguments = true; 1836dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1837e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Deduce template arguments from the pattern. 1838dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (Sema::TemplateDeductionResult Result 1839e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx], 1840e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info, Deduced)) 1841e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor return Result; 1842dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1843e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 1844e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 1845e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // for that pack, then clear out the deduced argument. 1846e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 1847e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 1848e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (!DeducedArg.isNull()) { 1849e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 1850e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor DeducedArg = DeducedTemplateArgument(); 1851e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1852e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1853dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1854e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor ++ArgIdx; 1855e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor } 1856dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1857e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 1858e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor // pack expansion. 18590216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Sema::TemplateDeductionResult Result 1860dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, 18610216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced, PackIndices, SavedPacks, 18620216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewlyDeducedPacks, Info)) 1863dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Result; 18640b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor } 1865dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1866f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor return Sema::TDK_Success; 18670b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 18680b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor 186920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregorstatic Sema::TemplateDeductionResult 187020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas GregorDeduceTemplateArguments(Sema &S, 187120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateParameterList *TemplateParams, 187220a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgumentList &ParamList, 187320a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor const TemplateArgumentList &ArgList, 187420a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor TemplateDeductionInfo &Info, 18755f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced) { 1876dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return DeduceTemplateArguments(S, TemplateParams, 187720a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ParamList.data(), ParamList.size(), 187820a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor ArgList.data(), ArgList.size(), 187920a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor Info, Deduced); 188020a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor} 188120a55e2515ce89ddf9993941f9b5d0f3a6c91b4fDouglas Gregor 1882f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor/// \brief Determine whether two template arguments are the same. 18831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic bool isSameTemplateArg(ASTContext &Context, 1884f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor const TemplateArgument &X, 1885f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor const TemplateArgument &Y) { 1886f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (X.getKind() != Y.getKind()) 1887f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 18881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1889f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor switch (X.getKind()) { 1890f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Null: 1891b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Comparing NULL template argument"); 18921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1893f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Type: 1894f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return Context.getCanonicalType(X.getAsType()) == 1895f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Context.getCanonicalType(Y.getAsType()); 18961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1897f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Declaration: 1898d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) && 1899d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman X.isDeclForReferenceParam() == Y.isDeclForReferenceParam(); 1900d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 1901d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman case TemplateArgument::NullPtr: 1902d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType()); 19031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1904788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 1905a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 1906a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return Context.getCanonicalTemplateName( 1907a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() == 1908a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Context.getCanonicalTemplateName( 1909a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer(); 1910dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1911f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Integral: 1912855243789cb44799c03f4c7216d3d6308805f549Benjamin Kramer return X.getAsIntegral() == Y.getAsIntegral(); 19131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1914788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Expression: { 1915788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor llvm::FoldingSetNodeID XID, YID; 1916788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor X.getAsExpr()->Profile(XID, Context, true); 1917dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Y.getAsExpr()->Profile(YID, Context, true); 1918788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return XID == YID; 1919788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor } 19201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1921f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor case TemplateArgument::Pack: 1922f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (X.pack_size() != Y.pack_size()) 1923f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 19241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (TemplateArgument::pack_iterator XP = X.pack_begin(), 19261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump XPEnd = X.pack_end(), 1927f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor YP = Y.pack_begin(); 19281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump XP != XPEnd; ++XP, ++YP) 1929f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor if (!isSameTemplateArg(Context, *XP, *YP)) 1930f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return false; 1931f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 1932f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor return true; 1933f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 1934f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 19353026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid TemplateArgument Kind!"); 1936f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor} 1937f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor 193854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \brief Allocate a TemplateArgumentLoc where all locations have 193954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// been initialized to the given location. 194054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 194154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param S The semantic analysis object. 194254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 19431dfbd92c83699820bfaa352e83083124e34fc9dcJames Dennett/// \param Arg The template argument we are producing template argument 194454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// location information for. 194554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 194654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param NTTPType For a declaration template argument, the type of 194754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// the non-type template parameter that corresponds to this template 194854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// argument. 194954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// 195054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \param Loc The source location to use for the resulting template 195154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// argument. 1952dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic TemplateArgumentLoc 195354c53cca105ed595e12fecf04e415c3712bda936Douglas GregorgetTrivialTemplateArgumentLoc(Sema &S, 1954dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi const TemplateArgument &Arg, 195554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor QualType NTTPType, 195654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor SourceLocation Loc) { 195754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor switch (Arg.getKind()) { 195854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Null: 195954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor llvm_unreachable("Can't get a NULL template argument here"); 1960dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 196154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Type: 1962dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return TemplateArgumentLoc(Arg, 196354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); 1964dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 196554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Declaration: { 196654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Expr *E 1967ba68eca7582a62e3e2ff4b0eba1b2b73a6b80895Douglas Gregor = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) 1968d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor .takeAs<Expr>(); 196954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(TemplateArgument(E), E); 197054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 1971dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1972d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman case TemplateArgument::NullPtr: { 1973d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman Expr *E 1974d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) 1975d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman .takeAs<Expr>(); 1976d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman return TemplateArgumentLoc(TemplateArgument(NTTPType, /*isNullPtr*/true), 1977d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman E); 1978d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman } 1979d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 198054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Integral: { 198154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Expr *E 1982ba68eca7582a62e3e2ff4b0eba1b2b73a6b80895Douglas Gregor = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs<Expr>(); 198354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(TemplateArgument(E), E); 198454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 1985dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 1986b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor case TemplateArgument::Template: 1987b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor case TemplateArgument::TemplateExpansion: { 1988b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor NestedNameSpecifierLocBuilder Builder; 1989b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor TemplateName Template = Arg.getAsTemplate(); 1990b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) 1991b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Builder.MakeTrivial(S.Context, DTN->getQualifier(), Loc); 1992b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 1993b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Builder.MakeTrivial(S.Context, QTN->getQualifier(), Loc); 1994b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor 1995b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor if (Arg.getKind() == TemplateArgument::Template) 1996b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor return TemplateArgumentLoc(Arg, 1997b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Builder.getWithLocInContext(S.Context), 1998b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Loc); 1999b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor 2000b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor 2001b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context), 2002b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor Loc, Loc); 2003b6744efecba58792cce20d2d7b9ee39927c5422eDouglas Gregor } 2004a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 200554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Expression: 200654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(Arg, Arg.getAsExpr()); 2007dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 200854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor case TemplateArgument::Pack: 200954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); 201054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 2011dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 20123026348bd4c13a0f83b59839f64065e0fcbea253David Blaikie llvm_unreachable("Invalid TemplateArgument Kind!"); 201354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor} 201454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 201554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 201654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// \brief Convert the given deduced template argument and add it to the set of 201754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor/// fully-converted template arguments. 2018dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumistatic bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, 201954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor DeducedTemplateArgument Arg, 2020dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NamedDecl *Template, 2021dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi QualType NTTPType, 20226952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor unsigned ArgumentPackIndex, 202354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateDeductionInfo &Info, 202454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor bool InFunctionTemplate, 20255f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<TemplateArgument> &Output) { 202654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (Arg.getKind() == TemplateArgument::Pack) { 202754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // This is a template argument pack, so check each of its arguments against 202854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // the template parameter. 20295f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 2> PackedArgsBuilder; 2030dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi for (TemplateArgument::pack_iterator PA = Arg.pack_begin(), 2031135ffa7375fb5802b92f42774e02d0e6e4c78e5bDouglas Gregor PAEnd = Arg.pack_end(); 203254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor PA != PAEnd; ++PA) { 2033d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // When converting the deduced template argument, append it to the 2034d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // general output list. We need to do this so that the template argument 2035d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // checking logic has all of the prior template arguments available. 203654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor DeducedTemplateArgument InnerArg(*PA); 203754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound()); 2038dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template, 20396952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NTTPType, PackedArgsBuilder.size(), 20406952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor Info, InFunctionTemplate, Output)) 204154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return true; 2042dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2043d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // Move the converted template argument into our argument pack. 2044d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor PackedArgsBuilder.push_back(Output.back()); 2045d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Output.pop_back(); 204654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 2047dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 204854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Create the resulting argument pack. 2049dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Output.push_back(TemplateArgument::CreatePackCopy(S.Context, 2050203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor PackedArgsBuilder.data(), 2051203e6a322ae29d577acafcb1572a57ec16e1e730Douglas Gregor PackedArgsBuilder.size())); 205254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return false; 205354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 2054dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 205554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Convert the deduced template argument into a template 205654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // argument that we can check, almost as if the user had written 205754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // the template argument explicitly. 205854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType, 205954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.getLocation()); 2060dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 206154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // Check the template argument, converting it as necessary. 206254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return S.CheckTemplateArgument(Param, ArgLoc, 206354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template, 206454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template->getLocation(), 206554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Template->getSourceRange().getEnd(), 20666952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ArgumentPackIndex, 206754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Output, 206854c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InFunctionTemplate 206954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor ? (Arg.wasDeducedFromArrayBound() 2070dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi ? Sema::CTAK_DeducedFromArrayBound 207154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor : Sema::CTAK_Deduced) 207254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor : Sema::CTAK_Specified); 207354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor} 207454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor 207531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// Complete template argument deduction for a class template partial 207631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// specialization. 207731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregorstatic Sema::TemplateDeductionResult 2078dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA TakumiFinishTemplateArgumentDeduction(Sema &S, 207931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor ClassTemplatePartialSpecializationDecl *Partial, 208031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor const TemplateArgumentList &TemplateArgs, 20815f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 20822a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall TemplateDeductionInfo &Info) { 208359a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 208459a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated); 208531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Sema::SFINAETrap Trap(S); 2086dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 208731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Sema::ContextRAII SavedContext(S, Partial); 2088f5813826802c2e76cdc13cae834ebfd4518d74a6John McCall 208902cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // C++ [temp.deduct.type]p2: 209002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // [...] or if any template argument remains neither deduced nor 209102cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // explicitly specified, template argument deduction fails. 20925f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> Builder; 2093033a3cad525e5b221ba035ffc3e0abfa1241d90eDouglas Gregor TemplateParameterList *PartialParams = Partial->getTemplateParameters(); 2094033a3cad525e5b221ba035ffc3e0abfa1241d90eDouglas Gregor for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) { 209554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NamedDecl *Param = PartialParams->getParam(I); 2096f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor if (Deduced[I].isNull()) { 209754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.Param = makeTemplateParameter(Param); 209831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_Incomplete; 2099f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor } 2100dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 210154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // We have deduced this argument, so it still needs to be 210254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // checked and converted. 2103dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 210454c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // First, for a non-type template parameter type that is 210554c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // initialized by a declaration, we need the type of the 210654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // corresponding non-type template parameter. 210754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor QualType NTTPType; 2108dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (NonTypeTemplateParmDecl *NTTP 2109d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 211054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor NTTPType = NTTP->getType(); 2111d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor if (NTTPType->isDependentType()) { 2112dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2113d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Builder.data(), Builder.size()); 2114d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTPType = S.SubstType(NTTPType, 2115d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor MultiLevelTemplateArgumentList(TemplateArgs), 2116d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTP->getLocation(), 2117d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor NTTP->getDeclName()); 2118d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor if (NTTPType.isNull()) { 2119d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Info.Param = makeTemplateParameter(Param); 2120d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor // FIXME: These template arguments are temporary. Free them! 2121dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(S.Context, 2122dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Builder.data(), 2123d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor Builder.size())); 2124d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor return Sema::TDK_SubstitutionFailure; 2125d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 2126d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 2127d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor } 2128d53e16abd1dcaa2942d5183f48e7f63d0e75b35aDouglas Gregor 212954c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], 21306952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor Partial, NTTPType, 0, Info, false, 213154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Builder)) { 213254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor Info.Param = makeTemplateParameter(Param); 213354c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2134dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(), 2135dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Builder.size())); 213654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor return Sema::TDK_SubstitutionFailure; 213754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor } 213802cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor } 2139dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 214002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // Form the template argument list from the deduced template arguments. 21411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *DeducedArgumentList 2142dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = TemplateArgumentList::CreateCopy(S.Context, Builder.data(), 2143910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.size()); 2144910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor 2145f67875d5addf36b951ad37fb04509ab2b572c88aDouglas Gregor Info.reset(DeducedArgumentList); 214602cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 214702cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // Substitute the deduced template arguments into the template 214802cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // arguments of the class template partial specialization, and 214902cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // verify that the instantiated template arguments are both valid 215002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor // and are equivalent to the template arguments originally provided 21511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // to the class template. 21522a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(S); 215302cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate(); 2154833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall const TemplateArgumentLoc *PartialTemplateArgs 2155833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall = Partial->getTemplateArgsAsWritten(); 2156d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 2157d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall // Note that we don't provide the langle and rangle locations. 2158d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall TemplateArgumentListInfo InstArgs; 2159d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 2160e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (S.Subst(PartialTemplateArgs, 2161e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Partial->getNumTemplateArgsAsWritten(), 2162e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) { 2163e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx; 2164e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor if (ParamIdx >= Partial->getTemplateParameters()->size()) 2165e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor ParamIdx = Partial->getTemplateParameters()->size() - 1; 2166e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor 2167e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Decl *Param 2168e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor = const_cast<NamedDecl *>( 2169e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Partial->getTemplateParameters()->getParam(ParamIdx)); 2170e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info.Param = makeTemplateParameter(Param); 2171e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument(); 2172e02e26293cf8e3bad1059b39cea75c6582896da6Douglas Gregor return Sema::TDK_SubstitutionFailure; 2173833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall } 2174833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 21755f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> ConvertedInstArgs; 217631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(), 217754c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor InstArgs, false, ConvertedInstArgs)) 217831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 2179dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 218054c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor TemplateParameterList *TemplateParams 218154c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor = ClassTemplate->getTemplateParameters(); 218254c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { 2183910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgument InstArg = ConvertedInstArgs.data()[I]; 218431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) { 21852fdc5e8199e1e239620f2faae88997153703e16fDouglas Gregor Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); 2186f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.FirstArg = TemplateArgs[I]; 2187f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor Info.SecondArg = InstArg; 218831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_NonDeducedMismatch; 2189f670c8cfa58b4c224eb8fb566130dc47844dd3deDouglas Gregor } 219002cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor } 219102cbbd2d945e466174bee536758e5a2e6a1c0ea2Douglas Gregor 2192bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor if (Trap.hasErrorOccurred()) 219331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 2194bb2604122f4186b6f666481f699b27c7e7a95790Douglas Gregor 219531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_Success; 219631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor} 219731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 219831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// \brief Perform template argument deduction to determine whether 219931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// the given template arguments match the given class template 220031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor/// partial specialization per C++ [temp.class.spec.match]. 220131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas GregorSema::TemplateDeductionResult 220231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas GregorSema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, 220331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor const TemplateArgumentList &TemplateArgs, 220431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor TemplateDeductionInfo &Info) { 2205ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor if (Partial->isInvalidDecl()) 2206ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor return TDK_Invalid; 2207ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor 220831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // C++ [temp.class.spec.match]p2: 220931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // A partial specialization matches a given actual template 221031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // argument list if the template arguments of the partial 221131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // specialization can be deduced from the actual template argument 221231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // list (14.8.2). 221359a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman 221459a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 221559a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 221631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor SFINAETrap Trap(*this); 221759a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman 22185f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 221931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Deduced.resize(Partial->getTemplateParameters()->size()); 222031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (TemplateDeductionResult Result 222131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor = ::DeduceTemplateArguments(*this, 222231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Partial->getTemplateParameters(), 222331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Partial->getTemplateArgs(), 222431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor TemplateArgs, Info, Deduced)) 222531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Result; 222631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 22277e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); 222831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial, 22297e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith DeducedArgs, Info); 223031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (Inst) 223131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return TDK_InstantiationDepth; 223231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor 223331dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor if (Trap.hasErrorOccurred()) 223431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor return Sema::TDK_SubstitutionFailure; 2235dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2236dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs, 223731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor Deduced, Info); 22380b9247f129401b4849682b2e2bcdea8fc977068aDouglas Gregor} 2239031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 22404112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor/// \brief Determine whether the given type T is a simple-template-id type. 22414112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregorstatic bool isSimpleTemplateIdType(QualType T) { 22421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const TemplateSpecializationType *Spec 2243183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = T->getAs<TemplateSpecializationType>()) 22444112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor return Spec->getTemplateName().getAsTemplateDecl() != 0; 22451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 22464112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor return false; 22474112877d1043d0b937f5abcf043bc7fa48138f05Douglas Gregor} 224883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 224983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \brief Substitute the explicitly-provided template arguments into the 225083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// given function template according to C++ [temp.arg.explicit]. 225183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 225283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionTemplate the function template into which the explicit 225383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template arguments will be substituted. 225483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 22551dfbd92c83699820bfaa352e83083124e34fc9dcJames Dennett/// \param ExplicitTemplateArgs the explicitly-specified template 225683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// arguments. 225783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 22581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param Deduced the deduced template arguments, which will be populated 225983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// with the converted and checked explicit template arguments. 226083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 22611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param ParamTypes will be populated with the instantiated function 226283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// parameters. 226383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 226483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionType if non-NULL, the result type of the function template 226583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// will also be instantiated and the pointed-to value will be updated with 226683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the instantiated function type. 226783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 226883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Info if substitution fails for any reason, this object will be 226983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// populated with more information about the failure. 227083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 227183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \returns TDK_Success if substitution was successful, or some failure 227283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// condition. 227383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::TemplateDeductionResult 227483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::SubstituteExplicitTemplateArguments( 227583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionTemplateDecl *FunctionTemplate, 227667714230a191bc3c01f33378f34f34ef377991a6Douglas Gregor TemplateArgumentListInfo &ExplicitTemplateArgs, 22775f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 22785f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<QualType> &ParamTypes, 227983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType *FunctionType, 228083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 228183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 228283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 228383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 228483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 2285d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs.size() == 0) { 228683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // No arguments to substitute; just copy over the parameter types and 228783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // fill in the function type. 228883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor for (FunctionDecl::param_iterator P = Function->param_begin(), 228983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor PEnd = Function->param_end(); 229083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor P != PEnd; 229183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ++P) 229283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes.push_back((*P)->getType()); 22931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 229483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType) 229583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor *FunctionType = Function->getType(); 229683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Success; 229783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 22981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 229959a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 230059a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 23011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 23021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 230383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.arg.explicit]p3: 23041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Template arguments that are present shall be specified in the 23051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // declaration order of their corresponding template-parameters. The 230683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template argument list shall not specify more template-arguments than 23071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // there are corresponding template-parameters. 23085f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> Builder; 23091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 23101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Enter a new template instantiation context where we check the 231183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly-specified template arguments against this function template, 231283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // and then substitute them into the function parameter types. 23137e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); 23141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), 23157e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith FunctionTemplate, DeducedArgs, 23169b623639378d53a675921ddfa7316034d571881eDouglas Gregor ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution, 23179b623639378d53a675921ddfa7316034d571881eDouglas Gregor Info); 231883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Inst) 231983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_InstantiationDepth; 23201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 232183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (CheckTemplateArgumentList(FunctionTemplate, 232283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SourceLocation(), 2323d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall ExplicitTemplateArgs, 232483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor true, 2325f1a8445036a2d047c7165d4170e3058cdeaba6ebDouglas Gregor Builder) || Trap.hasErrorOccurred()) { 2326910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor unsigned Index = Builder.size(); 2327fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor if (Index >= TemplateParams->size()) 2328fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor Index = TemplateParams->size() - 1; 2329fe52c91dcd1ecda90b579f789baf70f7a992e3c9Douglas Gregor Info.Param = makeTemplateParameter(TemplateParams->getParam(Index)); 233083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_InvalidExplicitArguments; 2331f1a8445036a2d047c7165d4170e3058cdeaba6ebDouglas Gregor } 23321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 233383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Form the template argument list from the explicitly-specified 233483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template arguments. 23351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *ExplicitArgumentList 2336910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); 233783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.reset(ExplicitArgumentList); 2338dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2339df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // Template argument deduction and the final substitution should be 2340df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // done in the context of the templated declaration. Explicit 2341df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // argument substitution, on the other hand, needs to happen in the 2342df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall // calling context. 2343df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); 2344df41f18936693f7c62e457eefb9fad5b2d2fe3cdJohn McCall 2345dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If we deduced template arguments for a template parameter pack, 2346d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // note that the template argument pack is partially substituted and record 2347d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // the explicit template arguments. They'll be used as part of deduction 2348d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // for this template parameter pack. 2349d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor for (unsigned I = 0, N = Builder.size(); I != N; ++I) { 2350d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor const TemplateArgument &Arg = Builder[I]; 2351d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (Arg.getKind() == TemplateArgument::Pack) { 2352d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor CurrentInstantiationScope->SetPartiallySubstitutedPack( 2353dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateParams->getParam(I), 2354d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Arg.pack_begin(), 2355d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Arg.pack_size()); 2356d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor break; 2357d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor } 2358d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor } 2359d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor 2360eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith const FunctionProtoType *Proto 2361eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith = Function->getType()->getAs<FunctionProtoType>(); 2362eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith assert(Proto && "Function template does not have a prototype?"); 2363eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith 236483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Instantiate the types of each of the function parameters given the 2365eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // explicitly-specified template arguments. If the function has a trailing 2366eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // return type, substitute it after the arguments to ensure we substitute 2367eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // in lexical order. 2368cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor if (Proto->hasTrailingReturn()) { 2369cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor if (SubstParmTypes(Function->getLocation(), 2370cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor Function->param_begin(), Function->getNumParams(), 2371cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor MultiLevelTemplateArgumentList(*ExplicitArgumentList), 2372cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor ParamTypes)) 2373cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor return TDK_SubstitutionFailure; 2374cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor } 2375cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor 2376eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // Instantiate the return type. 2377eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // FIXME: exception-specifications? 2378cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor QualType ResultType; 2379cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor { 2380cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // C++11 [expr.prim.general]p3: 2381cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // If a declaration declares a member function or member function 2382cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // template of a class X, the expression this is a prvalue of type 2383cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq 2384cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // and the end of the function-definition, member-declarator, or 2385cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor // declarator. 2386cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor unsigned ThisTypeQuals = 0; 2387cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor CXXRecordDecl *ThisContext = 0; 2388cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) { 2389cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor ThisContext = Method->getParent(); 2390cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor ThisTypeQuals = Method->getTypeQualifiers(); 2391cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor } 2392cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor 2393cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals, 239480ad52f327b532bded5c5b0ee38779d841c6cd35Richard Smith getLangOpts().CPlusPlus11); 2395cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor 2396cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor ResultType = SubstType(Proto->getResultType(), 2397cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor MultiLevelTemplateArgumentList(*ExplicitArgumentList), 2398cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor Function->getTypeSpecStartLoc(), 2399cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor Function->getDeclName()); 2400cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor if (ResultType.isNull() || Trap.hasErrorOccurred()) 2401cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor return TDK_SubstitutionFailure; 2402cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor } 2403cefc3afac14d29de5aba7810cc8fe6c858949e9dDouglas Gregor 2404eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // Instantiate the types of each of the function parameters given the 2405eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith // explicitly-specified template arguments if we didn't do so earlier. 2406eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith if (!Proto->hasTrailingReturn() && 2407eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith SubstParmTypes(Function->getLocation(), 2408eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith Function->param_begin(), Function->getNumParams(), 2409eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith MultiLevelTemplateArgumentList(*ExplicitArgumentList), 2410eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith ParamTypes)) 2411eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith return TDK_SubstitutionFailure; 2412eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith 2413eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith if (FunctionType) { 24141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump *FunctionType = BuildFunctionType(ResultType, 241583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes.data(), ParamTypes.size(), 241683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Proto->isVariadic(), 2417eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith Proto->hasTrailingReturn(), 241883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Proto->getTypeQuals(), 2419c938c1668b4fd12af154e965dd935a89e4801a70Douglas Gregor Proto->getRefQualifier(), 242083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Function->getLocation(), 2421fa869547eb1cab12d7e0c0dfa8ba594e336b9b32Eli Friedman Function->getDeclName(), 2422fa869547eb1cab12d7e0c0dfa8ba594e336b9b32Eli Friedman Proto->getExtInfo()); 242383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (FunctionType->isNull() || Trap.hasErrorOccurred()) 242483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 242583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 24261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 242783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.arg.explicit]p2: 24281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Trailing template arguments that can be deduced (14.8.2) may be 24291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // omitted from the list of explicit template-arguments. If all of the 243083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // template arguments can be deduced, they may all be omitted; in this 243183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // case, the empty template argument list <> itself may also be omitted. 243283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // 2433d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // Take all of the explicitly-specified arguments and put them into 2434d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // the set of deduced template arguments. Explicitly-specified 2435d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // parameter packs, however, will be set to NULL since the deduction 2436d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // mechanisms handle explicitly-specified argument packs directly. 243783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced.reserve(TemplateParams->size()); 2438d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) { 2439d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor const TemplateArgument &Arg = ExplicitArgumentList->get(I); 2440d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor if (Arg.getKind() == TemplateArgument::Pack) 2441d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Deduced.push_back(DeducedTemplateArgument()); 2442d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor else 2443d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Deduced.push_back(Arg); 2444d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor } 24451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 244683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Success; 244783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 244883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 2449b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor/// \brief Check whether the deduced argument type for a call to a function 2450b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor/// template matches the actual argument type per C++ [temp.deduct.call]p4. 2451b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregorstatic bool 2452b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas GregorCheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg, 2453b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor QualType DeducedA) { 2454b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor ASTContext &Context = S.Context; 2455b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2456b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor QualType A = OriginalArg.OriginalArgType; 2457b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor QualType OriginalParamType = OriginalArg.OriginalParamType; 2458b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2459b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // Check for type equality (top-level cv-qualifiers are ignored). 2460b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (Context.hasSameUnqualifiedType(A, DeducedA)) 2461b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return false; 2462b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2463b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // Strip off references on the argument types; they aren't needed for 2464b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // the following checks. 2465b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const ReferenceType *DeducedARef = DeducedA->getAs<ReferenceType>()) 2466b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor DeducedA = DeducedARef->getPointeeType(); 2467b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const ReferenceType *ARef = A->getAs<ReferenceType>()) 2468b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor A = ARef->getPointeeType(); 2469b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2470b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // C++ [temp.deduct.call]p4: 2471b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // [...] However, there are three cases that allow a difference: 2472b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // - If the original P is a reference type, the deduced A (i.e., the 2473b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // type referred to by the reference) can be more cv-qualified than 2474b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // the transformed A. 2475b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const ReferenceType *OriginalParamRef 2476b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor = OriginalParamType->getAs<ReferenceType>()) { 2477b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // We don't want to keep the reference around any more. 2478b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor OriginalParamType = OriginalParamRef->getPointeeType(); 2479b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2480b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor Qualifiers AQuals = A.getQualifiers(); 2481b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor Qualifiers DeducedAQuals = DeducedA.getQualifiers(); 2482b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor 2483b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor // Under Objective-C++ ARC, the deduced type may have implicitly been 2484b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor // given strong lifetime. If so, update the original qualifiers to 2485b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor // include this strong lifetime. 2486b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor if (S.getLangOpts().ObjCAutoRefCount && 2487b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_Strong && 2488b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor AQuals.getObjCLifetime() == Qualifiers::OCL_None) { 2489b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor AQuals.setObjCLifetime(Qualifiers::OCL_Strong); 2490b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor } 2491b251302dd52249c49ba6527fcd013396deef22cfDouglas Gregor 2492b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (AQuals == DeducedAQuals) { 2493b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // Qualifiers match; there's nothing to do. 2494b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } else if (!DeducedAQuals.compatiblyIncludes(AQuals)) { 2495c99f0ec89fd9782cfafd14d7b1b0a80151eab24aDouglas Gregor return true; 2496b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } else { 2497b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // Qualifiers are compatible, so have the argument type adopt the 2498b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // deduced argument type's qualifiers as if we had performed the 2499b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // qualification conversion. 2500b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor A = Context.getQualifiedType(A.getUnqualifiedType(), DeducedAQuals); 2501b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2502b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2503b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2504b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // - The transformed A can be another pointer or pointer to member 2505b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // type that can be converted to the deduced A via a qualification 2506b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // conversion. 250718e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth // 250818e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth // Also allow conversions which merely strip [[noreturn]] from function types 250918e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth // (recursively) as an extension. 251018e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth // FIXME: Currently, this doesn't place nicely with qualfication conversions. 2511b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor bool ObjCLifetimeConversion = false; 251218e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth QualType ResultTy; 2513b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if ((A->isAnyPointerType() || A->isMemberPointerType()) && 251418e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth (S.IsQualificationConversion(A, DeducedA, false, 251518e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth ObjCLifetimeConversion) || 251618e0461ad72dcf6ec93cd3b1df7bf1b5a30b10b7Chandler Carruth S.IsNoReturnConversion(A, DeducedA, ResultTy))) 2517b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return false; 2518b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2519b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2520b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // - If P is a class and P has the form simple-template-id, then the 2521b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // transformed A can be a derived class of the deduced A. [...] 2522b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // [...] Likewise, if P is a pointer to a class of the form 2523b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // simple-template-id, the transformed A can be a pointer to a 2524b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor // derived class pointed to by the deduced A. 2525b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const PointerType *OriginalParamPtr 2526b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor = OriginalParamType->getAs<PointerType>()) { 2527b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const PointerType *DeducedAPtr = DeducedA->getAs<PointerType>()) { 2528b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (const PointerType *APtr = A->getAs<PointerType>()) { 2529b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (A->getPointeeType()->isRecordType()) { 2530b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor OriginalParamType = OriginalParamPtr->getPointeeType(); 2531b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor DeducedA = DeducedAPtr->getPointeeType(); 2532b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor A = APtr->getPointeeType(); 2533b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2534b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2535b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2536b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor } 2537b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2538b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (Context.hasSameUnqualifiedType(A, DeducedA)) 2539b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return false; 2540b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2541b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) && 2542b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor S.IsDerivedFrom(A, DeducedA)) 2543b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return false; 2544b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 2545b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return true; 2546b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor} 2547b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor 25481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Finish template argument deduction for a function template, 254983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// checking the deduced template arguments for completeness and forming 255083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// the function template specialization. 2551dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor/// 2552dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor/// \param OriginalCallArgs If non-NULL, the original call arguments against 2553dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor/// which the deduced argument types should be compared. 25541eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpSema::TemplateDeductionResult 255583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, 25565f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<DeducedTemplateArgument> &Deduced, 255702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified, 255883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *&Specialization, 2559dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor TemplateDeductionInfo &Info, 25605f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs) { 256183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 256283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 25631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 256459a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 256559a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 256651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor SFINAETrap Trap(*this); 256751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 256851ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Enter a new template instantiation context while we instantiate the 256951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // actual function declaration. 25707e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); 257151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), 25727e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith FunctionTemplate, DeducedArgs, 25739b623639378d53a675921ddfa7316034d571881eDouglas Gregor ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution, 25749b623639378d53a675921ddfa7316034d571881eDouglas Gregor Info); 257551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (Inst) 257651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor return TDK_InstantiationDepth; 257751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 257896db310ab7ca59e1890ddef25a3701bc2909d20fJohn McCall ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); 2579f5813826802c2e76cdc13cae834ebfd4518d74a6John McCall 258083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // C++ [temp.deduct.type]p2: 258183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // [...] or if any template argument remains neither deduced nor 258283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // explicitly specified, template argument deduction fails. 25835f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> Builder; 2584b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { 2585b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NamedDecl *Param = TemplateParams->getParam(I); 2586dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 258751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (!Deduced[I].isNull()) { 25883273b0cea879c7af345d6bf98502bbf73fc4fde1Douglas Gregor if (I < NumExplicitlySpecified) { 258902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // We have already fully type-checked and converted this 2590dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // argument, because it was explicitly-specified. Just record the 25913273b0cea879c7af345d6bf98502bbf73fc4fde1Douglas Gregor // presence of this argument. 2592910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.push_back(Deduced[I]); 259302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor continue; 259402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 259502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 259602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // We have deduced this argument, so it still needs to be 259702024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // checked and converted. 259802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 259902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // First, for a non-type template parameter type that is 260002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // initialized by a declaration, we need the type of the 260102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // corresponding non-type template parameter. 260202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor QualType NTTPType; 2603dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (NonTypeTemplateParmDecl *NTTP 2604dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 2605b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTPType = NTTP->getType(); 2606b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (NTTPType->isDependentType()) { 2607dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2608b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.data(), Builder.size()); 2609b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTPType = SubstType(NTTPType, 2610b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor MultiLevelTemplateArgumentList(TemplateArgs), 2611b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTP->getLocation(), 2612b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor NTTP->getDeclName()); 2613b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (NTTPType.isNull()) { 2614b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Info.Param = makeTemplateParameter(Param); 2615b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2616dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(Context, 2617dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Builder.data(), 2618b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Builder.size())); 2619b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor return TDK_SubstitutionFailure; 262002024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 262102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 262202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 262302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 2624b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I], 26256952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor FunctionTemplate, NTTPType, 0, Info, 262654c53cca105ed595e12fecf04e415c3712bda936Douglas Gregor true, Builder)) { 2627b9a7d6fb53f2b76df2ef832146a1edb4cb01b9f6Douglas Gregor Info.Param = makeTemplateParameter(Param); 2628910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2629dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), 2630dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Builder.size())); 263102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor return TDK_SubstitutionFailure; 263202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor } 263302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 263451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor continue; 263551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor } 2636dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2637ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // C++0x [temp.arg.explicit]p3: 2638dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // A trailing template parameter pack (14.5.3) not otherwise deduced will 2639ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // be deduced to an empty sequence of template arguments. 2640ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor // FIXME: Where did the word "trailing" come from? 2641ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor if (Param->isTemplateParameterPack()) { 2642d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // We may have had explicitly-specified template arguments for this 2643d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // template parameter pack. If so, our empty deduction extends the 2644d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // explicitly-specified set (C++0x [temp.arg.explicit]p9). 2645d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor const TemplateArgument *ExplicitArgs; 2646d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor unsigned NumExplicitArgs; 2647a8eaf008e92759142982f7b40720b2b2674bd663Richard Smith if (CurrentInstantiationScope && 2648a8eaf008e92759142982f7b40720b2b2674bd663Richard Smith CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs, 2649d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor &NumExplicitArgs) 2650d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor == Param) 2651d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor Builder.push_back(TemplateArgument(ExplicitArgs, NumExplicitArgs)); 2652dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi else 2653d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman Builder.push_back(TemplateArgument::getEmptyPack()); 2654dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2655ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor continue; 2656ea6c96f63a45b4ffdcdf9824a9cf31a32825c0f6Douglas Gregor } 265751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 2658dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // Substitute into the default template argument, if available. 265951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor TemplateArgumentLoc DefArg 266051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate, 266151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getLocation(), 266251ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getSourceRange().getEnd(), 266351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Param, 266451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Builder); 266551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor 266651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // If there was no default argument, deduction is incomplete. 266751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (DefArg.getArgument().isNull()) { 266883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.Param = makeTemplateParameter( 266951ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor const_cast<NamedDecl *>(TemplateParams->getParam(I))); 267083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_Incomplete; 267183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 2672dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 267351ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // Check whether we can actually use the default argument. 267451ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor if (CheckTemplateArgument(Param, DefArg, 267551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate, 267651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getLocation(), 267751ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor FunctionTemplate->getSourceRange().getEnd(), 26786952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor 0, Builder, 26798735b294a257a07ca158c28094d7324f0adf889aDouglas Gregor CTAK_Specified)) { 268051ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor Info.Param = makeTemplateParameter( 268151ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor const_cast<NamedDecl *>(TemplateParams->getParam(I))); 2682910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor // FIXME: These template arguments are temporary. Free them! 2683dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(), 2684910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Builder.size())); 268551ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor return TDK_SubstitutionFailure; 268651ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor } 26871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 268851ffb0c9d43b2d3fd210e51ecdd67ba5d1790d70Douglas Gregor // If we get here, we successfully used the default template argument. 268983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor } 26901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 269183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Form the template argument list from the deduced template arguments. 26921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateArgumentList *DeducedArgumentList 2693910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size()); 269483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.reset(DeducedArgumentList); 26951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 26961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Substitute the deduced template arguments into the function template 269783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // declaration to produce the function template specialization. 2698d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor DeclContext *Owner = FunctionTemplate->getDeclContext(); 2699d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor if (FunctionTemplate->getFriendObjectKind()) 2700d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor Owner = FunctionTemplate->getLexicalDeclContext(); 270183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Specialization = cast_or_null<FunctionDecl>( 2702d4598a2cc7576c06f69d3cf64d0e2c9783ddf529Douglas Gregor SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, 2703357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor MultiLevelTemplateArgumentList(*DeducedArgumentList))); 27045fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor if (!Specialization || Specialization->isInvalidDecl()) 270583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return TDK_SubstitutionFailure; 27061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2707dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() == 2708f882574cf640d5c8355965e1c486f9d8d8ffcf47Douglas Gregor FunctionTemplate->getCanonicalDecl()); 2709dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 27101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the template argument list is owned by the function template 271183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // specialization, release it. 2712ec20f46740a59758b12c22108002395bcf5b6f9bDouglas Gregor if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList && 2713ec20f46740a59758b12c22108002395bcf5b6f9bDouglas Gregor !Trap.hasErrorOccurred()) 271483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info.take(); 27151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 27165fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor // There may have been an error that did not prevent us from constructing a 27175fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor // declaration. Mark the declaration invalid and return with a substitution 27185fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor // failure. 27195fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor if (Trap.hasErrorOccurred()) { 27205fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor Specialization->setInvalidDecl(true); 27215fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor return TDK_SubstitutionFailure; 27225fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor } 27235fad9b8362c62e230f6603d86ec7d1747e74c737Douglas Gregor 2724dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor if (OriginalCallArgs) { 2725dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // C++ [temp.deduct.call]p4: 2726dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // In general, the deduction process attempts to find template argument 2727dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // values that will make the deduced A identical to A (after the type A 2728dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // is transformed as described above). [...] 2729dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) { 2730dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor OriginalCallArg OriginalArg = (*OriginalCallArgs)[I]; 2731dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor unsigned ParamIdx = OriginalArg.ArgIdx; 2732dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 2733dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor if (ParamIdx >= Specialization->getNumParams()) 2734dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor continue; 2735dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 2736dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType DeducedA = Specialization->getParamDecl(ParamIdx)->getType(); 2737b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA)) 2738b7edc4f372f1abe6c422ea711a99f9906a7464daDouglas Gregor return Sema::TDK_SubstitutionFailure; 2739dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor } 2740dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor } 2741dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 27429b623639378d53a675921ddfa7316034d571881eDouglas Gregor // If we suppressed any diagnostics while performing template argument 27439b623639378d53a675921ddfa7316034d571881eDouglas Gregor // deduction, and if we haven't already instantiated this declaration, 27449b623639378d53a675921ddfa7316034d571881eDouglas Gregor // keep track of these diagnostics. They'll be emitted if this specialization 27459b623639378d53a675921ddfa7316034d571881eDouglas Gregor // is actually used. 27469b623639378d53a675921ddfa7316034d571881eDouglas Gregor if (Info.diag_begin() != Info.diag_end()) { 27475f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >::iterator 27489b623639378d53a675921ddfa7316034d571881eDouglas Gregor Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl()); 27499b623639378d53a675921ddfa7316034d571881eDouglas Gregor if (Pos == SuppressedDiagnostics.end()) 27509b623639378d53a675921ddfa7316034d571881eDouglas Gregor SuppressedDiagnostics[Specialization->getCanonicalDecl()] 27519b623639378d53a675921ddfa7316034d571881eDouglas Gregor .append(Info.diag_begin(), Info.diag_end()); 2752dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi } 27539b623639378d53a675921ddfa7316034d571881eDouglas Gregor 27541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return TDK_Success; 275583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 275683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 27579c72c6088d591ace8503b842d39448c2040f3033John McCall/// Gets the type of a function for template-argument-deducton 27589c72c6088d591ace8503b842d39448c2040f3033John McCall/// purposes when it's considered as part of an overload set. 2759eff92135d32039c9874dc356f3e93143af6069c1John McCallstatic QualType GetTypeOfFunction(ASTContext &Context, 27609c72c6088d591ace8503b842d39448c2040f3033John McCall const OverloadExpr::FindResult &R, 2761eff92135d32039c9874dc356f3e93143af6069c1John McCall FunctionDecl *Fn) { 2762eff92135d32039c9874dc356f3e93143af6069c1John McCall if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) 27639c72c6088d591ace8503b842d39448c2040f3033John McCall if (Method->isInstance()) { 27649c72c6088d591ace8503b842d39448c2040f3033John McCall // An instance method that's referenced in a form that doesn't 27659c72c6088d591ace8503b842d39448c2040f3033John McCall // look like a member pointer is just invalid. 27669c72c6088d591ace8503b842d39448c2040f3033John McCall if (!R.HasFormOfMemberPointer) return QualType(); 27679c72c6088d591ace8503b842d39448c2040f3033John McCall 2768eff92135d32039c9874dc356f3e93143af6069c1John McCall return Context.getMemberPointerType(Fn->getType(), 2769eff92135d32039c9874dc356f3e93143af6069c1John McCall Context.getTypeDeclType(Method->getParent()).getTypePtr()); 27709c72c6088d591ace8503b842d39448c2040f3033John McCall } 27719c72c6088d591ace8503b842d39448c2040f3033John McCall 27729c72c6088d591ace8503b842d39448c2040f3033John McCall if (!R.IsAddressOfOperand) return Fn->getType(); 2773eff92135d32039c9874dc356f3e93143af6069c1John McCall return Context.getPointerType(Fn->getType()); 2774eff92135d32039c9874dc356f3e93143af6069c1John McCall} 2775eff92135d32039c9874dc356f3e93143af6069c1John McCall 2776eff92135d32039c9874dc356f3e93143af6069c1John McCall/// Apply the deduction rules for overload sets. 2777eff92135d32039c9874dc356f3e93143af6069c1John McCall/// 2778eff92135d32039c9874dc356f3e93143af6069c1John McCall/// \return the null type if this argument should be treated as an 2779eff92135d32039c9874dc356f3e93143af6069c1John McCall/// undeduced context 2780eff92135d32039c9874dc356f3e93143af6069c1John McCallstatic QualType 2781eff92135d32039c9874dc356f3e93143af6069c1John McCallResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, 278275f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor Expr *Arg, QualType ParamType, 278375f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor bool ParamWasReference) { 2784dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 27859c72c6088d591ace8503b842d39448c2040f3033John McCall OverloadExpr::FindResult R = OverloadExpr::find(Arg); 2786eff92135d32039c9874dc356f3e93143af6069c1John McCall 27879c72c6088d591ace8503b842d39448c2040f3033John McCall OverloadExpr *Ovl = R.Expression; 2788eff92135d32039c9874dc356f3e93143af6069c1John McCall 278975f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor // C++0x [temp.deduct.call]p4 279075f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor unsigned TDF = 0; 279175f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor if (ParamWasReference) 279275f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor TDF |= TDF_ParamWithReferenceType; 279375f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor if (R.IsAddressOfOperand) 279475f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor TDF |= TDF_IgnoreQualifiers; 279575f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor 2796eff92135d32039c9874dc356f3e93143af6069c1John McCall // C++0x [temp.deduct.call]p6: 2797eff92135d32039c9874dc356f3e93143af6069c1John McCall // When P is a function type, pointer to function type, or pointer 2798eff92135d32039c9874dc356f3e93143af6069c1John McCall // to member function type: 2799eff92135d32039c9874dc356f3e93143af6069c1John McCall 2800eff92135d32039c9874dc356f3e93143af6069c1John McCall if (!ParamType->isFunctionType() && 2801eff92135d32039c9874dc356f3e93143af6069c1John McCall !ParamType->isFunctionPointerType() && 2802860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor !ParamType->isMemberFunctionPointerType()) { 2803860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (Ovl->hasExplicitTemplateArgs()) { 2804860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // But we can still look for an explicit specialization. 2805860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (FunctionDecl *ExplicitSpec 2806860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor = S.ResolveSingleFunctionTemplateSpecialization(Ovl)) 2807860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor return GetTypeOfFunction(S.Context, R, ExplicitSpec); 2808860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor } 2809eff92135d32039c9874dc356f3e93143af6069c1John McCall 2810860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor return QualType(); 2811860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor } 2812860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor 2813860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // Gather the explicit template arguments, if any. 2814860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor TemplateArgumentListInfo ExplicitTemplateArgs; 2815860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (Ovl->hasExplicitTemplateArgs()) 2816860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor Ovl->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs); 2817eff92135d32039c9874dc356f3e93143af6069c1John McCall QualType Match; 28187bb12da2b0749eeebb21854c77877736969e59f2John McCall for (UnresolvedSetIterator I = Ovl->decls_begin(), 28197bb12da2b0749eeebb21854c77877736969e59f2John McCall E = Ovl->decls_end(); I != E; ++I) { 2820eff92135d32039c9874dc356f3e93143af6069c1John McCall NamedDecl *D = (*I)->getUnderlyingDecl(); 2821eff92135d32039c9874dc356f3e93143af6069c1John McCall 2822860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) { 2823860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // - If the argument is an overload set containing one or more 2824860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // function templates, the parameter is treated as a 2825860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // non-deduced context. 2826860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (!Ovl->hasExplicitTemplateArgs()) 2827860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor return QualType(); 2828860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor 2829860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor // Otherwise, see if we can resolve a function type 2830860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor FunctionDecl *Specialization = 0; 283193e4599196654907dad3bd476013ad05d36ce604Craig Topper TemplateDeductionInfo Info(Ovl->getNameLoc()); 2832860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor if (S.DeduceTemplateArguments(FunTmpl, &ExplicitTemplateArgs, 2833860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor Specialization, Info)) 2834860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor continue; 2835860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor 2836860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor D = Specialization; 2837860d9b780b54f56cd27e16620196d213385d31f7Douglas Gregor } 2838eff92135d32039c9874dc356f3e93143af6069c1John McCall 2839eff92135d32039c9874dc356f3e93143af6069c1John McCall FunctionDecl *Fn = cast<FunctionDecl>(D); 28409c72c6088d591ace8503b842d39448c2040f3033John McCall QualType ArgType = GetTypeOfFunction(S.Context, R, Fn); 28419c72c6088d591ace8503b842d39448c2040f3033John McCall if (ArgType.isNull()) continue; 2842eff92135d32039c9874dc356f3e93143af6069c1John McCall 284375f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor // Function-to-pointer conversion. 2844dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (!ParamWasReference && ParamType->isPointerType() && 284575f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor ArgType->isFunctionType()) 284675f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor ArgType = S.Context.getPointerType(ArgType); 2847dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2848eff92135d32039c9874dc356f3e93143af6069c1John McCall // - If the argument is an overload set (not containing function 2849eff92135d32039c9874dc356f3e93143af6069c1John McCall // templates), trial argument deduction is attempted using each 2850eff92135d32039c9874dc356f3e93143af6069c1John McCall // of the members of the set. If deduction succeeds for only one 2851eff92135d32039c9874dc356f3e93143af6069c1John McCall // of the overload set members, that member is used as the 2852eff92135d32039c9874dc356f3e93143af6069c1John McCall // argument value for the deduction. If deduction succeeds for 2853eff92135d32039c9874dc356f3e93143af6069c1John McCall // more than one member of the overload set the parameter is 2854eff92135d32039c9874dc356f3e93143af6069c1John McCall // treated as a non-deduced context. 2855eff92135d32039c9874dc356f3e93143af6069c1John McCall 2856eff92135d32039c9874dc356f3e93143af6069c1John McCall // We do all of this in a fresh context per C++0x [temp.deduct.type]p2: 2857eff92135d32039c9874dc356f3e93143af6069c1John McCall // Type deduction is done independently for each P/A pair, and 2858eff92135d32039c9874dc356f3e93143af6069c1John McCall // the deduced template argument values are then combined. 2859eff92135d32039c9874dc356f3e93143af6069c1John McCall // So we do not reject deductions which were made elsewhere. 28605f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 8> 286102024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor Deduced(TemplateParams->size()); 286293e4599196654907dad3bd476013ad05d36ce604Craig Topper TemplateDeductionInfo Info(Ovl->getNameLoc()); 2863eff92135d32039c9874dc356f3e93143af6069c1John McCall Sema::TemplateDeductionResult Result 2864bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, 2865bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ArgType, Info, Deduced, TDF); 2866eff92135d32039c9874dc356f3e93143af6069c1John McCall if (Result) continue; 2867eff92135d32039c9874dc356f3e93143af6069c1John McCall if (!Match.isNull()) return QualType(); 2868eff92135d32039c9874dc356f3e93143af6069c1John McCall Match = ArgType; 2869eff92135d32039c9874dc356f3e93143af6069c1John McCall } 2870eff92135d32039c9874dc356f3e93143af6069c1John McCall 2871eff92135d32039c9874dc356f3e93143af6069c1John McCall return Match; 2872eff92135d32039c9874dc356f3e93143af6069c1John McCall} 2873eff92135d32039c9874dc356f3e93143af6069c1John McCall 2874dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \brief Perform the adjustments to the parameter and argument types 2875f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// described in C++ [temp.deduct.call]. 2876f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// 2877f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// \returns true if the caller should not attempt to perform any template 2878f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor/// argument deduction based on this P/A pair. 2879f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregorstatic bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S, 2880f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TemplateParameterList *TemplateParams, 2881f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType &ParamType, 2882f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType &ArgType, 2883f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg, 2884f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned &TDF) { 2885f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p3: 28860099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // If P is a cv-qualified type, the top level cv-qualifiers of P's type 2887f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // are ignored for type deduction. 2888a459cc26f6c895ae48742a36203f753cea8b3e91Douglas Gregor if (ParamType.hasQualifiers()) 2889a459cc26f6c895ae48742a36203f753cea8b3e91Douglas Gregor ParamType = ParamType.getUnqualifiedType(); 2890f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>(); 2891f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) { 289234b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType PointeeType = ParamRefType->getPointeeType(); 289334b41d939a1328f484511c6002ba2456db879a29Richard Smith 2894f15748a28c8443eef2924ef83689c358c661e9c5Douglas Gregor // If the argument has incomplete array type, try to complete it's type. 2895d10099e5c8238fa0327f03921cf2e3c8975c881eDouglas Gregor if (ArgType->isIncompleteArrayType() && !S.RequireCompleteExprType(Arg, 0)) 2896f15748a28c8443eef2924ef83689c358c661e9c5Douglas Gregor ArgType = Arg->getType(); 2897f15748a28c8443eef2924ef83689c358c661e9c5Douglas Gregor 28982ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor // [C++0x] If P is an rvalue reference to a cv-unqualified 28992ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor // template parameter and the argument is an lvalue, the type 29002ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor // "lvalue reference to A" is used in place of A for type 29012ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor // deduction. 290234b41d939a1328f484511c6002ba2456db879a29Richard Smith if (isa<RValueReferenceType>(ParamType)) { 290334b41d939a1328f484511c6002ba2456db879a29Richard Smith if (!PointeeType.getQualifiers() && 290434b41d939a1328f484511c6002ba2456db879a29Richard Smith isa<TemplateTypeParmType>(PointeeType) && 29059625e44c0252485277a340746ed8ac950686156fDouglas Gregor Arg->Classify(S.Context).isLValue() && 29069625e44c0252485277a340746ed8ac950686156fDouglas Gregor Arg->getType() != S.Context.OverloadTy && 29079625e44c0252485277a340746ed8ac950686156fDouglas Gregor Arg->getType() != S.Context.BoundMemberTy) 29082ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor ArgType = S.Context.getLValueReferenceType(ArgType); 29092ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor } 29102ad746aeb90e86cea7afaf552a02ae3f3b5ec859Douglas Gregor 2911f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // [...] If P is a reference type, the type referred to by P is used 2912f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // for type deduction. 291334b41d939a1328f484511c6002ba2456db879a29Richard Smith ParamType = PointeeType; 2914f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2915dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2916f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Overload sets usually make this parameter an undeduced 2917f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // context, but there are sometimes special circumstances. 2918f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType == S.Context.OverloadTy) { 2919f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = ResolveOverloadForDeduction(S, TemplateParams, 2920f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Arg, ParamType, 2921f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamRefType != 0); 2922f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType.isNull()) 2923f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return true; 2924f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2925dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2926f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) { 2927f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p3: 2928f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // [...] If P is of the form T&&, where T is a template parameter, and 2929f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the argument is an lvalue, the type A& is used in place of A for 2930f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type deduction. 2931f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType->isRValueReferenceType() && 2932f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamRefType->getAs<TemplateTypeParmType>() && 2933f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Arg->isLValue()) 2934f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getLValueReferenceType(ArgType); 2935f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } else { 2936f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++ [temp.deduct.call]p2: 2937f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // If P is not a reference type: 2938f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If A is an array type, the pointer type produced by the 2939f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // array-to-pointer standard conversion (4.2) is used in place of 2940f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // A for type deduction; otherwise, 2941f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType->isArrayType()) 2942f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getArrayDecayedType(ArgType); 2943f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If A is a function type, the pointer type produced by the 2944f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // function-to-pointer standard conversion (4.3) is used in place 2945f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // of A for type deduction; otherwise, 2946f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else if (ArgType->isFunctionType()) 2947f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType = S.Context.getPointerType(ArgType); 2948f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else { 29490099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // - If A is a cv-qualified type, the top level cv-qualifiers of A's 2950f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type are ignored for type deduction. 2951a459cc26f6c895ae48742a36203f753cea8b3e91Douglas Gregor ArgType = ArgType.getUnqualifiedType(); 2952f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2953f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 2954dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2955f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p4: 2956f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // In general, the deduction process attempts to find template argument 2957f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // values that will make the deduced A identical to A (after the type A 2958f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // is transformed as described above). [...] 2959f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF = TDF_SkipNonDependent; 2960dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2961f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If the original P is a reference type, the deduced A (i.e., the 2962f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type referred to by the reference) can be more cv-qualified than 2963f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the transformed A. 2964f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ParamRefType) 2965f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_ParamWithReferenceType; 2966f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - The transformed A can be another pointer or pointer to member 2967f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // type that can be converted to the deduced A via a qualification 2968f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // conversion (4.4). 2969f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgType->isPointerType() || ArgType->isMemberPointerType() || 2970f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ArgType->isObjCObjectPointerType()) 2971f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_IgnoreQualifiers; 2972f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // - If P is a class and P has the form simple-template-id, then the 2973f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // transformed A can be a derived class of the deduced A. Likewise, 2974f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // if P is a pointer to a class of the form simple-template-id, the 2975f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // transformed A can be a pointer to a derived class pointed to by 2976f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // the deduced A. 2977f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (isSimpleTemplateIdType(ParamType) || 2978f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor (isa<PointerType>(ParamType) && 2979f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor isSimpleTemplateIdType( 2980f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType->getAs<PointerType>()->getPointeeType()))) 2981f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF |= TDF_DerivedClass; 2982dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 2983f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return false; 2984f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor} 2985f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor 2986dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregorstatic bool hasDeducibleTemplateParameters(Sema &S, 2987dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor FunctionTemplateDecl *FunctionTemplate, 2988dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType T); 2989dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 29904b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl/// \brief Perform template argument deduction by matching a parameter type 29914b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl/// against a single expression, where the expression is an element of 29924b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl/// an initializer list that was originally matched against the argument 29934b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl/// type. 29944b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redlstatic Sema::TemplateDeductionResult 29954b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian RedlDeduceTemplateArgumentByListElement(Sema &S, 29964b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl TemplateParameterList *TemplateParams, 29974b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl QualType ParamType, Expr *Arg, 29984b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl TemplateDeductionInfo &Info, 29994b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl SmallVectorImpl<DeducedTemplateArgument> &Deduced, 30004b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl unsigned TDF) { 30014b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl // Handle the case where an init list contains another init list as the 30024b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl // element. 30034b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) { 30044b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl QualType X; 30054b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl if (!S.isStdInitializerList(ParamType.getNonReferenceType(), &X)) 30064b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl return Sema::TDK_Success; // Just ignore this expression. 30074b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl 30084b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl // Recurse down into the init list. 30094b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { 30104b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl if (Sema::TemplateDeductionResult Result = 30114b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl DeduceTemplateArgumentByListElement(S, TemplateParams, X, 30124b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl ILE->getInit(i), 30134b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl Info, Deduced, TDF)) 30144b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl return Result; 30154b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl } 30164b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl return Sema::TDK_Success; 30174b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl } 30184b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl 30194b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl // For all other cases, just match by type. 3020d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor QualType ArgType = Arg->getType(); 3021d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType, 3022d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor ArgType, Arg, TDF)) 3023d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor return Sema::TDK_FailedOverloadResolution; 30244b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, 3025d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor ArgType, Info, Deduced, TDF); 30264b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl} 30274b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl 3028e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \brief Perform template argument deduction from a function call 3029e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// (C++ [temp.deduct.call]). 3030e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 3031e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param FunctionTemplate the function template for which we are performing 3032e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// template argument deduction. 3033e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 303440ae6666dd7a458f2d213370922a38be13f003c4James Dennett/// \param ExplicitTemplateArgs the explicit template arguments provided 303548026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor/// for this call. 30366db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor/// 3037e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Args the function call arguments 3038e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 3039e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Specialization if template argument deduction was successful, 30401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// this will be set to the function template specialization produced by 3041e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// template argument deduction. 3042e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 3043e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \param Info the argument will be updated to provide additional information 3044e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// about template argument deduction. 3045e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// 3046e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor/// \returns the result of template argument deduction. 3047e53060fa78ad7e98352049f72787bdb7543e2a48Douglas GregorSema::TemplateDeductionResult 3048e53060fa78ad7e98352049f72787bdb7543e2a48Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 304967714230a191bc3c01f33378f34f34ef377991a6Douglas Gregor TemplateArgumentListInfo *ExplicitTemplateArgs, 305013a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles llvm::ArrayRef<Expr *> Args, 3051e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor FunctionDecl *&Specialization, 3052e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor TemplateDeductionInfo &Info) { 3053ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor if (FunctionTemplate->isInvalidDecl()) 3054ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor return TDK_Invalid; 3055ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor 3056e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 30576db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor 3058e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // C++ [temp.deduct.call]p1: 3059e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // Template argument deduction is done by comparing each function template 3060e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // parameter type (call it P) with the type of the corresponding argument 3061e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor // of the call (call it A) as described below. 306213a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles unsigned CheckArgs = Args.size(); 306313a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles if (Args.size() < Function->getMinRequiredArguments()) 3064e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor return TDK_TooFewArguments; 306513a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles else if (Args.size() > Function->getNumParams()) { 30661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionProtoType *Proto 3067183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = Function->getType()->getAs<FunctionProtoType>(); 3068f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (Proto->isTemplateVariadic()) 3069f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor /* Do nothing */; 3070f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor else if (Proto->isVariadic()) 3071f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor CheckArgs = Function->getNumParams(); 3072dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi else 3073e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor return TDK_TooManyArguments; 3074e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 30751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 30766db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // The types of the parameters from which we will perform template argument 30776db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // deduction. 30782a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 3079e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor TemplateParameterList *TemplateParams 3080e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor = FunctionTemplate->getTemplateParameters(); 30815f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 30825f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 4> ParamTypes; 308302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified = 0; 3084d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs) { 308583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionResult Result = 308683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor SubstituteExplicitTemplateArguments(FunctionTemplate, 3087d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall *ExplicitTemplateArgs, 308883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Deduced, 308983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor ParamTypes, 309083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 0, 309183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor Info); 309283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor if (Result) 309383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return Result; 309402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 309502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified = Deduced.size(); 30966db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor } else { 30976db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // Just fill in the parameter types from the function declaration. 3098f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) 30996db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor ParamTypes.push_back(Function->getParamDecl(I)->getType()); 31006db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor } 31011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 31026db8ed4498b83fe9336e3855a4ba1a298b04ee00Douglas Gregor // Deduce template arguments from the function parameters. 31031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced.resize(TemplateParams->size()); 3104f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned ArgIdx = 0; 31055f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<OriginalCallArg, 4> OriginalCallArgs; 3106dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi for (unsigned ParamIdx = 0, NumParams = ParamTypes.size(); 3107f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamIdx != NumParams; ++ParamIdx) { 3108dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType OrigParamType = ParamTypes[ParamIdx]; 3109dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType ParamType = OrigParamType; 3110dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 3111dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi const PackExpansionType *ParamExpansion 3112f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor = dyn_cast<PackExpansionType>(ParamType); 3113f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (!ParamExpansion) { 3114f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Simple case: matching a function parameter to a function argument. 3115f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (ArgIdx >= CheckArgs) 3116f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 3117dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3118f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg = Args[ArgIdx++]; 3119f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ArgType = Arg->getType(); 3120dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 3121f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned TDF = 0; 3122f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, 3123f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Arg, 3124f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) 3125f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor continue; 3126dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3127d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor // If we have nothing to deduce, we're done. 3128d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) 3129d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor continue; 3130d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor 313184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // If the argument is an initializer list ... 313284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) { 313384760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // ... then the parameter is an undeduced context, unless the parameter 313484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // type is (reference to cv) std::initializer_list<P'>, in which case 313584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // deduction is done for each element of the initializer list, and the 313684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // result is the deduced type if it's the same for all elements. 313784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl QualType X; 313884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // Removing references was already done. 313984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (!isStdInitializerList(ParamType, &X)) 314084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl continue; 314184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl 314284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { 314384760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (TemplateDeductionResult Result = 31444b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl DeduceTemplateArgumentByListElement(*this, TemplateParams, X, 31454b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl ILE->getInit(i), 31464b911e6536ed77524c3cef572cb0f6c8d9079e2eSebastian Redl Info, Deduced, TDF)) 314784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl return Result; 314884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 314984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // Don't track the argument type, since an initializer list has none. 315084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl continue; 315184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 315284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl 3153dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // Keep track of the argument type and corresponding parameter index, 3154dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor // so we can check for compatibility between the deduced A and A. 3155d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1, 3156d8f5b333f96b4e8018ff3a0d0db62d9e78eb6bddDouglas Gregor ArgType)); 3157dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 3158f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (TemplateDeductionResult Result 3159bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, 3160bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl ParamType, ArgType, 3161bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF)) 3162f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor return Result; 31631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3164f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor continue; 316575f21af57f3dce1577d6c27bbe7bb45b49ced732Douglas Gregor } 3166dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3167f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // C++0x [temp.deduct.call]p1: 3168dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // For a function parameter pack that occurs at the end of the 3169dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // parameter-declaration-list, the type A of each remaining argument of 3170dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the call is compared with the type P of the declarator-id of the 3171dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // function parameter pack. Each comparison deduces template arguments 3172dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // for subsequent positions in the template parameter packs expanded by 31737d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // the function parameter pack. For a function parameter pack that does 3174dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // not occur at the end of the parameter-declaration-list, the type of 31757d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor // the parameter pack is a non-deduced context. 31767d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor if (ParamIdx + 1 < NumParams) 31777d5c0c1273bdc1cb3dff1cb5a62d07b1439e82c7Douglas Gregor break; 3178dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3179f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ParamPattern = ParamExpansion->getPattern(); 31805f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<unsigned, 2> PackIndices; 3181f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor { 3182013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector SawIndices(TemplateParams->size()); 31835f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<UnexpandedParameterPack, 2> Unexpanded; 3184f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor collectUnexpandedParameterPacks(ParamPattern, Unexpanded); 3185f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 3186f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned Depth, Index; 3187f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); 3188f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (Depth == 0 && !SawIndices[Index]) { 3189f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor SawIndices[Index] = true; 3190f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor PackIndices.push_back(Index); 3191f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3192f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3193f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3194f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); 3195dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3196d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // Keep track of the deduced template arguments for each parameter pack 3197dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // expanded by this pack expansion (the outer index) and for each 3198d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor // template argument (the inner SmallVectors). 31995f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2> 3200d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor NewlyDeducedPacks(PackIndices.size()); 32015f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 2> 3202d3731198193eee92796ddeb493973b7a598b003eDouglas Gregor SavedPacks(PackIndices.size()); 32035429385919a2b6fb3708635b967221705f4b1dafDouglas Gregor PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks, 3204dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi NewlyDeducedPacks); 3205f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor bool HasAnyArguments = false; 320613a140caba448a66ffcc5ff0d32a87d6e4f4ad3fAhmed Charles for (; ArgIdx < Args.size(); ++ArgIdx) { 3207f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor HasAnyArguments = true; 3208dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3209dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType OrigParamType = ParamPattern; 3210dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor ParamType = OrigParamType; 3211f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor Expr *Arg = Args[ArgIdx]; 3212f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor QualType ArgType = Arg->getType(); 3213dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 3214f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor unsigned TDF = 0; 3215f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, 3216f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ParamType, ArgType, Arg, 3217f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor TDF)) { 3218f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // We can't actually perform any deduction for this argument, so stop 3219f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // deduction at this point. 3220f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor ++ArgIdx; 3221f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 3222f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3223dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 322484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // As above, initializer lists need special handling. 322584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) { 322684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl QualType X; 322784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (!isStdInitializerList(ParamType, &X)) { 322884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl ++ArgIdx; 322984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl break; 323084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 3231dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 323284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) { 323384760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (TemplateDeductionResult Result = 323484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, X, 323584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl ILE->getInit(i)->getType(), 323684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl Info, Deduced, TDF)) 323784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl return Result; 323884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 323984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } else { 324084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl 324184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // Keep track of the argument type and corresponding argument index, 324284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl // so we can check for compatibility between the deduced A and A. 324384760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType)) 324484760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx, 324584760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl ArgType)); 324684760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl 324784760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl if (TemplateDeductionResult Result 324884760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, 324984760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl ParamType, ArgType, Info, 325084760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl Deduced, TDF)) 325184760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl return Result; 325284760e3a5d885ab19b5d11aafe78dfdfe2911e3aSebastian Redl } 3253eff92135d32039c9874dc356f3e93143af6069c1John McCall 3254f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Capture the deduced template arguments for each parameter pack expanded 3255f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // by this pack expansion, add them to the list of arguments we've deduced 3256f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // for that pack, then clear out the deduced argument. 3257f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { 3258f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; 3259f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor if (!DeducedArg.isNull()) { 3260f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor NewlyDeducedPacks[I].push_back(DeducedArg); 3261f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor DeducedArg = DeducedTemplateArgument(); 3262f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor } 3263e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 3264e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 3265dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3266f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // Build argument packs for each of the parameter packs expanded by this 3267f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // pack expansion. 32680216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor if (Sema::TemplateDeductionResult Result 3269dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = FinishArgumentPackDeduction(*this, TemplateParams, HasAnyArguments, 32700216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor Deduced, PackIndices, SavedPacks, 32710216f8121df32b320cab659d5b703fee50cdfda5Douglas Gregor NewlyDeducedPacks, Info)) 3272dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi return Result; 32731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3274f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor // After we've matching against a parameter pack, we're done. 3275f5c65ffbd7374b6c8d9f1e361041578640cab320Douglas Gregor break; 3276e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor } 327765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 32781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 327902024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified, 3280dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor Specialization, Info, &OriginalCallArgs); 328183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor} 3282127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor 328383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \brief Deduce template arguments when taking the address of a function 32844b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template (C++ [temp.deduct.funcaddr]) or matching a specialization to 32854b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// a template. 328683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 328783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param FunctionTemplate the function template for which we are performing 328883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template argument deduction. 328983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 329040ae6666dd7a458f2d213370922a38be13f003c4James Dennett/// \param ExplicitTemplateArgs the explicitly-specified template 32914b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// arguments. 329283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 329383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param ArgFunctionType the function type that will be used as the 329483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// "argument" type (A) when performing template argument deduction from the 32954b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// function template's function type. This type may be NULL, if there is no 32964b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// argument type to compare against, in C++0x [temp.arg.explicit]p3. 329783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 329883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Specialization if template argument deduction was successful, 32991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// this will be set to the function template specialization produced by 330083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// template argument deduction. 330183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 330283314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \param Info the argument will be updated to provide additional information 330383314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// about template argument deduction. 330483314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// 330583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor/// \returns the result of template argument deduction. 330683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::TemplateDeductionResult 330783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 330867714230a191bc3c01f33378f34f34ef377991a6Douglas Gregor TemplateArgumentListInfo *ExplicitTemplateArgs, 330983314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType ArgFunctionType, 331083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *&Specialization, 331183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateDeductionInfo &Info) { 3312ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor if (FunctionTemplate->isInvalidDecl()) 3313ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor return TDK_Invalid; 3314ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor 331583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 331683314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor TemplateParameterList *TemplateParams 331783314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor = FunctionTemplate->getTemplateParameters(); 331883314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor QualType FunctionType = Function->getType(); 33191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 332083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor // Substitute any explicit template arguments. 33212a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 33225f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 332302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor unsigned NumExplicitlySpecified = 0; 33245f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 4> ParamTypes; 3325d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall if (ExplicitTemplateArgs) { 33261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (TemplateDeductionResult Result 33271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump = SubstituteExplicitTemplateArguments(FunctionTemplate, 3328d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall *ExplicitTemplateArgs, 33291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced, ParamTypes, 333083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor &FunctionType, Info)) 333183314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor return Result; 333202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor 333302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor NumExplicitlySpecified = Deduced.size(); 3334127102b5196ffe04bdb70fd553fe62c265ab10a9Douglas Gregor } 333583314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 333659a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 333759a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 33381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 33391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3340eff92135d32039c9874dc356f3e93143af6069c1John McCall Deduced.resize(TemplateParams->size()); 3341eff92135d32039c9874dc356f3e93143af6069c1John McCall 33424b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (!ArgFunctionType.isNull()) { 33434b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor // Deduce template arguments from the function type. 33444b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (TemplateDeductionResult Result 3345bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, 33464b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor FunctionType, ArgFunctionType, Info, 334773b3cf6503f72f054288cf474e1a8c8ae56383c2Douglas Gregor Deduced, TDF_TopLevelParameterTypeList)) 33484b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return Result; 33494b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor } 3350fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 3351dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (TemplateDeductionResult Result 3352fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 3353fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor NumExplicitlySpecified, 3354fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor Specialization, Info)) 3355fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return Result; 3356fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 3357fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor // If the requested function type does not match the actual type of the 3358fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor // specialization, template argument deduction fails. 3359fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor if (!ArgFunctionType.isNull() && 3360fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor !Context.hasSameType(ArgFunctionType, Specialization->getType())) 3361fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return TDK_NonDeducedMismatch; 3362fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor 3363fbb6fad63acac2bef36cfa13e0706fa3e2a1ed7dDouglas Gregor return TDK_Success; 3364e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor} 3365e53060fa78ad7e98352049f72787bdb7543e2a48Douglas Gregor 336665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \brief Deduce template arguments for a templated conversion 336765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// function (C++ [temp.deduct.conv]) and, if successful, produce a 336865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// conversion function template specialization. 336965ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::TemplateDeductionResult 337065ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 337165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType ToType, 337265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor CXXConversionDecl *&Specialization, 337365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateDeductionInfo &Info) { 3374ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor if (FunctionTemplate->isInvalidDecl()) 3375ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor return TDK_Invalid; 3376ae19fbba559d8199d1f2b7154863180b0ae22ac7Douglas Gregor 33771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CXXConversionDecl *Conv 337865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor = cast<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()); 337965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType FromType = Conv->getConversionType(); 338065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 338165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Canonicalize the types for deduction. 338265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType P = Context.getCanonicalType(FromType); 338365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor QualType A = Context.getCanonicalType(ToType); 338465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 33855453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // C++0x [temp.deduct.conv]p2: 338665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // If P is a reference type, the type referred to by P is used for 338765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type deduction. 338865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (const ReferenceType *PRef = P->getAs<ReferenceType>()) 338965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = PRef->getPointeeType(); 339065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 33915453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // C++0x [temp.deduct.conv]p4: 33925453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // [...] If A is a reference type, the type referred to by A is used 339365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // for type deduction. 339465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (const ReferenceType *ARef = A->getAs<ReferenceType>()) 33955453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor A = ARef->getPointeeType().getUnqualifiedType(); 33965453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // C++ [temp.deduct.conv]p3: 339765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // 33981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If A is not a reference type: 339965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else { 340065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor assert(!A->isReferenceType() && "Reference types were handled above"); 340165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 340265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is an array type, the pointer type produced by the 34031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // array-to-pointer standard conversion (4.2) is used in place 340465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // of P for type deduction; otherwise, 340565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (P->isArrayType()) 340665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = Context.getArrayDecayedType(P); 340765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is a function type, the pointer type produced by the 340865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // function-to-pointer standard conversion (4.3) is used in 340965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // place of P for type deduction; otherwise, 341065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else if (P->isFunctionType()) 341165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = Context.getPointerType(P); 341265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If P is a cv-qualified type, the top level cv-qualifiers of 34130099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // P's type are ignored for type deduction. 341465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor else 341565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor P = P.getUnqualifiedType(); 341665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 34175453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // C++0x [temp.deduct.conv]p4: 34180099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // If A is a cv-qualified type, the top level cv-qualifiers of A's 34195453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // type are ignored for type deduction. If A is a reference type, the type 34205453d93ab8668f2d9d0bc02182695b02d207e32dDouglas Gregor // referred to by A is used for type deduction. 342165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor A = A.getUnqualifiedType(); 342265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor } 342365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 342459a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman // Unevaluated SFINAE context. 342559a839c5a4eecfeb495fc64224f6a949d1c5b2daEli Friedman EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 34261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SFINAETrap Trap(*this); 342765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 342865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++ [temp.deduct.conv]p1: 342965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Template argument deduction is done by comparing the return 343065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type of the template conversion function (call it P) with the 343165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // type that is required as the result of the conversion (call it 343265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // A) as described in 14.8.2.4. 343365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateParameterList *TemplateParams 343465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor = FunctionTemplate->getTemplateParameters(); 34355f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 34361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Deduced.resize(TemplateParams->size()); 343765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 343865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // C++0x [temp.deduct.conv]p4: 343965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // In general, the deduction process attempts to find template 344065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // argument values that will make the deduced A identical to 344165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // A. However, there are two cases that allow a difference: 344265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor unsigned TDF = 0; 344365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - If the original A is a reference type, A can be more 344465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // cv-qualified than the deduced A (i.e., the type referred to 344565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // by the reference) 344665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (ToType->isReferenceType()) 344765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TDF |= TDF_ParamWithReferenceType; 344865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // - The deduced A can be another pointer or pointer to member 34490099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // type that can be converted to A via a qualification 345065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // conversion. 345165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // 345265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when 345365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // both P and A are pointers or member pointers. In this case, we 345465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // just ignore cv-qualifiers completely). 345565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if ((P->isPointerType() && A->isPointerType()) || 34562cae1e216c12c7574f5ac59cb0844d22bed9401dDouglas Gregor (P->isMemberPointerType() && A->isMemberPointerType())) 345765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TDF |= TDF_IgnoreQualifiers; 345865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (TemplateDeductionResult Result 3459bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, 3460bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl P, A, Info, Deduced, TDF)) 346165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return Result; 346265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 346365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor // Finish template argument deduction. 34642a7fb27913999d132cf9e10e03dc5271faa2e9d3John McCall LocalInstantiationScope InstScope(*this); 346565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor FunctionDecl *Spec = 0; 346665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor TemplateDeductionResult Result 3467dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 0, Spec, 346802024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor Info); 346965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor Specialization = cast_or_null<CXXConversionDecl>(Spec); 347065ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return Result; 347165ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor} 347265ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor 34734b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \brief Deduce template arguments for a function template when there is 34744b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// nothing to deduce against (C++0x [temp.arg.explicit]p3). 34754b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 34764b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param FunctionTemplate the function template for which we are performing 34774b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template argument deduction. 34784b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 347940ae6666dd7a458f2d213370922a38be13f003c4James Dennett/// \param ExplicitTemplateArgs the explicitly-specified template 34804b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// arguments. 34814b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 34824b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param Specialization if template argument deduction was successful, 34834b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// this will be set to the function template specialization produced by 34844b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// template argument deduction. 34854b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 34864b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \param Info the argument will be updated to provide additional information 34874b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// about template argument deduction. 34884b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// 34894b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor/// \returns the result of template argument deduction. 34904b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas GregorSema::TemplateDeductionResult 34914b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas GregorSema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 349267714230a191bc3c01f33378f34f34ef377991a6Douglas Gregor TemplateArgumentListInfo *ExplicitTemplateArgs, 34934b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor FunctionDecl *&Specialization, 34944b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor TemplateDeductionInfo &Info) { 34954b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, 34964b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor QualType(), Specialization, Info); 34974b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor} 34984b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor 349934b41d939a1328f484511c6002ba2456db879a29Richard Smithnamespace { 350034b41d939a1328f484511c6002ba2456db879a29Richard Smith /// Substitute the 'auto' type specifier within a type for a given replacement 350134b41d939a1328f484511c6002ba2456db879a29Richard Smith /// type. 350234b41d939a1328f484511c6002ba2456db879a29Richard Smith class SubstituteAutoTransform : 350334b41d939a1328f484511c6002ba2456db879a29Richard Smith public TreeTransform<SubstituteAutoTransform> { 350434b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType Replacement; 350534b41d939a1328f484511c6002ba2456db879a29Richard Smith public: 350634b41d939a1328f484511c6002ba2456db879a29Richard Smith SubstituteAutoTransform(Sema &SemaRef, QualType Replacement) : 350734b41d939a1328f484511c6002ba2456db879a29Richard Smith TreeTransform<SubstituteAutoTransform>(SemaRef), Replacement(Replacement) { 350834b41d939a1328f484511c6002ba2456db879a29Richard Smith } 350934b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) { 351034b41d939a1328f484511c6002ba2456db879a29Richard Smith // If we're building the type pattern to deduce against, don't wrap the 351134b41d939a1328f484511c6002ba2456db879a29Richard Smith // substituted type in an AutoType. Certain template deduction rules 351234b41d939a1328f484511c6002ba2456db879a29Richard Smith // apply only when a template type parameter appears directly (and not if 351334b41d939a1328f484511c6002ba2456db879a29Richard Smith // the parameter is found through desugaring). For instance: 351434b41d939a1328f484511c6002ba2456db879a29Richard Smith // auto &&lref = lvalue; 351534b41d939a1328f484511c6002ba2456db879a29Richard Smith // must transform into "rvalue reference to T" not "rvalue reference to 351634b41d939a1328f484511c6002ba2456db879a29Richard Smith // auto type deduced as T" in order for [temp.deduct.call]p3 to apply. 351734b41d939a1328f484511c6002ba2456db879a29Richard Smith if (isa<TemplateTypeParmType>(Replacement)) { 351834b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType Result = Replacement; 351934b41d939a1328f484511c6002ba2456db879a29Richard Smith TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result); 352034b41d939a1328f484511c6002ba2456db879a29Richard Smith NewTL.setNameLoc(TL.getNameLoc()); 352134b41d939a1328f484511c6002ba2456db879a29Richard Smith return Result; 352234b41d939a1328f484511c6002ba2456db879a29Richard Smith } else { 352334b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType Result = RebuildAutoType(Replacement); 352434b41d939a1328f484511c6002ba2456db879a29Richard Smith AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result); 352534b41d939a1328f484511c6002ba2456db879a29Richard Smith NewTL.setNameLoc(TL.getNameLoc()); 352634b41d939a1328f484511c6002ba2456db879a29Richard Smith return Result; 352734b41d939a1328f484511c6002ba2456db879a29Richard Smith } 352834b41d939a1328f484511c6002ba2456db879a29Richard Smith } 3529dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor 3530dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor ExprResult TransformLambdaExpr(LambdaExpr *E) { 3531dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor // Lambdas never need to be transformed. 3532dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor return E; 3533dfca6f53ab97d28d43e3fa2564209df08f3d282cDouglas Gregor } 353434b41d939a1328f484511c6002ba2456db879a29Richard Smith }; 35358ad6c8696a23f410398fc126929b107404c59a95Richard Smith 35368ad6c8696a23f410398fc126929b107404c59a95Richard Smith /// Determine whether the specified type (which contains an 'auto' type 35378ad6c8696a23f410398fc126929b107404c59a95Richard Smith /// specifier) is dependent. This is not trivial, because the 'auto' specifier 35388ad6c8696a23f410398fc126929b107404c59a95Richard Smith /// itself claims to be type-dependent. 35398ad6c8696a23f410398fc126929b107404c59a95Richard Smith bool isDependentAutoType(QualType Ty) { 35408ad6c8696a23f410398fc126929b107404c59a95Richard Smith while (1) { 35418ad6c8696a23f410398fc126929b107404c59a95Richard Smith QualType Pointee = Ty->getPointeeType(); 35428ad6c8696a23f410398fc126929b107404c59a95Richard Smith if (!Pointee.isNull()) { 35438ad6c8696a23f410398fc126929b107404c59a95Richard Smith Ty = Pointee; 35448ad6c8696a23f410398fc126929b107404c59a95Richard Smith } else if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()){ 35458ad6c8696a23f410398fc126929b107404c59a95Richard Smith if (MPT->getClass()->isDependentType()) 35468ad6c8696a23f410398fc126929b107404c59a95Richard Smith return true; 35478ad6c8696a23f410398fc126929b107404c59a95Richard Smith Ty = MPT->getPointeeType(); 35488ad6c8696a23f410398fc126929b107404c59a95Richard Smith } else if (const FunctionProtoType *FPT = Ty->getAs<FunctionProtoType>()){ 35498ad6c8696a23f410398fc126929b107404c59a95Richard Smith for (FunctionProtoType::arg_type_iterator I = FPT->arg_type_begin(), 35508ad6c8696a23f410398fc126929b107404c59a95Richard Smith E = FPT->arg_type_end(); 35518ad6c8696a23f410398fc126929b107404c59a95Richard Smith I != E; ++I) 35528ad6c8696a23f410398fc126929b107404c59a95Richard Smith if ((*I)->isDependentType()) 35538ad6c8696a23f410398fc126929b107404c59a95Richard Smith return true; 35548ad6c8696a23f410398fc126929b107404c59a95Richard Smith Ty = FPT->getResultType(); 35558ad6c8696a23f410398fc126929b107404c59a95Richard Smith } else if (Ty->isDependentSizedArrayType()) { 35568ad6c8696a23f410398fc126929b107404c59a95Richard Smith return true; 35578ad6c8696a23f410398fc126929b107404c59a95Richard Smith } else if (const ArrayType *AT = Ty->getAsArrayTypeUnsafe()) { 35588ad6c8696a23f410398fc126929b107404c59a95Richard Smith Ty = AT->getElementType(); 35598ad6c8696a23f410398fc126929b107404c59a95Richard Smith } else if (Ty->getAs<DependentSizedExtVectorType>()) { 35608ad6c8696a23f410398fc126929b107404c59a95Richard Smith return true; 35618ad6c8696a23f410398fc126929b107404c59a95Richard Smith } else if (const VectorType *VT = Ty->getAs<VectorType>()) { 35628ad6c8696a23f410398fc126929b107404c59a95Richard Smith Ty = VT->getElementType(); 35638ad6c8696a23f410398fc126929b107404c59a95Richard Smith } else { 35648ad6c8696a23f410398fc126929b107404c59a95Richard Smith break; 35658ad6c8696a23f410398fc126929b107404c59a95Richard Smith } 35668ad6c8696a23f410398fc126929b107404c59a95Richard Smith } 35678ad6c8696a23f410398fc126929b107404c59a95Richard Smith assert(Ty->getAs<AutoType>() && "didn't find 'auto' in auto type"); 35688ad6c8696a23f410398fc126929b107404c59a95Richard Smith return false; 35698ad6c8696a23f410398fc126929b107404c59a95Richard Smith } 357034b41d939a1328f484511c6002ba2456db879a29Richard Smith} 357134b41d939a1328f484511c6002ba2456db879a29Richard Smith 357234b41d939a1328f484511c6002ba2456db879a29Richard Smith/// \brief Deduce the type for an auto type-specifier (C++0x [dcl.spec.auto]p6) 357334b41d939a1328f484511c6002ba2456db879a29Richard Smith/// 357434b41d939a1328f484511c6002ba2456db879a29Richard Smith/// \param Type the type pattern using the auto type-specifier. 357534b41d939a1328f484511c6002ba2456db879a29Richard Smith/// 357634b41d939a1328f484511c6002ba2456db879a29Richard Smith/// \param Init the initializer for the variable whose type is to be deduced. 357734b41d939a1328f484511c6002ba2456db879a29Richard Smith/// 357834b41d939a1328f484511c6002ba2456db879a29Richard Smith/// \param Result if type deduction was successful, this will be set to the 357934b41d939a1328f484511c6002ba2456db879a29Richard Smith/// deduced type. This may still contain undeduced autos if the type is 3580a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith/// dependent. This will be set to null if deduction succeeded, but auto 3581a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith/// substitution failed; the appropriate diagnostic will already have been 3582a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith/// produced in that case. 3583b832f6dea893f25b40500a04781286236281cb20Sebastian RedlSema::DeduceAutoResult 358432509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCallSema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, 3585a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith TypeSourceInfo *&Result) { 358632509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCall if (Init->getType()->isNonOverloadPlaceholderType()) { 358732509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCall ExprResult result = CheckPlaceholderExpr(Init); 3588b832f6dea893f25b40500a04781286236281cb20Sebastian Redl if (result.isInvalid()) return DAR_FailedAlreadyDiagnosed; 358932509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCall Init = result.take(); 359032509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCall } 359132509f1e60451d86e9fbc473b6e853ba10b5fd1eJohn McCall 35928ad6c8696a23f410398fc126929b107404c59a95Richard Smith if (Init->isTypeDependent() || isDependentAutoType(Type->getType())) { 359334b41d939a1328f484511c6002ba2456db879a29Richard Smith Result = Type; 3594b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Succeeded; 359534b41d939a1328f484511c6002ba2456db879a29Richard Smith } 359634b41d939a1328f484511c6002ba2456db879a29Richard Smith 359734b41d939a1328f484511c6002ba2456db879a29Richard Smith SourceLocation Loc = Init->getExprLoc(); 359834b41d939a1328f484511c6002ba2456db879a29Richard Smith 359934b41d939a1328f484511c6002ba2456db879a29Richard Smith LocalInstantiationScope InstScope(*this); 360034b41d939a1328f484511c6002ba2456db879a29Richard Smith 360134b41d939a1328f484511c6002ba2456db879a29Richard Smith // Build template<class TemplParam> void Func(FuncParam); 36024fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmDecl *TemplParam = 36034fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmDecl::Create(Context, 0, SourceLocation(), Loc, 0, 0, 0, 36044fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth false, false); 36054fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0); 36064fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth NamedDecl *TemplParamPtr = TemplParam; 3607483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith FixedSizeTemplateParameterList<1> TemplateParams(Loc, Loc, &TemplParamPtr, 3608483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith Loc); 3609483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith 3610a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith TypeSourceInfo *FuncParamInfo = 361134b41d939a1328f484511c6002ba2456db879a29Richard Smith SubstituteAutoTransform(*this, TemplArg).TransformType(Type); 3612a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith assert(FuncParamInfo && "substituting template parameter for 'auto' failed"); 3613a085da86242c9b8e3466f8cf6f4397e9f248fd20Richard Smith QualType FuncParam = FuncParamInfo->getType(); 361434b41d939a1328f484511c6002ba2456db879a29Richard Smith 361534b41d939a1328f484511c6002ba2456db879a29Richard Smith // Deduce type of TemplParam in Func(Init) 36165f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 1> Deduced; 361734b41d939a1328f484511c6002ba2456db879a29Richard Smith Deduced.resize(1); 361834b41d939a1328f484511c6002ba2456db879a29Richard Smith QualType InitType = Init->getType(); 361934b41d939a1328f484511c6002ba2456db879a29Richard Smith unsigned TDF = 0; 362034b41d939a1328f484511c6002ba2456db879a29Richard Smith 362193e4599196654907dad3bd476013ad05d36ce604Craig Topper TemplateDeductionInfo Info(Loc); 362262b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 36238ad6c8696a23f410398fc126929b107404c59a95Richard Smith InitListExpr *InitList = dyn_cast<InitListExpr>(Init); 362462b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (InitList) { 362562b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl for (unsigned i = 0, e = InitList->getNumInits(); i < e; ++i) { 36268ad6c8696a23f410398fc126929b107404c59a95Richard Smith if (DeduceTemplateArgumentByListElement(*this, &TemplateParams, 3627d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor TemplArg, 3628d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor InitList->getInit(i), 3629d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor Info, Deduced, TDF)) 3630b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Failed; 363162b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl } 363262b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl } else { 3633d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor if (AdjustFunctionParmAndArgTypesForDeduction(*this, &TemplateParams, 3634d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor FuncParam, InitType, Init, 3635d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor TDF)) 3636d280389b42bb55cd8969eae181dc3ff9f05e9aafDouglas Gregor return DAR_Failed; 36378ad6c8696a23f410398fc126929b107404c59a95Richard Smith 363862b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (DeduceTemplateArgumentsByTypeMatch(*this, &TemplateParams, FuncParam, 363962b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl InitType, Info, Deduced, TDF)) 3640b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Failed; 364162b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl } 364234b41d939a1328f484511c6002ba2456db879a29Richard Smith 364370a01898008a90007866f15c4d9d53ba00b0d203Eli Friedman if (Deduced[0].getKind() != TemplateArgument::Type) 3644b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Failed; 364562b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 364670a01898008a90007866f15c4d9d53ba00b0d203Eli Friedman QualType DeducedType = Deduced[0].getAsType(); 364770a01898008a90007866f15c4d9d53ba00b0d203Eli Friedman 364862b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (InitList) { 364962b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl DeducedType = BuildStdInitializerList(DeducedType, Loc); 365062b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (DeducedType.isNull()) 3651b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_FailedAlreadyDiagnosed; 365262b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl } 365362b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 365434b41d939a1328f484511c6002ba2456db879a29Richard Smith Result = SubstituteAutoTransform(*this, DeducedType).TransformType(Type); 365562b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 36569a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor // Check that the deduced argument type is compatible with the original 36579a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor // argument type per C++ [temp.deduct.call]p4. 365862b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (!InitList && Result && 36599a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor CheckOriginalCallArgDeduction(*this, 36609a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor Sema::OriginalCallArg(FuncParam,0,InitType), 36619a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor Result->getType())) { 36629a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor Result = 0; 3663b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Failed; 36649a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor } 36659a636e8403287af0d4db8fe5bf49dee719f5b754Douglas Gregor 3666b832f6dea893f25b40500a04781286236281cb20Sebastian Redl return DAR_Succeeded; 366734b41d939a1328f484511c6002ba2456db879a29Richard Smith} 366834b41d939a1328f484511c6002ba2456db879a29Richard Smith 366962b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redlvoid Sema::DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init) { 367062b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl if (isa<InitListExpr>(Init)) 367162b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl Diag(VDecl->getLocation(), 367262b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl diag::err_auto_var_deduction_failure_from_init_list) 367362b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl << VDecl->getDeclName() << VDecl->getType() << Init->getSourceRange(); 367462b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl else 367562b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl Diag(VDecl->getLocation(), diag::err_auto_var_deduction_failure) 367662b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl << VDecl->getDeclName() << VDecl->getType() << Init->getType() 367762b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl << Init->getSourceRange(); 367862b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl} 367962b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl 36808a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregorstatic void 36816fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, QualType T, 3682e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 3683ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Level, 3684013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Deduced); 3685dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3686dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \brief If this is a non-static member function, 3687407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedmanstatic void AddImplicitObjectParameterType(ASTContext &Context, 368877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor CXXMethodDecl *Method, 36895f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<QualType> &ArgTypes) { 3690407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman // C++11 [temp.func.order]p3: 3691407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman // [...] The new parameter is of type "reference to cv A," where cv are 3692407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman // the cv-qualifiers of the function template (if any) and A is 3693407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman // the class of which the function template is a member. 369477bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor // 3695407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman // The standard doesn't say explicitly, but we pick the appropriate kind of 3696407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman // reference type based on [over.match.funcs]p4. 369777bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor QualType ArgTy = Context.getTypeDeclType(Method->getParent()); 369877bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor ArgTy = Context.getQualifiedType(ArgTy, 369977bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor Qualifiers::fromCVRMask(Method->getTypeQualifiers())); 3700407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman if (Method->getRefQualifier() == RQ_RValue) 3701407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman ArgTy = Context.getRValueReferenceType(ArgTy); 3702407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman else 3703407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman ArgTy = Context.getLValueReferenceType(ArgTy); 370477bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor ArgTypes.push_back(ArgTy); 370577bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor} 370677bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 37078a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \brief Determine whether the function template \p FT1 is at least as 37088a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// specialized as \p FT2. 37098a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregorstatic bool isAtLeastAsSpecializedAs(Sema &S, 37105769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc, 37118a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionTemplateDecl *FT1, 37128a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionTemplateDecl *FT2, 37138a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplatePartialOrderingContext TPOC, 3714dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi unsigned NumCallArguments, 37155f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<RefParamPartialOrderingComparison> *RefParamComparisons) { 37168a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor FunctionDecl *FD1 = FT1->getTemplatedDecl(); 3717dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi FunctionDecl *FD2 = FT2->getTemplatedDecl(); 37188a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>(); 37198a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>(); 3720dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 37218a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor assert(Proto1 && Proto2 && "Function templates must have prototypes"); 37228a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor TemplateParameterList *TemplateParams = FT2->getTemplateParameters(); 37235f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 37248a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Deduced.resize(TemplateParams->size()); 37258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 37268a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p3: 37278a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // The types used to determine the ordering depend on the context in which 37288a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // the partial ordering is done: 372993e4599196654907dad3bd476013ad05d36ce604Craig Topper TemplateDeductionInfo Info(Loc); 37308d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor CXXMethodDecl *Method1 = 0; 37318d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor CXXMethodDecl *Method2 = 0; 37328d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor bool IsNonStatic2 = false; 37338d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor bool IsNonStatic1 = false; 37348d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor unsigned Skip2 = 0; 37358a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor switch (TPOC) { 37368a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Call: { 37378a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - In the context of a function call, the function parameter types are 37388a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // used. 37398d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Method1 = dyn_cast<CXXMethodDecl>(FD1); 37408d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Method2 = dyn_cast<CXXMethodDecl>(FD2); 37418d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic1 = Method1 && !Method1->isStatic(); 37428d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor IsNonStatic2 = Method2 && !Method2->isStatic(); 37438d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor 37449cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // C++11 [temp.func.order]p3: 37458d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // [...] If only one of the function templates is a non-static 37468d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // member, that function template is considered to have a new 37478d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // first parameter inserted in its function parameter list. The 37488d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // new parameter is of type "reference to cv A," where cv are 37498d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // the cv-qualifiers of the function template (if any) and A is 37508d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // the class of which the function template is a member. 37518d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // 37529cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // Note that we interpret this to mean "if one of the function 37539cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // templates is a non-static member and the other is a non-member"; 37549cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // otherwise, the ordering rules for static functions against non-static 37559cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // functions don't make any sense. 37569cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // 37578d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor // C++98/03 doesn't have this provision, so instead we drop the 37589cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // first argument of the free function, which seems to match 37599cef0064da0fe93cf60cc351d28ddf2e95fba0b3Eli Friedman // existing practice. 37605f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 4> Args1; 376180ad52f327b532bded5c5b0ee38779d841c6cd35Richard Smith unsigned Skip1 = !S.getLangOpts().CPlusPlus11 && IsNonStatic2 && !Method1; 376280ad52f327b532bded5c5b0ee38779d841c6cd35Richard Smith if (S.getLangOpts().CPlusPlus11 && IsNonStatic1 && !Method2) 3763407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman AddImplicitObjectParameterType(S.Context, Method1, Args1); 3764dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Args1.insert(Args1.end(), 37658d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Proto1->arg_type_begin() + Skip1, Proto1->arg_type_end()); 376677bc572138543ef97ebec137522b763d6a6ee909Douglas Gregor 37675f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 4> Args2; 376880ad52f327b532bded5c5b0ee38779d841c6cd35Richard Smith Skip2 = !S.getLangOpts().CPlusPlus11 && IsNonStatic1 && !Method2; 376980ad52f327b532bded5c5b0ee38779d841c6cd35Richard Smith if (S.getLangOpts().CPlusPlus11 && IsNonStatic2 && !Method1) 3770407c8470d50be8edaae7ed39a3139adf35af2921Eli Friedman AddImplicitObjectParameterType(S.Context, Method2, Args2); 3771dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Args2.insert(Args2.end(), 37728d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor Proto2->arg_type_begin() + Skip2, Proto2->arg_type_end()); 3773dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 37745c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // C++ [temp.func.order]p5: 37755c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // The presence of unused ellipsis and default arguments has no effect on 37765c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor // the partial ordering of function templates. 37775c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (Args1.size() > NumCallArguments) 37785c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Args1.resize(NumCallArguments); 37795c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (Args2.size() > NumCallArguments) 37805c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Args2.resize(NumCallArguments); 37815c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(), 37825c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Args1.data(), Args1.size(), Info, Deduced, 37835c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor TDF_None, /*PartialOrdering=*/true, 3784b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons)) 37858a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 3786dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 37878a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 37888a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 3789dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 37908a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Conversion: 37918a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // - In the context of a call to a conversion operator, the return types 37928a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // of the conversion function templates are used. 3793bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 3794bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Proto2->getResultType(), 3795bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Proto1->getResultType(), 3796bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF_None, 3797bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl /*PartialOrdering=*/true, 3798bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons)) 37998a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 38008a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 3801dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38028a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Other: 38030099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi // - In other contexts (14.6.6.2) the function template's function type 38048a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // is used. 3805bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, 3806bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl FD2->getType(), FD1->getType(), 3807bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl Info, Deduced, TDF_None, 3808bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl /*PartialOrdering=*/true, 3809bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl RefParamComparisons)) 38108a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 38118a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 38128a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 3813dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38148a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p11: 3815dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // In most cases, all template parameters must have values in order for 3816dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // deduction to succeed, but for partial ordering purposes a template 3817dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // parameter may remain without a value provided it is not used in the 38188a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // types being used for partial ordering. [ Note: a template parameter used 38198a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // in a non-deduced context is considered used. -end note] 38208a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor unsigned ArgIdx = 0, NumArgs = Deduced.size(); 38218a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor for (; ArgIdx != NumArgs; ++ArgIdx) 38228a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Deduced[ArgIdx].isNull()) 38238a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 38248a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 38258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (ArgIdx == NumArgs) { 3826dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // All template arguments were deduced. FT1 is at least as specialized 38278a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // as FT2. 38288a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return true; 38298a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 38308a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 3831e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // Figure out which template parameters were used. 3832013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector UsedParameters(TemplateParams->size()); 38338a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor switch (TPOC) { 38348a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Call: { 3835dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi unsigned NumParams = std::min(NumCallArguments, 3836dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi std::min(Proto1->getNumArgs(), 38375c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Proto2->getNumArgs())); 383880ad52f327b532bded5c5b0ee38779d841c6cd35Richard Smith if (S.getLangOpts().CPlusPlus11 && IsNonStatic2 && !IsNonStatic1) 38396fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, Method2->getThisType(S.Context), 38406fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis false, 38418d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor TemplateParams->getDepth(), UsedParameters); 38428d706ecf488c4f548c4f8cf0aa08ea82a4d6a5baDouglas Gregor for (unsigned I = Skip2; I < NumParams; ++I) 38436fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, Proto2->getArgType(I), false, 3844ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 3845e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor UsedParameters); 38468a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 38478a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 3848dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38498a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Conversion: 38506fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, Proto2->getResultType(), false, 3851ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 3852e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor UsedParameters); 38538a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 3854dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38558a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor case TPOC_Other: 38566fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, FD2->getType(), false, 3857ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor TemplateParams->getDepth(), 3858ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor UsedParameters); 38598a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor break; 38608a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 3861dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38628a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor for (; ArgIdx != NumArgs; ++ArgIdx) 38638a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // If this argument had no value deduced but was used in one of the types 38648a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // used for partial ordering, then deduction fails. 38658a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx]) 38668a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return false; 3867dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38688a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return true; 38698a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor} 3870dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38719da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor/// \brief Determine whether this a function template whose parameter-type-list 38729da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor/// ends with a function parameter pack. 38739da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregorstatic bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) { 38749da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor FunctionDecl *Function = FunTmpl->getTemplatedDecl(); 38759da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor unsigned NumParams = Function->getNumParams(); 38769da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (NumParams == 0) 38779da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return false; 3878dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38799da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor ParmVarDecl *Last = Function->getParamDecl(NumParams - 1); 38809da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (!Last->isParameterPack()) 38819da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return false; 3882dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38839da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // Make sure that no previous parameter is a parameter pack. 38849da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor while (--NumParams > 0) { 38859da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (Function->getParamDecl(NumParams - 1)->isParameterPack()) 38869da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return false; 38879da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor } 3888dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 38899da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return true; 38909da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor} 3891dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3892bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \brief Returns the more specialized function template according 389365ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// to the rules of function template partial ordering (C++ [temp.func.order]). 389465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 389565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \param FT1 the first function template 389665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 389765ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// \param FT2 the second function template 389865ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// 38998a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// \param TPOC the context in which we are performing partial ordering of 39008a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor/// function templates. 39011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// 39025c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param NumCallArguments The number of arguments in a call, used only 39035c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// when \c TPOC is \c TPOC_Call. 39045c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 3905bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \returns the more specialized function template. If neither 390665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor/// template is more specialized, returns NULL. 390765ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorFunctionTemplateDecl * 390865ec1fda479688d143fe2403242cd9c730c800a1Douglas GregorSema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, 390965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor FunctionTemplateDecl *FT2, 39105769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc, 39115c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor TemplatePartialOrderingContext TPOC, 39125c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned NumCallArguments) { 39135f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<RefParamPartialOrderingComparison, 4> RefParamComparisons; 3914dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC, 39155c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor NumCallArguments, 0); 3916dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC, 39175c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor NumCallArguments, 3918b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor &RefParamComparisons); 3919dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 39208a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (Better1 != Better2) // We have a clear winner 39218a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return Better1? FT1 : FT2; 3922dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 39238a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor if (!Better1 && !Better2) // Neither is better than the other 392465ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return 0; 39258a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor 39268a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p10: 3927dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If for each type being considered a given template is at least as 39288a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized for all types and more specialized for some set of types and 3929dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the other template is not more specialized for any types or is not at 39308a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // least as specialized for any types, then the given template is more 39318a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized than the other template. Otherwise, neither template is more 39328a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // specialized than the other. 39338a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better1 = false; 39348a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor Better2 = false; 3935b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor for (unsigned I = 0, N = RefParamComparisons.size(); I != N; ++I) { 39368a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // C++0x [temp.deduct.partial]p9: 39378a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor // If, for a given type, deduction succeeds in both directions (i.e., the 3938b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // types are identical after the transformations above) and both P and A 3939b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // were reference types (before being replaced with the type referred to 3940b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // above): 3941b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor 3942dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // -- if the type from the argument template was an lvalue reference 3943b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // and the type from the parameter template was not, the argument 3944b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // type is considered to be more specialized than the other; 3945b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // otherwise, 3946b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (!RefParamComparisons[I].ArgIsRvalueRef && 3947b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons[I].ParamIsRvalueRef) { 3948b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Better2 = true; 3949b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (Better1) 3950b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor return 0; 3951b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor continue; 3952b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor } else if (!RefParamComparisons[I].ParamIsRvalueRef && 3953b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor RefParamComparisons[I].ArgIsRvalueRef) { 3954b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Better1 = true; 3955b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (Better2) 3956b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor return 0; 3957b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor continue; 3958b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor } 3959dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3960b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // -- if the type from the argument template is more cv-qualified than 3961b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // the type from the parameter template (as described above), the 3962b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // argument type is considered to be more specialized than the 3963b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // other; otherwise, 3964b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor switch (RefParamComparisons[I].Qualifiers) { 3965b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor case NeitherMoreQualified: 3966b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor break; 3967dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3968b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor case ParamMoreQualified: 3969b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Better1 = true; 3970b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (Better2) 3971b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor return 0; 3972b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor continue; 3973dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3974b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor case ArgMoreQualified: 3975b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor Better2 = true; 3976b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor if (Better1) 3977b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor return 0; 3978b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor continue; 39798a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 3980dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 3981b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor // -- neither type is more specialized than the other. 39828a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor } 3983dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 39848a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor assert(!(Better1 && Better2) && "Should have broken out in the loop above"); 398565ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor if (Better1) 398665ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor return FT1; 39878a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor else if (Better2) 39888a51491d936d8c50480f3c3ca6647be12a7ad51fDouglas Gregor return FT2; 3989dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 39909da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // FIXME: This mimics what GCC implements, but doesn't match up with the 39919da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // proposed resolution for core issue 692. This area needs to be sorted out, 39929da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor // but for now we attempt to maintain compatibility. 39939da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor bool Variadic1 = isVariadicFunctionTemplate(FT1); 39949da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor bool Variadic2 = isVariadicFunctionTemplate(FT2); 39959da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor if (Variadic1 != Variadic2) 39969da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return Variadic1? FT2 : FT1; 3997dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 39989da95e6eefc4b0ca25e18bdab1b703f5c185deabDouglas Gregor return 0; 399965ec1fda479688d143fe2403242cd9c730c800a1Douglas Gregor} 400083314aa1cf61ed2458a8a20c83b2d4708192d5dcDouglas Gregor 4001d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \brief Determine if the two templates are equivalent. 4002d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregorstatic bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) { 4003d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (T1 == T2) 4004d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return true; 4005dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4006d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (!T1 || !T2) 4007d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return false; 4008dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4009d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor return T1->getCanonicalDecl() == T2->getCanonicalDecl(); 4010d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor} 4011d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 4012d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \brief Retrieve the most specialized of the given function template 4013d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// specializations. 4014d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4015c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// \param SpecBegin the start iterator of the function template 4016c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// specializations that we will be comparing. 4017d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4018c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// \param SpecEnd the end iterator of the function template 4019c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// specializations, paired with \p SpecBegin. 4020d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4021d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param TPOC the partial ordering context to use to compare the function 4022d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// template specializations. 4023d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 40245c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// \param NumCallArguments The number of arguments in a call, used only 40255c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// when \c TPOC is \c TPOC_Call. 40265c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor/// 4027dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \param Loc the location where the ambiguity or no-specializations 4028d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// diagnostic should occur. 4029d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4030d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param NoneDiag partial diagnostic used to diagnose cases where there are 4031d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// no matching candidates. 4032d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4033d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one 4034d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// occurs. 4035d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4036d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// \param CandidateDiag partial diagnostic used for each function template 4037d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// specialization that is a candidate in the ambiguous ordering. One parameter 4038d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// in this diagnostic should be unbound, which will correspond to the string 4039d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// describing the template arguments for the function template specialization. 4040d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4041dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \returns the most specialized function template specialization, if 4042c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall/// found. Otherwise, returns SpecEnd. 4043d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// 4044dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \todo FIXME: Consider passing in the "also-ran" candidates that failed 4045d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor/// template argument deduction. 4046c373d48502ca7683ab55385f5bd624d778eb288dJohn McCallUnresolvedSetIterator 4047c373d48502ca7683ab55385f5bd624d778eb288dJohn McCallSema::getMostSpecialized(UnresolvedSetIterator SpecBegin, 40485c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor UnresolvedSetIterator SpecEnd, 4049c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall TemplatePartialOrderingContext TPOC, 40505c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor unsigned NumCallArguments, 4051c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall SourceLocation Loc, 4052c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall const PartialDiagnostic &NoneDiag, 4053c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall const PartialDiagnostic &AmbigDiag, 40541be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor const PartialDiagnostic &CandidateDiag, 40556efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu bool Complain, 40566efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu QualType TargetType) { 4057c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall if (SpecBegin == SpecEnd) { 40581be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor if (Complain) 40591be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor Diag(Loc, NoneDiag); 4060c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecEnd; 4061d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 4062dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4063dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (SpecBegin + 1 == SpecEnd) 4064c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecBegin; 4065dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4066d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Find the function template that is better than all of the templates it 4067d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // has been compared to. 4068c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall UnresolvedSetIterator Best = SpecBegin; 4069dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi FunctionTemplateDecl *BestTemplate 4070c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*Best)->getPrimaryTemplate(); 4071d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor assert(BestTemplate && "Not a function template specialization?"); 4072c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) { 4073c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall FunctionTemplateDecl *Challenger 4074c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*I)->getPrimaryTemplate(); 4075d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor assert(Challenger && "Not a function template specialization?"); 4076c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, 40775c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Loc, TPOC, NumCallArguments), 4078d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Challenger)) { 4079d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Best = I; 4080d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor BestTemplate = Challenger; 4081d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 4082d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 4083dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4084d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Make sure that the "best" function template is more specialized than all 4085d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // of the others. 4086d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor bool Ambiguous = false; 4087c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { 4088c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall FunctionTemplateDecl *Challenger 4089c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall = cast<FunctionDecl>(*I)->getPrimaryTemplate(); 4090d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (I != Best && 4091dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi !isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger, 40925c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor Loc, TPOC, NumCallArguments), 4093d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor BestTemplate)) { 4094d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor Ambiguous = true; 4095d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor break; 4096d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 4097d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 4098dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4099d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor if (!Ambiguous) { 4100d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // We found an answer. Return it. 4101c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return Best; 4102d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor } 4103dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4104d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // Diagnose the ambiguity. 41051be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor if (Complain) 41061be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor Diag(Loc, AmbigDiag); 4107dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 41081be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor if (Complain) 4109d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor // FIXME: Can we order the candidates in some sane way? 41106efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) { 41116efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu PartialDiagnostic PD = CandidateDiag; 41126efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu PD << getTemplateArgumentBindingsText( 41131be8eec3ddd2a23c19b453c2639226174eb5d4a8Douglas Gregor cast<FunctionDecl>(*I)->getPrimaryTemplate()->getTemplateParameters(), 4114c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall *cast<FunctionDecl>(*I)->getTemplateSpecializationArgs()); 41156efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu if (!TargetType.isNull()) 41166efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu HandleFunctionTypeMismatch(PD, cast<FunctionDecl>(*I)->getType(), 41176efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu TargetType); 41186efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu Diag((*I)->getLocation(), PD); 41196efd4c55a1a481d92966a91141c03e8145234cf6Richard Trieu } 4120dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4121c373d48502ca7683ab55385f5bd624d778eb288dJohn McCall return SpecEnd; 4122d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor} 4123d5a423b279e787e9fdd8309fe52cb515388c54eaDouglas Gregor 4124bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \brief Returns the more specialized class template partial specialization 4125bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// according to the rules of partial ordering of class template partial 4126bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// specializations (C++ [temp.class.order]). 4127bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 4128bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \param PS1 the first class template partial specialization 4129bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 4130bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \param PS2 the second class template partial specialization 4131bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// 4132bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// \returns the more specialized class template partial specialization. If 4133bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor/// neither partial specialization is more specialized, returns NULL. 4134bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas GregorClassTemplatePartialSpecializationDecl * 4135bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas GregorSema::getMoreSpecializedPartialSpecialization( 4136bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor ClassTemplatePartialSpecializationDecl *PS1, 41375769d6195087229770d7ac90449443e026c47103John McCall ClassTemplatePartialSpecializationDecl *PS2, 41385769d6195087229770d7ac90449443e026c47103John McCall SourceLocation Loc) { 4139bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // C++ [temp.class.order]p1: 4140bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // For two class template partial specializations, the first is at least as 4141dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // specialized as the second if, given the following rewrite to two 4142dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // function templates, the first function template is at least as 4143dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // specialized as the second according to the ordering rules for function 4144bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // templates (14.6.6.2): 4145bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // - the first function template has the same template parameters as the 4146dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // first partial specialization and has a single function parameter 4147dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // whose type is a class template specialization with the template 4148bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // arguments of the first partial specialization, and 4149bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // - the second function template has the same template parameters as the 4150dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // second partial specialization and has a single function parameter 4151dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // whose type is a class template specialization with the template 4152bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // arguments of the second partial specialization. 4153bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // 415431dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // Rather than synthesize function templates, we merely perform the 415531dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // equivalent partial ordering by performing deduction directly on 415631dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // the template arguments of the class template partial 415731dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // specializations. This computation is slightly simpler than the 415831dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // general problem of function template partial ordering, because 415931dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // class template partial specializations are more constrained. We 416031dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // know that every template parameter is deducible from the class 416131dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // template partial specialization's template arguments, for 416231dce8f606c5ff4a51db67caa24ac3312ccea3f3Douglas Gregor // example. 41635f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeducedTemplateArgument, 4> Deduced; 416493e4599196654907dad3bd476013ad05d36ce604Craig Topper TemplateDeductionInfo Info(Loc); 416531f17ecbef57b5679c017c375db330546b7b5145John McCall 416631f17ecbef57b5679c017c375db330546b7b5145John McCall QualType PT1 = PS1->getInjectedSpecializationType(); 416731f17ecbef57b5679c017c375db330546b7b5145John McCall QualType PT2 = PS2->getInjectedSpecializationType(); 4168dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4169bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // Determine whether PS1 is at least as specialized as PS2 4170bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Deduced.resize(PS2->getTemplateParameters()->size()); 4171bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl bool Better1 = !DeduceTemplateArgumentsByTypeMatch(*this, 4172bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl PS2->getTemplateParameters(), 41735c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor PT2, PT1, Info, Deduced, TDF_None, 4174dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi /*PartialOrdering=*/true, 4175b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /*RefParamComparisons=*/0); 41762c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis if (Better1) { 41777e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end()); 41782c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2, 41797e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith DeducedArgs, Info); 4180dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Better1 = !::FinishTemplateArgumentDeduction(*this, PS2, 4181dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi PS1->getTemplateArgs(), 4182516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Deduced, Info); 41832c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis } 4184dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4185bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor // Determine whether PS2 is at least as specialized as PS1 4186db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Deduced.clear(); 4187bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor Deduced.resize(PS1->getTemplateParameters()->size()); 4188bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl bool Better2 = !DeduceTemplateArgumentsByTypeMatch(*this, 4189bb95e51a3668c50133b989467cd44ba4d8a42e8aSebastian Redl PS1->getTemplateParameters(), 41905c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor PT1, PT2, Info, Deduced, TDF_None, 41915c7bf42ef16dc767615bed10f3b7b3c1265314e1Douglas Gregor /*PartialOrdering=*/true, 4192b939a1987318f802fd25f89e15ae7d2423161cacDouglas Gregor /*RefParamComparisons=*/0); 41932c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis if (Better2) { 41947e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end()); 41952c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1, 41967e54fb5fcc7d7b8e843501652cf7c19cea6c4c57Richard Smith DeducedArgs, Info); 4197dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi Better2 = !::FinishTemplateArgumentDeduction(*this, PS1, 4198dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi PS2->getTemplateArgs(), 4199516e6e09821a61e8975c787e189949723249e7c5Douglas Gregor Deduced, Info); 42002c4792c731690dbbcbe69dd0625977adffc2961aArgyrios Kyrtzidis } 4201dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4202bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor if (Better1 == Better2) 4203bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor return 0; 4204dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4205bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor return Better1? PS1 : PS2; 4206bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor} 4207bf4ea56cdc376cef5a12abf6bf18dc34805c2226Douglas Gregor 42081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 42096fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4210e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const TemplateArgument &TemplateArg, 4211e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4212ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4213013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used); 4214031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4215e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 4216031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// expression. 42171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 42186fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4219e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const Expr *E, 4220e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4221ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4222013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4223be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor // We can deduce from a pack expansion. 4224be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor if (const PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(E)) 4225be230c36e32142cbdcdbe9c97511d097beeecbabDouglas Gregor E = Expansion->getPattern(); 4226dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 42276098381c29c2693832aa81ef046cf21a49729436Richard Smith // Skip through any implicit casts we added while type-checking, and any 42286098381c29c2693832aa81ef046cf21a49729436Richard Smith // substitutions performed by template alias expansion. 42296098381c29c2693832aa81ef046cf21a49729436Richard Smith while (1) { 42306098381c29c2693832aa81ef046cf21a49729436Richard Smith if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 42316098381c29c2693832aa81ef046cf21a49729436Richard Smith E = ICE->getSubExpr(); 42326098381c29c2693832aa81ef046cf21a49729436Richard Smith else if (const SubstNonTypeTemplateParmExpr *Subst = 42336098381c29c2693832aa81ef046cf21a49729436Richard Smith dyn_cast<SubstNonTypeTemplateParmExpr>(E)) 42346098381c29c2693832aa81ef046cf21a49729436Richard Smith E = Subst->getReplacement(); 42356098381c29c2693832aa81ef046cf21a49729436Richard Smith else 42366098381c29c2693832aa81ef046cf21a49729436Richard Smith break; 42376098381c29c2693832aa81ef046cf21a49729436Richard Smith } 4238dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4239dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // FIXME: if !OnlyDeduced, we have to walk the whole subexpression to 4240e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // find other occurrences of template parameters. 4241f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 4242c781f9cd854f3d5d1c826f4a13382c6abca4cff7Douglas Gregor if (!DRE) 4243031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 4244031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 42451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const NonTypeTemplateParmDecl *NTTP 4246031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()); 4247031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (!NTTP) 4248031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 4249031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4250ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (NTTP->getDepth() == Depth) 4251ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[NTTP->getIndex()] = true; 4252031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 4253031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4254e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 4255e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// nested name specifier. 4256e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregorstatic void 42576fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4258e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor NestedNameSpecifier *NNS, 4259e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4260ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4261013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4262e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!NNS) 4263e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 4264dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 42656fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, NNS->getPrefix(), OnlyDeduced, Depth, 4266ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used); 42676fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, QualType(NNS->getAsType(), 0), 4268ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4269e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor} 4270dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4271e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 4272e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// template name. 4273e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregorstatic void 42746fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4275e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor TemplateName Name, 4276e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4277ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4278013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4279e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 4280e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (TemplateTemplateParmDecl *TTP 4281ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor = dyn_cast<TemplateTemplateParmDecl>(Template)) { 4282ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (TTP->getDepth() == Depth) 4283ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[TTP->getIndex()] = true; 4284ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor } 4285e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 4286e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor } 4287dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4288788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) 42896fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, QTN->getQualifier(), OnlyDeduced, 4290788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor Depth, Used); 4291e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) 42926fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, DTN->getQualifier(), OnlyDeduced, 4293ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4294e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor} 4295e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor 4296e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by the given 4297031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// type. 42981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 42996fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, QualType T, 4300e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4301ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4302013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4303e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (T.isNull()) 4304e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor return; 4305dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4306031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor // Non-dependent types have nothing deducible 4307031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor if (!T->isDependentType()) 4308031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor return; 4309031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 43106fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis T = Ctx.getCanonicalType(T); 4311031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor switch (T->getTypeClass()) { 4312031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Pointer: 43136fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4314e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<PointerType>(T)->getPointeeType(), 4315e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 4316ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 4317e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 4318031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4319031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4320031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::BlockPointer: 43216fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4322e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<BlockPointerType>(T)->getPointeeType(), 4323e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 4324ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 4325e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 4326031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4327031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4328031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::LValueReference: 4329031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::RValueReference: 43306fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4331e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ReferenceType>(T)->getPointeeType(), 4332e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor OnlyDeduced, 4333ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, 4334e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor Used); 4335031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4336031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4337031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::MemberPointer: { 4338031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr()); 43396fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, MemPtr->getPointeeType(), OnlyDeduced, 4340ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 43416fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, QualType(MemPtr->getClass(), 0), 4342ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4343031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4344031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 4345031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4346031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::DependentSizedArray: 43476fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4348e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<DependentSizedArrayType>(T)->getSizeExpr(), 4349ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4350031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor // Fall through to check the element type 4351031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4352031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ConstantArray: 4353031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::IncompleteArray: 43546fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4355e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ArrayType>(T)->getElementType(), 4356ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4357031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4358031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4359031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Vector: 4360031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ExtVector: 43616fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4362e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<VectorType>(T)->getElementType(), 4363ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4364031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4365031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 43669cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor case Type::DependentSizedExtVector: { 43679cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor const DependentSizedExtVectorType *VecType 4368f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor = cast<DependentSizedExtVectorType>(T); 43696fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced, 4370ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 43716fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced, 4372ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 43739cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor break; 43749cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor } 43759cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 4376031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::FunctionProto: { 4377f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor const FunctionProtoType *Proto = cast<FunctionProtoType>(T); 43786fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Proto->getResultType(), OnlyDeduced, 4379ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4380031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I) 43816fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Proto->getArgType(I), OnlyDeduced, 4382ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4383031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4384031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 4385031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4386ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor case Type::TemplateTypeParm: { 4387ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor const TemplateTypeParmType *TTP = cast<TemplateTypeParmType>(T); 4388ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor if (TTP->getDepth() == Depth) 4389ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used[TTP->getIndex()] = true; 4390031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4391ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor } 4392031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 43930bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor case Type::SubstTemplateTypeParmPack: { 43940bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor const SubstTemplateTypeParmPackType *Subst 43950bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor = cast<SubstTemplateTypeParmPackType>(T); 43966fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 43970bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor QualType(Subst->getReplacedParameter(), 0), 43980bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor OnlyDeduced, Depth, Used); 43996fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Subst->getArgumentPack(), 44000bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor OnlyDeduced, Depth, Used); 44010bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor break; 44020bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor } 44030bc15d92bf98cd01e7904d7fca9895dacc237618Douglas Gregor 440431f17ecbef57b5679c017c375db330546b7b5145John McCall case Type::InjectedClassName: 440531f17ecbef57b5679c017c375db330546b7b5145John McCall T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType(); 440631f17ecbef57b5679c017c375db330546b7b5145John McCall // fall through 440731f17ecbef57b5679c017c375db330546b7b5145John McCall 4408031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::TemplateSpecialization: { 44091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const TemplateSpecializationType *Spec 4410f6ddb737cb882ffbf0b75a9abd50b930cc2b9068Douglas Gregor = cast<TemplateSpecializationType>(T); 44116fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Spec->getTemplateName(), OnlyDeduced, 4412ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4413dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 44147b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 4415dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the template argument list of P contains a pack expansion that is not 4416dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the last template argument, the entire template argument list is a 44177b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 4418dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (OnlyDeduced && 44197b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) 44207b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor break; 44217b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 4422e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) 44236fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth, 4424ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Used); 4425e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor break; 4426e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor } 44271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4428e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor case Type::Complex: 4429e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!OnlyDeduced) 44306fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4431e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor cast<ComplexType>(T)->getElementType(), 4432ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4433e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor break; 4434031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4435b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: 4436b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (!OnlyDeduced) 44376fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4438b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman cast<AtomicType>(T)->getValueType(), 4439b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman OnlyDeduced, Depth, Used); 4440b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman break; 4441b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 44424714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor case Type::DependentName: 4443e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor if (!OnlyDeduced) 44446fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 44454714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor cast<DependentNameType>(T)->getQualifier(), 4446ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor OnlyDeduced, Depth, Used); 4447031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4448031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 444933500955d731c73717af52088b7fc0e7a85681e7John McCall case Type::DependentTemplateSpecialization: { 445033500955d731c73717af52088b7fc0e7a85681e7John McCall const DependentTemplateSpecializationType *Spec 445133500955d731c73717af52088b7fc0e7a85681e7John McCall = cast<DependentTemplateSpecializationType>(T); 445233500955d731c73717af52088b7fc0e7a85681e7John McCall if (!OnlyDeduced) 44536fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Spec->getQualifier(), 445433500955d731c73717af52088b7fc0e7a85681e7John McCall OnlyDeduced, Depth, Used); 4455dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 44567b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 4457dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the template argument list of P contains a pack expansion that is not 4458dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the last template argument, the entire template argument list is a 44597b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 4460dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (OnlyDeduced && 44617b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs())) 44627b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor break; 44637b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 446433500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) 44656fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth, 446633500955d731c73717af52088b7fc0e7a85681e7John McCall Used); 446733500955d731c73717af52088b7fc0e7a85681e7John McCall break; 446833500955d731c73717af52088b7fc0e7a85681e7John McCall } 446933500955d731c73717af52088b7fc0e7a85681e7John McCall 4470ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::TypeOf: 4471ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 44726fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4473ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<TypeOfType>(T)->getUnderlyingType(), 4474ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 4475ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 4476ad5e73887052193afda72db8efcb812bd083a4a8John McCall 4477ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::TypeOfExpr: 4478ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 44796fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4480ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<TypeOfExprType>(T)->getUnderlyingExpr(), 4481ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 4482ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 4483ad5e73887052193afda72db8efcb812bd083a4a8John McCall 4484ad5e73887052193afda72db8efcb812bd083a4a8John McCall case Type::Decltype: 4485ad5e73887052193afda72db8efcb812bd083a4a8John McCall if (!OnlyDeduced) 44866fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4487ad5e73887052193afda72db8efcb812bd083a4a8John McCall cast<DecltypeType>(T)->getUnderlyingExpr(), 4488ad5e73887052193afda72db8efcb812bd083a4a8John McCall OnlyDeduced, Depth, Used); 4489ad5e73887052193afda72db8efcb812bd083a4a8John McCall break; 4490ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt 4491ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt case Type::UnaryTransform: 4492ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt if (!OnlyDeduced) 44936fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4494ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt cast<UnaryTransformType>(T)->getUnderlyingType(), 4495ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt OnlyDeduced, Depth, Used); 4496ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt break; 4497ad5e73887052193afda72db8efcb812bd083a4a8John McCall 44987536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor case Type::PackExpansion: 44996fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 45007536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor cast<PackExpansionType>(T)->getPattern(), 45017536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor OnlyDeduced, Depth, Used); 45027536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor break; 45037536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 450434b41d939a1328f484511c6002ba2456db879a29Richard Smith case Type::Auto: 45056fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 450634b41d939a1328f484511c6002ba2456db879a29Richard Smith cast<AutoType>(T)->getDeducedType(), 450734b41d939a1328f484511c6002ba2456db879a29Richard Smith OnlyDeduced, Depth, Used); 450834b41d939a1328f484511c6002ba2456db879a29Richard Smith 4509e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor // None of these types have any template parameters in them. 4510031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Builtin: 4511031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::VariableArray: 4512031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::FunctionNoProto: 4513031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Record: 4514031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::Enum: 4515031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case Type::ObjCInterface: 4516c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: 4517d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff case Type::ObjCObjectPointer: 4518ed97649e9574b9d854fa4d6109c9333ae0993554John McCall case Type::UnresolvedUsing: 4519031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define TYPE(Class, Base) 4520031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 4521031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define DEPENDENT_TYPE(Class, Base) 4522031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 4523031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor#include "clang/AST/TypeNodes.def" 4524031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4525031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 4526031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 4527031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4528e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor/// \brief Mark the template parameters that are used by this 4529031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// template argument. 45301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void 45316fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisMarkUsedTemplateParameters(ASTContext &Ctx, 4532e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor const TemplateArgument &TemplateArg, 4533e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor bool OnlyDeduced, 4534ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor unsigned Depth, 4535013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 4536031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor switch (TemplateArg.getKind()) { 4537031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Null: 4538031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Integral: 4539d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor case TemplateArgument::Declaration: 4540031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 45411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4542d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman case TemplateArgument::NullPtr: 4543d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman MarkUsedTemplateParameters(Ctx, TemplateArg.getNullPtrType(), OnlyDeduced, 4544d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman Depth, Used); 4545d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman break; 4546d7a6b1640e565487d163023a6a2e83f55476ae96Eli Friedman 4547031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Type: 45486fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, TemplateArg.getAsType(), OnlyDeduced, 4549ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4550031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4551031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4552788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 4553a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 45546fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, 4555dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateArg.getAsTemplateOrTemplatePattern(), 4556788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor OnlyDeduced, Depth, Used); 4557031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4558031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 4559031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor case TemplateArgument::Expression: 45606fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, TemplateArg.getAsExpr(), OnlyDeduced, 4561ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4562031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor break; 4563dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 4564d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson case TemplateArgument::Pack: 4565e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(), 4566e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor PEnd = TemplateArg.pack_end(); 4567e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas Gregor P != PEnd; ++P) 45686fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis MarkUsedTemplateParameters(Ctx, *P, OnlyDeduced, Depth, Used); 4569d01b1da213aeb71fd40ff7fb78a194613cc1ece7Anders Carlsson break; 4570031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor } 4571031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 4572031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor 457316ae9de07730832945204877d752db7f1c070962James Dennett/// \brief Mark which template parameters can be deduced from a given 4574031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// template argument list. 4575031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// 4576031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// \param TemplateArgs the template argument list from which template 4577031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// parameters will be deduced. 4578031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// 457916ae9de07730832945204877d752db7f1c070962James Dennett/// \param Used a bit vector whose elements will be set to \c true 4580031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// to indicate when the corresponding template parameter will be 4581031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor/// deduced. 45821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid 4583e73bb60de3c7c60453a86e097fc428d1cd367a42Douglas GregorSema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs, 4584ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor bool OnlyDeduced, unsigned Depth, 4585013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Used) { 45867b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // C++0x [temp.deduct.type]p9: 4587dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // If the template argument list of P contains a pack expansion that is not 4588dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi // the last template argument, the entire template argument list is a 45897b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor // non-deduced context. 4590dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi if (OnlyDeduced && 45917b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size())) 45927b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor return; 45937b976ece336d209977b25b5c28ee09c2d2146e6aDouglas Gregor 4594031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) 45956fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(Context, TemplateArgs[I], OnlyDeduced, 4596ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor Depth, Used); 4597031a5880e19d06624551aed9d74594356f4f9db1Douglas Gregor} 459863f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor 459963f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor/// \brief Marks all of the template parameters that will be deduced by a 460063f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor/// call to the given function template. 4601dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumivoid 46026fc9e1d98205649e4d0f741d194d288a45995a62Argyrios KyrtzidisSema::MarkDeducedTemplateParameters(ASTContext &Ctx, 46036fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis FunctionTemplateDecl *FunctionTemplate, 4604013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector &Deduced) { 4605dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi TemplateParameterList *TemplateParams 460663f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor = FunctionTemplate->getTemplateParameters(); 460763f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor Deduced.clear(); 460863f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor Deduced.resize(TemplateParams->size()); 4609dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi 461063f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); 461163f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) 46126fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(Ctx, Function->getParamDecl(I)->getType(), 4613ed9c0f90b7e0811c209b95e39fe07c211c531285Douglas Gregor true, TemplateParams->getDepth(), Deduced); 461463f07c55d58951574afe9bbb9f7cb3f92eecdd9bDouglas Gregor} 4615dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 4616dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregorbool hasDeducibleTemplateParameters(Sema &S, 4617dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor FunctionTemplateDecl *FunctionTemplate, 4618dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor QualType T) { 4619dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor if (!T->isDependentType()) 4620dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor return false; 4621dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 4622dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor TemplateParameterList *TemplateParams 4623dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor = FunctionTemplate->getTemplateParameters(); 4624013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer llvm::SmallBitVector Deduced(TemplateParams->size()); 46256fc9e1d98205649e4d0f741d194d288a45995a62Argyrios Kyrtzidis ::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(), 4626dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor Deduced); 4627dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor 4628013b3668b67c8cb3ad2ee516c5607a3eba11829fBenjamin Kramer return Deduced.any(); 4629dbfb371e297794e827ad2e5b33b45fafbfc46b29Douglas Gregor} 4630